@trezor/connect 9.0.0-beta.1

package/lib/api/signTransaction.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const bignumber_js_1 = (0, tslib_1.__importDefault)(require("bignumber.js"));
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const coinInfo_1 = require("../data/coinInfo");
+const pathUtils_1 = require("../utils/pathUtils");
+const constants_1 = require("../constants");
+const BlockchainLink_1 = require("../backend/BlockchainLink");
+const bitcoin_1 = require("./bitcoin");
+class SignTransaction extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        this.info = 'Sign transaction';
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'coin', type: 'string', required: true },
+            { name: 'inputs', type: 'array', required: true },
+            { name: 'outputs', type: 'array', required: true },
+            { name: 'paymentRequests', type: 'array', allowEmpty: true },
+            { name: 'refTxs', type: 'array', allowEmpty: true },
+            { name: 'account', type: 'object' },
+            { name: 'locktime', type: 'number' },
+            { name: 'timestamp', type: 'number' },
+            { name: 'version', type: 'number' },
+            { name: 'expiry', type: 'number' },
+            { name: 'overwintered', type: 'boolean' },
+            { name: 'versionGroupId', type: 'number' },
+            { name: 'branchId', type: 'number' },
+            { name: 'decredStakingTicket', type: 'boolean' },
+            { name: 'push', type: 'boolean' },
+            { name: 'preauthorized', type: 'boolean' },
+            { name: 'amountUnit', type: ['number', 'string'] },
+        ]);
+        const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(payload.coin);
+        if (!coinInfo) {
+            throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+        }
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
+        this.info = (0, pathUtils_1.getLabel)('Sign #NETWORK transaction', coinInfo);
+        const inputs = (0, bitcoin_1.validateTrezorInputs)(payload.inputs, coinInfo);
+        const outputs = (0, bitcoin_1.validateTrezorOutputs)(payload.outputs, coinInfo);
+        const refTxs = (0, bitcoin_1.validateReferencedTransactions)(payload.refTxs, inputs, outputs);
+        const outputsWithAmount = outputs.filter(output => typeof output.amount === 'string' &&
+            !Object.prototype.hasOwnProperty.call(output, 'op_return_data'));
+        if (outputsWithAmount.length > 0) {
+            const total = outputsWithAmount.reduce((bn, output) => bn.plus(typeof output.amount === 'string' ? output.amount : '0'), new bignumber_js_1.default(0));
+            if (total.lte(coinInfo.dustLimit)) {
+                throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Total amount is below dust limit.');
+            }
+        }
+        this.params = {
+            inputs,
+            outputs: payload.outputs,
+            paymentRequests: payload.paymentRequests || [],
+            refTxs,
+            addresses: payload.account ? payload.account.addresses : undefined,
+            options: {
+                lock_time: payload.locktime,
+                timestamp: payload.timestamp,
+                version: payload.version,
+                expiry: payload.expiry,
+                overwintered: payload.overwintered,
+                version_group_id: payload.versionGroupId,
+                branch_id: payload.branchId,
+                decred_staking_ticket: payload.decredStakingTicket,
+                amount_unit: payload.amountUnit,
+            },
+            coinInfo,
+            push: typeof payload.push === 'boolean' ? payload.push : false,
+            preauthorized: payload.preauthorized,
+        };
+        this.params.options = (0, bitcoin_1.enhanceSignTx)(this.params.options, coinInfo);
+    }
+    async run() {
+        const { device, params } = this;
+        let refTxs = [];
+        const useLegacySignProcess = device.unavailableCapabilities.replaceTransaction;
+        if (!params.refTxs) {
+            const requiredRefTxs = (0, bitcoin_1.requireReferencedTransactions)(params.inputs, params.options, params.coinInfo);
+            const refTxsIds = (0, bitcoin_1.getReferencedTransactions)(params.inputs);
+            if (requiredRefTxs && refTxsIds.length > 0) {
+                (0, BlockchainLink_1.isBackendSupported)(params.coinInfo);
+                const blockchain = await (0, BlockchainLink_1.initBlockchain)(params.coinInfo, this.postMessage);
+                const rawTxs = await blockchain.getTransactions(refTxsIds);
+                (0, bitcoin_1.enhanceTrezorInputs)(this.params.inputs, rawTxs);
+                refTxs = (0, bitcoin_1.transformReferencedTransactions)(rawTxs, params.coinInfo);
+                const origTxsIds = (0, bitcoin_1.getOrigTransactions)(params.inputs, params.outputs);
+                if (!useLegacySignProcess && origTxsIds.length > 0) {
+                    const rawOrigTxs = await blockchain.getTransactions(origTxsIds);
+                    let { addresses } = params;
+                    if (!addresses) {
+                        const accountPath = params.inputs.find(i => i.address_n);
+                        if (!accountPath || !accountPath.address_n) {
+                            throw constants_1.ERRORS.TypedError('Runtime', 'Account not found');
+                        }
+                        const node = await device
+                            .getCommands()
+                            .getHDNode(accountPath.address_n.slice(0, 3), params.coinInfo);
+                        const account = await blockchain.getAccountInfo({
+                            descriptor: node.xpubSegwit || node.xpub,
+                            details: 'tokens',
+                        });
+                        addresses = account.addresses;
+                    }
+                    const origRefTxs = (0, bitcoin_1.transformOrigTransactions)(rawOrigTxs, params.coinInfo, addresses);
+                    refTxs = refTxs.concat(origRefTxs);
+                }
+            }
+        }
+        else {
+            refTxs = params.refTxs;
+        }
+        if (params.preauthorized) {
+            await device.getCommands().typedCall('DoPreauthorized', 'PreauthorizedRequest', {});
+        }
+        const signTxMethod = !useLegacySignProcess ? bitcoin_1.signTx : bitcoin_1.signTxLegacy;
+        const response = await signTxMethod({
+            ...params,
+            refTxs,
+            typedCall: device.getCommands().typedCall.bind(device.getCommands()),
+        });
+        if (params.options.decred_staking_ticket) {
+            await (0, bitcoin_1.verifyTicketTx)(device.getCommands().getHDNode.bind(device.getCommands()), params.inputs, params.outputs, response.serializedTx, params.coinInfo);
+        }
+        else {
+            const bitcoinTx = await (0, bitcoin_1.verifyTx)(device.getCommands().getHDNode.bind(device.getCommands()), params.inputs, params.outputs, response.serializedTx, params.coinInfo);
+            if (bitcoinTx.hasWitnesses()) {
+                response.witnesses = bitcoinTx.ins.map((_, i) => { var _a; return (_a = bitcoinTx.getWitness(i)) === null || _a === void 0 ? void 0 : _a.toString('hex'); });
+            }
+        }
+        if (params.push) {
+            (0, BlockchainLink_1.isBackendSupported)(params.coinInfo);
+            const blockchain = await (0, BlockchainLink_1.initBlockchain)(params.coinInfo, this.postMessage);
+            const txid = await blockchain.pushTransaction(response.serializedTx);
+            return {
+                ...response,
+                txid,
+            };
+        }
+        return response;
+    }
+}
+exports.default = SignTransaction;
+//# sourceMappingURL=signTransaction.js.map

