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

package/lib/api/composeTransaction.js

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

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