@trezor/connect 10.0.0-alpha.1 → 10.0.0-beta.1

package/libESM/api/changeWipeCode.mjs

@@ -1,27 +0,0 @@
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { validateParams } from "./common/paramsValidator.mjs";
-export default class ChangeWipeCode extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'remove',
-      type: 'boolean'
-    }]);
-    const params = {
-      remove: payload.remove
-    };
-    super(message, params);
-    this.skipFinalReload = false;
-    this.useDeviceState = false;
-  }
-  get requiredPermissions() {
-    return ['management'];
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    const response = await cmd.typedCall('ChangeWipeCode', 'Success', this.params);
-    return response.message;
-  }
-}

package/libESM/api/cipherKeyValue.d.mts

@@ -1,15 +0,0 @@
-import { type MethodPermission } from '@trezor/connect-common';
-import type { MessagesSchema as PROTO } from '@trezor/protobuf';
-import type { MethodContext, MethodMessage } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-export default class CipherKeyValue extends AbstractMethod<'cipherKeyValue', PROTO.CipherKeyValue[]> {
-    hasBundle?: boolean;
-    constructor(message: MethodMessage<'cipherKeyValue'>);
-    get requiredPermissions(): MethodPermission[];
-    get info(): string;
-    run({ sendCoreMessage }: MethodContext): Promise<{
-        value: string;
-    } | {
-        value: string;
-    }[]>;
-}

package/libESM/api/cipherKeyValue.mjs

@@ -1,51 +0,0 @@
-import { CipherKeyValue as CipherKeyValueSchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
-import { Bundle } from "@trezor/connect-common/libESM/types/params.mjs";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { bundlify } from "./common/paramsValidator.mjs";
-import { validatePath } from "../utils/pathUtils.mjs";
-export default class CipherKeyValue extends AbstractMethod {
-  hasBundle;
-  constructor(message) {
-    const {
-      hasBundle,
-      payload
-    } = bundlify(message.payload);
-    Assert(Bundle(CipherKeyValueSchema), payload);
-    const params = payload.bundle.map(batch => ({
-      address_n: 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
-    }));
-    super(message, params);
-    this.hasBundle = hasBundle;
-  }
-  get requiredPermissions() {
-    return ['read', 'write'];
-  }
-  get info() {
-    return 'Cipher key value';
-  }
-  async run({
-    sendCoreMessage
-  }) {
-    const responses = [];
-    const cmd = this.getDevice().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) {
-        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
-          total: this.params.length,
-          progress: i,
-          response
-        }));
-      }
-    }
-    return this.hasBundle ? responses : responses[0];
-  }
-}

package/libESM/api/common/AbstractMiscGetAddress.d.mts

@@ -1,35 +0,0 @@
-import { type MethodPermission } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage, MethodReturnType } from '../../core/AbstractMethod';
-import { AbstractMethod } from '../../core/AbstractMethod';
-export type MiscGetAddressMethodName = 'rippleGetAddress' | 'stellarGetAddress' | 'tezosGetAddress' | 'solanaGetAddress' | 'tronGetAddress';
-type MiscProto = {
-    address_n: number[];
-    show_display: boolean;
-    chunkify: boolean;
-};
-export type MiscGetAddressParams = {
-    proto: MiscProto;
-    address?: string;
-};
-export declare abstract class AbstractMiscGetAddress<Name extends MiscGetAddressMethodName> extends AbstractMethod<Name, MiscGetAddressParams[]> {
-    hasBundle?: boolean;
-    progress: number;
-    constructor(message: MethodMessage<Name>, pathDepth: number);
-    get requiredPermissions(): MethodPermission[];
-    protected getInfo(coinName: string, showAccountInInfo: boolean): string;
-    getButtonRequestData(code: string): {
-        type: "address";
-        serializedPath: string;
-        address: string;
-    } | undefined;
-    protected getConfirmation(coinName: string): {
-        view: "export-address";
-        label: string;
-    };
-    protected abstract _call(params: MiscGetAddressParams): Promise<{
-        address: string;
-        mac?: string;
-    }>;
-    run({ sendCoreMessage }: MethodContext): Promise<MethodReturnType<Name>>;
-}
-export {};

package/libESM/api/common/AbstractMiscGetAddress.mjs

