@trezor/connect 9.0.0-beta.1

package/lib/api/composeTransaction.js

@@ -0,0 +1,270 @@
+"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 constants_1 = require("../constants");
+const events_1 = require("../events");
+const Discovery_1 = require("./common/Discovery");
+const paramsValidator_1 = require("./common/paramsValidator");
+const pathUtils = (0, tslib_1.__importStar)(require("../utils/pathUtils"));
+const promiseUtils_1 = require("../utils/promiseUtils");
+const formatUtils_1 = require("../utils/formatUtils");
+const coinInfo_1 = require("../data/coinInfo");
+const BlockchainLink_1 = require("../backend/BlockchainLink");
+const bitcoin_1 = require("./bitcoin");
+class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'outputs', type: 'array', required: true },
+            { name: 'coin', type: 'string', required: true },
+            { name: 'push', type: 'boolean' },
+            { name: 'account', type: 'object' },
+            { name: 'feeLevels', type: 'array' },
+            { name: 'baseFee', type: 'number' },
+            { name: 'floorBaseFee', type: 'boolean' },
+            { name: 'sequence', type: 'number' },
+            { name: 'skipPermutation', type: 'boolean' },
+        ]);
+        const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(payload.coin);
+        if (!coinInfo) {
+            throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+        }
+        (0, BlockchainLink_1.isBackendSupported)(coinInfo);
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
+        const outputs = [];
+        let total = new bignumber_js_1.default(0);
+        payload.outputs.forEach(out => {
+            const output = (0, bitcoin_1.validateHDOutput)(out, coinInfo);
+            if ('amount' in output && typeof output.amount === 'string') {
+                total = total.plus(output.amount);
+            }
+            outputs.push(output);
+        });
+        const sendMax = outputs.find(o => o.type === 'send-max') !== undefined;
+        if (sendMax) {
+            this.info = 'Send maximum amount';
+        }
+        else {
+            this.info = `Send ${(0, formatUtils_1.formatAmount)(total.toString(), coinInfo)}`;
+        }
+        this.useDevice = !payload.account && !payload.feeLevels;
+        this.useUi = this.useDevice;
+        this.params = {
+            outputs,
+            coinInfo,
+            account: payload.account,
+            feeLevels: payload.feeLevels,
+            baseFee: payload.baseFee,
+            floorBaseFee: payload.floorBaseFee,
+            sequence: payload.sequence,
+            skipPermutation: payload.skipPermutation,
+            push: typeof payload.push === 'boolean' ? payload.push : false,
+        };
+    }
+    async precompose(account, feeLevels) {
+        const { coinInfo, outputs, baseFee, skipPermutation } = this.params;
+        const address_n = pathUtils.validatePath(account.path);
+        const composer = new bitcoin_1.TransactionComposer({
+            account: {
+                type: pathUtils.getAccountType(address_n),
+                label: 'Account',
+                descriptor: account.path,
+                address_n,
+                addresses: account.addresses,
+            },
+            utxo: account.utxo,
+            coinInfo,
+            outputs,
+            baseFee,
+            skipPermutation,
+        });
+        const blockchain = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage);
+        await composer.init(blockchain);
+        return feeLevels.map(level => {
+            composer.composeCustomFee(level.feePerUnit);
+            const tx = { ...composer.composed.custom };
+            if (tx.type === 'final') {
+                const inputs = tx.transaction.inputs.map(inp => (0, bitcoin_1.inputToTrezor)(inp, this.params.sequence || 0xffffffff));
+                const { sorted, permutation } = tx.transaction.outputs;
+                const txOutputs = sorted.map(out => (0, bitcoin_1.outputToTrezor)(out, coinInfo));
+                return {
+                    type: 'final',
+                    max: tx.max,
+                    totalSpent: tx.totalSpent,
+                    fee: tx.fee,
+                    feePerByte: tx.feePerByte,
+                    bytes: tx.bytes,
+                    transaction: {
+                        inputs,
+                        outputs: txOutputs,
+                        outputsPermutation: permutation,
+                    },
+                };
+            }
+            return tx;
+        });
+    }
+    async run() {
+        if (this.params.account && this.params.feeLevels) {
+            return this.precompose(this.params.account, this.params.feeLevels);
+        }
+        const { account, utxo } = await this.selectAccount();
+        const response = await this.selectFee(account, utxo);
+        if (!this.discovery) {
+            throw constants_1.ERRORS.TypedError('Runtime', 'ComposeTransaction: selectFee response received after dispose');
+        }
+        if (typeof response === 'string') {
+            return this.run();
+        }
+        return response;
+    }
+    async selectAccount() {
+        const { coinInfo } = this.params;
+        const blockchain = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage);
+        const dfd = this.createUiPromise(events_1.UI.RECEIVE_ACCOUNT);
+        if (this.discovery && this.discovery.completed) {
+            const { discovery } = this;
+            this.postMessage((0, events_1.createUiMessage)(events_1.UI.SELECT_ACCOUNT, {
+                type: 'end',
+                coinInfo,
+                accountTypes: discovery.types.map(t => t.type),
+                accounts: discovery.accounts,
+            }));
+            const uiResp = await dfd.promise;
+            const account = discovery.accounts[uiResp.payload];
+            const utxo = await blockchain.getAccountUtxo(account.descriptor);
+            return {
+                account,
+                utxo,
+            };
+        }
+        const discovery = this.discovery ||
+            new Discovery_1.Discovery({
+                blockchain,
+                commands: this.device.getCommands(),
+            });
+        this.discovery = discovery;
+        discovery.on('progress', accounts => {
+            this.postMessage((0, events_1.createUiMessage)(events_1.UI.SELECT_ACCOUNT, {
+                type: 'progress',
+                coinInfo,
+                accounts,
+            }));
+        });
+        discovery.on('complete', () => {
+            this.postMessage((0, events_1.createUiMessage)(events_1.UI.SELECT_ACCOUNT, {
+                type: 'end',
+                coinInfo,
+            }));
+        });
+        discovery.start('tokens').catch(error => {
+            dfd.reject(error);
+        });
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.SELECT_ACCOUNT, {
+            type: 'start',
+            accountTypes: discovery.types.map(t => t.type),
+            coinInfo,
+        }));
+        const uiResp = await dfd.promise;
+        discovery.removeAllListeners();
+        discovery.stop();
+        if (!discovery.completed) {
+            await (0, promiseUtils_1.resolveAfter)(501);
+        }
+        const account = discovery.accounts[uiResp.payload];
+        this.params.coinInfo = (0, coinInfo_1.fixCoinInfoNetwork)(this.params.coinInfo, account.address_n);
+        const utxo = await blockchain.getAccountUtxo(account.descriptor);
+        return {
+            account,
+            utxo,
+        };
+    }
+    async selectFee(account, utxo) {
+        const { coinInfo, outputs } = this.params;
+        const blockchain = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage);
+        const composer = new bitcoin_1.TransactionComposer({
+            account,
+            utxo,
+            coinInfo,
+            outputs,
+        });
+        await composer.init(blockchain);
+        const hasFunds = composer.composeAllFeeLevels();
+        if (!hasFunds) {
+            this.postMessage((0, events_1.createUiMessage)(events_1.UI.INSUFFICIENT_FUNDS));
+            await (0, promiseUtils_1.resolveAfter)(2000, null);
+            return 'change-account';
+        }
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.SELECT_FEE, {
+            feeLevels: composer.getFeeLevelList(),
+            coinInfo: this.params.coinInfo,
+        }));
+        return this._selectFeeUiResponse(composer);
+    }
+    async _selectFeeUiResponse(composer) {
+        const resp = await this.createUiPromise(events_1.UI.RECEIVE_FEE).promise;
+        switch (resp.payload.type) {
+            case 'compose-custom':
+                composer.composeCustomFee(resp.payload.value);
+                this.postMessage((0, events_1.createUiMessage)(events_1.UI.UPDATE_CUSTOM_FEE, {
+                    feeLevels: composer.getFeeLevelList(),
+                    coinInfo: this.params.coinInfo,
+                }));
+                return this._selectFeeUiResponse(composer);
+            case 'send':
+                return this._sign(composer.composed[resp.payload.value]);
+            default:
+                return 'change-account';
+        }
+    }
+    async _sign(tx) {
+        if (tx.type !== 'final')
+            throw constants_1.ERRORS.TypedError('Runtime', 'ComposeTransaction: Trying to sign unfinished tx');
+        const { coinInfo } = this.params;
+        const options = (0, bitcoin_1.enhanceSignTx)({}, coinInfo);
+        const inputs = tx.transaction.inputs.map(inp => (0, bitcoin_1.inputToTrezor)(inp, this.params.sequence || 0xffffffff));
+        const outputs = tx.transaction.outputs.sorted.map(out => (0, bitcoin_1.outputToTrezor)(out, coinInfo));
+        let refTxs = [];
+        const requiredRefTxs = (0, bitcoin_1.requireReferencedTransactions)(inputs, options, coinInfo);
+        const refTxsIds = (0, bitcoin_1.getReferencedTransactions)(inputs);
+        if (requiredRefTxs && refTxsIds.length > 0) {
+            const blockchain = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage);
+            const rawTxs = await blockchain.getTransactions(refTxsIds);
+            refTxs = (0, bitcoin_1.transformReferencedTransactions)(rawTxs, coinInfo);
+        }
+        const signTxMethod = !this.device.unavailableCapabilities.replaceTransaction
+            ? bitcoin_1.signTx
+            : bitcoin_1.signTxLegacy;
+        const response = await signTxMethod({
+            typedCall: this.device.getCommands().typedCall.bind(this.device.getCommands()),
+            inputs,
+            outputs,
+            refTxs,
+            options,
+            coinInfo,
+        });
+        await (0, bitcoin_1.verifyTx)(this.device.getCommands().getHDNode.bind(this.device.getCommands()), inputs, outputs, response.serializedTx, coinInfo);
+        if (this.params.push) {
+            const blockchain = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage);
+            const txid = await blockchain.pushTransaction(response.serializedTx);
+            return {
+                ...response,
+                txid,
+            };
+        }
+        return response;
+    }
+    dispose() {
+        const { discovery } = this;
+        if (discovery) {
+            discovery.stop();
+            discovery.removeAllListeners();
+            this.discovery = undefined;
+        }
+    }
+}
+exports.default = ComposeTransaction;
+//# sourceMappingURL=composeTransaction.js.map

