@trezor/connect 9.0.0-beta.1

package/lib/api/bitcoin/refTx.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateReferencedTransactions = exports.transformReferencedTransactions = exports.transformOrigTransactions = exports.getOrigTransactions = exports.getReferencedTransactions = exports.requireReferencedTransactions = void 0;
+const utxo_lib_1 = require("@trezor/utxo-lib");
+const bufferUtils_1 = require("../../utils/bufferUtils");
+const pathUtils_1 = require("../../utils/pathUtils");
+const paramsValidator_1 = require("../common/paramsValidator");
+const errors_1 = require("../../constants/errors");
+const requireReferencedTransactions = (inputs, options = {}, coinInfo) => {
+    if ((coinInfo === null || coinInfo === void 0 ? void 0 : coinInfo.shortcut) === 'ZEC' || (coinInfo === null || coinInfo === void 0 ? void 0 : coinInfo.shortcut) === 'TAZ') {
+        return !(options.version && options.version >= 5);
+    }
+    const inputTypes = ['SPENDTAPROOT', 'EXTERNAL'];
+    return !!inputs.find(input => !inputTypes.find(t => t === input.script_type));
+};
+exports.requireReferencedTransactions = requireReferencedTransactions;
+const getReferencedTransactions = (inputs) => {
+    const result = [];
+    inputs.forEach(input => {
+        if (input.prev_hash && !result.includes(input.prev_hash)) {
+            result.push(input.prev_hash);
+        }
+    });
+    return result;
+};
+exports.getReferencedTransactions = getReferencedTransactions;
+const getOrigTransactions = (inputs, outputs) => {
+    const result = [];
+    inputs.forEach(input => {
+        if (input.orig_hash && !result.includes(input.orig_hash)) {
+            result.push(input.orig_hash);
+        }
+    });
+    outputs.forEach(output => {
+        if (output.orig_hash && !result.includes(output.orig_hash)) {
+            result.push(output.orig_hash);
+        }
+    });
+    return result;
+};
+exports.getOrigTransactions = getOrigTransactions;
+const enhanceTransaction = (refTx, srcTx) => {
+    const extraData = srcTx.getExtraData();
+    if (extraData) {
+        refTx.extra_data = extraData.toString('hex');
+    }
+    const specific = srcTx.getSpecificData();
+    if (specific) {
+        if (specific.type === 'zcash' && specific.versionGroupId && refTx.version >= 3) {
+            refTx.version_group_id = specific.versionGroupId;
+        }
+        if (specific.type === 'dash' && srcTx.type && srcTx.version >= 3) {
+            refTx.version |= srcTx.type << 16;
+        }
+    }
+    return refTx;
+};
+const transformOrigTransactions = (txs, coinInfo, addresses) => txs.flatMap(raw => {
+    if (coinInfo.type !== 'bitcoin' || raw.type !== 'blockbook' || !addresses)
+        return [];
+    const { hex, vin, vout } = raw.tx;
+    const tx = utxo_lib_1.Transaction.fromHex(hex, { network: coinInfo.network });
+    const inputAddresses = addresses.used.concat(addresses.change).concat(addresses.unused);
+    const inputsMap = (input, i) => {
+        var _a;
+        const rawInput = vin[i];
+        if (!(rawInput === null || rawInput === void 0 ? void 0 : rawInput.value) || !(rawInput === null || rawInput === void 0 ? void 0 : rawInput.addresses) || rawInput.addresses.length !== 1) {
+            throw (0, errors_1.TypedError)('Method_InvalidParameter', `transformOrigTransactions: invalid input at ${raw.tx.txid} [${i}]`);
+        }
+        const [address] = rawInput.addresses;
+        const inputAddress = inputAddresses.find(addr => addr.address === address);
+        const address_n = (0, pathUtils_1.getHDPath)((inputAddress === null || inputAddress === void 0 ? void 0 : inputAddress.path) || '');
+        return {
+            address_n,
+            prev_hash: (0, bufferUtils_1.reverseBuffer)(input.hash).toString('hex'),
+            prev_index: input.index,
+            script_sig: input.script.toString('hex'),
+            sequence: input.sequence,
+            script_type: (0, pathUtils_1.getScriptType)(address_n),
+            multisig: undefined,
+            amount: rawInput.value,
+            decred_tree: undefined,
+            witness: (_a = tx.getWitness(i)) === null || _a === void 0 ? void 0 : _a.toString('hex'),
+            ownership_proof: undefined,
+            commitment_data: undefined,
+        };
+    };
+    const outputsMap = (output, i) => {
+        var _a;
+        const rawOutput = vout[i];
+        if (!rawOutput.isAddress) {
+            const { data } = utxo_lib_1.payments.embed({ output: output.script });
+            const op_return_data = (_a = data === null || data === void 0 ? void 0 : data.shift()) === null || _a === void 0 ? void 0 : _a.toString('hex');
+            if (typeof op_return_data !== 'string') {
+                throw (0, errors_1.TypedError)('Method_InvalidParameter', `transformOrigTransactions: invalid op_return_data at ${raw.tx.txid} [${i}]`);
+            }
+            return {
+                script_type: 'PAYTOOPRETURN',
+                amount: '0',
+                op_return_data,
+            };
+        }
+        if (!rawOutput.addresses || rawOutput.addresses.length !== 1) {
+            throw (0, errors_1.TypedError)('Method_InvalidParameter', `transformOrigTransactions: invalid output at ${raw.tx.txid} [${i}]`);
+        }
+        const [address] = rawOutput.addresses;
+        const changeAddress = addresses.change.find(addr => addr.address === address);
+        const address_n = changeAddress && (0, pathUtils_1.getHDPath)(changeAddress.path);
+        const amount = output.value.toString();
+        return address_n
+            ? {
+                address_n,
+                amount,
+                script_type: (0, pathUtils_1.getOutputScriptType)(address_n),
+            }
+            : {
+                address,
+                amount,
+                script_type: 'PAYTOADDRESS',
+            };
+    };
+    const refTx = {
+        version: tx.version,
+        hash: tx.getId(),
+        inputs: tx.ins.map(inputsMap),
+        outputs: tx.outs.map(outputsMap),
+        lock_time: tx.locktime,
+        timestamp: tx.timestamp,
+        expiry: tx.expiry,
+    };
+    return enhanceTransaction(refTx, tx);
+});
+exports.transformOrigTransactions = transformOrigTransactions;
+const transformReferencedTransactions = (txs, coinInfo) => txs.flatMap(raw => {
+    if (coinInfo.type !== 'bitcoin' || raw.type !== 'blockbook')
+        return [];
+    const { hex } = raw.tx;
+    const tx = utxo_lib_1.Transaction.fromHex(hex, { network: coinInfo.network });
+    const inputsMap = (input) => ({
+        prev_index: input.index,
+        sequence: input.sequence,
+        prev_hash: (0, bufferUtils_1.reverseBuffer)(input.hash).toString('hex'),
+        script_sig: input.script.toString('hex'),
+    });
+    const binOutputsMap = (output) => ({
+        amount: output.value.toString(),
+        script_pubkey: output.script.toString('hex'),
+    });
+    const refTx = {
+        version: tx.version,
+        hash: tx.getId(),
+        inputs: tx.ins.map(inputsMap),
+        bin_outputs: tx.outs.map(binOutputsMap),
+        lock_time: tx.locktime,
+        timestamp: tx.timestamp,
+        expiry: tx.expiry,
+    };
+    return enhanceTransaction(refTx, tx);
+});
+exports.transformReferencedTransactions = transformReferencedTransactions;
+const validateReferencedTransactions = (txs, inputs, outputs) => {
+    if (!Array.isArray(txs) || txs.length === 0)
+        return;
+    const refTxs = (0, exports.getReferencedTransactions)(inputs);
+    const origTxs = (0, exports.getOrigTransactions)(inputs, outputs);
+    const transformedTxs = txs.map(tx => {
+        (0, paramsValidator_1.validateParams)(tx, [
+            { name: 'hash', type: 'string', required: true },
+            { name: 'inputs', type: 'array', required: true },
+            { name: 'version', type: 'number', required: true },
+            { name: 'lock_time', type: 'number', required: true },
+            { name: 'extra_data', type: 'string' },
+            { name: 'timestamp', type: 'number' },
+            { name: 'version_group_id', type: 'number' },
+        ]);
+        if (origTxs.includes(tx.hash)) {
+            (0, paramsValidator_1.validateParams)(tx, [{ name: 'outputs', type: 'array', required: true }]);
+            return tx;
+        }
+        (0, paramsValidator_1.validateParams)(tx, [{ name: 'bin_outputs', type: 'array', required: true }]);
+        tx.inputs.forEach(input => {
+            (0, paramsValidator_1.validateParams)(input, [
+                { name: 'prev_hash', type: 'string', required: true },
+                { name: 'prev_index', type: 'number', required: true },
+                { name: 'script_sig', type: 'string', required: true },
+                { name: 'sequence', type: 'number', required: true },
+                { name: 'decred_tree', type: 'number' },
+            ]);
+        });
+        return {
+            hash: tx.hash,
+            version: tx.version,
+            extra_data: tx.extra_data,
+            lock_time: tx.lock_time,
+            timestamp: tx.timestamp,
+            version_group_id: tx.version_group_id,
+            expiry: tx.expiry,
+            inputs: tx.inputs.map(input => ({
+                prev_hash: input.prev_hash,
+                prev_index: input.prev_index,
+                script_sig: input.script_sig,
+                sequence: input.sequence,
+                decred_tree: input.decred_tree,
+            })),
+            bin_outputs: tx.bin_outputs.map(output => ({
+                amount: output.amount,
+                script_pubkey: output.script_pubkey,
+                decred_script_version: output.decred_script_version,
+            })),
+        };
+    });
+    refTxs.concat(origTxs).forEach(hash => {
+        if (!transformedTxs.find(tx => tx.hash === hash)) {
+            throw (0, errors_1.TypedError)('Method_InvalidParameter', `refTx: ${hash} not provided`);
+        }
+    });
+    return transformedTxs;
+};
+exports.validateReferencedTransactions = validateReferencedTransactions;
+//# sourceMappingURL=refTx.js.map

