@bitgo-beta/sdk-coin-flrp 1.0.1-beta.2 → 1.0.1-beta.20

package/dist/src/lib/exportInCTxBuilder.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportInCTxBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const atomicInCTransactionBuilder_1 = require("./atomicInCTransactionBuilder");
+class ExportInCTxBuilder extends atomicInCTransactionBuilder_1.AtomicInCTransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    /**
+     * Utxos are not required in Export Tx in C-Chain.
+     * Override utxos to prevent used by throwing a error.
+     *
+     * @param {DecodedUtxoObj[]} value ignored
+     */
+    utxos(_value) {
+        throw new sdk_core_1.BuildTransactionError('utxos are not required in Export Tx in C-Chain');
+    }
+    /**
+     * Amount is a long 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 {BN | string} amount The withdrawal amount
+     */
+    amount(amount) {
+        const n = typeof amount === 'bigint' ? amount : BigInt(amount);
+        this.validateAmount(n);
+        this._amount = n;
+        return this;
+    }
+    /**
+     * Set the nonce of C-Chain sender address
+     *
+     * @param {number | string} nonce - number that can be only used once
+     */
+    nonce(nonce) {
+        const n = typeof nonce === 'bigint' ? nonce : BigInt(nonce);
+        this.validateNonce(n);
+        this._nonce = n;
+        return this;
+    }
+    /**
+     * Export tx target P wallet.
+     *
+     * @param pAddresses
+     */
+    to(pAddresses) {
+        const pubKeys = Array.isArray(pAddresses) ? pAddresses : pAddresses.split('~');
+        // For now ensure they are stored as bech32 / string addresses directly
+        this.transaction._to = pubKeys.map((a) => a.toString());
+        return this;
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.Export;
+    }
+    initBuilder(raw) {
+        // Basic shape validation
+        const unsigned = raw.unsignedTx;
+        if (unsigned.networkId !== this.transaction._networkID) {
+            throw new Error('Network ID mismatch');
+        }
+        if (!unsigned.sourceBlockchainId.equals(this.transaction._blockchainID)) {
+            throw new Error('Blockchain ID mismatch');
+        }
+        if (unsigned.outputs.length !== 1) {
+            throw new sdk_core_1.BuildTransactionError('Transaction can have one output');
+        }
+        if (unsigned.inputs.length !== 1) {
+            throw new sdk_core_1.BuildTransactionError('Transaction can have one input');
+        }
+        const out = unsigned.outputs[0];
+        const inp = unsigned.inputs[0];
+        if (!out.assetId.equals(this.transaction._assetId) || !inp.assetId.equals(this.transaction._assetId)) {
+            throw new Error('AssetID mismatch');
+        }
+        this.transaction._to = out.addresses;
+        this._amount = out.amount;
+        const fee = inp.amount - out.amount;
+        if (fee < 0n) {
+            throw new sdk_core_1.BuildTransactionError('Computed fee is negative');
+        }
+        const fixed = this.fixedFee;
+        const feeRate = fee - fixed;
+        this.transaction._fee.feeRate = feeRate.toString();
+        this.transaction._fee.fee = fee.toString();
+        this.transaction._fee.size = 1;
+        this.transaction._fromAddresses = [inp.address];
+        this._nonce = inp.nonce;
+        this.transaction.setTransaction(raw);
+        return this;
+    }
+    // For parity with Avalanche builder interfaces; always returns true for placeholder
+    //TODO: WIN-6322
+    static verifyTxType(_tx) {
+        return true;
+    }
+    verifyTxType(_tx) {
+        return ExportInCTxBuilder.verifyTxType(_tx);
+    }
+    /**
+     * Build the export in C-chain transaction
+     * @protected
+     */
+    buildFlareTransaction() {
+        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);
+        const fixed = this.fixedFee;
+        const totalFee = feeRate + fixed;
+        const input = {
+            address: this.transaction._fromAddresses[0],
+            amount: this._amount + totalFee,
+            assetId: this.transaction._assetId,
+            nonce: this._nonce,
+        };
+        const output = {
+            addresses: this.transaction._to,
+            amount: this._amount,
+            assetId: this.transaction._assetId,
+        };
+        const unsigned = {
+            networkId: this.transaction._networkID,
+            sourceBlockchainId: this.transaction._blockchainID,
+            destinationBlockchainId: this._externalChainId || Buffer.alloc(0),
+            inputs: [input],
+            outputs: [output],
+        };
+        const signed = { unsignedTx: unsigned, credentials: [] };
+        this.transaction._fee.fee = totalFee.toString();
+        this.transaction._fee.size = 1;
+        this.transaction.setTransaction(signed);
+    }
+    /** @inheritdoc */
+    fromImplementation(raw) {
+        if (typeof raw === 'string') {
+            // Future: parse hex or serialized form. For now treat as opaque raw tx.
+            this.transaction.setTransaction(raw);
+            return this.transaction;
+        }
+        return this.initBuilder(raw).transaction;
+    }
+    /**
+     * Check the amount is positive.
+     * @param amount
+     */
+    validateNonce(nonce) {
+        if (nonce < 0n) {
+            throw new sdk_core_1.BuildTransactionError('Nonce must be greater or equal than 0');
+        }
+    }
+}
+exports.ExportInCTxBuilder = ExportInCTxBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"exportInCTxBuilder.js","sourceRoot":"","sources":["../../../src/lib/exportInCTxBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BuildTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { AtomicInCTransactionBuilder } from './atomicInCTransactionBuilder';\n\n// Lightweight interface placeholders replacing Avalanche SDK transaction shapes\ninterface FlareExportInputShape {\n  address: string;\n  amount: bigint; // includes exported amount + fee\n  assetId: Buffer;\n  nonce: bigint;\n}\n\ninterface FlareExportOutputShape {\n  addresses: string[]; // destination P-chain addresses\n  amount: bigint; // exported amount\n  assetId: Buffer;\n}\n\ninterface FlareUnsignedExportTx {\n  networkId: number;\n  sourceBlockchainId: Buffer; // C-chain id\n  destinationBlockchainId: Buffer; // P-chain id\n  inputs: FlareExportInputShape[];\n  outputs: FlareExportOutputShape[];\n}\n\ninterface FlareSignedExportTx {\n  unsignedTx: FlareUnsignedExportTx;\n  // credentials placeholder\n  credentials: unknown[];\n}\n\ntype RawFlareExportTx = FlareSignedExportTx; // for now treat them the same\n\nexport class ExportInCTxBuilder extends AtomicInCTransactionBuilder {\n  private _amount?: bigint;\n  private _nonce?: bigint;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /**\n   * Utxos are not required in Export Tx in C-Chain.\n   * Override utxos to prevent used by throwing a error.\n   *\n   * @param {DecodedUtxoObj[]} value ignored\n   */\n  utxos(_value: unknown[]): this {\n    throw new BuildTransactionError('utxos are not required in Export Tx in C-Chain');\n  }\n\n  /**\n   * Amount is a long that specifies the quantity of the asset that this output owns. Must be positive.\n   * The transaction output amount add a fixed fee that will be paid upon import.\n   *\n   * @param {BN | string} amount The withdrawal amount\n   */\n  amount(amount: bigint | number | string): this {\n    const n = typeof amount === 'bigint' ? amount : BigInt(amount);\n    this.validateAmount(n);\n    this._amount = n;\n    return this;\n  }\n\n  /**\n   * Set the nonce of C-Chain sender address\n   *\n   * @param {number | string} nonce - number that can be only used once\n   */\n  nonce(nonce: bigint | number | string): this {\n    const n = typeof nonce === 'bigint' ? nonce : BigInt(nonce);\n    this.validateNonce(n);\n    this._nonce = n;\n    return this;\n  }\n\n  /**\n   * Export tx target P wallet.\n   *\n   * @param pAddresses\n   */\n  to(pAddresses: string | string[]): this {\n    const pubKeys = Array.isArray(pAddresses) ? pAddresses : pAddresses.split('~');\n    // For now ensure they are stored as bech32 / string addresses directly\n    this.transaction._to = pubKeys.map((a) => a.toString());\n    return this;\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.Export;\n  }\n\n  initBuilder(raw: RawFlareExportTx): this {\n    // Basic shape validation\n    const unsigned = raw.unsignedTx;\n    if (unsigned.networkId !== this.transaction._networkID) {\n      throw new Error('Network ID mismatch');\n    }\n    if (!unsigned.sourceBlockchainId.equals(this.transaction._blockchainID)) {\n      throw new Error('Blockchain ID mismatch');\n    }\n    if (unsigned.outputs.length !== 1) {\n      throw new BuildTransactionError('Transaction can have one output');\n    }\n    if (unsigned.inputs.length !== 1) {\n      throw new BuildTransactionError('Transaction can have one input');\n    }\n    const out = unsigned.outputs[0];\n    const inp = unsigned.inputs[0];\n    if (!out.assetId.equals(this.transaction._assetId) || !inp.assetId.equals(this.transaction._assetId)) {\n      throw new Error('AssetID mismatch');\n    }\n    this.transaction._to = out.addresses;\n    this._amount = out.amount;\n    const fee = inp.amount - out.amount;\n    if (fee < 0n) {\n      throw new BuildTransactionError('Computed fee is negative');\n    }\n    const fixed = this.fixedFee;\n    const feeRate = fee - fixed;\n    this.transaction._fee.feeRate = feeRate.toString();\n    this.transaction._fee.fee = fee.toString();\n    this.transaction._fee.size = 1;\n    this.transaction._fromAddresses = [inp.address];\n    this._nonce = inp.nonce;\n    this.transaction.setTransaction(raw);\n    return this;\n  }\n\n  // For parity with Avalanche builder interfaces; always returns true for placeholder\n  //TODO: WIN-6322\n  static verifyTxType(_tx: unknown): _tx is FlareUnsignedExportTx {\n    return true;\n  }\n\n  verifyTxType(_tx: unknown): _tx is FlareUnsignedExportTx {\n    return ExportInCTxBuilder.verifyTxType(_tx);\n  }\n\n  /**\n   * Build the export in C-chain transaction\n   * @protected\n   */\n  protected buildFlareTransaction(): void {\n    if (this.transaction.hasCredentials) {\n      return; // placeholder: credentials not yet implemented\n    }\n    if (this._amount === undefined) {\n      throw new Error('amount is required');\n    }\n    if (this.transaction._fromAddresses.length !== 1) {\n      throw new Error('sender is one and required');\n    }\n    if (this.transaction._to.length === 0) {\n      throw new Error('to is required');\n    }\n    if (!this.transaction._fee.feeRate) {\n      throw new Error('fee rate is required');\n    }\n    if (this._nonce === undefined) {\n      throw new Error('nonce is required');\n    }\n\n    // Compose placeholder unsigned tx shape\n    const feeRate = BigInt(this.transaction._fee.feeRate);\n    const fixed = this.fixedFee;\n    const totalFee = feeRate + fixed;\n    const input: FlareExportInputShape = {\n      address: this.transaction._fromAddresses[0],\n      amount: this._amount + totalFee,\n      assetId: this.transaction._assetId,\n      nonce: this._nonce,\n    };\n    const output: FlareExportOutputShape = {\n      addresses: this.transaction._to,\n      amount: this._amount,\n      assetId: this.transaction._assetId,\n    };\n    const unsigned: FlareUnsignedExportTx = {\n      networkId: this.transaction._networkID,\n      sourceBlockchainId: this.transaction._blockchainID,\n      destinationBlockchainId: this._externalChainId || Buffer.alloc(0),\n      inputs: [input],\n      outputs: [output],\n    };\n    const signed: FlareSignedExportTx = { unsignedTx: unsigned, credentials: [] };\n    this.transaction._fee.fee = totalFee.toString();\n    this.transaction._fee.size = 1;\n    this.transaction.setTransaction(signed);\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(raw: string | RawFlareExportTx): { _tx?: unknown } {\n    if (typeof raw === 'string') {\n      // Future: parse hex or serialized form. For now treat as opaque raw tx.\n      this.transaction.setTransaction(raw);\n      return this.transaction;\n    }\n    return this.initBuilder(raw).transaction;\n  }\n\n  /**\n   * Check the amount is positive.\n   * @param amount\n   */\n  validateNonce(nonce: bigint): void {\n    if (nonce < 0n) {\n      throw new BuildTransactionError('Nonce must be greater or equal than 0');\n    }\n  }\n}\n"]}

