feat(sdk-coin-flrp): enhance transaction builders and utils with new methods

Ticket: WIN-7770

Author: mohd-kashif

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

@@ -35,7 +35,7 @@ import {
   FLARE_ATOMIC_PARSED_PREFIX,
   HEX_ENCODING,
 } from './constants';
-import { createFlexibleHexRegex } from './utils';
+import utils, { createFlexibleHexRegex } from './utils';
 
 /**
  * Flare P-chain atomic transaction builder with FlareJS credential support.
@@ -420,4 +420,58 @@ export abstract class AtomicTransactionBuilder {
       );
     }
   }
+
+  /**
+   * Threshold is an int that names the number of unique signatures required to spend the output.
+   * Must be less than or equal to the length of Addresses.
+   * @param {number}
+   */
+  threshold(value: number): this {
+    this.validateThreshold(value);
+    this.transaction._threshold = value;
+    return this;
+  }
+
+  /**
+   * Validates the threshold
+   * @param threshold
+   */
+  validateThreshold(threshold: number): void {
+    if (!threshold || threshold !== 2) {
+      throw new BuildTransactionError('Invalid transaction: threshold must be set to 2');
+    }
+  }
+
+  /**
+   * fromPubKey is a list of unique addresses that correspond to the private keys that can be used to spend this output.
+   * @param {string | string[]} senderPubKey
+   */
+  // TODO: check the format of the public keys
+  fromPubKey(senderPubKey: string | string[]): this {
+    const pubKeys = senderPubKey instanceof Array ? senderPubKey : [senderPubKey];
+    this.transaction._fromAddresses = pubKeys.map(utils.parseAddress).toString().split(',');
+    return this;
+  }
+
+  /**
+   * Locktime is a long that contains the unix timestamp that this output can be spent after.
+   * The unix timestamp is specific to the second.
+   * @param value
+   */
+  locktime(value: number): this {
+    const locktime = BigInt(value);
+    this.validateLocktime(locktime);
+    this.transaction._locktime = locktime;
+    return this;
+  }
+
+  /**
+   * Validates locktime
+   * @param locktime
+   */
+  validateLocktime(locktime: bigint): void {
+    if (!locktime || locktime < 0n) {
+      throw new BuildTransactionError('Invalid transaction: locktime must be 0 or higher');
+    }
+  }
 }

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

@@ -5,6 +5,7 @@ export { KeyPair } from './keyPair';
 export { Utils };
 export { TransactionBuilderFactory } from './transactionBuilderFactory';
 export { Transaction } from './transaction';
+export { TransactionBuilder } from './transactionBuilder';
 export { AtomicTransactionBuilder } from './atomicTransactionBuilder';
 export { AtomicInCTransactionBuilder } from './atomicInCTransactionBuilder';
 export { ImportInCTxBuilder } from './importInCTxBuilder';

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

@@ -1,51 +1,11 @@
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
-import { NotImplementedError, TransactionType } from '@bitgo/sdk-core';
 import { AtomicTransactionBuilder } from './atomicTransactionBuilder';
-
-// Placeholder builders - basic implementations for testing
-export class ExportTxBuilder extends AtomicTransactionBuilder {
-  protected get transactionType(): TransactionType {
-    return TransactionType.Export;
-  }
-
-  constructor(coinConfig: Readonly<CoinConfig>) {
-    super(coinConfig);
-    // Don't throw error, allow placeholder functionality
-  }
-}
-
-export class ImportTxBuilder extends AtomicTransactionBuilder {
-  protected get transactionType(): TransactionType {
-    return TransactionType.Import;
-  }
-
-  constructor(coinConfig: Readonly<CoinConfig>) {
-    super(coinConfig);
-    // Don't throw error, allow placeholder functionality
-  }
-}
-
-export class ValidatorTxBuilder extends AtomicTransactionBuilder {
-  protected get transactionType(): TransactionType {
-    return TransactionType.AddValidator;
-  }
-
-  constructor(coinConfig: Readonly<CoinConfig>) {
-    super(coinConfig);
-    // Don't throw error, allow placeholder functionality
-  }
-}
-
-export class DelegatorTxBuilder extends AtomicTransactionBuilder {
-  protected get transactionType(): TransactionType {
-    return TransactionType.AddDelegator;
-  }
-
-  constructor(coinConfig: Readonly<CoinConfig>) {
-    super(coinConfig);
-    // Don't throw error, allow placeholder functionality
-  }
-}
+import { ImportInCTxBuilder } from './importInCTxBuilder';
+import { ValidatorTxBuilder } from './validatorTxBuilder';
+import { PermissionlessValidatorTxBuilder } from './permissionlessValidatorTxBuilder';
+import { ExportInCTxBuilder } from './exportInCTxBuilder';
+import { ExportInPTxBuilder } from './exportInPTxBuilder';
+import { ImportInPTxBuilder } from './importInPTxBuilder';
 
 /**
  * Factory for Flare P-chain transaction builders
@@ -70,7 +30,7 @@ export class TransactionBuilderFactory {
 
     // Create a mock export builder for now
     // In the future, this will parse the transaction and determine the correct type
-    const builder = new ExportTxBuilder(this._coinConfig);
+    const builder = new ExportInPTxBuilder(this._coinConfig);
 
     // Initialize with the hex data (placeholder)
     builder.initBuilder({ txHex });
@@ -79,21 +39,56 @@ export class TransactionBuilderFactory {
   }
 
   /**
-   * Create a transaction builder for a specific type
-   * @param type - Transaction type
+   * Initialize Validator builder
+   *
+   * @returns {ValidatorTxBuilder} the builder initialized
    */