package/lib/api/stellar/stellarSignTx.d.ts

@@ -0,0 +1,5 @@
+import { PROTO } from '../../constants';
+import type { TypedCall } from '../../device/DeviceCommands';
+import type { StellarTransaction } from '../../types/api/stellarSignTransaction';
+export declare const stellarSignTx: (typedCall: TypedCall, address_n: number[], networkPassphrase: string, tx: StellarTransaction) => Promise<PROTO.StellarSignedTx>;
+//# sourceMappingURL=stellarSignTx.d.ts.map

package/lib/api/stellar/stellarSignTx.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stellarSignTx = void 0;
+const constants_1 = require("../../constants");
+const paramsValidator_1 = require("../common/paramsValidator");
+const processTxRequest = async (typedCall, operations, index) => {
+    const lastOp = index + 1 >= operations.length;
+    const { type, ...op } = operations[index];
+    if (lastOp) {
+        const response = await typedCall(type, 'StellarSignedTx', op);
+        return response.message;
+    }
+    await typedCall(type, 'StellarTxOpRequest', op);
+    return processTxRequest(typedCall, operations, index + 1);
+};
+const transformSignMessage = (tx) => {
+    if (!tx.timebounds) {
+        throw constants_1.ERRORS.TypedError('Runtime', 'transformSignMessage: Unspecified timebounds are not supported');
+    }
+    const msg = {
+        address_n: [],
+        network_passphrase: '',
+        source_account: tx.source,
+        fee: tx.fee,
+        sequence_number: tx.sequence,
+        timebounds_start: tx.timebounds.minTime,
+        timebounds_end: tx.timebounds.maxTime,
+        memo_type: constants_1.PROTO.StellarMemoType.NONE,
+        num_operations: tx.operations.length,
+    };
+    if (tx.memo) {
+        msg.memo_type = tx.memo.type;
+        msg.memo_text = tx.memo.text;
+        msg.memo_id = tx.memo.id;
+        msg.memo_hash = tx.memo.hash;
+    }
+    return msg;
+};
+const transformOperation = (op) => {
+    switch (op.type) {
+        case 'createAccount':
+            (0, paramsValidator_1.validateParams)(op, [
+                { name: 'destination', type: 'string', required: true },
+                { name: 'startingBalance', type: 'uint', required: true },
+            ]);
+            return {
+                type: 'StellarCreateAccountOp',
+                source_account: op.source,
+                new_account: op.destination,
+                starting_balance: op.startingBalance,
+            };
+        case 'payment':
+            (0, paramsValidator_1.validateParams)(op, [
+                { name: 'destination', type: 'string', required: true },
+                { name: 'amount', type: 'uint', required: true },
+            ]);
+            return {
+                type: 'StellarPaymentOp',
+                source_account: op.source,
+                destination_account: op.destination,
+                asset: op.asset,
+                amount: op.amount,
+            };
+        case 'pathPaymentStrictReceive':
+            (0, paramsValidator_1.validateParams)(op, [{ name: 'destAmount', type: 'uint', required: true }]);
+            return {
+                type: 'StellarPathPaymentStrictReceiveOp',
+                source_account: op.source,
+                send_asset: op.sendAsset,
+                send_max: op.sendMax,
+                destination_account: op.destination,
+                destination_asset: op.destAsset,
+                destination_amount: op.destAmount,
+                paths: op.path,
+            };
+        case 'pathPaymentStrictSend':
+            (0, paramsValidator_1.validateParams)(op, [{ name: 'destMin', type: 'uint', required: true }]);
+            return {
+                type: 'StellarPathPaymentStrictSendOp',
+                source_account: op.source,
+                send_asset: op.sendAsset,
+                send_amount: op.sendAmount,
+                destination_account: op.destination,
+                destination_asset: op.destAsset,
+                destination_min: op.destMin,
+                paths: op.path,
+            };
+        case 'createPassiveSellOffer':
+            (0, paramsValidator_1.validateParams)(op, [{ name: 'amount', type: 'uint', required: true }]);
+            return {
+                type: 'StellarCreatePassiveSellOfferOp',
+                source_account: op.source,
+                buying_asset: op.buying,
+                selling_asset: op.selling,
+                amount: op.amount,
+                price_n: op.price.n,
+                price_d: op.price.d,
+            };
+        case 'manageSellOffer':
+            (0, paramsValidator_1.validateParams)(op, [{ name: 'amount', type: 'uint', required: true }]);
+            return {
+                type: 'StellarManageSellOfferOp',
+                source_account: op.source,
+                buying_asset: op.buying,
+                selling_asset: op.selling,
+                amount: op.amount,
+                offer_id: op.offerId || 0,
+                price_n: op.price.n,
+                price_d: op.price.d,
+            };
+        case 'manageBuyOffer':
+            (0, paramsValidator_1.validateParams)(op, [{ name: 'amount', type: 'uint', required: true }]);
+            return {
+                type: 'StellarManageBuyOfferOp',
+                source_account: op.source,
+                buying_asset: op.buying,
+                selling_asset: op.selling,
+                amount: op.amount,
+                offer_id: op.offerId || 0,
+                price_n: op.price.n,
+                price_d: op.price.d,
+            };
+        case 'setOptions': {
+            const signer = op.signer
+                ? {
+                    signer_type: op.signer.type,
+                    signer_key: op.signer.key,
+                    signer_weight: op.signer.weight,
+                }
+                : undefined;
+            return {
+                type: 'StellarSetOptionsOp',
+                source_account: op.source,
+                clear_flags: op.clearFlags,
+                set_flags: op.setFlags,
+                master_weight: op.masterWeight,
+                low_threshold: op.lowThreshold,
+                medium_threshold: op.medThreshold,
+                high_threshold: op.highThreshold,
+                home_domain: op.homeDomain,
+                inflation_destination_account: op.inflationDest,
+                ...signer,
+            };
+        }
+        case 'changeTrust':
+            (0, paramsValidator_1.validateParams)(op, [{ name: 'limit', type: 'uint' }]);
+            return {
+                type: 'StellarChangeTrustOp',
+                source_account: op.source,
+                asset: op.line,
+                limit: op.limit,
+            };
+        case 'allowTrust':
+            return {
+                type: 'StellarAllowTrustOp',
+                source_account: op.source,
+                trusted_account: op.trustor,
+                asset_type: op.assetType,
+                asset_code: op.assetCode,
+                is_authorized: !!op.authorize,
+            };
+        case 'accountMerge':
+            return {
+                type: 'StellarAccountMergeOp',
+                source_account: op.source,
+                destination_account: op.destination,
+            };
+        case 'manageData':
+            return {
+                type: 'StellarManageDataOp',
+                source_account: op.source,
+                key: op.name,
+                value: op.value,
+            };
+        case 'bumpSequence':
+            return {
+                type: 'StellarBumpSequenceOp',
+                source_account: op.source,
+                bump_to: op.bumpTo,
+            };
+    }
+};
+const stellarSignTx = async (typedCall, address_n, networkPassphrase, tx) => {
+    const message = transformSignMessage(tx);
+    message.address_n = address_n;
+    message.network_passphrase = networkPassphrase;
+    const operations = [];
+    tx.operations.forEach(op => {
+        const transformed = transformOperation(op);
+        if (transformed) {
+            operations.push(transformed);
+        }
+    });
+    await typedCall('StellarSignTx', 'StellarTxOpRequest', message);
+    return processTxRequest(typedCall, operations, 0);
+};
+exports.stellarSignTx = stellarSignTx;
+//# sourceMappingURL=stellarSignTx.js.map

