@trezor/connect 9.0.0-beta.1

package/lib/api/binanceSignTransaction.js

@@ -0,0 +1,31 @@
+"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("./binance/binanceSignTx"));
+class BinanceSignTransaction extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('BNB'), this.firmwareRange);
+        this.info = 'Sign Binance transaction';
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'path', type: 'string', required: true },
+            { name: 'transaction', required: true },
+        ]);
+        const path = (0, pathUtils_1.validatePath)(payload.path, 3);
+        const transaction = helper.validate(payload.transaction);
+        this.params = {
+            path,
+            transaction,
+        };
+    }
+    run() {
+        return helper.signTx(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, this.params.transaction);
+    }
+}
+exports.default = BinanceSignTransaction;
+//# sourceMappingURL=binanceSignTransaction.js.map

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

@@ -0,0 +1,15 @@
+import { Blockchain } from '../../backend/BlockchainLink';
+import type { CoinInfo } from '../../types';
+import type { FeeLevel } from '../../types/account';
+declare type Blocks = Array<string | undefined>;
+export declare class FeeLevels {
+    coinInfo: CoinInfo;
+    levels: FeeLevel[];
+    blocks: Blocks;
+    constructor(coinInfo: CoinInfo);
+    loadMisc(blockchain: Blockchain): Promise<FeeLevel[]>;
+    load(blockchain: Blockchain): Promise<FeeLevel[]>;
+    updateCustomFee(feePerUnit: string): void;
+}
+export {};
+//# sourceMappingURL=Fees.d.ts.map

