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

package/lib/api/index.js

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

package/lib/api/loadDevice.d.ts

@@ -0,0 +1,16 @@
+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 LoadDevice extends AbstractMethod<'loadDevice', PROTO.LoadDevice> {
+  constructor(message: MethodMessage<'loadDevice'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  get confirmation(): {
+    view: "device-management";
+    label: string;
+  };
+  run(): Promise<{
+    message: string;
+  }>;
+}

package/lib/api/loadDevice.js

@@ -0,0 +1,46 @@
+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.js";
+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 [{
+      permission: '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/lib/api/monero/api/index.d.ts

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

package/lib/api/monero/api/index.js

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

package/lib/api/monero/api/moneroGetAddress.d.ts

@@ -0,0 +1,32 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { Address } from '@trezor/connect-common/lib/types/params';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+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(): PermissionRequest[];
+  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/lib/api/monero/api/moneroGetAddress.js

@@ -0,0 +1,117 @@
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { HD_HARDENED_PATH_PART } from "@trezor/crypto-utils";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { getSerializedPath, validatePath } from "../../../utils/pathUtils.js";
+import { bundlify } from "../../common/paramsValidator.js";
+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_PATH_PART) !== 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.confirmMissingBackup = true;
+    this.requiredDeviceCapabilities = ['Capability_Monero'];
+    this.requiredFirmwareCoins = [getMiscNetwork('xmr')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_address', this.requiredFirmwareCoins);
+  }
+  get info() {
+    return 'Export Monero address';
+  }
+  getButtonRequestData(code) {
+    if (code === 'ButtonRequest_Address') {
+      const {
+        params
+      } = this;
+      const current = params[this.progress];
+      const {
+        proto,
+        address
+      } = current;
+      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 {
+        params
+      } = this;
+      const batch = 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++;
+    }
+    const first = responses[0];
+    return this.hasBundle ? responses : first;
+  }
+}

package/lib/api/monero/api/moneroGetWatchKey.d.ts

@@ -0,0 +1,14 @@
+import type { MoneroWatchKey, 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";
+type Params = {
+  proto: PROTO.MoneroGetWatchKey;
+};
+export default class MoneroGetWatchKeyMethod extends AbstractMethod<'moneroGetWatchKey', Params> {
+  constructor(message: MethodMessage<'moneroGetWatchKey'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<MoneroWatchKey>;
+}
+export {};

package/lib/api/monero/api/moneroGetWatchKey.js

@@ -0,0 +1,45 @@
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { HD_HARDENED_PATH_PART } from "@trezor/crypto-utils";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { validatePath } from "../../../utils/pathUtils.js";
+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_PATH_PART) !== 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('xmr')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_xpub', this.requiredFirmwareCoins);
+  }
+  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/lib/api/monero/api/moneroKeyImageSync.d.ts

@@ -0,0 +1,17 @@
+import type { MoneroKeyImageSyncResult, 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";
+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(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<MoneroKeyImageSyncResult>;
+}
+export {};

package/lib/api/monero/api/moneroKeyImageSync.js

@@ -0,0 +1,128 @@
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import { hexToBytes } from "@noble/hashes/utils.js";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { HD_HARDENED_PATH_PART } from "@trezor/crypto-utils";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { validatePath } from "../../../utils/pathUtils.js";
+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_PATH_PART) !== 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('xmr')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_account_info', this.requiredFirmwareCoins);
+  }
+  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
+    };
+  }
+}

package/lib/api/monero/api/moneroSignTransaction.d.ts

@@ -0,0 +1,17 @@
+import type { PROTO, PermissionRequest } from '@trezor/connect-common';
+import type { MethodMessage, MethodReturnType } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+type Params = {
+  address_n: number[];
+  network_type: PROTO.MoneroNetworkType;
+  tsx_data: PROTO.MoneroTransactionData;
+  inputs: PROTO.MoneroTransactionSourceEntry[];
+};
+export default class MoneroSignTransactionMethod extends AbstractMethod<'moneroSignTransaction', Params> {
+  get requiredPermissions(): PermissionRequest[];
+  private state;
+  constructor(message: MethodMessage<'moneroSignTransaction'>);
+  get info(): string;
+  run(): Promise<MethodReturnType<typeof this.name>>;
+}
+export {};