@trezor/connect 9.0.0-beta.1

package/lib/api/common/__fixtures__/paramsValidator.js

@@ -0,0 +1,355 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFirmwareRange = exports.validateParams = void 0;
+exports.validateParams = [
+    {
+        description: 'array',
+        type: 'array',
+        value: [],
+        success: true,
+        allowEmpty: true,
+    },
+    {
+        description: 'array invalid (empty)',
+        type: 'array',
+        value: [],
+    },
+    {
+        description: 'array-buffer',
+        type: 'array-buffer',
+        value: new ArrayBuffer(0),
+        success: true,
+    },
+    {
+        description: 'array-buffer invalid',
+        type: 'array-buffer',
+        value: Buffer.from('foo'),
+    },
+    {
+        description: 'array-buffer invalid',
+        type: 'array-buffer',
+        value: [],
+    },
+    {
+        description: 'array-buffer invalid',
+        type: 'array-buffer',
+        value: 'foo',
+    },
+    {
+        description: 'array-buffer invalid',
+        type: 'array-buffer',
+        value: 0,
+    },
+    {
+        description: 'uint valid (zero string)',
+        type: 'uint',
+        value: '0',
+        success: true,
+    },
+    {
+        description: 'uint valid (zero number)',
+        type: 'uint',
+        value: 0,
+        success: true,
+    },
+    {
+        description: 'uint valid (positive string)',
+        type: 'uint',
+        value: '10',
+        success: true,
+    },
+    {
+        description: 'uint valid (positive number)',
+        type: 'uint',
+        value: 10,
+        success: true,
+    },
+    {
+        description: 'negative string uint valid (allowNegative)',
+        type: 'uint',
+        allowNegative: true,
+        value: '-1',
+        success: true,
+    },
+    {
+        description: 'negative number uint valid (allowNegative)',
+        type: 'uint',
+        allowNegative: true,
+        value: -1,
+        success: true,
+    },
+    {
+        description: 'uint invalid (decimal number)',
+        type: 'uint',
+        value: 10.1,
+    },
+    {
+        description: 'uint invalid (decimal string)',
+        type: 'uint',
+        value: '10.1',
+    },
+    {
+        description: 'uint invalid (negative number)',
+        type: 'uint',
+        value: -1,
+    },
+    {
+        description: 'uint invalid (negative string)',
+        type: 'uint',
+        value: '-1',
+    },
+    {
+        description: 'uint invalid not safe integer',
+        type: 'uint',
+        value: Number.MAX_SAFE_INTEGER + 2,
+    },
+    {
+        description: 'uint invalid leading zeros',
+        type: 'uint',
+        value: '01',
+    },
+    {
+        description: 'uint invalid digits',
+        type: 'uint',
+        value: '123f',
+    },
+    {
+        description: 'uint invalid type',
+        type: 'uint',
+        value: true,
+    },
+    {
+        description: 'not required param without value (null)',
+        type: 'number',
+        value: null,
+        success: true,
+    },
+    {
+        description: 'not required param without value (undefined)',
+        type: 'string',
+        value: null,
+        success: true,
+    },
+    {
+        description: 'required param without type and false negative value (0)',
+        required: true,
+        value: 0,
+        success: true,
+    },
+    {
+        description: 'required param without type and false negative value (false)',
+        required: true,
+        value: false,
+        success: true,
+    },
+    {
+        description: 'required param without value (null)',
+        required: true,
+        value: null,
+    },
+    {
+        description: 'required param without value (undefined)',
+        required: true,
+        value: undefined,
+    },
+    {
+        description: 'param with union of types (string)',
+        type: ['string', 'boolean', 'number'],
+        value: 'true',
+        success: true,
+    },
+    {
+        description: 'param with union of types (boolean)',
+        type: ['string', 'boolean', 'number'],
+        value: true,
+        success: true,
+    },
+    {
+        description: 'param with union of types (invalid value)',
+        type: ['string', 'boolean', 'number', 'array', 'array-buffer'],
+        value: Buffer.from('00'),
+    },
+];
+const DEFAULT_RANGE = {
+    1: { min: '1.0.0', max: '0' },
+    2: { min: '2.0.0', max: '0' },
+};
+const DEFAULT_COIN_INFO = {
+    support: { trezor1: '1.6.2', trezor2: '2.1.0' },
+    shortcut: 'btc',
+    type: 'bitcoin',
+};
+const EMPTY_CONFIG = {
+    supportedFirmware: [],
+};
+exports.getFirmwareRange = [
+    {
+        description: 'default range. coinInfo and config.json data not found',
+        config: EMPTY_CONFIG,
+        params: ['signTransaction', null, DEFAULT_RANGE],
+        result: DEFAULT_RANGE,
+    },
+    {
+        description: 'range from coinInfo',
+        config: EMPTY_CONFIG,
+        params: ['signTransaction', DEFAULT_COIN_INFO, DEFAULT_RANGE],
+        result: { 1: { min: '1.6.2', max: '0' }, 2: { min: '2.1.0', max: '0' } },
+    },
+    {
+        description: 'coinInfo without support',
+        config: EMPTY_CONFIG,
+        params: ['signTransaction', { shortcut: 'btc', type: 'bitcoin' }, DEFAULT_RANGE],
+        result: { 1: { min: '0', max: '0' }, 2: { min: '0', max: '0' } },
+    },
+    {
+        description: 'coinInfo without T1 support',
+        config: EMPTY_CONFIG,
+        params: [
+            'signTransaction',
+            { support: { trezor1: null, trezor2: '2.1.0' }, shortcut: 'btc', type: 'bitcoin' },
+            DEFAULT_RANGE,
+        ],
+        result: { 1: { min: '0', max: '0' }, 2: { min: '2.1.0', max: '0' } },
+    },
+    {
+        description: 'coinInfo without T2 support',
+        config: EMPTY_CONFIG,
+        params: [
+            'signTransaction',
+            { support: { trezor1: '1.6.2', trezor2: null }, shortcut: 'btc', type: 'bitcoin' },
+            DEFAULT_RANGE,
+        ],
+        result: { 1: { min: '1.6.2', max: '0' }, 2: { min: '0', max: '0' } },
+    },
+    {
+        description: 'coinInfo support is lower than default',
+        config: EMPTY_CONFIG,
+        params: [
+            'signTransaction',
+            DEFAULT_COIN_INFO,
+            { 1: { min: '1.10.0', max: '0' }, 2: { min: '2.4.0', max: '0' } },
+        ],
+        result: { 1: { min: '1.10.0', max: '0' }, 2: { min: '2.4.0', max: '0' } },
+    },
+    {
+        description: 'range from config.json (by coinType and coin as string)',
+        config: {
+            supportedFirmware: [
+                { coinType: 'bitcoin', methods: ['showAddress'], min: ['1.12.0', '2.6.0'] },
+                { coinType: 'bitcoin', min: ['1.10.0', '2.5.0'] },
+                { coin: 'btc', min: ['1.11.0', '2.4.0'] },
+            ],
+        },
+        params: ['signTransaction', DEFAULT_COIN_INFO, DEFAULT_RANGE],
+        result: { 1: { min: '1.11.0', max: '0' }, 2: { min: '2.5.0', max: '0' } },
+    },
+    {
+        description: 'range from config.json (by coin as string)',
+        config: {
+            supportedFirmware: [
+                { coin: 'btc', methods: ['showAddress'], min: ['1.11.0', '2.5.0'] },
+                { coin: 'btc', min: ['1.10.0', '2.4.0'] },
+            ],
+        },
+        params: ['signTransaction', DEFAULT_COIN_INFO, DEFAULT_RANGE],
+        result: { 1: { min: '1.10.0', max: '0' }, 2: { min: '2.4.0', max: '0' } },
+    },
+    {
+        description: 'range from config.json (by coin as array)',
+        config: {
+            supportedFirmware: [
+                { coin: ['btc'], methods: ['showAddress'], min: ['1.11.0', '2.5.0'] },
+                { coin: ['btc'], min: ['1.10.0', '2.4.0'] },
+            ],
+        },
+        params: ['signTransaction', DEFAULT_COIN_INFO, DEFAULT_RANGE],
+        result: { 1: { min: '1.10.0', max: '0' }, 2: { min: '2.4.0', max: '0' } },
+    },
+    {
+        description: 'range from config.json (by methods)',
+        config: {
+            supportedFirmware: [
+                { min: ['1.11.0', '2.5.0'] },
+                { coin: ['btc'], methods: ['showAddress'], min: ['1.11.0', '2.5.0'] },
+                { coin: ['ltc'], methods: ['signTransaction'], min: ['1.11.0', '2.5.0'] },
+                { coinType: 'bitcoin', methods: ['showAddress'], min: ['1.11.0', '2.5.0'] },
+                { methods: ['signTransaction'], min: ['1.10.0', '2.4.0'] },
+            ],
+        },
+        params: ['signTransaction', DEFAULT_COIN_INFO, DEFAULT_RANGE],
+        result: { 1: { min: '1.10.0', max: '0' }, 2: { min: '2.4.0', max: '0' } },
+    },
+    {
+        description: 'range from config.json (by capabilities)',
+        config: {
+            supportedFirmware: [
+                { min: ['1.11.0', '2.5.0'] },
+                { coin: ['btc'], methods: ['showAddress'], min: ['1.11.0', '2.5.0'] },
+                { coin: ['ltc'], methods: ['signTransaction'], min: ['1.11.0', '2.5.0'] },
+                { coinType: 'bitcoin', methods: ['showAddress'], min: ['1.11.0', '2.5.0'] },
+                { capabilities: ['decreaseOutput'], min: ['1.10.0', '2.4.0'] },
+            ],
+        },
+        params: ['decreaseOutput', DEFAULT_COIN_INFO, DEFAULT_RANGE],
+        result: { 1: { min: '1.10.0', max: '0' }, 2: { min: '2.4.0', max: '0' } },
+    },
+    {
+        description: 'range from config.json is lower than coinInfo',
+        config: {
+            supportedFirmware: [{ methods: ['signTransaction'], min: ['1.6.2', '2.1.0'] }],
+        },
+        params: [
+            'signTransaction',
+            { support: { trezor1: '1.10.0', trezor2: '2.4.0' }, shortcut: 'btc', type: 'bitcoin' },
+            DEFAULT_RANGE,
+        ],
+        result: { 1: { min: '1.10.0', max: '0' }, 2: { min: '2.4.0', max: '0' } },
+    },
+    {
+        description: 'range from config.json using max',
+        config: {
+            supportedFirmware: [{ methods: ['signTransaction'], max: ['1.10.0', '2.4.0'] }],
+        },
+        params: ['signTransaction', DEFAULT_COIN_INFO, DEFAULT_RANGE],
+        result: { 1: { min: '1.6.2', max: '1.10.0' }, 2: { min: '2.1.0', max: '2.4.0' } },
+    },
+    {
+        description: 'range from config.json using max (values lower than default)',
+        config: {
+            supportedFirmware: [{ methods: ['signTransaction'], max: ['1.0.1', '2.0.1'] }],
+        },
+        params: [
+            'signTransaction',
+            DEFAULT_COIN_INFO,
+            {
+                1: { min: '1.0.0', max: '1.10.0' },
+                2: { min: '1.0.0', max: '2.10.0' },
+            },
+        ],
+        result: { 1: { min: '1.6.2', max: '1.10.0' }, 2: { min: '2.1.0', max: '2.10.0' } },
+    },
+    {
+        description: 'xrp + getAccountInfo: coinInfo range IS replaced by config.json range',
+        params: [
+            'getAccountInfo',
+            { support: { trezor1: '1.0.1', trezor2: '2.0.1' }, shortcut: 'xrp', type: 'ripple' },
+            DEFAULT_RANGE,
+        ],
+        result: { 1: { min: '0', max: '0' }, 2: { min: '2.1.0', max: '0' } },
+    },
+    {
+        description: 'btc + getAccountInfo: coinInfo range IS NOT replaced by config.json range',
+        params: ['getAccountInfo', null, DEFAULT_RANGE],
+        result: DEFAULT_RANGE,
+    },
+    {
+        description: 'eip1559: coinInfo range is replaced by config.json range',
+        params: [
+            'eip1559',
+            { support: { trezor1: '1.6.2', trezor2: '2.1.0' }, shortcut: 'eth', type: 'ethereum' },
+            DEFAULT_RANGE,
+        ],
+        result: { 1: { min: '1.10.4', max: '0' }, 2: { min: '2.4.2', max: '0' } },
+    },
+];
+//# sourceMappingURL=paramsValidator.js.map

