@trezor/connect 9.0.0-beta.1

package/lib/api/firmware/modifyFirmware.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modifyFirmware = void 0;
+const utils_1 = require("@trezor/utils");
+const modifyFirmware = ({ fw, features }) => {
+    if (features.major_version === 2)
+        return fw;
+    if (utils_1.versionUtils.isNewerOrEqual([features.major_version, features.minor_version, features.patch_version], [1, 8, 0])) {
+        const fwView = new Uint8Array(fw);
+        if (String.fromCharCode(...Array.from(fwView.slice(0, 4))) === 'TRZR' &&
+            String.fromCharCode(...Array.from(fwView.slice(256, 260))) === 'TRZF') {
+            return fw.slice(256);
+        }
+    }
+    return fw;
+};
+exports.modifyFirmware = modifyFirmware;
+//# sourceMappingURL=modifyFirmware.js.map

package/lib/api/firmwareUpdate.d.ts

@@ -0,0 +1,15 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+declare type Params = {
+    binary?: ArrayBuffer;
+    version?: number[];
+    btcOnly?: boolean;
+    baseUrl?: string;
+    intermediary?: boolean;
+};
+export default class FirmwareUpdate extends AbstractMethod<'firmwareUpdate', Params> {
+    init(): void;
+    confirmation(): Promise<boolean>;
+    run(): Promise<import("packages/transport/lib/types/messages").Success>;
+}
+export {};
+//# sourceMappingURL=firmwareUpdate.d.ts.map

package/lib/api/firmwareUpdate.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getBinary_1 = require("./firmware/getBinary");
+const modifyFirmware_1 = require("./firmware/modifyFirmware");
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const constants_1 = require("../constants");
+const events_1 = require("../events");
+const uploadFirmware_1 = require("./management/uploadFirmware");
+const paramsValidator_1 = require("./common/paramsValidator");
+const firmwareInfo_1 = require("../data/firmwareInfo");
+const firmwareUtils_1 = require("../utils/firmwareUtils");
+class FirmwareUpdate extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.useEmptyPassphrase = true;
+        this.requiredPermissions = ['management'];
+        this.allowDeviceMode = [events_1.UI.BOOTLOADER, events_1.UI.INITIALIZE];
+        this.requireDeviceMode = [events_1.UI.BOOTLOADER];
+        this.useDeviceState = false;
+        this.skipFirmwareCheck = true;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'version', type: 'array' },
+            { name: 'btcOnly', type: 'boolean' },
+            { name: 'baseUrl', type: 'string' },
+            { name: 'binary', type: 'array-buffer' },
+            { name: 'intermediary', type: 'boolean' },
+        ]);
+        if ('version' in payload) {
+            this.params = {
+                version: payload.version,
+                btcOnly: payload.btcOnly,
+                baseUrl: payload.baseUrl || 'https://data.trezor.io',
+                intermediary: payload.intermediary,
+            };
+        }
+        if ('binary' in payload) {
+            this.params = {
+                ...this.params,
+                binary: payload.binary,
+            };
+        }
+    }
+    async confirmation() {
+        await this.getPopupPromise().promise;
+        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+            view: 'device-management',
+            customConfirmButton: {
+                className: 'wipe',
+                label: 'Proceed',
+            },
+            label: 'Do you want to update firmware? Never do this without your recovery card.',
+        }));
+        const uiResp = await uiPromise.promise;
+        return uiResp.payload;
+    }
+    async run() {
+        const { device, params } = this;
+        let binary;
+        try {
+            if (params.binary) {
+                if (!(0, firmwareUtils_1.isStrictFeatures)(device.features)) {
+                    throw new Error('Features of unexpected shape provided');
+                }
+                binary = (0, modifyFirmware_1.modifyFirmware)({
+                    fw: params.binary,
+                    features: device.features,
+                });
+            }
+            else {
+                const firmware = await (0, getBinary_1.getBinary)({
+                    features: device.features,
+                    releases: (0, firmwareInfo_1.getReleases)(device.features.major_version),
+                    version: params.version,
+                    btcOnly: params.btcOnly,
+                    baseUrl: params.baseUrl,
+                    intermediary: params.intermediary,
+                });
+                binary = firmware.binary;
+            }
+        }
+        catch (err) {
+            throw constants_1.ERRORS.TypedError('Method_FirmwareUpdate_DownloadFailed', 'Failed to download firmware binary');
+        }
+        return (0, uploadFirmware_1.uploadFirmware)(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, { payload: binary });
+    }
+}
+exports.default = FirmwareUpdate;
+//# sourceMappingURL=firmwareUpdate.js.map

