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

package/libESM/api/discoverAccounts.mjs

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

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

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

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

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

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