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

package/lib/api/composeTransaction.js

@@ -0,0 +1,404 @@
+import { DEFAULT_SORTING_STRATEGY, ERRORS, UI_REQUEST, UI_RESPONSE, createUiMessage } from "@trezor/connect-common";
+import { BigNumber } from "@trezor/utils/lib/bigNumber.js";
+import { promiseAllSequence } from "@trezor/utils/lib/promiseAllSequence.js";
+import { resolveAfter } from "@trezor/utils/lib/resolveAfter.js";
+import { unique } from "@trezor/utils/lib/unique.js";
+import { assertBackendSupported, initBlockchain } from "../backend/BlockchainLink.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { requestExistingAccounts } from "./common/requestExistingAccounts.js";
+import { fixCoinInfoNetwork, getBitcoinNetwork } from "../data/coinInfo.js";
+import { formatAmount } from "../utils/formatUtils.js";
+import * as pathUtils from "../utils/pathUtils.js";
+import { TransactionComposer } from "./bitcoin/TransactionComposer.js";
+import { enhanceSignTx } from "./bitcoin/enhanceSignTx.js";
+import { inputToTrezor } from "./bitcoin/inputs.js";
+import { outputToTrezor, validateHDOutput } from "./bitcoin/outputs.js";
+import { getReferencedTransactions, parseTransactionHexes, requireReferencedTransactions, transformReferencedTransactions } from "./bitcoin/refTx.js";
+import { signTx } from "./bitcoin/signtx.js";
+import { signTxLegacy } from "./bitcoin/signtxLegacy.js";
+import { deriveOutputScript, verifyTx } from "./bitcoin/signtxVerify.js";
+import { Discovery } from "./common/Discovery.js";
+import { validateParams } from "./common/paramsValidator.js";
+export default class ComposeTransaction extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    validateParams(payload, [{
+      name: 'outputs',
+      type: 'array',
+      required: true
+    }, {
+      name: 'coin',
+      type: 'string',
+      required: true
+    }, {
+      name: 'identity',
+      type: 'string'
+    }, {
+      name: 'push',
+      type: 'boolean'
+    }, {
+      name: 'account',
+      type: 'object'
+    }, {
+      name: 'feeLevels',
+      type: 'array'
+    }, {
+      name: 'baseFee',
+      type: 'number'
+    }, {
+      name: 'sequence',
+      type: 'number'
+    }, {
+      name: 'sortingStrategy',
+      type: 'string'
+    }]);
+    const coinInfo = getBitcoinNetwork(payload.coin);
+    if (!coinInfo) {
+      throw ERRORS.TypedError('Method_UnknownCoin');
+    }
+    assertBackendSupported(coinInfo);
+    const outputs = [];
+    let total = new BigNumber(0);
+    payload.outputs.forEach(out => {
+      const output = validateHDOutput(out, coinInfo);
+      if ('amount' in output && typeof output.amount === 'string') {
+        total = total.plus(output.amount);
+      }
+      outputs.push(output);
+    });
+    const params = {
+      outputs,
+      coinInfo,
+      identity: payload.identity,
+      account: payload.account,
+      feeLevels: payload.feeLevels,
+      baseFee: payload.baseFee,
+      sequence: payload.sequence,
+      sortingStrategy: payload.sortingStrategy,
+      push: typeof payload.push === 'boolean' ? payload.push : false,
+      total
+    };
+    super(message, params);
+    this.useDevice = !payload.account && !payload.feeLevels;
+    this.useUi = this.useDevice;
+    this.requiredFirmwareCoins = [coinInfo];
+  }
+  discovery;
+  disposed = false;
+  get requiredPermissions() {
+    const permissions = [this.coinPerm('sign', this.params.coinInfo)];
+    if (this.params.push) {
+      permissions.push(this.coinPerm('push_tx', this.params.coinInfo));
+    }
+    return permissions;
+  }
+  get info() {
+    const sendMax = this.params.outputs.some(o => o.type === 'send-max');
+    if (sendMax) {
+      return 'Send maximum amount';
+    }
+    return `Send ${formatAmount(this.params.total.toString(), this.params.coinInfo)}`;
+  }
+  getBlockchain(sendCoreMessage) {
+    return initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
+  }
+  async precompose(account, feeLevels, sendCoreMessage) {
+    const {
+      coinInfo,
+      outputs,
+      baseFee,
+      sortingStrategy
+    } = this.params;
+    const address_n = pathUtils.validatePath(account.path);
+    const composer = new TransactionComposer({
+      account: {
+        type: pathUtils.getAccountType(address_n),
+        label: 'Account',
+        descriptor: account.path,
+        address_n,
+        addresses: account.addresses
+      },
+      utxos: account.utxo,
+      coinInfo,
+      outputs,
+      baseFee,
+      sortingStrategy: sortingStrategy ?? DEFAULT_SORTING_STRATEGY
+    });
+    const blockchain = await this.getBlockchain(sendCoreMessage);
+    await composer.init(blockchain);
+    return feeLevels.map(level => {
+      composer.composeCustomFee(level.feePerUnit);
+      const {
+        composed
+      } = composer;
+      const composedCustom = composed['custom'];
+      const tx = {
+        ...composedCustom
+      };
+      if (tx.type === 'final') {
+        return {
+          ...tx,
+          inputs: tx.inputs.map(inp => inputToTrezor(inp, this.params.sequence)),
+          outputs: tx.outputs.map(outputToTrezor)
+        };
+      }
+      if (tx.type === 'nonfinal') {
+        return {
+          ...tx,
+          inputs: tx.inputs.map(inp => inputToTrezor(inp, this.params.sequence))
+        };
+      }
+      return tx;
+    });
+  }
+  async run(context) {
+    if (this.params.account && this.params.feeLevels) {
+      return this.precompose(this.params.account, this.params.feeLevels, context.sendCoreMessage);
+    }
+    const {
+      account,
+      utxo
+    } = await this.selectAccount(context);
+    const response = await this.selectFee(account, utxo, context);
+    if (this.disposed) {
+      throw ERRORS.TypedError('Runtime', 'ComposeTransaction: selectFee response received after dispose');
+    }
+    if (typeof response === 'string') {
+      return this.run(context);
+    }
+    return response;
+  }
+  async selectAccount(context) {
+    const {
+      coinInfo
+    } = this.params;
+    const blockchain = await this.getBlockchain(context.sendCoreMessage);
+    if (!this.discovery) {
+      const existingAccounts = await requestExistingAccounts({
+        postMessage: context.sendCoreMessage,
+        createUiPromise: context.createUiPromise,
+        device: this.getDevice(),
+        coinInfo
+      });
+      if (existingAccounts) {
+        return this.selectFromExistingAccounts(existingAccounts, blockchain, context);
+      }
+    }
+    return this.selectFromDiscovery(blockchain, context);
+  }
+  async selectFromExistingAccounts(accounts, blockchain, context) {
+    const {
+      coinInfo
+    } = this.params;
+    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)),
+      coinInfo,
+      accounts
+    }));
+    const uiResp = await dfd.promise;
+    const accountIndex = uiResp.payload;
+    const account = accounts[accountIndex];
+    this.params.coinInfo = fixCoinInfoNetwork(this.params.coinInfo, account.address_n);
+    const utxo = await blockchain.getAccountUtxo(account.descriptor);
+    return {
+      account,
+      utxo
+    };
+  }
+  async selectFromDiscovery(blockchain, context) {
+    const {
+      coinInfo
+    } = this.params;
+    const dfd = context.createUiPromise(UI_RESPONSE.RECEIVE_ACCOUNT, this.getDevice());
+    if (this.discovery?.completed) {
+      const {
+        discovery
+      } = this;
+      context.sendCoreMessage(createUiMessage(UI_REQUEST.SELECT_ACCOUNT, {
+        type: 'end',
+        coinInfo,
+        accountTypes: discovery.types.map(t => t.type),
+        accounts: discovery.accounts
+      }, {
+        requestId: dfd.requestId
+      }));
+      const uiResp = await dfd.promise;
+      const {
+        accounts
+      } = discovery;
+      const accountIndex = uiResp.payload;
+      const account = accounts[accountIndex];
+      const utxo = await blockchain.getAccountUtxo(account.descriptor);
+      return {
+        account,
+        utxo
+      };
+    }
+    const discovery = this.discovery || new Discovery({
+      blockchain,
+      getDescriptor: path => this.getDevice().getCommands().getAccountDescriptor(this.params.coinInfo, path)
+    });
+    this.discovery = discovery;
+    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('tokens').catch(error => {
+      dfd.reject(error);
+    });
+    context.sendCoreMessage(createUiMessage(UI_REQUEST.SELECT_ACCOUNT, {
+      type: 'start',
+      accountTypes: discovery.types.map(t => t.type),
+      coinInfo
+    }, {
+      requestId: dfd.requestId
+    }));
+    const uiResp = await dfd.promise;
+    discovery.removeAllListeners();
+    discovery.stop();
+    if (!discovery.completed) {
+      await resolveAfter(501);
+    }
+    const {
+      accounts
+    } = discovery;
+    const accountIndex = uiResp.payload;
+    const account = accounts[accountIndex];
+    this.params.coinInfo = fixCoinInfoNetwork(this.params.coinInfo, account.address_n);
+    const utxo = await blockchain.getAccountUtxo(account.descriptor);
+    return {
+      account,
+      utxo
+    };
+  }
+  async selectFee(account, utxos, context) {
+    const {
+      coinInfo,
+      outputs,
+      sortingStrategy
+    } = this.params;
+    const blockchain = await this.getBlockchain(context.sendCoreMessage);
+    const composer = new TransactionComposer({
+      account,
+      utxos,
+      coinInfo,
+      outputs,
+      sortingStrategy: sortingStrategy ?? DEFAULT_SORTING_STRATEGY
+    });
+    await composer.init(blockchain);
+    const hasFunds = composer.composeAllFeeLevels();
+    if (!hasFunds) {
+      context.sendCoreMessage(createUiMessage(UI_REQUEST.INSUFFICIENT_FUNDS));
+      await resolveAfter(2000);
+      return 'change-account';
+    }
+    context.sendCoreMessage(createUiMessage(UI_REQUEST.SELECT_FEE, {
+      feeLevels: composer.getFeeLevelList(),
+      coinInfo: this.params.coinInfo
+    }));
+    return this._selectFeeUiResponse(composer, context);
+  }
+  async _selectFeeUiResponse(composer, context) {
+    const resp = await context.createUiPromise(UI_RESPONSE.RECEIVE_FEE, this.getDevice()).promise;
+    switch (resp.payload.type) {
+      case 'compose-custom':
+        composer.composeCustomFee(resp.payload.value);
+        context.sendCoreMessage(createUiMessage(UI_REQUEST.UPDATE_CUSTOM_FEE, {
+          feeLevels: composer.getFeeLevelList(),
+          coinInfo: this.params.coinInfo
+        }, {
+          requestId: resp.requestId
+        }));
+        return this._selectFeeUiResponse(composer, context);
+      case 'send':
+        {
+          const {
+            composed
+          } = composer;
+          const composedKey = resp.payload.value;
+          const tx = composed[composedKey];
+          return this._sign(tx, context.sendCoreMessage);
+        }
+      default:
+        return 'change-account';
+    }
+  }
+  async _sign(tx, sendCoreMessage) {
+    const device = this.getDevice();
+    const {
+      params
+    } = this;
+    if (tx.type !== 'final') throw ERRORS.TypedError('Runtime', 'ComposeTransaction: Trying to sign unfinished tx');
+    const {
+      coinInfo
+    } = params;
+    const options = enhanceSignTx({}, coinInfo);
+    const inputs = tx.inputs.map(inp => inputToTrezor(inp, params.sequence));
+    const outputs = tx.outputs.map(outputToTrezor);
+    let refTxs = [];
+    const requiredRefTxs = requireReferencedTransactions(inputs, options, coinInfo);
+    const refTxsIds = getReferencedTransactions(inputs);
+    if (requiredRefTxs && refTxsIds.length > 0) {
+      refTxs = await this.getBlockchain(sendCoreMessage).then(blockchain => blockchain.getTransactionHexes(refTxsIds)).then(parseTransactionHexes(coinInfo.network)).then(transformReferencedTransactions);
+    }
+    const getHDNode = address_n => device.getCommands().getHDNode({
+      address_n
+    }, {
+      coinInfo: params.coinInfo
+    });
+    const outputScripts = await promiseAllSequence(outputs.map(output => () => deriveOutputScript(getHDNode, output, coinInfo.network)));
+    const signTxMethod = !device.unavailableCapabilities.replaceTransaction ? signTx : signTxLegacy;
+    const cmd = device.getCommands();
+    const response = await signTxMethod({
+      typedCall: cmd.typedCall,
+      inputs,
+      outputs,
+      refTxs,
+      options,
+      coinInfo
+    });
+    verifyTx(response.serializedTx, {
+      inputs,
+      outputs,
+      outputScripts,
+      network: coinInfo.network
+    });
+    if (params.push) {
+      const blockchain = await this.getBlockchain(sendCoreMessage);
+      const txid = await blockchain.pushTransaction(response.serializedTx);
+      return {
+        ...response,
+        txid
+      };
+    }
+    return response;
+  }
+  dispose() {
+    this.disposed = true;
+    const {
+      discovery
+    } = this;
+    if (discovery) {
+      discovery.stop();
+      discovery.removeAllListeners();
+      this.discovery = undefined;
+    }
+  }
+}

