fix: Complete transfer functionality with proper serialization

- Fixed CLType serialization: Option(U64) -> {Option: U64} for RPC
- Fixed body hash: RuntimeArgs now include CLType bytes per Casper spec
- Fixed header serialization: public key without length prefix, u64 for all integers
- Fixed SECP256K1 key format: 02 prefix + 33 bytes EC point = 68 hex chars
- Added CasperKeyConstants for clean key prefix handling
- Import Keys now correctly loads Casper Wallet PEM files
- Added -30s timestamp offset to avoid clock drift errors

Transfer transactions now work end-to-end with imported wallets!

Author: SamuelGuizani

Assets/CasperSDK/Runtime/Services/Deploy/DeployBuilder.cs

@@ -265,40 +265,40 @@ private string HashBlake2b256(byte[] data)
         }
 
         /// <summary>
-        /// Serializes a deploy header to bytes (simplified Casper serialization)
+        /// Serializes a deploy header to bytes according to Casper bytesrepr format
         /// </summary>
         private byte[] SerializeDeployHeader(DeployHeader header)
         {
             var parts = new List<byte>();
 
-            // Account (public key with length prefix)
+            // Account (public key: just the bytes, no length prefix)
+            // PublicKey format: [algo_tag(1 byte)][key_bytes(32 or 33 bytes)]
             var accountBytes = CryptoHelper.HexToBytes(header.Account);
-            parts.AddRange(BitConverter.GetBytes((uint)accountBytes.Length));
             parts.AddRange(accountBytes);
 
-            // Timestamp (as milliseconds since epoch)
+            // Timestamp (as milliseconds since epoch, u64 LE)
             var timestamp = DateTime.Parse(header.Timestamp).ToUniversalTime();
             var epochMs = (long)(timestamp - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds;
-            parts.AddRange(BitConverter.GetBytes(epochMs));
+            parts.AddRange(BitConverter.GetBytes((ulong)epochMs));
 
-            // TTL
-            parts.AddRange(BitConverter.GetBytes(header.TTL));
+            // TTL (u64 LE)
+            parts.AddRange(BitConverter.GetBytes((ulong)header.TTL));
 
-            // Gas price
-            parts.AddRange(BitConverter.GetBytes(header.GasPrice));
+            // Gas price (u64 LE) 
+            parts.AddRange(BitConverter.GetBytes((ulong)header.GasPrice));
 
-            // Body hash
+            // Body hash (32 bytes, no length prefix)
             var bodyHashBytes = CryptoHelper.HexToBytes(header.BodyHash);
             parts.AddRange(bodyHashBytes);
 
-            // Dependencies count and hashes
+            // Dependencies count (u32 LE) and hashes
             parts.AddRange(BitConverter.GetBytes((uint)header.Dependencies.Length));
             foreach (var dep in header.Dependencies)
             {
                 parts.AddRange(CryptoHelper.HexToBytes(dep));
             }
 
-            // Chain name (length-prefixed string)
+            // Chain name (length-prefixed string, u32 LE)
             var chainNameBytes = Encoding.UTF8.GetBytes(header.ChainName);
             parts.AddRange(BitConverter.GetBytes((uint)chainNameBytes.Length));
             parts.AddRange(chainNameBytes);
@@ -361,30 +361,122 @@ private byte[] SerializeExecutableDeployItem(ExecutableDeployItem item)
         }
 
         /// <summary>
-        /// Serializes runtime arguments
+        /// Serializes runtime arguments according to Casper bytesrepr format
+        /// Format: [count][arg1][arg2]...
+        /// Each arg: [name_len][name][value_bytes_len][value_bytes][cltype_bytes]
         /// </summary>
         private byte[] SerializeRuntimeArgs(RuntimeArg[] args)
         {
             var parts = new List<byte>();
             args = args ?? Array.Empty<RuntimeArg>();
 
-            // Args count
+            // Args count (u32 LE)
             parts.AddRange(BitConverter.GetBytes((uint)args.Length));
 
             foreach (var arg in args)
             {
-                // Name (length-prefixed)
+                // Name (length-prefixed string)
                 var nameBytes = Encoding.UTF8.GetBytes(arg.Name ?? "");
                 parts.AddRange(BitConverter.GetBytes((uint)nameBytes.Length));
                 parts.AddRange(nameBytes);
 
-                // Value bytes
+                // CLValue: [bytes_len][bytes][cltype_serialized]
                 var valueBytes = CryptoHelper.HexToBytes(arg.Value?.Bytes ?? "");
+                var clTypeBytes = SerializeCLType(arg.Value?.CLType ?? "Unit");
+                
+                // Value bytes length + bytes
                 parts.AddRange(BitConverter.GetBytes((uint)valueBytes.Length));
                 parts.AddRange(valueBytes);
+                
+                // CLType (no length prefix, directly appended)
+                parts.AddRange(clTypeBytes);
             }
 
             return parts.ToArray();
         }
+
+        /// <summary>
+        /// Serializes CLType to bytes according to Casper spec
+        /// </summary>
+        private byte[] SerializeCLType(string clType)
+        {
+            // Simple types have a single byte tag
+            switch (clType)
+            {
+                case "Bool": return new byte[] { 0 };
+                case "I32": return new byte[] { 1 };
+                case "I64": return new byte[] { 2 };
+                case "U8": return new byte[] { 3 };
+                case "U32": return new byte[] { 4 };
+                case "U64": return new byte[] { 5 };
+                case "U128": return new byte[] { 6 };
+                case "U256": return new byte[] { 7 };
+                case "U512": return new byte[] { 8 };
+                case "Unit": return new byte[] { 9 };
+                case "String": return new byte[] { 10 };
+                case "Key": return new byte[] { 11 };
+                case "URef": return new byte[] { 12 };
+                case "PublicKey": return new byte[] { 22 };
+            }
+
+            // Option type: tag 13 + inner type
+            if (clType == "Option")
+            {
+                return new byte[] { 13, 5 }; // Option(U64) for transfer id
+            }
+            if (clType.StartsWith("Option(") && clType.EndsWith(")"))
+            {
+                var inner = clType.Substring(7, clType.Length - 8);
+                var innerBytes = SerializeCLType(inner);
+                var result = new byte[1 + innerBytes.Length];
+                result[0] = 13; // Option tag
+                Buffer.BlockCopy(innerBytes, 0, result, 1, innerBytes.Length);
+                return result;
+            }
+
+            // List type: tag 14 + inner type
+            if (clType.StartsWith("List(") && clType.EndsWith(")"))
+            {
+                var inner = clType.Substring(5, clType.Length - 6);
+                var innerBytes = SerializeCLType(inner);
+                var result = new byte[1 + innerBytes.Length];
+                result[0] = 14; // List tag
+                Buffer.BlockCopy(innerBytes, 0, result, 1, innerBytes.Length);
+                return result;
+            }
+
+            // ByteArray - tag 15 + size (u32)
+            if (clType.StartsWith("ByteArray(") && clType.EndsWith(")"))
+            {
+                var sizeStr = clType.Substring(10, clType.Length - 11);
+                var size = uint.Parse(sizeStr);
+                var result = new byte[5];
+                result[0] = 15; // ByteArray tag
+                Buffer.BlockCopy(BitConverter.GetBytes(size), 0, result, 1, 4);
+                return result;
+            }
+
+            // Map type: tag 17 + key type + value type
+            if (clType.StartsWith("Map(") && clType.EndsWith(")"))
+            {
+                var inner = clType.Substring(4, clType.Length - 5);
+                var comma = inner.IndexOf(',');
+                if (comma > 0)
+                {
+                    var keyType = inner.Substring(0, comma).Trim();
+                    var valueType = inner.Substring(comma + 1).Trim();
+                    var keyBytes = SerializeCLType(keyType);
+                    var valueBytes = SerializeCLType(valueType);
+                    var result = new byte[1 + keyBytes.Length + valueBytes.Length];
+                    result[0] = 17; // Map tag
+                    Buffer.BlockCopy(keyBytes, 0, result, 1, keyBytes.Length);
+                    Buffer.BlockCopy(valueBytes, 0, result, 1 + keyBytes.Length, valueBytes.Length);
+                    return result;
+                }
+            }
+
+            // Default: Unit
+            return new byte[] { 9 };
+        }
     }
 }