package/lib/api/bitcoin/Fees.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeeLevels = void 0;
+const tslib_1 = require("tslib");
+const bignumber_js_1 = (0, tslib_1.__importDefault)(require("bignumber.js"));
+const BLOCKS = {
+    btc: {
+        high: 1,
+        normal: 6,
+        economy: 36,
+        low: 144,
+    },
+    bch: {
+        high: 1,
+        normal: 5,
+        economy: 10,
+        low: 10,
+    },
+    btg: {
+        high: 1,
+        normal: 5,
+        economy: 10,
+        low: 10,
+    },
+    dgb: {
+        high: 1,
+        normal: 15,
+        economy: 30,
+        low: 60,
+    },
+};
+const getDefaultBlocks = (shortcut, label) => BLOCKS[shortcut] && BLOCKS[shortcut][label] ? BLOCKS[shortcut][label] : -1;
+const feePerKB = (fee) => {
+    const bn = new bignumber_js_1.default(fee);
+    if (bn.isNaN() || bn.lte('0'))
+        return;
+    return bn.div(1000).integerValue(bignumber_js_1.default.ROUND_HALF_CEIL).toString();
+};
+const fillGap = (from, step, size) => {
+    const fill = [];
+    for (let i = from + step; i <= from + size; i += step) {
+        fill.push(i);
+    }
+    return fill;
+};
+const findLowest = (blocks) => {
+    const unique = [];
+    blocks.forEach(item => {
+        if (typeof item === 'string' && unique.indexOf(item) < 0) {
+            unique.push(item);
+        }
+    });
+    return unique[unique.length - 1];
+};
+const findNearest = (requested, blocks) => {
+    const len = blocks.length;
+    const knownValue = blocks[requested];
+    if (typeof knownValue === 'string')
+        return knownValue;
+    const lastKnownValue = blocks
+        .slice()
+        .reverse()
+        .find(item => typeof item === 'string');
+    if (!lastKnownValue)
+        return;
+    const lastKnownIndex = blocks.indexOf(lastKnownValue);
+    if (requested >= lastKnownIndex) {
+        return lastKnownValue;
+    }
+    let index = requested;
+    while (typeof blocks[index] !== 'string' && index < len) {
+        index++;
+    }
+    return blocks[index];
+};
+const findBlocksForFee = (feePerUnit, blocks) => {
+    const bn = new bignumber_js_1.default(feePerUnit);
+    const lower = blocks.find(b => typeof b === 'string' && bn.gte(b));
+    if (!lower)
+        return -1;
+    return blocks.indexOf(lower);
+};
+class FeeLevels {
+    constructor(coinInfo) {
+        this.blocks = [];
+        this.coinInfo = coinInfo;
+        const shortcut = coinInfo.shortcut.toLowerCase();
+        if (coinInfo.type === 'ethereum') {
+            this.levels = coinInfo.defaultFees.map(level => ({
+                ...level,
+                blocks: -1,
+            }));
+            return;
+        }
+        const keys = Object.keys(coinInfo.defaultFees);
+        this.levels = keys
+            .sort((levelA, levelB) => coinInfo.defaultFees[levelB] - coinInfo.defaultFees[levelA])
+            .map(level => {
+            const label = level.toLowerCase();
+            const blocks = getDefaultBlocks(shortcut, label);
+            return {
+                label,
+                feePerUnit: coinInfo.defaultFees[level].toString(),
+                blocks,
+            };
+        });
+    }
+    async loadMisc(blockchain) {
+        try {
+            const [response] = await blockchain.estimateFee({ blocks: [1] });
+            this.levels[0] = {
+                ...this.levels[0],
+                ...response,
+                feePerUnit: Math.min(this.coinInfo.maxFee, Math.max(this.coinInfo.minFee, parseInt(response.feePerUnit, 10))).toString(),
+            };
+        }
+        catch (error) {
+        }
+        return this.levels;
+    }
+    async load(blockchain) {
+        if (this.coinInfo.type !== 'bitcoin')
+            return this.loadMisc(blockchain);
+        let blocks = fillGap(0, 1, 10);
+        if (this.levels.length > 1) {
+            blocks = this.levels
+                .map(l => l.blocks)
+                .reduce((result, bl) => {
+                if (result.length === 0)
+                    return result.concat([bl]);
+                const from = result[result.length - 1];
+                const gap = bl - from;
+                const incr = gap <= 30 ? 1 : 6;
+                const fill = fillGap(from, incr, gap);
+                return result.concat(fill);
+            }, []);
+        }
+        try {
+            const response = await blockchain.estimateFee({ blocks });
+            response.forEach((r, i) => {
+                this.blocks[blocks[i]] = feePerKB(r.feePerUnit);
+            });
+            if (this.levels.length === 1) {
+                const lowest = findLowest(this.blocks);
+                if (typeof lowest === 'string') {
+                    this.levels[0].blocks = this.blocks.indexOf(lowest);
+                    this.levels[0].feePerUnit = lowest;
+                }
+            }
+            else {
+                this.levels.forEach(l => {
+                    const updatedValue = findNearest(l.blocks, this.blocks);
+                    if (typeof updatedValue === 'string') {
+                        l.blocks = this.blocks.indexOf(updatedValue);
+                        l.feePerUnit = updatedValue;
+                    }
+                });
+            }
+        }
+        catch (error) {
+        }
+        return this.levels;
+    }
+    updateCustomFee(feePerUnit) {
+        this.levels = this.levels.filter(l => l.label !== 'custom');
+        const blocks = findBlocksForFee(feePerUnit, this.blocks);
+        this.levels.push({
+            label: 'custom',
+            feePerUnit,
+            blocks,
+        });
+    }
+}
+exports.FeeLevels = FeeLevels;
+//# sourceMappingURL=Fees.js.map

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

