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

package/lib/api/evoluGetNode.js

@@ -1,29 +0,0 @@
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-export default class EvoluGetNode extends AbstractMethod {
-  hasBundle;
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(PROTO.EvoluGetNode, payload);
-    const params = {
-      proof_of_delegated_identity: payload.proof_of_delegated_identity
-    };
-    super(message, params);
-  }
-  get requiredPermissions() {
-    return [{
-      permission: 'read_xpub'
-    }];
-  }
-  get info() {
-    return 'Evolu get node';
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    const response = await cmd.typedCall('EvoluGetNode', 'EvoluNode', this.params);
-    return response.message;
-  }
-}

package/lib/api/evoluSignRegistrationRequest.d.ts

@@ -1,16 +0,0 @@
-import { type PermissionRequest } from '@trezor/connect-common';
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import type { MethodMessage } from "../core/AbstractMethod.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-export default class EvoluSignRegistrationRequest extends AbstractMethod<'evoluSignRegistrationRequest', PROTO.EvoluSignRegistrationRequest> {
-  hasBundle?: boolean;
-  constructor(message: MethodMessage<'evoluSignRegistrationRequest'>);
-  get requiredPermissions(): PermissionRequest[];
-  init(): void;
-  get info(): string;
-  run(): Promise<{
-    rotation_index?: number | undefined;
-    signature: string;
-    certificate_chain: string[];
-  }>;
-}

package/lib/api/evoluSignRegistrationRequest.js

@@ -1,33 +0,0 @@
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-export default class EvoluSignRegistrationRequest extends AbstractMethod {
-  hasBundle;
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(PROTO.EvoluSignRegistrationRequest, payload);
-    const params = {
-      challenge_from_server: payload.challenge_from_server,
-      size_to_acquire: payload.size_to_acquire,
-      proof_of_delegated_identity: payload.proof_of_delegated_identity
-    };
-    super(message, params);
-    this.useEmptyPassphrase = true;
-  }
-  get requiredPermissions() {
-    return [{
-      permission: 'sign'
-    }];
-  }
-  init() {}
-  get info() {
-    return 'Evolu sign registration request';
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    const response = await cmd.typedCall('EvoluSignRegistrationRequest', 'EvoluRegistrationRequest', this.params);
-    return response.message;
-  }
-}

package/lib/api/firmware/calculateFirmwareHash.d.ts

@@ -1,18 +0,0 @@
-import { DeviceModelInternal } from '@trezor/device-utils';
-import type { VersionArray } from '@trezor/utils/lib/versionUtils';
-type CalculateFirmwareHashParams = {
-  internal_model: DeviceModelInternal;
-  fw: Buffer;
-  firmwareVersion: VersionArray;
-  key?: Buffer;
-};
-export declare const calculateFirmwareHash: ({
-  internal_model,
-  firmwareVersion,
-  fw,
-  key
-}: CalculateFirmwareHashParams) => {
-  hash: string;
-  challenge: string;
-};
-export {};

package/lib/api/firmware/calculateFirmwareHash.js

