@bitgo-beta/sdk-coin-flrp 1.0.1-beta.4 → 1.0.1-beta.40

package/dist/src/flrp.js

@@ -1,7 +1,47 @@
 "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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Flrp = void 0;
+const statics_1 = require("@bitgo-beta/statics");
 const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const FlrpLib = __importStar(require("./lib"));
+const utils_1 = __importDefault(require("./lib/utils"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
 class Flrp extends sdk_core_1.BaseCoin {
     constructor(bitgo, staticsCoin) {
         super(bitgo);
@@ -25,151 +65,279 @@ class Flrp extends sdk_core_1.BaseCoin {
     getBaseFactor() {
         return Math.pow(10, this._staticsCoin.decimalPlaces);
     }
-    // TODO WIN-6321, 6322, 6318: All below methods will be implemented in coming ticket
-    // Feature flags
-    supportsTss() {
-        return false;
-    }
-    supportsMessageSigning() {
-        return false;
-    }
-    supportsSigningTypedData() {
-        return false;
-    }
-    supportsBlockTarget() {
-        return false;
-    }
-    supportsLightning() {
-        return false;
-    }
-    supportsBlsDkg() {
-        return false;
-    }
-    isEVM() {
-        return false;
-    }
-    // Conversions (placeholder)
-    // Use BaseCoin default conversions (baseUnitsToBigUnits / bigUnitsToBaseUnits)
-    // Key methods (stubs)
-    generateKeyPair() {
-        throw new Error('generateKeyPair not implemented');
-    }
-    generateRootKeyPair() {
-        throw new Error('generateRootKeyPair not implemented');
-    }
-    keyIdsForSigning() {
-        return [0, 1, 2];
-    }
-    isValidPub(_pub) {
-        return false;
-    }
-    isValidAddress(_address) {
-        return false;
-    }
-    isValidMofNSetup(_params) {
-        return false;
-    }
-    canonicalAddress(address) {
-        return address;
-    }
-    checkRecipient(_recipient) {
-        /* no-op */
-    }
-    // Verification
-    async verifyAddress(_params) {
-        throw new Error('verifyAddress not implemented');
-    }
-    async isWalletAddress(_params) {
-        throw new Error('isWalletAddress not implemented');
-    }
-    async verifyTransaction(_params) {
-        throw new Error('verifyTransaction not implemented');
-    }
-    // Tx lifecycle
-    async signTransaction(_params) {
-        // TODO WIN-6320: implement signTransaction
-        throw new Error('signTransaction not implemented');
-    }
-    async explainTransaction(_options) {
-        // TODO WIN-6320: implement signTransaction
-        throw new Error('explainTransaction not implemented');
-    }
-    async parseTransaction(_params) {
-        // TODO WIN-6320: implement signTransaction
-        throw new Error('parseTransaction not implemented');
+    /** inherited doc */
+    getDefaultMultisigType() {
+        return sdk_core_1.multisigTypes.onchain;
+    }
+    /**
+     * Check if staking txn is valid, based on expected tx params.
+     *
+     * @param {FlrpTransactionStakingOptions} stakingOptions expected staking params to check against
+     * @param {FlrpLib.TransactionExplanation} explainedTx explained staking transaction
+     */
+    validateStakingTx(stakingOptions, explainedTx) {
+        const filteredRecipients = [{ address: stakingOptions.nodeID, amount: stakingOptions.amount }];
+        const filteredOutputs = explainedTx.outputs.map((output) => utils_1.default.pick(output, ['address', 'amount']));
+        if (!utils_1.default.isEqual(filteredOutputs, filteredRecipients)) {
+            throw new Error('Tx outputs does not match with expected txParams');
+        }
+        if (stakingOptions?.amount !== explainedTx.outputAmount) {
+            throw new Error('Tx total amount does not match with expected total amount field');
+        }
     }
-    async presignTransaction(_params) {
-        // TODO WIN-6320: implement signTransaction
-        throw new Error('presignTransaction not implemented');
+    /**
+     * Check if export txn is valid, based on expected tx params.
+     *
+     * @param {ITransactionRecipient[]} recipients expected recipients and info
+     * @param {FlrpLib.TransactionExplanation} explainedTx explained export transaction
+     */
+    validateExportTx(recipients, explainedTx) {
+        if (recipients.length !== 1 || explainedTx.outputs.length !== 1) {
+            throw new Error('Export Tx requires one recipient');
+        }
+        const maxImportFee = this._staticsCoin.network.maxImportFee || '0';
+        const recipientAmount = new bignumber_js_1.default(recipients[0].amount);
+        if (recipientAmount.isGreaterThan(explainedTx.outputAmount) ||
+            recipientAmount.plus(maxImportFee).isLessThan(explainedTx.outputAmount)) {
+            throw new Error(`Tx total amount ${explainedTx.outputAmount} does not match with expected total amount field ${recipientAmount} and max import fee ${maxImportFee}`);
+        }
+        if (explainedTx.outputs && !utils_1.default.isValidAddress(explainedTx.outputs[0].address)) {
+            throw new Error(`Invalid P-chain address ${explainedTx.outputs[0].address}`);
+        }
     }
-    async postProcessPrebuild(prebuild) {
-        // TODO WIN-6320: implement signTransaction
-        return prebuild;
+    /**
+     * Check if import txn into P is valid, based on expected tx params.
+     *
+     * @param {FlrpLib.FlrpEntry[]} explainedTxInputs tx inputs (unspents to be imported)
+     * @param {FlrpTransactionParams} txParams expected tx info to check against
+     */
+    validateImportTx(explainedTxInputs, txParams) {
+        if (txParams.unspents) {
+            if (explainedTxInputs.length !== txParams.unspents.length) {
+                throw new Error(`Expected ${txParams.unspents.length} UTXOs, transaction had ${explainedTxInputs.length}`);
+            }
+            const unspents = new Set(txParams.unspents);
+            for (const unspent of explainedTxInputs) {
+                if (!unspents.has(unspent.id)) {
+                    throw new Error(`Transaction should not contain the UTXO: ${unspent.id}`);
+                }
+            }
+        }
     }
-    async getExtraPrebuildParams(_buildParams) {
-        // TODO WIN-6320: implement signTransaction
-        return {};
+    async verifyTransaction(params) {
+        const txHex = params.txPrebuild && params.txPrebuild.txHex;
+        if (!txHex) {
+            throw new Error('missing required tx prebuild property txHex');
+        }
+        let tx;
+        try {
+            const txBuilder = this.getBuilder().from(txHex);
+            tx = await txBuilder.build();
+        }
+        catch (error) {
+            throw new Error('Invalid transaction');
+        }
+        const explainedTx = tx.explainTransaction();
+        const { type, stakingOptions } = params.txParams;
+        // TODO(BG-62112): change ImportToC type to Import
+        if (!type || (type !== 'ImportToC' && explainedTx.type !== sdk_core_1.TransactionType[type])) {
+            throw new Error('Tx type does not match with expected txParams type');
+        }
+        switch (explainedTx.type) {
+            // @deprecated
+            case sdk_core_1.TransactionType.AddDelegator:
+            case sdk_core_1.TransactionType.AddValidator:
+            case sdk_core_1.TransactionType.AddPermissionlessDelegator:
+            case sdk_core_1.TransactionType.AddPermissionlessValidator:
+                if (stakingOptions) {
+                    this.validateStakingTx(stakingOptions, explainedTx);
+                }
+                break;
+            case sdk_core_1.TransactionType.Export:
+                if (!params.txParams.recipients || params.txParams.recipients?.length !== 1) {
+                    throw new Error('Export Tx requires a recipient');
+                }
+                else {
+                    this.validateExportTx(params.txParams.recipients, explainedTx);
+                }
+                break;
+            case sdk_core_1.TransactionType.Import:
+                if (tx.isTransactionForCChain) {
+                    // Import to C-chain
+                    if (explainedTx.outputs.length !== 1) {
+                        throw new Error('Expected 1 output in import transaction');
+                    }
+                    if (!params.txParams.recipients || params.txParams.recipients.length !== 1) {
+                        throw new Error('Expected 1 recipient in import transaction');
+                    }
+                }
+                else {
+                    // Import to P-chain
+                    if (explainedTx.outputs.length !== 1) {
+                        throw new Error('Expected 1 output in import transaction');
+                    }
+                    this.validateImportTx(explainedTx.inputs, params.txParams);
+                }
+                break;
+            default:
+                throw new Error('Tx type is not supported yet');
+        }
+        return true;
+    }
+    /**
+     * Check if address is valid, then make sure it matches the root address.
+     *
+     * @param params.address address to validate
+     * @param params.keychains public keys to generate the wallet
+     */
+    async isWalletAddress(params) {
+        const { address, keychains } = params;
+        if (!this.isValidAddress(address)) {
+            throw new sdk_core_1.InvalidAddressError(`invalid address: ${address}`);
+        }
+        if (!keychains || keychains.length !== 3) {
+            throw new Error('Invalid keychains');
+        }
+        // multisig addresses are separated by ~
+        const splitAddresses = address.split('~');
+        // derive addresses from keychain
+        const unlockAddresses = keychains.map((keychain) => new FlrpLib.KeyPair({ pub: keychain.pub }).getAddress(this._staticsCoin.network.type));
+        if (splitAddresses.length !== unlockAddresses.length) {
+            throw new sdk_core_1.UnexpectedAddressError(`address validation failure: multisig address length does not match`);
+        }
+        if (!this.adressesArraysMatch(splitAddresses, unlockAddresses)) {
+            throw new sdk_core_1.UnexpectedAddressError(`address validation failure: ${address} is not of this wallet`);
+        }
+        return true;
+    }
+    /**
+     * Validate that two multisig address arrays have the same elements, order doesnt matter
+     * @param addressArray1
+     * @param addressArray2
+     * @returns true if address arrays have the same addresses
+     * @private
+     */
+    adressesArraysMatch(addressArray1, addressArray2) {
+        return JSON.stringify(addressArray1.sort()) === JSON.stringify(addressArray2.sort());
+    }
+    /**
+     * Generate Flrp key pair
+     *
+     * @param {Buffer} seed - Seed from which the new keypair should be generated, otherwise a random seed is used
+     * @returns {Object} object with generated pub and prv
+     */
+    generateKeyPair(seed) {
+        const keyPair = seed ? new FlrpLib.KeyPair({ seed }) : new FlrpLib.KeyPair();
+        const keys = keyPair.getKeys();
+        if (!keys.prv) {
+            throw new Error('Missing prv in key generation.');
+        }
+        return {
+            pub: keys.pub,
+            prv: keys.prv,
+        };
+    }
+    /**
+     * Return boolean indicating whether input is valid public key for the coin
+     *
+     * @param {string} pub the prv to be checked
+     * @returns is it valid?
+     */
+    isValidPub(pub) {
+        try {
+            new FlrpLib.KeyPair({ pub });
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
     }
-    async feeEstimate(_params) {
-        // TODO WIN-6320: implement signTransaction
-        throw new Error('feeEstimate not implemented');
+    /**
+     * Return boolean indicating whether input is valid private key for the coin
+     *
+     * @param {string} prv the prv to be checked
+     * @returns is it valid?
+     */
+    isValidPrv(prv) {
+        try {
+            new FlrpLib.KeyPair({ prv });
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
     }
-    async broadcastTransaction(_params) {
-        // TODO WIN-6320: implement signTransaction
-        throw new Error('broadcastTransaction not implemented');
+    isValidAddress(address) {
+        if (address === undefined) {
+            return false;
+        }
+        // validate eth address for cross-chain txs to c-chain
+        if (typeof address === 'string' && utils_1.default.isValidEthereumAddress(address)) {
+            return true;
+        }
+        return FlrpLib.Utils.isValidAddress(address);
+    }
+    /**
+     * Signs Flrp transaction
+     */
+    async signTransaction(params) {
+        // deserialize raw transaction (note: fromAddress has onchain order)
+        const txBuilder = this.getBuilder().from(params.txPrebuild.txHex);
+        const key = params.prv;
+        // push the keypair to signer array
+        txBuilder.sign({ key });
+        // build the transaction
+        const transaction = await txBuilder.build();
+        if (!transaction) {
+            throw new sdk_core_1.InvalidTransactionError('Error while trying to build transaction');
+        }
+        return transaction.signature.length >= 2
+            ? { txHex: transaction.toBroadcastFormat() }
+            : { halfSigned: { txHex: transaction.toBroadcastFormat() } };
     }
-    // Wallet helpers
-    async supplementGenerateWallet(_walletParams, _keychains) {
+    async parseTransaction(params) {
         return {};
     }
-    newWalletObject(walletParams) {
-        return walletParams;
-    }
-    preCreateBitGo(_params) {
-        /* no-op */
-    }
-    initiateRecovery(_params) {
-        throw new Error('initiateRecovery not implemented');
-    }
-    // Signing helpers
-    async signMessage(_key, _message) {
-        throw new Error('signMessage not implemented');
-    }
-    async createKeySignatures(_prv, _backup, _bitgo) {
-        throw new Error('createKeySignatures not implemented');
-    }
-    async getSignablePayload(_serializedTx) {
-        throw new Error('getSignablePayload not implemented');
-    }
-    getMPCAlgorithm() {
-        return 'ecdsa';
-    }
-    // Token / NFT / inscription / recovery placeholders
-    recoverToken(_params) {
-        throw new Error('recoverToken not implemented');
-    }
-    buildNftTransferData(_params) {
-        throw new Error('buildNftTransferData not implemented');
-    }
-    getInscriptionBuilder(_wallet) {
-        throw new Error('getInscriptionBuilder not implemented');
-    }
-    // Misc
-    getHashFunction() {
-        throw new Error('getHashFunction not implemented');
+    /**
+     * Explain a Flrp transaction from txHex
+     * @param params
+     * @param callback
+     */
+    async explainTransaction(params) {
+        const txHex = params.txHex ?? params?.halfSigned?.txHex;
+        if (!txHex) {
+            throw new Error('missing transaction hex');
+        }
+        try {
+            const txBuilder = this.getBuilder().from(txHex);
+            const tx = await txBuilder.build();
+            return tx.explainTransaction();
+        }
+        catch (e) {
+            throw new Error(`Invalid transaction: ${e.message}`);
+        }
     }
-    deriveKeyWithSeed(_params) {
-        throw new Error('deriveKeyWithSeed not implemented');
+    recoverySignature(message, signature) {
+        return FlrpLib.Utils.recoverySignature(this._staticsCoin.network, message, signature);
     }
-    setCoinSpecificFieldsInIntent(_intent, _params) {
-        /* no-op */
+    async signMessage(key, message) {
+        const prv = new FlrpLib.KeyPair(key).getPrivateKey();
+        if (!prv) {
+            throw new sdk_core_1.SigningError('Invalid key pair options');
+        }
+        if (typeof message === 'string') {
+            message = Buffer.from(message, 'hex');
+        }
+        return FlrpLib.Utils.createSignature(this._staticsCoin.network, message, prv);
     }
-    assertIsValidKey(_params) {
-        /* no-op */
+    getBuilder() {
+        return new FlrpLib.TransactionBuilderFactory(statics_1.coins.get(this.getChain()));
     }
-    auditDecryptedKey() {
-        /* no-op */
+    /** @inheritDoc */
+    auditDecryptedKey(params) {
+        /** https://bitgoinc.atlassian.net/browse/COIN-4213 */
+        throw new sdk_core_1.MethodNotImplementedError();
     }
 }
 exports.Flrp = Flrp;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flrp.js","sourceRoot":"","sources":["../../src/flrp.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BaseCoin,\n  BitGoBase,\n  VerifyAddressOptions,\n  ParsedTransaction,\n  ParseTransactionOptions,\n  KeyPair,\n  SignTransactionOptions,\n  SignedTransaction,\n  InitiateRecoveryOptions,\n  SupplementGenerateWalletOptions,\n  KeychainsTriplet,\n  TransactionPrebuild,\n  PresignTransactionOptions,\n  FeeEstimateOptions,\n  DeriveKeyWithSeedOptions,\n  AuditKeyParams,\n  PopulatedIntent,\n  PrebuildTransactionWithIntentOptions,\n  TokenTransferRecipientParams,\n  BuildNftTransferDataOptions,\n  BaseBroadcastTransactionOptions,\n  BaseBroadcastTransactionResult,\n  MPCAlgorithm,\n  Wallet,\n  IInscriptionBuilder,\n  ExtraPrebuildParamsOptions,\n  ValidMofNOptions,\n  VerifyTransactionOptions,\n  ITransactionExplanation,\n  RecoverTokenTransaction,\n  RecoverWalletTokenOptions,\n  PrecreateBitGoOptions,\n  IWallet,\n} from '@bitgo-beta/sdk-core';\nimport { BaseCoin as StaticsBaseCoin, CoinFamily } from '@bitgo-beta/statics';\nimport { Hash } from 'crypto';\n\nexport class Flrp extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n\n  protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo);\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n    this._staticsCoin = staticsCoin;\n  }\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Flrp(bitgo, staticsCoin);\n  }\n\n  getChain(): string {\n    return this._staticsCoin.name;\n  }\n  getFamily(): CoinFamily {\n    return this._staticsCoin.family as CoinFamily;\n  }\n  getFullName(): string {\n    return this._staticsCoin.fullName;\n  }\n  getBaseFactor(): number | string {\n    return Math.pow(10, this._staticsCoin.decimalPlaces);\n  }\n\n  // TODO WIN-6321, 6322, 6318: All below methods will be implemented in coming ticket\n  // Feature flags\n  supportsTss(): boolean {\n    return false;\n  }\n  supportsMessageSigning(): boolean {\n    return false;\n  }\n  supportsSigningTypedData(): boolean {\n    return false;\n  }\n  supportsBlockTarget(): boolean {\n    return false;\n  }\n  supportsLightning(): boolean {\n    return false;\n  }\n  supportsBlsDkg(): boolean {\n    return false;\n  }\n  isEVM(): boolean {\n    return false;\n  }\n\n  // Conversions (placeholder)\n  // Use BaseCoin default conversions (baseUnitsToBigUnits / bigUnitsToBaseUnits)\n\n  // Key methods (stubs)\n  generateKeyPair(): KeyPair {\n    throw new Error('generateKeyPair not implemented');\n  }\n  generateRootKeyPair(): KeyPair {\n    throw new Error('generateRootKeyPair not implemented');\n  }\n  keyIdsForSigning(): number[] {\n    return [0, 1, 2];\n  }\n  isValidPub(_pub: string): boolean {\n    return false;\n  }\n  isValidAddress(_address: string): boolean {\n    return false;\n  }\n  isValidMofNSetup(_params: ValidMofNOptions): boolean {\n    return false;\n  }\n  canonicalAddress(address: string): string {\n    return address;\n  }\n  checkRecipient(_recipient: { address: string; amount: string | number }): void {\n    /* no-op */\n  }\n\n  // Verification\n  async verifyAddress(_params: VerifyAddressOptions): Promise<boolean> {\n    throw new Error('verifyAddress not implemented');\n  }\n  async isWalletAddress(_params: VerifyAddressOptions): Promise<boolean> {\n    throw new Error('isWalletAddress not implemented');\n  }\n  async verifyTransaction(_params: VerifyTransactionOptions): Promise<boolean> {\n    throw new Error('verifyTransaction not implemented');\n  }\n\n  // Tx lifecycle\n  async signTransaction(_params: SignTransactionOptions): Promise<SignedTransaction> {\n    // TODO WIN-6320: implement signTransaction\n    throw new Error('signTransaction not implemented');\n  }\n  async explainTransaction(\n    _options: Record<string, unknown>\n  ): Promise<ITransactionExplanation<unknown, string | number> | undefined> {\n    // TODO WIN-6320: implement signTransaction\n    throw new Error('explainTransaction not implemented');\n  }\n  async parseTransaction(_params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    // TODO WIN-6320: implement signTransaction\n    throw new Error('parseTransaction not implemented');\n  }\n  async presignTransaction(_params: PresignTransactionOptions): Promise<PresignTransactionOptions> {\n    // TODO WIN-6320: implement signTransaction\n    throw new Error('presignTransaction not implemented');\n  }\n  async postProcessPrebuild(prebuild: TransactionPrebuild): Promise<TransactionPrebuild> {\n    // TODO WIN-6320: implement signTransaction\n    return prebuild;\n  }\n  async getExtraPrebuildParams(_buildParams: ExtraPrebuildParamsOptions): Promise<Record<string, unknown>> {\n    // TODO WIN-6320: implement signTransaction\n    return {};\n  }\n  async feeEstimate(_params: FeeEstimateOptions): Promise<unknown> {\n    // TODO WIN-6320: implement signTransaction\n    throw new Error('feeEstimate not implemented');\n  }\n  async broadcastTransaction(_params: BaseBroadcastTransactionOptions): Promise<BaseBroadcastTransactionResult> {\n    // TODO WIN-6320: implement signTransaction\n    throw new Error('broadcastTransaction not implemented');\n  }\n\n  // Wallet helpers\n  async supplementGenerateWallet(\n    _walletParams: SupplementGenerateWalletOptions,\n    _keychains: KeychainsTriplet\n  ): Promise<Record<string, unknown>> {\n    return {};\n  }\n  newWalletObject(walletParams: unknown): IWallet {\n    return walletParams as IWallet;\n  }\n  preCreateBitGo(_params: PrecreateBitGoOptions): void {\n    /* no-op */\n  }\n  initiateRecovery(_params: InitiateRecoveryOptions): never {\n    throw new Error('initiateRecovery not implemented');\n  }\n\n  // Signing helpers\n  async signMessage(_key: { prv: string }, _message: string): Promise<Buffer> {\n    throw new Error('signMessage not implemented');\n  }\n  async createKeySignatures(\n    _prv: string,\n    _backup: { pub: string },\n    _bitgo: { pub: string }\n  ): Promise<{ backup: string; bitgo: string }> {\n    throw new Error('createKeySignatures not implemented');\n  }\n  async getSignablePayload(_serializedTx: string): Promise<Buffer> {\n    throw new Error('getSignablePayload not implemented');\n  }\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'ecdsa';\n  }\n\n  // Token / NFT / inscription / recovery placeholders\n  recoverToken(_params: RecoverWalletTokenOptions): Promise<RecoverTokenTransaction> {\n    throw new Error('recoverToken not implemented');\n  }\n  buildNftTransferData(_params: BuildNftTransferDataOptions): string | TokenTransferRecipientParams {\n    throw new Error('buildNftTransferData not implemented');\n  }\n  getInscriptionBuilder(_wallet: Wallet): IInscriptionBuilder {\n    throw new Error('getInscriptionBuilder not implemented');\n  }\n\n  // Misc\n  getHashFunction(): Hash {\n    throw new Error('getHashFunction not implemented');\n  }\n  deriveKeyWithSeed(_params: DeriveKeyWithSeedOptions): { key: string; derivationPath: string } {\n    throw new Error('deriveKeyWithSeed not implemented');\n  }\n  setCoinSpecificFieldsInIntent(_intent: PopulatedIntent, _params: PrebuildTransactionWithIntentOptions): void {\n    /* no-op */\n  }\n  assertIsValidKey(_params: AuditKeyParams): void {\n    /* no-op */\n  }\n  auditDecryptedKey(): void {\n    /* no-op */\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flrp.js","sourceRoot":"","sources":["../../src/flrp.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iDAAmG;AACnG,mDAmB8B;AAC9B,+CAAiC;AAQjC,wDAAgC;AAChC,gEAAqC;AAErC,MAAa,IAAK,SAAQ,mBAAQ;IAGhC,YAAY,KAAgB,EAAE,WAAuC;QACnE,KAAK,CAAC,KAAK,CAAC,CAAC;QAEb,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;QACxE,CAAC;QAED,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;IAClC,CAAC;IAED,MAAM,CAAC,cAAc,CAAC,KAAgB,EAAE,WAAuC;QAC7E,OAAO,IAAI,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IACtC,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC;IAChC,CAAC;IACD,SAAS;QACP,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC;IAClC,CAAC;IACD,WAAW;QACT,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC;IACpC,CAAC;IACD,aAAa;QACX,OAAO,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IACvD,CAAC;IAED,oBAAoB;IACpB,sBAAsB;QACpB,OAAO,wBAAa,CAAC,OAAO,CAAC;IAC/B,CAAC;IAED;;;;;OAKG;IACH,iBAAiB,CAAC,cAA6C,EAAE,WAA2C;QAC1G,MAAM,kBAAkB,GAAG,CAAC,EAAE,OAAO,EAAE,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,CAAC,MAAM,EAAE,CAAC,CAAC;QAC/F,MAAM,eAAe,GAAG,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,eAAK,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;QAEvG,IAAI,CAAC,eAAK,CAAC,OAAO,CAAC,eAAe,EAAE,kBAAkB,CAAC,EAAE,CAAC;YACxD,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;QACtE,CAAC;QACD,IAAI,cAAc,EAAE,MAAM,KAAK,WAAW,CAAC,YAAY,EAAE,CAAC;YACxD,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAC;QACrF,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,gBAAgB,CAAC,UAAmC,EAAE,WAA2C;QAC/F,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,IAAI,WAAW,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAChE,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;QACtD,CAAC;QAED,MAAM,YAAY,GAAI,IAAI,CAAC,YAAY,CAAC,OAAwB,CAAC,YAAY,IAAI,GAAG,CAAC;QACrF,MAAM,eAAe,GAAG,IAAI,sBAAS,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QAC5D,IACE,eAAe,CAAC,aAAa,CAAC,WAAW,CAAC,YAAY,CAAC;YACvD,eAAe,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC,YAAY,CAAC,EACvE,CAAC;YACD,MAAM,IAAI,KAAK,CACb,mBAAmB,WAAW,CAAC,YAAY,oDAAoD,eAAe,uBAAuB,YAAY,EAAE,CACpJ,CAAC;QACJ,CAAC;QAED,IAAI,WAAW,CAAC,OAAO,IAAI,CAAC,eAAK,CAAC,cAAc,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;YACjF,MAAM,IAAI,KAAK,CAAC,2BAA2B,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;QAC/E,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,gBAAgB,CAAC,iBAAsC,EAAE,QAA+B;QACtF,IAAI,QAAQ,CAAC,QAAQ,EAAE,CAAC;YACtB,IAAI,iBAAiB,CAAC,MAAM,KAAK,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;gBAC1D,MAAM,IAAI,KAAK,CAAC,YAAY,QAAQ,CAAC,QAAQ,CAAC,MAAM,2BAA2B,iBAAiB,CAAC,MAAM,EAAE,CAAC,CAAC;YAC7G,CAAC;YAED,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;YAE5C,KAAK,MAAM,OAAO,IAAI,iBAAiB,EAAE,CAAC;gBACxC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC;oBAC9B,MAAM,IAAI,KAAK,CAAC,4CAA4C,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC5E,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED,KAAK,CAAC,iBAAiB,CAAC,MAAoC;QAC1D,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,IAAI,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC;QAC3D,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;QACjE,CAAC;QACD,IAAI,EAAE,CAAC;QACP,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAChD,EAAE,GAAG,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC;QAC/B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACzC,CAAC;QACD,MAAM,WAAW,GAAG,EAAE,CAAC,kBAAkB,EAAE,CAAC;QAE5C,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,GAAG,MAAM,CAAC,QAAQ,CAAC;QACjD,kDAAkD;QAClD,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW,IAAI,WAAW,CAAC,IAAI,KAAK,0BAAe,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;YAClF,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;QACxE,CAAC;QAED,QAAQ,WAAW,CAAC,IAAI,EAAE,CAAC;YACzB,cAAc;YACd,KAAK,0BAAe,CAAC,YAAY,CAAC;YAClC,KAAK,0BAAe,CAAC,YAAY,CAAC;YAClC,KAAK,0BAAe,CAAC,0BAA0B,CAAC;YAChD,KAAK,0BAAe,CAAC,0BAA0B;gBAC7C,IAAI,cAAc,EAAE,CAAC;oBACnB,IAAI,CAAC,iBAAiB,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;gBACtD,CAAC;gBACD,MAAM;YACR,KAAK,0BAAe,CAAC,MAAM;gBACzB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,IAAI,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,KAAK,CAAC,EAAE,CAAC;oBAC5E,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;gBACpD,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;gBACjE,CAAC;gBACD,MAAM;YACR,KAAK,0BAAe,CAAC,MAAM;gBACzB,IAAI,EAAE,CAAC,sBAAsB,EAAE,CAAC;oBAC9B,oBAAoB;oBACpB,IAAI,WAAW,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;wBACrC,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;oBAC7D,CAAC;oBACD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,IAAI,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;wBAC3E,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;oBAChE,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,oBAAoB;oBACpB,IAAI,WAAW,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;wBACrC,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;oBAC7D,CAAC;oBACD,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;gBAC7D,CAAC;gBACD,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;QACpD,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,eAAe,CAAC,MAA4B;QAChD,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC;QAEtC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,CAAC;YAClC,MAAM,IAAI,8BAAmB,CAAC,oBAAoB,OAAO,EAAE,CAAC,CAAC;QAC/D,CAAC;QACD,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACzC,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;QACvC,CAAC;QAED,wCAAwC;QACxC,MAAM,cAAc,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAE1C,iCAAiC;QACjC,MAAM,eAAe,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CACjD,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,CACtF,CAAC;QAEF,IAAI,cAAc,CAAC,MAAM,KAAK,eAAe,CAAC,MAAM,EAAE,CAAC;YACrD,MAAM,IAAI,iCAAsB,CAAC,oEAAoE,CAAC,CAAC;QACzG,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,cAAc,EAAE,eAAe,CAAC,EAAE,CAAC;YAC/D,MAAM,IAAI,iCAAsB,CAAC,+BAA+B,OAAO,wBAAwB,CAAC,CAAC;QACnG,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACK,mBAAmB,CAAC,aAAuB,EAAE,aAAuB;QAC1E,OAAO,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC,CAAC;IACvF,CAAC;IAED;;;;;OAKG;IACH,eAAe,CAAC,IAAa;QAC3B,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;QAC7E,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;QAE/B,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;QACpD,CAAC;QAED,OAAO;YACL,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,GAAG,EAAE,IAAI,CAAC,GAAG;SACd,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,UAAU,CAAC,GAAW;QACpB,IAAI,CAAC;YACH,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;YAC7B,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,UAAU,CAAC,GAAW;QACpB,IAAI,CAAC;YACH,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;YAC7B,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED,cAAc,CAAC,OAA0B;QACvC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,sDAAsD;QACtD,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,eAAK,CAAC,sBAAsB,CAAC,OAAO,CAAC,EAAE,CAAC;YACzE,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;IAC/C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,eAAe,CAAC,MAAkC;QACtD,oEAAoE;QACpE,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAClE,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC;QAEvB,mCAAmC;QACnC,SAAS,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;QAExB,wBAAwB;QACxB,MAAM,WAAW,GAAoB,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC;QAC7D,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,IAAI,kCAAuB,CAAC,yCAAyC,CAAC,CAAC;QAC/E,CAAC;QACD,OAAO,WAAW,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC;YACtC,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,iBAAiB,EAAE,EAAE;YAC5C,CAAC,CAAC,EAAE,UAAU,EAAE,EAAE,KAAK,EAAE,WAAW,CAAC,iBAAiB,EAAE,EAAE,EAAE,CAAC;IACjE,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAC,MAA+B;QACpD,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,kBAAkB,CAAC,MAAiC;QACxD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,MAAM,EAAE,UAAU,EAAE,KAAK,CAAC;QACxD,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC7C,CAAC;QACD,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAChD,MAAM,EAAE,GAAG,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC;YACnC,OAAO,EAAE,CAAC,kBAAkB,EAAE,CAAC;QACjC,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;QACvD,CAAC;IACH,CAAC;IAED,iBAAiB,CAAC,OAAe,EAAE,SAAiB;QAClD,OAAO,OAAO,CAAC,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC,YAAY,CAAC,OAAuB,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;IACxG,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,GAAY,EAAE,OAAwB;QACtD,MAAM,GAAG,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,aAAa,EAAE,CAAC;QACrD,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,MAAM,IAAI,uBAAY,CAAC,0BAA0B,CAAC,CAAC;QACrD,CAAC;QACD,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;YAChC,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QACxC,CAAC;QACD,OAAO,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,YAAY,CAAC,OAAuB,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;IAChG,CAAC;IAEO,UAAU;QAChB,OAAO,IAAI,OAAO,CAAC,yBAAyB,CAAC,eAAK,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IAC3E,CAAC;IAED,kBAAkB;IAClB,iBAAiB,CAAC,MAA+B;QAC/C,sDAAsD;QACtD,MAAM,IAAI,oCAAyB,EAAE,CAAC;IACxC,CAAC;CACF;AAnVD,oBAmVC","sourcesContent":["import { FlareNetwork, BaseCoin as StaticsBaseCoin, CoinFamily, coins } from '@bitgo-beta/statics';\nimport {\n  BaseCoin,\n  BitGoBase,\n  KeyPair,\n  VerifyAddressOptions,\n  SignedTransaction,\n  ParseTransactionOptions,\n  BaseTransaction,\n  InvalidTransactionError,\n  SigningError,\n  TransactionType,\n  InvalidAddressError,\n  UnexpectedAddressError,\n  ITransactionRecipient,\n  ParsedTransaction,\n  MultisigType,\n  multisigTypes,\n  AuditDecryptedKeyParams,\n  MethodNotImplementedError,\n} from '@bitgo-beta/sdk-core';\nimport * as FlrpLib from './lib';\nimport {\n  FlrpSignTransactionOptions,\n  ExplainTransactionOptions,\n  FlrpVerifyTransactionOptions,\n  FlrpTransactionStakingOptions,\n  FlrpTransactionParams,\n} from './lib/iface';\nimport utils from './lib/utils';\nimport BigNumber from 'bignumber.js';\n\nexport class Flrp extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n\n  constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo);\n\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this._staticsCoin = staticsCoin;\n  }\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Flrp(bitgo, staticsCoin);\n  }\n\n  getChain(): string {\n    return this._staticsCoin.name;\n  }\n  getFamily(): CoinFamily {\n    return this._staticsCoin.family;\n  }\n  getFullName(): string {\n    return this._staticsCoin.fullName;\n  }\n  getBaseFactor(): string | number {\n    return Math.pow(10, this._staticsCoin.decimalPlaces);\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.onchain;\n  }\n\n  /**\n   * Check if staking txn is valid, based on expected tx params.\n   *\n   * @param {FlrpTransactionStakingOptions} stakingOptions expected staking params to check against\n   * @param {FlrpLib.TransactionExplanation} explainedTx explained staking transaction\n   */\n  validateStakingTx(stakingOptions: FlrpTransactionStakingOptions, explainedTx: FlrpLib.TransactionExplanation): void {\n    const filteredRecipients = [{ address: stakingOptions.nodeID, amount: stakingOptions.amount }];\n    const filteredOutputs = explainedTx.outputs.map((output) => utils.pick(output, ['address', 'amount']));\n\n    if (!utils.isEqual(filteredOutputs, filteredRecipients)) {\n      throw new Error('Tx outputs does not match with expected txParams');\n    }\n    if (stakingOptions?.amount !== explainedTx.outputAmount) {\n      throw new Error('Tx total amount does not match with expected total amount field');\n    }\n  }\n\n  /**\n   * Check if export txn is valid, based on expected tx params.\n   *\n   * @param {ITransactionRecipient[]} recipients expected recipients and info\n   * @param {FlrpLib.TransactionExplanation} explainedTx explained export transaction\n   */\n  validateExportTx(recipients: ITransactionRecipient[], explainedTx: FlrpLib.TransactionExplanation): void {\n    if (recipients.length !== 1 || explainedTx.outputs.length !== 1) {\n      throw new Error('Export Tx requires one recipient');\n    }\n\n    const maxImportFee = (this._staticsCoin.network as FlareNetwork).maxImportFee || '0';\n    const recipientAmount = new BigNumber(recipients[0].amount);\n    if (\n      recipientAmount.isGreaterThan(explainedTx.outputAmount) ||\n      recipientAmount.plus(maxImportFee).isLessThan(explainedTx.outputAmount)\n    ) {\n      throw new Error(\n        `Tx total amount ${explainedTx.outputAmount} does not match with expected total amount field ${recipientAmount} and max import fee ${maxImportFee}`\n      );\n    }\n\n    if (explainedTx.outputs && !utils.isValidAddress(explainedTx.outputs[0].address)) {\n      throw new Error(`Invalid P-chain address ${explainedTx.outputs[0].address}`);\n    }\n  }\n\n  /**\n   * Check if import txn into P is valid, based on expected tx params.\n   *\n   * @param {FlrpLib.FlrpEntry[]} explainedTxInputs tx inputs (unspents to be imported)\n   * @param {FlrpTransactionParams} txParams expected tx info to check against\n   */\n  validateImportTx(explainedTxInputs: FlrpLib.FlrpEntry[], txParams: FlrpTransactionParams): void {\n    if (txParams.unspents) {\n      if (explainedTxInputs.length !== txParams.unspents.length) {\n        throw new Error(`Expected ${txParams.unspents.length} UTXOs, transaction had ${explainedTxInputs.length}`);\n      }\n\n      const unspents = new Set(txParams.unspents);\n\n      for (const unspent of explainedTxInputs) {\n        if (!unspents.has(unspent.id)) {\n          throw new Error(`Transaction should not contain the UTXO: ${unspent.id}`);\n        }\n      }\n    }\n  }\n\n  async verifyTransaction(params: FlrpVerifyTransactionOptions): Promise<boolean> {\n    const txHex = params.txPrebuild && params.txPrebuild.txHex;\n    if (!txHex) {\n      throw new Error('missing required tx prebuild property txHex');\n    }\n    let tx;\n    try {\n      const txBuilder = this.getBuilder().from(txHex);\n      tx = await txBuilder.build();\n    } catch (error) {\n      throw new Error('Invalid transaction');\n    }\n    const explainedTx = tx.explainTransaction();\n\n    const { type, stakingOptions } = params.txParams;\n    // TODO(BG-62112): change ImportToC type to Import\n    if (!type || (type !== 'ImportToC' && explainedTx.type !== TransactionType[type])) {\n      throw new Error('Tx type does not match with expected txParams type');\n    }\n\n    switch (explainedTx.type) {\n      // @deprecated\n      case TransactionType.AddDelegator:\n      case TransactionType.AddValidator:\n      case TransactionType.AddPermissionlessDelegator:\n      case TransactionType.AddPermissionlessValidator:\n        if (stakingOptions) {\n          this.validateStakingTx(stakingOptions, explainedTx);\n        }\n        break;\n      case TransactionType.Export:\n        if (!params.txParams.recipients || params.txParams.recipients?.length !== 1) {\n          throw new Error('Export Tx requires a recipient');\n        } else {\n          this.validateExportTx(params.txParams.recipients, explainedTx);\n        }\n        break;\n      case TransactionType.Import:\n        if (tx.isTransactionForCChain) {\n          // Import to C-chain\n          if (explainedTx.outputs.length !== 1) {\n            throw new Error('Expected 1 output in import transaction');\n          }\n          if (!params.txParams.recipients || params.txParams.recipients.length !== 1) {\n            throw new Error('Expected 1 recipient in import transaction');\n          }\n        } else {\n          // Import to P-chain\n          if (explainedTx.outputs.length !== 1) {\n            throw new Error('Expected 1 output in import transaction');\n          }\n          this.validateImportTx(explainedTx.inputs, params.txParams);\n        }\n        break;\n      default:\n        throw new Error('Tx type is not supported yet');\n    }\n    return true;\n  }\n\n  /**\n   * Check if address is valid, then make sure it matches the root address.\n   *\n   * @param params.address address to validate\n   * @param params.keychains public keys to generate the wallet\n   */\n  async isWalletAddress(params: VerifyAddressOptions): Promise<boolean> {\n    const { address, keychains } = params;\n\n    if (!this.isValidAddress(address)) {\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n    if (!keychains || keychains.length !== 3) {\n      throw new Error('Invalid keychains');\n    }\n\n    // multisig addresses are separated by ~\n    const splitAddresses = address.split('~');\n\n    // derive addresses from keychain\n    const unlockAddresses = keychains.map((keychain) =>\n      new FlrpLib.KeyPair({ pub: keychain.pub }).getAddress(this._staticsCoin.network.type)\n    );\n\n    if (splitAddresses.length !== unlockAddresses.length) {\n      throw new UnexpectedAddressError(`address validation failure: multisig address length does not match`);\n    }\n\n    if (!this.adressesArraysMatch(splitAddresses, unlockAddresses)) {\n      throw new UnexpectedAddressError(`address validation failure: ${address} is not of this wallet`);\n    }\n\n    return true;\n  }\n\n  /**\n   * Validate that two multisig address arrays have the same elements, order doesnt matter\n   * @param addressArray1\n   * @param addressArray2\n   * @returns true if address arrays have the same addresses\n   * @private\n   */\n  private adressesArraysMatch(addressArray1: string[], addressArray2: string[]) {\n    return JSON.stringify(addressArray1.sort()) === JSON.stringify(addressArray2.sort());\n  }\n\n  /**\n   * Generate Flrp key pair\n   *\n   * @param {Buffer} seed - Seed from which the new keypair should be generated, otherwise a random seed is used\n   * @returns {Object} object with generated pub and prv\n   */\n  generateKeyPair(seed?: Buffer): KeyPair {\n    const keyPair = seed ? new FlrpLib.KeyPair({ seed }) : new FlrpLib.KeyPair();\n    const keys = keyPair.getKeys();\n\n    if (!keys.prv) {\n      throw new Error('Missing prv in key generation.');\n    }\n\n    return {\n      pub: keys.pub,\n      prv: keys.prv,\n    };\n  }\n\n  /**\n   * Return boolean indicating whether input is valid public key for the coin\n   *\n   * @param {string} pub the prv to be checked\n   * @returns is it valid?\n   */\n  isValidPub(pub: string): boolean {\n    try {\n      new FlrpLib.KeyPair({ pub });\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Return boolean indicating whether input is valid private key for the coin\n   *\n   * @param {string} prv the prv to be checked\n   * @returns is it valid?\n   */\n  isValidPrv(prv: string): boolean {\n    try {\n      new FlrpLib.KeyPair({ prv });\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  isValidAddress(address: string | string[]): boolean {\n    if (address === undefined) {\n      return false;\n    }\n\n    // validate eth address for cross-chain txs to c-chain\n    if (typeof address === 'string' && utils.isValidEthereumAddress(address)) {\n      return true;\n    }\n\n    return FlrpLib.Utils.isValidAddress(address);\n  }\n\n  /**\n   * Signs Flrp transaction\n   */\n  async signTransaction(params: FlrpSignTransactionOptions): Promise<SignedTransaction> {\n    // deserialize raw transaction (note: fromAddress has onchain order)\n    const txBuilder = this.getBuilder().from(params.txPrebuild.txHex);\n    const key = params.prv;\n\n    // push the keypair to signer array\n    txBuilder.sign({ key });\n\n    // build the transaction\n    const transaction: BaseTransaction = await txBuilder.build();\n    if (!transaction) {\n      throw new InvalidTransactionError('Error while trying to build transaction');\n    }\n    return transaction.signature.length >= 2\n      ? { txHex: transaction.toBroadcastFormat() }\n      : { halfSigned: { txHex: transaction.toBroadcastFormat() } };\n  }\n\n  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    return {};\n  }\n\n  /**\n   * Explain a Flrp transaction from txHex\n   * @param params\n   * @param callback\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<FlrpLib.TransactionExplanation> {\n    const txHex = params.txHex ?? params?.halfSigned?.txHex;\n    if (!txHex) {\n      throw new Error('missing transaction hex');\n    }\n    try {\n      const txBuilder = this.getBuilder().from(txHex);\n      const tx = await txBuilder.build();\n      return tx.explainTransaction();\n    } catch (e) {\n      throw new Error(`Invalid transaction: ${e.message}`);\n    }\n  }\n\n  recoverySignature(message: Buffer, signature: Buffer): Buffer {\n    return FlrpLib.Utils.recoverySignature(this._staticsCoin.network as FlareNetwork, message, signature);\n  }\n\n  async signMessage(key: KeyPair, message: string | Buffer): Promise<Buffer> {\n    const prv = new FlrpLib.KeyPair(key).getPrivateKey();\n    if (!prv) {\n      throw new SigningError('Invalid key pair options');\n    }\n    if (typeof message === 'string') {\n      message = Buffer.from(message, 'hex');\n    }\n    return FlrpLib.Utils.createSignature(this._staticsCoin.network as FlareNetwork, message, prv);\n  }\n\n  private getBuilder(): FlrpLib.TransactionBuilderFactory {\n    return new FlrpLib.TransactionBuilderFactory(coins.get(this.getChain()));\n  }\n\n  /** @inheritDoc */\n  auditDecryptedKey(params: AuditDecryptedKeyParams): void {\n    /** https://bitgoinc.atlassian.net/browse/COIN-4213 */\n    throw new MethodNotImplementedError();\n  }\n}\n"]}

package/dist/src/lib/atomicTransactionBuilder.d.ts

@@ -1,12 +1,16 @@
 import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
-import { TransactionType } from '@bitgo-beta/sdk-core';
+import { TransactionType, BaseTransaction } from '@bitgo-beta/sdk-core';
+import { Credential, TransferableInput, TransferableOutput } from '@flarenetwork/flarejs';
+import { TransactionExplanation, DecodedUtxoObj } from './iface';
 /**
- * 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 declare abstract class AtomicTransactionBuilder {
     protected readonly _coinConfig: Readonly<CoinConfig>;
     protected _externalChainId: Buffer | undefined;
+    protected _utxos: DecodedUtxoObj[];
     protected transaction: {
         _network: Record<string, unknown>;
         _networkID: number;
@@ -29,16 +33,61 @@ export declare abstract class AtomicTransactionBuilder {
     protected abstract get transactionType(): TransactionType;
     validateAmount(amount: bigint): void;
     /**
-     * Placeholder that should assemble inputs/outputs and credentials once UTXO + key logic is implemented.
+     * Validates that credentials array is properly formed
+     * @param credentials - Array of credentials to validate
      */
-    protected createInputOutput(_total: bigint): {
-        inputs: unknown[];
-        outputs: unknown[];
-        credentials: unknown[];
+    protected validateCredentials(credentials: Credential[]): void;
+    /**
+     * Creates inputs, outputs, and credentials for Flare P-chain atomic transactions.
+     * Based on AVAX P-chain implementation adapted for FlareJS.
+     *
+     * Note: This is a simplified implementation that creates the core structure.
+     * The FlareJS type system integration will be refined in future iterations.
+     *
+     * @param total - Total amount needed including fees
+     * @returns Object containing TransferableInput[], TransferableOutput[], and Credential[]
+     */
+    protected createInputOutput(total: bigint): {
+        inputs: TransferableInput[];
+        outputs: TransferableOutput[];
+        credentials: Credential[];
     };
+    /**
+     * Set UTXOs for the transaction. This is required for creating inputs and outputs.
+     *
+     * @param utxos - Array of decoded UTXO objects
+     * @returns this builder instance for chaining
+     */
+    utxos(utxos: DecodedUtxoObj[]): this;
+    /**
+     * 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;
     /**
      * Base initBuilder used by concrete builders. For now just returns this so fluent API works.
      */
     initBuilder(_tx: unknown): this;
+    /**
+     * Sign transaction with private key (placeholder implementation)
+     * TODO: Implement proper FlareJS signing
+     */
+    sign(_params: {
+        key: string;
+    }): this;
+    /**
+     * Build the transaction (placeholder implementation)
+     * TODO: Implement proper FlareJS transaction building
+     */
+    build(): Promise<BaseTransaction>;
+    /**
+     * Parse and explain a transaction from hex (placeholder implementation)
+     * TODO: Implement proper FlareJS transaction parsing
+     */
+    explainTransaction(): TransactionExplanation;
 }
 //# sourceMappingURL=atomicTransactionBuilder.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"atomicTransactionBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/atomicTransactionBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAyB,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE9E;;;GAGG;AACH,8BAAsB,wBAAwB;IAC5C,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC;IAErD,SAAS,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IAI/C,SAAS,CAAC,WAAW,EAAE;QACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAClC,UAAU,EAAE,MAAM,CAAC;QACnB,aAAa,EAAE,MAAM,CAAC;QACtB,QAAQ,EAAE,MAAM,CAAC;QACjB,cAAc,EAAE,MAAM,EAAE,CAAC;QACzB,GAAG,EAAE,MAAM,EAAE,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QACvD,cAAc,EAAE,OAAO,CAAC;QACxB,GAAG,CAAC,EAAE,OAAO,CAAC;QACd,cAAc,EAAE,CAAC,EAAE,EAAE,OAAO,KAAK,IAAI,CAAC;KACvC,CAcC;gBAEU,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI5C,SAAS,CAAC,QAAQ,KAAK,eAAe,IAAI,eAAe,CAAC;IAE1D,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAMpC;;OAEG;IACH,SAAS,CAAC,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG;QAAE,MAAM,EAAE,OAAO,EAAE,CAAC;QAAC,OAAO,EAAE,OAAO,EAAE,CAAC;QAAC,WAAW,EAAE,OAAO,EAAE,CAAA;KAAE;IAI9G;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;CAGhC"}
+{"version":3,"file":"atomicTransactionBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/atomicTransactionBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAyB,eAAe,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC/F,OAAO,EAAE,UAAU,EAAa,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACrG,OAAO,EAAE,sBAAsB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAKjE;;;;GAIG;AACH,8BAAsB,wBAAwB;IAC5C,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC;IAErD,SAAS,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IAE/C,SAAS,CAAC,MAAM,EAAE,cAAc,EAAE,CAAM;IAExC,SAAS,CAAC,WAAW,EAAE;QACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAClC,UAAU,EAAE,MAAM,CAAC;QACnB,aAAa,EAAE,MAAM,CAAC;QACtB,QAAQ,EAAE,MAAM,CAAC;QACjB,cAAc,EAAE,MAAM,EAAE,CAAC;QACzB,GAAG,EAAE,MAAM,EAAE,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QACvD,cAAc,EAAE,OAAO,CAAC;QACxB,GAAG,CAAC,EAAE,OAAO,CAAC;QACd,cAAc,EAAE,CAAC,EAAE,EAAE,OAAO,KAAK,IAAI,CAAC;KACvC,CAcC;gBAEU,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI5C,SAAS,CAAC,QAAQ,KAAK,eAAe,IAAI,eAAe,CAAC;IAE1D,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAMpC;;;OAGG;IACH,SAAS,CAAC,mBAAmB,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,IAAI;IAY9D;;;;;;;;;OASG;IACH,SAAS,CAAC,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG;QAC1C,MAAM,EAAE,iBAAiB,EAAE,CAAC;QAC5B,OAAO,EAAE,kBAAkB,EAAE,CAAC;QAC9B,WAAW,EAAE,UAAU,EAAE,CAAC;KAC3B;IAmED;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,IAAI;IAKpC;;;;;;;OAOG;IACH,SAAS,CAAC,qBAAqB,CAAC,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,UAAU;IAmDxF;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAI/B;;;OAGG;IACH,IAAI,CAAC,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAOpC;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,eAAe,CAAC;IAuCvC;;;OAGG;IACH,kBAAkB,IAAI,sBAAsB;CAe7C"}