package/lib/api/bitcoin/signtx.d.ts

@@ -0,0 +1,25 @@
+import { PROTO } from '../../constants';
+import type { BitcoinNetworkInfo } from '../../types';
+import type { TypedCall } from '../../device/DeviceCommands';
+import type { RefTransaction, TransactionOptions, SignedTransaction } from '../../types/api/signTransaction';
+export interface SignTxHelperProps {
+    typedCall: TypedCall;
+    txRequest: PROTO.TxRequest;
+    refTxs: Record<string, RefTransaction>;
+    inputs: PROTO.TxInputType[];
+    outputs: PROTO.TxOutputType[];
+    paymentRequests: PROTO.TxAckPaymentRequest[];
+    serializedTx: string[];
+    signatures: string[];
+}
+export interface SignTxHelperParams {
+    typedCall: TypedCall;
+    inputs: PROTO.TxInputType[];
+    outputs: PROTO.TxOutputType[];
+    paymentRequests?: PROTO.TxAckPaymentRequest[];
+    refTxs: RefTransaction[];
+    options: TransactionOptions;
+    coinInfo: BitcoinNetworkInfo;
+}
+export declare const signTx: ({ typedCall, inputs, outputs, paymentRequests, refTxs, options, coinInfo, }: SignTxHelperParams) => Promise<SignedTransaction>;
+//# sourceMappingURL=signtx.d.ts.map

