fix(sdk-coin-flrp): update fee calculation and address sorting in ExportInCTxBuilder

Ticket: WIN-7770

Author: mohd-kashif

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

@@ -12,6 +12,7 @@ import {
   Address,
   TransferOutput,
   OutputOwners,
+  Signature,
   utils as FlareUtils,
 } from '@flarenetwork/flarejs';
 import utils from './utils';
@@ -75,7 +76,7 @@ export class ExportInCTxBuilder extends AtomicInCTransactionBuilder {
     return TransactionType.Export;
   }
 
-  initBuilder(tx: Tx): this {
+  initBuilder(tx: Tx, rawBytes?: Buffer): this {
     const baseTx = tx as evmSerial.ExportTx;
     if (!this.verifyTxType(baseTx._type)) {
       throw new NotSupported('Transaction cannot be parsed or has an unsupported transaction type');
@@ -106,17 +107,149 @@ export class ExportInCTxBuilder extends AtomicInCTransactionBuilder {
     const outputAmount = transferOutput.amount();
     const fee = inputAmount - outputAmount;
     this._amount = outputAmount;
-    this.transaction._fee.feeRate = Number(fee) - Number(this.fixedFee);
+    // Store the actual fee directly (don't subtract fixedFee since buildFlareTransaction doesn't add it back)
+    this.transaction._fee.feeRate = Number(fee);
     this.transaction._fee.fee = fee.toString();
     this.transaction._fee.size = 1;
     this.transaction._fromAddresses = [Buffer.from(input.address.toBytes())];
     this.transaction._locktime = transferOutput.getLocktime();
 
     this._nonce = input.nonce.value();
-    this.transaction.setTransaction(tx);
+
+    // Check if this is a signed transaction by looking for credentials in raw bytes
+    const isSignedTransaction = rawBytes ? this.hasCredentialsInRawBytes(rawBytes, baseTx) : false;
+
+    // If it's a signed transaction, store the original raw bytes to preserve exact format
+    if (isSignedTransaction && rawBytes) {
+      this.transaction._rawSignedBytes = rawBytes;
+    }
+
+    // Extract credentials from raw bytes if present (for signed transactions)
+    const credentials = rawBytes ? this.extractCredentialsFromRawBytes(rawBytes, baseTx) : [];
+
+    // Create proper UnsignedTx wrapper with credentials
+    const fromAddress = new Address(this.transaction._fromAddresses[0]);
+    const addressMap = new FlareUtils.AddressMap([
+      [fromAddress, 0],
+      [fromAddress, 1],
+    ]);
+    const addressMaps = new FlareUtils.AddressMaps([addressMap]);
+
+    const unsignedTx = new UnsignedTx(
+      baseTx,
+      [],
+      addressMaps,
+      credentials.length > 0 ? credentials : [new Credential([utils.createNewSig('')])]
+    );
+
+    this.transaction.setTransaction(unsignedTx);
     return this;
   }
 
+  /**
+   * Check if raw bytes contain credentials (i.e., it's a signed transaction)
+   */
+  private hasCredentialsInRawBytes(rawBytes: Buffer, tx: evmSerial.ExportTx): boolean {
+    try {
+      const codec = FlareUtils.getManagerForVM('EVM').getDefaultCodec();
+      const txBytes = tx.toBytes(codec);
+      const txSize = txBytes.length;
+
+      // If raw bytes are longer than tx bytes, there are credentials
+      if (rawBytes.length > txSize) {
+        const credentialBytes = rawBytes.slice(txSize);
+        // Check if there's at least a num_credentials field with value > 0
+        if (credentialBytes.length >= 4) {
+          const numCredentials = credentialBytes.readUInt32BE(0);
+          return numCredentials > 0;
+        }
+      }
+      return false;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /**
+   * Extract credentials from raw transaction bytes.
+   * Signed transactions have credentials appended after the transaction body.
+   *
+   * @param rawBytes - The full raw transaction bytes
+   * @param tx - The parsed transaction (to calculate its size)
+   * @returns Array of credentials, or empty array if none found
+   */
+  private extractCredentialsFromRawBytes(rawBytes: Buffer, tx: evmSerial.ExportTx): Credential[] {
+    try {
+      // Get the size of the transaction without credentials using the default codec
+      const codec = FlareUtils.getManagerForVM('EVM').getDefaultCodec();
+      const txBytes = tx.toBytes(codec);
+      const txSize = txBytes.length;
+
+      // If raw bytes are longer than tx bytes, there are credentials
+      if (rawBytes.length <= txSize) {
+        return [];
+      }
+
+      // Extract credential bytes (everything after the transaction)
+      const credentialBytes = rawBytes.slice(txSize);
+
+      // Parse credentials
+      // Format: [num_credentials: 4 bytes] [credentials...]
+      if (credentialBytes.length < 4) {
+        return [];
+      }
+
+      const numCredentials = credentialBytes.readUInt32BE(0);
+      if (numCredentials === 0) {
+        return [];
+      }
+
+      const credentials: Credential[] = [];
+      let offset = 4;
+
+      for (let i = 0; i < numCredentials; i++) {
+        if (offset + 8 > credentialBytes.length) {
+          break;
+        }
+
+        // Read type ID (4 bytes) - Type ID 9 = secp256k1 credential
+        const typeId = credentialBytes.readUInt32BE(offset);
+        offset += 4;
+
+        // Validate credential type (9 = secp256k1)
+        if (typeId !== 9) {
+          continue; // Skip unsupported credential types
+        }
+
+        // Read number of signatures (4 bytes)
+        const numSigs = credentialBytes.readUInt32BE(offset);
+        offset += 4;
+
+        // Parse all signatures for this credential
+        const signatures: Signature[] = [];
+        for (let j = 0; j < numSigs; j++) {
+          if (offset + 65 > credentialBytes.length) {
+            break;
+          }
+          // Each signature is 65 bytes (64 bytes signature + 1 byte recovery)
+          const sigBytes = Buffer.from(credentialBytes.slice(offset, offset + 65));
+          signatures.push(new Signature(sigBytes));
+          offset += 65;
+        }
+
+        // Create credential with the parsed signatures
+        if (signatures.length > 0) {
+          credentials.push(new Credential(signatures));
+        }
+      }
+
+      return credentials;
+    } catch (e) {
+      // If parsing fails, return empty credentials
+      return [];
+    }
+  }
+
   static verifyTxType(txnType: string): boolean {
     return txnType === FlareTransactionType.EvmExportTx;
   }
@@ -147,8 +280,9 @@ export class ExportInCTxBuilder extends AtomicInCTransactionBuilder {
       throw new Error('nonce is required');
     }
 
-    const txFee = BigInt(this.fixedFee);
-    const fee = BigInt(this.transaction._fee.feeRate) + txFee;
+    // For EVM exports, feeRate represents the total fee (baseFee * gasUnits)
+    // Don't add fixedFee as it's already accounted for in the EVM gas model
+    const fee = BigInt(this.transaction._fee.feeRate);
     this.transaction._fee.fee = fee.toString();
     this.transaction._fee.size = 1;
 
@@ -158,6 +292,15 @@ export class ExportInCTxBuilder extends AtomicInCTransactionBuilder {
     const amount = new BigIntPr(this._amount + fee);
     const nonce = new BigIntPr(this._nonce);
     const input = new evmSerial.Input(fromAddress, amount, assetId, nonce);
+    // Map all destination P-chain addresses for multisig support
+    // Sort addresses alphabetically by hex representation (required by Avalanche/Flare protocol)
+    const sortedToAddresses = [...this.transaction._to].sort((a, b) => {
+      const aHex = Buffer.from(a).toString('hex');
+      const bHex = Buffer.from(b).toString('hex');
+      return aHex.localeCompare(bHex);
+    });
+    const toAddresses = sortedToAddresses.map((addr) => new Address(addr));
+
     const exportTx = new evmSerial.ExportTx(
       new Int(this.transaction._networkID),
       utils.flareIdString(this.transaction._blockchainID),
@@ -168,9 +311,11 @@ export class ExportInCTxBuilder extends AtomicInCTransactionBuilder {
           assetId,
           new TransferOutput(
             new BigIntPr(this._amount),
-            new OutputOwners(new BigIntPr(this.transaction._locktime), new Int(this.transaction._threshold), [
-              new Address(this.transaction._to[0]),
-            ])
+            new OutputOwners(
+              new BigIntPr(this.transaction._locktime),
+              new Int(this.transaction._threshold),
+              toAddresses
+            )
           )
         ),
       ]

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

@@ -32,7 +32,7 @@ function isEmptySignature(signature: string): boolean {
 }
 
 export class Transaction extends BaseTransaction {
-  protected _flareTransaction: pvmSerial.BaseTx | UnsignedTx;
+  protected _flareTransaction: Tx;
   public _type: TransactionType;
   public _network: FlareNetwork;
   public _networkID: number;
@@ -49,11 +49,14 @@ export class Transaction extends BaseTransaction {
   public _rewardAddresses: Uint8Array[] = [];
   public _utxos: DecodedUtxoObj[] = []; // Define proper type based on Flare's UTXO structure
   public _fee: Partial<TransactionFee> = {};
+  // Store original raw signed bytes to preserve exact format when re-serializing
+  public _rawSignedBytes: Buffer | undefined;
 
   constructor(coinConfig: Readonly<CoinConfig>) {
     super(coinConfig);
     this._network = coinConfig.network as FlareNetwork;
-    this._assetId = this._network.assetId; // Update with proper Flare asset ID
+    // Decode cb58-encoded asset ID to hex for use in transaction serialization
+    this._assetId = utils.cb58Decode(this._network.assetId).toString('hex');
     this._blockchainID = this._network.blockchainID;
     this._networkID = this._network.networkID;
   }
@@ -113,6 +116,8 @@ export class Transaction extends BaseTransaction {
         if (emptySlotIndex !== -1) {
           credential.setSignature(emptySlotIndex, signature);
           signatureSet = true;
+          // Clear raw signed bytes since we've modified the transaction
+          this._rawSignedBytes = undefined;
           break;
         }
       }
@@ -127,9 +132,18 @@ export class Transaction extends BaseTransaction {
     if (!this._flareTransaction) {
       throw new InvalidTransactionError('Empty transaction data');
     }
-    return FlareUtils.bufferToHex(
-      FlareUtils.addChecksum((this._flareTransaction as UnsignedTx).getSignedTx().toBytes())
-    );
+    // If we have the original raw signed bytes, use them directly to preserve exact format
+    if (this._rawSignedBytes) {
+      return FlareUtils.bufferToHex(this._rawSignedBytes);
+    }
+    const unsignedTx = this._flareTransaction as UnsignedTx;
+    // For signed transactions, return the full signed tx with credentials
+    // Check signature.length for robustness
+    if (this.signature.length > 0) {
+      return FlareUtils.bufferToHex(unsignedTx.getSignedTx().toBytes());
+    }
+    // For unsigned transactions, return just the transaction bytes
+    return FlareUtils.bufferToHex(unsignedTx.toBytes());
   }
 
   toJson(): TxData {

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

@@ -78,7 +78,7 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
    * @param locktime - Timestamp after which the output can be spent
    */
   validateLocktime(locktime: bigint): void {
-    if (!locktime || locktime < BigInt(0)) {
+    if (locktime < BigInt(0)) {
       throw new BuildTransactionError('Invalid transaction: locktime must be 0 or higher');
     }
   }

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

@@ -18,7 +18,6 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
   /** @inheritdoc */
   from(raw: string): TransactionBuilder {
     utils.validateRawTransaction(raw);
-    let transactionBuilder: TransactionBuilder | undefined = undefined;
     const rawNoHex = utils.removeHexPrefix(raw);
     const rawBuffer = Buffer.from(rawNoHex, 'hex');
     let txSource: 'EVM' | 'PVM';
@@ -40,9 +39,9 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
 
       if (txSource === 'EVM') {
         if (ExportInCTxBuilder.verifyTxType(tx._type)) {
-          transactionBuilder = this.getExportInCBuilder();
-          transactionBuilder.initBuilder(tx as evmSerial.ExportTx);
-          return transactionBuilder;
+          const exportBuilder = this.getExportInCBuilder();
+          exportBuilder.initBuilder(tx as evmSerial.ExportTx, rawBuffer);
+          return exportBuilder;
         }
       }
     } catch (e) {

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

@@ -1,29 +1,34 @@
 // Test data for building export transactions with multiple P-addresses
 export const EXPORT_IN_C = {
-  txhash: 'jHRxuZjnSHYNwWpUUyob7RpfHwj1wfuQa8DGWQrkDh2RQ5Jb3',
+  txhash: '4AiWTT1uHFw6TDekeAGxcdrfgoaif9sjRG9J6wsmkVHH7fMkL',
   unsignedHex:
-    '0x0000000000010000007278db5c30bed04c05ce209179812850bbb3fe6d46d7eef3744d814c0da55524790000000000000000000000000000000000000000000000000000000000000000000000017dae940e7fbd1854207be51da222ec43f93b7d0b000000000098968000000000000000000000000000000000000000000000000000000000000000000000000000000009000000010000000000000000000000000000000000000000000000000000000000000000000000070000000000895427000000000000000a000000020000000103e1085f6e146def5a2c7bac91be5aab59710bbd0000000100000009000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000215afad8',
+    '0x0000000000010000007278db5c30bed04c05ce209179812850bbb3fe6d46d7eef3744d814c0da555247900000000000000000000000000000000000000000000000000000000000000000000000128a05933dc76e4e6c25f35d5c9b2a58769700e760000000002ff3d1658734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd00000000000000090000000158734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd000000070000000002faf0800000000000000000000000020000000312cb32eaf92553064db98d271b56cba079ec78f5a6e0c1abd0132f70efb77e2274637ff336a29a57c386d58d09a9ae77cf1cf07bf1c9de44ebb0c9f3',
   signedHex:
-    '0x0000000000010000007278db5c30bed04c05ce209179812850bbb3fe6d46d7eef3744d814c0da55524790000000000000000000000000000000000000000000000000000000000000000000000017dae940e7fbd1854207be51da222ec43f93b7d0b000000000098968000000000000000000000000000000000000000000000000000000000000000000000000000000009000000010000000000000000000000000000000000000000000000000000000000000000000000070000000000895427000000000000000a000000020000000103e1085f6e146def5a2c7bac91be5aab59710bbd0000000100000009000000018ef6432440c6a0b91c7cecef787ca94742abd0759ecd98e3864992182d6b05eb6f39f08b1e032b051ff5f7893b752338bd7614a9d0b462d68bfb863680382c6c01e44d605a',
+    '0x0000000000010000007278db5c30bed04c05ce209179812850bbb3fe6d46d7eef3744d814c0da555247900000000000000000000000000000000000000000000000000000000000000000000000128a05933dc76e4e6c25f35d5c9b2a58769700e760000000002ff3d1658734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd00000000000000090000000158734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd000000070000000002faf0800000000000000000000000020000000312cb32eaf92553064db98d271b56cba079ec78f5a6e0c1abd0132f70efb77e2274637ff336a29a57c386d58d09a9ae77cf1cf07bf1c9de44ebb0c9f300000001000000090000000133f126dee90108c473af9513ebd9eb1591a701b5dfc69041075b303b858fee0609ca9a60208b46f6836f0baf1a9fba740d97b65d45caae10470b5fa707eb45c900',
   xPrivateKey:
     'xprv9s21ZrQH143K2DW9jvDoAkVpRKi5V9XhZaVdoUcqoYPPQ9wRrLNT6VGgWBbRoSYB39Lak6kXgdTM9T3QokEi5n2JJ8EdggHLkZPX8eDiBu1',
   signature: [
-    '0x8ef6432440c6a0b91c7cecef787ca94742abd0759ecd98e3864992182d6b05eb6f39f08b1e032b051ff5f7893b752338bd7614a9d0b462d68bfb863680382c6c01',
+    '0x33f126dee90108c473af9513ebd9eb1591a701b5dfc69041075b303b858fee0609ca9a60208b46f6836f0baf1a9fba740d97b65d45caae10470b5fa707eb45c900',
   ],
-  privateKey: 'bac20595af556338287cb631060473364b023dca089c50f87efd18e70655574d',
-  publicKey: '028fe87afe7b6a6a7f51beaf95357cb5a3cd75da16f8b24fa866d6ab8aef0dcabc',
-  amount: '8999975',
-  cHexAddress: '0x7Dae940e7fBd1854207Be51dA222Ec43f93b7d0b',
+
+  privateKey: '14977929a4e00e4af1c33545240a6a5a08ca3034214618f6b04b72b80883be3a',
+  publicKey: '033ca1801f51484063f3bce093413ca06f7d91c44c3883f642eb103eda5e0eaed3',
+  amount: '50000000', // 0.00005 FLR
+  cHexAddress: '0x28A05933dC76e4e6c25f35D5c9b2A58769700E76',
   pAddresses: [
-    'P-costwo1q0ssshmwz3k77k3v0wkfr0j64dvhzzaaf9wdhq',
-    'P-costwo1n4a86kc3td6nvmwm4xh0w78mc5jjxc9g8w6en0',
-    'P-costwo1nhm2vw8653f3qwtj3kl6qa359kkt6y9r7qgljv',
+    'P-costwo1zt9n96hey4fsvnde35n3k4kt5pu7c784dzewzd',
+    'P-costwo1cwrdtrgf4xh80ncu7palrjw7gn4mpj0n4dxghh',
+    'P-costwo15msvr27szvhhpmah0c38gcml7vm29xjh7tcek8',
   ],
   mainAddress: 'P-costwo1q0ssshmwz3k77k3v0wkfr0j64dvhzzaaf9wdhq',
-  pAddressRelatedToPrivateKey: 'P-costwo1kr3937ujjftcue445uxfesz7w6247pf2a8ts4k',
-  corethAddress: 'C-costwo1kr3937ujjftcue445uxfesz7w6247pf2a8ts4k',
+  corethAddress: [
+    'C-costwo1zt9n96hey4fsvnde35n3k4kt5pu7c784dzewzd',
+    'C-costwo1cwrdtrgf4xh80ncu7palrjw7gn4mpj0n4dxghh',
+    'C-costwo15msvr27szvhhpmah0c38gcml7vm29xjh7tcek8',
+  ],
   targetChainId: '11111111111111111111111111111111LpoYY',
   nonce: 9,
   threshold: 2,
-  fee: '25',
+  fee: '281750', // Total fee derived from expected hex (input - output = 50281750 - 50000000)
+  locktime: 0,
 };

modules/sdk-coin-flrp/test/unit/lib/exportInCTxBuilder.ts

@@ -90,7 +90,7 @@ describe('ExportInCTxBuilder', function () {
         .nonce(testData.nonce)
         .amount(testData.amount)
         .threshold(testData.threshold)
-        .locktime(10)
+        .locktime(testData.locktime)
         .to(testData.pAddresses)
         .feeRate(testData.fee);
 
@@ -110,7 +110,7 @@ describe('ExportInCTxBuilder', function () {
       rawTx.should.equal(testData.unsignedHex);
     });
 
-    xit('Should recover signed export from signed raw tx', async () => {
+    it('Should recover signed export from signed raw tx', async () => {
       const txBuilder = new TransactionBuilderFactory(coins.get('tflrp')).from(testData.signedHex);
       const tx = await txBuilder.build();
       const rawTx = tx.toBroadcastFormat();
@@ -136,18 +136,16 @@ describe('ExportInCTxBuilder', function () {
     });
 
     it('Key cannot sign the transaction', () => {
-      it('Should full sign a export  tx from unsigned raw tx', () => {
-        const txBuilder = new TransactionBuilderFactory(coins.get('tflrp'))
-          .from(testData.unsignedHex)
-          .fromPubKey(testData.pAddresses);
-        txBuilder.sign({ key: testData.privateKey });
-        txBuilder
-          .build()
-          .then(() => assert.fail('it can sign'))
-          .catch((err) => {
-            err.message.should.be.equal('Private key cannot sign the transaction');
-          });
-      });
+      const txBuilder = new TransactionBuilderFactory(coins.get('tflrp'))
+        .from(testData.unsignedHex)
+        .fromPubKey(testData.pAddresses);
+      txBuilder.sign({ key: testData.privateKey });
+      txBuilder
+        .build()
+        .then(() => assert.fail('it can sign'))
+        .catch((err) => {
+          err.message.should.be.equal('Private key cannot sign the transaction');
+        });
     });
   });
 });