@trezor/connect 9.0.0-beta.1

package/lib/api/ethereum/__fixtures__/ethereumSignTypedData.js

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeData = exports.getFieldType = exports.parseArrayType = void 0;
+const tslib_1 = require("tslib");
+const bignumber_js_1 = (0, tslib_1.__importDefault)(require("bignumber.js"));
+const errors_1 = require("../../../constants/errors");
+const constants_1 = require("../../../constants");
+exports.parseArrayType = [
+    {
+        description: 'should parse sized arrays',
+        input: 'uint8[26]',
+        output: {
+            entryTypeName: 'uint8',
+            arraySize: 26,
+        },
+    },
+    {
+        description: 'should parse dynamic arrays',
+        input: 'int32[]',
+        output: {
+            entryTypeName: 'int32',
+            arraySize: null,
+        },
+    },
+    {
+        description: 'should parse nested arrays',
+        input: 'int32[5][12]',
+        output: {
+            entryTypeName: 'int32[5]',
+            arraySize: 12,
+        },
+    },
+    {
+        description: 'should throw error for non-array type',
+        input: 'bytes',
+        error: [errors_1.TrezorError, 'could not be parsed'],
+    },
+];
+exports.getFieldType = [
+    {
+        description: `should parse uints`,
+        input: {
+            typeName: 'uint256',
+            types: {},
+        },
+        output: {
+            data_type: constants_1.PROTO.EthereumDataType.UINT,
+            size: 32,
+        },
+    },
+    {
+        description: `should parse ints`,
+        input: {
+            typeName: 'int8',
+            types: {},
+        },
+        output: {
+            data_type: constants_1.PROTO.EthereumDataType.INT,
+            size: 1,
+        },
+    },
+    {
+        description: `should parse booleans`,
+        input: {
+            typeName: 'bool',
+            types: {},
+        },
+        output: {
+            data_type: constants_1.PROTO.EthereumDataType.BOOL,
+        },
+    },
+    {
+        description: `should parse address`,
+        input: {
+            typeName: 'address',
+            types: {},
+        },
+        output: {
+            data_type: constants_1.PROTO.EthereumDataType.ADDRESS,
+        },
+    },
+    {
+        description: `should parse dynamic bytes`,
+        input: {
+            typeName: 'bytes',
+            types: {},
+        },
+        output: {
+            data_type: constants_1.PROTO.EthereumDataType.BYTES,
+            size: undefined,
+        },
+    },
+    {
+        description: `should parse fixed-size bytes`,
+        input: {
+            typeName: 'bytes18',
+            types: {},
+        },
+        output: {
+            data_type: constants_1.PROTO.EthereumDataType.BYTES,
+            size: 18,
+        },
+    },
+    {
+        description: `should parse array types`,
+        input: {
+            typeName: 'uint256[57]',
+            types: {},
+        },
+        output: {
+            data_type: constants_1.PROTO.EthereumDataType.ARRAY,
+            size: 57,
+            entry_type: {
+                data_type: constants_1.PROTO.EthereumDataType.UINT,
+                size: 32,
+            },
+        },
+    },
+    {
+        description: `should parse dynamic array types`,
+        input: {
+            typeName: 'uint256[]',
+            types: {},
+        },
+        output: {
+            data_type: constants_1.PROTO.EthereumDataType.ARRAY,
+            size: undefined,
+            entry_type: {
+                data_type: constants_1.PROTO.EthereumDataType.UINT,
+                size: 32,
+            },
+        },
+    },
+    {
+        description: 'should parse nested arrays',
+        input: {
+            typeName: 'int32[5][12]',
+            types: {},
+        },
+        output: {
+            data_type: constants_1.PROTO.EthereumDataType.ARRAY,
+            size: 12,
+            entry_type: {
+                data_type: constants_1.PROTO.EthereumDataType.ARRAY,
+                size: 5,
+                entry_type: {
+                    data_type: constants_1.PROTO.EthereumDataType.INT,
+                    size: 4,
+                },
+            },
+        },
+    },
+    {
+        description: `should parse Struct types`,
+        input: {
+            typeName: 'ExampleStruct',
+            types: {
+                ExampleStruct: [
+                    { name: 'message', type: 'string' },
+                    { name: 'cost', type: 'int8' },
+                ],
+            },
+        },
+        output: {
+            data_type: constants_1.PROTO.EthereumDataType.STRUCT,
+            size: 2,
+            struct_name: 'ExampleStruct',
+        },
+    },
+    {
+        description: `should throw if Struct type not defined`,
+        input: {
+            typeName: 'MissingType',
+            types: {},
+        },
+        error: [errors_1.TrezorError, 'No type definition specified: MissingType'],
+    },
+];
+exports.encodeData = [
+    {
+        description: 'should remove leading `0x` from byte hex-string',
+        input: {
+            typeName: 'bytes',
+            data: '0x0123456789abcdef',
+        },
+        output: '0123456789abcdef',
+    },
+    {
+        description: 'should pad hex to nearest byte',
+        input: {
+            typeName: 'bytes',
+            data: '0x1',
+        },
+        output: '01',
+    },
+    {
+        description: 'should encode bytes from Buffer',
+        input: {
+            typeName: 'bytes',
+            data: Buffer.from('0123456789abcdef', 'hex'),
+        },
+        output: '0123456789abcdef',
+    },
+    {
+        description: 'should encode bytes from ArrayBuffer',
+        input: {
+            typeName: 'bytes',
+            data: new Uint8Array([0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]).buffer,
+        },
+        output: '0123456789abcdef',
+    },
+    {
+        description: 'should remove leading `0x` from Ethereum address',
+        input: {
+            typeName: 'address',
+            data: '0x000000000000000000000000000000000000dead',
+        },
+        output: '000000000000000000000000000000000000dead',
+    },
+    {
+        description: `should encode unsigned integers`,
+        input: {
+            typeName: 'uint8',
+            data: 255,
+        },
+        output: 'ff',
+    },
+    {
+        description: `should encode positive signed integers`,
+        input: {
+            typeName: 'int8',
+            data: 127,
+        },
+        output: '7f',
+    },
+    {
+        description: `should encode negative signed integers`,
+        input: {
+            typeName: 'int8',
+            data: -1,
+        },
+        output: 'ff',
+    },
+    {
+        description: `should encode int from bigint`,
+        input: {
+            typeName: 'int256',
+            data: -(1n << 254n) + 1n,
+        },
+        output: 'c000000000000000000000000000000000000000000000000000000000000001',
+    },
+    {
+        description: `should encode int from string`,
+        input: {
+            typeName: 'int256',
+            data: `${-(1n << 254n) + 1n}`,
+        },
+        output: 'c000000000000000000000000000000000000000000000000000000000000001',
+    },
+    {
+        description: `should encode int from BigNumber`,
+        input: {
+            typeName: 'int256',
+            data: new bignumber_js_1.default(2).pow(254).negated().plus(1),
+        },
+        output: 'c000000000000000000000000000000000000000000000000000000000000001',
+    },
+    {
+        description: `should encode uint from hex-string`,
+        input: {
+            typeName: 'uint256',
+            data: '0xc000000000000000000000000000000000000000000000000000000000000001',
+        },
+        output: 'c000000000000000000000000000000000000000000000000000000000000001',
+    },
+    {
+        description: `should throw overflow error when signed int is too large`,
+        input: {
+            typeName: 'int8',
+            data: 128,
+        },
+        error: [errors_1.TrezorError, 'overflow'],
+    },
+    {
+        description: `should throw overflow error when signed int is too small`,
+        input: {
+            typeName: 'int8',
+            data: -129,
+        },
+        error: [errors_1.TrezorError, 'overflow'],
+    },
+    {
+        description: `should throw overflow error when unsigned int is too large`,
+        input: {
+            typeName: 'uint8',
+            data: 256,
+        },
+        error: [errors_1.TrezorError, 'overflow'],
+    },
+    {
+        description: `should throw error when unsigned int is negative`,
+        input: {
+            typeName: 'uint8',
+            data: -1,
+        },
+        error: [errors_1.TrezorError, 'negative'],
+    },
+    {
+        description: 'should encode string as utf-8',
+        input: {
+            typeName: 'string',
+            data: 'Trezor Model T is an amazing piece of hardware. 😋😋',
+        },
+        output: '5472657a6f72204d6f64656c205420697320616e20616d617a696e67207069656365206f662068617264776172652e20f09f988bf09f988b',
+    },
+    {
+        description: 'should encode bool as a single byte',
+        input: {
+            typeName: 'bool',
+            data: true,
+        },
+        output: '01',
+    },
+    {
+        description: 'should encode bool as a single byte',
+        input: {
+            typeName: 'bool',
+            data: false,
+        },
+        output: '00',
+    },
+    {
+        description: 'should throw for array types',
+        input: {
+            typeName: 'bool[1]',
+            data: [true],
+        },
+        error: [errors_1.TrezorError, 'Unsupported'],
+    },
+];
+//# sourceMappingURL=ethereumSignTypedData.js.map