@@ -1,102 +0,0 @@
-import { Bundle, GetAddress as GetAddressSchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { Assert } from "@trezor/schema-utils";
-import { bundlify } from "./paramsValidator.mjs";
-import { AbstractMethod } from "../../core/AbstractMethod.mjs";
-import { fromHardened, getSerializedPath, validatePath } from "../../utils/pathUtils.mjs";
-export class AbstractMiscGetAddress extends AbstractMethod {
-  hasBundle;
-  progress = 0;
-  constructor(message, pathDepth) {
-    const {
-      hasBundle,
-      payload
-    } = bundlify(message.payload);
-    Assert(Bundle(GetAddressSchema), payload);
-    const params = payload.bundle.map(batch => ({
-      proto: {
-        address_n: validatePath(batch.path, pathDepth),
-        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
-        chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false
-      },
-      address: batch.address
-    }));
-    super(message, params);
-    this.hasBundle = hasBundle;
-    this.useUi = this.getUseUi(this.params, payload.useEventListener);
-    this.confirmMissingBackup = true;
-  }
-  get requiredPermissions() {
-    return ['read'];
-  }
-  getInfo(coinName, showAccountInInfo) {
-    if (this.params.length > 1) {
-      return `Export multiple ${coinName} addresses`;
-    }
-    if (showAccountInInfo) {
-      return `Export ${coinName} address for account #${fromHardened(this.params[0].proto.address_n[2]) + 1}`;
-    }
-    return `Export ${coinName} address`;
-  }
-  getButtonRequestData(code) {
-    if (code === 'ButtonRequest_Address') {
-      return {
-        type: 'address',
-        serializedPath: getSerializedPath(this.params[this.progress].proto.address_n),
-        address: this.params[this.progress].address || 'not-set'
-      };
-    }
-  }
-  getConfirmation(coinName) {
-    if (this.params.length > 1) {
-      return {
-        view: 'export-address',
-        label: `Export multiple ${coinName} addresses`
-      };
-    }
-    return {
-      view: 'export-address',
-      label: `Export ${coinName} address for account #${fromHardened(this.params[0].proto.address_n[2]) + 1}`
-    };
-  }
-  async run({
-    sendCoreMessage
-  }) {
-    const responses = [];
-    for (let i = 0; i < this.params.length; i++) {
-      const batch = this.params[i];
-      if (batch.proto.show_display) {
-        const silent = await this._call({
-          ...batch,
-          proto: {
-            ...batch.proto,
-            show_display: false
-          }
-        });
-        if (typeof batch.address === 'string') {
-          if (batch.address !== silent.address) {
-            throw ERRORS.TypedError('Method_AddressNotMatch');
-          }
-        } else {
-          batch.address = silent.address;
-        }
-      }
-      const response = await this._call(batch);
-      responses.push({
-        path: batch.proto.address_n,
-        serializedPath: getSerializedPath(batch.proto.address_n),
-        address: response.address,
-        mac: response.mac
-      });
-      if (this.hasBundle) {
-        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
-          total: this.params.length,
-          progress: i,
-          response
-        }));
-      }
-      this.progress++;
-    }
-    return this.hasBundle ? responses : responses[0];
-  }
-}

package/libESM/api/common/Discovery.d.mts

@@ -1,33 +0,0 @@
-import type { DiscoveryAccount, DiscoveryAccountType, GetAccountInfo } from '@trezor/connect-common';
-import { TypedEmitter } from '@trezor/utils';
-import type { Blockchain } from '../../backend/BlockchainLink';
-import type { DeviceCommands } from '../../device/DeviceCommands';
-type DiscoveryType = {
-    type: DiscoveryAccountType;
-    getPath: (index: number) => number[];
-};
-type GetDescriptor = (path: number[]) => ReturnType<ReturnType<typeof DeviceCommands>['getAccountDescriptor']>;
-type DiscoveryOptions = {
-    blockchain: Blockchain;
-    getDescriptor: GetDescriptor;
-    limit?: number;
-};
-interface Events {
-    progress: DiscoveryAccount[];
-    complete: void;
-}
-export declare class Discovery extends TypedEmitter<Events> {
-    types: DiscoveryType[];
-    private typeIndex;
-    accounts: DiscoveryAccount[];
-    private coinInfo;
-    private blockchain;
-    getDescriptor: GetDescriptor;
-    private index;
-    private interrupted;
-    completed: boolean;
-    constructor(options: DiscoveryOptions);
-    start(details?: GetAccountInfo['details']): Promise<void>;
-    stop(): void;
-}
-export {};

package/libESM/api/common/Discovery.mjs

