chore: unit tests and credential change

TICKET: WIN-6322

Author: yogeshwar-bitgo

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

@@ -35,6 +35,7 @@ import {
 } from '@bitgo/sdk-core';
 import { BaseCoin as StaticsBaseCoin, CoinFamily } from '@bitgo/statics';
 import { Hash } from 'crypto';
+import { KeyPair as FlrpKeyPair } from './lib/keyPair';
 
 export class Flrp extends BaseCoin {
   protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
@@ -93,7 +94,15 @@ export class Flrp extends BaseCoin {
 
   // Key methods (stubs)
   generateKeyPair(): KeyPair {
-    throw new Error('generateKeyPair not implemented');
+    const keyPair = new FlrpKeyPair();
+    const keys = keyPair.getKeys();
+    if (!keys.prv) {
+      throw new Error('Failed to generate private key');
+    }
+    return {
+      pub: keys.pub,
+      prv: keys.prv,
+    };
   }
   generateRootKeyPair(): KeyPair {
     throw new Error('generateRootKeyPair not implemented');

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

@@ -1,9 +1,14 @@
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { BuildTransactionError, TransactionType } from '@bitgo/sdk-core';
+import { Credential, Signature } from '@flarenetwork/flarejs';
+
+// Constants for signature handling
+const SECP256K1_SIGNATURE_LENGTH = 65;
 
 /**
- * Minimal placeholder for Flare P-chain atomic transaction building.
- * This will be expanded with proper Flare P-chain logic (inputs/outputs/credentials, UTXO handling, fees, etc.).
+ * 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 {
   protected readonly _coinConfig: Readonly<CoinConfig>;
@@ -53,13 +58,88 @@ export abstract class AtomicTransactionBuilder {
     }
   }
 
+  /**
+   * Validates that credentials array is properly formed
+   * @param credentials - Array of credentials to validate
+   */
+  protected validateCredentials(credentials: Credential[]): void {
+    if (!Array.isArray(credentials)) {
+      throw new BuildTransactionError('Credentials must be an array');
+    }
+
+    credentials.forEach((credential, index) => {
+      if (!(credential instanceof Credential)) {
+        throw new BuildTransactionError(`Invalid credential at index ${index}`);
+      }
+    });
+  }
+
   /**
    * Placeholder that should assemble inputs/outputs and credentials once UTXO + key logic is implemented.
    */
-  protected createInputOutput(_total: bigint): { inputs: unknown[]; outputs: unknown[]; credentials: unknown[] } {
+  protected createInputOutput(_total: bigint): { inputs: unknown[]; outputs: unknown[]; credentials: Credential[] } {
     return { inputs: [], outputs: [], credentials: [] };
   }
 
+  /**
+   * Flare equivalent of Avalanche's SelectCredentialClass
+   * Creates a credential with the provided signatures
+   *
+   * @param credentialId - The credential ID (not used in FlareJS but kept for compatibility)
+   * @param signatures - Array of signature hex strings or empty strings for placeholders
+   * @returns Credential instance
+   */
+  protected createFlareCredential(_credentialId: number, signatures: string[]): Credential {
+    if (!Array.isArray(signatures)) {
+      throw new BuildTransactionError('Signatures must be an array');
+    }
+
+    if (signatures.length === 0) {
+      throw new BuildTransactionError('Signatures array cannot be empty');
+    }
+
+    const sigs = signatures.map((sig, index) => {
+      // Handle empty/placeholder signatures
+      if (!sig || sig.length === 0) {
+        return new Signature(new Uint8Array(SECP256K1_SIGNATURE_LENGTH));
+      }
+
+      // Validate hex string format
+      const cleanSig = sig.startsWith('0x') ? sig.slice(2) : sig;
+      if (!/^[0-9a-fA-F]*$/.test(cleanSig)) {
+        throw new BuildTransactionError(`Invalid hex signature at index ${index}: contains non-hex characters`);
+      }
+
+      // Convert to buffer and validate length
+      const sigBuffer = Buffer.from(cleanSig, 'hex');
+      if (sigBuffer.length > SECP256K1_SIGNATURE_LENGTH) {
+        throw new BuildTransactionError(
+          `Signature too long at index ${index}: ${sigBuffer.length} bytes (max ${SECP256K1_SIGNATURE_LENGTH})`
+        );
+      }
+
+      // Create fixed-length buffer and copy signature data
+      const fixedLengthBuffer = Buffer.alloc(SECP256K1_SIGNATURE_LENGTH);
+      sigBuffer.copy(fixedLengthBuffer);
+
+      try {
+        return new Signature(new Uint8Array(fixedLengthBuffer));
+      } catch (error) {
+        throw new BuildTransactionError(
+          `Failed to create signature at index ${index}: ${error instanceof Error ? error.message : 'unknown error'}`
+        );
+      }
+    });
+
+    try {
+      return new Credential(sigs);
+    } catch (error) {
+      throw new BuildTransactionError(
+        `Failed to create credential: ${error instanceof Error ? error.message : 'unknown error'}`
+      );
+    }
+  }
+
   /**
    * Base initBuilder used by concrete builders. For now just returns this so fluent API works.
    */

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

@@ -143,12 +143,24 @@ export class ExportInCTxBuilder extends AtomicInCTransactionBuilder {
    * @protected
    */
   protected buildFlareTransaction(): void {
-    if (this.transaction.hasCredentials) return; // placeholder: credentials not yet implemented
-    if (this._amount === undefined) throw new Error('amount is required');
-    if (this.transaction._fromAddresses.length !== 1) throw new Error('sender is one and required');
-    if (this.transaction._to.length === 0) throw new Error('to is required');
-    if (!this.transaction._fee.feeRate) throw new Error('fee rate is required');
-    if (this._nonce === undefined) throw new Error('nonce is required');
+    if (this.transaction.hasCredentials) {
+      return; // placeholder: credentials not yet implemented
+    }
+    if (this._amount === undefined) {
+      throw new Error('amount is required');
+    }
+    if (this.transaction._fromAddresses.length !== 1) {
+      throw new Error('sender is one and required');
+    }
+    if (this.transaction._to.length === 0) {
+      throw new Error('to is required');
+    }
+    if (!this.transaction._fee.feeRate) {
+      throw new Error('fee rate is required');
+    }
+    if (this._nonce === undefined) {
+      throw new Error('nonce is required');
+    }
 
     // Compose placeholder unsigned tx shape
     const feeRate = BigInt(this.transaction._fee.feeRate);

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

@@ -1,11 +1,13 @@
+import { coins } from '@bitgo/statics';
+import * as assert from 'assert';
+import { Flrp } from '../../src/flrp';
 import { BitGoBase } from '@bitgo/sdk-core';
 import { TestBitGo, TestBitGoAPI } from '@bitgo/sdk-test';
 import { BitGoAPI } from '@bitgo/sdk-api';
-import { Flrp } from '../../src/flrp';
-import { coins } from '@bitgo/statics';
 
 describe('Flrp', function () {
   let bitgo: TestBitGoAPI;
+  const staticsCoin = coins.get('flrp');
 
   before(function () {
     bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });
@@ -17,18 +19,85 @@ describe('Flrp', function () {
     );
   });
 
-  it('createInstance returns a Flrp instance', function () {
-    const staticsCoin = coins.get('flrp');
-    const coin = Flrp.createInstance(bitgo as unknown as BitGoBase, staticsCoin);
-    coin.should.be.instanceOf(Flrp);
+  describe('createInstance', function () {
+    it('should return a Flrp instance', function () {
+      const coin = Flrp.createInstance(bitgo as unknown as BitGoBase, staticsCoin);
+      assert.ok(coin instanceof Flrp);
+    });
+
+    it('should produce distinct objects on multiple calls', function () {
+      const a = Flrp.createInstance(bitgo as unknown as BitGoBase, staticsCoin);
+      const b = Flrp.createInstance(bitgo as unknown as BitGoBase, staticsCoin);
+      assert.notStrictEqual(a, b);
+      assert.ok(a instanceof Flrp);
+      assert.ok(b instanceof Flrp);
+    });
   });
 
-  it('multiple createInstance calls produce distinct objects', function () {
-    const sc = coins.get('flrp');
-    const a = Flrp.createInstance(bitgo as unknown as BitGoBase, sc);
-    const b = Flrp.createInstance(bitgo as unknown as BitGoBase, sc);
-    a.should.not.equal(b);
-    a.should.be.instanceOf(Flrp);
-    b.should.be.instanceOf(Flrp);
+  describe('coin properties', function () {
+    let coin: Flrp;
+
+    beforeEach(function () {
+      coin = Flrp.createInstance(bitgo as unknown as BitGoBase, staticsCoin) as Flrp;
+    });
+
+    it('should have correct coin family', function () {
+      assert.strictEqual(coin.getFamily(), staticsCoin.family);
+    });
+
+    it('should have correct coin name', function () {
+      assert.strictEqual(coin.getFullName(), staticsCoin.fullName);
+    });
+
+    it('should have correct base factor', function () {
+      assert.strictEqual(coin.getBaseFactor(), Math.pow(10, staticsCoin.decimalPlaces));
+    });
+
+    it('should validate addresses using utils', function () {
+      const validAddress = 'flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh';
+      const result = coin.isValidAddress(validAddress);
+      assert.strictEqual(typeof result, 'boolean');
+    });
+
+    it('should generate key pairs', function () {
+      const keyPair = coin.generateKeyPair();
+      assert.ok('pub' in keyPair);
+      assert.ok('prv' in keyPair);
+      if (keyPair.pub && keyPair.prv) {
+        assert.strictEqual(typeof keyPair.pub, 'string');
+        assert.strictEqual(typeof keyPair.prv, 'string');
+      }
+    });
+  });
+
+  describe('error handling', function () {
+    it('should handle construction with invalid parameters', function () {
+      assert.throws(() => Flrp.createInstance(null as unknown as BitGoBase, staticsCoin));
+      assert.throws(() => Flrp.createInstance(bitgo as unknown as BitGoBase, null as unknown as typeof staticsCoin));
+    });
+  });
+
+  describe('inheritance and methods', function () {
+    let coin: Flrp;
+
+    beforeEach(function () {
+      coin = Flrp.createInstance(bitgo as unknown as BitGoBase, staticsCoin) as Flrp;
+    });
+
+    it('should have required base coin methods', function () {
+      assert.ok('getFamily' in coin);
+      assert.ok('getFullName' in coin);
+      assert.ok('getBaseFactor' in coin);
+      assert.ok('isValidAddress' in coin);
+      assert.ok('generateKeyPair' in coin);
+    });
+
+    it('should handle address validation consistently', function () {
+      const validAddress = 'flare1test';
+      const invalidAddress = 'invalid-address';
+
+      assert.strictEqual(typeof coin.isValidAddress(validAddress), 'boolean');
+      assert.strictEqual(typeof coin.isValidAddress(invalidAddress), 'boolean');
+    });
   });
 });