package/dist/src/lib/{exportTxBuilder.d.ts → exportInPTxBuilder.d.ts}

@@ -1,7 +1,7 @@
 import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
 import { TransactionType } from '@bitgo-beta/sdk-core';
 import { AtomicTransactionBuilder } from './atomicTransactionBuilder';
-export declare class ExportTxBuilder extends AtomicTransactionBuilder {
+export declare class ExportInPTxBuilder extends AtomicTransactionBuilder {
     private _amount;
     constructor(_coinConfig: Readonly<CoinConfig>);
     protected get transactionType(): TransactionType;
@@ -27,4 +27,4 @@ export declare class ExportTxBuilder extends AtomicTransactionBuilder {
      */
     protected exportedOutputs(): unknown[];
 }
-//# sourceMappingURL=exportTxBuilder.d.ts.map
+//# sourceMappingURL=exportInPTxBuilder.d.ts.map

package/dist/src/lib/exportInPTxBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exportInPTxBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/exportInPTxBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,qBAAa,kBAAmB,SAAQ,wBAAwB;IAC9D,OAAO,CAAC,OAAO,CAAM;gBAET,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI;IAO7C,kBAAkB;IAElB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAM/B,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO;IAI9C,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO;IAIvC;;;OAGG;IAEH,SAAS,CAAC,qBAAqB,IAAI,IAAI;IAIvC;;;;OAIG;IACH,SAAS,CAAC,eAAe,IAAI,OAAO,EAAE;CAGvC"}

package/dist/src/lib/exportInPTxBuilder.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportInPTxBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const atomicTransactionBuilder_1 = require("./atomicTransactionBuilder");
+class ExportInPTxBuilder extends atomicTransactionBuilder_1.AtomicTransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._amount = 0n;
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.Export;
+    }
+    /**
+     * Amount is a long that specifies the quantity of the asset that this output owns. Must be positive.
+     *
+     * @param {BN | string} amount The withdrawal amount
+     */
+    amount(value) {
+        const v = typeof value === 'bigint' ? value : BigInt(value);
+        this.validateAmount(v);
+        this._amount = v;
+        return this;
+    }
+    /** @inheritdoc */
+    // Placeholder: parsing existing ExportTx not yet supported on Flare P-chain
+    initBuilder(_tx) {
+        super.initBuilder(_tx);
+        return this;
+    }
+    // Type verification not yet implemented for Flare P-chain
+    static verifyTxType(_baseTx) {
+        return false;
+    }
+    verifyTxType(_baseTx) {
+        return ExportInPTxBuilder.verifyTxType(_baseTx);
+    }
+    /**
+     * Create the internal transaction.
+     * @protected
+     */
+    // Build not implemented yet
+    buildFlareTransaction() {
+        throw new Error('Flare P-chain export transaction build not implemented');
+    }
+    /**
+     * Create the ExportedOut where the recipient address are the sender.
+     * Later a importTx should complete the operations signing with the same keys.
+     * @protected
+     */
+    exportedOutputs() {
+        return [];
+    }
+}
+exports.ExportInPTxBuilder = ExportInPTxBuilder;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/unit/flrp.js