package/lib/api/common/paramsValidator.d.ts

@@ -0,0 +1,14 @@
+import type { CoinInfo, FirmwareRange } from '../../types';
+declare type ParamType = 'string' | 'number' | 'array' | 'array-buffer' | 'boolean' | 'uint' | 'object';
+declare type Param = {
+    name: string;
+    type?: ParamType | ParamType[];
+    required?: boolean;
+    allowEmpty?: boolean;
+    allowNegative?: boolean;
+};
+export declare function validateParams<P extends Record<string, any>>(params: P, schema: Param[]): P;
+export declare const validateCoinPath: (path: number[], coinInfo?: CoinInfo | undefined) => void;
+export declare const getFirmwareRange: (method: string, coinInfo: CoinInfo | null | undefined, currentRange: FirmwareRange) => FirmwareRange;
+export {};
+//# sourceMappingURL=paramsValidator.d.ts.map

package/lib/api/common/paramsValidator.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFirmwareRange = exports.validateCoinPath = exports.validateParams = void 0;
+const constants_1 = require("../../constants");
+const pathUtils_1 = require("../../utils/pathUtils");
+const versionUtils_1 = require("../../utils/versionUtils");
+const config_1 = require("../../data/config");
+const invalidParameter = (message) => constants_1.ERRORS.TypedError('Method_InvalidParameter', message);
+function validateParams(params, schema) {
+    schema.forEach(field => {
+        const value = params[field.name];
+        if (field.required && value == null) {
+            throw invalidParameter(`Parameter "${field.name}" is missing.`);
+        }
+        if (!field.type || value == null)
+            return;
+        const { name, type } = field;
+        if (Array.isArray(type)) {
+            const p = {};
+            p[name] = value;
+            const success = type.reduce((count, t) => {
+                try {
+                    validateParams(p, [{ name: field.name, type: t }]);
+                    return count + 1;
+                }
+                catch (e) {
+                    return count;
+                }
+            }, 0);
+            if (!success) {
+                throw invalidParameter(`Parameter "${name}" has invalid type. Union of "${type.join('|')}" expected.`);
+            }
+            return;
+        }
+        if (type === 'array') {
+            if (!Array.isArray(value)) {
+                throw invalidParameter(`Parameter "${name}" has invalid type. "${type}" expected.`);
+            }
+            if (!field.allowEmpty && value.length < 1) {
+                throw invalidParameter(`Parameter "${name}" is empty.`);
+            }
+        }
+        else if (type === 'uint') {
+            if (typeof value !== 'string' && typeof value !== 'number') {
+                throw invalidParameter(`Parameter "${name}" has invalid type. "string|number" expected.`);
+            }
+            if ((typeof value === 'number' && !Number.isSafeInteger(value)) ||
+                !/^(?:[1-9]\d*|\d)$/.test(value.toString().replace(/^-/, field.allowNegative ? '' : '-'))) {
+                throw invalidParameter(`Parameter "${name}" has invalid value "${value}". Integer representation expected.`);
+            }
+        }
+        else if (type === 'array-buffer') {
+            if (!(value instanceof ArrayBuffer)) {
+                throw invalidParameter(`Parameter "${name}" has invalid type. "ArrayBuffer" expected.`);
+            }
+        }
+        else if (typeof value !== type) {
+            throw invalidParameter(`Parameter "${name}" has invalid type. "${type}" expected.`);
+        }
+    });
+    return params;
+}
+exports.validateParams = validateParams;
+const validateCoinPath = (path, coinInfo) => {
+    if (coinInfo && coinInfo.slip44 !== (0, pathUtils_1.fromHardened)(path[1])) {
+        throw invalidParameter('Parameters "path" and "coin" do not match.');
+    }
+};
+exports.validateCoinPath = validateCoinPath;
+const getFirmwareRange = (method, coinInfo, currentRange) => {
+    const current = JSON.parse(JSON.stringify(currentRange));
+    if (coinInfo) {
+        if (!coinInfo.support || typeof coinInfo.support.trezor1 !== 'string') {
+            current['1'].min = '0';
+        }
+        else if ((0, versionUtils_1.versionCompare)(coinInfo.support.trezor1, current['1'].min) > 0) {
+            current['1'].min = coinInfo.support.trezor1;
+        }
+        if (!coinInfo.support || typeof coinInfo.support.trezor2 !== 'string') {
+            current['2'].min = '0';
+        }
+        else if ((0, versionUtils_1.versionCompare)(coinInfo.support.trezor2, current['2'].min) > 0) {
+            current['2'].min = coinInfo.support.trezor2;
+        }
+    }
+    const coinType = coinInfo ? coinInfo.type : null;
+    const shortcut = coinInfo ? coinInfo.shortcut.toLowerCase() : null;
+    const { supportedFirmware } = config_1.config;
+    const ranges = supportedFirmware
+        .filter(rule => {
+        if (rule.methods) {
+            return rule.methods.includes(method);
+        }
+        if (rule.capabilities) {
+            return rule.capabilities.includes(method);
+        }
+        return true;
+    })
+        .filter(c => {
+        if (c.coinType) {
+            return c.coinType === coinType;
+        }
+        if (c.coin) {
+            return (typeof c.coin === 'string' ? [c.coin] : c.coin).includes(shortcut);
+        }
+        return c.methods || c.capabilities;
+    });
+    ranges.forEach(range => {
+        const { min, max } = range;
+        if (min) {
+            const [t1, t2] = min;
+            if (t1 === '0' ||
+                current['1'].min === '0' ||
+                (0, versionUtils_1.versionCompare)(current['1'].min, t1) < 0) {
+                current['1'].min = t1;
+            }
+            if (t2 === '0' ||
+                current['2'].min === '0' ||
+                (0, versionUtils_1.versionCompare)(current['2'].min, t2) < 0) {
+                current['2'].min = t2;
+            }
+        }
+        if (max) {
+            const [t1, t2] = max;
+            if (t1 === '0' ||
+                current['1'].max === '0' ||
+                (0, versionUtils_1.versionCompare)(current['1'].max, t1) < 0) {
+                current['1'].max = t1;
+            }
+            if (t2 === '0' ||
+                current['2'].max === '0' ||
+                (0, versionUtils_1.versionCompare)(current['2'].max, t2) < 0) {
+                current['2'].max = t2;
+            }
+        }
+    });
+    return current;
+};
+exports.getFirmwareRange = getFirmwareRange;
+//# sourceMappingURL=paramsValidator.js.map

