@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/composeTransaction.d.ts

@@ -1,44 +1,36 @@
+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 { AbstractMethod } from '../core/AbstractMethod';
-import { TransactionComposer } from './bitcoin';
-import type { AccountUtxo, BitcoinNetworkInfo, DiscoveryAccount } from '../types';
-import { Discovery } from './common/Discovery';
-import type { ComposeResult, PrecomposeParams, PrecomposedResult, SignedTransaction } from '../types/api/composeTransaction';
+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'];
-    floorBaseFee?: PrecomposeParams['floorBaseFee'];
-    sequence?: PrecomposeParams['sequence'];
-    total: BigNumber;
-    sortingStrategy: PrecomposeParams['sortingStrategy'];
-} & ({
-    skipPermutation?: PrecomposeParams['skipPermutation'];
-    sortingStrategy?: undefined;
-} | {
-    skipPermutation?: undefined;
-    sortingStrategy?: TransactionInputOutputSortingStrategy;
-});
+  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> {
-    discovery?: Discovery;
-    init(): void;
-    get info(): string;
-    private getBlockchain;
-    precompose(account: PrecomposeParams['account'], feeLevels: PrecomposeParams['feeLevels']): Promise<PrecomposedResult[]>;
-    run(): Promise<SignedTransaction | PrecomposedResult[]>;
-    selectAccount(): Promise<{
-        account: DiscoveryAccount;
-        utxo: AccountUtxo[];
-    }>;
-    selectFee(account: DiscoveryAccount, utxos: AccountUtxo[]): Promise<SignedTransaction | "change-account">;
-    _selectFeeUiResponse(composer: TransactionComposer): Promise<SignedTransaction | 'change-account'>;
-    _sign(tx: ComposeResult): Promise<import("../types").SignedTransaction>;
-    dispose(): void;
+  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 {};
-//# sourceMappingURL=composeTransaction.d.ts.map
+export {};

package/lib/api/composeTransaction.js

@@ -1,31 +1,30 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const tslib_1 = require("tslib");
-const bigNumber_1 = require("@trezor/utils/lib/bigNumber");
-const promiseAllSequence_1 = require("@trezor/utils/lib/promiseAllSequence");
-const resolveAfter_1 = require("@trezor/utils/lib/resolveAfter");
-const BlockchainLink_1 = require("../backend/BlockchainLink");
-const constants_1 = require("../constants");
-const utxo_1 = require("../constants/utxo");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const events_1 = require("../events");
-const bitcoin_1 = require("./bitcoin");
-const Discovery_1 = require("./common/Discovery");
-const paramsValidator_1 = require("./common/paramsValidator");
-const coinInfo_1 = require("../data/coinInfo");
-const formatUtils_1 = require("../utils/formatUtils");
-const pathUtils = tslib_1.__importStar(require("../utils/pathUtils"));
-class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
-  discovery;
-  init() {
-    this.requiredPermissions = ['read', 'write'];
+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
-    } = this;
-    (0, paramsValidator_1.validateParams)(payload, [{
+    } = message;
+    validateParams(payload, [{
       name: 'outputs',
       type: 'array',
       required: true
@@ -48,64 +47,64 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
     }, {
       name: 'baseFee',
       type: 'number'
-    }, {
-      name: 'floorBaseFee',
-      type: 'boolean'
     }, {
       name: 'sequence',
       type: 'number'
-    }, {
-      name: 'skipPermutation',
-      type: 'boolean'
     }, {
       name: 'sortingStrategy',
       type: 'string'
     }]);
-    const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(payload.coin);
+    const coinInfo = getBitcoinNetwork(payload.coin);
     if (!coinInfo) {
-      throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+      throw ERRORS.TypedError('Method_UnknownCoin');
     }
-    (0, BlockchainLink_1.isBackendSupported)(coinInfo);
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
+    assertBackendSupported(coinInfo);
     const outputs = [];
-    let total = new bigNumber_1.BigNumber(0);
+    let total = new BigNumber(0);
     payload.outputs.forEach(out => {
-      const output = (0, bitcoin_1.validateHDOutput)(out, coinInfo);
+      const output = validateHDOutput(out, coinInfo);
       if ('amount' in output && typeof output.amount === 'string') {
         total = total.plus(output.amount);
       }
       outputs.push(output);
     });
-    this.useDevice = !payload.account && !payload.feeLevels;
-    this.useUi = this.useDevice;
-    this.params = {
+    const params = {
       outputs,
       coinInfo,
       identity: payload.identity,
       account: payload.account,
       feeLevels: payload.feeLevels,
       baseFee: payload.baseFee,
-      floorBaseFee: payload.floorBaseFee,
       sequence: payload.sequence,
-      sortingStrategy: payload.skipPermutation === true ? 'none' : payload.sortingStrategy,
+      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) {
-      this.requiredPermissions.push('push_tx');
+      permissions.push(this.coinPerm('push_tx', this.params.coinInfo));
     }
+    return permissions;
   }
   get info() {
-    const sendMax = this.params?.outputs.find(o => o.type === 'send-max') !== undefined;
+    const sendMax = this.params.outputs.some(o => o.type === 'send-max');
     if (sendMax) {
       return 'Send maximum amount';
     }
-    return `Send ${(0, formatUtils_1.formatAmount)(this.params.total.toString(), this.params.coinInfo)}`;
+    return `Send ${formatAmount(this.params.total.toString(), this.params.coinInfo)}`;
   }
-  getBlockchain() {
-    return (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage, this.params.identity);
+  getBlockchain(sendCoreMessage) {
+    return initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
   }
-  async precompose(account, feeLevels) {
+  async precompose(account, feeLevels, sendCoreMessage) {
     const {
       coinInfo,
       outputs,
@@ -113,7 +112,7 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
       sortingStrategy
     } = this.params;
     const address_n = pathUtils.validatePath(account.path);
-    const composer = new bitcoin_1.TransactionComposer({
+    const composer = new TransactionComposer({
       account: {
         type: pathUtils.getAccountType(address_n),
         label: 'Account',
@@ -125,181 +124,247 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
       coinInfo,
       outputs,
       baseFee,
-      sortingStrategy: sortingStrategy ?? utxo_1.DEFAULT_SORTING_STRATEGY
+      sortingStrategy: sortingStrategy ?? DEFAULT_SORTING_STRATEGY
     });
-    const blockchain = await this.getBlockchain();
+    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 = {
-        ...composer.composed.custom
+        ...composedCustom
       };
       if (tx.type === 'final') {
         return {
           ...tx,
-          inputs: tx.inputs.map(inp => (0, bitcoin_1.inputToTrezor)(inp, this.params.sequence)),
-          outputs: tx.outputs.map(bitcoin_1.outputToTrezor)
+          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 => (0, bitcoin_1.inputToTrezor)(inp, this.params.sequence))
+          inputs: tx.inputs.map(inp => inputToTrezor(inp, this.params.sequence))
         };
       }
       return tx;
     });
   }
-  async run() {
+  async run(context) {
     if (this.params.account && this.params.feeLevels) {
-      return this.precompose(this.params.account, this.params.feeLevels);
+      return this.precompose(this.params.account, this.params.feeLevels, context.sendCoreMessage);
     }
     const {
       account,
       utxo
-    } = await this.selectAccount();
-    const response = await this.selectFee(account, utxo);
-    if (!this.discovery) {
-      throw constants_1.ERRORS.TypedError('Runtime', 'ComposeTransaction: selectFee response received after dispose');
+    } = 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();
+      return this.run(context);
     }
     return response;
   }
-  async selectAccount() {
+  async selectAccount(context) {
     const {
       coinInfo
     } = this.params;
-    const blockchain = await this.getBlockchain();
-    const dfd = this.createUiPromise(events_1.UI.RECEIVE_ACCOUNT);
-    if (this.discovery && this.discovery.completed) {
+    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;
-      this.postMessage((0, events_1.createUiMessage)(events_1.UI.SELECT_ACCOUNT, {
+      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 account = discovery.accounts[uiResp.payload];
+      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_1.Discovery({
+    const discovery = this.discovery || new Discovery({
       blockchain,
-      getDescriptor: path => this.device.getCommands().getAccountDescriptor(this.params.coinInfo, path)
+      getDescriptor: path => this.getDevice().getCommands().getAccountDescriptor(this.params.coinInfo, path)
     });
     this.discovery = discovery;
     discovery.on('progress', accounts => {
-      this.postMessage((0, events_1.createUiMessage)(events_1.UI.SELECT_ACCOUNT, {
+      context.sendCoreMessage(createUiMessage(UI_REQUEST.SELECT_ACCOUNT, {
         type: 'progress',
         coinInfo,
         accounts
+      }, {
+        requestId: dfd.requestId
       }));
     });
     discovery.on('complete', () => {
-      this.postMessage((0, events_1.createUiMessage)(events_1.UI.SELECT_ACCOUNT, {
+      context.sendCoreMessage(createUiMessage(UI_REQUEST.SELECT_ACCOUNT, {
         type: 'end',
         coinInfo
+      }, {
+        requestId: dfd.requestId
       }));
     });
     discovery.start('tokens').catch(error => {
       dfd.reject(error);
     });
-    this.postMessage((0, events_1.createUiMessage)(events_1.UI.SELECT_ACCOUNT, {
+    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 (0, resolveAfter_1.resolveAfter)(501);
+      await resolveAfter(501);
     }
-    const account = discovery.accounts[uiResp.payload];
-    this.params.coinInfo = (0, coinInfo_1.fixCoinInfoNetwork)(this.params.coinInfo, account.address_n);
+    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) {
+  async selectFee(account, utxos, context) {
     const {
       coinInfo,
       outputs,
-      sortingStrategy,
-      skipPermutation
+      sortingStrategy
     } = this.params;
-    const blockchain = await this.getBlockchain();
-    const composer = new bitcoin_1.TransactionComposer({
+    const blockchain = await this.getBlockchain(context.sendCoreMessage);
+    const composer = new TransactionComposer({
       account,
       utxos,
       coinInfo,
       outputs,
-      sortingStrategy: skipPermutation === true ? 'none' : sortingStrategy ?? utxo_1.DEFAULT_SORTING_STRATEGY
+      sortingStrategy: sortingStrategy ?? DEFAULT_SORTING_STRATEGY
     });
     await composer.init(blockchain);
     const hasFunds = composer.composeAllFeeLevels();
     if (!hasFunds) {
-      this.postMessage((0, events_1.createUiMessage)(events_1.UI.INSUFFICIENT_FUNDS));
-      await (0, resolveAfter_1.resolveAfter)(2000);
+      context.sendCoreMessage(createUiMessage(UI_REQUEST.INSUFFICIENT_FUNDS));
+      await resolveAfter(2000);
       return 'change-account';
     }
-    this.postMessage((0, events_1.createUiMessage)(events_1.UI.SELECT_FEE, {
+    context.sendCoreMessage(createUiMessage(UI_REQUEST.SELECT_FEE, {
       feeLevels: composer.getFeeLevelList(),
       coinInfo: this.params.coinInfo
     }));
-    return this._selectFeeUiResponse(composer);
+    return this._selectFeeUiResponse(composer, context);
   }
-  async _selectFeeUiResponse(composer) {
-    const resp = await this.createUiPromise(events_1.UI.RECEIVE_FEE).promise;
+  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);
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.UPDATE_CUSTOM_FEE, {
+        context.sendCoreMessage(createUiMessage(UI_REQUEST.UPDATE_CUSTOM_FEE, {
           feeLevels: composer.getFeeLevelList(),
           coinInfo: this.params.coinInfo
+        }, {
+          requestId: resp.requestId
         }));
-        return this._selectFeeUiResponse(composer);
+        return this._selectFeeUiResponse(composer, context);
       case 'send':
-        return this._sign(composer.composed[resp.payload.value]);
+        {
+          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) {
+  async _sign(tx, sendCoreMessage) {
+    const device = this.getDevice();
     const {
-      device,
       params
     } = this;
-    if (tx.type !== 'final') throw constants_1.ERRORS.TypedError('Runtime', 'ComposeTransaction: Trying to sign unfinished tx');
+    if (tx.type !== 'final') throw ERRORS.TypedError('Runtime', 'ComposeTransaction: Trying to sign unfinished tx');
     const {
       coinInfo
     } = params;
-    const options = (0, bitcoin_1.enhanceSignTx)({}, coinInfo);
-    const inputs = tx.inputs.map(inp => (0, bitcoin_1.inputToTrezor)(inp, params.sequence));
-    const outputs = tx.outputs.map(bitcoin_1.outputToTrezor);
+    const options = enhanceSignTx({}, coinInfo);
+    const inputs = tx.inputs.map(inp => inputToTrezor(inp, params.sequence));
+    const outputs = tx.outputs.map(outputToTrezor);
     let refTxs = [];
-    const requiredRefTxs = (0, bitcoin_1.requireReferencedTransactions)(inputs, options, coinInfo);
-    const refTxsIds = (0, bitcoin_1.getReferencedTransactions)(inputs);
+    const requiredRefTxs = requireReferencedTransactions(inputs, options, coinInfo);
+    const refTxsIds = getReferencedTransactions(inputs);
     if (requiredRefTxs && refTxsIds.length > 0) {
-      refTxs = await this.getBlockchain().then(blockchain => blockchain.getTransactionHexes(refTxsIds)).then((0, bitcoin_1.parseTransactionHexes)(coinInfo.network)).then(bitcoin_1.transformReferencedTransactions);
+      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 (0, promiseAllSequence_1.promiseAllSequence)(outputs.map(output => () => (0, bitcoin_1.deriveOutputScript)(getHDNode, output, coinInfo.network)));
-    const signTxMethod = !device.unavailableCapabilities.replaceTransaction ? bitcoin_1.signTx : bitcoin_1.signTxLegacy;
+    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,
@@ -309,14 +374,14 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
       options,
       coinInfo
     });
-    (0, bitcoin_1.verifyTx)(response.serializedTx, {
+    verifyTx(response.serializedTx, {
       inputs,
       outputs,
       outputScripts,
       network: coinInfo.network
     });
     if (params.push) {
-      const blockchain = await this.getBlockchain();
+      const blockchain = await this.getBlockchain(sendCoreMessage);
       const txid = await blockchain.pushTransaction(response.serializedTx);
       return {
         ...response,
@@ -326,6 +391,7 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
     return response;
   }
   dispose() {
+    this.disposed = true;
     const {
       discovery
     } = this;
@@ -335,6 +401,4 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
       this.discovery = undefined;
     }
   }
-}
-exports.default = ComposeTransaction;
-//# sourceMappingURL=composeTransaction.js.map
+}

package/lib/api/discoverAccounts.d.ts

@@ -1,33 +1,40 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import type { CoinInfo, FirmwareRange } from '../types';
-import { AccountTypeItem, AdditionalParams, CARDANO_DERIVATIONS } from '../types/api/discoverAccounts';
+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;
+  account: AccountTypeItem;
+  derivation?: CardanoDerivation;
+  firmwareRange: FirmwareRange;
+  coinInfo: CoinInfo;
+  offset: number;
+  skip: number;
 };
-export default class DiscoverAccounts extends AbstractMethod<'discoverAccounts', Request[]> {
-    disposed: boolean;
-    init(): void;
-    private progress;
-    private updateProgress;
-    private sendProgress;
-    run(): Promise<{
-        empty: number;
-        nonempty: number;
-        failed: number;
-    }>;
-    private filterUnsupportedAccounts;
-    private filterCardanoDerivations;
-    private readonly descriptorLock;
-    private readonly descriptorCache;
-    private getDescriptor;
-    private discoverAccount;
-    dispose(): void;
+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 {};
-//# sourceMappingURL=discoverAccounts.d.ts.map
+export {};