@@ -1,116 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { TypedEmitter } from "@trezor/utils";
-import { getAccountAddressN } from "../../utils/accountUtils.mjs";
-import { formatAmount } from "../../utils/formatUtils.mjs";
-export class Discovery extends TypedEmitter {
-  types = [];
-  typeIndex;
-  accounts;
-  coinInfo;
-  blockchain;
-  getDescriptor;
-  index;
-  interrupted;
-  completed;
-  constructor(options) {
-    super();
-    this.accounts = [];
-    this.index = 0;
-    this.typeIndex = 0;
-    this.interrupted = false;
-    this.completed = false;
-    this.blockchain = options.blockchain;
-    this.coinInfo = options.blockchain.coinInfo;
-    this.getDescriptor = options.getDescriptor;
-    const {
-      coinInfo
-    } = this;
-    if (coinInfo.type === 'bitcoin') {
-      const getDescriptor = (purpose, index) => getAccountAddressN(coinInfo, index, {
-        purpose
-      });
-      if (coinInfo.xPubMagicSegwitNative) {
-        this.types.push({
-          type: 'p2wpkh',
-          getPath: getDescriptor.bind(this, 84)
-        });
-      }
-      if (coinInfo.taproot) {
-        this.types.push({
-          type: 'p2tr',
-          getPath: getDescriptor.bind(this, 86)
-        });
-      }
-      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: 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.getDescriptor(path);
-      if (!descriptor) {
-        throw 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 = 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;
-  }
-}

package/libESM/api/common/paramsValidator.d.mts

@@ -1,23 +0,0 @@
-import type { CallMethodKeys, CoinInfo, FirmwareCapability, FirmwareRange } from '@trezor/connect-common';
-type MethodOrCapability = CallMethodKeys | FirmwareCapability;
-type ParamType = 'string' | 'number' | 'array' | 'array-buffer' | 'boolean' | 'uint' | 'object';
-type Param = {
-    name: string;
-    type?: ParamType | ParamType[];
-    required?: boolean;
-    allowEmpty?: boolean;
-    allowNegative?: boolean;
-};
-export declare const bundlify: <T extends {
-    bundle?: unknown[];
-}>(payload: T) => {
-    hasBundle: boolean;
-    payload: T & {
-        bundle: unknown[];
-    };
-};
-export declare function validateParams<P extends Record<string, any>>(params: P, schema: Param[]): P;
-export declare const validateCoinPath: (path: number[], coinInfo?: CoinInfo) => void;
-export declare const DEFAULT_FIRMWARE_RANGE: FirmwareRange;
-export declare const getFirmwareRange: (methodsOrCapabilities: MethodOrCapability[], coins: CoinInfo[], currentRange?: FirmwareRange) => FirmwareRange;
-export {};

package/libESM/api/common/paramsValidator.mjs

@@ -1,134 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { typedObjectTransformValues, versionUtils } from "@trezor/utils";
-import { config } from "../../data/config.mjs";
-import { fromHardened } from "../../utils/pathUtils.mjs";
-const invalidParameter = message => ERRORS.TypedError('Method_InvalidParameter', message);
-export const bundlify = payload => ({
-  hasBundle: !!payload.bundle,
-  payload: {
-    ...payload,
-    bundle: payload.bundle ?? [payload]
-  }
-});
-export 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 {
-          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;
-}
-export const validateCoinPath = (path, coinInfo) => {
-  if (coinInfo && coinInfo.slip44 !== fromHardened(path[1])) {
-    throw invalidParameter('Parameters "path" and "coin" do not match.');
-  }
-};
-export const DEFAULT_FIRMWARE_RANGE = {
-  UNKNOWN: {
-    min: '1.0.0',
-    max: '0'
-  },
-  T1B1: {
-    min: '1.0.0',
-    max: '0'
-  },
-  T2T1: {
-    min: '2.0.0',
-    max: '0'
-  },
-  T2B1: {
-    min: '2.6.1',
-    max: '0'
-  },
-  T3B1: {
-    min: '2.8.1',
-    max: '0'
-  },
-  T3T1: {
-    min: '2.7.1',
-    max: '0'
-  },
-  T3W1: {
-    min: '2.7.1',
-    max: '0'
-  }
-};
-const intersectMin = (a, b) => a === '0' || b !== '0' && versionUtils.isNewer(a, b) ? a : b;
-const intersectMax = (a, b) => a === '0' || b !== '0' && versionUtils.isNewer(a, b) ? b : a;
-const intersectRange = (a, b) => typedObjectTransformValues(a, (value, model) => ({
-  min: intersectMin(value.min, b[model].min),
-  max: intersectMax(value.max, b[model].max)
-}));
-const ensureArray = (item = []) => Array.isArray(item) ? item : [item];
-const filterByCoins = coins => {
-  const coinSet = new Set(coins.map(coin => coin.shortcut.toLowerCase()));
-  const coinTypeSet = new Set(coins.map(coin => coin.type));
-  return rule => !rule.coin && !rule.coinType || ensureArray(rule.coin).some(coinSet.has.bind(coinSet)) || ensureArray(rule.coinType).some(coinTypeSet.has.bind(coinTypeSet));
-};
-const filterByMethods = methodsOrCapabilities => {
-  const methodSet = new Set(methodsOrCapabilities);
-  return rule => !rule.methods && !rule.capabilities || ensureArray(rule.methods).some(methodSet.has.bind(methodSet)) || ensureArray(rule.capabilities).some(methodSet.has.bind(methodSet));
-};
-const getCoinRules = (coins, currentRange) => coins.map(({
-  support = typedObjectTransformValues(DEFAULT_FIRMWARE_RANGE, () => false)
-}) => ({
-  ...currentRange,
-  ...typedObjectTransformValues(support, value => ({
-    min: value || '0',
-    max: '0'
-  }))
-}));
-const getConfigRules = (methodsOrCapabilities, coins, currentRange) => config.supportedFirmware.filter(filterByCoins(coins)).filter(filterByMethods(methodsOrCapabilities)).map(({
-  min,
-  max
-}) => typedObjectTransformValues(currentRange, (value, key) => ({
-  min: min?.[key] ?? value.min,
-  max: max?.[key] ?? value.max
-})));
-export const getFirmwareRange = (methodsOrCapabilities, coins, currentRange = DEFAULT_FIRMWARE_RANGE) => getCoinRules(coins, currentRange).concat(getConfigRules(methodsOrCapabilities, coins, currentRange)).reduce(intersectRange, currentRange);

package/libESM/api/common/requestExistingAccounts.d.mts

@@ -1,9 +0,0 @@
-import { type CoinInfo, type CoreEventMessage, type DiscoveryAccount } from '@trezor/connect-common';
-import type { UiPromiseCreator } from '../../events/ui-promise';
-import type { IDevice } from '../../types/idevice';
-export declare const requestExistingAccounts: ({ postMessage, createUiPromise, device, coinInfo, }: {
-    postMessage: (message: CoreEventMessage) => void;
-    createUiPromise: UiPromiseCreator;
-    device: IDevice;
-    coinInfo: CoinInfo;
-}) => Promise<DiscoveryAccount[] | null>;

package/libESM/api/common/requestExistingAccounts.mjs

@@ -1,20 +0,0 @@
-import { UI_REQUEST, UI_RESPONSE, createUiMessage } from "@trezor/connect-common";
-import { resolveAfter } from "@trezor/utils/libESM/resolveAfter.mjs";
-const REQUEST_TIMEOUT_MS = 200;
-export const requestExistingAccounts = async ({
-  postMessage,
-  createUiPromise,
-  device,
-  coinInfo
-}) => {
-  const dfd = createUiPromise(UI_RESPONSE.RECEIVE_DISCOVERY_ACCOUNTS, device);
-  postMessage(createUiMessage(UI_REQUEST.REQUEST_DISCOVERY_ACCOUNTS, {
-    coinInfo
-  }));
-  const result = await Promise.race([dfd.promise.then(response => response.payload), resolveAfter(REQUEST_TIMEOUT_MS).then(() => null)]);
-  if (result === null) {
-    dfd.reject(new Error('No discovery accounts handler'));
-    return null;
-  }
-  return result.accounts.length > 0 ? result.accounts : null;
-};

package/libESM/api/composeTransaction.d.mts

@@ -1,36 +0,0 @@
-import { type BitcoinNetworkInfo, type MethodPermission, type PrecomposeParams, type PrecomposedResult, type SignedTransaction } from '@trezor/connect-common';
-import { BigNumber } from '@trezor/utils/libESM/bigNumber';
-import type { ComposeOutput, TransactionInputOutputSortingStrategy } from '@trezor/utxo-lib';
-import type { MethodContext, MethodMessage } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-import { Discovery } from './common/Discovery';
-type Params = {
-    outputs: ComposeOutput[];
-    coinInfo: BitcoinNetworkInfo;
-    identity?: string;
-    push: boolean;
-    account?: PrecomposeParams['account'];
-    feeLevels?: PrecomposeParams['feeLevels'];
-    baseFee?: PrecomposeParams['baseFee'];
-    floorBaseFee?: PrecomposeParams['floorBaseFee'];
-    sequence?: PrecomposeParams['sequence'];
-    total: BigNumber;
-    sortingStrategy?: TransactionInputOutputSortingStrategy;
-};
-export default class ComposeTransaction extends AbstractMethod<'composeTransaction', Params> {
-    constructor(message: MethodMessage<'composeTransaction'>);
-    discovery?: Discovery;
-    get requiredPermissions(): MethodPermission[];
-    get info(): string;
-    private getBlockchain;
-    private precompose;
-    run(context: MethodContext): Promise<SignedTransaction | PrecomposedResult[]>;
-    private selectAccount;
-    private selectFromExistingAccounts;
-    private selectFromDiscovery;
-    private selectFee;
-    private _selectFeeUiResponse;
-    private _sign;
-    dispose(): void;
-}
-export {};