@trezor/connect 9.0.0-beta.1

package/lib/api/changePin.d.ts

@@ -0,0 +1,7 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { PROTO } from '../constants';
+export default class ChangePin extends AbstractMethod<'changePin', PROTO.ChangePin> {
+    init(): void;
+    run(): Promise<PROTO.Success>;
+}
+//# sourceMappingURL=changePin.d.ts.map

package/lib/api/changePin.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+class ChangePin extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['management'];
+        this.useDeviceState = false;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [{ name: 'remove', type: 'boolean' }]);
+        this.params = {
+            remove: payload.remove,
+        };
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('ChangePin', 'Success', this.params);
+        return response.message;
+    }
+}
+exports.default = ChangePin;
+//# sourceMappingURL=changePin.js.map

package/lib/api/cipherKeyValue.d.ts

@@ -0,0 +1,8 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { PROTO } from '../constants';
+export default class CipherKeyValue extends AbstractMethod<'cipherKeyValue', PROTO.CipherKeyValue[]> {
+    hasBundle?: boolean;
+    init(): void;
+    run(): Promise<PROTO.CipheredKeyValue | PROTO.CipheredKeyValue[]>;
+}
+//# sourceMappingURL=cipherKeyValue.d.ts.map

package/lib/api/cipherKeyValue.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("../events");
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const pathUtils_1 = require("../utils/pathUtils");
+class CipherKeyValue extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
+        this.info = 'Cypher key value';
+        this.useEmptyPassphrase = true;
+        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: 'key', type: 'string' },
+                { name: 'value', type: 'string' },
+                { name: 'encrypt', type: 'boolean' },
+                { name: 'askOnEncrypt', type: 'boolean' },
+                { name: 'askOnDecrypt', type: 'boolean' },
+                { name: 'iv', type: 'string' },
+            ]);
+            return {
+                address_n: (0, pathUtils_1.validatePath)(batch.path),
+                key: batch.key,
+                value: batch.value instanceof Buffer ? batch.value.toString('hex') : batch.value,
+                encrypt: batch.encrypt,
+                ask_on_encrypt: batch.askOnEncrypt,
+                ask_on_decrypt: batch.askOnDecrypt,
+                iv: batch.iv instanceof Buffer ? batch.iv.toString('hex') : batch.iv,
+            };
+        });
+    }
+    async run() {
+        const responses = [];
+        const cmd = this.device.getCommands();
+        for (let i = 0; i < this.params.length; i++) {
+            const response = await cmd.typedCall('CipherKeyValue', 'CipheredKeyValue', this.params[i]);
+            responses.push(response.message);
+            if (this.hasBundle) {
+                this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
+                    progress: i,
+                    response,
+                }));
+            }
+        }
+        return this.hasBundle ? responses : responses[0];
+    }
+}
+exports.default = CipherKeyValue;
+//# sourceMappingURL=cipherKeyValue.js.map

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

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { PROTO } from '../../constants';
+import { Blockchain } from '../../backend/BlockchainLink';
+import { DeviceCommands } from '../../device/DeviceCommands';
+import type { CoinInfo, DiscoveryAccountType, DiscoveryAccount } from '../../types';
+import type { GetAccountInfo } from '../../types/api/getAccountInfo';
+declare type DiscoveryType = {
+    type: DiscoveryAccountType;
+    getPath: (index: number) => number[];
+};
+declare type DiscoveryOptions = {
+    blockchain: Blockchain;
+    commands: DeviceCommands;
+    limit?: number;
+    derivationType?: PROTO.CardanoDerivationType;
+};
+export declare class Discovery extends EventEmitter {
+    types: DiscoveryType[];
+    typeIndex: number;
+    accounts: DiscoveryAccount[];
+    coinInfo: CoinInfo;
+    blockchain: Blockchain;
+    commands: DeviceCommands;
+    index: number;
+    interrupted: boolean;
+    completed: boolean;
+    derivationType?: PROTO.CardanoDerivationType;
+    constructor(options: DiscoveryOptions);
+    start(details?: GetAccountInfo['details']): Promise<void>;
+    stop(): void;
+    dispose(): void;
+}
+export {};
+//# sourceMappingURL=Discovery.d.ts.map