package/lib/api/bitcoin/signtx.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signTx = void 0;
+const constants_1 = require("../../constants");
+const requestPrevTxInfo = ({ typedCall, txRequest: { request_type, details }, refTxs, }) => {
+    const { tx_hash } = details;
+    if (!tx_hash) {
+        throw constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: unknown details.tx_hash');
+    }
+    const tx = refTxs[tx_hash.toLowerCase()];
+    if (!tx) {
+        throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
+    }
+    if (request_type === 'TXINPUT') {
+        if (!tx.bin_outputs)
+            throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXINPUT: ${tx_hash}`);
+        return typedCall('TxAckPrevInput', 'TxRequest', {
+            tx: { input: tx.inputs[details.request_index] },
+        });
+    }
+    if (request_type === 'TXOUTPUT') {
+        if (!tx.bin_outputs)
+            throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXOUTPUT: ${tx_hash}`);
+        return typedCall('TxAckPrevOutput', 'TxRequest', {
+            tx: { output: tx.bin_outputs[details.request_index] },
+        });
+    }
+    if (request_type === 'TXORIGINPUT') {
+        if (!tx.outputs)
+            throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXORIGINPUT: ${tx_hash}`);
+        return typedCall('TxAckInput', 'TxRequest', {
+            tx: { input: tx.inputs[details.request_index] },
+        });
+    }
+    if (request_type === 'TXORIGOUTPUT') {
+        if (!tx.outputs)
+            throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXORIGOUTPUT: ${tx_hash}`);
+        return typedCall('TxAckOutput', 'TxRequest', {
+            tx: { output: tx.outputs[details.request_index] },
+        });
+    }
+    if (request_type === 'TXEXTRADATA') {
+        if (typeof details.extra_data_len !== 'number') {
+            throw constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_len');
+        }
+        if (typeof details.extra_data_offset !== 'number') {
+            throw constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_offset');
+        }
+        if (typeof tx.extra_data !== 'string') {
+            throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
+        }
+        const data = tx.extra_data;
+        const dataLen = details.extra_data_len;
+        const dataOffset = details.extra_data_offset;
+        const extra_data_chunk = data.substring(dataOffset * 2, (dataOffset + dataLen) * 2);
+        return typedCall('TxAckPrevExtraData', 'TxRequest', { tx: { extra_data_chunk } });
+    }
+    if (request_type === 'TXMETA') {
+        const data = tx.extra_data;
+        const meta = {
+            version: tx.version,
+            lock_time: tx.lock_time,
+            inputs_count: tx.inputs.length,
+            outputs_count: tx.outputs ? tx.outputs.length : tx.bin_outputs.length,
+            timestamp: tx.timestamp,
+            version_group_id: tx.version_group_id,
+            expiry: tx.expiry,
+            branch_id: tx.branch_id,
+            extra_data_len: data ? data.length / 2 : undefined,
+        };
+        return typedCall('TxAckPrevMeta', 'TxRequest', { tx: meta });
+    }
+    throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Unknown request type: ${request_type}`);
+};
+const requestSignedTxInfo = ({ typedCall, txRequest: { request_type, details }, inputs, outputs, paymentRequests, }) => {
+    if (request_type === 'TXINPUT') {
+        return typedCall('TxAckInput', 'TxRequest', {
+            tx: { input: inputs[details.request_index] },
+        });
+    }
+    if (request_type === 'TXOUTPUT') {
+        return typedCall('TxAckOutput', 'TxRequest', {
+            tx: { output: outputs[details.request_index] },
+        });
+    }
+    if (request_type === 'TXPAYMENTREQ') {
+        const req = paymentRequests[details.request_index];
+        if (!req) {
+            throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown payment request at ${details.request_index}`);
+        }
+        return typedCall('TxAckPaymentRequest', 'TxRequest', {
+            nonce: req.nonce,
+            recipient_name: req.recipient_name,
+            memos: req.memos,
+            amount: req.amount,
+            signature: req.signature,
+        });
+    }
+    if (request_type === 'TXMETA') {
+        throw constants_1.ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
+    }
+    if (request_type === 'TXEXTRADATA') {
+        throw constants_1.ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
+    }
+    throw constants_1.ERRORS.TypedError('Runtime', `requestSignedTxInfo: Unknown request type: ${request_type}`);
+};
+const requestTxAck = (props) => {
+    const { tx_hash } = props.txRequest.details;
+    if (tx_hash) {
+        return requestPrevTxInfo(props);
+    }
+    return requestSignedTxInfo(props);
+};
+const saveTxSignatures = (txRequest, serializedTx, signatures) => {
+    const { signature_index, signature, serialized_tx } = txRequest;
+    if (serialized_tx) {
+        serializedTx.push(serialized_tx);
+    }
+    if (typeof signature_index === 'number') {
+        if (!signature) {
+            throw constants_1.ERRORS.TypedError('Runtime', 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
+        }
+        signatures[signature_index] = signature;
+    }
+};
+const processTxRequest = async (props) => {
+    const { txRequest, serializedTx, signatures } = props;
+    if (txRequest.serialized)
+        saveTxSignatures(txRequest.serialized, serializedTx, signatures);
+    if (txRequest.request_type === 'TXFINISHED') {
+        return Promise.resolve({
+            signatures,
+            serializedTx: serializedTx.join(''),
+        });
+    }
+    const { message } = await requestTxAck(props);
+    return processTxRequest({
+        ...props,
+        txRequest: message,
+    });
+};
+const signTx = async ({ typedCall, inputs, outputs, paymentRequests, refTxs, options, coinInfo, }) => {
+    const { message } = await typedCall('SignTx', 'TxRequest', {
+        ...options,
+        inputs_count: inputs.length,
+        outputs_count: outputs.length,
+        coin_name: coinInfo.name,
+    });
+    return processTxRequest({
+        typedCall,
+        txRequest: message,
+        refTxs: refTxs.reduce((record, tx) => ({
+            ...record,
+            [tx.hash.toLowerCase()]: tx,
+        }), {}),
+        inputs,
+        outputs,
+        paymentRequests: paymentRequests || [],
+        serializedTx: [],
+        signatures: [],
+    });
+};
+exports.signTx = signTx;
+//# sourceMappingURL=signtx.js.map

package/lib/api/bitcoin/signtxLegacy.d.ts

@@ -0,0 +1,4 @@
+import type { SignedTransaction } from '../../types/api/signTransaction';
+import type { SignTxHelperParams } from './signtx';
+export declare const signTxLegacy: ({ typedCall, inputs, outputs, refTxs, options, coinInfo, }: SignTxHelperParams) => Promise<SignedTransaction>;
+//# sourceMappingURL=signtxLegacy.d.ts.map

package/lib/api/bitcoin/signtxLegacy.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signTxLegacy = void 0;
+const constants_1 = require("../../constants");
+const requestPrevTxInfo = ({ txRequest: { request_type, details }, refTxs, }) => {
+    const { tx_hash } = details;
+    if (!tx_hash) {
+        throw constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: unknown details.tx_hash');
+    }
+    const tx = refTxs[tx_hash.toLowerCase()];
+    if (!tx) {
+        throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
+    }
+    if (!tx.bin_outputs) {
+        throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: bin_outputs not set tx: ${tx_hash}`);
+    }
+    if (request_type === 'TXINPUT') {
+        return { inputs: [tx.inputs[details.request_index]] };
+    }
+    if (request_type === 'TXOUTPUT') {
+        return { bin_outputs: [tx.bin_outputs[details.request_index]] };
+    }
+    if (request_type === 'TXEXTRADATA') {
+        if (typeof details.extra_data_len !== 'number') {
+            throw constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_len');
+        }
+        if (typeof details.extra_data_offset !== 'number') {
+            throw constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_offset');
+        }
+        if (typeof tx.extra_data !== 'string') {
+            throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
+        }
+        const data = tx.extra_data;
+        const dataLen = details.extra_data_len;
+        const dataOffset = details.extra_data_offset;
+        const extra_data = data.substring(dataOffset * 2, (dataOffset + dataLen) * 2);
+        return { extra_data };
+    }
+    if (request_type === 'TXMETA') {
+        const data = tx.extra_data;
+        const meta = {
+            version: tx.version,
+            lock_time: tx.lock_time,
+            inputs_cnt: tx.inputs.length,
+            outputs_cnt: tx.bin_outputs.length,
+            timestamp: tx.timestamp,
+            version_group_id: tx.version_group_id,
+            expiry: tx.expiry,
+            branch_id: tx.branch_id,
+        };
+        if (typeof data === 'string' && data.length !== 0) {
+            return {
+                ...meta,
+                extra_data_len: data.length / 2,
+            };
+        }
+        return meta;
+    }
+    throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Unknown request type: ${request_type}`);
+};
+const requestSignedTxInfo = ({ txRequest: { request_type, details }, inputs, outputs, }) => {
+    if (request_type === 'TXINPUT') {
+        return { inputs: [inputs[details.request_index]] };
+    }
+    if (request_type === 'TXOUTPUT') {
+        return { outputs: [outputs[details.request_index]] };
+    }
+    if (request_type === 'TXMETA') {
+        throw constants_1.ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
+    }
+    if (request_type === 'TXEXTRADATA') {
+        throw constants_1.ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
+    }
+    throw constants_1.ERRORS.TypedError('Runtime', `requestSignedTxInfo: Unknown request type: ${request_type}`);
+};
+const requestTxAck = (props) => {
+    const { tx_hash } = props.txRequest.details;
+    if (tx_hash) {
+        return requestPrevTxInfo(props);
+    }
+    return requestSignedTxInfo(props);
+};
+const saveTxSignatures = (txRequest, serializedTx, signatures) => {
+    if (!txRequest)
+        return;
+    const { signature_index, signature, serialized_tx } = txRequest;
+    if (serialized_tx) {
+        serializedTx.push(serialized_tx);
+    }
+    if (typeof signature_index === 'number') {
+        if (!signature) {
+            throw constants_1.ERRORS.TypedError('Runtime', 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
+        }
+        signatures[signature_index] = signature;
+    }
+};
+const processTxRequest = async (props) => {
+    const { typedCall, txRequest, serializedTx, signatures } = props;
+    if (txRequest.serialized)
+        saveTxSignatures(txRequest.serialized, serializedTx, signatures);
+    if (txRequest.request_type === 'TXFINISHED') {
+        return Promise.resolve({
+            signatures,
+            serializedTx: serializedTx.join(''),
+        });
+    }
+    const txAck = requestTxAck(props);
+    const { message } = await typedCall('TxAck', 'TxRequest', { tx: txAck });
+    return processTxRequest({
+        ...props,
+        txRequest: message,
+    });
+};
+const signTxLegacy = async ({ typedCall, inputs, outputs, refTxs, options, coinInfo, }) => {
+    const { message } = await typedCall('SignTx', 'TxRequest', {
+        ...options,
+        inputs_count: inputs.length,
+        outputs_count: outputs.length,
+        coin_name: coinInfo.name,
+    });
+    return processTxRequest({
+        typedCall,
+        txRequest: message,
+        refTxs: refTxs.reduce((record, tx) => ({
+            ...record,
+            [tx.hash.toLowerCase()]: tx,
+        }), {}),
+        inputs,
+        outputs,
+        paymentRequests: [],
+        serializedTx: [],
+        signatures: [],
+    });
+};
+exports.signTxLegacy = signTxLegacy;
+//# sourceMappingURL=signtxLegacy.js.map

package/lib/api/bitcoin/signtxVerify.d.ts

@@ -0,0 +1,8 @@
+import { PROTO } from '../../constants';
+import type { BitcoinNetworkInfo } from '../../types';
+import type { HDNodeResponse } from '../../types/api/getPublicKey';
+declare type GetHDNode = (path: number[], coinInfo?: BitcoinNetworkInfo, validation?: boolean) => Promise<HDNodeResponse>;
+export declare const verifyTx: (getHDNode: GetHDNode, inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[], serializedTx: string, coinInfo: BitcoinNetworkInfo) => Promise<import("packages/utxo-lib/lib/transaction/base").TransactionBase<undefined> | import("packages/utxo-lib/lib/transaction/base").TransactionBase<import("packages/utxo-lib/lib/transaction/dash").DashSpecific> | import("packages/utxo-lib/lib/transaction/base").TransactionBase<import("packages/utxo-lib/lib/transaction/zcash").ZcashSpecific>>;
+export declare const verifyTicketTx: (getHDNode: GetHDNode, inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[], serializedTx: string, coinInfo: BitcoinNetworkInfo) => Promise<void>;
+export {};
+//# sourceMappingURL=signtxVerify.d.ts.map