@trezor/connect 9.0.0-beta.1

package/lib/api/eos/eosSignTx.js

@@ -0,0 +1,347 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signTx = exports.validate = void 0;
+const tslib_1 = require("tslib");
+const bs58 = (0, tslib_1.__importStar)(require("bs58"));
+const constants_1 = require("../../constants");
+const binaryToDecimal = (bignum, minDigits = 1) => {
+    const result = Array(minDigits).fill('0'.charCodeAt(0));
+    for (let i = bignum.length - 1; i >= 0; --i) {
+        let carry = bignum[i];
+        for (let j = 0; j < result.length; ++j) {
+            const x = ((result[j] - '0'.charCodeAt(0)) << 8) + carry;
+            result[j] = '0'.charCodeAt(0) + (x % 10);
+            carry = (x / 10) | 0;
+        }
+        while (carry) {
+            result.push('0'.charCodeAt(0) + (carry % 10));
+            carry = (carry / 10) | 0;
+        }
+    }
+    result.reverse();
+    return String.fromCharCode(...result);
+};
+const serialize = (s) => {
+    if (typeof s !== 'string') {
+        throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Eos serialization error, "${typeof s}" should be a string`);
+    }
+    const charToSymbol = (c) => {
+        if (c >= 'a'.charCodeAt(0) && c <= 'z'.charCodeAt(0)) {
+            return c - 'a'.charCodeAt(0) + 6;
+        }
+        if (c >= '1'.charCodeAt(0) && c <= '5'.charCodeAt(0)) {
+            return c - '1'.charCodeAt(0) + 1;
+        }
+        return 0;
+    };
+    const a = new Uint8Array(8);
+    let bit = 63;
+    for (let i = 0; i < s.length; ++i) {
+        let c = charToSymbol(s.charCodeAt(i));
+        if (bit < 5) {
+            c <<= 1;
+        }
+        for (let j = 4; j >= 0; --j) {
+            if (bit >= 0) {
+                a[Math.floor(bit / 8)] |= ((c >> j) & 1) << bit % 8;
+                --bit;
+            }
+        }
+    }
+    return binaryToDecimal(a);
+};
+const parseQuantity = (s) => {
+    if (typeof s !== 'string') {
+        throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Eos serialization error. Expected string containing asset, got: ${typeof s}`);
+    }
+    s = s.trim();
+    let pos = 0;
+    let amount = '';
+    let precision = 0;
+    if (s[pos] === '-') {
+        amount += '-';
+        ++pos;
+    }
+    let foundDigit = false;
+    while (pos < s.length &&
+        s.charCodeAt(pos) >= '0'.charCodeAt(0) &&
+        s.charCodeAt(pos) <= '9'.charCodeAt(0)) {
+        foundDigit = true;
+        amount += s[pos];
+        ++pos;
+    }
+    if (!foundDigit) {
+        throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Eos serialization error. Asset must begin with a number');
+    }
+    if (s[pos] === '.') {
+        ++pos;
+        while (pos < s.length &&
+            s.charCodeAt(pos) >= '0'.charCodeAt(0) &&
+            s.charCodeAt(pos) <= '9'.charCodeAt(0)) {
+            amount += s[pos];
+            ++precision;
+            ++pos;
+        }
+    }
+    const symbol = s.substring(pos).trim();
+    const a = [precision & 0xff];
+    for (let i = 0; i < symbol.length; ++i) {
+        a.push(symbol.charCodeAt(i));
+    }
+    while (a.length < 8) {
+        a.push(0);
+    }
+    return {
+        amount,
+        symbol: binaryToDecimal(a.slice(0, 8)),
+    };
+};
+const parseAuth = (a) => {
+    const keyToBuffer = (pk) => {
+        const len = pk.indexOf('EOS') === 0 ? 3 : 7;
+        const key = bs58.decode(pk.substring(len));
+        return {
+            type: 0,
+            key: key.slice(0, key.length - 4).toString('hex'),
+        };
+    };
+    return {
+        threshold: a.threshold,
+        keys: a.keys.map(k => ({
+            weight: k.weight,
+            ...keyToBuffer(k.key),
+        })),
+        accounts: a.accounts.map(acc => ({
+            weight: acc.weight,
+            account: {
+                actor: serialize(acc.permission.actor),
+                permission: serialize(acc.permission.permission),
+            },
+        })),
+        waits: a.waits,
+    };
+};
+const parseDate = (d) => {
+    if (typeof d !== 'string') {
+        throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Eos serialization error. Header.expiration should be string or number');
+    }
+    if (d.substring(d.length - 1, d.length) !== 'Z') {
+        d += 'Z';
+    }
+    return Date.parse(d) / 1000;
+};
+const parseAck = (action) => {
+    switch (action.name) {
+        case 'transfer':
+            return {
+                transfer: {
+                    sender: serialize(action.data.from),
+                    receiver: serialize(action.data.to),
+                    quantity: parseQuantity(action.data.quantity),
+                    memo: action.data.memo,
+                },
+            };
+        case 'delegatebw':
+            return {
+                delegate: {
+                    sender: serialize(action.data.from),
+                    receiver: serialize(action.data.receiver),
+                    net_quantity: parseQuantity(action.data.stake_net_quantity),
+                    cpu_quantity: parseQuantity(action.data.stake_cpu_quantity),
+                    transfer: action.data.transfer,
+                },
+            };
+        case 'undelegatebw':
+            return {
+                undelegate: {
+                    sender: serialize(action.data.from),
+                    receiver: serialize(action.data.receiver),
+                    net_quantity: parseQuantity(action.data.unstake_net_quantity),
+                    cpu_quantity: parseQuantity(action.data.unstake_cpu_quantity),
+                },
+            };
+        case 'buyram':
+            return {
+                buy_ram: {
+                    payer: serialize(action.data.payer),
+                    receiver: serialize(action.data.receiver),
+                    quantity: parseQuantity(action.data.quant),
+                },
+            };
+        case 'buyrambytes':
+            return {
+                buy_ram_bytes: {
+                    payer: serialize(action.data.payer),
+                    receiver: serialize(action.data.receiver),
+                    bytes: action.data.bytes,
+                },
+            };
+        case 'sellram':
+            return {
+                sell_ram: {
+                    account: serialize(action.data.account),
+                    bytes: action.data.bytes,
+                },
+            };
+        case 'voteproducer':
+            return {
+                vote_producer: {
+                    voter: serialize(action.data.voter),
+                    proxy: serialize(action.data.proxy),
+                    producers: action.data.producers.map(p => serialize(p)),
+                },
+            };
+        case 'refund':
+            return {
+                refund: {
+                    owner: serialize(action.data.owner),
+                },
+            };
+        case 'updateauth':
+            return {
+                update_auth: {
+                    account: serialize(action.data.account),
+                    permission: serialize(action.data.permission),
+                    parent: serialize(action.data.parent),
+                    auth: parseAuth(action.data.auth),
+                },
+            };
+        case 'deleteauth':
+            return {
+                delete_auth: {
+                    account: serialize(action.data.account),
+                    permission: serialize(action.data.permission),
+                },
+            };
+        case 'linkauth':
+            return {
+                link_auth: {
+                    account: serialize(action.data.account),
+                    code: serialize(action.data.code),
+                    type: serialize(action.data.type),
+                    requirement: serialize(action.data.requirement),
+                },
+            };
+        case 'unlinkauth':
+            return {
+                unlink_auth: {
+                    account: serialize(action.data.account),
+                    code: serialize(action.data.code),
+                    type: serialize(action.data.type),
+                },
+            };
+        case 'newaccount':
+            return {
+                new_account: {
+                    creator: serialize(action.data.creator),
+                    name: serialize(action.data.name),
+                    owner: parseAuth(action.data.owner),
+                    active: parseAuth(action.data.active),
+                },
+            };
+        default:
+            return null;
+    }
+};
+const parseUnknown = (action) => {
+    if (typeof action.data !== 'string')
+        return null;
+    return {
+        unknown: {
+            data_size: action.data.length / 2,
+            data_chunk: action.data,
+        },
+    };
+};
+const parseCommon = (action) => ({
+    account: serialize(action.account),
+    name: serialize(action.name),
+    authorization: action.authorization.map(a => ({
+        actor: serialize(a.actor),
+        permission: serialize(a.permission),
+    })),
+});
+const parseAction = (action) => {
+    const ack = parseAck(action) || parseUnknown(action);
+    return {
+        common: parseCommon(action),
+        ...ack,
+    };
+};
+const validate = (tx) => {
+    const header = {
+        expiration: typeof tx.header.expiration === 'number'
+            ? tx.header.expiration
+            : parseDate(tx.header.expiration),
+        ref_block_num: tx.header.refBlockNum,
+        ref_block_prefix: tx.header.refBlockPrefix,
+        max_net_usage_words: tx.header.maxNetUsageWords,
+        max_cpu_usage_ms: tx.header.maxCpuUsageMs,
+        delay_sec: tx.header.delaySec,
+    };
+    const ack = [];
+    tx.actions.forEach(action => {
+        ack.push(parseAction(action));
+    });
+    return {
+        chain_id: tx.chainId,
+        header,
+        ack,
+    };
+};
+exports.validate = validate;
+const CHUNK_SIZE = 2048;
+const getDataChunk = (data, offset) => {
+    if (!data || offset < 0 || data.length < offset)
+        return '';
+    const o = offset > 0 ? data.length - offset * 2 : 0;
+    return data.substring(o, o + CHUNK_SIZE * 2);
+};
+const processTxRequest = async (typedCall, message, actions, index) => {
+    const action = actions[index];
+    const lastOp = index + 1 >= actions.length;
+    let ack;
+    const requestedDataSize = message.data_size;
+    if (action.unknown) {
+        const { unknown } = action;
+        const offset = typeof requestedDataSize === 'number' ? requestedDataSize : 0;
+        const data_chunk = getDataChunk(unknown.data_chunk, offset);
+        const params = {
+            common: action.common,
+            unknown: {
+                data_size: unknown.data_size,
+                data_chunk,
+            },
+        };
+        const sent = offset > 0 ? unknown.data_size - offset + CHUNK_SIZE : CHUNK_SIZE;
+        const lastChunk = sent >= unknown.data_size;
+        if (lastOp && lastChunk) {
+            const response = await typedCall('EosTxActionAck', 'EosSignedTx', params);
+            return response.message;
+        }
+        ack = await typedCall('EosTxActionAck', 'EosTxActionRequest', params);
+        if (lastChunk) {
+            index++;
+        }
+    }
+    else {
+        if (lastOp) {
+            const response = await typedCall('EosTxActionAck', 'EosSignedTx', action);
+            return response.message;
+        }
+        ack = await typedCall('EosTxActionAck', 'EosTxActionRequest', action);
+        index++;
+    }
+    return processTxRequest(typedCall, ack.message, actions, index);
+};
+const signTx = async (typedCall, address_n, chain_id, header, actions) => {
+    const response = await typedCall('EosSignTx', 'EosTxActionRequest', {
+        address_n,
+        chain_id,
+        header,
+        num_actions: actions.length,
+    });
+    return processTxRequest(typedCall, response.message, actions, 0);
+};
+exports.signTx = signTx;
+//# sourceMappingURL=eosSignTx.js.map