package/lib/api/common/Discovery.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Discovery = void 0;
+const tslib_1 = require("tslib");
+const events_1 = (0, tslib_1.__importDefault)(require("events"));
+const constants_1 = require("../../constants");
+const accountUtils_1 = require("../../utils/accountUtils");
+const formatUtils_1 = require("../../utils/formatUtils");
+class Discovery extends events_1.default {
+    constructor(options) {
+        super();
+        this.types = [];
+        this.accounts = [];
+        this.index = 0;
+        this.typeIndex = 0;
+        this.interrupted = false;
+        this.completed = false;
+        this.blockchain = options.blockchain;
+        this.commands = options.commands;
+        this.coinInfo = options.blockchain.coinInfo;
+        this.derivationType = options.derivationType;
+        const { coinInfo } = this;
+        if (coinInfo.type === 'bitcoin') {
+            const getDescriptor = (purpose, index) => (0, accountUtils_1.getAccountAddressN)(coinInfo, index, { purpose });
+            if (coinInfo.xPubMagicSegwitNative) {
+                this.types.push({
+                    type: 'p2wpkh',
+                    getPath: getDescriptor.bind(this, 84),
+                });
+            }
+            if (coinInfo.xPubMagicSegwit) {
+                this.types.push({
+                    type: 'p2sh',
+                    getPath: getDescriptor.bind(this, 49),
+                });
+            }
+            this.types.push({
+                type: 'p2pkh',
+                getPath: getDescriptor.bind(this, 44),
+            });
+        }
+        else {
+            this.types.push({
+                type: 'p2pkh',
+                getPath: accountUtils_1.getAccountAddressN.bind(this, coinInfo),
+            });
+        }
+    }
+    async start(details) {
+        const limit = 10;
+        this.interrupted = false;
+        while (!this.completed && !this.interrupted) {
+            const accountType = this.types[this.typeIndex];
+            const label = `Account #${this.index + 1}`;
+            const overTheLimit = this.index >= limit;
+            const path = accountType.getPath(this.index);
+            const descriptor = await this.commands.getAccountDescriptor(this.coinInfo, path, this.derivationType);
+            if (!descriptor) {
+                throw constants_1.ERRORS.TypedError('Runtime', 'Discovery: descriptor not found');
+            }
+            if (this.interrupted)
+                return;
+            const account = {
+                ...descriptor,
+                type: accountType.type,
+                label,
+            };
+            this.accounts = this.accounts.filter(a => a.descriptor !== account.descriptor);
+            if (!overTheLimit) {
+                this.accounts.push(account);
+                this.emit('progress', this.accounts);
+            }
+            const info = await this.blockchain.getAccountInfo({
+                descriptor: account.descriptor,
+                details,
+            });
+            if (this.interrupted)
+                return;
+            this.accounts = this.accounts.filter(a => a.descriptor !== account.descriptor);
+            if (!overTheLimit || (overTheLimit && !info.empty)) {
+                const balance = (0, formatUtils_1.formatAmount)(info.availableBalance, this.coinInfo);
+                this.accounts.push({
+                    ...account,
+                    empty: info.empty,
+                    balance,
+                    addresses: info.addresses,
+                });
+                this.emit('progress', this.accounts);
+            }
+            if (info.empty) {
+                if (this.typeIndex + 1 < this.types.length) {
+                    this.typeIndex++;
+                    this.index = 0;
+                }
+                else {
+                    this.emit('complete');
+                    this.completed = true;
+                }
+            }
+            else {
+                this.index++;
+            }
+        }
+    }
+    stop() {
+        this.interrupted = !this.completed;
+    }
+    dispose() {
+        this.accounts = [];
+    }
+}
+exports.Discovery = Discovery;
+//# sourceMappingURL=Discovery.js.map