@trezor/connect 9.0.0-beta.1

package/lib/api/rebootToBootloader.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const events_1 = require("../events");
+class RebootToBootloader extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.allowDeviceMode = [events_1.UI.INITIALIZE, events_1.UI.SEEDLESS];
+        this.skipFinalReload = true;
+        this.keepSession = false;
+        this.requiredPermissions = ['management'];
+        this.info = 'Reboot to bootloader';
+        this.useDeviceState = false;
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, {
+            1: { min: '1.10.0', max: '0' },
+            2: { min: '0', max: '0' },
+        });
+    }
+    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: 'device-management',
+            customConfirmButton: {
+                className: 'confirm',
+                label: `Reboot`,
+            },
+            label: 'Are you sure you want to reboot to bootloader?',
+        }));
+        const uiResp = await uiPromise.promise;
+        this.confirmed = uiResp.payload;
+        return this.confirmed;
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('RebootToBootloader', 'Success');
+        return response.message;
+    }
+}
+exports.default = RebootToBootloader;
+//# sourceMappingURL=rebootToBootloader.js.map

package/lib/api/recoveryDevice.d.ts

@@ -0,0 +1,8 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { PROTO } from '../constants';
+export default class RecoveryDevice extends AbstractMethod<'recoveryDevice', PROTO.RecoveryDevice> {
+    init(): void;
+    confirmation(): Promise<boolean>;
+    run(): Promise<PROTO.Success>;
+}
+//# sourceMappingURL=recoveryDevice.d.ts.map

package/lib/api/recoveryDevice.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const events_1 = require("../events");
+const paramsValidator_1 = require("./common/paramsValidator");
+class RecoveryDevice extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['management'];
+        this.useEmptyPassphrase = true;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'word_count', type: 'number' },
+            { name: 'passphrase_protection', type: 'boolean' },
+            { name: 'pin_protection', type: 'boolean' },
+            { name: 'language', type: 'string' },
+            { name: 'label', type: 'string' },
+            { name: 'enforce_wordlist', type: 'boolean' },
+            { name: 'type', type: 'number' },
+            { name: 'u2f_counter', type: 'number' },
+            { name: 'dry_run', type: 'boolean' },
+        ]);
+        this.params = {
+            word_count: payload.word_count,
+            passphrase_protection: payload.passphrase_protection,
+            pin_protection: payload.pin_protection,
+            language: payload.language,
+            label: payload.label,
+            enforce_wordlist: payload.enforce_wordlist,
+            type: payload.type,
+            u2f_counter: payload.u2f_counter,
+            dry_run: payload.dry_run,
+        };
+        this.allowDeviceMode = [...this.allowDeviceMode, events_1.UI.INITIALIZE];
+        this.useDeviceState = false;
+    }
+    async confirmation() {
+        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: 'device-management',
+            customConfirmButton: {
+                className: 'confirm',
+                label: 'Proceed',
+            },
+            label: 'Do you want to recover device from seed?',
+        }));
+        const uiResp = await uiPromise.promise;
+        return uiResp.payload;
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('RecoveryDevice', 'Success', this.params);
+        return response.message;
+    }
+}
+exports.default = RecoveryDevice;
+//# sourceMappingURL=recoveryDevice.js.map

package/lib/api/requestLogin.d.ts

@@ -0,0 +1,12 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { PROTO } from '../constants';
+export default class RequestLogin extends AbstractMethod<'requestLogin', PROTO.SignIdentity> {
+    asyncChallenge?: boolean;
+    init(): void;
+    run(): Promise<{
+        address: string;
+        publicKey: string;
+        signature: string;
+    }>;
+}
+//# sourceMappingURL=requestLogin.d.ts.map

