@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/api/getPublicKey.mjs

@@ -0,0 +1,88 @@
+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 { getBitcoinNetwork } from "../data/coinInfo.mjs";
+import { bundlify, validateCoinPath } from "./common/paramsValidator.mjs";
+import { getPublicKeyLabel } from "../utils/accountUtils.mjs";
+import { validatePath } from "../utils/pathUtils.mjs";
+export default class GetPublicKey extends AbstractMethod {
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(GetPublicKeySchema), payload);
+    const params = payload.bundle.map(batch => {
+      let coinInfo;
+      if (batch.coin) {
+        coinInfo = getBitcoinNetwork(batch.coin);
+      }
+      const address_n = validatePath(batch.path, coinInfo ? 3 : 0);
+      if (coinInfo && !batch.crossChain) {
+        validateCoinPath(address_n, coinInfo);
+      } else if (!coinInfo) {
+        coinInfo = getBitcoinNetwork(address_n);
+      }
+      const proto = {
+        address_n,
+        coin_name: coinInfo?.name,
+        show_display: batch.showOnTrezor,
+        script_type: batch.scriptType,
+        ignore_xpub_magic: batch.ignoreXpubMagic,
+        ecdsa_curve_name: batch.ecdsaCurveName
+      };
+      return {
+        proto,
+        coinInfo,
+        unlockPath: batch.unlockPath,
+        suppressBackupWarning: batch.suppressBackupWarning
+      };
+    });
+    super(message, params);
+    this.requiredFirmwareCoins = params.map(({
+      coinInfo
+    }) => coinInfo);
+    this.hasBundle = hasBundle;
+    this.confirmMissingBackup = !this.params.every(batch => batch.suppressBackupWarning || !batch.proto.show_display);
+  }
+  hasBundle;
+  get requiredPermissions() {
+    return ['read'];
+  }
+  get info() {
+    return 'Export public key';
+  }
+  get confirmation() {
+    return {
+      view: 'export-xpub',
+      label: this.params.length > 1 ? 'Export multiple public keys' : getPublicKeyLabel(this.params[0].proto.address_n, this.params[0].coinInfo)
+    };
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const responses = [];
+    const cmd = this.getDevice().getCommands();
+    for (let i = 0; i < this.params.length; i++) {
+      const {
+        coinInfo,
+        unlockPath,
+        proto
+      } = this.params[i];
+      const coinInfoFallback = coinInfo ?? getBitcoinNetwork('btc');
+      const response = await cmd.getHDNode(proto, {
+        coinInfo: coinInfoFallback,
+        unlockPath
+      });
+      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/getSettings.d.mts

@@ -0,0 +1,8 @@
+import { type MethodPermission } from '@trezor/connect-common';
+import type { MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+export default class GetSettings extends AbstractMethod<'getSettings'> {
+    constructor(message: MethodMessage<'getSettings'>);
+    get requiredPermissions(): MethodPermission[];
+    run(): Promise<import("@trezor/connect-common").ConnectSettings>;
+}

package/libESM/api/getSettings.mjs

@@ -0,0 +1,15 @@
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+import * as settingsStore from "../data/settingsStore.mjs";
+export default class GetSettings extends AbstractMethod {
+  constructor(message) {
+    super(message, undefined);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return ['management'];
+  }
+  run() {
+    return Promise.resolve(settingsStore.get());
+  }
+}

package/libESM/api/index.d.mts

@@ -0,0 +1,59 @@
+export { default as applyFlags } from './applyFlags';
+export { default as applySettings } from './applySettings';
+export { default as authenticateDevice } from './authenticateDevice';
+export { default as authorizeCoinjoin } from './authorizeCoinjoin';
+export { default as cancelCoinjoinAuthorization } from './cancelCoinjoinAuthorization';
+export { default as showDeviceTutorial } from './showDeviceTutorial';
+export { default as backupDevice } from './backupDevice';
+export { default as bleUnpair } from './bleUnpair';
+export { default as blockchainDisconnect } from './blockchainDisconnect';
+export { default as blockchainEstimateFee } from './blockchainEstimateFee';
+export { default as blockchainGetAccountBalanceHistory } from './blockchainGetAccountBalanceHistory';
+export { default as blockchainGetCurrentFiatRates } from './blockchainGetCurrentFiatRates';
+export { default as blockchainGetContractInfo } from './blockchainGetContractInfo';
+export { default as blockchainGetInfo } from './blockchainGetInfo';
+export { default as blockchainEvmRpcCall } from './blockchainEvmRpcCall';
+export { default as blockchainGetFiatRatesForTimestamps } from './blockchainGetFiatRatesForTimestamps';
+export { default as blockchainGetTransactions } from './blockchainGetTransactions';
+export { default as blockchainSetCustomBackend } from './blockchainSetCustomBackend';
+export { default as blockchainSubscribe } from './blockchainSubscribe';
+export { default as blockchainSubscribeFiatRates } from './blockchainSubscribeFiatRates';
+export { default as blockchainUnsubscribe } from './blockchainUnsubscribe';
+export { default as blockchainUnsubscribeFiatRates } from './blockchainUnsubscribeFiatRates';
+export { default as blockchainValidateEvmRpcUrl } from './blockchainValidateEvmRpcUrl';
+export { default as changeLanguage } from './changeLanguage';
+export { default as changePin } from './changePin';
+export { default as changeWipeCode } from './changeWipeCode';
+export { default as cipherKeyValue } from './cipherKeyValue';
+export { default as evoluGetNode } from './evoluGetNode';
+export { default as evoluSignRegistrationRequest } from './evoluSignRegistrationRequest';
+export { default as evoluGetDelegatedIdentityKey } from './evoluGetDelegatedIdentityKey';
+export { default as composeTransaction } from './composeTransaction';
+export { default as discoverAccounts } from './discoverAccounts';
+export { default as getAccountInfo } from './getAccountInfo';
+export { default as getAddress } from './getAddress';
+export { default as getCoinInfo } from './getCoinInfo';
+export { default as getDeviceState } from './getDeviceState';
+export { default as getFeatures } from './getFeatures';
+export { default as getFirmwareHash } from './getFirmwareHash';
+export { default as getNonce } from './getNonce';
+export { default as getOwnershipId } from './getOwnershipId';
+export { default as getOwnershipProof } from './getOwnershipProof';
+export { default as getPublicKey } from './getPublicKey';
+export { default as getSettings } from './getSettings';
+export { default as pingDevice } from './pingDevice';
+export { default as pushTransaction } from './pushTransaction';
+export { default as recoveryDevice } from './recoveryDevice';
+export { default as requestLogin } from './requestLogin';
+export { default as resetDevice } from './resetDevice';
+export { default as loadDevice } from './loadDevice';
+export { default as setBrightness } from './setBrightness';
+export { default as setBusy } from './setBusy';
+export { default as signMessage } from './signMessage';
+export { default as signTransaction } from './signTransaction';
+export { default as unlockPath } from './unlockPath';
+export { default as telemetryGet } from './telemetryGet';
+export { default as thpGetCredentials } from './thpGetCredentials';
+export { default as thpRemoveCredentials } from './thpRemoveCredentials';
+export { default as verifyMessage } from './verifyMessage';
+export { default as wipeDevice } from './wipeDevice';

package/libESM/api/index.mjs

@@ -0,0 +1,59 @@
+export { default as applyFlags } from "./applyFlags.mjs";
+export { default as applySettings } from "./applySettings.mjs";
+export { default as authenticateDevice } from "./authenticateDevice.mjs";
+export { default as authorizeCoinjoin } from "./authorizeCoinjoin.mjs";
+export { default as cancelCoinjoinAuthorization } from "./cancelCoinjoinAuthorization.mjs";
+export { default as showDeviceTutorial } from "./showDeviceTutorial.mjs";
+export { default as backupDevice } from "./backupDevice.mjs";
+export { default as bleUnpair } from "./bleUnpair.mjs";
+export { default as blockchainDisconnect } from "./blockchainDisconnect.mjs";
+export { default as blockchainEstimateFee } from "./blockchainEstimateFee.mjs";
+export { default as blockchainGetAccountBalanceHistory } from "./blockchainGetAccountBalanceHistory.mjs";
+export { default as blockchainGetCurrentFiatRates } from "./blockchainGetCurrentFiatRates.mjs";
+export { default as blockchainGetContractInfo } from "./blockchainGetContractInfo.mjs";
+export { default as blockchainGetInfo } from "./blockchainGetInfo.mjs";
+export { default as blockchainEvmRpcCall } from "./blockchainEvmRpcCall.mjs";
+export { default as blockchainGetFiatRatesForTimestamps } from "./blockchainGetFiatRatesForTimestamps.mjs";
+export { default as blockchainGetTransactions } from "./blockchainGetTransactions.mjs";
+export { default as blockchainSetCustomBackend } from "./blockchainSetCustomBackend.mjs";
+export { default as blockchainSubscribe } from "./blockchainSubscribe.mjs";
+export { default as blockchainSubscribeFiatRates } from "./blockchainSubscribeFiatRates.mjs";
+export { default as blockchainUnsubscribe } from "./blockchainUnsubscribe.mjs";
+export { default as blockchainUnsubscribeFiatRates } from "./blockchainUnsubscribeFiatRates.mjs";
+export { default as blockchainValidateEvmRpcUrl } from "./blockchainValidateEvmRpcUrl.mjs";
+export { default as changeLanguage } from "./changeLanguage.mjs";
+export { default as changePin } from "./changePin.mjs";
+export { default as changeWipeCode } from "./changeWipeCode.mjs";
+export { default as cipherKeyValue } from "./cipherKeyValue.mjs";
+export { default as evoluGetNode } from "./evoluGetNode.mjs";
+export { default as evoluSignRegistrationRequest } from "./evoluSignRegistrationRequest.mjs";
+export { default as evoluGetDelegatedIdentityKey } from "./evoluGetDelegatedIdentityKey.mjs";
+export { default as composeTransaction } from "./composeTransaction.mjs";
+export { default as discoverAccounts } from "./discoverAccounts.mjs";
+export { default as getAccountInfo } from "./getAccountInfo.mjs";
+export { default as getAddress } from "./getAddress.mjs";
+export { default as getCoinInfo } from "./getCoinInfo.mjs";
+export { default as getDeviceState } from "./getDeviceState.mjs";
+export { default as getFeatures } from "./getFeatures.mjs";
+export { default as getFirmwareHash } from "./getFirmwareHash.mjs";
+export { default as getNonce } from "./getNonce.mjs";
+export { default as getOwnershipId } from "./getOwnershipId.mjs";
+export { default as getOwnershipProof } from "./getOwnershipProof.mjs";
+export { default as getPublicKey } from "./getPublicKey.mjs";
+export { default as getSettings } from "./getSettings.mjs";
+export { default as pingDevice } from "./pingDevice.mjs";
+export { default as pushTransaction } from "./pushTransaction.mjs";
+export { default as recoveryDevice } from "./recoveryDevice.mjs";
+export { default as requestLogin } from "./requestLogin.mjs";
+export { default as resetDevice } from "./resetDevice.mjs";
+export { default as loadDevice } from "./loadDevice.mjs";
+export { default as setBrightness } from "./setBrightness.mjs";
+export { default as setBusy } from "./setBusy.mjs";
+export { default as signMessage } from "./signMessage.mjs";
+export { default as signTransaction } from "./signTransaction.mjs";
+export { default as unlockPath } from "./unlockPath.mjs";
+export { default as telemetryGet } from "./telemetryGet.mjs";
+export { default as thpGetCredentials } from "./thpGetCredentials.mjs";
+export { default as thpRemoveCredentials } from "./thpRemoveCredentials.mjs";
+export { default as verifyMessage } from "./verifyMessage.mjs";
+export { default as wipeDevice } from "./wipeDevice.mjs";

package/libESM/api/loadDevice.d.mts

@@ -0,0 +1,16 @@
+import { type MethodPermission } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+export default class LoadDevice extends AbstractMethod<'loadDevice', PROTO.LoadDevice> {
+    constructor(message: MethodMessage<'loadDevice'>);
+    get requiredPermissions(): MethodPermission[];
+    get info(): string;
+    get confirmation(): {
+        view: "device-management";
+        label: string;
+    };
+    run(): Promise<{
+        message: string;
+    }>;
+}

package/libESM/api/loadDevice.mjs

@@ -0,0 +1,44 @@
+import { UI_REQUEST } from "@trezor/connect-common";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+export default class LoadDevice extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(PROTO.LoadDevice, payload);
+    const params = {
+      mnemonics: payload.mnemonics,
+      pin: payload.pin,
+      passphrase_protection: payload.passphrase_protection,
+      language: payload.language,
+      label: payload.label,
+      skip_checksum: payload.skip_checksum,
+      u2f_counter: payload.u2f_counter,
+      needs_backup: payload.needs_backup,
+      no_backup: payload.no_backup
+    };
+    super(message, params);
+    this.allowDeviceMode = [UI_REQUEST.INITIALIZE];
+    this.useDeviceState = false;
+    this.skipFinalReload = false;
+  }
+  get requiredPermissions() {
+    return ['management'];
+  }
+  get info() {
+    return 'Load seed and related internal settings.';
+  }
+  get confirmation() {
+    return {
+      view: 'device-management',
+      label: 'Do you really you want to load device?'
+    };
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('LoadDevice', 'Success', this.params);
+    return response.message;
+  }
+}

package/libESM/api/monero/api/index.d.mts

@@ -0,0 +1,4 @@
+export { default as moneroGetAddress } from './moneroGetAddress';
+export { default as moneroGetWatchKey } from './moneroGetWatchKey';
+export { default as moneroKeyImageSync } from './moneroKeyImageSync';
+export { default as moneroSignTransaction } from './moneroSignTransaction';

package/libESM/api/monero/api/index.mjs

@@ -0,0 +1,4 @@
+export { default as moneroGetAddress } from "./moneroGetAddress.mjs";
+export { default as moneroGetWatchKey } from "./moneroGetWatchKey.mjs";
+export { default as moneroKeyImageSync } from "./moneroKeyImageSync.mjs";
+export { default as moneroSignTransaction } from "./moneroSignTransaction.mjs";

package/libESM/api/monero/api/moneroGetAddress.d.mts

@@ -0,0 +1,30 @@
+import { type MethodPermission } from '@trezor/connect-common';
+import type { Address } from '@trezor/connect-common/libESM/types/params';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from '../../../core/AbstractMethod';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+type Params = {
+    proto: PROTO.MoneroGetAddress;
+    address?: string;
+};
+export default class MoneroGetAddress extends AbstractMethod<'moneroGetAddress', Params[]> {
+    hasBundle?: boolean;
+    progress: number;
+    constructor(message: MethodMessage<'moneroGetAddress'>);
+    get requiredPermissions(): MethodPermission[];
+    get info(): string;
+    getButtonRequestData(code: string): {
+        type: "address";
+        serializedPath: string;
+        address: string;
+    } | undefined;
+    get confirmation(): {
+        view: "export-address";
+        label: string;
+    };
+    _call({ proto }: Params): Promise<{
+        address: string;
+    }>;
+    run(): Promise<Address | Address[]>;
+}
+export {};

package/libESM/api/monero/api/moneroGetAddress.mjs

@@ -0,0 +1,109 @@
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { getMiscNetwork } from "../../../data/coinInfo.mjs";
+import { HD_HARDENED, getSerializedPath, validatePath } from "../../../utils/pathUtils.mjs";
+import { bundlify } from "../../common/paramsValidator.mjs";
+export default class MoneroGetAddress extends AbstractMethod {
+  hasBundle;
+  progress = 0;
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    const params = payload.bundle.map(batch => {
+      const path = validatePath(batch.path, 3);
+      const allHardened = path.every(component => (component & HD_HARDENED) !== 0);
+      if (!allHardened) {
+        throw ERRORS.TypedError('Method_InvalidParameter', `Monero requires all path components to be hardened. Use m/44'/128'/0' format.`);
+      }
+      const proto = {
+        address_n: path,
+        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+        network_type: batch.networkType || PROTO.MoneroNetworkType.MAINNET,
+        account: batch.account,
+        minor: batch.minor,
+        payment_id: batch.paymentId,
+        chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false
+      };
+      return {
+        proto,
+        address: batch.address
+      };
+    });
+    super(message, params);
+    this.hasBundle = hasBundle;
+    this.useUi = this.getUseUi(this.params, payload.useEventListener);
+    this.confirmMissingBackup = true;
+    this.requiredDeviceCapabilities = ['Capability_Monero'];
+    this.requiredFirmwareCoins = [getMiscNetwork('Monero')];
+  }
+  get requiredPermissions() {
+    return ['read'];
+  }
+  get info() {
+    return 'Export Monero address';
+  }
+  getButtonRequestData(code) {
+    if (code === 'ButtonRequest_Address') {
+      const {
+        proto,
+        address
+      } = this.params[this.progress];
+      return {
+        type: 'address',
+        serializedPath: getSerializedPath(proto.address_n),
+        address: address || 'not-set'
+      };
+    }
+  }
+  get confirmation() {
+    return {
+      view: 'export-address',
+      label: this.info
+    };
+  }
+  async _call({
+    proto
+  }) {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('MoneroGetAddress', 'MoneroAddress', proto);
+    const addressHex = response.message.address;
+    const addressBytes = Buffer.from(addressHex, 'hex');
+    const address = addressBytes.toString('utf8');
+    return {
+      address
+    };
+  }
+  async run() {
+    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 (batch.address !== silent.address) {
+            throw ERRORS.TypedError('Method_AddressNotMatch');
+          }
+        } else {
+          batch.address = silent.address;
+        }
+      }
+      const response = await this._call(batch);
+      responses.push({
+        address: response.address,
+        path: batch.proto.address_n,
+        serializedPath: getSerializedPath(batch.proto.address_n)
+      });
+      this.progress++;
+    }
+    return this.hasBundle ? responses : responses[0];
+  }
+}

