@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/api/discoverAccounts.mjs

@@ -0,0 +1,363 @@
+import { ACCOUNT_TYPES, CARDANO_DERIVATIONS, ERRORS, PAGING, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { arrayPartition, getSynchronize, versionUtils } from "@trezor/utils";
+import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+import { getCoinInfo } from "../data/coinInfo.mjs";
+import { isUtxoBased } from "../utils/accountUtils.mjs";
+import { validatePath } from "../utils/pathUtils.mjs";
+import { getFirmwareRange, validateParams } from "./common/paramsValidator.mjs";
+import { checkXPubWithHashes } from "./firmware/calculateXPubHash.mjs";
+const {
+  CARDANO_TXS_PER_PAGE,
+  DEFAULT_TXS_PER_PAGE,
+  SOLANA_TXS_PER_PAGE
+} = PAGING;
+const ACCOUNT_LIMIT = 10;
+const DETAILS = 'txs';
+const isCardano = account => account.symbol === 'ada';
+const isCardanoRequest = request => isCardano(request.account);
+const shouldSkipFirstAccountIndex = (account, coinInfo) => (coinInfo.type === 'ethereum' || coinInfo.shortcut === 'TRX') && account.type === 'ledger';
+const getAccountTypeKey = ({
+  symbol,
+  type
+}) => `${symbol}-${type}`;
+const substituteBip43Path = (path, index) => path.replace('i', String(index));
+export const getTxsPerPage = account => {
+  switch (account.symbol) {
+    case 'ada':
+      return CARDANO_TXS_PER_PAGE;
+    case 'sol':
+      return SOLANA_TXS_PER_PAGE;
+    default:
+      return DEFAULT_TXS_PER_PAGE;
+  }
+};
+export default class DiscoverAccounts extends AbstractMethod {
+  disposed = false;
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    const {
+      entropyCheckResult
+    } = payload;
+    validateParams(payload, [{
+      name: 'coins',
+      type: 'array',
+      required: true,
+      allowEmpty: true
+    }, {
+      name: 'entropyCheckResult',
+      type: 'object'
+    }]);
+    const coins = payload.coins.flatMap(coin => {
+      validateParams(coin, [{
+        name: 'symbol',
+        type: 'string',
+        required: true
+      }, {
+        name: 'known',
+        type: 'array',
+        allowEmpty: true
+      }, {
+        name: 'knownOnly',
+        type: 'boolean'
+      }, {
+        name: 'identity',
+        type: 'string'
+      }, {
+        name: 'details',
+        type: 'string'
+      }, {
+        name: 'pageSize',
+        type: 'number'
+      }, {
+        name: 'protocols',
+        type: 'array'
+      }]);
+      const {
+        symbol,
+        known: knownAccs,
+        knownOnly,
+        ...rest
+      } = coin;
+      const coinInfo = getCoinInfo(symbol);
+      if (!coinInfo) {
+        throw ERRORS.TypedError('Method_UnknownCoin');
+      }
+      isBackendSupported(coinInfo);
+      const firmwareRange = getFirmwareRange([payload.method], [coinInfo]);
+      const symbolAccounts = ACCOUNT_TYPES.filter(a => a.symbol === symbol);
+      knownAccs?.forEach(account => {
+        validateParams(account, [{
+          name: 'type',
+          type: 'string',
+          required: true
+        }, {
+          name: 'skip',
+          type: 'number'
+        }]);
+        if (!symbolAccounts.some(a => a.type === account.type)) {
+          throw new Error(`Unknown account type: ${symbol}/${account.type}`);
+        }
+      });
+      return symbolAccounts.map(account => [account, knownAccs?.find(t => t.type === account.type)]).filter(([_, known]) => known ? typeof known.skip === 'number' : !knownOnly).map(([account, known]) => ({
+        pageSize: getTxsPerPage(account),
+        details: DETAILS,
+        coinInfo,
+        firmwareRange,
+        skip: known?.skip ?? 0,
+        account,
+        ...rest,
+        offset: shouldSkipFirstAccountIndex(account, coinInfo) ? 1 : 0,
+        derivation: isCardano(account) ? CARDANO_DERIVATIONS[account.type] : undefined
+      }));
+    });
+    const params = {
+      coins,
+      entropyCheckResult
+    };
+    super(message, params);
+    this.useDevice = true;
+    this.useDeviceState = true;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return ['read'];
+  }
+  progress = {};
+  updateProgress(account, done, last = false) {
+    const progress = last ? 1 : done / Math.max(ACCOUNT_LIMIT, done + 1);
+    const key = getAccountTypeKey(account);
+    this.progress[key] = progress;
+  }
+  sendProgress(response, sendCoreMessage) {
+    const progress = Object.values(this.progress).reduce((sum, typeProgress) => sum + typeProgress, 0) / (Object.keys(this.progress).length || 1);
+    sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+      total: 100,
+      progress: 100 * progress,
+      response
+    }));
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const [unsupported, supported] = this.filterUnsupportedAccounts(this.params.coins);
+    unsupported.forEach(({
+      account: {
+        path: bip43,
+        ...rest
+      },
+      error,
+      coinInfo,
+      skip,
+      offset
+    }) => {
+      const path = substituteBip43Path(bip43, skip + offset);
+      const backendType = coinInfo.blockchainLink?.type;
+      this.sendProgress({
+        ...rest,
+        index: skip,
+        failed: true,
+        error,
+        path,
+        backendType
+      }, sendCoreMessage);
+    });
+    const [cardanoAccounts, otherAccounts] = arrayPartition(supported, isCardanoRequest);
+    const [_, filteredCardanoAccounts] = await this.filterCardanoDerivations(cardanoAccounts);
+    const accounts = [...otherAccounts, ...filteredCardanoAccounts];
+    accounts.forEach(({
+      account,
+      skip
+    }) => this.updateProgress(account, skip));
+    const counts = await Promise.all(accounts.map(account => this.discoverAccount(account, sendCoreMessage)));
+    const nonempty = counts.reduce((sum, acc) => sum + acc.nonempty, 0);
+    const failed = counts.filter(acc => acc.error).length;
+    const empty = counts.length - failed;
+    return {
+      empty,
+      nonempty,
+      failed
+    };
+  }
+  filterUnsupportedAccounts(accounts) {
+    const version = this.getDevice().getVersion();
+    const model = this.getDevice().features?.internal_model;
+    if (!version || !model) return [[], accounts];
+    return arrayPartition(accounts.map(item => {
+      const {
+        min,
+        max
+      } = item.firmwareRange[model];
+      let error;
+      if (min === '0') {
+        error = UI_REQUEST.FIRMWARE_NOT_SUPPORTED;
+      } else if (!versionUtils.isNewerOrEqual(version, min)) {
+        error = UI_REQUEST.FIRMWARE_OLD;
+      } else if (max !== '0' && versionUtils.isNewer(version, max)) {
+        error = UI_REQUEST.FIRMWARE_NOT_COMPATIBLE;
+      }
+      return error ? {
+        ...item,
+        error
+      } : item;
+    }), item => 'error' in item);
+  }
+  async filterCardanoDerivations(accounts) {
+    const legacyRequest = accounts.find(a => a.account.type === 'legacy');
+    const ledgerRequest = accounts.find(a => a.account.type === 'ledger');
+    const filterableRequest = legacyRequest ?? ledgerRequest;
+    const getDescriptor = derivation => filterableRequest && this.getDescriptor(filterableRequest.coinInfo, filterableRequest.account.path, CARDANO_DERIVATIONS[derivation], 0).then(({
+      descriptor
+    }) => descriptor);
+    const normalDescriptor = await getDescriptor('normal');
+    const omitLegacy = legacyRequest && (await getDescriptor('legacy')) === normalDescriptor;
+    const omitLedger = ledgerRequest && (!legacyRequest || omitLegacy) && (await getDescriptor('ledger')) === normalDescriptor;
+    return arrayPartition(accounts.map(item => item.account.type === 'legacy' && omitLegacy || item.account.type === 'ledger' && omitLedger ? {
+      ...item,
+      error: 'ignored cardano derivation'
+    } : item), item => 'error' in item);
+  }
+  descriptorLock = getSynchronize();
+  descriptorCache = {};
+  async getDescriptor(coinInfo, bip43PathTemplate, derivationType, index) {
+    const path = substituteBip43Path(bip43PathTemplate, index);
+    const {
+      address_n: _,
+      ...descriptorRest
+    } = await this.descriptorLock(async () => {
+      const key = `${path}-${derivationType}`;
+      if (!this.descriptorCache[key]) {
+        const address_n = validatePath(path, 3);
+        const descriptor = await this.getDevice().getCommands().getAccountDescriptor(coinInfo, address_n, derivationType);
+        this.descriptorCache[key] = descriptor;
+        const knownXPubHashes = this.params.entropyCheckResult?.xpubHashes;
+        const {
+          legacyXpub: xpub
+        } = descriptor;
+        const isPassphraseEnabled = this.getDevice().features?.passphrase_protection;
+        const alwaysPassphrase = this.getDevice().features?.passphrase_always_on_device;
+        const isStandardWallet = !isPassphraseEnabled || this.useEmptyPassphrase && !alwaysPassphrase;
+        if (xpub && knownXPubHashes && isStandardWallet) {
+          const isValid = checkXPubWithHashes({
+            xpub,
+            path,
+            knownXPubHashes
+          });
+          if (!isValid) {
+            console.error(`Entropy check failed at getAccountDescriptor on ${path}`);
+          }
+        }
+      }
+      return this.descriptorCache[key];
+    });
+    return {
+      path,
+      ...descriptorRest
+    };
+  }
+  async discoverAccount(request, sendCoreMessage) {
+    const {
+      details,
+      identity,
+      pageSize,
+      gap,
+      protocols,
+      coinInfo,
+      derivation,
+      offset,
+      skip
+    } = request;
+    const {
+      path: bip43,
+      ...accountKey
+    } = request.account;
+    const backendType = coinInfo.blockchainLink?.type;
+    const utxoRequired = isUtxoBased(coinInfo) && details && details !== 'basic';
+    let index = skip;
+    const sendProgress = response => this.sendProgress(response, sendCoreMessage);
+    let blockchain;
+    try {
+      blockchain = await initBlockchain(coinInfo, sendCoreMessage, identity);
+    } catch (err) {
+      const path = substituteBip43Path(bip43, offset + index);
+      this.updateProgress(accountKey, index + 1, true);
+      const error = err.message;
+      sendProgress({
+        ...accountKey,
+        index,
+        failed: true,
+        error,
+        path,
+        backendType
+      });
+      return {
+        nonempty: 0,
+        error
+      };
+    }
+    let descPromise = this.getDescriptor(coinInfo, bip43, derivation, offset + index);
+    descPromise.catch(() => {});
+    while (true) {
+      try {
+        const {
+          descriptor,
+          ...descRest
+        } = await descPromise;
+        descPromise = this.getDescriptor(coinInfo, bip43, derivation, offset + index + 1);
+        descPromise.catch(() => {});
+        const info = await blockchain.getAccountInfo({
+          descriptor,
+          details,
+          pageSize,
+          protocols,
+          gap
+        });
+        const utxo = !utxoRequired ? undefined : info.empty ? [] : await blockchain.getAccountUtxo(descriptor);
+        this.updateProgress(accountKey, index + 1, info.empty);
+        sendProgress({
+          ...info,
+          descriptor,
+          ...descRest,
+          utxo,
+          ...accountKey,
+          index,
+          backendType,
+          failed: false
+        });
+        if (info.empty) {
+          await descPromise.catch(() => {});
+          return {
+            nonempty: index - skip
+          };
+        }
+      } catch (err) {
+        const path = substituteBip43Path(bip43, offset + index);
+        const {
+          message: error,
+          code
+        } = err;
+        const failed = true;
+        this.updateProgress(accountKey, index + 1, true);
+        sendProgress({
+          ...accountKey,
+          index,
+          failed,
+          error,
+          code,
+          path,
+          backendType
+        });
+        return {
+          nonempty: index - skip,
+          error
+        };
+      }
+      index++;
+    }
+  }
+  dispose() {
+    this.disposed = true;
+  }
+}

