fix(sdk-coin-flrp): tighten fee/baseFee validation on C-chain imports

- Treat a zero fee/baseFee as unset instead of relying on string
  truthiness, and clear the inherited network txFee default in the
  import builder constructor so an unset fee is actually detectable.
- Reject setting both fee and baseFee, since silently preferring
  baseFee masked the ambiguity.
- Guard against a zero/negative computed fee in the baseFee path in
  case malformed UTXOs or upstream flarejs behavior changes slip
  through.
- Rewrite the padding test to independently reconstruct the unpadded
  flarejs estimate and assert the padded fee is exactly 10% higher,
  instead of only checking determinism against a hard-coded floor.

Ticket: CECHO-1821

Author: ArunBala-Bitgo

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

@@ -23,6 +23,10 @@ const BASE_FEE_PADDING_BPS = 1000n;
 export class ImportInCTxBuilder extends AtomicInCTransactionBuilder {
   constructor(_coinConfig: Readonly<CoinConfig>) {
     super(_coinConfig);
+    // Unlike P-chain-oriented atomic txs, a C-chain import has no meaningful default fee.
+    // Clear the inherited network txFee default so an unset fee is detectable at build time,
+    // rather than silently building with that unrelated default value.
+    this.transaction._fee.fee = '';
   }
 
   /**
@@ -133,9 +137,16 @@ export class ImportInCTxBuilder extends AtomicInCTransactionBuilder {
     if (this.transaction._to.length !== 1) {
       throw new BuildTransactionError('to is required');
     }
-    if (!this.transaction._fee.fee && !this.transaction._fee.baseFee) {
+    const hasFee = !!this.transaction._fee.fee && BigInt(this.transaction._fee.fee) !== BigInt(0);
+    const hasBaseFee = !!this.transaction._fee.baseFee && BigInt(this.transaction._fee.baseFee) !== BigInt(0);
+    if (!hasFee && !hasBaseFee) {
       throw new BuildTransactionError('fee is required');
     }
+    if (hasFee && hasBaseFee) {
+      throw new BuildTransactionError(
+        'fee and baseFee are mutually exclusive: use baseFee for gas-aware fee calculation, or fee for a fixed amount, not both'
+      );
+    }
     if (!this.transaction._context) {
       throw new BuildTransactionError('context is required');
     }
@@ -168,12 +179,12 @@ export class ImportInCTxBuilder extends AtomicInCTransactionBuilder {
 
     let importTx: UnsignedTx;
 
-    if (this.transaction._fee.baseFee) {
+    if (hasBaseFee) {
       // Gas-aware path: let flarejs compute the actual import gas cost (including the
       // ~10,000 AtomicTxBaseCost) from the real tx size/inputs, instead of trusting a
       // pre-computed fee amount. Pad the base fee to absorb volatility between signing
       // and broadcast.
-      const suppliedBaseFee = BigInt(this.transaction._fee.baseFee);
+      const suppliedBaseFee = BigInt(this.transaction._fee.baseFee as string);
       const paddedBaseFee = (suppliedBaseFee * (10000n + BASE_FEE_PADDING_BPS)) / 10000n;
 
       importTx = evm.newImportTxFromBaseFee(
@@ -187,7 +198,13 @@ export class ImportInCTxBuilder extends AtomicInCTransactionBuilder {
 
       const innerImportTx = importTx.getTx() as evmSerial.ImportTx;
       const totalOutputAmount = innerImportTx.Outs.reduce((sum, out) => sum + out.amount.value(), BigInt(0));
-      this.transaction._fee.fee = (totalUtxoAmount - totalOutputAmount).toString();
+      const computedFee = totalUtxoAmount - totalOutputAmount;
+      if (computedFee <= BigInt(0)) {
+        throw new BuildTransactionError(
+          `Computed import fee must be greater than 0, got ${computedFee.toString()} nFLR`
+        );
+      }
+      this.transaction._fee.fee = computedFee.toString();
     } else {
       const actualFeeNFlr = BigInt(this.transaction._fee.fee);
 

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

@@ -1,11 +1,11 @@
 import assert from 'assert';
 import 'should';
-import { TransactionBuilderFactory, Transaction } from '../../../src/lib';
+import { TransactionBuilderFactory, Transaction, Utils } from '../../../src/lib';
 import { coins } from '@bitgo/statics';
 import { IMPORT_IN_C as testData } from '../../resources/transactionData/importInC';
 import { ON_CHAIN_TEST_WALLET } from '../../resources/account';
 import signFlowTest from './signFlowTestSuit';
-import { secp256k1, UnsignedTx } from '@flarenetwork/flarejs';
+import { secp256k1, UnsignedTx, evm, evmSerial } from '@flarenetwork/flarejs';
 
 describe('Flrp Import In C Tx Builder', () => {
   const factory = new TransactionBuilderFactory(coins.get('tflrp'));
@@ -258,30 +258,42 @@ describe('Flrp Import In C Tx Builder', () => {
       );
     });
 
-    it('should pad the supplied base fee to absorb volatility between signing and broadcast', async () => {
+    it('should pad the supplied base fee on top of the raw flarejs gas*baseFee estimate', async () => {
       const baseFeeWei = 500n;
+      const fromAddress = ON_CHAIN_TEST_WALLET.user.pChainAddress;
+      const toAddress = '0x96993BAEb6AaE2e06BF95F144e2775D4f8efbD35';
 
-      const buildWithBaseFee = async (fee: bigint) =>
-        factory
-          .getImportInCBuilder()
-          .threshold(1)
-          .locktime(0)
-          .fromPubKey([ON_CHAIN_TEST_WALLET.user.pChainAddress])
-          .to('0x96993BAEb6AaE2e06BF95F144e2775D4f8efbD35')
-          .baseFee(fee)
-          .decodedUtxos([utxo])
-          .context(testData.context)
-          .build();
-
-      const paddedTx = (await buildWithBaseFee(baseFeeWei)) as Transaction;
-      const unpaddedFeeEquivalentTx = (await buildWithBaseFee(baseFeeWei)) as Transaction;
-
-      // Same input should be deterministic, and strictly greater than the raw baseFee * gas
-      // (i.e. some padding is applied on top of the network-observed base fee).
-      BigInt(paddedTx.fee.fee).should.equal(BigInt(unpaddedFeeEquivalentTx.fee.fee));
+      const paddedTx = (await factory
+        .getImportInCBuilder()
+        .threshold(1)
+        .locktime(0)
+        .fromPubKey([fromAddress])
+        .to(toAddress)
+        .baseFee(baseFeeWei)
+        .decodedUtxos([utxo])
+        .context(testData.context)
+        .build()) as Transaction;
       const paddedFee = BigInt(paddedTx.fee.fee);
-      const minExpectedFee = baseFeeWei * 11300n; // > known real gas cost * baseFee, proving padding
-      assert(paddedFee > minExpectedFee, `Expected paddedFee (${paddedFee}) to be above ${minExpectedFee}`);
+
+      // Reconstruct the same import tx directly via flarejs using the *unpadded* base fee,
+      // to recover the network's raw gas*baseFee requirement with no buffer applied.
+      const assetId = (coins.get('tflrp').network as unknown as { assetId: string }).assetId;
+      const nativeUtxos = Utils.decodedToUtxos([utxo], assetId);
+      const rawImportTx = evm.newImportTxFromBaseFee(
+        testData.context,
+        Utils.parseAddress(toAddress),
+        [Utils.parseAddress(fromAddress)],
+        nativeUtxos,
+        'P',
+        baseFeeWei
+      ) as UnsignedTx;
+      const rawInnerTx = rawImportTx.getTx() as evmSerial.ImportTx;
+      const rawTotalOutput = rawInnerTx.Outs.reduce((sum, out) => sum + out.amount.value(), BigInt(0));
+      const rawFee = BigInt(utxo.amount) - rawTotalOutput;
+
+      assert(paddedFee > rawFee, `Expected padded fee (${paddedFee}) to exceed the unpadded raw fee (${rawFee})`);
+      // Padding is exactly the configured 10% buffer applied to the base fee before estimation.
+      assert.strictEqual(paddedFee, (rawFee * 11000n) / 10000n);
     });
   });