package/lib/api/customMessage.d.ts

@@ -0,0 +1,13 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+declare type Params = {
+    customMessages?: JSON | Record<string, any>;
+    message: string;
+    params?: any;
+};
+export default class CustomMessage extends AbstractMethod<'customMessage', Params> {
+    init(): void;
+    getCustomMessages(): JSON | Record<string, any> | undefined;
+    run(): Promise<any>;
+}
+export {};
+//# sourceMappingURL=customMessage.d.ts.map

package/lib/api/customMessage.js

@@ -0,0 +1,56 @@
+"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");
+class CustomMessage extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['custom-message', 'read', 'write'];
+        this.info = 'Custom message';
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'message', type: 'string', required: true },
+            { name: 'params', type: 'object', required: true },
+        ]);
+        if (payload.messages) {
+            try {
+                JSON.parse(JSON.stringify(payload.messages));
+            }
+            catch (error) {
+                throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Parameter "messages" has invalid type. JSON expected.');
+            }
+        }
+        this.params = {
+            customMessages: payload.messages,
+            message: payload.message,
+            params: payload.params,
+        };
+    }
+    getCustomMessages() {
+        return this.params.customMessages;
+    }
+    async run() {
+        if (this.device.features.vendor === 'trezor.io' ||
+            this.device.features.vendor === 'bitcointrezor.com') {
+            throw constants_1.ERRORS.TypedError('Runtime', 'Cannot use custom message on device with official firmware. Change device "vendor" field.');
+        }
+        const response = await this.device
+            .getCommands()
+            ._commonCall(this.params.message, this.params.params);
+        const uiPromise = this.createUiPromise(events_1.UI.CUSTOM_MESSAGE_RESPONSE);
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.CUSTOM_MESSAGE_REQUEST, response));
+        const uiResp = await uiPromise.promise;
+        const { payload } = uiResp;
+        (0, paramsValidator_1.validateParams)(payload, [{ name: 'message', type: 'string', required: true }]);
+        if (payload.message.toLowerCase() === 'release') {
+            return response;
+        }
+        (0, paramsValidator_1.validateParams)(payload, [{ name: 'params', type: 'object', required: true }]);
+        this.params.message = payload.message;
+        this.params.params = payload.params;
+        return this.run();
+    }
+}
+exports.default = CustomMessage;
+//# sourceMappingURL=customMessage.js.map

package/lib/api/eos/eosSignTx.d.ts

@@ -0,0 +1,17 @@
+import { PROTO } from '../../constants';
+import type { EosSDKTransaction } from '../../types/api/eosSignTransaction';
+import type { TypedCall } from '../../device/DeviceCommands';
+export declare const validate: (tx: EosSDKTransaction) => {
+    chain_id: string;
+    header: {
+        expiration: number;
+        ref_block_num: number;
+        ref_block_prefix: number;
+        max_net_usage_words: number;
+        max_cpu_usage_ms: number;
+        delay_sec: number;
+    };
+    ack: PROTO.EosTxActionAck[];
+};
+export declare const signTx: (typedCall: TypedCall, address_n: number[], chain_id: string, header: PROTO.EosTxHeader, actions: PROTO.EosTxActionAck[]) => Promise<PROTO.EosSignedTx>;
+//# sourceMappingURL=eosSignTx.d.ts.map