Fix/substrate sign tx

packages/kos/src/chains/substrate/mod.rs

@@ -1,8 +1,9 @@
 mod models;
 
+use crate::chains::substrate::models::ExtrinsicPayload;
 use crate::chains::util::private_key_from_vec;
 use crate::chains::{Chain, ChainError, Transaction, TxInfo};
-use crate::crypto::hash::blake2b_64_digest;
+use crate::crypto::hash::{blake2b_64_digest, blake2b_digest};
 use crate::crypto::sr25519::Sr25519Trait;
 use crate::crypto::{b58, bip32, sr25519};
 use alloc::format;
@@ -108,8 +109,27 @@ impl Chain for Substrate {
         private_key: Vec<u8>,
         mut tx: Transaction,
     ) -> Result<Transaction, ChainError> {
-        let sig = self.sign_raw(private_key, tx.raw_data.clone())?;
-        tx.signature = [[1u8].to_vec(), sig].concat();
+        let extrinsic = ExtrinsicPayload::from_raw(tx.raw_data.clone())?;
+
+        let signature = {
+            let full_unsigned_payload_scale_bytes = tx.raw_data.clone();
+
+            // If payload is longer than 256 bytes, we hash it and sign the hash instead:
+            if full_unsigned_payload_scale_bytes.len() > 256 {
+                self.sign_raw(
+                    private_key.clone(),
+                    blake2b_digest(&full_unsigned_payload_scale_bytes).to_vec(),
+                )?
+            } else {
+                self.sign_raw(private_key.clone(), full_unsigned_payload_scale_bytes)?
+            }
+        };
+
+        let public_key: [u8; 32] = self.get_pbk(private_key)?.try_into().unwrap();
+
+        tx.raw_data = extrinsic.encode_with_signature(&public_key, &signature);
+
+        tx.signature = [[1u8].to_vec(), signature].concat();
         Ok(tx)
     }
 
