refactor(sdk-coin-flrp): enhance transaction builders with improved fee state management and amount handling

TICKET: WIN-8498

Author: mohd-kashif

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

@@ -8,42 +8,27 @@ import {
   Address,
   TransferOutput,
   utils as FlareUtils,
-  Utxo,
   evm,
 } from '@flarenetwork/flarejs';
 import utils from './utils';
-import { Tx, FlareTransactionType, Context, ExportEVMOptions } from './iface';
+import { Tx, FlareTransactionType, ExportEVMOptions } from './iface';
 
 export class ExportInCTxBuilder extends AtomicInCTransactionBuilder {
-  private _amount: bigint;
   private _nonce: bigint;
-  private _context: Context;
 
   constructor(_coinConfig: Readonly<CoinConfig>) {
     super(_coinConfig);
   }
 
   /**
-   * Utxos are not required in Export Tx in C-Chain.
-   * Override utxos to prevent used by throwing a error.
+   * UTXOs are not required for Export Tx from C-Chain (uses EVM balance instead).
+   * Override to prevent usage by throwing an error.
    *
-   * @param {Utxo[]} utxos ignored
+   * @param {string[]} _utxoHexStrings - ignored, UTXOs not used for C-chain exports
+   * @throws {BuildTransactionError} always throws as UTXOs are not applicable
    */
-  utxos(utxos: Utxo[]): this {
-    throw new BuildTransactionError('utxos are not required in Export Tx in C-Chain');
-  }
-
-  /**
-   * Amount is a bigint that specifies the quantity of the asset that this output owns. Must be positive.
-   * The transaction output amount add a fixed fee that will be paid upon import.
-   *
-   * @param {bigint | string} amount The withdrawal amount
-   */
-  amount(amount: bigint | string): this {
-    const amountBigInt = typeof amount === 'string' ? BigInt(amount) : amount;
-    this.validateAmount(amountBigInt);
-    this._amount = amountBigInt;
-    return this;
+  utxos(_utxoHexStrings: string[]): this {
+    throw new BuildTransactionError('UTXOs are not required for Export Tx from C-Chain');
   }
 
   /**
@@ -58,11 +43,6 @@ export class ExportInCTxBuilder extends AtomicInCTransactionBuilder {
     return this;
   }
 
-  context(context: Context): this {
-    this._context = context;
-    return this;
-  }
-
   /**
    * Export tx target P wallet.
    *
@@ -106,7 +86,7 @@ export class ExportInCTxBuilder extends AtomicInCTransactionBuilder {
     const inputAmount = input.amount.value();
     const outputAmount = transferOutput.amount();
     const fee = inputAmount - outputAmount;
-    this._amount = outputAmount;
+    this.transaction._amount = outputAmount;
     this.transaction._fee.fee = fee.toString();
     this.transaction._fromAddresses = [Buffer.from(input.address.toBytes())];
     this.transaction._locktime = transferOutput.getLocktime();
@@ -149,23 +129,23 @@ export class ExportInCTxBuilder extends AtomicInCTransactionBuilder {
    */
   protected buildFlareTransaction(): void {
     if (this.transaction.hasCredentials) return;
-    if (this._amount === undefined) {
-      throw new Error('amount is required');
+    if (this.transaction._amount === undefined) {
+      throw new BuildTransactionError('amount is required');
     }
     if (this.transaction._fromAddresses.length !== 1) {
-      throw new Error('sender is one and required');
+      throw new BuildTransactionError('sender is one and required');
     }
     if (this.transaction._to.length === 0) {
-      throw new Error('to is required');
+      throw new BuildTransactionError('to is required');
     }
     if (!this.transaction._fee.fee) {
-      throw new Error('fee rate is required');
+      throw new BuildTransactionError('fee rate is required');
     }
     if (this._nonce === undefined) {
-      throw new Error('nonce is required');
+      throw new BuildTransactionError('nonce is required');
     }
-    if (!this._context) {
-      throw new Error('context is required');
+    if (!this.transaction._context) {
+      throw new BuildTransactionError('context is required');
     }
 
     const fee = BigInt(this.transaction._fee.fee);
@@ -183,10 +163,10 @@ export class ExportInCTxBuilder extends AtomicInCTransactionBuilder {
     };
 
     const exportTx = evm.newExportTxFromBaseFee(
-      this._context,
+      this.transaction._context,
       fee / BigInt(1e9),
-      this._amount,
-      this._context.pBlockchainID,
+      this.transaction._amount,
+      this.transaction._context.pBlockchainID,
       fromAddressBytes,
       toAddresses.map((addr) => Buffer.from(addr.toBytes())),
       BigInt(this._nonce),

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

@@ -13,14 +13,9 @@ import {
   pvm,
 } from '@flarenetwork/flarejs';
 import utils from './utils';
-import { DecodedUtxoObj, SECP256K1_Transfer_Output, FlareTransactionType, Tx, Context } from './iface';
-import { FlrpFeeState } from '@bitgo/public-types';
+import { DecodedUtxoObj, SECP256K1_Transfer_Output, FlareTransactionType, Tx } from './iface';
 
 export class ExportInPTxBuilder extends AtomicTransactionBuilder {
-  private _amount: bigint;
-  private _feeState: FlrpFeeState;
-  private _context: Context;
-
   constructor(_coinConfig: Readonly<CoinConfig>) {
     super(_coinConfig);
     // For Export FROM P-chain:
@@ -37,41 +32,6 @@ export class ExportInPTxBuilder extends AtomicTransactionBuilder {
     return TransactionType.Export;
   }
 
-  /**
-   * Amount is a bigint that specifies the quantity of the asset that this output owns. Must be positive.
-   * @param {bigint | string} amount The withdrawal amount
-   */
-  amount(value: bigint | string): this {
-    const valueBigInt = typeof value === 'string' ? BigInt(value) : value;
-    this.validateAmount(valueBigInt);
-    this._amount = valueBigInt;
-    return this;
-  }
-
-  feeState(state: FlrpFeeState): this {
-    this._feeState = state;
-    return this;
-  }
-
-  context(context: Context): this {
-    this._context = context;
-    return this;
-  }
-
-  /**
-   * Sets the UTXOs for the transaction from hex strings
-   * @param utxoHexStrings - Array of UTXO hex strings from getUTXOs API
-   */
-  utxos(utxoHexStrings: string[]): this {
-    if (!utxoHexStrings || utxoHexStrings.length === 0) {
-      throw new BuildTransactionError('UTXOs array cannot be empty');
-    }
-    this.transaction._utxoHexStrings = utxoHexStrings;
-    const nativeUtxos = utils.parseUtxoHexArray(utxoHexStrings);
-    this.transaction._utxos = utils.utxosToDecoded(nativeUtxos, this.transaction._network);
-    return this;
-  }
-
   initBuilder(tx: Tx, rawBytes?: Buffer, parsedCredentials?: Credential[]): this {
     const exportTx = tx as pvmSerial.ExportTx;
 
@@ -95,15 +55,15 @@ export class ExportInPTxBuilder extends AtomicTransactionBuilder {
     this.transaction._threshold = outputOwners.threshold.value();
     this.transaction._fromAddresses = outputOwners.addrs.map((addr) => Buffer.from(addr.toBytes()));
     this._externalChainId = Buffer.from(exportTx.destination.toBytes());
-    this._amount = outputTransfer.amount();
+    this.transaction._amount = outputTransfer.amount();
     this.transaction._utxos = this.recoverUtxos([...exportTx.baseTx.inputs]);
 
     const totalInputAmount = exportTx.baseTx.inputs.reduce((sum, input) => sum + input.amount(), BigInt(0));
     const changeOutputAmount = exportTx.baseTx.outputs.reduce((sum, out) => {
       const transferOut = out.output as TransferOutput;
       return sum + transferOut.amount();
     }, BigInt(0));
-    const fee = totalInputAmount - changeOutputAmount - this._amount;
+    const fee = totalInputAmount - changeOutputAmount - this.transaction._amount;
     this.transaction._fee.fee = fee.toString();
 
     const credentials = parsedCredentials || [];
@@ -157,25 +117,35 @@ export class ExportInPTxBuilder extends AtomicTransactionBuilder {
   protected async buildFlareTransaction(): Promise<void> {
     if (this.transaction.hasCredentials) return;
 
-    const feeState = this._feeState;
+    const feeState = this.transaction._feeState;
     if (!feeState) {
       throw new BuildTransactionError('Fee state is required');
     }
-    if (!this._context) {
+    if (!this.transaction._context) {
       throw new BuildTransactionError('context is required');
     }
-    if (this._amount === undefined) {
+    if (this.transaction._amount === undefined) {
       throw new BuildTransactionError('amount is required');
     }
 
     const nativeUtxos = utils.parseUtxoHexArray(this.transaction._utxoHexStrings);
 
+    const totalUtxoAmount = nativeUtxos.reduce((sum, utxo) => {
+      const output = utxo.output as TransferOutput;
+      return sum + output.amount();
+    }, BigInt(0));
+
+    if (totalUtxoAmount < this.transaction._amount) {
+      throw new BuildTransactionError(
+        `Insufficient UTXO balance: have ${totalUtxoAmount.toString()} nFLR, need at least ${this.transaction._amount.toString()} nFLR (plus fee)`
+      );
+    }
+
     const assetId = utils.flareIdString(this.transaction._assetId).toString();
-    ``;
     const fromAddresses = this.transaction._fromAddresses.map((addr) => Buffer.from(addr));
     const transferableOutput = TransferableOutput.fromNative(
       assetId,
-      this._amount,
+      this.transaction._amount,
       fromAddresses,
       this.transaction._locktime,
       this.transaction._threshold
@@ -189,7 +159,7 @@ export class ExportInPTxBuilder extends AtomicTransactionBuilder {
         outputs: [transferableOutput],
         utxos: nativeUtxos,
       },
-      this._context
+      this.transaction._context
     );
 
     this.transaction.setTransaction(exportTx);

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

@@ -6,25 +6,19 @@ import {
   UnsignedTx,
   Credential,
   TransferableInput,
+  TransferOutput,
   Address,
   utils as FlareUtils,
   evm,
 } from '@flarenetwork/flarejs';
 import utils from './utils';
-import { Context, DecodedUtxoObj, FlareTransactionType, SECP256K1_Transfer_Output, Tx } from './iface';
+import { DecodedUtxoObj, FlareTransactionType, SECP256K1_Transfer_Output, Tx } from './iface';
 
 export class ImportInCTxBuilder extends AtomicInCTransactionBuilder {
-  private _context: Context;
-
   constructor(_coinConfig: Readonly<CoinConfig>) {
     super(_coinConfig);
   }
 
-  context(context: Context): this {
-    this._context = context;
-    return this;
-  }
-
   /**
    * C-chain address who is target of the import.
    * Address format is eth like
@@ -135,13 +129,13 @@ export class ImportInCTxBuilder extends AtomicInCTransactionBuilder {
   protected buildFlareTransaction(): void {
     if (this.transaction.hasCredentials) return;
     if (this.transaction._to.length !== 1) {
-      throw new Error('to is required');
+      throw new BuildTransactionError('to is required');
     }
     if (!this.transaction._fee.fee) {
-      throw new Error('fee is required');
+      throw new BuildTransactionError('fee is required');
     }
-    if (!this._context) {
-      throw new Error('context is required');
+    if (!this.transaction._context) {
+      throw new BuildTransactionError('context is required');
     }
     if (!this.transaction._fromAddresses || this.transaction._fromAddresses.length === 0) {
       throw new BuildTransactionError('fromAddresses are required');
@@ -153,18 +147,31 @@ export class ImportInCTxBuilder extends AtomicInCTransactionBuilder {
       throw new BuildTransactionError('threshold is required');
     }
 
-    const estimatedGasUnits = 200000n;
-    const baseFeeNFlr = BigInt(this._transaction._fee.fee) / BigInt(1_000_000_000);
-    const actualFee = baseFeeNFlr * estimatedGasUnits;
+    const estimatedGasUnits = BigInt(this.transaction._network.txFee) || 200000n;
+    const baseFeeInWei = BigInt(this.transaction._fee.fee);
+    const baseFeeGwei = baseFeeInWei / BigInt(1e9);
+    const actualFeeNFlr = baseFeeGwei * estimatedGasUnits;
     const sourceChain = 'P';
     const nativeUtxos = utils.parseUtxoHexArray(this.transaction._utxoHexStrings);
+
+    // Validate UTXO balance is sufficient to cover the import fee
+    const totalUtxoAmount = nativeUtxos.reduce((sum, utxo) => {
+      const output = utxo.output as TransferOutput;
+      return sum + output.amount();
+    }, BigInt(0));
+
+    if (totalUtxoAmount <= actualFeeNFlr) {
+      throw new BuildTransactionError(
+        `Insufficient UTXO balance: have ${totalUtxoAmount.toString()} nFLR, need more than ${actualFeeNFlr.toString()} nFLR to cover import fee`
+      );
+    }
     const importTx = evm.newImportTx(
-      this._context,
+      this.transaction._context,
       this.transaction._to[0],
       this.transaction._fromAddresses.map((addr) => Buffer.from(addr)),
       nativeUtxos,
       sourceChain,
-      actualFee
+      actualFeeNFlr
     );
 
     this.transaction.setTransaction(importTx);