@bitgo-beta/sdk-coin-flrp 1.0.0-alpha.4 → 1.0.0-alpha.41

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

@@ -0,0 +1,56 @@
+import { FlareNetwork, BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { BaseKey, BaseTransaction, Entry, TransactionType, TransactionFee } from '@bitgo-beta/sdk-core';
+import { Credential } from '@flarenetwork/flarejs';
+import { Buffer } from 'buffer';
+import { DecodedUtxoObj, TransactionExplanation, Tx, TxData } from './iface';
+import { KeyPair } from './keyPair';
+export declare class Transaction extends BaseTransaction {
+    protected _flareTransaction: Tx;
+    _type: TransactionType;
+    _network: FlareNetwork;
+    _networkID: number;
+    _assetId: string;
+    _blockchainID: string;
+    _nodeID: string;
+    _startTime: bigint;
+    _endTime: bigint;
+    _stakeAmount: bigint;
+    _threshold: number;
+    _locktime: bigint;
+    _fromAddresses: Uint8Array[];
+    _to: Uint8Array[];
+    _rewardAddresses: Uint8Array[];
+    _utxos: DecodedUtxoObj[];
+    _fee: Partial<TransactionFee>;
+    _rawSignedBytes: Buffer | undefined;
+    constructor(coinConfig: Readonly<CoinConfig>);
+    get signature(): string[];
+    get credentials(): Credential[];
+    get hasCredentials(): boolean;
+    /** @inheritdoc */
+    canSign({ key }: BaseKey): boolean;
+    sign(keyPair: KeyPair): Promise<void>;
+    toBroadcastFormat(): string;
+    toJson(): TxData;
+    setTransaction(tx: Tx): void;
+    /**
+     * Get the underlying Flare transaction
+     * @returns The Flare transaction object
+     */
+    getFlareTransaction(): Tx;
+    setTransactionType(transactionType: TransactionType): void;
+    get signablePayload(): Buffer;
+    get id(): string;
+    get fromAddresses(): string[];
+    get rewardAddresses(): string[];
+    get fee(): TransactionFee;
+    /**
+     * Check if this transaction is for C-chain (EVM transactions)
+     */
+    get isTransactionForCChain(): boolean;
+    get outputs(): Entry[];
+    get changeOutputs(): Entry[];
+    get inputs(): Entry[];
+    explainTransaction(): TransactionExplanation;
+}
+//# sourceMappingURL=transaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EACL,OAAO,EACP,eAAe,EACf,KAAK,EAGL,eAAe,EACf,cAAc,EACf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,UAAU,EAOX,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,EAAE,EAAE,MAAM,EAA2C,MAAM,SAAS,CAAC;AACtH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgEpC,qBAAa,WAAY,SAAQ,eAAe;IAC9C,SAAS,CAAC,iBAAiB,EAAE,EAAE,CAAC;IACzB,KAAK,EAAE,eAAe,CAAC;IACvB,QAAQ,EAAE,YAAY,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,SAAK;IACf,SAAS,SAAa;IACtB,cAAc,EAAE,UAAU,EAAE,CAAM;IAClC,GAAG,EAAE,UAAU,EAAE,CAAM;IACvB,gBAAgB,EAAE,UAAU,EAAE,CAAM;IACpC,MAAM,EAAE,cAAc,EAAE,CAAM;IAC9B,IAAI,EAAE,OAAO,CAAC,cAAc,CAAC,CAAM;IAEnC,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;gBAE/B,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAS5C,IAAI,SAAS,IAAI,MAAM,EAAE,CAKxB;IAED,IAAI,WAAW,IAAI,UAAU,EAAE,CAE9B;IAED,IAAI,cAAc,IAAI,OAAO,CAE5B;IAED,kBAAkB;IAClB,OAAO,CAAC,EAAE,GAAG,EAAE,EAAE,OAAO,GAAG,OAAO;IAI5B,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAuF3C,iBAAiB,IAAI,MAAM;IAkB3B,MAAM,IAAI,MAAM;IAiBhB,cAAc,CAAC,EAAE,EAAE,EAAE,GAAG,IAAI;IAI5B;;;OAGG;IACH,mBAAmB,IAAI,EAAE;IAIzB,kBAAkB,CAAC,eAAe,EAAE,eAAe,GAAG,IAAI;IAO1D,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED,IAAI,EAAE,IAAI,MAAM,CAGf;IAED,IAAI,aAAa,IAAI,MAAM,EAAE,CAE5B;IAED,IAAI,eAAe,IAAI,MAAM,EAAE,CAE9B;IAED,IAAI,GAAG,IAAI,cAAc,CAExB;IAED;;OAEG;IACH,IAAI,sBAAsB,IAAI,OAAO,CAIpC;IAED,IAAI,OAAO,IAAI,KAAK,EAAE,CAwCrB;IAED,IAAI,aAAa,IAAI,KAAK,EAAE,CAmB3B;IAED,IAAI,MAAM,IAAI,KAAK,EAAE,CAsDpB;IAED,kBAAkB,IAAI,sBAAsB;CA0B7C"}

package/dist/src/lib/transaction.js

@@ -0,0 +1,380 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const flarejs_1 = require("@flarenetwork/flarejs");
+const buffer_1 = require("buffer");
+const crypto_1 = require("crypto");
+const iface_1 = require("./iface");
+const utils_1 = __importDefault(require("./utils"));
+/**
+ * Checks if a signature is empty (first 90 hex chars are zeros)
+ * @param signature
+ * @returns {boolean}
+ */
+function isEmptySignature(signature) {
+    return !!signature && utils_1.default.removeHexPrefix(signature).startsWith(''.padStart(90, '0'));
+}
+/**
+ * Checks if an empty signature has an embedded address (non-zero bytes after position 90)
+ * @param signature Hex string of the signature
+ */
+function hasEmbeddedAddress(signature) {
+    if (!isEmptySignature(signature))
+        return false;
+    const cleanSig = utils_1.default.removeHexPrefix(signature);
+    if (cleanSig.length < 130)
+        return false;
+    const embeddedPart = cleanSig.substring(90, 130);
+    // Check if it's not all zeros
+    return embeddedPart !== '0'.repeat(40);
+}
+/**
+ * Generates a function to check if a signature slot matches a given address.
+ * If signatures have embedded addresses, it matches by address.
+ * Otherwise, it just finds empty slots.
+ * @param signatures Array of signature hex strings
+ */
+function generateSelectorSignature(signatures) {
+    // Check if any empty signature has an embedded address
+    const hasEmbeddedAddresses = signatures.some((sig) => isEmptySignature(sig) && hasEmbeddedAddress(sig));
+    if (hasEmbeddedAddresses) {
+        // Look for address embedded in the empty signature (after position 90)
+        return function (sig, address) {
+            try {
+                if (!isEmptySignature(sig)) {
+                    return false;
+                }
+                const cleanSig = utils_1.default.removeHexPrefix(sig);
+                const embeddedAddr = cleanSig.substring(90, 130).toLowerCase();
+                return embeddedAddr === address.toLowerCase();
+            }
+            catch (e) {
+                return false;
+            }
+        };
+    }
+    else {
+        // Look for any empty slot (no embedded addresses)
+        return function (sig, address) {
+            return isEmptySignature(sig);
+        };
+    }
+}
+class Transaction extends sdk_core_1.BaseTransaction {
+    constructor(coinConfig) {
+        super(coinConfig);
+        this._threshold = 2;
+        this._locktime = BigInt(0);
+        this._fromAddresses = [];
+        this._to = [];
+        this._rewardAddresses = [];
+        this._utxos = []; // Define proper type based on Flare's UTXO structure
+        this._fee = {};
+        this._network = coinConfig.network;
+        // Decode cb58-encoded asset ID to hex for use in transaction serialization
+        this._assetId = utils_1.default.cb58Decode(this._network.assetId).toString('hex');
+        this._blockchainID = this._network.blockchainID;
+        this._networkID = this._network.networkID;
+    }
+    get signature() {
+        if (!this.hasCredentials) {
+            return [];
+        }
+        return this.credentials[0].getSignatures().filter((s) => !isEmptySignature(s));
+    }
+    get credentials() {
+        return this._flareTransaction?.credentials;
+    }
+    get hasCredentials() {
+        return this.credentials !== undefined && this.credentials.length > 0;
+    }
+    /** @inheritdoc */
+    canSign({ key }) {
+        return true;
+    }
+    async sign(keyPair) {
+        const prv = keyPair.getPrivateKey();
+        if (!prv) {
+            throw new sdk_core_1.SigningError('Missing private key');
+        }
+        if (!this._flareTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('empty transaction to sign');
+        }
+        if (!this.hasCredentials) {
+            throw new sdk_core_1.InvalidTransactionError('empty credentials to sign');
+        }
+        const unsignedTx = this._flareTransaction;
+        const unsignedBytes = unsignedTx.toBytes();
+        const publicKey = flarejs_1.secp256k1.getPublicKey(prv);
+        // Derive both EVM and P-chain addresses from the public key
+        const evmAddressHex = new flarejs_1.Address(flarejs_1.secp256k1.publicKeyToEthAddress(publicKey)).toHex();
+        // P-chain address derivation: ripemd160(sha256(publicKey))
+        const sha256Hash = (0, crypto_1.createHash)('sha256').update(buffer_1.Buffer.from(publicKey)).digest();
+        const pChainAddressBuffer = (0, crypto_1.createHash)('ripemd160').update(sha256Hash).digest();
+        const pChainAddressHex = pChainAddressBuffer.toString('hex');
+        const addressMap = unsignedTx.getAddresses();
+        // Check for both EVM and P-chain address formats
+        const hasMatchingAddress = addressMap.some((addr) => {
+            const addrHex = buffer_1.Buffer.from(addr).toString('hex').toLowerCase();
+            return (addrHex === utils_1.default.removeHexPrefix(evmAddressHex).toLowerCase() || addrHex === pChainAddressHex.toLowerCase());
+        });
+        const signature = await flarejs_1.secp256k1.sign(unsignedBytes, prv);
+        let signatureSet = false;
+        if (hasMatchingAddress) {
+            // Use address-based slot matching (like AVAX-P)
+            let checkSign = undefined;
+            for (const credential of unsignedTx.credentials) {
+                const signatures = credential.getSignatures();
+                if (checkSign === undefined) {
+                    checkSign = generateSelectorSignature(signatures);
+                }
+                // Find the slot that matches this address
+                for (let i = 0; i < signatures.length; i++) {
+                    const sig = signatures[i];
+                    // Try matching with P-chain address first, then EVM address
+                    if (checkSign(sig, pChainAddressHex) || checkSign(sig, utils_1.default.removeHexPrefix(evmAddressHex).toLowerCase())) {
+                        credential.setSignature(i, signature);
+                        signatureSet = true;
+                        // Clear raw signed bytes since we've modified the transaction
+                        this._rawSignedBytes = undefined;
+                        break;
+                    }
+                }
+                if (signatureSet)
+                    break;
+            }
+        }
+        // Fallback: If address-based matching didn't work (e.g., ImportInC loaded from unsigned tx
+        // where P-chain addresses aren't in addressMaps), try to sign the first empty slot.
+        // This handles the case where we have empty credentials but signer address isn't in the map.
+        if (!signatureSet) {
+            for (const credential of unsignedTx.credentials) {
+                const signatures = credential.getSignatures();
+                for (let i = 0; i < signatures.length; i++) {
+                    if (isEmptySignature(signatures[i])) {
+                        credential.setSignature(i, signature);
+                        signatureSet = true;
+                        this._rawSignedBytes = undefined;
+                        break;
+                    }
+                }
+                if (signatureSet)
+                    break;
+            }
+        }
+        if (!signatureSet) {
+            throw new sdk_core_1.SigningError('No matching signature slot found for this private key');
+        }
+    }
+    toBroadcastFormat() {
+        if (!this._flareTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction data');
+        }
+        // If we have the original raw signed bytes, use them directly to preserve exact format
+        if (this._rawSignedBytes) {
+            return flarejs_1.utils.bufferToHex(this._rawSignedBytes);
+        }
+        const unsignedTx = this._flareTransaction;
+        // For signed transactions, return the full signed tx with credentials
+        // Check signature.length for robustness
+        if (this.signature.length > 0) {
+            return flarejs_1.utils.bufferToHex(unsignedTx.getSignedTx().toBytes());
+        }
+        // For unsigned transactions, return just the transaction bytes
+        return flarejs_1.utils.bufferToHex(unsignedTx.toBytes());
+    }
+    toJson() {
+        if (!this._flareTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction data');
+        }
+        return {
+            id: this.id,
+            inputs: this.inputs,
+            fromAddresses: this.fromAddresses,
+            threshold: this._threshold,
+            locktime: this._locktime.toString(),
+            type: this.type,
+            signatures: this.signature,
+            outputs: this.outputs,
+            changeOutputs: this.changeOutputs,
+        };
+    }
+    setTransaction(tx) {
+        this._flareTransaction = tx;
+    }
+    /**
+     * Get the underlying Flare transaction
+     * @returns The Flare transaction object
+     */
+    getFlareTransaction() {
+        return this._flareTransaction;
+    }
+    setTransactionType(transactionType) {
+        if (![sdk_core_1.TransactionType.AddPermissionlessValidator].includes(transactionType)) {
+            throw new Error(`Transaction type ${transactionType} is not supported`);
+        }
+        this._type = transactionType;
+    }
+    get signablePayload() {
+        return utils_1.default.sha256(this._flareTransaction.toBytes());
+    }
+    get id() {
+        const bufferArray = utils_1.default.sha256(this._flareTransaction.toBytes());
+        return utils_1.default.cb58Encode(buffer_1.Buffer.from(bufferArray));
+    }
+    get fromAddresses() {
+        return this._fromAddresses.map((a) => flarejs_1.utils.format(this._network.alias, this._network.hrp, a));
+    }
+    get rewardAddresses() {
+        return this._rewardAddresses.map((a) => flarejs_1.utils.format(this._network.alias, this._network.hrp, a));
+    }
+    get fee() {
+        return { fee: '0', ...this._fee };
+    }
+    /**
+     * Check if this transaction is for C-chain (EVM transactions)
+     */
+    get isTransactionForCChain() {
+        const tx = this._flareTransaction.getTx();
+        const txType = tx._type;
+        return txType === iface_1.FlareTransactionType.EvmExportTx || txType === iface_1.FlareTransactionType.EvmImportTx;
+    }
+    get outputs() {
+        const tx = this._flareTransaction.getTx();
+        switch (this.type) {
+            case sdk_core_1.TransactionType.Import:
+                if (this.isTransactionForCChain) {
+                    // C-chain Import: output is to a C-chain address
+                    const importTx = tx;
+                    return importTx.Outs.map((out) => ({
+                        address: '0x' + buffer_1.Buffer.from(out.address.toBytes()).toString('hex'),
+                        value: out.amount.value().toString(),
+                    }));
+                }
+                else {
+                    // P-chain Import: outputs are the baseTx.outputs (destination on P-chain)
+                    const pvmImportTx = tx;
+                    return pvmImportTx.baseTx.outputs.map(utils_1.default.mapOutputToEntry(this._network));
+                }
+            case sdk_core_1.TransactionType.Export:
+                if (this.isTransactionForCChain) {
+                    // C-chain Export: exported outputs go to P-chain
+                    const exportTx = tx;
+                    return exportTx.exportedOutputs.map(utils_1.default.mapOutputToEntry(this._network));
+                }
+                else {
+                    // P-chain Export: exported outputs go to C-chain
+                    const pvmExportTx = tx;
+                    return pvmExportTx.outs.map(utils_1.default.mapOutputToEntry(this._network));
+                }
+            case sdk_core_1.TransactionType.AddPermissionlessValidator:
+                return [
+                    {
+                        address: tx.subnetValidator.validator.nodeId.toString(),
+                        value: tx.subnetValidator.validator.weight.toJSON(),
+                    },
+                ];
+            default:
+                return [];
+        }
+    }
+    get changeOutputs() {
+        const tx = this._flareTransaction.getTx();
+        // C-chain transactions and Import transactions don't have change outputs
+        if (this.isTransactionForCChain || this.type === sdk_core_1.TransactionType.Import) {
+            return [];
+        }
+        switch (this.type) {
+            case sdk_core_1.TransactionType.Export:
+                // P-chain Export: change outputs are in baseTx.outputs
+                return tx.baseTx.outputs.map(utils_1.default.mapOutputToEntry(this._network));
+            case sdk_core_1.TransactionType.AddPermissionlessValidator:
+                return tx.baseTx.outputs.map(utils_1.default.mapOutputToEntry(this._network));
+            default:
+                return [];
+        }
+    }
+    get inputs() {
+        const tx = this._flareTransaction.getTx();
+        switch (this.type) {
+            case sdk_core_1.TransactionType.Import:
+                if (this.isTransactionForCChain) {
+                    // C-chain Import: inputs come from P-chain (importedInputs)
+                    const importTx = tx;
+                    return importTx.importedInputs.map((input) => ({
+                        id: utils_1.default.cb58Encode(buffer_1.Buffer.from(input.utxoID.txID.toBytes())) + ':' + input.utxoID.outputIdx.value(),
+                        address: this.fromAddresses.sort().join(iface_1.ADDRESS_SEPARATOR),
+                        value: input.amount().toString(),
+                    }));
+                }
+                else {
+                    // P-chain Import: inputs are ins (imported from C-chain)
+                    const pvmImportTx = tx;
+                    return pvmImportTx.ins.map((input) => ({
+                        id: utils_1.default.cb58Encode(buffer_1.Buffer.from(input.utxoID.txID.toBytes())) + ':' + input.utxoID.outputIdx.value(),
+                        address: this.fromAddresses.sort().join(iface_1.ADDRESS_SEPARATOR),
+                        value: input.amount().toString(),
+                    }));
+                }
+            case sdk_core_1.TransactionType.Export:
+                if (this.isTransactionForCChain) {
+                    // C-chain Export: inputs are from C-chain (EVM inputs)
+                    const exportTx = tx;
+                    return exportTx.ins.map((evmInput) => ({
+                        address: '0x' + buffer_1.Buffer.from(evmInput.address.toBytes()).toString('hex'),
+                        value: evmInput.amount.value().toString(),
+                        nonce: Number(evmInput.nonce.value()),
+                    }));
+                }
+                else {
+                    // P-chain Export: inputs are from baseTx.inputs
+                    const pvmExportTx = tx;
+                    return pvmExportTx.baseTx.inputs.map((input) => ({
+                        id: utils_1.default.cb58Encode(buffer_1.Buffer.from(input.utxoID.txID.toBytes())) + ':' + input.utxoID.outputIdx.value(),
+                        address: this.fromAddresses.sort().join(iface_1.ADDRESS_SEPARATOR),
+                        value: input.amount().toString(),
+                    }));
+                }
+            case sdk_core_1.TransactionType.AddPermissionlessValidator:
+            default:
+                const baseTx = tx;
+                if (baseTx.baseTx?.inputs) {
+                    return baseTx.baseTx.inputs.map((input) => ({
+                        id: utils_1.default.cb58Encode(buffer_1.Buffer.from(input.utxoID.txID.toBytes())) + ':' + input.utxoID.outputIdx.value(),
+                        address: this.fromAddresses.sort().join(iface_1.ADDRESS_SEPARATOR),
+                        value: input.amount().toString(),
+                    }));
+                }
+                return [];
+        }
+    }
+    explainTransaction() {
+        const txJson = this.toJson();
+        const displayOrder = ['id', 'inputs', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee', 'type'];
+        const outputAmount = txJson.outputs.reduce((p, n) => p + BigInt(n.value), BigInt(0)).toString();
+        const changeAmount = txJson.changeOutputs.reduce((p, n) => p + BigInt(n.value), BigInt(0)).toString();
+        let rewardAddresses;
+        if ([sdk_core_1.TransactionType.AddPermissionlessValidator].includes(txJson.type)) {
+            rewardAddresses = this.rewardAddresses;
+            displayOrder.splice(6, 0, 'rewardAddresses');
+        }
+        return {
+            displayOrder,
+            id: txJson.id,
+            inputs: txJson.inputs,
+            outputs: txJson.outputs.map((o) => ({ address: o.address, amount: o.value })),
+            outputAmount,
+            changeOutputs: txJson.changeOutputs.map((o) => ({ address: o.address, amount: o.value })),
+            changeAmount,
+            rewardAddresses,
+            fee: this.fee,
+            type: txJson.type,
+        };
+    }
+}
+exports.Transaction = Transaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { FlareNetwork, BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport {\n  BaseKey,\n  BaseTransaction,\n  Entry,\n  InvalidTransactionError,\n  SigningError,\n  TransactionType,\n  TransactionFee,\n} from '@bitgo-beta/sdk-core';\nimport {\n  utils as FlareUtils,\n  Credential,\n  pvmSerial,\n  evmSerial,\n  UnsignedTx,\n  secp256k1,\n  EVMUnsignedTx,\n  Address,\n} from '@flarenetwork/flarejs';\nimport { Buffer } from 'buffer';\nimport { createHash } from 'crypto';\nimport { DecodedUtxoObj, TransactionExplanation, Tx, TxData, ADDRESS_SEPARATOR, FlareTransactionType } from './iface';\nimport { KeyPair } from './keyPair';\nimport utils from './utils';\n\n/**\n * Checks if a signature is empty (first 90 hex chars are zeros)\n * @param signature\n * @returns {boolean}\n */\nfunction isEmptySignature(signature: string): boolean {\n  return !!signature && utils.removeHexPrefix(signature).startsWith(''.padStart(90, '0'));\n}\n\n/**\n * Interface for signature slot checking\n */\ninterface CheckSignature {\n  (signature: string, addressHex: string): boolean;\n}\n\n/**\n * Checks if an empty signature has an embedded address (non-zero bytes after position 90)\n * @param signature Hex string of the signature\n */\nfunction hasEmbeddedAddress(signature: string): boolean {\n  if (!isEmptySignature(signature)) return false;\n  const cleanSig = utils.removeHexPrefix(signature);\n  if (cleanSig.length < 130) return false;\n  const embeddedPart = cleanSig.substring(90, 130);\n  // Check if it's not all zeros\n  return embeddedPart !== '0'.repeat(40);\n}\n\n/**\n * Generates a function to check if a signature slot matches a given address.\n * If signatures have embedded addresses, it matches by address.\n * Otherwise, it just finds empty slots.\n * @param signatures Array of signature hex strings\n */\nfunction generateSelectorSignature(signatures: string[]): CheckSignature {\n  // Check if any empty signature has an embedded address\n  const hasEmbeddedAddresses = signatures.some((sig) => isEmptySignature(sig) && hasEmbeddedAddress(sig));\n\n  if (hasEmbeddedAddresses) {\n    // Look for address embedded in the empty signature (after position 90)\n    return function (sig: string, address: string): boolean {\n      try {\n        if (!isEmptySignature(sig)) {\n          return false;\n        }\n        const cleanSig = utils.removeHexPrefix(sig);\n        const embeddedAddr = cleanSig.substring(90, 130).toLowerCase();\n        return embeddedAddr === address.toLowerCase();\n      } catch (e) {\n        return false;\n      }\n    };\n  } else {\n    // Look for any empty slot (no embedded addresses)\n    return function (sig: string, address: string): boolean {\n      return isEmptySignature(sig);\n    };\n  }\n}\n\nexport class Transaction extends BaseTransaction {\n  protected _flareTransaction: Tx;\n  public _type: TransactionType;\n  public _network: FlareNetwork;\n  public _networkID: number;\n  public _assetId: string;\n  public _blockchainID: string;\n  public _nodeID: string;\n  public _startTime: bigint;\n  public _endTime: bigint;\n  public _stakeAmount: bigint;\n  public _threshold = 2;\n  public _locktime = BigInt(0);\n  public _fromAddresses: Uint8Array[] = [];\n  public _to: Uint8Array[] = [];\n  public _rewardAddresses: Uint8Array[] = [];\n  public _utxos: DecodedUtxoObj[] = []; // Define proper type based on Flare's UTXO structure\n  public _fee: Partial<TransactionFee> = {};\n  // Store original raw signed bytes to preserve exact format when re-serializing\n  public _rawSignedBytes: Buffer | undefined;\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    this._network = coinConfig.network as FlareNetwork;\n    // Decode cb58-encoded asset ID to hex for use in transaction serialization\n    this._assetId = utils.cb58Decode(this._network.assetId).toString('hex');\n    this._blockchainID = this._network.blockchainID;\n    this._networkID = this._network.networkID;\n  }\n\n  get signature(): string[] {\n    if (!this.hasCredentials) {\n      return [];\n    }\n    return this.credentials[0].getSignatures().filter((s) => !isEmptySignature(s));\n  }\n\n  get credentials(): Credential[] {\n    return (this._flareTransaction as UnsignedTx)?.credentials;\n  }\n\n  get hasCredentials(): boolean {\n    return this.credentials !== undefined && this.credentials.length > 0;\n  }\n\n  /** @inheritdoc */\n  canSign({ key }: BaseKey): boolean {\n    return true;\n  }\n\n  async sign(keyPair: KeyPair): Promise<void> {\n    const prv = keyPair.getPrivateKey() as Uint8Array;\n    if (!prv) {\n      throw new SigningError('Missing private key');\n    }\n    if (!this._flareTransaction) {\n      throw new InvalidTransactionError('empty transaction to sign');\n    }\n    if (!this.hasCredentials) {\n      throw new InvalidTransactionError('empty credentials to sign');\n    }\n\n    const unsignedTx = this._flareTransaction as EVMUnsignedTx;\n    const unsignedBytes = unsignedTx.toBytes();\n    const publicKey = secp256k1.getPublicKey(prv);\n\n    // Derive both EVM and P-chain addresses from the public key\n    const evmAddressHex = new Address(secp256k1.publicKeyToEthAddress(publicKey)).toHex();\n\n    // P-chain address derivation: ripemd160(sha256(publicKey))\n    const sha256Hash = createHash('sha256').update(Buffer.from(publicKey)).digest();\n    const pChainAddressBuffer = createHash('ripemd160').update(sha256Hash).digest();\n    const pChainAddressHex = pChainAddressBuffer.toString('hex');\n\n    const addressMap = unsignedTx.getAddresses();\n\n    // Check for both EVM and P-chain address formats\n    const hasMatchingAddress = addressMap.some((addr) => {\n      const addrHex = Buffer.from(addr).toString('hex').toLowerCase();\n      return (\n        addrHex === utils.removeHexPrefix(evmAddressHex).toLowerCase() || addrHex === pChainAddressHex.toLowerCase()\n      );\n    });\n\n    const signature = await secp256k1.sign(unsignedBytes, prv);\n    let signatureSet = false;\n\n    if (hasMatchingAddress) {\n      // Use address-based slot matching (like AVAX-P)\n      let checkSign: CheckSignature | undefined = undefined;\n\n      for (const credential of unsignedTx.credentials) {\n        const signatures = credential.getSignatures();\n        if (checkSign === undefined) {\n          checkSign = generateSelectorSignature(signatures);\n        }\n\n        // Find the slot that matches this address\n        for (let i = 0; i < signatures.length; i++) {\n          const sig = signatures[i];\n          // Try matching with P-chain address first, then EVM address\n          if (checkSign(sig, pChainAddressHex) || checkSign(sig, utils.removeHexPrefix(evmAddressHex).toLowerCase())) {\n            credential.setSignature(i, signature);\n            signatureSet = true;\n            // Clear raw signed bytes since we've modified the transaction\n            this._rawSignedBytes = undefined;\n            break;\n          }\n        }\n\n        if (signatureSet) break;\n      }\n    }\n\n    // Fallback: If address-based matching didn't work (e.g., ImportInC loaded from unsigned tx\n    // where P-chain addresses aren't in addressMaps), try to sign the first empty slot.\n    // This handles the case where we have empty credentials but signer address isn't in the map.\n    if (!signatureSet) {\n      for (const credential of unsignedTx.credentials) {\n        const signatures = credential.getSignatures();\n        for (let i = 0; i < signatures.length; i++) {\n          if (isEmptySignature(signatures[i])) {\n            credential.setSignature(i, signature);\n            signatureSet = true;\n            this._rawSignedBytes = undefined;\n            break;\n          }\n        }\n        if (signatureSet) break;\n      }\n    }\n\n    if (!signatureSet) {\n      throw new SigningError('No matching signature slot found for this private key');\n    }\n  }\n\n  toBroadcastFormat(): string {\n    if (!this._flareTransaction) {\n      throw new InvalidTransactionError('Empty transaction data');\n    }\n    // If we have the original raw signed bytes, use them directly to preserve exact format\n    if (this._rawSignedBytes) {\n      return FlareUtils.bufferToHex(this._rawSignedBytes);\n    }\n    const unsignedTx = this._flareTransaction as UnsignedTx;\n    // For signed transactions, return the full signed tx with credentials\n    // Check signature.length for robustness\n    if (this.signature.length > 0) {\n      return FlareUtils.bufferToHex(unsignedTx.getSignedTx().toBytes());\n    }\n    // For unsigned transactions, return just the transaction bytes\n    return FlareUtils.bufferToHex(unsignedTx.toBytes());\n  }\n\n  toJson(): TxData {\n    if (!this._flareTransaction) {\n      throw new InvalidTransactionError('Empty transaction data');\n    }\n    return {\n      id: this.id,\n      inputs: this.inputs,\n      fromAddresses: this.fromAddresses,\n      threshold: this._threshold,\n      locktime: this._locktime.toString(),\n      type: this.type,\n      signatures: this.signature,\n      outputs: this.outputs,\n      changeOutputs: this.changeOutputs,\n    };\n  }\n\n  setTransaction(tx: Tx): void {\n    this._flareTransaction = tx as UnsignedTx;\n  }\n\n  /**\n   * Get the underlying Flare transaction\n   * @returns The Flare transaction object\n   */\n  getFlareTransaction(): Tx {\n    return this._flareTransaction;\n  }\n\n  setTransactionType(transactionType: TransactionType): void {\n    if (![TransactionType.AddPermissionlessValidator].includes(transactionType)) {\n      throw new Error(`Transaction type ${transactionType} is not supported`);\n    }\n    this._type = transactionType;\n  }\n\n  get signablePayload(): Buffer {\n    return utils.sha256((this._flareTransaction as UnsignedTx).toBytes());\n  }\n\n  get id(): string {\n    const bufferArray = utils.sha256((this._flareTransaction as UnsignedTx).toBytes());\n    return utils.cb58Encode(Buffer.from(bufferArray));\n  }\n\n  get fromAddresses(): string[] {\n    return this._fromAddresses.map((a) => FlareUtils.format(this._network.alias, this._network.hrp, a));\n  }\n\n  get rewardAddresses(): string[] {\n    return this._rewardAddresses.map((a) => FlareUtils.format(this._network.alias, this._network.hrp, a));\n  }\n\n  get fee(): TransactionFee {\n    return { fee: '0', ...this._fee };\n  }\n\n  /**\n   * Check if this transaction is for C-chain (EVM transactions)\n   */\n  get isTransactionForCChain(): boolean {\n    const tx = (this._flareTransaction as UnsignedTx).getTx();\n    const txType = (tx as { _type?: string })._type;\n    return txType === FlareTransactionType.EvmExportTx || txType === FlareTransactionType.EvmImportTx;\n  }\n\n  get outputs(): Entry[] {\n    const tx = (this._flareTransaction as UnsignedTx).getTx();\n\n    switch (this.type) {\n      case TransactionType.Import:\n        if (this.isTransactionForCChain) {\n          // C-chain Import: output is to a C-chain address\n          const importTx = tx as evmSerial.ImportTx;\n          return importTx.Outs.map((out) => ({\n            address: '0x' + Buffer.from(out.address.toBytes()).toString('hex'),\n            value: out.amount.value().toString(),\n          }));\n        } else {\n          // P-chain Import: outputs are the baseTx.outputs (destination on P-chain)\n          const pvmImportTx = tx as pvmSerial.ImportTx;\n          return pvmImportTx.baseTx.outputs.map(utils.mapOutputToEntry(this._network));\n        }\n\n      case TransactionType.Export:\n        if (this.isTransactionForCChain) {\n          // C-chain Export: exported outputs go to P-chain\n          const exportTx = tx as evmSerial.ExportTx;\n          return exportTx.exportedOutputs.map(utils.mapOutputToEntry(this._network));\n        } else {\n          // P-chain Export: exported outputs go to C-chain\n          const pvmExportTx = tx as pvmSerial.ExportTx;\n          return pvmExportTx.outs.map(utils.mapOutputToEntry(this._network));\n        }\n\n      case TransactionType.AddPermissionlessValidator:\n        return [\n          {\n            address: (tx as pvmSerial.AddPermissionlessValidatorTx).subnetValidator.validator.nodeId.toString(),\n            value: (tx as pvmSerial.AddPermissionlessValidatorTx).subnetValidator.validator.weight.toJSON(),\n          },\n        ];\n\n      default:\n        return [];\n    }\n  }\n\n  get changeOutputs(): Entry[] {\n    const tx = (this._flareTransaction as UnsignedTx).getTx();\n\n    // C-chain transactions and Import transactions don't have change outputs\n    if (this.isTransactionForCChain || this.type === TransactionType.Import) {\n      return [];\n    }\n\n    switch (this.type) {\n      case TransactionType.Export:\n        // P-chain Export: change outputs are in baseTx.outputs\n        return (tx as pvmSerial.ExportTx).baseTx.outputs.map(utils.mapOutputToEntry(this._network));\n\n      case TransactionType.AddPermissionlessValidator:\n        return (tx as pvmSerial.AddPermissionlessValidatorTx).baseTx.outputs.map(utils.mapOutputToEntry(this._network));\n\n      default:\n        return [];\n    }\n  }\n\n  get inputs(): Entry[] {\n    const tx = (this._flareTransaction as UnsignedTx).getTx();\n\n    switch (this.type) {\n      case TransactionType.Import:\n        if (this.isTransactionForCChain) {\n          // C-chain Import: inputs come from P-chain (importedInputs)\n          const importTx = tx as evmSerial.ImportTx;\n          return importTx.importedInputs.map((input) => ({\n            id: utils.cb58Encode(Buffer.from(input.utxoID.txID.toBytes())) + ':' + input.utxoID.outputIdx.value(),\n            address: this.fromAddresses.sort().join(ADDRESS_SEPARATOR),\n            value: input.amount().toString(),\n          }));\n        } else {\n          // P-chain Import: inputs are ins (imported from C-chain)\n          const pvmImportTx = tx as pvmSerial.ImportTx;\n          return pvmImportTx.ins.map((input) => ({\n            id: utils.cb58Encode(Buffer.from(input.utxoID.txID.toBytes())) + ':' + input.utxoID.outputIdx.value(),\n            address: this.fromAddresses.sort().join(ADDRESS_SEPARATOR),\n            value: input.amount().toString(),\n          }));\n        }\n\n      case TransactionType.Export:\n        if (this.isTransactionForCChain) {\n          // C-chain Export: inputs are from C-chain (EVM inputs)\n          const exportTx = tx as evmSerial.ExportTx;\n          return exportTx.ins.map((evmInput) => ({\n            address: '0x' + Buffer.from(evmInput.address.toBytes()).toString('hex'),\n            value: evmInput.amount.value().toString(),\n            nonce: Number(evmInput.nonce.value()),\n          }));\n        } else {\n          // P-chain Export: inputs are from baseTx.inputs\n          const pvmExportTx = tx as pvmSerial.ExportTx;\n          return pvmExportTx.baseTx.inputs.map((input) => ({\n            id: utils.cb58Encode(Buffer.from(input.utxoID.txID.toBytes())) + ':' + input.utxoID.outputIdx.value(),\n            address: this.fromAddresses.sort().join(ADDRESS_SEPARATOR),\n            value: input.amount().toString(),\n          }));\n        }\n\n      case TransactionType.AddPermissionlessValidator:\n      default:\n        const baseTx = tx as pvmSerial.AddPermissionlessValidatorTx;\n        if (baseTx.baseTx?.inputs) {\n          return baseTx.baseTx.inputs.map((input) => ({\n            id: utils.cb58Encode(Buffer.from(input.utxoID.txID.toBytes())) + ':' + input.utxoID.outputIdx.value(),\n            address: this.fromAddresses.sort().join(ADDRESS_SEPARATOR),\n            value: input.amount().toString(),\n          }));\n        }\n        return [];\n    }\n  }\n\n  explainTransaction(): TransactionExplanation {\n    const txJson = this.toJson();\n    const displayOrder = ['id', 'inputs', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee', 'type'];\n\n    const outputAmount = txJson.outputs.reduce((p, n) => p + BigInt(n.value), BigInt(0)).toString();\n    const changeAmount = txJson.changeOutputs.reduce((p, n) => p + BigInt(n.value), BigInt(0)).toString();\n\n    let rewardAddresses;\n    if ([TransactionType.AddPermissionlessValidator].includes(txJson.type)) {\n      rewardAddresses = this.rewardAddresses;\n      displayOrder.splice(6, 0, 'rewardAddresses');\n    }\n\n    return {\n      displayOrder,\n      id: txJson.id,\n      inputs: txJson.inputs,\n      outputs: txJson.outputs.map((o) => ({ address: o.address, amount: o.value })),\n      outputAmount,\n      changeOutputs: txJson.changeOutputs.map((o) => ({ address: o.address, amount: o.value })),\n      changeAmount,\n      rewardAddresses,\n      fee: this.fee,\n      type: txJson.type,\n    };\n  }\n}\n"]}

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

@@ -0,0 +1,107 @@
+import { BaseTransactionBuilder, BaseKey, BaseAddress } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { DecodedUtxoObj, Tx } from './iface';
+import { KeyPair } from './keyPair';
+import { Transaction } from './transaction';
+import BigNumber from 'bignumber.js';
+export declare abstract class TransactionBuilder extends BaseTransactionBuilder {
+    protected _transaction: Transaction;
+    protected recoverSigner: boolean;
+    _signer: KeyPair[];
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Initialize the transaction builder fields using the decoded transaction data
+     *
+     * @param {Transaction} tx the transaction data
+     * @returns itself
+     */
+    initBuilder(tx: Tx): this;
+    /**
+     * Validates the threshold for multi-signature transactions
+     * @param threshold - Number of required signatures
+     */
+    validateThreshold(threshold: number): void;
+    /**
+     * Validates a single UTXO object
+     * @param value - UTXO to validate
+     */
+    validateUtxo(value: DecodedUtxoObj): void;
+    /**
+     * Validates an array of UTXOs
+     * @param values - Array of UTXOs to validate
+     */
+    validateUtxos(values: DecodedUtxoObj[]): void;
+    /**
+     * Validates the locktime value
+     * @param locktime - Timestamp after which the output can be spent
+     */
+    validateLocktime(locktime: bigint): void;
+    /**
+     * Sets the threshold for multi-signature transactions
+     * @param value - Number of required signatures
+     */
+    threshold(value: number): this;
+    /**
+     * Sets the locktime for the transaction
+     * @param value - Timestamp after which the output can be spent
+     */
+    locktime(value: string | number): this;
+    /**
+     * Enables recovery mode for the transaction
+     * @param recoverSigner - Whether to use recovery signing
+     */
+    recoverMode(recoverSigner?: boolean): this;
+    /**
+     * Sets the sender's public key(s)
+     * @param senderPubKey - Public key or array of public keys
+     */
+    fromPubKey(senderPubKey: string | string[]): this;
+    /**
+     * Sets the UTXOs for the transaction
+     * @param value - Array of UTXOs to use
+     */
+    utxos(value: DecodedUtxoObj[]): this;
+    /** @inheritdoc */
+    protected fromImplementation(rawTransaction: string): Transaction;
+    /**
+     * Abstract method to be implemented by specific transaction builders
+     * Builds the actual transaction based on the builder's configuration
+     */
+    protected abstract buildImplementation(): Promise<Transaction>;
+    /**
+     * Check the buffer has 32 byte long.
+     * @param chainID
+     */
+    validateChainId(chainID: Buffer): void;
+    /** @inheritdoc */
+    protected get transaction(): Transaction;
+    protected set transaction(transaction: Transaction);
+    /**
+     * Check that fee is greater than 0.
+     * @param {bigint} fee
+     */
+    validateFee(fee: bigint): void;
+    /** @inheritdoc */
+    validateKey({ key }: BaseKey): void;
+    /** @inheritdoc */
+    validateTransaction(transaction?: Transaction): void;
+    /** @inheritdoc */
+    validateValue(value: BigNumber): void;
+    /** @inheritdoc */
+    validateAddress(address: BaseAddress, addressFormat?: string): void;
+    /**
+     * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+     *
+     * @param rawTransaction Transaction in any format
+     */
+    validateRawTransaction(rawTransaction: string): void;
+    /** @inheritdoc */
+    protected signImplementation({ key }: BaseKey): Transaction;
+    hasSigner(): boolean;
+    /**
+     * Check the amount is positive.
+     * @param amount
+     */
+    validateAmount(amount: bigint): void;
+}
+//# sourceMappingURL=transactionBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transactionBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAyB,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC3G,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,SAAS,MAAM,cAAc,CAAC;AAErC,8BAAsB,kBAAmB,SAAQ,sBAAsB;IACrE,SAAS,CAAC,YAAY,EAAE,WAAW,CAAC;IACpC,SAAS,CAAC,aAAa,UAAS;IACzB,OAAO,EAAE,OAAO,EAAE,CAAM;gBAEnB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C;;;;;OAKG;IACH,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,IAAI;IAgBzB;;;OAGG;IACH,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAM1C;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IASzC;;;OAGG;IACH,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,IAAI;IAO7C;;;OAGG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAOxC;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAM9B;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAMtC;;;OAGG;IACH,WAAW,CAAC,aAAa,UAAO,GAAG,IAAI;IAKvC;;;OAGG;IACH,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI;IAMjD;;;OAGG;IACH,KAAK,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,IAAI;IAMpC,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;IAcjE;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;IAE9D;;;OAGG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAMtC,kBAAkB;IAClB,SAAS,KAAK,WAAW,IAAI,WAAW,CAEvC;IAED,SAAS,KAAK,WAAW,CAAC,WAAW,EAAE,WAAW,EAEjD;IAED;;;OAGG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAM9B,kBAAkB;IAClB,WAAW,CAAC,EAAE,GAAG,EAAE,EAAE,OAAO,GAAG,IAAI;IAQnC,kBAAkB;IAClB,mBAAmB,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI;IAIpD,kBAAkB;IAClB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAMrC,kBAAkB;IAClB,eAAe,CAAC,OAAO,EAAE,WAAW,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI;IAMnE;;;;OAIG;IACH,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAIpD,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,EAAE,GAAG,EAAE,EAAE,OAAO,GAAG,WAAW;IAK3D,SAAS,IAAI,OAAO;IAIpB;;;OAGG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;CAKrC"}