Assets/CasperSDK/Runtime/Utilities/Cryptography/KeyExporter.cs

@@ -229,16 +229,33 @@ private static KeyPair CreateKeyPairFromECPrivate(ECPrivateKeyParameters ecPriva
             // Get the curve - could be from the key's parameters or default to secp256k1
             var curve = ECNamedCurveTable.GetByName("secp256k1");
             var publicKeyPoint = curve.G.Multiply(ecPrivate.D);
-            var publicKeyBytes = publicKeyPoint.GetEncoded(true); // Compressed format
+            var compressedPoint = publicKeyPoint.GetEncoded(true); // EC compressed: 02/03 + 32 bytes X = 33 bytes
+            
+            // Casper SECP256K1 public key format (from docs):
+            // 02 (1 byte Casper algo tag) + 33 bytes EC compressed point = 34 bytes = 68 hex chars
+            var publicKeyHex = CasperKeyConstants.SECP256K1_PREFIX + CryptoHelper.BytesToHex(compressedPoint);
+            
+            Debug.Log($"[CasperSDK] SECP256K1 imported - public key: {publicKeyHex} (length: {publicKeyHex.Length})");
 
             return new KeyPair
             {
                 PrivateKeyHex = CryptoHelper.BytesToHex(ecPrivate.D.ToByteArrayUnsigned()),
-                PublicKeyHex = "02" + CryptoHelper.BytesToHex(publicKeyBytes),
+                PublicKeyHex = publicKeyHex,
                 Algorithm = KeyAlgorithm.SECP256K1,
-                AccountHash = CryptoHelper.GenerateAccountHash("02" + CryptoHelper.BytesToHex(publicKeyBytes))
+                AccountHash = CryptoHelper.GenerateAccountHash(publicKeyHex)
             };
         }
+        
+        /// <summary>
+        /// Constants for Casper key prefixes (from Casper network specification)
+        /// </summary>
+        private static class CasperKeyConstants
+        {
+            /// <summary>ED25519 algorithm prefix (1 byte)</summary>
+            public const string ED25519_PREFIX = "01";
+            /// <summary>SECP256K1 algorithm prefix (1 byte)</summary>
+            public const string SECP256K1_PREFIX = "02";
+        }
 
         #endregion
     }