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

package/lib/api/getAccountInfo.js

@@ -0,0 +1,253 @@
+import { UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { fromHardenedPathPart } from "@trezor/crypto-utils";
+import { assertBackendSupported, initBlockchain } from "../backend/BlockchainLink.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { getCoinInfoOrThrow } from "../data/coinInfo.js";
+import { bundlify, validateParams } from "./common/paramsValidator.js";
+import { getAccountLabel, isUtxoBased } from "../utils/accountUtils.js";
+import { buildOutputDescriptor } from "../utils/buildOutputDescriptor.js";
+import { getScriptType, validatePath } from "../utils/pathUtils.js";
+export default class GetAccountInfo extends AbstractMethod {
+  disposed = false;
+  hasBundle;
+  constructor(message) {
+    let willUseDevice = false;
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    validateParams(payload, [{
+      name: 'bundle',
+      type: 'array'
+    }]);
+    const params = payload.bundle.map(batch => {
+      validateParams(batch, [{
+        name: 'coin',
+        type: 'string',
+        required: true
+      }, {
+        name: 'identity',
+        type: 'string'
+      }, {
+        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: 'protocols',
+        type: 'array'
+      }, {
+        name: 'confirmedNonce',
+        type: 'boolean'
+      }, {
+        name: 'defaultAccountType',
+        type: 'string'
+      }, {
+        name: 'derivationType',
+        type: 'number'
+      }, {
+        name: 'suppressBackupWarning',
+        type: 'boolean'
+      }]);
+      const coinInfo = getCoinInfoOrThrow(batch.coin);
+      assertBackendSupported(coinInfo);
+      let address_n = [];
+      if (batch.path) {
+        address_n = validatePath(batch.path, 3);
+        willUseDevice = typeof batch.descriptor !== 'string';
+      }
+      if (!batch.path && !batch.descriptor) {
+        throw ERRORS.TypedError('Method_InvalidParameter', 'GetAccountInfo: path or descriptor is required');
+      }
+      return {
+        ...batch,
+        address_n,
+        coinInfo
+      };
+    });
+    super(message, params);
+    this.hasBundle = hasBundle;
+    this.useDevice = willUseDevice;
+    this.useDeviceState = willUseDevice;
+    this.useUi = willUseDevice;
+    this.confirmMissingBackup = !params.every(batch => batch.suppressBackupWarning);
+    this.requiredFirmwareCoins = params.map(({
+      coinInfo
+    }) => coinInfo);
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_account_info', this.requiredFirmwareCoins);
+  }
+  get info() {
+    return 'Export account info';
+  }
+  get confirmation() {
+    const keys = {};
+    this.params.forEach(b => {
+      if (!keys[b.coinInfo.label]) {
+        keys[b.coinInfo.label] = {
+          coinInfo: b.coinInfo,
+          values: []
+        };
+      }
+      const entry = keys[b.coinInfo.label];
+      entry.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(k);
+        str.push(' ');
+        if (typeof acc === 'string') {
+          str.push(acc);
+        } else {
+          str.push(getAccountLabel(acc, details.coinInfo));
+        }
+      });
+    });
+    return {
+      view: 'export-account-info',
+      label: `Export info for: ${str.join('')}`
+    };
+  }
+  async run(context) {
+    const responses = [];
+    const sendProgress = (progress, response, error) => {
+      if (!this.hasBundle || this.getDevice()?.getCurrentSession().isDisposed()) return;
+      context.sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+        total: this.params.length,
+        progress,
+        response,
+        error
+      }));
+    };
+    for (let i = 0; i < this.params.length; i++) {
+      const allParams = this.params;
+      const request = allParams[i];
+      const {
+        address_n
+      } = request;
+      let {
+        descriptor
+      } = request;
+      let legacyXpub;
+      let descriptorChecksum;
+      let rootFingerprint;
+      let outputDescriptorBip380;
+      if (this.disposed) break;
+      if (address_n && typeof descriptor !== 'string') {
+        try {
+          const accountDescriptor = await this.getDevice().getCommands().getAccountDescriptor(request.coinInfo, address_n, request.derivationType);
+          if (accountDescriptor) {
+            descriptor = accountDescriptor.descriptor;
+            legacyXpub = accountDescriptor.legacyXpub;
+            descriptorChecksum = accountDescriptor.descriptorChecksum;
+            rootFingerprint = accountDescriptor.rootFingerprint;
+            const accountIndex = address_n[2];
+            const purposeIndex = address_n[0];
+            outputDescriptorBip380 = accountDescriptor.outputDescriptorBip380 ?? (request.coinInfo.type === 'bitcoin' && legacyXpub ? buildOutputDescriptor({
+              coin: request.coinInfo.name,
+              account: fromHardenedPathPart(accountIndex),
+              purpose: fromHardenedPathPart(purposeIndex),
+              scriptType: getScriptType(address_n),
+              xpub: legacyXpub,
+              rootFingerprint
+            }) : undefined);
+          }
+        } 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 ERRORS.TypedError('Runtime', 'GetAccountInfo: descriptor not found');
+        }
+        const blockchain = await initBlockchain(request.coinInfo, context.sendCoreMessage, request.identity);
+        if (this.disposed) break;
+        const info = await blockchain.getAccountInfo({
+          descriptor,
+          details: request.details,
+          tokens: request.tokens,
+          page: request.page,
+          pageSize: request.pageSize,
+          pageCursor: request.pageCursor,
+          from: request.from,
+          to: request.to,
+          contractFilter: request.contractFilter,
+          gap: request.gap,
+          marker: request.marker,
+          tokenAccountsPubKeys: request.tokenAccountsPubKeys,
+          protocols: request.protocols,
+          confirmedNonce: request.confirmedNonce
+        });
+        if (this.disposed) break;
+        let utxo;
+        if (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,
+          descriptorChecksum,
+          outputDescriptorBip380
+        };
+        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];
+  }
+  dispose() {
+    this.disposed = true;
+  }
+}

