feat(sdk-coin-flrp): refactored transaction builder

Ticket: WIN-7770

Author: mohd-kashif

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

@@ -2,12 +2,13 @@ import { AtomicTransactionBuilder } from './atomicTransactionBuilder';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import utils from './utils';
 import { BuildTransactionError } from '@bitgo/sdk-core';
+import { Transaction } from './transaction';
 
-interface FlareChainNetworkMeta {
-  blockchainID?: string; // P-chain id (external)
-  cChainBlockchainID?: string; // C-chain id (local)
-  [k: string]: unknown;
-}
+// interface FlareChainNetworkMeta {
+//   blockchainID?: string; // P-chain id (external)
+//   cChainBlockchainID?: string; // C-chain id (local)
+//   [k: string]: unknown;
+// }
 
 interface FeeShape {
   fee?: string; // legacy
@@ -41,12 +42,12 @@ export abstract class AtomicInCTransactionBuilder extends AtomicTransactionBuild
   /**
    * Recreate builder state from raw tx (hex). Flare C-chain support TBD; for now validate & stash.
    */
-  protected fromImplementation(rawTransaction: string): { _tx?: unknown } {
+  protected fromImplementation(rawTransaction: string): Transaction {
     // If utils has validateRawTransaction use it; otherwise basic check
     if ((utils as unknown as { validateRawTransaction?: (r: string) => void }).validateRawTransaction) {
       (utils as unknown as { validateRawTransaction: (r: string) => void }).validateRawTransaction(rawTransaction);
     }
-    this.transaction.setTransaction(rawTransaction);
+    // this.transaction.setTransaction(rawTransaction);
     return this.transaction;
   }
 
@@ -57,13 +58,8 @@ export abstract class AtomicInCTransactionBuilder extends AtomicTransactionBuild
   }
 
   private initializeChainIds(): void {
-    const meta = this.transaction._network as FlareChainNetworkMeta;
-    if (meta?.blockchainID) {
-      this._externalChainId = utils.cb58Decode(meta.blockchainID);
-    }
-    if (meta?.cChainBlockchainID) {
-      this.transaction._blockchainID = utils.cb58Decode(meta.cChainBlockchainID);
-    }
+    this._externalChainId = utils.cb58Decode(this._network.blockchainID);
+    this._blockchainID = utils.cb58Decode(this._network.cChainBlockchainID);
   }
 
   private setFeeRate(n: bigint): void {

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

@@ -1,22 +1,20 @@
-import { BaseCoin as CoinConfig } from '@bitgo/statics';
-import { BuildTransactionError, TransactionType, BaseTransaction } from '@bitgo/sdk-core';
+import { BaseCoin as CoinConfig, FlareNetwork } from '@bitgo/statics';
+import { BuildTransactionError, TransactionType, BaseTransaction, BaseKey } from '@bitgo/sdk-core';
 import { Credential, Signature, TransferableInput, TransferableOutput } from '@flarenetwork/flarejs';
-import { TransactionExplanation, DecodedUtxoObj } from './iface';
+import { TransactionExplanation, DecodedUtxoObj, BaseAddress } from './iface';
+import { KeyPair } from './keyPair';
+import BigNumber from 'bignumber.js';
 import {
   ASSET_ID_LENGTH,
   TRANSACTION_ID_HEX_LENGTH,
   PRIVATE_KEY_HEX_LENGTH,
   SECP256K1_SIGNATURE_LENGTH,
   TRANSACTION_ID_PREFIX,
-  DEFAULT_NETWORK_ID,
-  EMPTY_BUFFER_SIZE,
   HEX_PREFIX,
   HEX_PREFIX_LENGTH,
   DECIMAL_RADIX,
   SIGNING_METHOD,
   AMOUNT_STRING_ZERO,
-  DEFAULT_LOCKTIME,
-  DEFAULT_THRESHOLD,
   ZERO_BIGINT,
   ZERO_NUMBER,
   ERROR_AMOUNT_POSITIVE,
@@ -35,51 +33,41 @@ import {
   FLARE_ATOMIC_PARSED_PREFIX,
   HEX_ENCODING,
 } from './constants';
-import { createFlexibleHexRegex } from './utils';
+import utils, { createFlexibleHexRegex } from './utils';
+import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from './transaction';
 
 /**
  * Flare P-chain atomic transaction builder with FlareJS credential support.
  * This provides the foundation for building Flare P-chain transactions with proper
  * credential handling using FlareJS Credential and Signature classes.
  */
-export abstract class AtomicTransactionBuilder {
+export abstract class AtomicTransactionBuilder extends TransactionBuilder {
   protected readonly _coinConfig: Readonly<CoinConfig>;
   // External chain id (destination) for export transactions
   protected _externalChainId: Buffer | undefined;
 
   protected _utxos: DecodedUtxoObj[] = [];
-
-  protected transaction: {
-    _network: Record<string, unknown>;
-    _networkID: number;
-    _blockchainID: Buffer;
-    _assetId: Buffer;
-    _fromAddresses: string[];
-    _to: string[];
-    _locktime: bigint;
-    _threshold: number;
-    _fee: { fee: string; feeRate?: string; size?: number };
-    hasCredentials: boolean;
-    _tx?: unknown;
-    _signature?: unknown;
-    setTransaction: (tx: unknown) => void;
-  } = {
-    _network: {},
-    _networkID: DEFAULT_NETWORK_ID,
-    _blockchainID: Buffer.alloc(EMPTY_BUFFER_SIZE),
-    _assetId: Buffer.alloc(EMPTY_BUFFER_SIZE),
-    _fromAddresses: [],
-    _to: [],
-    _locktime: DEFAULT_LOCKTIME,
-    _threshold: DEFAULT_THRESHOLD,
-    _fee: { fee: AMOUNT_STRING_ZERO },
-    hasCredentials: false,
-    setTransaction: function (_tx: unknown) {
-      this._tx = _tx;
-    },
-  };
+  // TODO check _flrpTransaction type
+  protected _flrpTransaction: any;
+
+  public _network: FlareNetwork;
+  public _networkID: number;
+  public _blockchainID: Buffer;
+  public _assetId: Buffer;
+  public _fromAddresses: string[];
+  public _to: string[];
+  public _locktime: bigint;
+  public _threshold: number;
+  public _fee: { fee: string; feeRate?: string; size?: number };
+  public hasCredentials: boolean;
+  public _tx?: unknown;
+  public _signature?: unknown;
+  public _type: TransactionType;
+  public _rewardAddresses: Buffer[];
 
   constructor(coinConfig: Readonly<CoinConfig>) {
+    super(coinConfig);
     this._coinConfig = coinConfig;
   }
 
@@ -91,8 +79,8 @@ export abstract class AtomicTransactionBuilder {
    */
   protected getAssetId(): Buffer {
     // Use the asset ID from transaction if already set
-    if (this.transaction._assetId && this.transaction._assetId.length > 0) {
-      return this.transaction._assetId;
+    if (this._assetId && this._assetId.length > 0) {
+      return this._assetId;
     }
 
     // For native FLR transactions, return zero-filled buffer as placeholder
@@ -218,7 +206,7 @@ export abstract class AtomicTransactionBuilder {
         assetID: this.getAssetId(),
         output: {
           amount: changeAmount,
-          addresses: this.transaction._fromAddresses,
+          addresses: this._fromAddresses,
           threshold: 1,
           locktime: 0n,
         },
@@ -326,8 +314,8 @@ export abstract class AtomicTransactionBuilder {
       };
 
       // Store signature for FlareJS compatibility
-      this.transaction._signature = signature;
-      this.transaction.hasCredentials = true;
+      this._signature = signature;
+      this.hasCredentials = true;
 
       return this;
     } catch (error) {
@@ -356,7 +344,7 @@ export abstract class AtomicTransactionBuilder {
         _type: this.transactionType,
         signature: [] as string[],
 
-        fromAddresses: this.transaction._fromAddresses,
+        fromAddresses: this._fromAddresses,
         validationErrors: [],
 
         // FlareJS methods with atomic support
@@ -374,7 +362,7 @@ export abstract class AtomicTransactionBuilder {
           id: `${FLARE_ATOMIC_PREFIX}${Date.now()}`,
           changeOutputs: [],
           changeAmount: AMOUNT_STRING_ZERO,
-          fee: { fee: this.transaction._fee.fee },
+          fee: { fee: this._fee.fee },
         }),
 
         isTransactionForCChain: false,
@@ -383,7 +371,7 @@ export abstract class AtomicTransactionBuilder {
         },
         inputs: () => [],
         outputs: () => [],
-        fee: () => ({ fee: this.transaction._fee.fee }),
+        fee: () => ({ fee: this._fee.fee }),
         feeRate: () => 0,
         id: () => `${FLARE_ATOMIC_PREFIX}${Date.now()}`,
         type: this.transactionType,
@@ -412,12 +400,76 @@ export abstract class AtomicTransactionBuilder {
         id: `${FLARE_ATOMIC_PARSED_PREFIX}${Date.now()}`,
         changeOutputs: [],
         changeAmount: AMOUNT_STRING_ZERO,
-        fee: { fee: this.transaction._fee.fee },
+        fee: { fee: this._fee.fee },
       };
     } catch (error) {
       throw new BuildTransactionError(
         `${ERROR_ENHANCED_PARSE_FAILED}: ${error instanceof Error ? error.message : ERROR_UNKNOWN}`
       );
     }
   }
+
+  /** @inheritdoc */
+  protected signImplementation({ key }: BaseKey): BaseTransaction {
+    this._signer.push(new KeyPair({ prv: key }));
+    return this.transaction;
+  }
+
+  /** @inheritdoc */
+  protected async buildImplementation(): Promise<Transaction> {
+    this.buildFlareTransaction();
+    this.transaction.setTransactionType(this.transactionType);
+    if (this.hasSigner) {
+      this._signer.forEach((keyPair) => this.transaction.sign(keyPair));
+    }
+    return this.transaction;
+  }
+
+  /**
+   * Builds the avax transaction. transaction field is changed.
+   */
+  protected abstract buildFlareTransaction(): void;
+
+  /**
+   * Getter for know if build should sign
+   */
+  get hasSigner(): boolean {
+    return this._signer !== undefined && this._signer.length > 0;
+  }
+
+  /** @inheritdoc */
+  validateKey({ key }: BaseKey): void {
+    if (!new KeyPair({ prv: key })) {
+      throw new BuildTransactionError('Invalid key');
+    }
+  }
+
+  /** @inheritdoc */
+  validateAddress(address: BaseAddress, addressFormat?: string): void {
+    if (!utils.isValidAddress(address.address)) {
+      throw new BuildTransactionError('Invalid address');
+    }
+  }
+
+  /** @inheritdoc */
+  validateValue(value: BigNumber): void {
+    if (value.isLessThan(0)) {
+      throw new BuildTransactionError('Value cannot be less than zero');
+    }
+  }
+
+  /**
+   * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+   * It overrides abstract method from BaseTransactionBuilder
+   *
+   * @param rawTransaction Transaction in any format
+   */
+  validateRawTransaction(rawTransaction: string): void {
+    utils.validateRawTransaction(rawTransaction);
+  }
+
+  /** @inheritdoc */
+  validateTransaction(transaction?: Transaction): void {
+    // throw new NotImplementedError('validateTransaction not implemented');
+  }
 }

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

@@ -15,6 +15,7 @@ import {
   NETWORK_ID_PROP,
   BLOCKCHAIN_ID_PROP,
 } from './constants';
+import { Transaction } from './transaction';
 
 // Lightweight interface placeholders replacing Avalanche SDK transaction shapes
 interface FlareExportInputShape {
@@ -111,7 +112,7 @@ export class ExportInCTxBuilder extends AtomicInCTransactionBuilder {
     if (unsigned.networkId !== this.transaction._networkID) {
       throw new Error('Network ID mismatch');
     }
-    if (!unsigned.sourceBlockchainId.equals(this.transaction._blockchainID)) {
+    if (!unsigned.sourceBlockchainId.equals(this._blockchainID)) {
       throw new Error('Blockchain ID mismatch');
     }
     if (unsigned.outputs.length !== 1) {
@@ -122,23 +123,23 @@ export class ExportInCTxBuilder extends AtomicInCTransactionBuilder {
     }
     const out = unsigned.outputs[0];
     const inp = unsigned.inputs[0];
-    if (!out.assetId.equals(this.transaction._assetId) || !inp.assetId.equals(this.transaction._assetId)) {
+    if (!out.assetId.equals(this._assetId) || !inp.assetId.equals(this._assetId)) {
       throw new Error('AssetID mismatch');
     }
-    this.transaction._to = out.addresses;
+    this._to = out.addresses;
     this._amount = out.amount;
     const fee = inp.amount - out.amount;
     if (fee < 0n) {
       throw new BuildTransactionError('Computed fee is negative');
     }
     const fixed = this.fixedFee;
-    const feeRate = fee - fixed;
-    this.transaction._fee.feeRate = feeRate.toString();
+    const feeRate = Number(fee - fixed);
+    this.transaction._fee.feeRate = feeRate;
     this.transaction._fee.fee = fee.toString();
     this.transaction._fee.size = 1;
     this.transaction._fromAddresses = [inp.address];
     this._nonce = inp.nonce;
-    this.transaction.setTransaction(raw);
+    // this.transaction.setTransaction(raw.unsignedTx);
     return this;
   }
 
@@ -225,28 +226,30 @@ export class ExportInCTxBuilder extends AtomicInCTransactionBuilder {
     // Create FlareJS-ready unsigned transaction
     const unsigned: FlareUnsignedExportTx = {
       networkId: this.transaction._networkID,
-      sourceBlockchainId: this.transaction._blockchainID,
+      sourceBlockchainId: this._blockchainID,
       destinationBlockchainId: this._externalChainId || Buffer.alloc(ASSET_ID_LENGTH),
       inputs: [input],
       outputs: [output],
     };
 
+    console.log('Unsigned Export Tx:', unsigned);
+
     // Create signed transaction structure
-    const signed: FlareSignedExportTx = { unsignedTx: unsigned, credentials: [] };
+    // const signed: FlareSignedExportTx = { unsignedTx: unsigned, credentials: [] };
 
     // Update transaction fee information
     this.transaction._fee.fee = totalFee.toString();
     this.transaction._fee.size = 1;
 
     // Set the enhanced transaction
-    this.transaction.setTransaction(signed);
+    // this.transaction.setTransaction(signed);
   }
 
   /** @inheritdoc */
-  protected fromImplementation(raw: string | RawFlareExportTx): { _tx?: unknown } {
+  protected fromImplementation(raw: string | RawFlareExportTx): Transaction {
     if (typeof raw === STRING_TYPE) {
       // Future: parse hex or serialized form. For now treat as opaque raw tx.
-      this.transaction.setTransaction(raw);
+      // this.transaction.setTransaction(raw);
       return this.transaction;
     }
     return this.initBuilder(raw as RawFlareExportTx).transaction;

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

@@ -126,7 +126,7 @@ export class ExportInPTxBuilder extends AtomicTransactionBuilder {
       ],
 
       // Enhanced fee structure for P-chain operations
-      fee: BigInt(this.transaction._fee.fee) || BigInt(DEFAULT_BASE_FEE), // Default P-chain fee
+      fee: BigInt(this._fee.fee) || BigInt(DEFAULT_BASE_FEE), // Default P-chain fee
 
       // Credential placeholders ready for FlareJS integration
       credentials: this.transaction._fromAddresses.map(() => ({
@@ -139,8 +139,10 @@ export class ExportInPTxBuilder extends AtomicTransactionBuilder {
       memo: Buffer.alloc(EMPTY_BUFFER_SIZE),
     };
 
+    console.log('Enhanced P-chain Export Tx:', enhancedExportTx);
+
     // Store the transaction structure
-    this.transaction.setTransaction(enhancedExportTx);
+    // this.transaction.setTransaction(enhancedExportTx);
   }
 
   /**

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

@@ -138,3 +138,7 @@ export interface FlrpSpendOptions {
   memo?: Uint8Array; // FlareJS memo format (byte array)
   locktime?: bigint;
 }
+
+export interface BaseAddress {
+  address: string;
+}