@@ -1,56 +0,0 @@
-import { blake2s } from "@noble/hashes/blake2.js";
-import { bytesToHex } from "@noble/hashes/utils.js";
-import { DeviceModelInternal } from "@trezor/device-utils";
-import { versionUtils } from "@trezor/utils";
-const SIZE_T1B1 = (7 * 128 + 64) * 1024;
-const SIZE_T2T1 = 13 * 128 * 1024;
-const SIZE_T2B1 = 13 * 128 * 1024;
-const SIZE_T3B1 = 208 * 8 * 1024;
-const SIZE_T3T1 = 208 * 8 * 1024;
-const SIZE_T3W1 = 417 * 8 * 1024;
-const firmwareSizeMap = {
-  [DeviceModelInternal.T1B1]: SIZE_T1B1,
-  [DeviceModelInternal.T2T1]: SIZE_T2T1,
-  [DeviceModelInternal.T2B1]: SIZE_T2B1,
-  [DeviceModelInternal.T3B1]: SIZE_T3B1,
-  [DeviceModelInternal.T3T1]: SIZE_T3T1,
-  [DeviceModelInternal.T3W1]: SIZE_T3W1
-};
-const getSizeForModel = ({
-  internal_model,
-  firmwareVersion
-}) => {
-  const size = firmwareSizeMap[internal_model] ?? SIZE_T1B1;
-  if (firmwareVersion !== undefined && internal_model === DeviceModelInternal.T3W1 && versionUtils.isEqual(firmwareVersion, [2, 9, 3])) {
-    return size - 16 * 1024;
-  }
-  return size;
-};
-export const calculateFirmwareHash = ({
-  internal_model,
-  firmwareVersion,
-  fw,
-  key
-}) => {
-  const size = getSizeForModel({
-    internal_model,
-    firmwareVersion
-  });
-  const padding = size - fw.byteLength;
-  if (padding < 0) {
-    throw new Error('Firmware too big');
-  }
-  const data = new Uint8Array(new ArrayBuffer(size));
-  data.set(new Uint8Array(fw));
-  if (padding > 0) {
-    const zeroBytes = Buffer.alloc(padding);
-    zeroBytes.fill(Buffer.from('ff', 'hex'));
-    data.set(zeroBytes, fw.byteLength);
-  }
-  return {
-    hash: key && key.length > 0 ? bytesToHex(blake2s(data, {
-      key
-    })) : bytesToHex(blake2s(data)),
-    challenge: key ? key.toString('hex') : ''
-  };
-};

package/lib/api/firmware/calculateXPubHash.d.ts

@@ -1,14 +0,0 @@
-import type { XPubHashesPerBip43Path } from '@trezor/connect-common';
-export declare const calculateXPubHash: (xpub: string) => string;
-export declare const calculateXPubHashes: (xpubs: Record<string, string>) => XPubHashesPerBip43Path;
-type CheckXPubWithHashesParams = {
-  xpub: string;
-  path: string;
-  knownXPubHashes: XPubHashesPerBip43Path;
-};
-export declare const checkXPubWithHashes: ({
-  xpub,
-  path,
-  knownXPubHashes
-}: CheckXPubWithHashesParams) => boolean;
-export {};

package/lib/api/firmware/calculateXPubHash.js

@@ -1,16 +0,0 @@
-import { sha256 } from "@noble/hashes/sha2.js";
-import { bytesToHex } from "@noble/hashes/utils.js";
-export const calculateXPubHash = xpub => bytesToHex(sha256(new TextEncoder().encode(xpub)));
-export const calculateXPubHashes = xpubs => {
-  const hashes = {};
-  Object.keys(xpubs).forEach(path => {
-    const xpub = xpubs[path];
-    hashes[path] = calculateXPubHash(xpub);
-  });
-  return hashes;
-};
-export const checkXPubWithHashes = ({
-  xpub,
-  path,
-  knownXPubHashes
-}) => knownXPubHashes[path] === undefined || knownXPubHashes[path] === calculateXPubHash(xpub);

package/lib/api/firmware/getBinary.d.ts

@@ -1,14 +0,0 @@
-import type { BinaryInfo } from '@trezor/connect-common';
-import type { FirmwareRelease } from '@trezor/device-utils';
-interface GetBinaryParams {
-  baseUrl: string;
-  path: string;
-  release: FirmwareRelease;
-}
-export declare const getBinary: ({
-  baseUrl,
-  path,
-  release
-}: GetBinaryParams) => Promise<BinaryInfo>;
-export declare const getBinaryOptional: (params: GetBinaryParams) => Promise<BinaryInfo | null>;
-export {};

package/lib/api/firmware/getBinary.js

