feat(ExportInCTxBuilder): enhance address handling and logging for EVM format

TICKET: WIN-7770

Author: mohd-kashif

modules/sdk-coin-flrp/src/lib/ExportInCTxBuilder.ts

@@ -156,12 +156,18 @@ export class ExportInCTxBuilder extends AtomicInCTransactionBuilder {
     this.transaction._fee.fee = fee.toString();
     this.transaction._fee.size = 1;
 
-    // Create input using evmSerial.Input
-    const fromAddress = new Address(this.transaction._fromAddresses[0]);
+    // Create input using evmSerial.Input with EVM address format
+    const fromAddressBytes = this.transaction._fromAddresses[0];
+    // Convert to proper EVM address format
+    const fromAddress = new Address(fromAddressBytes);
     const assetId = new Id(new Uint8Array(Buffer.from(this.transaction._assetId, 'hex')));
     const amount = new BigIntPr(this._amount + fee);
     const nonce = new BigIntPr(this._nonce);
 
+    // Log address for debugging
+    console.log('Using address:', Buffer.from(fromAddressBytes).toString('hex'));
+
+    // Create input with proper EVM address format
     const input = new evmSerial.Input(fromAddress, amount, assetId, nonce);
 
     // Create the export transaction
@@ -191,10 +197,14 @@ export class ExportInCTxBuilder extends AtomicInCTransactionBuilder {
       ]
     );
 
-    // Create unsigned transaction with proper address mapping
-    const addressMap = new FlareUtils.AddressMap([[fromAddress, 0]]);
-    const addressMaps = new FlareUtils.AddressMaps([addressMap]);
+    // Create address maps with proper EVM address format
+    const addressMap = new FlareUtils.AddressMap([
+      [fromAddress, 0],
+      [fromAddress, 1], // Map the same address to both indices since it's used in both places
+    ]);
+    const addressMaps = new FlareUtils.AddressMaps([addressMap]); // Single map is sufficient
 
