@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/api/getAccountInfo.mjs

@@ -0,0 +1,385 @@
+import { UI_REQUEST, UI_RESPONSE, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { resolveAfter } from "@trezor/utils/libESM/resolveAfter.mjs";
+import { unique } from "@trezor/utils/libESM/unique.mjs";
+import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+import { getCoinInfo } from "../data/coinInfo.mjs";
+import { Discovery } from "./common/Discovery.mjs";
+import { bundlify, validateParams } from "./common/paramsValidator.mjs";
+import { requestExistingAccounts } from "./common/requestExistingAccounts.mjs";
+import { getAccountLabel, isUtxoBased } from "../utils/accountUtils.mjs";
+import { buildOutputDescriptor } from "../utils/buildOutputDescriptor.mjs";
+import { fromHardened, getScriptType, getSerializedPath, validatePath } from "../utils/pathUtils.mjs";
+export default class GetAccountInfo extends AbstractMethod {
+  disposed = false;
+  hasBundle;
+  discovery;
+  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: 'defaultAccountType',
+        type: 'string'
+      }, {
+        name: 'derivationType',
+        type: 'number'
+      }, {
+        name: 'suppressBackupWarning',
+        type: 'boolean'
+      }]);
+      const coinInfo = getCoinInfo(batch.coin);
+      if (!coinInfo) {
+        throw ERRORS.TypedError('Method_UnknownCoin');
+      }
+      isBackendSupported(coinInfo);
+      let address_n = [];
+      if (batch.path) {
+        address_n = validatePath(batch.path, 3);
+        willUseDevice = typeof batch.descriptor !== 'string';
+      }
+      if (!batch.path && !batch.descriptor) {
+        if (payload.bundle.length > 1) {
+          throw Error('Discovery for multiple coins in not supported');
+        }
+        willUseDevice = true;
+      }
+      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 ['read'];
+  }
+  get info() {
+    return 'Export account info';
+  }
+  get confirmation() {
+    if (this.params.length === 1 && !this.params[0].path && !this.params[0].descriptor) {
+      return {
+        view: 'export-account-info',
+        label: `Export info for ${this.params[0].coinInfo.label} account of your selection`,
+        customConfirmButton: {
+          label: 'Proceed to account selection',
+          className: 'not-empty-css'
+        }
+      };
+    } else {
+      const keys = {};
+      this.params.forEach(b => {
+        if (!keys[b.coinInfo.label]) {
+          keys[b.coinInfo.label] = {
+            coinInfo: b.coinInfo,
+            values: []
+          };
+        }
+        keys[b.coinInfo.label].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) {
+    if (this.params.length === 1 && !this.params[0].path && !this.params[0].descriptor) {
+      return this.discover(this.params[0], 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 request = this.params[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;
+            outputDescriptorBip380 = accountDescriptor.outputDescriptorBip380 ?? (request.coinInfo.type === 'bitcoin' && legacyXpub ? buildOutputDescriptor({
+              coin: request.coinInfo.name,
+              account: fromHardened(address_n[2]),
+              purpose: fromHardened(address_n[0]),
+              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
+        });
+        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];
+  }
+  async discover(request, context) {
+    const {
+      coinInfo,
+      identity
+    } = request;
+    const blockchain = await initBlockchain(coinInfo, context.sendCoreMessage, identity);
+    const existingAccounts = await requestExistingAccounts({
+      postMessage: context.sendCoreMessage,
+      createUiPromise: context.createUiPromise,
+      device: this.getDevice(),
+      coinInfo
+    });
+    if (existingAccounts) {
+      return this.selectExistingAccount(existingAccounts, request, blockchain, context);
+    }
+    return this.runDiscovery(request, blockchain, context);
+  }
+  async selectExistingAccount(accounts, request, blockchain, context) {
+    const {
+      coinInfo,
+      defaultAccountType
+    } = request;
+    const dfd = context.createUiPromise(UI_RESPONSE.RECEIVE_ACCOUNT, this.getDevice());
+    context.sendCoreMessage(createUiMessage(UI_REQUEST.SELECT_ACCOUNT, {
+      type: 'complete',
+      accountTypes: unique(accounts.map(a => a.type)),
+      defaultAccountType,
+      coinInfo,
+      accounts
+    }));
+    const uiResp = await dfd.promise;
+    const account = accounts[uiResp.payload];
+    return this.fetchAccountInfo(account, request, blockchain);
+  }
+  async runDiscovery(request, blockchain, context) {
+    const {
+      coinInfo,
+      defaultAccountType,
+      derivationType
+    } = request;
+    const dfd = context.createUiPromise(UI_RESPONSE.RECEIVE_ACCOUNT, this.getDevice());
+    const discovery = new Discovery({
+      blockchain,
+      getDescriptor: path => this.getDevice().getCommands().getAccountDescriptor(coinInfo, path, derivationType)
+    });
+    discovery.on('progress', accounts => {
+      context.sendCoreMessage(createUiMessage(UI_REQUEST.SELECT_ACCOUNT, {
+        type: 'progress',
+        coinInfo,
+        accounts
+      }, {
+        requestId: dfd.requestId
+      }));
+    });
+    discovery.on('complete', () => {
+      context.sendCoreMessage(createUiMessage(UI_REQUEST.SELECT_ACCOUNT, {
+        type: 'end',
+        coinInfo
+      }, {
+        requestId: dfd.requestId
+      }));
+    });
+    discovery.start().catch(error => {
+      dfd.reject(error);
+    });
+    context.sendCoreMessage(createUiMessage(UI_REQUEST.SELECT_ACCOUNT, {
+      type: 'start',
+      accountTypes: discovery.types.map(t => t.type),
+      defaultAccountType,
+      coinInfo
+    }, {
+      requestId: dfd.requestId
+    }));
+    const uiResp = await dfd.promise;
+    discovery.stop();
+    const account = discovery.accounts[uiResp.payload];
+    if (!discovery.completed) {
+      await resolveAfter(501);
+    }
+    return this.fetchAccountInfo(account, request, blockchain);
+  }
+  async fetchAccountInfo(account, request, blockchain) {
+    const {
+      coinInfo
+    } = request;
+    const info = await blockchain.getAccountInfo({
+      descriptor: account.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,
+      protocols: request.protocols
+    });
+    let utxo;
+    if (isUtxoBased(coinInfo) && typeof request.details === 'string' && request.details !== 'basic') {
+      utxo = await blockchain.getAccountUtxo(account.descriptor);
+    }
+    return {
+      path: getSerializedPath(account.address_n),
+      ...info,
+      utxo
+    };
+  }
+  dispose() {
+    this.disposed = true;
+    const {
+      discovery
+    } = this;
+    if (discovery) {
+      discovery.removeAllListeners();
+      discovery.stop();
+    }
+  }
+}

package/libESM/api/getAddress.d.mts

@@ -0,0 +1,39 @@
+import { type BitcoinNetworkInfo, type MethodPermission, type PROTO } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+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(): MethodPermission[];
+    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/libESM/api/getAddress.mjs

@@ -0,0 +1,142 @@
+import { Bundle } from "@trezor/connect-common";
+import { UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { GetAddress as GetAddressSchema } from "@trezor/connect-common/libESM/types/api/getAddress.mjs";
+import { Assert } from "@trezor/schema-utils";
+import { bundlify, validateCoinPath } from "./common/paramsValidator.mjs";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+import { fixCoinInfoNetwork, getBitcoinNetwork, getUniqueNetworks } from "../data/coinInfo.mjs";
+import { getLabel, getSerializedPath, validatePath } from "../utils/pathUtils.mjs";
+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.useUi = this.getUseUi(this.params, payload.useEventListener);
+    this.requiredFirmwareCoins = params.map(({
+      coinInfo
+    }) => coinInfo);
+    this.confirmMissingBackup = true;
+  }
+  get requiredPermissions() {
+    return ['read'];
+  }
+  get info() {
+    if (this.params.length === 1) {
+      return getLabel('Export #NETWORK address', this.params[0].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') {
+      return {
+        type: 'address',
+        serializedPath: getSerializedPath(this.params[this.progress].proto.address_n),
+        address: this.params[this.progress].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 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(response);
+      if (this.hasBundle) {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+          total: this.params.length,
+          progress: i,
+          response
+        }));
+      }
+      this.progress++;
+    }
+    return this.hasBundle ? responses : responses[0];
+  }
+}