@@ -1,29 +1,118 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+const statics_1 = require("@bitgo-beta/statics");
+const assert = __importStar(require("assert"));
+const flrp_1 = require("../../src/flrp");
 const sdk_test_1 = require("@bitgo-beta/sdk-test");
 const sdk_api_1 = require("@bitgo-beta/sdk-api");
-const flrp_1 = require("../../src/flrp");
-const statics_1 = require("@bitgo-beta/statics");
 describe('Flrp', function () {
     let bitgo;
+    const staticsCoin = statics_1.coins.get('flrp');
     before(function () {
         bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
         bitgo.initializeTestVars();
         // Attempt to register the coin symbol; safeRegister is idempotent.
         bitgo.safeRegister?.('flrp', flrp_1.Flrp.createInstance);
     });
-    it('createInstance returns a Flrp instance', function () {
-        const staticsCoin = statics_1.coins.get('flrp');
-        const coin = flrp_1.Flrp.createInstance(bitgo, staticsCoin);
-        coin.should.be.instanceOf(flrp_1.Flrp);
+    describe('createInstance', function () {
+        it('should return a Flrp instance', function () {
+            const coin = flrp_1.Flrp.createInstance(bitgo, staticsCoin);
+            assert.ok(coin instanceof flrp_1.Flrp);
+        });
+        it('should produce distinct objects on multiple calls', function () {
+            const a = flrp_1.Flrp.createInstance(bitgo, staticsCoin);
+            const b = flrp_1.Flrp.createInstance(bitgo, staticsCoin);
+            assert.notStrictEqual(a, b);
+            assert.ok(a instanceof flrp_1.Flrp);
+            assert.ok(b instanceof flrp_1.Flrp);
+        });
+    });
+    describe('coin properties', function () {
+        let coin;
+        beforeEach(function () {
+            coin = flrp_1.Flrp.createInstance(bitgo, staticsCoin);
+        });
+        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_1.Flrp.createInstance(null, staticsCoin));
+            assert.throws(() => flrp_1.Flrp.createInstance(bitgo, null));
+        });
     });
-    it('multiple createInstance calls produce distinct objects', function () {
-        const sc = statics_1.coins.get('flrp');
-        const a = flrp_1.Flrp.createInstance(bitgo, sc);
-        const b = flrp_1.Flrp.createInstance(bitgo, sc);
-        a.should.not.equal(b);
-        a.should.be.instanceOf(flrp_1.Flrp);
-        b.should.be.instanceOf(flrp_1.Flrp);
+    describe('inheritance and methods', function () {
+        let coin;
+        beforeEach(function () {
+            coin = flrp_1.Flrp.createInstance(bitgo, staticsCoin);
+        });
+        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');
+        });
     });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flrp.js","sourceRoot":"","sources":["../../../test/unit/flrp.ts"],"names":[],"mappings":"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","sourcesContent":["import { coins } from '@bitgo-beta/statics';\nimport * as assert from 'assert';\nimport { Flrp } from '../../src/flrp';\nimport { BitGoBase } from '@bitgo-beta/sdk-core';\nimport { TestBitGo, TestBitGoAPI } from '@bitgo-beta/sdk-test';\nimport { BitGoAPI } from '@bitgo-beta/sdk-api';\n\ndescribe('Flrp', function () {\n  let bitgo: TestBitGoAPI;\n  const staticsCoin = coins.get('flrp');\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n    bitgo.initializeTestVars();\n    // Attempt to register the coin symbol; safeRegister is idempotent.\n    (bitgo as unknown as { safeRegister?: (n: string, f: (bg: BitGoBase) => unknown) => void }).safeRegister?.(\n      'flrp',\n      Flrp.createInstance\n    );\n  });\n\n  describe('createInstance', function () {\n    it('should return a Flrp instance', function () {\n      const coin = Flrp.createInstance(bitgo as unknown as BitGoBase, staticsCoin);\n      assert.ok(coin instanceof Flrp);\n    });\n\n    it('should produce distinct objects on multiple calls', function () {\n      const a = Flrp.createInstance(bitgo as unknown as BitGoBase, staticsCoin);\n      const b = Flrp.createInstance(bitgo as unknown as BitGoBase, staticsCoin);\n      assert.notStrictEqual(a, b);\n      assert.ok(a instanceof Flrp);\n      assert.ok(b instanceof Flrp);\n    });\n  });\n\n  describe('coin properties', function () {\n    let coin: Flrp;\n\n    beforeEach(function () {\n      coin = Flrp.createInstance(bitgo as unknown as BitGoBase, staticsCoin) as Flrp;\n    });\n\n    it('should have correct coin family', function () {\n      assert.strictEqual(coin.getFamily(), staticsCoin.family);\n    });\n\n    it('should have correct coin name', function () {\n      assert.strictEqual(coin.getFullName(), staticsCoin.fullName);\n    });\n\n    it('should have correct base factor', function () {\n      assert.strictEqual(coin.getBaseFactor(), Math.pow(10, staticsCoin.decimalPlaces));\n    });\n\n    it('should validate addresses using utils', function () {\n      const validAddress = 'flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh';\n      const result = coin.isValidAddress(validAddress);\n      assert.strictEqual(typeof result, 'boolean');\n    });\n\n    it('should generate key pairs', function () {\n      const keyPair = coin.generateKeyPair();\n      assert.ok('pub' in keyPair);\n      assert.ok('prv' in keyPair);\n      if (keyPair.pub && keyPair.prv) {\n        assert.strictEqual(typeof keyPair.pub, 'string');\n        assert.strictEqual(typeof keyPair.prv, 'string');\n      }\n    });\n  });\n\n  describe('error handling', function () {\n    it('should handle construction with invalid parameters', function () {\n      assert.throws(() => Flrp.createInstance(null as unknown as BitGoBase, staticsCoin));\n      assert.throws(() => Flrp.createInstance(bitgo as unknown as BitGoBase, null as unknown as typeof staticsCoin));\n    });\n  });\n\n  describe('inheritance and methods', function () {\n    let coin: Flrp;\n\n    beforeEach(function () {\n      coin = Flrp.createInstance(bitgo as unknown as BitGoBase, staticsCoin) as Flrp;\n    });\n\n    it('should have required base coin methods', function () {\n      assert.ok('getFamily' in coin);\n      assert.ok('getFullName' in coin);\n      assert.ok('getBaseFactor' in coin);\n      assert.ok('isValidAddress' in coin);\n      assert.ok('generateKeyPair' in coin);\n    });\n\n    it('should handle address validation consistently', function () {\n      const validAddress = 'flare1test';\n      const invalidAddress = 'invalid-address';\n\n      assert.strictEqual(typeof coin.isValidAddress(validAddress), 'boolean');\n      assert.strictEqual(typeof coin.isValidAddress(invalidAddress), 'boolean');\n    });\n  });\n});\n"]}

package/dist/test/unit/lib/atomicTransactionBuilder.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=atomicTransactionBuilder.d.ts.map

package/dist/test/unit/lib/atomicTransactionBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomicTransactionBuilder.d.ts","sourceRoot":"","sources":["../../../../test/unit/lib/atomicTransactionBuilder.ts"],"names":[],"mappings":""}