package/lib/api/discoverAccounts.d.ts

@@ -0,0 +1,40 @@
+import { type AccountTypeItem, type AdditionalParams, CARDANO_DERIVATIONS, type CoinInfo, type EntropyCheckResult, type FirmwareRange, type PermissionRequest } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+type CardanoDerivation = (typeof CARDANO_DERIVATIONS)[keyof typeof CARDANO_DERIVATIONS];
+type Request = AdditionalParams & {
+  account: AccountTypeItem;
+  derivation?: CardanoDerivation;
+  firmwareRange: FirmwareRange;
+  coinInfo: CoinInfo;
+  offset: number;
+  skip: number;
+};
+type DiscoverAccountsLocalParams = {
+  coins: Request[];
+  entropyCheckResult?: EntropyCheckResult;
+};
+export declare const getTxsPerPage: (account: AccountTypeItem) => 8 | 25;
+export default class DiscoverAccounts extends AbstractMethod<'discoverAccounts', DiscoverAccountsLocalParams> {
+  disposed: boolean;
+  constructor(message: MethodMessage<'discoverAccounts'>);
+  get requiredPermissions(): PermissionRequest[];
+  private progress;
+  private updateProgress;
+  private sendProgress;
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<{
+    empty: number;
+    nonempty: number;
+    failed: number;
+  }>;
+  private filterUnsupportedAccounts;
+  private filterCardanoDerivations;
+  private readonly descriptorLock;
+  private readonly descriptorCache;
+  private getDescriptor;
+  private discoverAccount;
+  dispose(): void;
+}
+export {};