package/lib/api/requestLogin.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const constants_1 = require("../constants");
+const events_1 = require("../events");
+const DataManager_1 = require("../data/DataManager");
+class RequestLogin extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
+        this.info = 'Login';
+        this.useEmptyPassphrase = true;
+        const { payload } = this;
+        const identity = {};
+        const settings = DataManager_1.DataManager.getSettings();
+        if (settings.origin) {
+            const [proto, host, port] = settings.origin.split(':');
+            identity.proto = proto;
+            identity.host = host.substring(2);
+            if (port) {
+                identity.port = port;
+            }
+            identity.index = 0;
+        }
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'challengeHidden', type: 'string' },
+            { name: 'challengeVisual', type: 'string' },
+            { name: 'asyncChallenge', type: 'boolean' },
+        ]);
+        this.params = {
+            identity,
+            challenge_hidden: payload.challengeHidden || '',
+            challenge_visual: payload.challengeVisual || '',
+        };
+        this.asyncChallenge = !!payload.asyncChallenge;
+    }
+    async run() {
+        if (this.asyncChallenge) {
+            const uiPromise = this.createUiPromise(events_1.UI.LOGIN_CHALLENGE_RESPONSE);
+            this.postMessage((0, events_1.createUiMessage)(events_1.UI.LOGIN_CHALLENGE_REQUEST));
+            const { payload } = await uiPromise.promise;
+            if (typeof payload === 'string') {
+                throw constants_1.ERRORS.TypedError('Runtime', `TrezorConnect.requestLogin callback error: ${payload}`);
+            }
+            (0, paramsValidator_1.validateParams)(payload, [
+                { name: 'challengeHidden', type: 'string', required: true },
+                { name: 'challengeVisual', type: 'string', required: true },
+            ]);
+            this.params.challenge_hidden = payload.challengeHidden;
+            this.params.challenge_visual = payload.challengeVisual;
+        }
+        const cmd = this.device.getCommands();
+        const { message } = await cmd.typedCall('SignIdentity', 'SignedIdentity', this.params);
+        return {
+            address: message.address,
+            publicKey: message.public_key,
+            signature: message.signature,
+        };
+    }
+}
+exports.default = RequestLogin;
+//# sourceMappingURL=requestLogin.js.map

package/lib/api/resetDevice.d.ts

@@ -0,0 +1,9 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { PROTO } from '../constants';
+export default class ResetDevice extends AbstractMethod<'resetDevice', PROTO.ResetDevice> {
+    confirmed?: boolean;
+    init(): void;
+    confirmation(): Promise<boolean>;
+    run(): Promise<PROTO.Success>;
+}
+//# sourceMappingURL=resetDevice.d.ts.map

package/lib/api/resetDevice.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const events_1 = require("../events");
+const paramsValidator_1 = require("./common/paramsValidator");
+class ResetDevice extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.allowDeviceMode = [events_1.UI.INITIALIZE, events_1.UI.SEEDLESS];
+        this.useDeviceState = false;
+        this.requiredPermissions = ['management'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
+        this.info = 'Setup device';
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'display_random', type: 'boolean' },
+            { name: 'strength', type: 'number' },
+            { name: 'passphrase_protection', type: 'boolean' },
+            { name: 'pin_protection', type: 'boolean' },
+            { name: 'language', type: 'string' },
+            { name: 'label', type: 'string' },
+            { name: 'u2f_counter', type: 'number' },
+            { name: 'skip_backup', type: 'boolean' },
+            { name: 'no_backup', type: 'boolean' },
+            { name: 'backup_type', type: 'number' },
+        ]);
+        this.params = {
+            display_random: payload.display_random,
+            strength: payload.strength || 256,
+            passphrase_protection: payload.passphrase_protection,
+            pin_protection: payload.pin_protection,
+            language: payload.language,
+            label: payload.label,
+            u2f_counter: payload.u2f_counter || Math.floor(Date.now() / 1000),
+            skip_backup: payload.skip_backup,
+            no_backup: payload.no_backup,
+            backup_type: payload.backup_type,
+        };
+    }
+    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: 'device-management',
+            label: 'Do you really you want to create a new wallet?',
+        }));
+        const uiResp = await uiPromise.promise;
+        this.confirmed = uiResp.payload;
+        return this.confirmed;
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('ResetDevice', 'Success', this.params);
+        return response.message;
+    }
+}
+exports.default = ResetDevice;
+//# sourceMappingURL=resetDevice.js.map