@@ -1,33 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
-import { removeTrailingSlashes } from "@trezor/utils";
-import { parseFirmwareHeaders } from "./parseFirmwareHeaders.js";
-import { httpRequest } from "../../utils/assets.js";
-const MIN_FIRMWARE_SIZE_BYTES = 200;
-export const getBinary = async ({
-  baseUrl,
-  path,
-  release
-}) => {
-  const sanitizedBaseUrl = removeTrailingSlashes(baseUrl);
-  const url = `${sanitizedBaseUrl}/${path}`;
-  const binaryArrayBuffer = await httpRequest(url, 'binary');
-  if (binaryArrayBuffer.byteLength < MIN_FIRMWARE_SIZE_BYTES) {
-    throw ERRORS.TypedError('Runtime', 'Firmware binary is too small');
-  }
-  const firmwareBuffer = Buffer.from(binaryArrayBuffer);
-  const {
-    version: binaryVersion
-  } = parseFirmwareHeaders(firmwareBuffer);
-  return {
-    binary: binaryArrayBuffer,
-    binaryVersion,
-    release
-  };
-};
-export const getBinaryOptional = async params => {
-  try {
-    return await getBinary(params);
-  } catch {
-    return null;
-  }
-};

package/lib/api/firmware/index.d.ts

@@ -1,6 +0,0 @@
-export { getBinary, getBinaryOptional } from "./getBinary.js";
-export { shouldStripFwHeaders, stripFwHeaders } from "./modifyFirmware.js";
-export { uploadFirmware } from "./uploadFirmware.js";
-export { calculateFirmwareHash } from "./calculateFirmwareHash.js";
-export { parseFirmwareHeaders } from "./parseFirmwareHeaders.js";
-export { calculateXPubHash, calculateXPubHashes, checkXPubWithHashes } from "./calculateXPubHash.js";

package/lib/api/firmware/index.js

@@ -1,6 +0,0 @@
-export { getBinary, getBinaryOptional } from "./getBinary.js";
-export { shouldStripFwHeaders, stripFwHeaders } from "./modifyFirmware.js";
-export { uploadFirmware } from "./uploadFirmware.js";
-export { calculateFirmwareHash } from "./calculateFirmwareHash.js";
-export { parseFirmwareHeaders } from "./parseFirmwareHeaders.js";
-export { calculateXPubHash, calculateXPubHashes, checkXPubWithHashes } from "./calculateXPubHash.js";

package/lib/api/firmware/modifyFirmware.d.ts

@@ -1,3 +0,0 @@
-import type { Features } from '@trezor/connect-common';
-export declare const shouldStripFwHeaders: (features: Features) => boolean;
-export declare const stripFwHeaders: (fw: ArrayBuffer) => ArrayBuffer;

package/lib/api/firmware/modifyFirmware.js

@@ -1,13 +0,0 @@
-import { getFirmwareOrBootloaderVersionArray } from "@trezor/device-utils";
-import { versionUtils } from "@trezor/utils";
-export const shouldStripFwHeaders = features => {
-  if (features.major_version === 2) return false;
-  return versionUtils.isNewerOrEqual(getFirmwareOrBootloaderVersionArray(features), [1, 8, 0]);
-};
-export const stripFwHeaders = fw => {
-  const fwView = new Uint8Array(fw);
-  if (String.fromCharCode(...Array.from(fwView.slice(0, 4))) === 'TRZR' && String.fromCharCode(...Array.from(fwView.slice(256, 260))) === 'TRZF') {
-    return fw.slice(256);
-  }
-  return fw;
-};

package/lib/api/firmware/parseFirmwareHeaders.d.ts

@@ -1,4 +0,0 @@
-import type { VersionArray } from '@trezor/utils/lib/versionUtils';
-export declare const parseFirmwareHeaders: (buff: Buffer) => {
-  version: VersionArray;
-};

package/lib/api/firmware/parseFirmwareHeaders.js