package/lib/api/getAddress.d.ts

@@ -0,0 +1,45 @@
+import { type BitcoinNetworkInfo, type PROTO, type PermissionRequest } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+type Params = {
+  proto: PROTO.GetAddress;
+  address?: string;
+  coinInfo: BitcoinNetworkInfo;
+  unlockPath?: PROTO.UnlockPath;
+};
+export default class GetAddress extends AbstractMethod<'getAddress', Params[]> {
+  hasBundle?: boolean;
+  progress: number;
+  constructor(message: MethodMessage<'getAddress'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  getButtonRequestData(code: string): {
+    type: "address";
+    serializedPath: string;
+    address: string;
+  } | undefined;
+  get confirmation(): {
+    view: "export-address";
+    label: string;
+  } | undefined;
+  _call({
+    proto,
+    coinInfo,
+    unlockPath
+  }: Params): Promise<{
+    path: number[];
+    serializedPath: string;
+    address: string;
+    mac: string | undefined;
+  }>;
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<(import("@trezor/connect-common").Address & {
+    mac?: string | undefined;
+    address: string;
+  }) | (import("@trezor/connect-common").Address & {
+    mac?: string | undefined;
+    address: string;
+  })[]>;
+}
+export {};

package/lib/api/getAddress.js

@@ -0,0 +1,153 @@
+import { Bundle } from "@trezor/connect-common";
+import { UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { GetAddress as GetAddressSchema } from "@trezor/connect-common/lib/types/api/account/getAddress.js";
+import { Assert } from "@trezor/schema-utils";
+import { bundlify, validateCoinPath } from "./common/paramsValidator.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { fixCoinInfoNetwork, getBitcoinNetwork, getUniqueNetworks } from "../data/coinInfo.js";
+import { getLabel, getSerializedPath, validatePath } from "../utils/pathUtils.js";
+export default class GetAddress extends AbstractMethod {
+  hasBundle;
+  progress = 0;
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    payload.bundle.forEach(bundleElement => {
+      if (bundleElement.multisig && bundleElement.multisig?.signatures === undefined) {
+        bundleElement.multisig.signatures = Array(bundleElement.multisig?.pubkeys.length).fill('');
+      }
+    });
+    Assert(Bundle(GetAddressSchema), payload);
+    const params = payload.bundle.map(batch => {
+      const path = validatePath(batch.path, 1);
+      let coinInfo;
+      if (batch.coin) {
+        coinInfo = getBitcoinNetwork(batch.coin);
+      }
+      if (coinInfo && !batch.crossChain) {
+        validateCoinPath(path, coinInfo);
+      } else if (!coinInfo) {
+        coinInfo = getBitcoinNetwork(path);
+      }
+      if (!coinInfo) {
+        throw ERRORS.TypedError('Method_UnknownCoin');
+      }
+      coinInfo = fixCoinInfoNetwork(coinInfo, path);
+      const proto = {
+        address_n: path,
+        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+        multisig: batch.multisig,
+        script_type: batch.scriptType,
+        chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false
+      };
+      return {
+        proto,
+        address: batch.address,
+        coinInfo,
+        unlockPath: batch.unlockPath
+      };
+    });
+    super(message, params);
+    this.hasBundle = hasBundle;
+    this.requiredFirmwareCoins = params.map(({
+      coinInfo
+    }) => coinInfo);
+    this.confirmMissingBackup = true;
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_address', this.requiredFirmwareCoins);
+  }
+  get info() {
+    if (this.params.length === 1) {
+      const {
+        params
+      } = this;
+      const first = params[0];
+      return getLabel('Export #NETWORK address', first.coinInfo);
+    }
+    const requestedNetworks = this.params.map(b => b.coinInfo);
+    const uniqNetworks = getUniqueNetworks(requestedNetworks);
+    if (uniqNetworks.length === 1 && uniqNetworks[0]) {
+      return getLabel('Export multiple #NETWORK addresses', uniqNetworks[0]);
+    }
+    return 'Export multiple addresses';
+  }
+  getButtonRequestData(code) {
+    if (code === 'ButtonRequest_Address') {
+      const {
+        params
+      } = this;
+      const current = params[this.progress];
+      return {
+        type: 'address',
+        serializedPath: getSerializedPath(current.proto.address_n),
+        address: current.address || 'not-set'
+      };
+    }
+  }
+  get confirmation() {
+    return !this.useUi ? undefined : {
+      view: 'export-address',
+      label: this.info
+    };
+  }
+  async _call({
+    proto,
+    coinInfo,
+    unlockPath
+  }) {
+    const cmd = this.getDevice().getCommands();
+    if (unlockPath) {
+      await cmd.unlockPath(unlockPath);
+    }
+    const response = await cmd.getAddress(proto, coinInfo);
+    return {
+      path: proto.address_n,
+      serializedPath: getSerializedPath(proto.address_n),
+      address: response.address,
+      mac: response.mac
+    };
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const responses = [];
+    for (let i = 0; i < this.params.length; i++) {
+      const {
+        params
+      } = this;
+      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(response);
+      if (this.hasBundle) {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+          total: this.params.length,
+          progress: i,
+          response
+        }));
+      }
+      this.progress++;
+    }
+    const first = responses[0];
+    return this.hasBundle ? responses : first;
+  }
+}