package/lib/api/eosGetPublicKey.d.ts

@@ -0,0 +1,10 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { PROTO } from '../constants';
+export default class EosGetPublicKey extends AbstractMethod<'eosGetPublicKey', PROTO.EosGetPublicKey[]> {
+    hasBundle?: boolean;
+    confirmed?: boolean;
+    init(): void;
+    confirmation(): Promise<boolean>;
+    run(): Promise<import("../types/api/eosGetPublicKey").EosPublicKey | import("../types/api/eosGetPublicKey").EosPublicKey[]>;
+}
+//# sourceMappingURL=eosGetPublicKey.d.ts.map

package/lib/api/eosGetPublicKey.js

@@ -0,0 +1,73 @@
+"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 events_1 = require("../events");
+class EosGetPublicKey extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('EOS'), this.firmwareRange);
+        this.info = 'Export Eos public key';
+        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' }]);
+        this.params = payload.bundle.map(batch => {
+            (0, paramsValidator_1.validateParams)(batch, [
+                { name: 'path', required: true },
+                { name: 'showOnTrezor', type: 'boolean' },
+            ]);
+            const path = (0, pathUtils_1.validatePath)(batch.path, 3);
+            return {
+                address_n: path,
+                show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : false,
+            };
+        });
+    }
+    async confirmation() {
+        if (this.confirmed)
+            return true;
+        await this.getPopupPromise().promise;
+        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
+        let label;
+        if (this.params.length > 1) {
+            label = 'Export multiple Eos public keys';
+        }
+        else {
+            label = `Export Eos public key for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_n[2]) + 1}`;
+        }
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+            view: 'export-address',
+            label,
+        }));
+        const uiResp = await uiPromise.promise;
+        this.confirmed = uiResp.payload;
+        return this.confirmed;
+    }
+    async run() {
+        const responses = [];
+        const cmd = this.device.getCommands();
+        for (let i = 0; i < this.params.length; i++) {
+            const batch = this.params[i];
+            const { message } = await cmd.typedCall('EosGetPublicKey', 'EosPublicKey', batch);
+            responses.push({
+                rawPublicKey: message.raw_public_key,
+                wifPublicKey: message.wif_public_key,
+                path: batch.address_n,
+                serializedPath: (0, pathUtils_1.getSerializedPath)(batch.address_n),
+            });
+            if (this.hasBundle) {
+                this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
+                    progress: i,
+                    response: message,
+                }));
+            }
+        }
+        return this.hasBundle ? responses : responses[0];
+    }
+}
+exports.default = EosGetPublicKey;
+//# sourceMappingURL=eosGetPublicKey.js.map