@@ -1,26 +0,0 @@
-export const parseFirmwareHeaders = buff => {
-  const vendorHeader = buff.subarray(0, 4).toString('utf8');
-  let trezorImageHeader = '';
-  let restbuff;
-  if (vendorHeader === 'TRZV') {
-    const vendorHeaderLength = buff.readUInt32LE(4);
-    trezorImageHeader = buff.subarray(vendorHeaderLength, vendorHeaderLength + 4).toString('utf8');
-    restbuff = buff.subarray(vendorHeaderLength + 4);
-  } else if (vendorHeader === 'TRZR') {
-    restbuff = buff.subarray(256 + 4);
-    trezorImageHeader = buff.subarray(256, 256 + 4).toString('utf8');
-  } else {
-    restbuff = buff.subarray(4);
-    trezorImageHeader = buff.subarray(0, 4).toString('utf8');
-  }
-  if (trezorImageHeader !== 'TRZF') {
-    throw new Error(`unexpected header ${vendorHeader}`);
-  }
-  const version_major = restbuff.readInt8(12);
-  const version_minor = restbuff.readInt8(13);
-  const version_patch = restbuff.readInt8(14);
-  const version = [version_major, version_minor, version_patch];
-  return {
-    version
-  };
-};

package/lib/api/firmware/uploadFirmware.d.ts

@@ -1,27 +0,0 @@
-import type { CoreEventMessage, FirmwareUpdateFlowType, PROTO } from '@trezor/connect-common';
-import type { TypedCall } from "../../device/DeviceCommands.js";
-import type { IDevice } from "../../types/idevice.js";
-type UploadFirmwareProps = {
-  typedCall: TypedCall;
-  postMessage: (message: CoreEventMessage) => void;
-  device: IDevice;
-  firmwareUploadRequest: PROTO.FirmwareUpload;
-  updateFlowType: FirmwareUpdateFlowType;
-};
-export declare const uploadFirmware: ({
-  typedCall,
-  postMessage,
-  device,
-  firmwareUploadRequest: {
-    payload
-  },
-  updateFlowType
-}: UploadFirmwareProps) => Promise<{
-  type: "Success";
-  message: {
-    message: string;
-  };
-} | {
-  message: string;
-}>;
-export {};

package/lib/api/firmware/uploadFirmware.js

@@ -1,99 +0,0 @@
-import { DEVICE, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
-import { getFirmwareVersionArray } from "@trezor/device-utils";
-import { TRANSPORT } from "@trezor/transport-common";
-import { isWithinRange } from "@trezor/utils/lib/versionUtils.js";
-const postConfirmationMessage = (device, updateFlowType) => {
-  const freshInstall = device.features.firmware_present === false;
-  if (freshInstall || updateFlowType === 'reboot_and_upgrade') return;
-  device.emit(DEVICE.BUTTON, {
-    device,
-    payload: {
-      code: 'ButtonRequest_FirmwareUpdate'
-    }
-  });
-};
-const postProgressMessage = (device, progress, postMessage) => {
-  postMessage(createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
-    device: device.toMessageObject(),
-    operation: 'flashing',
-    progress
-  }));
-};
-const FIRMWARE_ERASE_TIMEOUT_MILLISECONDS = 15_000;
-const TIMEOUT_MIN_FW_VERSION = '1.12.1';
-const TIMEOUT_MAX_FW_VERSION = '1.13.0';
-export const uploadFirmware = async ({
-  typedCall,
-  postMessage,
-  device,
-  firmwareUploadRequest: {
-    payload
-  },
-  updateFlowType
-}) => {
-  if (device.features.major_version === 1) {
-    postConfirmationMessage(device, updateFlowType);
-    const timeoutId = setTimeout(() => {
-      const version = getFirmwareVersionArray(device.toMessageObject());
-      if (version === null) return;
-      if (isWithinRange(version, TIMEOUT_MIN_FW_VERSION, TIMEOUT_MAX_FW_VERSION)) {
-        postMessage(createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS_UNEXPECTED_DELAY, {}));
-      }
-    }, FIRMWARE_ERASE_TIMEOUT_MILLISECONDS);
-    await typedCall('FirmwareErase', 'Success', {});
-    clearTimeout(timeoutId);
-    postProgressMessage(device, 0, postMessage);
-    let i = 0;
-    const progressTimer = setInterval(() => {
-      i++;
-      postProgressMessage(device, Math.min(i * 2, 99), postMessage);
-    }, 300);
-    const message = await typedCall('FirmwareUpload', 'Success', {
-      payload
-    }).finally(() => {
-      clearInterval(progressTimer);
-    });
-    postProgressMessage(device, 100, postMessage);
-    return message;
-  }
-  if (device.features.major_version === 2) {
-    postConfirmationMessage(device, updateFlowType);
-    const length = payload.byteLength;
-    let progress = 0;
-    let response = await typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], {
-      length
-    });
-    postMessage(createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
-      device: device.toMessageObject(),
-      operation: 'start-flashing',
-      progress
-    }));
-    while (response.type !== 'Success') {
-      const start = response.message.offset;
-      const end = response.message.offset + response.message.length;
-      const chunk = payload.slice(start, end);
-      const progressStart = Math.round(start / length * 100);
-      const progressEnd = Math.round(end / length * 100);
-      const progressDiff = progressEnd - progressStart;
-      device.transport.on(TRANSPORT.SEND_MESSAGE_PROGRESS, p => {
-        const newProgress = progressStart + Math.floor(progressDiff * p);
-        if (start > 0 && newProgress > progress) {
-          progress = newProgress;
-          postProgressMessage(device, progress, postMessage);
-        }
-      });
-      if (start > 0) {
-        postProgressMessage(device, progressStart, postMessage);
-      }
-      response = await typedCall('FirmwareUpload', ['FirmwareRequest', 'Success'], {
-        payload: chunk
-      }).finally(() => {
-        device.transport.removeAllListeners(TRANSPORT.SEND_MESSAGE_PROGRESS);
-      });
-    }
-    postProgressMessage(device, 100, postMessage);
-    return response.message;
-  }
-  throw ERRORS.TypedError('Runtime', 'uploadFirmware: unknown major_version');
-};