@@ -0,0 +1,36 @@
+import { ComposeInput, ComposeOutput, ComposeResult } from '@trezor/utxo-lib';
+import { FeeLevels } from './Fees';
+import { Blockchain } from '../../backend/BlockchainLink';
+import type { BitcoinNetworkInfo } from '../../types';
+import type { DiscoveryAccount, SelectFeeLevel } from '../../types/account';
+import type { PrecomposeParams } from '../../types/api/composeTransaction';
+declare type Options = {
+    account: DiscoveryAccount;
+    utxo: PrecomposeParams['account']['utxo'];
+    outputs: ComposeOutput[];
+    coinInfo: BitcoinNetworkInfo;
+    baseFee?: number;
+    skipPermutation?: boolean;
+};
+export declare class TransactionComposer {
+    account: DiscoveryAccount;
+    utxos: ComposeInput[];
+    outputs: ComposeOutput[];
+    coinInfo: BitcoinNetworkInfo;
+    blockHeight: number;
+    baseFee: number;
+    skipPermutation: boolean;
+    feeLevels: FeeLevels;
+    composed: {
+        [key: string]: ComposeResult;
+    };
+    constructor(options: Options);
+    init(blockchain: Blockchain): Promise<void>;
+    composeAllFeeLevels(): boolean;
+    composeCustomFee(fee: string): void;
+    getFeeLevelList(): SelectFeeLevel[];
+    compose(feeRate: string): ComposeResult;
+    dispose(): void;
+}
+export {};
+//# sourceMappingURL=TransactionComposer.d.ts.map

package/lib/api/bitcoin/TransactionComposer.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionComposer = void 0;
+const tslib_1 = require("tslib");
+const bignumber_js_1 = (0, tslib_1.__importDefault)(require("bignumber.js"));
+const utxo_lib_1 = require("@trezor/utxo-lib");
+const Fees_1 = require("./Fees");
+const pathUtils_1 = require("../../utils/pathUtils");
+class TransactionComposer {
+    constructor(options) {
+        this.blockHeight = 0;
+        this.composed = {};
+        this.account = options.account;
+        this.outputs = options.outputs;
+        this.coinInfo = options.coinInfo;
+        this.blockHeight = 0;
+        this.baseFee = options.baseFee || 0;
+        this.skipPermutation = options.skipPermutation || false;
+        this.feeLevels = new Fees_1.FeeLevels(options.coinInfo);
+        const { addresses } = options.account;
+        const allAddresses = !addresses
+            ? []
+            : addresses.used
+                .concat(addresses.unused)
+                .concat(addresses.change)
+                .map(a => a.address);
+        this.utxos = options.utxo.flatMap(u => {
+            if (!u.required && new bignumber_js_1.default(u.amount).lte(this.coinInfo.dustLimit))
+                return [];
+            const addressPath = (0, pathUtils_1.getHDPath)(u.path);
+            return {
+                index: u.vout,
+                transactionHash: u.txid,
+                value: u.amount,
+                addressPath: [addressPath[3], addressPath[4]],
+                height: u.blockHeight,
+                tsize: 0,
+                vsize: 0,
+                coinbase: typeof u.coinbase === 'boolean' ? u.coinbase : false,
+                own: allAddresses.indexOf(u.address) >= 0,
+                required: u.required,
+            };
+        });
+    }
+    async init(blockchain) {
+        const { blockHeight } = await blockchain.getNetworkInfo();
+        this.blockHeight = blockHeight;
+        await this.feeLevels.load(blockchain);
+    }
+    composeAllFeeLevels() {
+        const { levels } = this.feeLevels;
+        if (this.utxos.length < 1)
+            return false;
+        this.composed = {};
+        let atLeastOneValid = false;
+        levels.forEach(level => {
+            if (level.feePerUnit !== '0') {
+                const tx = this.compose(level.feePerUnit);
+                if (tx.type === 'final') {
+                    atLeastOneValid = true;
+                }
+                this.composed[level.label] = tx;
+            }
+        });
+        if (!atLeastOneValid) {
+            const lastLevel = levels[levels.length - 1];
+            let lastFee = new bignumber_js_1.default(lastLevel.feePerUnit);
+            while (lastFee.gt(this.coinInfo.minFee) && this.composed.custom === undefined) {
+                lastFee = lastFee.minus(1);
+                const tx = this.compose(lastFee.toString());
+                if (tx.type === 'final') {
+                    this.feeLevels.updateCustomFee(lastFee.toString());
+                    this.composed.custom = tx;
+                    return true;
+                }
+            }
+            return false;
+        }
+        return true;
+    }
+    composeCustomFee(fee) {
+        const tx = this.compose(fee);
+        this.composed.custom = tx;
+        if (tx.type === 'final') {
+            this.feeLevels.updateCustomFee(tx.feePerByte);
+        }
+        else {
+            this.feeLevels.updateCustomFee(fee);
+        }
+    }
+    getFeeLevelList() {
+        const list = [];
+        const { levels } = this.feeLevels;
+        levels.forEach(level => {
+            const tx = this.composed[level.label];
+            if (tx && tx.type === 'final') {
+                list.push({
+                    name: level.label,
+                    fee: tx.fee,
+                    feePerByte: level.feePerUnit,
+                    minutes: level.blocks * this.coinInfo.blocktime,
+                    total: tx.totalSpent,
+                });
+            }
+            else {
+                list.push({
+                    name: level.label,
+                    fee: '0',
+                    disabled: true,
+                });
+            }
+        });
+        return list;
+    }
+    compose(feeRate) {
+        const { account, coinInfo, baseFee } = this;
+        const { addresses } = account;
+        if (!addresses)
+            return { type: 'error', error: 'ADDRESSES-NOT-SET' };
+        const changeAddress = addresses.change.find(a => !a.transfers) ||
+            addresses.change[addresses.change.length - 1];
+        const changeId = (0, pathUtils_1.getHDPath)(changeAddress.path).slice(-1)[0];
+        const enhancement = {
+            baseFee,
+            floorBaseFee: false,
+            dustOutputFee: 0,
+        };
+        if (coinInfo.shortcut === 'DOGE') {
+            enhancement.dustOutputFee = 1000000;
+        }
+        return (0, utxo_lib_1.composeTx)({
+            txType: account.type,
+            utxos: this.utxos,
+            outputs: this.outputs,
+            height: this.blockHeight,
+            feeRate,
+            skipPermutation: this.skipPermutation,
+            basePath: account.address_n,
+            network: coinInfo.network,
+            changeId,
+            changeAddress: changeAddress.address,
+            dustThreshold: coinInfo.dustLimit,
+            ...enhancement,
+        });
+    }
+    dispose() {
+    }
+}
+exports.TransactionComposer = TransactionComposer;
+//# sourceMappingURL=TransactionComposer.js.map