package/libESM/api/ethereum/api/ethereumGetAddress.d.mts

@@ -0,0 +1,28 @@
+import type { EthereumNetworkInfoDefinitionValues, MethodPermission, PROTO } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage } from '../../../core/AbstractMethod';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+type Params = {
+    proto: PROTO.EthereumGetAddress;
+    address?: string;
+    network?: EthereumNetworkInfoDefinitionValues;
+};
+export default class EthereumGetAddress extends AbstractMethod<'ethereumGetAddress', Params[]> {
+    hasBundle?: boolean;
+    progress: number;
+    constructor(message: MethodMessage<'ethereumGetAddress'>);
+    get requiredPermissions(): MethodPermission[];
+    initAsync(): Promise<void>;
+    get info(): string;
+    getButtonRequestData(code: string): {
+        type: "address";
+        serializedPath: string;
+        address: string;
+    } | undefined;
+    get confirmation(): {
+        view: "export-address";
+        label: string;
+    };
+    private _call;
+    run({ sendCoreMessage }: MethodContext): Promise<import("@trezor/connect-common").Address | import("@trezor/connect-common").Address[]>;
+}
+export {};

package/libESM/api/ethereum/api/ethereumGetAddress.mjs

@@ -0,0 +1,135 @@
+import { Bundle, GetAddress as GetAddressSchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { getEthereumNetwork, getUniqueNetworks } from "../../../data/coinInfo.mjs";
+import { getNetworkLabel } from "../../../utils/ethereumUtils.mjs";
+import { stripHexPrefix } from "../../../utils/formatUtils.mjs";
+import { getSerializedPath, getSlip44ByPath, validatePath } from "../../../utils/pathUtils.mjs";
+import { bundlify } from "../../common/paramsValidator.mjs";
+import { decodeEthereumDefinition, ethereumNetworkInfoFromDefinition, getEthereumDefinitions } from "../ethereumDefinitions.mjs";
+export default class EthereumGetAddress extends AbstractMethod {
+  hasBundle;
+  progress = 0;
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(GetAddressSchema), payload);
+    const params = payload.bundle.map(batch => {
+      const path = validatePath(batch.path, 3);
+      const network = getEthereumNetwork(path);
+      const proto = {
+        address_n: path,
+        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+        chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false
+      };
+      return {
+        proto,
+        address: batch.address,
+        network
+      };
+    });
+    super(message, params);
+    this.requiredFirmwareCoins = params.map(({
+      network
+    }) => network);
+    this.hasBundle = hasBundle;
+    this.useUi = this.getUseUi(this.params, payload.useEventListener);
+    this.confirmMissingBackup = true;
+    this.requiredDeviceCapabilities = ['Capability_Ethereum'];
+  }
+  get requiredPermissions() {
+    return ['read'];
+  }
+  async initAsync() {
+    for (let i = 0; i < this.params.length; i++) {
+      if (!this.params[i].network) {
+        const slip44 = getSlip44ByPath(this.params[i].proto.address_n);
+        const definitions = await getEthereumDefinitions({
+          slip44
+        });
+        const decoded = decodeEthereumDefinition(definitions);
+        if (decoded.network) {
+          this.params[i].network = ethereumNetworkInfoFromDefinition(decoded.network);
+        }
+        if (definitions.encoded_network) {
+          this.params[i].proto.encoded_network = definitions.encoded_network;
+        }
+      }
+    }
+  }
+  get info() {
+    if (this.params.length === 1) {
+      return getNetworkLabel('Export #NETWORK address', this.params[0].network);
+    }
+    const requestedNetworks = this.params.map(b => b.network);
+    const uniqNetworks = getUniqueNetworks(requestedNetworks);
+    if (uniqNetworks.length === 1 && uniqNetworks[0]) {
+      return getNetworkLabel('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 {
+      view: 'export-address',
+      label: this.info
+    };
+  }
+  async _call(params) {
+    const response = await this.getDevice().getCommands().ethereumGetAddress(params.proto);
+    return {
+      path: params.proto.address_n,
+      serializedPath: getSerializedPath(params.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 (stripHexPrefix(batch.address).toLowerCase() !== stripHexPrefix(silent.address).toLowerCase()) {
+            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];
+  }
+}

package/libESM/api/ethereum/api/ethereumGetPublicKey.d.mts

@@ -0,0 +1,48 @@
+import { type EthereumNetworkInfo, type MethodPermission } from '@trezor/connect-common';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodContext, MethodMessage } from '../../../core/AbstractMethod';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+type Params = {
+    proto: PROTO.EthereumGetPublicKey;
+    network?: EthereumNetworkInfo;
+};
+export default class EthereumGetPublicKey extends AbstractMethod<'ethereumGetPublicKey', Params[]> {
+    hasBundle?: boolean;
+    constructor(message: MethodMessage<'ethereumGetPublicKey'>);
+    get requiredPermissions(): MethodPermission[];
+    get info(): string;
+    get confirmation(): {
+        view: "export-xpub";
+        label: string;
+    };
+    run({ sendCoreMessage }: MethodContext): Promise<({
+        publicKey: string;
+        path: number[];
+        serializedPath: string;
+    } & {
+        xpubSegwit?: string | undefined;
+        descriptorChecksum?: string | undefined;
+        rootFingerprint?: number | undefined;
+        descriptor?: string | undefined;
+        childNum: number;
+        xpub: string;
+        chainCode: string;
+        fingerprint: number;
+        depth: number;
+    }) | ({
+        publicKey: string;
+        path: number[];
+        serializedPath: string;
+    } & {
+        xpubSegwit?: string | undefined;
+        descriptorChecksum?: string | undefined;
+        rootFingerprint?: number | undefined;
+        descriptor?: string | undefined;
+        childNum: number;
+        xpub: string;
+        chainCode: string;
+        fingerprint: number;
+        depth: number;
+    })[]>;
+}
+export {};

package/libESM/api/ethereum/api/ethereumGetPublicKey.mjs

@@ -0,0 +1,90 @@
+import { Bundle, GetPublicKey as GetPublicKeySchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { getEthereumNetwork, getUniqueNetworks } from "../../../data/coinInfo.mjs";
+import { getNetworkLabel } from "../../../utils/ethereumUtils.mjs";
+import { getSerializedPath, validatePath } from "../../../utils/pathUtils.mjs";
+import { bundlify } from "../../common/paramsValidator.mjs";
+export default class EthereumGetPublicKey extends AbstractMethod {
+  hasBundle;
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(GetPublicKeySchema), payload);
+    const params = payload.bundle.map(batch => {
+      const path = validatePath(batch.path, 3);
+      const network = getEthereumNetwork(path);
+      const proto = {
+        address_n: path,
+        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : false
+      };
+      return {
+        proto,
+        network
+      };
+    });
+    super(message, params);
+    this.requiredFirmwareCoins = params.map(({
+      network
+    }) => network);
+    this.hasBundle = hasBundle;
+    this.requiredDeviceCapabilities = ['Capability_Ethereum'];
+  }
+  get requiredPermissions() {
+    return ['read'];
+  }
+  get info() {
+    if (this.params.length === 1) {
+      return getNetworkLabel('Export #NETWORK public key', this.params[0].network);
+    }
+    const requestedNetworks = this.params.map(b => b.network);
+    const uniqNetworks = getUniqueNetworks(requestedNetworks);
+    if (uniqNetworks.length === 1 && uniqNetworks[0]) {
+      return getNetworkLabel('Export multiple #NETWORK public keys', uniqNetworks[0]);
+    }
+    return 'Export multiple public keys';
+  }
+  get confirmation() {
+    return {
+      view: 'export-xpub',
+      label: this.info
+    };
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const responses = [];
+    const cmd = this.getDevice().getCommands();
+    for (let i = 0; i < this.params.length; i++) {
+      const {
+        address_n,
+        show_display
+      } = this.params[i].proto;
+      const publicKey = await cmd.ethereumGetPublicKey({
+        address_n,
+        show_display
+      });
+      const response = {
+        path: address_n,
+        serializedPath: getSerializedPath(address_n),
+        childNum: publicKey.node.child_num,
+        xpub: publicKey.xpub,
+        chainCode: publicKey.node.chain_code,
+        publicKey: publicKey.node.public_key,
+        fingerprint: publicKey.node.fingerprint,
+        depth: publicKey.node.depth
+      };
+      responses.push(response);
+      if (this.hasBundle) {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+          total: this.params.length,
+          progress: i,
+          response
+        }));
+      }
+    }
+    return this.hasBundle ? responses : responses[0];
+  }
+}

package/libESM/api/ethereum/api/ethereumSignMessage.d.mts

@@ -0,0 +1,27 @@
+import type { EthereumNetworkInfo, MethodPermission } from '@trezor/connect-common';
+import type { MessagesSchema, MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from '../../../core/AbstractMethod';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+type Params = {
+    proto: PROTO.EthereumSignMessage;
+    readableMessage: string;
+    network?: EthereumNetworkInfo;
+    definitions?: MessagesSchema.EthereumDefinitions;
+};
+export default class EthereumSignMessage extends AbstractMethod<'ethereumSignMessage', Params> {
+    constructor(message: MethodMessage<'ethereumSignMessage'>);
+    get requiredPermissions(): MethodPermission[];
+    initAsync(): Promise<void>;
+    get info(): string;
+    getButtonRequestData(code: string, name?: string): {
+        type: "message";
+        coin: string;
+        serializedPath: string;
+        message: string;
+    } | undefined;
+    run(): Promise<{
+        address: string;
+        signature: string;
+    }>;
+}
+export {};