package/lib/api/firmware/verifyEntropy.d.ts

@@ -1,25 +0,0 @@
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-export declare const generateEntropy: (len: number) => Buffer<ArrayBuffer>;
-type VerifyEntropyOptions = {
-  type?: PROTO.Enum_BackupType;
-  strength?: number;
-  commitment?: string;
-  hostEntropy: string;
-  trezorEntropy?: string;
-  xpubs: Record<string, string>;
-};
-export declare const verifyEntropy: ({
-  type,
-  strength,
-  trezorEntropy,
-  hostEntropy,
-  commitment,
-  xpubs
-}: VerifyEntropyOptions) => Promise<{
-  success: true;
-  error?: undefined;
-} | {
-  success: false;
-  error: any;
-}>;
-export {};

package/lib/api/firmware/verifyEntropy.js

@@ -1,110 +0,0 @@
-import { hmac } from "@noble/hashes/hmac.js";
-import { sha256 } from "@noble/hashes/sha2.js";
-import { randomBytes } from "@noble/hashes/utils.js";
-import { entropyToMnemonic, mnemonicToSeed } from "@scure/bip39";
-import { bip39EnglishWordlist } from "@trezor/crypto-utils";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { bip32 } from "@trezor/utxo-lib";
-export const generateEntropy = len => {
-  try {
-    return Buffer.from(randomBytes(len));
-  } catch {
-    throw new Error('generateEntropy: Environment does not support crypto random');
-  }
-};
-const BASE_ITERATION_COUNT = 10000;
-const ROUND_COUNT = 4;
-const roundFunction = async (i, passphrase, e, salt, r) => {
-  const data = Buffer.concat([Buffer.from([i]), passphrase]);
-  const iterations = Math.floor((BASE_ITERATION_COUNT << e) / ROUND_COUNT);
-  const {
-    subtle
-  } = crypto;
-  const key = await subtle.importKey('raw', data, 'PBKDF2', false, ['deriveBits']);
-  const bits = await subtle.deriveBits({
-    name: 'PBKDF2',
-    hash: 'SHA-256',
-    salt: Buffer.concat([salt, r]),
-    iterations
-  }, key, r.length * 8);
-  return Buffer.from(bits);
-};
-const xor = (a, b) => {
-  if (a.length !== b.length) {
-    throw new Error('Buffers must be of equal length to XOR.');
-  }
-  const result = Buffer.alloc(a.length);
-  for (let i = 0; i < a.length; i++) {
-    const ai = a[i];
-    const bi = b[i];
-    result[i] = ai ^ bi;
-  }
-  return result;
-};
-const entropyToSeedSlip39 = async encryptedSecret => {
-  const iterationExponent = 1;
-  const passphrase = Buffer.from('', 'utf-8');
-  const salt = Buffer.alloc(0);
-  const half = Math.floor(encryptedSecret.length / 2);
-  let l = encryptedSecret.subarray(0, half);
-  let r = encryptedSecret.subarray(half);
-  for (let round = ROUND_COUNT - 1; round >= 0; round--) {
-    const f = await roundFunction(round, passphrase, iterationExponent, salt, r);
-    const rr = xor(l, f);
-    l = r;
-    r = rr;
-  }
-  return Buffer.concat([r, l]);
-};
-const getEntropy = (trezorEntropy, hostEntropy, strength) => {
-  const data = Buffer.concat([Buffer.from(trezorEntropy, 'hex'), Buffer.from(hostEntropy, 'hex')]);
-  const entropy = sha256(data);
-  return Buffer.from(entropy.subarray(0, Math.floor(strength / 8)));
-};
-const computeSeed = (type, secret) => {
-  const BackupType = PROTO.Enum_BackupType;
-  if (type && [BackupType.Slip39_Basic, BackupType.Slip39_Advanced, BackupType.Slip39_Single_Extendable, BackupType.Slip39_Basic_Extendable, BackupType.Slip39_Advanced_Extendable].includes(type)) {
-    return entropyToSeedSlip39(secret);
-  }
-  return mnemonicToSeed(entropyToMnemonic(secret, [...bip39EnglishWordlist])).then(seed => Buffer.from(seed));
-};
-const verifyCommitment = (entropy, commitment) => {
-  const hmacDigest = hmac(sha256, Buffer.from(entropy, 'hex'), Buffer.alloc(0));
-  if (!Buffer.from(hmacDigest).equals(Buffer.from(commitment, 'hex'))) {
-    throw new Error('Invalid entropy commitment');
-  }
-};
-export const verifyEntropy = async ({
-  type,
-  strength,
-  trezorEntropy,
-  hostEntropy,
-  commitment,
-  xpubs
-}) => {
-  try {
-    if (!trezorEntropy || !commitment || !strength || Object.keys(xpubs).length < 1) {
-      throw new Error('Missing verifyEntropy data');
-    }
-    verifyCommitment(trezorEntropy, commitment);
-    const secret = getEntropy(trezorEntropy, hostEntropy, strength);
-    const seed = await computeSeed(type, secret);
-    const node = bip32.fromSeed(seed);
-    Object.keys(xpubs).forEach(path => {
-      const pubKey = node.derivePath(path);
-      const xpub = pubKey.neutered().toBase58();
-      const expectedXpub = xpubs[path];
-      if (xpub !== expectedXpub) {
-        throw new Error('verifyEntropy xpub mismatch');
-      }
-    });
-    return {
-      success: true
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error.message
-    };
-  }
-};

package/lib/api/getAccountInfo.d.ts

@@ -1,21 +0,0 @@
-import type { AccountInfo, CoinInfo, GetAccountInfo as GetAccountInfoParams, PermissionRequest } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage } from "../core/AbstractMethod.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-type Request = GetAccountInfoParams & {
-  address_n: number[];
-  coinInfo: CoinInfo;
-};
-export default class GetAccountInfo extends AbstractMethod<'getAccountInfo', Request[]> {
-  disposed: boolean;
-  hasBundle?: boolean;
-  constructor(message: MethodMessage<'getAccountInfo'>);
-  get requiredPermissions(): PermissionRequest[];
-  get info(): string;
-  get confirmation(): {
-    view: "export-account-info";
-    label: string;
-  };
-  run(context: MethodContext): Promise<AccountInfo | (AccountInfo | null)[]>;
-  dispose(): void;
-}
-export {};