package/lib/api/ethereum/ethereumSignTx.d.ts

@@ -0,0 +1,13 @@
+import type { TypedCall } from '../../device/DeviceCommands';
+import type { EthereumAccessList } from '../../types/api/ethereumSignTransaction';
+export declare const ethereumSignTx: (typedCall: TypedCall, address_n: number[], to: string, value: string, gas_limit: string, gas_price: string, nonce: string, chain_id: number, data?: string | undefined, tx_type?: number | undefined) => Promise<{
+    v: string;
+    r: string;
+    s: string;
+}>;
+export declare const ethereumSignTxEIP1559: (typedCall: TypedCall, address_n: number[], to: string, value: string, gas_limit: string, max_gas_fee: string, max_priority_fee: string, nonce: string, chain_id: number, data?: string | undefined, access_list?: EthereumAccessList[] | undefined) => Promise<{
+    v: string;
+    r: string;
+    s: string;
+}>;
+//# sourceMappingURL=ethereumSignTx.d.ts.map

package/lib/api/ethereum/ethereumSignTx.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ethereumSignTxEIP1559 = exports.ethereumSignTx = void 0;
+const constants_1 = require("../../constants");
+const splitString = (str, len) => {
+    if (str == null) {
+        return ['', ''];
+    }
+    const first = str.slice(0, len);
+    const second = str.slice(len);
+    return [first, second];
+};
+const processTxRequest = async (typedCall, request, data, chain_id) => {
+    if (!request.data_length) {
+        let v = request.signature_v;
+        const r = request.signature_r;
+        const s = request.signature_s;
+        if (v == null || r == null || s == null) {
+            throw constants_1.ERRORS.TypedError('Runtime', 'processTxRequest: Unexpected request');
+        }
+        if (chain_id && v <= 1) {
+            v += 2 * chain_id + 35;
+        }
+        return Promise.resolve({
+            v: `0x${v.toString(16)}`,
+            r: `0x${r}`,
+            s: `0x${s}`,
+        });
+    }
+    const [first, rest] = splitString(data, request.data_length * 2);
+    const response = await typedCall('EthereumTxAck', 'EthereumTxRequest', { data_chunk: first });
+    return processTxRequest(typedCall, response.message, rest, chain_id);
+};
+const stripLeadingZeroes = (str) => {
+    while (/^00/.test(str)) {
+        str = str.slice(2);
+    }
+    return str;
+};
+const ethereumSignTx = async (typedCall, address_n, to, value, gas_limit, gas_price, nonce, chain_id, data, tx_type) => {
+    const length = data == null ? 0 : data.length / 2;
+    const [first, rest] = splitString(data, 1024 * 2);
+    let message = {
+        address_n,
+        chain_id,
+        nonce: stripLeadingZeroes(nonce),
+        gas_price: stripLeadingZeroes(gas_price),
+        gas_limit: stripLeadingZeroes(gas_limit),
+        to,
+        value: stripLeadingZeroes(value),
+    };
+    if (length !== 0) {
+        message = {
+            ...message,
+            data_length: length,
+            data_initial_chunk: first,
+        };
+    }
+    if (tx_type !== null) {
+        message = {
+            ...message,
+            tx_type,
+        };
+    }
+    const response = await typedCall('EthereumSignTx', 'EthereumTxRequest', message);
+    return processTxRequest(typedCall, response.message, rest, chain_id);
+};
+exports.ethereumSignTx = ethereumSignTx;
+const ethereumSignTxEIP1559 = async (typedCall, address_n, to, value, gas_limit, max_gas_fee, max_priority_fee, nonce, chain_id, data, access_list) => {
+    const length = data == null ? 0 : data.length / 2;
+    const [first, rest] = splitString(data, 1024 * 2);
+    const message = {
+        address_n,
+        nonce: stripLeadingZeroes(nonce),
+        max_gas_fee: stripLeadingZeroes(max_gas_fee),
+        max_priority_fee: stripLeadingZeroes(max_priority_fee),
+        gas_limit: stripLeadingZeroes(gas_limit),
+        to,
+        value: stripLeadingZeroes(value),
+        data_length: length,
+        data_initial_chunk: first,
+        chain_id,
+        access_list: (access_list || []).map(a => ({
+            address: a.address,
+            storage_keys: a.storageKeys,
+        })),
+    };
+    const response = await typedCall('EthereumSignTxEIP1559', 'EthereumTxRequest', message);
+    return processTxRequest(typedCall, response.message, rest);
+};
+exports.ethereumSignTxEIP1559 = ethereumSignTxEIP1559;
+//# sourceMappingURL=ethereumSignTx.js.map