package/lib/api/stellarGetAddress.d.ts

@@ -0,0 +1,22 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import { PROTO } from '../constants';
+declare type Params = PROTO.StellarGetAddress & {
+    address?: string;
+};
+export default class StellarGetAddress extends AbstractMethod<'stellarGetAddress', Params[]> {
+    hasBundle?: boolean;
+    progress: number;
+    confirmed?: boolean;
+    init(): void;
+    getButtonRequestData(code: string): {
+        type: "address";
+        serializedPath: string;
+        address: string;
+    } | undefined;
+    confirmation(): Promise<boolean>;
+    noBackupConfirmation(): Promise<boolean>;
+    _call({ address_n, show_display }: Params): Promise<PROTO.StellarAddress>;
+    run(): Promise<import("..").Address | import("..").Address[]>;
+}
+export {};
+//# sourceMappingURL=stellarGetAddress.d.ts.map

package/lib/api/stellarGetAddress.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const coinInfo_1 = require("../data/coinInfo");
+const pathUtils_1 = require("../utils/pathUtils");
+const constants_1 = require("../constants");
+const events_1 = require("../events");
+class StellarGetAddress extends AbstractMethod_1.AbstractMethod {
+    constructor() {
+        super(...arguments);
+        this.progress = 0;
+    }
+    init() {
+        this.requiredPermissions = ['read'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Stellar'), this.firmwareRange);
+        this.hasBundle = !!this.payload.bundle;
+        const payload = !this.payload.bundle
+            ? { ...this.payload, bundle: [this.payload] }
+            : this.payload;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'bundle', type: 'array' },
+            { name: 'useEventListener', type: 'boolean' },
+        ]);
+        this.params = payload.bundle.map(batch => {
+            (0, paramsValidator_1.validateParams)(batch, [
+                { name: 'path', required: true },
+                { name: 'address', type: 'string' },
+                { name: 'showOnTrezor', type: 'boolean' },
+            ]);
+            const path = (0, pathUtils_1.validatePath)(batch.path, 3);
+            return {
+                address_n: path,
+                address: batch.address,
+                show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+            };
+        });
+        const useEventListener = payload.useEventListener &&
+            this.params.length === 1 &&
+            typeof this.params[0].address === 'string' &&
+            this.params[0].show_display;
+        this.confirmed = useEventListener;
+        this.useUi = !useEventListener;
+        if (this.params.length === 1) {
+            this.info = `Export Stellar address for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_n[2]) + 1}`;
+        }
+        else {
+            this.info = 'Export multiple Stellar addresses';
+        }
+    }
+    getButtonRequestData(code) {
+        if (code === 'ButtonRequest_Address') {
+            return {
+                type: 'address',
+                serializedPath: (0, pathUtils_1.getSerializedPath)(this.params[this.progress].address_n),
+                address: this.params[this.progress].address || 'not-set',
+            };
+        }
+    }
+    async confirmation() {
+        if (this.confirmed)
+            return true;
+        await this.getPopupPromise().promise;
+        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+            view: 'export-address',
+            label: this.info,
+        }));
+        const uiResp = await uiPromise.promise;
+        this.confirmed = uiResp.payload;
+        return this.confirmed;
+    }
+    async noBackupConfirmation() {
+        await this.getPopupPromise().promise;
+        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+            view: 'no-backup',
+        }));
+        const uiResp = await uiPromise.promise;
+        return uiResp.payload;
+    }
+    async _call({ address_n, show_display }) {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('StellarGetAddress', 'StellarAddress', {
+            address_n,
+            show_display,
+        });
+        return response.message;
+    }
+    async run() {
+        const responses = [];
+        for (let i = 0; i < this.params.length; i++) {
+            const batch = this.params[i];
+            if (batch.show_display) {
+                const silent = await this._call({
+                    ...batch,
+                    show_display: false,
+                });
+                if (typeof batch.address === 'string') {
+                    if (batch.address !== silent.address) {
+                        throw constants_1.ERRORS.TypedError('Method_AddressNotMatch');
+                    }
+                }
+                else {
+                    batch.address = silent.address;
+                }
+            }
+            const response = await this._call(batch);
+            responses.push({
+                path: batch.address_n,
+                serializedPath: (0, pathUtils_1.getSerializedPath)(batch.address_n),
+                address: response.address,
+            });
+            if (this.hasBundle) {
+                this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
+                    progress: i,
+                    response,
+                }));
+            }
+            this.progress++;
+        }
+        return this.hasBundle ? responses : responses[0];
+    }
+}
+exports.default = StellarGetAddress;
+//# sourceMappingURL=stellarGetAddress.js.map