package/lib/api/eosSignTransaction.d.ts

@@ -0,0 +1,16 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { PROTO } from '../constants';
+declare type Params = {
+    path: number[];
+    chain_id: string;
+    header: PROTO.EosTxHeader;
+    ack: PROTO.EosTxActionAck[];
+};
+export default class EosSignTransaction extends AbstractMethod<'eosSignTransaction', Params> {
+    init(): void;
+    run(): Promise<{
+        signature: string;
+    }>;
+}
+export {};
+//# sourceMappingURL=eosSignTransaction.d.ts.map

package/lib/api/eosSignTransaction.js

@@ -0,0 +1,36 @@
+"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("./eos/eosSignTx"));
+class EosSignTransaction extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('EOS'), this.firmwareRange);
+        this.info = 'Sign EOS 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, 3);
+        const { chain_id, header, ack } = helper.validate(payload.transaction);
+        this.params = {
+            path,
+            chain_id,
+            header,
+            ack,
+        };
+    }
+    async run() {
+        const response = await helper.signTx(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, this.params.chain_id, this.params.header, this.params.ack);
+        return {
+            signature: response.signature,
+        };
+    }
+}
+exports.default = EosSignTransaction;
+//# sourceMappingURL=eosSignTransaction.js.map

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

@@ -0,0 +1,225 @@
+import BigNumber from 'bignumber.js';
+import { TrezorError } from '../../../constants/errors';
+import { PROTO } from '../../../constants';
+export declare const parseArrayType: ({
+    description: string;
+    input: string;
+    output: {
+        entryTypeName: string;
+        arraySize: number;
+    };
+    error?: undefined;
+} | {
+    description: string;
+    input: string;
+    output: {
+        entryTypeName: string;
+        arraySize: null;
+    };
+    error?: undefined;
+} | {
+    description: string;
+    input: string;
+    error: (string | typeof TrezorError)[];
+    output?: undefined;
+})[];
+export declare const getFieldType: ({
+    description: string;
+    input: {
+        typeName: string;
+        types: {
+            ExampleStruct?: undefined;
+        };
+    };
+    output: {
+        data_type: PROTO.EthereumDataType;
+        size: number;
+        entry_type?: undefined;
+        struct_name?: undefined;
+    };
+    error?: undefined;
+} | {
+    description: string;
+    input: {
+        typeName: string;
+        types: {
+            ExampleStruct?: undefined;
+        };
+    };
+    output: {
+        data_type: PROTO.EthereumDataType;
+        size?: undefined;
+        entry_type?: undefined;
+        struct_name?: undefined;
+    };
+    error?: undefined;
+} | {
+    description: string;
+    input: {
+        typeName: string;
+        types: {
+            ExampleStruct?: undefined;
+        };
+    };
+    output: {
+        data_type: PROTO.EthereumDataType;
+        size: undefined;
+        entry_type?: undefined;
+        struct_name?: undefined;
+    };
+    error?: undefined;
+} | {
+    description: string;
+    input: {
+        typeName: string;
+        types: {
+            ExampleStruct?: undefined;
+        };
+    };
+    output: {
+        data_type: PROTO.EthereumDataType;
+        size: number;
+        entry_type: {
+            data_type: PROTO.EthereumDataType;
+            size: number;
+            entry_type?: undefined;
+        };
+        struct_name?: undefined;
+    };
+    error?: undefined;
+} | {
+    description: string;
+    input: {
+        typeName: string;
+        types: {
+            ExampleStruct?: undefined;
+        };
+    };
+    output: {
+        data_type: PROTO.EthereumDataType;
+        size: undefined;
+        entry_type: {
+            data_type: PROTO.EthereumDataType;
+            size: number;
+            entry_type?: undefined;
+        };
+        struct_name?: undefined;
+    };
+    error?: undefined;
+} | {
+    description: string;
+    input: {
+        typeName: string;
+        types: {
+            ExampleStruct?: undefined;
+        };
+    };
+    output: {
+        data_type: PROTO.EthereumDataType;
+        size: number;
+        entry_type: {
+            data_type: PROTO.EthereumDataType;
+            size: number;
+            entry_type: {
+                data_type: PROTO.EthereumDataType;
+                size: number;
+            };
+        };
+        struct_name?: undefined;
+    };
+    error?: undefined;
+} | {
+    description: string;
+    input: {
+        typeName: string;
+        types: {
+            ExampleStruct: {
+                name: string;
+                type: string;
+            }[];
+        };
+    };
+    output: {
+        data_type: PROTO.EthereumDataType;
+        size: number;
+        struct_name: string;
+        entry_type?: undefined;
+    };
+    error?: undefined;
+} | {
+    description: string;
+    input: {
+        typeName: string;
+        types: {
+            ExampleStruct?: undefined;
+        };
+    };
+    error: (string | typeof TrezorError)[];
+    output?: undefined;
+})[];
+export declare const encodeData: ({
+    description: string;
+    input: {
+        typeName: string;
+        data: string;
+    };
+    output: string;
+    error?: undefined;
+} | {
+    description: string;
+    input: {
+        typeName: string;
+        data: ArrayBufferLike;
+    };
+    output: string;
+    error?: undefined;
+} | {
+    description: string;
+    input: {
+        typeName: string;
+        data: number;
+    };
+    output: string;
+    error?: undefined;
+} | {
+    description: string;
+    input: {
+        typeName: string;
+        data: bigint;
+    };
+    output: string;
+    error?: undefined;
+} | {
+    description: string;
+    input: {
+        typeName: string;
+        data: BigNumber;
+    };
+    output: string;
+    error?: undefined;
+} | {
+    description: string;
+    input: {
+        typeName: string;
+        data: number;
+    };
+    error: (string | typeof TrezorError)[];
+    output?: undefined;
+} | {
+    description: string;
+    input: {
+        typeName: string;
+        data: boolean;
+    };
+    output: string;
+    error?: undefined;
+} | {
+    description: string;
+    input: {
+        typeName: string;
+        data: boolean[];
+    };
+    error: (string | typeof TrezorError)[];
+    output?: undefined;
+})[];
+//# sourceMappingURL=ethereumSignTypedData.d.ts.map