package/lib/api/composeTransaction.d.ts

@@ -0,0 +1,33 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import { Discovery } from './common/Discovery';
+import { TransactionComposer } from './bitcoin';
+import type { ComposeOutput, ComposeResult } from '@trezor/utxo-lib';
+import type { BitcoinNetworkInfo, DiscoveryAccount, AccountUtxo } from '../types';
+import type { SignedTransaction, PrecomposeParams, PrecomposedTransaction } from '../types/api/composeTransaction';
+declare type Params = {
+    outputs: ComposeOutput[];
+    coinInfo: BitcoinNetworkInfo;
+    push: boolean;
+    account?: PrecomposeParams['account'];
+    feeLevels?: PrecomposeParams['feeLevels'];
+    baseFee?: PrecomposeParams['baseFee'];
+    floorBaseFee?: PrecomposeParams['floorBaseFee'];
+    sequence?: PrecomposeParams['sequence'];
+    skipPermutation?: PrecomposeParams['skipPermutation'];
+};
+export default class ComposeTransaction extends AbstractMethod<'composeTransaction', Params> {
+    discovery?: Discovery;
+    init(): void;
+    precompose(account: PrecomposeParams['account'], feeLevels: PrecomposeParams['feeLevels']): Promise<PrecomposedTransaction[]>;
+    run(): Promise<SignedTransaction | PrecomposedTransaction[]>;
+    selectAccount(): Promise<{
+        account: DiscoveryAccount;
+        utxo: AccountUtxo[];
+    }>;
+    selectFee(account: DiscoveryAccount, utxo: AccountUtxo[]): Promise<SignedTransaction | "change-account">;
+    _selectFeeUiResponse(composer: TransactionComposer): Promise<SignedTransaction | 'change-account'>;
+    _sign(tx: ComposeResult): Promise<import("../types/api/signTransaction").SignedTransaction>;
+    dispose(): void;
+}
+export {};
+//# sourceMappingURL=composeTransaction.d.ts.map