package/lib/api/ethereum/ethereumSignTypedData.d.ts

@@ -0,0 +1,9 @@
+import { PROTO } from '../../constants';
+import type { EthereumSignTypedDataTypes } from '../../types/api/ethereumSignTypedData';
+export declare function parseArrayType(arrayTypeName: string): {
+    entryTypeName: string;
+    arraySize: number | null;
+};
+export declare function encodeData(typeName: string, data: any): string;
+export declare function getFieldType(typeName: string, types: EthereumSignTypedDataTypes): PROTO.EthereumFieldType;
+//# sourceMappingURL=ethereumSignTypedData.d.ts.map

package/lib/api/ethereum/ethereumSignTypedData.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFieldType = exports.encodeData = exports.parseArrayType = void 0;
+const tslib_1 = require("tslib");
+const bignumber_js_1 = (0, tslib_1.__importDefault)(require("bignumber.js"));
+const constants_1 = require("../../constants");
+const formatUtils_1 = require("../../utils/formatUtils");
+const paramTypeArray = new RegExp(/^(.*)\[([0-9]*)\]$/);
+const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
+const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
+function parseArrayType(arrayTypeName) {
+    const arrayMatch = paramTypeArray.exec(arrayTypeName);
+    if (arrayMatch === null) {
+        throw constants_1.ERRORS.TypedError('Runtime', `typename ${arrayTypeName} could not be parsed as an EIP-712 array`);
+    }
+    const [_, entryTypeName, arraySize] = arrayMatch;
+    return {
+        entryTypeName,
+        arraySize: parseInt(arraySize, 10) || null,
+    };
+}
+exports.parseArrayType = parseArrayType;
+function twosComplement(number, bytes) {
+    if (bytes < 1 || bytes > 32) {
+        throw constants_1.ERRORS.TypedError('Runtime', 'Int byte size must be between 1 and 32 (8 and 256 bits)');
+    }
+    const minValue = new bignumber_js_1.default(2).exponentiatedBy(bytes * 8 - 1).negated();
+    const maxValue = minValue.negated().minus(1);
+    const bigNumber = new bignumber_js_1.default(number);
+    if (bigNumber.isGreaterThan(maxValue) || bigNumber.isLessThan(minValue)) {
+        throw constants_1.ERRORS.TypedError('Runtime', `Overflow when trying to convert number ${number} into ${bytes} bytes`);
+    }
+    if (bigNumber.isPositive()) {
+        return bigNumber;
+    }
+    return bigNumber.minus(minValue).minus(minValue);
+}
+function intToHex(number, bytes, signed) {
+    let bigNumber = new bignumber_js_1.default(number);
+    if (signed) {
+        bigNumber = twosComplement(bigNumber, bytes);
+    }
+    if (bigNumber.isNegative()) {
+        throw constants_1.ERRORS.TypedError('Runtime', `Cannot convert negative number to unsigned interger: ${number}`);
+    }
+    const hex = bigNumber.toString(16);
+    const hexChars = bytes * 2;
+    if (hex.length > hexChars) {
+        throw constants_1.ERRORS.TypedError('Runtime', `Overflow when trying to convert number ${number} into ${bytes} bytes`);
+    }
+    return hex.padStart(bytes * 2, '0');
+}
+function encodeData(typeName, data) {
+    if (paramTypeBytes.test(typeName) || typeName === 'address') {
+        return (0, formatUtils_1.messageToHex)(data);
+    }
+    if (typeName === 'string') {
+        return Buffer.from(data, 'utf-8').toString('hex');
+    }
+    const numberMatch = paramTypeNumber.exec(typeName);
+    if (numberMatch) {
+        const [_, intType, bits] = numberMatch;
+        const bytes = Math.ceil(parseInt(bits, 10) / 8);
+        return intToHex(data, bytes, intType === 'int');
+    }
+    if (typeName === 'bool') {
+        return data ? '01' : '00';
+    }
+    throw constants_1.ERRORS.TypedError('Runtime', `Unsupported data type for direct field encoding: ${typeName}`);
+}
+exports.encodeData = encodeData;
+const paramTypesMap = {
+    string: constants_1.PROTO.EthereumDataType.STRING,
+    bool: constants_1.PROTO.EthereumDataType.BOOL,
+    address: constants_1.PROTO.EthereumDataType.ADDRESS,
+};
+function getFieldType(typeName, types) {
+    const arrayMatch = paramTypeArray.exec(typeName);
+    if (arrayMatch) {
+        const [_, arrayItemTypeName, arraySize] = arrayMatch;
+        const entryType = getFieldType(arrayItemTypeName, types);
+        return {
+            data_type: constants_1.PROTO.EthereumDataType.ARRAY,
+            size: parseInt(arraySize, 10) || undefined,
+            entry_type: entryType,
+        };
+    }
+    const numberMatch = paramTypeNumber.exec(typeName);
+    if (numberMatch) {
+        const [_, type, bits] = numberMatch;
+        return {
+            data_type: type === 'uint' ? constants_1.PROTO.EthereumDataType.UINT : constants_1.PROTO.EthereumDataType.INT,
+            size: Math.floor(parseInt(bits, 10) / 8),
+        };
+    }
+    const bytesMatch = paramTypeBytes.exec(typeName);
+    if (bytesMatch) {
+        const [_, size] = bytesMatch;
+        return {
+            data_type: constants_1.PROTO.EthereumDataType.BYTES,
+            size: parseInt(size, 10) || undefined,
+        };
+    }
+    const fixedSizeTypeMatch = paramTypesMap[typeName];
+    if (fixedSizeTypeMatch) {
+        return {
+            data_type: fixedSizeTypeMatch,
+        };
+    }
+    if (typeName in types) {
+        return {
+            data_type: constants_1.PROTO.EthereumDataType.STRUCT,
+            size: types[typeName].length,
+            struct_name: typeName,
+        };
+    }
+    throw constants_1.ERRORS.TypedError('Runtime', `No type definition specified: ${typeName}`);
+}
+exports.getFieldType = getFieldType;
+//# sourceMappingURL=ethereumSignTypedData.js.map

package/lib/api/ethereumGetAddress.d.ts

@@ -0,0 +1,28 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import { PROTO } from '../constants';
+import type { EthereumNetworkInfo } from '../types';
+declare type Params = PROTO.EthereumGetAddress & {
+    address?: string;
+    network?: EthereumNetworkInfo;
+};
+export default class EthereumGetAddress extends AbstractMethod<'ethereumGetAddress', 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<{
+        path: number[];
+        serializedPath: string;
+        address: string;
+    }>;
+    run(): Promise<import("../types").Address | import("../types").Address[]>;
+}
+export {};
+//# sourceMappingURL=ethereumGetAddress.d.ts.map