-  getBuilder(type: TransactionType): AtomicTransactionBuilder {
-    switch (type) {
-      case TransactionType.Export:
-        return new ExportTxBuilder(this._coinConfig);
-      case TransactionType.Import:
-        return new ImportTxBuilder(this._coinConfig);
-      case TransactionType.AddValidator:
-        return new ValidatorTxBuilder(this._coinConfig);
-      case TransactionType.AddDelegator:
-        return new DelegatorTxBuilder(this._coinConfig);
-      default:
-        throw new NotImplementedError(`Transaction type ${type} not supported`);
-    }
+  getValidatorBuilder(): ValidatorTxBuilder {
+    return new ValidatorTxBuilder(this._coinConfig);
+  }
+
+  /**
+   * Initialize Permissionless Validator builder
+   *
+   * @returns {PermissionlessValidatorTxBuilder} the builder initialized
+   */
+  getPermissionlessValidatorTxBuilder(): PermissionlessValidatorTxBuilder {
+    return new PermissionlessValidatorTxBuilder(this._coinConfig);
+  }
+
+  /**
+   * Export Cross chain transfer
+   *
+   * @returns {ExportInPTxBuilder} the builder initialized
+   */
+  getExportBuilder(): ExportInPTxBuilder {
+    return new ExportInPTxBuilder(this._coinConfig);
+  }
+
+  /**
+   * Import Cross chain transfer
+   *
+   * @returns {ImportInPTxBuilder} the builder initialized
+   */
+  getImportBuilder(): ImportInPTxBuilder {
+    return new ImportInPTxBuilder(this._coinConfig);
+  }
+
+  /**
+   * Import in C chain Cross chain transfer
+   *
+   * @returns {ImportInCTxBuilder} the builder initialized
+   */
+  getImportInCBuilder(): ImportInCTxBuilder {
+    return new ImportInCTxBuilder(this._coinConfig);
+  }
+
+  /**
+   * Export in C chain Cross chain transfer
+   *
+   * @returns {ExportInCTxBuilder} the builder initialized
+   */
+  getExportInCBuilder(): ExportInCTxBuilder {
+    return new ExportInCTxBuilder(this._coinConfig);
   }
 }

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

@@ -1,5 +1,5 @@
 import { TransferableOutput } from '@flarenetwork/flarejs';
-import { bech32 } from 'bech32';
+import * as bech32 from 'bech32';
 import bs58 from 'bs58';
 import {
   BaseUtils,
@@ -53,6 +53,27 @@ export class Utils implements BaseUtils {
     return `${prefix}-${bech32.encode(hrp, words)}`;
   };
 
+  /**
+   * Convert a NodeID string to a Buffer. This is a Flare-specific implementation
+   * that doesn't rely on the Avalanche dependency.
+   *
+   * NodeIDs in Flare follow the format: NodeID-<base58_string>
+   *
+   * @param {string} nodeID - The NodeID string to convert
+   * @returns {Buffer} - The decoded NodeID as a Buffer
+   */
+  public NodeIDStringToBuffer = (nodeID: string): Buffer => {
+    // Remove 'NodeID-' prefix if present
+    const cleanNodeID = nodeID.startsWith('NodeID-') ? nodeID.slice(7) : nodeID;
+
+    try {
+      // Decode base58 string to buffer
+      return Buffer.from(bs58.decode(cleanNodeID));
+    } catch (error) {
+      throw new Error(`Invalid NodeID format: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  };
+
   public includeIn(walletAddresses: string[], otxoOutputAddresses: string[]): boolean {
     return walletAddresses.map((a) => otxoOutputAddresses.includes(a)).reduce((a, b) => a && b, true);
   }
@@ -126,6 +147,7 @@ export class Utils implements BaseUtils {
     }
   }
 
+  // TODO add test cases for this method
   public parseAddress = (address: string): Buffer => {
     return this.stringToAddress(address);
   };