@@ -142,8 +162,8 @@ impl Chain for Substrate {
 
 #[cfg(test)]
 mod test {
-
-    use crate::chains::Chain;
+    use crate::chains::{Chain, Transaction};
+    use crate::crypto::base64::simple_base64_decode;
     use alloc::string::{String, ToString};
 
     #[test]
@@ -191,10 +211,24 @@ mod test {
         let dot = super::Substrate::new(21, 0, "Polkadot", "DOT");
 
         let mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about".to_string();
-        let path = String::from("");
+        let path = dot.get_path(0, false);
 
         let seed = dot.mnemonic_to_seed(mnemonic, String::from("")).unwrap();
-        let _pvk = dot.derive(seed, path).unwrap();
+        let pvk = dot.derive(seed, path).unwrap();
+
+        let raw_data = simple_base64_decode("BQMADCRBuM7b/Hou3AlouaU1gZlp0+ngmYaAurtYJyh/wHCRAXUDYAAA/E0PABoAAACRsXG7FY4tOEj6I6nxwlGC+44gMTssHrSSGdp6cM6Qw36KXLq5dgOoEvZRpzirvfO3HDN6fM3bEwtF1XTUSlrGAA==").unwrap();
+
+        let tx = Transaction {
+            raw_data,
+            signature: Vec::new(),
+            tx_hash: Vec::new(),
+            options: None,
+        };
+
+        let signed_tx = dot.sign_tx(pvk, tx).unwrap();
+
+        assert_eq!(signed_tx.signature.len(), 65);
+        assert_eq!(signed_tx.raw_data.len(), 143);
     }
 
     #[test]

packages/kos/src/chains/substrate/models.rs

@@ -1,8 +1,8 @@
+use crate::chains::ChainError;
+use crate::crypto::bignum::U256;
 use alloc::vec;
 use alloc::vec::Vec;
-use parity_scale_codec::{Decode, Input};
-
-use crate::crypto::bignum::U256;
+use parity_scale_codec::{Compact, Decode, Encode, Input};
 
 #[derive(Decode)]
 pub struct Call {
@@ -136,3 +136,139 @@ impl Decode for UIntCompact {
         }
     }
 }
+
+#[derive(Debug)]
+pub struct ExtrinsicPayload {
+    pub call_index: [u8; 2],
+    pub destination: [u8; 32],
+    pub value: [u8; 2],
+    pub era: [u8; 2],
+    pub nonce: [u8; 1],
+    pub tip: u8,
+    pub mode: u8,
+    pub spec_version: u32,
+    pub transaction_version: u32,
+    pub genesis_hash: [u8; 32],
+    pub block_hash: [u8; 32],
+    pub metadata_hash: u8,
+}
+
+impl ExtrinsicPayload {
+    pub fn from_raw(bytes: Vec<u8>) -> Result<Self, ChainError> {
+        let mut input = bytes.as_slice();
+
+        let mut call_index = [0u8; 2];
+        call_index.copy_from_slice(&input[0..2]);
+        input = &input[2..];
+
+        let mut destination = [0u8; 32];
+        destination.copy_from_slice(&input[1..33]);
+        input = &input[33..];
+
+        let mut value = [0u8; 2];
+        value.copy_from_slice(&input[0..2]);
+        input = &input[2..];
+
+        let mut era = [0u8; 2];
+        era.copy_from_slice(&input[0..2]);
+        input = &input[2..];
+
+        let mut nonce = [0u8; 1];
+        nonce.copy_from_slice(&input[0..1]);
+        input = &input[1..];
+
+        let tip = input[0];
+        input = &input[1..];
+
+        let mode = input[0];
+        input = &input[1..];
+
+        let spec_version = u32::from_le_bytes([input[0], input[1], input[2], input[3]]);
+        input = &input[4..];
+
+        let transaction_version = u32::from_le_bytes([input[0], input[1], input[2], input[3]]);
+        input = &input[4..];
+
+        let mut genesis_hash = [0u8; 32];
+        genesis_hash.copy_from_slice(&input[0..32]);
+        input = &input[32..];
+
+        let mut block_hash = [0u8; 32];
+
+        block_hash.copy_from_slice(&input[0..32]);
+        input = &input[32..];
+
+        let metadata_hash = if !input.is_empty() { input[0] } else { 0 };
+
+        Ok(ExtrinsicPayload {
+            call_index,
+            destination,
+            value,
+            era,
+            nonce,
+            tip,
+            mode,
+            spec_version,
+            transaction_version,
+            genesis_hash,
+            block_hash,
+            metadata_hash,
+        })
+    }
+
+    #[allow(dead_code)]
+    pub fn to_bytes(&self) -> Vec<u8> {
+        let mut encoded = Vec::new();
+        encoded.extend_from_slice(&self.call_index);
+        encoded.push(0x00);
+        encoded.extend_from_slice(&self.destination);
+        encoded.extend_from_slice(&self.value);
+        encoded.extend_from_slice(&self.era);
+        encoded.extend_from_slice(self.nonce.encode().as_slice());
+        encoded.extend_from_slice(self.tip.encode().as_slice());
+        encoded.push(self.mode);
+        encoded.extend_from_slice(&self.spec_version.encode());
+        encoded.extend_from_slice(&self.transaction_version.encode());
+        encoded.extend_from_slice(&self.genesis_hash);
+        encoded.extend_from_slice(&self.block_hash);
+
+        if self.metadata_hash != 0 {
+            encoded.push(self.metadata_hash);
+        }
+        encoded
+    }
+
+    pub fn encode_with_signature(&self, public_key: &[u8; 32], signature: &[u8]) -> Vec<u8> {
+        let mut encoded = Vec::new();
+
+        let signed_flag: u8 = 0b1000_0000;
+        let transaction_version = 4;
+        encoded.push(signed_flag | transaction_version);
+
+        encoded.push(0x00);
+        encoded.extend_from_slice(public_key);
+
+        encoded.push(0x01);
+
+        encoded.extend_from_slice(signature);
+
+        encoded.extend_from_slice(&self.era);
+        encoded.extend_from_slice(self.nonce.as_slice());
+        encoded.push(self.tip);
+        encoded.push(self.mode);
+
+        encoded.extend_from_slice(&self.call_index);
+
+        encoded.push(0x00);
+
+        encoded.extend_from_slice(&self.destination);
+        encoded.extend_from_slice(&self.value);
+
+        let length = Compact(encoded.len() as u32).encode();
+        let mut complete_encoded = Vec::with_capacity(length.len() + encoded.len());
+        complete_encoded.extend_from_slice(&length);
+        complete_encoded.extend_from_slice(&encoded);
+
+        complete_encoded
+    }
+}