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

package/lib/api/common/AbstractMiscGetAddress.js

@@ -1,126 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,119 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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 {};