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

package/lib/api/cipherKeyValue.js

@@ -0,0 +1,58 @@
+import { CipherKeyValue as CipherKeyValueSchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { Bundle } from "@trezor/connect-common/lib/types/params.js";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { bundlify } from "./common/paramsValidator.js";
+import { validatePath } from "../utils/pathUtils.js";
+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 [{
+      permission: 'sign'
+    }];
+  }
+  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 {
+        params
+      } = this;
+      const batch = params[i];
+      const response = await cmd.typedCall('CipherKeyValue', 'CipheredKeyValue', batch);
+      responses.push(response.message);
+      if (this.hasBundle) {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+          total: this.params.length,
+          progress: i,
+          response
+        }));
+      }
+    }
+    const first = responses[0];
+    return this.hasBundle ? responses : first;
+  }
+}

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

@@ -0,0 +1,37 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage, MethodReturnType } from "../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../core/AbstractMethod.js";
+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(): PermissionRequest[];
+  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/lib/api/common/AbstractMiscGetAddress.js

@@ -0,0 +1,126 @@
+import { Bundle, GetAddress as GetAddressSchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { fromHardenedPathPart } from "@trezor/crypto-utils";
+import { Assert } from "@trezor/schema-utils";
+import { bundlify } from "./paramsValidator.js";
+import { AbstractMethod } from "../../core/AbstractMethod.js";
+import { getSerializedPath, validatePath } from "../../utils/pathUtils.js";
+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.confirmMissingBackup = true;
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_address', this.requiredFirmwareCoins);
+  }
+  getInfo(coinName, showAccountInInfo) {
+    if (this.params.length > 1) {
+      return `Export multiple ${coinName} addresses`;
+    }
+    if (showAccountInInfo) {
+      const {
+        params
+      } = this;
+      const firstParam = params[0];
+      const {
+        address_n
+      } = firstParam.proto;
+      const accountIndex = address_n[2];
+      return `Export ${coinName} address for account #${fromHardenedPathPart(accountIndex) + 1}`;
+    }
+    return `Export ${coinName} address`;
+  }
+  getButtonRequestData(code) {
+    if (code === 'ButtonRequest_Address') {
+      const {
+        params,
+        progress
+      } = this;
+      const currentParam = params[progress];
+      return {
+        type: 'address',
+        serializedPath: getSerializedPath(currentParam.proto.address_n),
+        address: currentParam.address || 'not-set'
+      };
+    }
+  }
+  getConfirmation(coinName) {
+    if (this.params.length > 1) {
+      return {
+        view: 'export-address',
+        label: `Export multiple ${coinName} addresses`
+      };
+    }
+    const {
+      params
+    } = this;
+    const firstParam = params[0];
+    const {
+      address_n
+    } = firstParam.proto;
+    const accountIndex = address_n[2];
+    return {
+      view: 'export-address',
+      label: `Export ${coinName} address for account #${fromHardenedPathPart(accountIndex) + 1}`
+    };
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const responses = [];
+    const {
+      params
+    } = this;
+    for (let i = 0; i < params.length; i++) {
+      const batch = 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: params.length,
+          progress: i,
+          response
+        }));
+      }
+      this.progress++;
+    }
+    return this.hasBundle ? responses : responses[0];
+  }
+}

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

@@ -0,0 +1,33 @@
+import type { DiscoveryAccount, DiscoveryAccountType, GetAccountInfo } from '@trezor/connect-common';
+import { TypedEmitter } from '@trezor/utils';
+import type { Blockchain } from "../../backend/BlockchainLink.js";
+import type { DeviceCommands } from "../../device/DeviceCommands.js";
+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/lib/api/common/Discovery.js

@@ -0,0 +1,119 @@
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { TypedEmitter } from "@trezor/utils";
+import { getAccountAddressN } from "../../utils/accountUtils.js";
+import { formatAmount } from "../../utils/formatUtils.js";
+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 {
+        types
+      } = this;
+      const accountType = 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/lib/api/common/paramsValidator.d.ts

@@ -0,0 +1,24 @@
+import type { CallMethodKeys, CoinInfo, FirmwareCapability, FirmwareRange, FirmwareRule } 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 filterByFirmwareType: (isDebug: boolean) => (rule: FirmwareRule) => boolean;
+export declare const getFirmwareRange: (methodsOrCapabilities: MethodOrCapability[], coins: CoinInfo[], currentRange?: FirmwareRange, isDebug?: boolean) => FirmwareRange;
+export {};

package/lib/api/common/paramsValidator.js

@@ -0,0 +1,136 @@
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { fromHardenedPathPart } from "@trezor/crypto-utils";
+import { typedObjectTransformValues, versionUtils } from "@trezor/utils";
+import { config } from "../../data/config.js";
+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) => {
+  const slip44Component = path[1];
+  if (coinInfo && coinInfo.slip44 !== fromHardenedPathPart(slip44Component)) {
+    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));
+};
+export const filterByFirmwareType = isDebug => rule => !rule.firmwareType || rule.firmwareType === 'debug' === isDebug;
+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, isDebug) => config.supportedFirmware.filter(filterByCoins(coins)).filter(filterByMethods(methodsOrCapabilities)).filter(filterByFirmwareType(isDebug)).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, isDebug = false) => getCoinRules(coins, currentRange).concat(getConfigRules(methodsOrCapabilities, coins, currentRange, isDebug)).reduce(intersectRange, currentRange);

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

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

package/lib/api/common/requestExistingAccounts.js

@@ -0,0 +1,20 @@
+import { UI_REQUEST, UI_RESPONSE, createUiMessage } from "@trezor/connect-common";
+import { resolveAfter } from "@trezor/utils/lib/resolveAfter.js";
+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/lib/api/composeTransaction.d.ts

@@ -0,0 +1,36 @@
+import { type BitcoinNetworkInfo, type PermissionRequest, type PrecomposeParams, type PrecomposedResult, type SignedTransaction } from '@trezor/connect-common';
+import { BigNumber } from '@trezor/utils/lib/bigNumber';
+import type { ComposeOutput, TransactionInputOutputSortingStrategy } from '@trezor/utxo-lib';
+import type { MethodContext, MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { Discovery } from "./common/Discovery.js";
+type Params = {
+  outputs: ComposeOutput[];
+  coinInfo: BitcoinNetworkInfo;
+  identity?: string;
+  push: boolean;
+  account?: PrecomposeParams['account'];
+  feeLevels?: PrecomposeParams['feeLevels'];
+  baseFee?: PrecomposeParams['baseFee'];
+  sequence?: PrecomposeParams['sequence'];
+  total: BigNumber;
+  sortingStrategy?: TransactionInputOutputSortingStrategy;
+};
+export default class ComposeTransaction extends AbstractMethod<'composeTransaction', Params> {
+  constructor(message: MethodMessage<'composeTransaction'>);
+  discovery?: Discovery;
+  private disposed;
+  get requiredPermissions(): PermissionRequest[];
+  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 {};