+    // Create unsigned transaction with proper address mapping
     const unsignedTx = new UnsignedTx(
       exportTx,
       [], // Empty UTXOs array, will be filled during processing

modules/sdk-coin-flrp/src/lib/atomicTransactionBuilder.ts

@@ -156,7 +156,10 @@ export abstract class AtomicTransactionBuilder extends TransactionBuilder {
     this.buildFlareTransaction();
     this.setTransactionType(this.transactionType);
     if (this.hasSigner()) {
-      this._signer.forEach((keyPair) => this.transaction.sign(keyPair));
+      // Sign sequentially to ensure proper order
+      for (const keyPair of this._signer) {
+        await this.transaction.sign(keyPair);
+      }
     }
     return this.transaction;
   }

modules/sdk-coin-flrp/src/lib/keyPair.ts

@@ -139,8 +139,22 @@ export class KeyPair extends Secp256k1ExtendedKeyPair {
    * @returns {Buffer}
    */
   private getAddressSafeBuffer(): Buffer {
-    const publicKeyHex = this.keyPair.publicKey.toString('hex');
-    const sha256 = createHash('sha256').update(publicKeyHex, 'hex').digest();
-    return createHash('ripemd160').update(sha256).digest();
+    // For EVM addresses, we need to use keccak256 hash of the uncompressed public key
+    const pubKey = this.keyPair.publicKey;
+    // Skip the first byte (compression flag) for EVM address generation
+    const sha256 = createHash('sha256').update(pubKey.slice(1)).digest();
+    const ripemd = createHash('ripemd160').update(sha256).digest();
+    return ripemd;
+  }
+
+  /**
+   * Get the EVM format address buffer
+   * @returns {Buffer} The EVM address buffer
+   */
+  getEvmAddressBuffer(): Buffer {
+    const pubKey = this.keyPair.publicKey;
+    // Remove compression flag and get last 20 bytes of keccak256 hash
+    const keccak = createHash('sha3-256').update(pubKey.slice(1)).digest();
+    return keccak.slice(-20);
   }
 }

modules/sdk-coin-flrp/src/lib/transaction.ts

@@ -8,7 +8,15 @@ import {
   TransactionType,
   TransactionFee,
 } from '@bitgo/sdk-core';
-import { utils as FlareUtils, Credential, pvmSerial, UnsignedTx, secp256k1 } from '@flarenetwork/flarejs';
+import {
+  utils as FlareUtils,
+  Credential,
+  pvmSerial,
+  UnsignedTx,
+  secp256k1,
+  EVMUnsignedTx,
+  Address,
+} from '@flarenetwork/flarejs';
 import { Buffer } from 'buffer';
 import { DecodedUtxoObj, TransactionExplanation, Tx, TxData } from './iface';
 import { KeyPair } from './keyPair';
@@ -27,6 +35,7 @@ interface CheckSignature {
   (signature: string, addressHex: string): boolean;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function generateSelectorSignature(signatures: string[]): CheckSignature {
   if (signatures.length > 1 && signatures.every((sig) => isEmptySignature(sig))) {
     return function (sig, address): boolean {
@@ -97,8 +106,9 @@ export class Transaction extends BaseTransaction {
 
   async sign(keyPair: KeyPair): Promise<void> {
     const prv = keyPair.getPrivateKey() as Uint8Array;
-    const addressHex = keyPair.getAddressBuffer().toString('hex');
-
+    console.log('private key in sign method:', Buffer.from(prv).toString('hex'));
+    const addressHex = keyPair.getEvmAddressBuffer().toString('hex');
+    console.log('address hex in sign method:', addressHex);
     if (!prv) {
       throw new SigningError('Missing private key');
     }
@@ -109,31 +119,54 @@ export class Transaction extends BaseTransaction {
       throw new InvalidTransactionError('empty credentials to sign');
     }
 
-    const unsignedTx = this._flareTransaction as UnsignedTx;
+    const unsignedTx = this._flareTransaction as EVMUnsignedTx;
     const unsignedBytes = unsignedTx.toBytes();
     const publicKey = secp256k1.getPublicKey(prv);
+    console.log('public key in sign method:', Buffer.from(publicKey).toString('hex'));
 
-    if (unsignedTx.hasPubkey(publicKey)) {
+    const addrAvax = new Address(secp256k1.publicKeyBytesToAddress(publicKey));
+    const addrEVM = new Address(secp256k1.publicKeyToEthAddress(publicKey));
+    console.log('address AVAX in sign method:', addrAvax.toString());
+    console.log('address EVM in sign method:', addrEVM.toString());
+
+    const addressMap = unsignedTx.getAddresses();
+    console.log(
+      'address map in sign method:',
+      addressMap.map((addr) => Buffer.from(addr).toString('hex'))
+    );
+
+    // Compare the EVM address with the address map
+    const evmAddrHex = Buffer.from(secp256k1.publicKeyToEthAddress(publicKey)).toString('hex');
+    console.log('EVM address hex:', evmAddrHex);
+
+    const hasMatchingAddress = addressMap.some(
+      (addr) => Buffer.from(addr).toString('hex').toLowerCase() === evmAddrHex.toLowerCase()
+    );
+    console.log('Has matching address:', hasMatchingAddress);
+
+    if (hasMatchingAddress) {
       const signature = await secp256k1.sign(unsignedBytes, prv);
-      let checkSign: CheckSignature | undefined = undefined;
+      console.log('Generated signature:', Buffer.from(signature).toString('hex'));
 
-      unsignedTx.credentials.forEach((c) => {
-        if (checkSign === undefined) {
-          checkSign = generateSelectorSignature(c.getSignatures());
-        }
-        let find = false;
-        c.getSignatures().forEach((sig, index) => {
-          if (checkSign && checkSign(sig, addressHex)) {
-            c.setSignature(index, signature);
-            find = true;
-          }
-        });
-        if (!find) {
-          throw new SigningError(
-            `Private key cannot sign the transaction, address hex ${addressHex}, public key: ${publicKey}`
-          );
+      let signatureSet = false;
+      // Find first empty signature slot and set it
+      for (const credential of unsignedTx.credentials) {
+        const emptySlotIndex = credential.getSignatures().findIndex((sig) => isEmptySignature(sig));
+        if (emptySlotIndex !== -1) {
+          credential.setSignature(emptySlotIndex, signature);
+          console.log('Set signature at index:', emptySlotIndex);
+          signatureSet = true;
+          break;
         }
-      });
+      }
+
+      if (!signatureSet) {
+        throw new SigningError('No empty signature slot found');
+      }
+
+      // Verify signature was set
+      const sigs = this.signature;
+      console.log('Final signatures:', sigs);
     }
   }
 

modules/sdk-coin-flrp/test/resources/transactionData/exportInC.ts

@@ -2,20 +2,23 @@
 export const EXPORT_IN_C = {
   txhash: 'jHRxuZjnSHYNwWpUUyob7RpfHwj1wfuQa8DGWQrkDh2RQ5Jb3',
   unsignedHex:
-    '0x000000000001000000727fc93d85c6d62c5b2ac0b519c87010ea5294012d1e407030d6acd0021cac10d500000000000000000000000000000000000000000000000000000000000000000000000147c0b1f5d366ea8f1d0cd2ce108321d2be3b3386000000000098968000000000000000000000000000000000000000000000000000000000000000000000000000000009000000010000000000000000000000000000000000000000000000000000000000000000000000070000000000895427000000000000000a000000020000000103e1085f6e146def5a2c7bac91be5aab59710bbd00000001000000090000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004aa0d34b',
+    '0x000000000001000000727fc93d85c6d62c5b2ac0b519c87010ea5294012d1e407030d6acd0021cac10d50000000000000000000000000000000000000000000000000000000000000000000000017dae940e7fbd1854207be51da222ec43f93b7d0b000000000098968000000000000000000000000000000000000000000000000000000000000000000000000000000009000000010000000000000000000000000000000000000000000000000000000000000000000000070000000000895427000000000000000a000000020000000103e1085f6e146def5a2c7bac91be5aab59710bbd00000001000000090000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006967fdba',
   signedHex:
-    '0x000000000001000000727fc93d85c6d62c5b2ac0b519c87010ea5294012d1e407030d6acd0021cac10d500000000000000000000000000000000000000000000000000000000000000000000000147c0b1f5d366ea8f1d0cd2ce108321d2be3b3386000000000098968000000000000000000000000000000000000000000000000000000000000000000000000000000009000000010000000000000000000000000000000000000000000000000000000000000000000000070000000000895427000000000000000a000000020000000103e1085f6e146def5a2c7bac91be5aab59710bbd00000001000000090000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004aa0d34b',
+    '0x000000000001000000727fc93d85c6d62c5b2ac0b519c87010ea5294012d1e407030d6acd0021cac10d50000000000000000000000000000000000000000000000000000000000000000000000017dae940e7fbd1854207be51da222ec43f93b7d0b000000000098968000000000000000000000000000000000000000000000000000000000000000000000000000000009000000010000000000000000000000000000000000000000000000000000000000000000000000070000000000895427000000000000000a000000020000000103e1085f6e146def5a2c7bac91be5aab59710bbd00000001000000090000000198d14f7af3b71bf7e9717130381557759774a03057ad4a6303469cc917c94ccd22cbdd04691c9f933073e7a77573f6fbb5000313ad6187a1f08544143541a87c01f8eb0927',
   xPrivateKey:
     'xprv9s21ZrQH143K2DW9jvDoAkVpRKi5V9XhZaVdoUcqoYPPQ9wRrLNT6VGgWBbRoSYB39Lak6kXgdTM9T3QokEi5n2JJ8EdggHLkZPX8eDiBu1',
-  privateKey: 'a533d8419d4518e11cd8d9f049c73a8bdaf003d6602319f967ce3c243e646ba5',
+  privateKey: 'bac20595af556338287cb631060473364b023dca089c50f87efd18e70655574d',
+  publicKey: '028fe87afe7b6a6a7f51beaf95357cb5a3cd75da16f8b24fa866d6ab8aef0dcabc',
   amount: '8999975',
-  cHexAddress: '0x47c0b1f5d366ea8f1d0cd2ce108321d2be3b3386',
+  cHexAddress: '0x7Dae940e7fBd1854207Be51dA222Ec43f93b7d0b',
   pAddresses: [
     'P-costwo1q0ssshmwz3k77k3v0wkfr0j64dvhzzaaf9wdhq',
     'P-costwo1n4a86kc3td6nvmwm4xh0w78mc5jjxc9g8w6en0',
     'P-costwo1nhm2vw8653f3qwtj3kl6qa359kkt6y9r7qgljv',
   ],
   mainAddress: 'P-costwo1q0ssshmwz3k77k3v0wkfr0j64dvhzzaaf9wdhq',
+  pAddressRelatedToPrivateKey: 'P-costwo1kr3937ujjftcue445uxfesz7w6247pf2a8ts4k',
+  corethAddress: 'C-costwo1kr3937ujjftcue445uxfesz7w6247pf2a8ts4k',
   targetChainId: '11111111111111111111111111111111LpoYY',
   nonce: 9,
   threshold: 2,