package/lib/api/rippleGetAddress.d.ts

@@ -0,0 +1,22 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import { PROTO } from '../constants';
+declare type Params = PROTO.RippleGetAddress & {
+    address?: string;
+};
+export default class RippleGetAddress extends AbstractMethod<'rippleGetAddress', 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.RippleAddress>;
+    run(): Promise<import("..").Address | import("..").Address[]>;
+}
+export {};
+//# sourceMappingURL=rippleGetAddress.d.ts.map

package/lib/api/rippleGetAddress.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 RippleGetAddress 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)('Ripple'), 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 Ripple address for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_n[2]) + 1}`;
+        }
+        else {
+            this.info = 'Export multiple Ripple 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('RippleGetAddress', 'RippleAddress', {
+            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 = RippleGetAddress;
+//# sourceMappingURL=rippleGetAddress.js.map

package/lib/api/rippleSignTransaction.d.ts

@@ -0,0 +1,10 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { PROTO } from '../constants';
+export default class RippleSignTransaction extends AbstractMethod<'rippleSignTransaction', PROTO.RippleSignTx> {
+    init(): void;
+    run(): Promise<{
+        serializedTx: string;
+        signature: string;
+    }>;
+}
+//# sourceMappingURL=rippleSignTransaction.d.ts.map

package/lib/api/rippleSignTransaction.js

@@ -0,0 +1,54 @@
+"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");
+class RippleSignTransaction extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Ripple'), this.firmwareRange);
+        this.info = 'Sign Ripple transaction';
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'path', required: true },
+            { name: 'transaction', required: true },
+        ]);
+        const path = (0, pathUtils_1.validatePath)(payload.path, 5);
+        const { transaction } = payload;
+        (0, paramsValidator_1.validateParams)(transaction, [
+            { name: 'fee', type: 'uint' },
+            { name: 'flags', type: 'number' },
+            { name: 'sequence', type: 'number' },
+            { name: 'maxLedgerVersion', type: 'number' },
+            { name: 'payment', type: 'object' },
+        ]);
+        (0, paramsValidator_1.validateParams)(transaction.payment, [
+            { name: 'amount', type: 'uint', required: true },
+            { name: 'destination', type: 'string', required: true },
+            { name: 'destinationTag', type: 'number' },
+        ]);
+        this.params = {
+            address_n: path,
+            fee: transaction.fee,
+            flags: transaction.flags,
+            sequence: transaction.sequence,
+            last_ledger_sequence: transaction.maxLedgerVersion,
+            payment: {
+                amount: transaction.payment.amount,
+                destination: transaction.payment.destination,
+                destination_tag: transaction.payment.destinationTag,
+            },
+        };
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const { message } = await cmd.typedCall('RippleSignTx', 'RippleSignedTx', this.params);
+        return {
+            serializedTx: message.serialized_tx,
+            signature: message.signature,
+        };
+    }
+}
+exports.default = RippleSignTransaction;
+//# sourceMappingURL=rippleSignTransaction.js.map

package/lib/api/setProxy.d.ts

@@ -0,0 +1,8 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+export default class SetProxy extends AbstractMethod<'setProxy'> {
+    init(): void;
+    run(): Promise<{
+        message: string;
+    }>;
+}
+//# sourceMappingURL=setProxy.d.ts.map

package/lib/api/setProxy.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const DataManager_1 = require("../data/DataManager");
+const BlockchainLink_1 = require("../backend/BlockchainLink");
+class SetProxy extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = [];
+        this.useDevice = false;
+        this.useUi = false;
+        (0, paramsValidator_1.validateParams)(this.payload, [{ name: 'useOnionLinks', type: 'boolean' }]);
+    }
+    async run() {
+        const { proxy, useOnionLinks } = DataManager_1.DataManager.getSettings();
+        const isChanged = proxy !== this.payload.proxy || useOnionLinks !== this.payload.useOnionLinks;
+        if (isChanged) {
+            DataManager_1.DataManager.settings.proxy = this.payload.proxy;
+            DataManager_1.DataManager.settings.useOnionLinks = this.payload.useOnionLinks;
+            await (0, BlockchainLink_1.reconnectAllBackends)();
+        }
+        return { message: 'Success' };
+    }
+}
+exports.default = SetProxy;
+//# sourceMappingURL=setProxy.js.map

package/lib/api/signMessage.d.ts

@@ -0,0 +1,7 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { PROTO } from '../constants';
+export default class SignMessage extends AbstractMethod<'signMessage', PROTO.SignMessage> {
+    init(): void;
+    run(): Promise<PROTO.MessageSignature>;
+}
+//# sourceMappingURL=signMessage.d.ts.map

package/lib/api/signMessage.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const pathUtils_1 = require("../utils/pathUtils");
+const coinInfo_1 = require("../data/coinInfo");
+const formatUtils_1 = require("../utils/formatUtils");
+class SignMessage extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'path', required: true },
+            { name: 'coin', type: 'string' },
+            { name: 'message', type: 'string', required: true },
+            { name: 'hex', type: 'boolean' },
+            { name: 'no_script_type', type: 'boolean' },
+        ]);
+        const path = (0, pathUtils_1.validatePath)(payload.path);
+        let coinInfo;
+        if (payload.coin) {
+            coinInfo = (0, coinInfo_1.getBitcoinNetwork)(payload.coin);
+            (0, paramsValidator_1.validateCoinPath)(path, coinInfo);
+        }
+        else {
+            coinInfo = (0, coinInfo_1.getBitcoinNetwork)(path);
+        }
+        this.info = (0, pathUtils_1.getLabel)('Sign #NETWORK message', coinInfo);
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(payload.no_script_type ? 'signMessageNoScriptType' : this.name, coinInfo, this.firmwareRange);
+        const messageHex = payload.hex
+            ? (0, formatUtils_1.messageToHex)(payload.message)
+            : Buffer.from(payload.message, 'utf8').toString('hex');
+        const scriptType = (0, pathUtils_1.getScriptType)(path);
+        this.params = {
+            address_n: path,
+            message: messageHex,
+            coin_name: coinInfo ? coinInfo.name : undefined,
+            script_type: scriptType && scriptType !== 'SPENDMULTISIG' ? scriptType : 'SPENDADDRESS',
+            no_script_type: payload.no_script_type,
+        };
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const { message } = await cmd.typedCall('SignMessage', 'MessageSignature', this.params);
+        const signatureBuffer = Buffer.from(message.signature, 'hex');
+        message.signature = signatureBuffer.toString('base64');
+        return message;
+    }
+}
+exports.default = SignMessage;
+//# sourceMappingURL=signMessage.js.map

package/lib/api/signTransaction.d.ts

@@ -0,0 +1,21 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import { PROTO } from '../constants';
+import type { BitcoinNetworkInfo, AccountAddresses } from '../types';
+import type { RefTransaction, TransactionOptions } from '../types/api/signTransaction';
+declare type Params = {
+    inputs: PROTO.TxInputType[];
+    outputs: PROTO.TxOutputType[];
+    paymentRequests: PROTO.TxAckPaymentRequest[];
+    refTxs?: RefTransaction[];
+    addresses?: AccountAddresses;
+    options: TransactionOptions;
+    coinInfo: BitcoinNetworkInfo;
+    push: boolean;
+    preauthorized?: boolean;
+};
+export default class SignTransaction extends AbstractMethod<'signTransaction', Params> {
+    init(): void;
+    run(): Promise<import("../types/api/signTransaction").SignedTransaction>;
+}
+export {};
+//# sourceMappingURL=signTransaction.d.ts.map