package/lib/api/getAccountInfo.d.ts

@@ -0,0 +1,98 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import { Discovery } from './common/Discovery';
+import type { CoinInfo, AccountInfo, AccountUtxo } from '../types';
+import type { GetAccountInfo as GetAccountInfoParams } from '../types/api/getAccountInfo';
+declare type Request = GetAccountInfoParams & {
+    address_n: number[];
+    coinInfo: CoinInfo;
+};
+export default class GetAccountInfo extends AbstractMethod<'getAccountInfo', Request[]> {
+    disposed: boolean;
+    hasBundle?: boolean;
+    discovery?: Discovery;
+    init(): void;
+    confirmation(): Promise<boolean>;
+    noBackupConfirmation(): Promise<boolean>;
+    checkFirmwareRange(isUsingPopup: boolean): Promise<"ui-device_firmware_old" | "ui-device_firmware_unsupported" | "ui-device_firmware_not_compatible" | "ui-device_firmware_not_installed" | undefined>;
+    run(): Promise<AccountInfo | (AccountInfo | null)[] | {
+        utxo: AccountUtxo[] | undefined;
+        descriptor: string;
+        balance: string;
+        availableBalance: string;
+        empty: boolean;
+        tokens?: import("packages/blockchain-link/lib/types/common").TokenInfo[] | undefined;
+        addresses?: import("packages/blockchain-link/lib/types/common").AccountAddresses | undefined;
+        history: {
+            total: number;
+            tokens?: number | undefined;
+            unconfirmed: number;
+            transactions?: import("packages/blockchain-link/lib/types/common").Transaction[] | undefined;
+            txids?: string[] | undefined;
+        };
+        misc?: {
+            nonce?: string | undefined;
+            erc20Contract?: import("packages/blockchain-link/lib/types/common").TokenInfo | undefined;
+            sequence?: number | undefined;
+            reserve?: string | undefined;
+            rewards?: string | undefined;
+            staking?: {
+                address: string;
+                isActive: boolean;
+                rewards: string;
+                poolId: string | null;
+            } | undefined;
+        } | undefined;
+        page?: {
+            index: number;
+            size: number;
+            total: number;
+        } | undefined;
+        marker?: {
+            ledger: number;
+            seq: number;
+        } | undefined;
+        path: string;
+    }>;
+    discover(request: Request): Promise<{
+        utxo: AccountUtxo[] | undefined;
+        descriptor: string;
+        balance: string;
+        availableBalance: string;
+        empty: boolean;
+        tokens?: import("packages/blockchain-link/lib/types/common").TokenInfo[] | undefined;
+        addresses?: import("packages/blockchain-link/lib/types/common").AccountAddresses | undefined;
+        history: {
+            total: number;
+            tokens?: number | undefined;
+            unconfirmed: number;
+            transactions?: import("packages/blockchain-link/lib/types/common").Transaction[] | undefined;
+            txids?: string[] | undefined;
+        };
+        misc?: {
+            nonce?: string | undefined;
+            erc20Contract?: import("packages/blockchain-link/lib/types/common").TokenInfo | undefined;
+            sequence?: number | undefined;
+            reserve?: string | undefined;
+            rewards?: string | undefined;
+            staking?: {
+                address: string;
+                isActive: boolean;
+                rewards: string;
+                poolId: string | null;
+            } | undefined;
+        } | undefined;
+        page?: {
+            index: number;
+            size: number;
+            total: number;
+        } | undefined;
+        marker?: {
+            ledger: number;
+            seq: number;
+        } | undefined;
+        path: string;
+    }>;
+    dispose(): void;
+}
+export {};
+//# sourceMappingURL=getAccountInfo.d.ts.map

package/lib/api/getAccountInfo.js