package/lib/api/stellarSignTransaction.d.ts

@@ -0,0 +1,23 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import { StellarTransaction } from '../types/api/stellarSignTransaction';
+declare type Params = {
+    path: number[];
+    networkPassphrase: string;
+    transaction: StellarTransaction;
+};
+declare const StellarSignTransactionFeatures: Readonly<{
+    manageBuyOffer: string[];
+    pathPaymentStrictSend: string[];
+}>;
+export default class StellarSignTransaction extends AbstractMethod<'stellarSignTransaction', Params> {
+    init(): void;
+    _isFeatureSupported(feature: keyof typeof StellarSignTransactionFeatures): boolean;
+    _ensureFeatureIsSupported(feature: keyof typeof StellarSignTransactionFeatures): void;
+    _ensureFirmwareSupportsParams(): void;
+    run(): Promise<{
+        publicKey: string;
+        signature: string;
+    }>;
+}
+export {};
+//# sourceMappingURL=stellarSignTransaction.d.ts.map

package/lib/api/stellarSignTransaction.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const coinInfo_1 = require("../data/coinInfo");
+const pathUtils_1 = require("../utils/pathUtils");
+const helper = (0, tslib_1.__importStar)(require("./stellar/stellarSignTx"));
+const constants_1 = require("../constants");
+const StellarSignTransactionFeatures = Object.freeze({
+    manageBuyOffer: ['1.10.4', '2.4.3'],
+    pathPaymentStrictSend: ['1.10.4', '2.4.3'],
+});
+class StellarSignTransaction extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Stellar'), this.firmwareRange);
+        this.info = 'Sign Stellar transaction';
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'path', required: true },
+            { name: 'networkPassphrase', type: 'string', required: true },
+            { name: 'transaction', required: true },
+        ]);
+        const path = (0, pathUtils_1.validatePath)(payload.path, 3);
+        const { transaction } = payload;
+        this.params = {
+            path,
+            networkPassphrase: payload.networkPassphrase,
+            transaction,
+        };
+    }
+    _isFeatureSupported(feature) {
+        return this.device.atLeast(StellarSignTransactionFeatures[feature]);
+    }
+    _ensureFeatureIsSupported(feature) {
+        if (!this._isFeatureSupported(feature)) {
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Feature ${feature} not supported by device firmware`);
+        }
+    }
+    _ensureFirmwareSupportsParams() {
+        const { params } = this;
+        if (params.transaction.operations &&
+            params.transaction.operations.find(o => o.type === 'manageBuyOffer')) {
+            this._ensureFeatureIsSupported('manageBuyOffer');
+        }
+        if (params.transaction.operations &&
+            params.transaction.operations.find(o => o.type === 'pathPaymentStrictSend')) {
+            this._ensureFeatureIsSupported('pathPaymentStrictSend');
+        }
+    }
+    async run() {
+        this._ensureFirmwareSupportsParams();
+        const response = await helper.stellarSignTx(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, this.params.networkPassphrase, this.params.transaction);
+        return {
+            publicKey: response.public_key,
+            signature: response.signature,
+        };
+    }
+}
+exports.default = StellarSignTransaction;
+//# sourceMappingURL=stellarSignTransaction.js.map

package/lib/api/tezos/tezosSignTx.d.ts

@@ -0,0 +1,4 @@
+import { PROTO } from '../../constants';
+import type { TezosOperation } from '../../types/api/tezosSignTransaction';
+export declare const createTx: (address_n: number[], branch: string, operation: TezosOperation) => PROTO.TezosSignTx;
+//# sourceMappingURL=tezosSignTx.d.ts.map