package/lib/api/bitcoin/__fixtures__/inputs.d.ts

@@ -0,0 +1,112 @@
+export declare const validateTrezorInputs: ({
+    description: string;
+    params: {
+        address_n: number[];
+        amount: string;
+        prev_index: number;
+        prev_hash: string;
+    }[];
+    result: {
+        amount: string;
+    }[];
+} | {
+    description: string;
+    params: {
+        address_n: number[];
+        amount: string;
+        prev_index: number;
+        prev_hash: string;
+    }[];
+    result: {
+        address_n: number[];
+    }[];
+} | {
+    description: string;
+    params: {
+        address_n: number[];
+        amount: string;
+        prev_index: number;
+        prev_hash: string;
+        multisig: {
+            pubkeys: {
+                node: string;
+            }[];
+        };
+    }[];
+    result: {
+        multisig: {
+            pubkeys: {
+                node: {
+                    public_key: string;
+                    chain_code: string;
+                    depth: number;
+                };
+            }[];
+        };
+    }[];
+} | {
+    description: string;
+    params: {
+        amount: string;
+        prev_index: number;
+        prev_hash: string;
+        script_type: string;
+        script_pubkey: string;
+        witness: string;
+    }[];
+    result: {
+        amount: string;
+    }[];
+} | {
+    description: string;
+    params: {
+        amount: string;
+        prev_index: number;
+        prev_hash: string;
+    }[];
+    result?: undefined;
+} | {
+    description: string;
+    params: {
+        address_n: number[];
+        amount: string;
+        prev_hash: string;
+    }[];
+    result?: undefined;
+} | {
+    description: string;
+    params: {
+        address_n: number[];
+        amount: string;
+        prev_index: number;
+    }[];
+    result?: undefined;
+} | {
+    description: string;
+    params: {
+        address_n: number[];
+        prev_index: number;
+        prev_hash: string;
+    }[];
+    result: {
+        prev_index: number;
+    }[];
+} | {
+    description: string;
+    params: {
+        address_n: number[];
+        prev_index: number;
+        prev_hash: string;
+    }[];
+    result?: undefined;
+} | {
+    description: string;
+    params: {
+        amount: string;
+        prev_index: number;
+        prev_hash: string;
+        script_type: string;
+    }[];
+    result?: undefined;
+})[];
+//# sourceMappingURL=inputs.d.ts.map