@@ -0,0 +1,326 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const Discovery_1 = require("./common/Discovery");
+const paramsValidator_1 = require("./common/paramsValidator");
+const pathUtils_1 = require("../utils/pathUtils");
+const accountUtils_1 = require("../utils/accountUtils");
+const promiseUtils_1 = require("../utils/promiseUtils");
+const coinInfo_1 = require("../data/coinInfo");
+const constants_1 = require("../constants");
+const events_1 = require("../events");
+const BlockchainLink_1 = require("../backend/BlockchainLink");
+class GetAccountInfo extends AbstractMethod_1.AbstractMethod {
+    constructor() {
+        super(...arguments);
+        this.disposed = false;
+    }
+    init() {
+        this.requiredPermissions = ['read'];
+        this.info = 'Export account info';
+        this.useDevice = true;
+        this.useUi = true;
+        let willUseDevice = false;
+        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: 'coin', type: 'string', required: true },
+                { name: 'descriptor', type: 'string' },
+                { name: 'path', type: 'string' },
+                { name: 'details', type: 'string' },
+                { name: 'tokens', type: 'string' },
+                { name: 'page', type: 'number' },
+                { name: 'pageSize', type: 'number' },
+                { name: 'from', type: 'number' },
+                { name: 'to', type: 'number' },
+                { name: 'contractFilter', type: 'string' },
+                { name: 'gap', type: 'number' },
+                { name: 'marker', type: 'object' },
+                { name: 'defaultAccountType', type: 'string' },
+                { name: 'derivationType', type: 'number' },
+            ]);
+            const coinInfo = (0, coinInfo_1.getCoinInfo)(batch.coin);
+            if (!coinInfo) {
+                throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+            }
+            (0, BlockchainLink_1.isBackendSupported)(coinInfo);
+            let address_n = [];
+            if (batch.path) {
+                address_n = (0, pathUtils_1.validatePath)(batch.path, 3);
+                willUseDevice = typeof batch.descriptor !== 'string';
+            }
+            if (!batch.path && !batch.descriptor) {
+                if (payload.bundle.length > 1) {
+                    throw Error('Discovery for multiple coins in not supported');
+                }
+                willUseDevice = true;
+            }
+            this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
+            return {
+                ...batch,
+                address_n,
+                coinInfo,
+            };
+        });
+        this.useDevice = willUseDevice;
+        this.useUi = willUseDevice;
+    }
+    async confirmation() {
+        await this.getPopupPromise().promise;
+        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
+        if (this.params.length === 1 && !this.params[0].path && !this.params[0].descriptor) {
+            this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+                view: 'export-account-info',
+                label: `Export info for ${this.params[0].coinInfo.label} account of your selection`,
+                customConfirmButton: {
+                    label: 'Proceed to account selection',
+                    className: 'not-empty-css',
+                },
+            }));
+        }
+        else {
+            const keys = {};
+            this.params.forEach(b => {
+                if (!keys[b.coinInfo.label]) {
+                    keys[b.coinInfo.label] = {
+                        coinInfo: b.coinInfo,
+                        values: [],
+                    };
+                }
+                keys[b.coinInfo.label].values.push(b.descriptor || b.address_n);
+            });
+            const str = [];
+            Object.keys(keys).forEach((k, _i, _a) => {
+                const details = keys[k];
+                details.values.forEach(acc => {
+                    str.push('<span>');
+                    str.push(k);
+                    str.push(' ');
+                    if (typeof acc === 'string') {
+                        str.push(acc);
+                    }
+                    else {
+                        str.push((0, accountUtils_1.getAccountLabel)(acc, details.coinInfo));
+                    }
+                    str.push('</span>');
+                });
+            });
+            this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+                view: 'export-account-info',
+                label: `Export info for: ${str.join('')}`,
+            }));
+        }
+        const uiResp = await uiPromise.promise;
+        return uiResp.payload;
+    }
+    async noBackupConfirmation() {
+        await this.getPopupPromise().promise;
+        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+            view: 'no-backup',
+        }));
+        const uiResp = await uiPromise.promise;
+        return uiResp.payload;
+    }
+    async checkFirmwareRange(isUsingPopup) {
+        if (isUsingPopup || this.params.length === 1) {
+            return super.checkFirmwareRange(isUsingPopup);
+        }
+        const defaultRange = {
+            1: { min: '1.0.0', max: '0' },
+            2: { min: '2.0.0', max: '0' },
+        };
+        const invalid = [];
+        for (let i = 0; i < this.params.length; i++) {
+            this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, this.params[i].coinInfo, defaultRange);
+            const exception = await super.checkFirmwareRange(false);
+            if (exception) {
+                invalid.push({
+                    index: i,
+                    exception,
+                    coin: this.params[i].coin,
+                });
+            }
+        }
+        if (invalid.length > 0) {
+            throw constants_1.ERRORS.TypedError('Method_Discovery_BundleException', JSON.stringify(invalid));
+        }
+    }
+    async run() {
+        if (this.params.length === 1 && !this.params[0].path && !this.params[0].descriptor) {
+            return this.discover(this.params[0]);
+        }
+        const responses = [];
+        const sendProgress = (progress, response, error) => {
+            if (!this.hasBundle || (this.device && this.device.getCommands().disposed))
+                return;
+            this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
+                progress,
+                response,
+                error,
+            }));
+        };
+        for (let i = 0; i < this.params.length; i++) {
+            const request = this.params[i];
+            const { address_n } = request;
+            let { descriptor } = request;
+            let legacyXpub;
+            if (this.disposed)
+                break;
+            if (address_n && typeof descriptor !== 'string') {
+                try {
+                    const accountDescriptor = await this.device
+                        .getCommands()
+                        .getAccountDescriptor(request.coinInfo, address_n, typeof request.derivationType !== 'undefined'
+                        ? request.derivationType
+                        : constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR);
+                    if (accountDescriptor) {
+                        descriptor = accountDescriptor.descriptor;
+                        legacyXpub = accountDescriptor.legacyXpub;
+                    }
+                }
+                catch (error) {
+                    if (this.hasBundle) {
+                        responses.push(null);
+                        sendProgress(i, null, error.message);
+                        continue;
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+            if (this.disposed)
+                break;
+            try {
+                if (typeof descriptor !== 'string') {
+                    throw constants_1.ERRORS.TypedError('Runtime', 'GetAccountInfo: descriptor not found');
+                }
+                const blockchain = await (0, BlockchainLink_1.initBlockchain)(request.coinInfo, this.postMessage);
+                if (this.disposed)
+                    break;
+                const info = await blockchain.getAccountInfo({
+                    descriptor,
+                    details: request.details,
+                    tokens: request.tokens,
+                    page: request.page,
+                    pageSize: request.pageSize,
+                    from: request.from,
+                    to: request.to,
+                    contractFilter: request.contractFilter,
+                    gap: request.gap,
+                    marker: request.marker,
+                });
+                if (this.disposed)
+                    break;
+                let utxo;
+                if ((0, accountUtils_1.isUtxoBased)(request.coinInfo) &&
+                    typeof request.details === 'string' &&
+                    request.details !== 'basic') {
+                    utxo = await blockchain.getAccountUtxo(descriptor);
+                }
+                if (this.disposed)
+                    break;
+                const account = {
+                    path: request.path,
+                    ...info,
+                    descriptor,
+                    legacyXpub,
+                    utxo,
+                };
+                responses.push(account);
+                sendProgress(i, account);
+            }
+            catch (error) {
+                if (this.hasBundle) {
+                    responses.push(null);
+                    sendProgress(i, null, error.message);
+                    continue;
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        if (this.disposed)
+            return new Promise(() => []);
+        return this.hasBundle ? responses : responses[0];
+    }
+    async discover(request) {
+        const { coinInfo, defaultAccountType } = request;
+        const blockchain = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage);
+        const dfd = this.createUiPromise(events_1.UI.RECEIVE_ACCOUNT);
+        const discovery = new Discovery_1.Discovery({
+            blockchain,
+            commands: this.device.getCommands(),
+            derivationType: typeof request.derivationType !== 'undefined'
+                ? request.derivationType
+                : constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR,
+        });
+        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().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),
+            defaultAccountType,
+            coinInfo,
+        }));
+        const uiResp = await dfd.promise;
+        discovery.stop();
+        const account = discovery.accounts[uiResp.payload];
+        if (!discovery.completed) {
+            await (0, promiseUtils_1.resolveAfter)(501);
+        }
+        const info = await blockchain.getAccountInfo({
+            descriptor: account.descriptor,
+            details: request.details,
+            tokens: request.tokens,
+            page: request.page,
+            pageSize: request.pageSize,
+            from: request.from,
+            to: request.to,
+            contractFilter: request.contractFilter,
+            gap: request.gap,
+            marker: request.marker,
+        });
+        let utxo;
+        if ((0, accountUtils_1.isUtxoBased)(coinInfo) &&
+            typeof request.details === 'string' &&
+            request.details !== 'basic') {
+            utxo = await blockchain.getAccountUtxo(account.descriptor);
+        }
+        return {
+            path: (0, pathUtils_1.getSerializedPath)(account.address_n),
+            ...info,
+            utxo,
+        };
+    }
+    dispose() {
+        this.disposed = true;
+        const { discovery } = this;
+        if (discovery) {
+            discovery.removeAllListeners();
+            discovery.stop();
+        }
+    }
+}
+exports.default = GetAccountInfo;
+//# sourceMappingURL=getAccountInfo.js.map

package/lib/api/getAddress.d.ts

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