package/lib/api/getCoinInfo.d.ts

@@ -0,0 +1,148 @@
+import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+type Params = {
+  coinInfo: CoinInfo;
+};
+export default class GetCoinInfo extends AbstractMethod<'getCoinInfo', Params> {
+  constructor(message: MethodMessage<'getCoinInfo'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<({
+    blockchainLink?: {
+      type: string;
+      url: string[];
+    } | undefined;
+    label: string;
+    name: string;
+    shortcut: string;
+    slip44: number;
+    support: {
+      T1B1: string | false;
+      T2T1: string | false;
+      T3T1: string | false;
+      T2B1: string | false;
+      T3B1: string | false;
+      T3W1: string | false;
+      UNKNOWN: string | false;
+    };
+    decimals: number;
+    blockTime: number;
+    minFee: number;
+    maxFee: number;
+    minPriorityFee: number;
+    defaultFees: {
+      feePerTx?: string | undefined;
+      feeLimit?: string | undefined;
+      baseFeePerGas?: string | undefined;
+      maxFeePerGas?: string | undefined;
+      maxPriorityFeePerGas?: string | undefined;
+      label: "high" | "normal" | "economy" | "low" | "custom";
+      blocks: number;
+      feePerUnit: string;
+    }[];
+  } & {
+    taproot?: boolean | undefined;
+    cashAddrPrefix?: string | undefined;
+    xPubMagicSegwitNative?: number | undefined;
+    xPubMagicSegwit?: number | undefined;
+    type: "bitcoin";
+    curveName: string;
+    dustLimit: number;
+    forceBip143: boolean;
+    hashGenesisBlock: string;
+    maxAddressLength: number;
+    maxFeeSatoshiKb: number;
+    minAddressLength: number;
+    minFeeSatoshiKb: number;
+    segwit: boolean;
+    xPubMagic: number;
+    network: {
+      forkId?: number | undefined;
+      messagePrefix: string;
+      bech32: string;
+      bip32: {
+        public: number;
+        private: number;
+      };
+      pubKeyHash: number;
+      scriptHash: number;
+      wif: number;
+    };
+    isBitcoin: boolean;
+  }) | ({
+    blockchainLink?: {
+      type: string;
+      url: string[];
+    } | undefined;
+    label: string;
+    name: string;
+    shortcut: string;
+    slip44: number;
+    support: {
+      T1B1: string | false;
+      T2T1: string | false;
+      T3T1: string | false;
+      T2B1: string | false;
+      T3B1: string | false;
+      T3W1: string | false;
+      UNKNOWN: string | false;
+    };
+    decimals: number;
+    blockTime: number;
+    minFee: number;
+    maxFee: number;
+    minPriorityFee: number;
+    defaultFees: {
+      feePerTx?: string | undefined;
+      feeLimit?: string | undefined;
+      baseFeePerGas?: string | undefined;
+      maxFeePerGas?: string | undefined;
+      maxPriorityFeePerGas?: string | undefined;
+      label: "high" | "normal" | "economy" | "low" | "custom";
+      blocks: number;
+      feePerUnit: string;
+    }[];
+  } & {
+    network?: undefined;
+    type: "ethereum";
+    chainId: number;
+  }) | ({
+    blockchainLink?: {
+      type: string;
+      url: string[];
+    } | undefined;
+    label: string;
+    name: string;
+    shortcut: string;
+    slip44: number;
+    support: {
+      T1B1: string | false;
+      T2T1: string | false;
+      T3T1: string | false;
+      T2B1: string | false;
+      T3B1: string | false;
+      T3W1: string | false;
+      UNKNOWN: string | false;
+    };
+    decimals: number;
+    blockTime: number;
+    minFee: number;
+    maxFee: number;
+    minPriorityFee: number;
+    defaultFees: {
+      feePerTx?: string | undefined;
+      feeLimit?: string | undefined;
+      baseFeePerGas?: string | undefined;
+      maxFeePerGas?: string | undefined;
+      maxPriorityFeePerGas?: string | undefined;
+      label: "high" | "normal" | "economy" | "low" | "custom";
+      blocks: number;
+      feePerUnit: string;
+    }[];
+  } & {
+    network?: undefined;
+    type: "misc";
+    curve: string;
+  })>;
+}
+export {};

package/lib/api/getCoinInfo.js

@@ -0,0 +1,25 @@
+import { CoinObj } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { getCoinInfoOrThrow } from "../data/coinInfo.js";
+export default class GetCoinInfo extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(CoinObj, payload);
+    const coinInfo = getCoinInfoOrThrow(payload.coin);
+    const params = {
+      coinInfo
+    };
+    super(message, params);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [];
+  }
+  run() {
+    return Promise.resolve(this.params.coinInfo);
+  }
+}

package/lib/api/getDeviceState.d.ts

@@ -0,0 +1,8 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class GetDeviceState extends AbstractMethod<'getDeviceState'> {
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<{
+    state: import("@trezor/connect-common").DeviceState;
+  }>;
+}

package/lib/api/getDeviceState.js

@@ -0,0 +1,18 @@
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class GetDeviceState extends AbstractMethod {
+  get requiredPermissions() {
+    return [{
+      permission: 'read_features'
+    }];
+  }
+  run() {
+    const state = this.getDevice().getState();
+    if (!state?.staticSessionId) {
+      throw ERRORS.TypedError('Runtime', 'Device state not set');
+    }
+    return Promise.resolve({
+      state
+    });
+  }
+}