package/libESM/api/monero/api/moneroGetWatchKey.d.mts

@@ -0,0 +1,14 @@
+import type { MethodPermission, MoneroWatchKey } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from '../../../core/AbstractMethod';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+type Params = {
+    proto: PROTO.MoneroGetWatchKey;
+};
+export default class MoneroGetWatchKeyMethod extends AbstractMethod<'moneroGetWatchKey', Params> {
+    constructor(message: MethodMessage<'moneroGetWatchKey'>);
+    get requiredPermissions(): MethodPermission[];
+    get info(): string;
+    run(): Promise<MoneroWatchKey>;
+}
+export {};

package/libESM/api/monero/api/moneroGetWatchKey.mjs

@@ -0,0 +1,44 @@
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { getMiscNetwork } from "../../../data/coinInfo.mjs";
+import { HD_HARDENED, validatePath } from "../../../utils/pathUtils.mjs";
+export default class MoneroGetWatchKeyMethod extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    const path = validatePath(payload.path, 3);
+    const allHardened = path.every(component => (component & HD_HARDENED) !== 0);
+    if (!allHardened) {
+      throw ERRORS.TypedError('Method_InvalidParameter', `Monero requires all path components to be hardened. Use m/44'/128'/0' format.`);
+    }
+    const proto = {
+      address_n: path,
+      network_type: payload.networkType || PROTO.MoneroNetworkType.MAINNET
+    };
+    const params = {
+      proto
+    };
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Monero'];
+    this.requiredFirmwareCoins = [getMiscNetwork('Monero')];
+  }
+  get requiredPermissions() {
+    return ['read'];
+  }
+  get info() {
+    return 'Export Monero watch-only credentials';
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('MoneroGetWatchKey', 'MoneroWatchKey', this.params.proto);
+    const addressHex = response.message.address;
+    const addressBytes = Buffer.from(addressHex, 'hex');
+    const address = addressBytes.toString('utf8');
+    return {
+      watch_key: response.message.watch_key,
+      address
+    };
+  }
+}