package/lib/api/bitcoin/__fixtures__/inputs.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTrezorInputs = void 0;
+exports.validateTrezorInputs = [
+    {
+        description: 'valid input',
+        params: [
+            {
+                address_n: [1],
+                amount: '1',
+                prev_index: 1,
+                prev_hash: 'txid',
+            },
+        ],
+        result: [{ amount: '1' }],
+    },
+    {
+        description: 'input with fixed path',
+        params: [
+            {
+                address_n: [44 | 0x80000000],
+                amount: '1',
+                prev_index: 1,
+                prev_hash: 'txid',
+            },
+        ],
+        result: [{ address_n: [(44 | 0x80000000) >>> 0] }],
+    },
+    {
+        description: 'input with converted multisig pubkey',
+        params: [
+            {
+                address_n: [0],
+                amount: '1',
+                prev_index: 1,
+                prev_hash: 'txid',
+                multisig: {
+                    pubkeys: [
+                        {
+                            node: 'xpub661MyMwAqRbcF1zGijBb2K6x9YiJPh58xpcCeLvTxMX6spkY3PcpJ4ABcCyWfskq5DDxM3e6Ez5ePCqG5bnPUXR4wL8TZWyoDaUdiWW7bKy',
+                        },
+                    ],
+                },
+            },
+        ],
+        result: [
+            {
+                multisig: {
+                    pubkeys: [
+                        {
+                            node: {
+                                public_key: '03f645ec6544a92f951f3bca16a2bc1c56846d065594db222725d59b9902528385',
+                                chain_code: '2fb77e25cd3e2e034bcbafa1f81ec7e4caf927b06c87db296f1186208315525e',
+                                depth: 0,
+                            },
+                        },
+                    ],
+                },
+            },
+        ],
+    },
+    {
+        description: 'valid EXTERNAL input',
+        params: [
+            {
+                amount: '1',
+                prev_index: 1,
+                prev_hash: 'txid',
+                script_type: 'EXTERNAL',
+                script_pubkey: '0000',
+                witness: '00',
+            },
+        ],
+        result: [{ amount: '1' }],
+    },
+    {
+        description: 'missing address_n',
+        params: [{ amount: '1', prev_index: 1, prev_hash: 'txid' }],
+    },
+    {
+        description: 'missing prev_index',
+        params: [{ address_n: [0], amount: '1', prev_hash: 'txid' }],
+    },
+    {
+        description: 'missing prev_hash',
+        params: [{ address_n: [0], amount: '1', prev_index: 1 }],
+    },
+    {
+        description: 'missing amount on non segwit path. valid only because of legacy reasons',
+        params: [{ address_n: [0], prev_index: 1, prev_hash: 'txid' }],
+        result: [{ prev_index: 1 }],
+    },
+    {
+        description: 'missing amount p2sh',
+        params: [{ address_n: [49 | 0x80000000], prev_index: 1, prev_hash: 'txid' }],
+    },
+    {
+        description: 'missing script_pubkey in EXTERNAL',
+        params: [{ amount: '1', prev_index: 1, prev_hash: 'txid', script_type: 'EXTERNAL' }],
+    },
+];
+//# sourceMappingURL=inputs.js.map