package/libESM/api/monero/api/moneroKeyImageSync.d.mts

@@ -0,0 +1,17 @@
+import type { MethodPermission, MoneroKeyImageSyncResult } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from '../../../core/AbstractMethod';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+type Params = {
+    address_n: number[];
+    network_type: PROTO.MoneroNetworkType;
+    subs: PROTO.MoneroSubAddressIndicesList[];
+    tdis: PROTO.MoneroTransferDetails[];
+};
+export default class MoneroKeyImageSyncMethod extends AbstractMethod<'moneroKeyImageSync', Params> {
+    constructor(message: MethodMessage<'moneroKeyImageSync'>);
+    get requiredPermissions(): MethodPermission[];
+    get info(): string;
+    run(): Promise<MoneroKeyImageSyncResult>;
+}
+export {};

package/libESM/api/monero/api/moneroKeyImageSync.mjs

@@ -0,0 +1,127 @@
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import { hexToBytes } from "@noble/hashes/utils.js";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { getMiscNetwork } from "../../../data/coinInfo.mjs";
+import { HD_HARDENED, validatePath } from "../../../utils/pathUtils.mjs";
+function encodeVarint(n) {
+  const bytes = [];
+  while (n >= 0x80) {
+    bytes.push(n & 0x7f | 0x80);
+    n >>= 7;
+  }
+  bytes.push(n & 0x7f);
+  return new Uint8Array(bytes);
+}
+export default class MoneroKeyImageSyncMethod extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    const path = validatePath(payload.path, 3);
+    const allHardened = path.every(component => (component & HD_HARDENED) !== 0);
+    if (!allHardened) {
+      throw ERRORS.TypedError('Method_InvalidParameter', `Monero requires all path components to be hardened. Use m/44'/128'/0' format.`);
+    }
+    if (!payload.tdis || payload.tdis.length === 0) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'tdis (transfer details) array is required and cannot be empty');
+    }
+    const tdis = payload.tdis.map((tdi, index) => {
+      if (tdi.out_key.length !== 64) {
+        throw ERRORS.TypedError('Method_InvalidParameter', `Invalid out_key length at index ${index}: expected 64 hex characters, got ${tdi.out_key.length}`);
+      }
+      if (tdi.tx_pub_key.length !== 64) {
+        throw ERRORS.TypedError('Method_InvalidParameter', `Invalid tx_pub_key length at index ${index}: expected 64 hex characters, got ${tdi.tx_pub_key.length}`);
+      }
+      let additionalKeys = [];
+      const addlKeys = tdi.additional_tx_pub_keys;
+      if (addlKeys) {
+        if (Array.isArray(addlKeys)) {
+          additionalKeys = addlKeys;
+        } else if (typeof addlKeys === 'string') {
+          const trimmed = addlKeys.trim();
+          if (trimmed) {
+            additionalKeys = trimmed.split(',').map(k => k.trim());
+          }
+        }
+      }
+      additionalKeys.forEach((key, keyIndex) => {
+        if (key && key.length !== 64) {
+          throw ERRORS.TypedError('Method_InvalidParameter', `Invalid additional_tx_pub_keys[${keyIndex}] length at tdi index ${index}: expected 64 hex characters, got ${key.length}`);
+        }
+      });
+      return {
+        out_key: hexToBytes(tdi.out_key),
+        tx_pub_key: hexToBytes(tdi.tx_pub_key),
+        additional_tx_pub_keys: additionalKeys.map(k => hexToBytes(k)),
+        internal_output_index: tdi.internal_output_index,
+        sub_addr_major: tdi.sub_addr_major,
+        sub_addr_minor: tdi.sub_addr_minor
+      };
+    });
+    const params = {
+      address_n: path,
+      network_type: payload.networkType || PROTO.MoneroNetworkType.MAINNET,
+      subs: payload.subs || [],
+      tdis
+    };
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Monero'];
+    this.requiredFirmwareCoins = [getMiscNetwork('Monero')];
+  }
+  get requiredPermissions() {
+    return ['read'];
+  }
+  get info() {
+    return 'Export Monero key images for spent output tracking';
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const tdHashes = [];
+    for (const tdi of this.params.tdis) {
+      const kck = keccak_256.create();
+      kck.update(tdi.out_key);
+      kck.update(tdi.tx_pub_key);
+      if (tdi.additional_tx_pub_keys && tdi.additional_tx_pub_keys.length > 0) {
+        for (const addKey of tdi.additional_tx_pub_keys) {
+          kck.update(addKey);
+        }
+      }
+      const indexVarint = encodeVarint(tdi.internal_output_index);
+      kck.update(indexVarint);
+      tdHashes.push(kck.digest());
+    }
+    const finalKck = keccak_256.create();
+    for (const hash of tdHashes) {
+      finalKck.update(hash);
+    }
+    const hashBytes = finalKck.digest();
+    const numOutputs = this.params.tdis.length;
+    await cmd.typedCall('MoneroKeyImageExportInitRequest', 'MoneroKeyImageExportInitAck', {
+      num: numOutputs,
+      hash: hashBytes,
+      address_n: this.params.address_n,
+      network_type: this.params.network_type,
+      subs: this.params.subs
+    });
+    const allKeyImages = [];
+    const stepResponse = await cmd.typedCall('MoneroKeyImageSyncStepRequest', 'MoneroKeyImageSyncStepAck', {
+      tdis: this.params.tdis
+    });
+    allKeyImages.push(...stepResponse.message.kis);
+    const finalResponse = await cmd.typedCall('MoneroKeyImageSyncFinalRequest', 'MoneroKeyImageSyncFinalAck', {});
+    const encKey = finalResponse.message.enc_key;
+    if (!encKey) {
+      throw ERRORS.TypedError('Runtime', 'Device did not return encryption key for key images');
+    }
+    const keyImages = allKeyImages.map(ki => ({
+      iv: ki.iv || '',
+      key_image: ki.blob || ''
+    }));
+    return {
+      key_images: keyImages,
+      signature: encKey
+    };
+  }
+}