@onekeyfe/hd-core 1.2.0-alpha.56 → 1.2.0-alpha.57

package/src/api/methodExtension.ts

@@ -0,0 +1,27 @@
+import * as FactoryMethods from './factoryMethods';
+import * as TestMethods from './testMethods';
+import { FACTORY_API_METHOD_NAMES } from './extensionMethodNames';
+
+import type { BaseMethod } from './BaseMethod';
+import type { IFrameCallMessage } from '../events';
+
+export type CoreMethodConstructor = new (
+  message: IFrameCallMessage & { id?: number }
+) => BaseMethod<any>;
+
+export type CoreMethodExtension = {
+  name: string;
+  methods: Readonly<Record<string, CoreMethodConstructor>>;
+  destructiveMethods?: readonly string[];
+};
+
+export const testApiMethodExtension: CoreMethodExtension = {
+  name: 'test-api',
+  methods: TestMethods as unknown as Record<string, CoreMethodConstructor>,
+};
+
+export const factoryApiMethodExtension: CoreMethodExtension = {
+  name: 'factory-api',
+  methods: FactoryMethods as unknown as Record<string, CoreMethodConstructor>,
+  destructiveMethods: FACTORY_API_METHOD_NAMES,
+};

package/src/api/monero/MoneroGetAddress.ts

@@ -0,0 +1,64 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+import type { MoneroGetAddress as HardwareMoneroGetAddress } from '@onekeyfe/hd-transport';
+import type { MoneroAddress } from '../../types/api/moneroGetAddress';
+
+export default class MoneroGetAddress extends BaseMethod<HardwareMoneroGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: any) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  async run() {
+    const responses: MoneroAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('MoneroGetAddress', 'MoneroAddress', {
+        ...param,
+      });
+
+      const { address } = res.message;
+
+      const result = {
+        path: serializedPath(param.address_n),
+        address,
+      };
+      responses.push(result);
+
+      this.postPreviousAddressMessage(result);
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/monero/MoneroGetWatchKey.ts

@@ -0,0 +1,59 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+import type { MoneroGetAddress as HardwareMoneroGetAddress } from '@onekeyfe/hd-transport';
+
+export default class MoneroGetWatchKey extends BaseMethod<HardwareMoneroGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: any) => {
+      const addressN = validatePath(batch.path, 3);
+
+      const { network_type } = batch;
+
+      this.params.push({
+        address_n: addressN,
+        network_type,
+      });
+    });
+  }
+
+  async run() {
+    const responses: any[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('MoneroGetWatchKey', 'MoneroWatchKey', {
+        ...param,
+      });
+
+      const { address, watch_key } = res.message;
+
+      const result = {
+        path: serializedPath(param.address_n),
+        address,
+        watch_key,
+      };
+      responses.push(result);
+
+      this.postPreviousAddressMessage(result);
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/nem/NEMDecryptMessage.ts

@@ -0,0 +1,29 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+
+import type { NEMDecryptMessage as HardwareNEMDecryptMessage } from '@onekeyfe/hd-transport';
+
+const MAINNET = 0x68; // 104
+
+export default class NEMDecryptMessage extends BaseMethod<HardwareNEMDecryptMessage> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.params = {
+      address_n: validatePath(this.payload.path, 3),
+      network: this.payload.network ?? MAINNET,
+      public_key: this.payload.public_key,
+      payload: this.payload.payload,
+    };
+  }
+
+  async run() {
+    return this.device.commands.typedCall('NEMDecryptMessage', 'NEMDecryptedMessage', {
+      ...this.params,
+    });
+  }
+}

package/src/api/protocol-v2/DeviceFactoryCertificateRead.ts

@@ -0,0 +1,25 @@
+import { BaseMethod } from '../BaseMethod';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+export default class DeviceFactoryCertificateRead extends BaseMethod {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.unlockPolicy = 'none';
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.params = undefined;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'DeviceCertificateRead',
+      'DeviceCertificate',
+      {}
+    );
+    return res.message;
+  }
+}

package/src/api/protocol-v2/DeviceFactoryCertificateWrite.ts

@@ -0,0 +1,30 @@
+import { BaseMethod } from '../BaseMethod';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validateDeviceFactoryCertificateWriteParams } from './helpers';
+
+import type { DeviceFactoryCertificateWriteParams } from './helpers';
+
+export default class DeviceFactoryCertificateWrite extends BaseMethod<DeviceFactoryCertificateWriteParams> {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.unlockPolicy = 'none';
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.requireDeviceMode = [UI_REQUEST.BOOTLOADER];
+    this.params = validateDeviceFactoryCertificateWriteParams(this.payload);
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('DeviceCertificateWrite', 'Success', {
+      cert: {
+        cert_and_pubkey: this.params.certificate,
+        private_key: this.params.privateKey,
+      },
+    });
+    return res.message;
+  }
+}

package/src/api/protocol-v2/DeviceFactoryChallengeSign.ts

@@ -0,0 +1,28 @@
+import { BaseMethod } from '../BaseMethod';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validateDeviceFactoryChallengeSignParams } from './helpers';
+
+import type { DeviceFactoryChallengeSignParams } from './helpers';
+
+export default class DeviceFactoryChallengeSign extends BaseMethod<DeviceFactoryChallengeSignParams> {
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.unlockPolicy = 'none';
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.params = validateDeviceFactoryChallengeSignParams(this.payload);
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'DeviceCertificateSign',
+      'DeviceCertificateSignature',
+      { data: this.params.digest }
+    );
+    return res.message;
+  }
+}

package/src/api/protocol-v2/DeviceFactoryInfoGet.ts

@@ -1,4 +1,5 @@
 import { BaseMethod } from '../BaseMethod';
+import { UI_REQUEST } from '../../constants/ui-request';
 
 export default class DeviceFactoryInfoGet extends BaseMethod {
   getSupportedProtocols() {
@@ -9,6 +10,8 @@ export default class DeviceFactoryInfoGet extends BaseMethod {
     // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
+    this.unlockPolicy = 'none';
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
     this.params = undefined;
   }
 

package/src/api/protocol-v2/DeviceFactoryInfoSet.ts

@@ -1,4 +1,6 @@
 import { BaseMethod } from '../BaseMethod';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validateDeviceFactoryInfoSetParams } from './helpers';
 
 import type { DeviceFactoryInfoSetParams } from './helpers';
 
@@ -11,13 +13,10 @@ export default class DeviceFactoryInfoSet extends BaseMethod<DeviceFactoryInfoSe
     // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
-    this.params = {
-      version: this.payload.version,
-      serial_number: this.payload.serial_number,
-      burn_in_completed: this.payload.burn_in_completed,
-      factory_test_completed: this.payload.factory_test_completed,
-      manufacture_time: this.payload.manufacture_time,
-    };
+    this.unlockPolicy = 'none';
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.requireDeviceMode = [UI_REQUEST.BOOTLOADER];
+    this.params = validateDeviceFactoryInfoSetParams(this.payload);
   }
 
   async run() {

package/src/api/protocol-v2/helpers.ts

@@ -37,11 +37,11 @@ export type DeviceFirmwareUpdateStatusGetParams = {
 };
 
 export type DeviceFactoryInfoSetParams = {
-  version?: number;
-  serial_number?: string;
-  burn_in_completed?: boolean;
-  factory_test_completed?: boolean;
-  manufacture_time?: {
+  version: number;
+  serial_number: string;
+  burn_in_completed: boolean;
+  factory_test_completed: boolean;
+  manufacture_time: {
     year: number;
     month: number;
     day: number;
@@ -51,6 +51,153 @@ export type DeviceFactoryInfoSetParams = {
   };
 };
 
+export type DeviceFactoryCertificateWriteParams = {
+  certificate: string;
+  privateKey?: string;
+};
+
+export type DeviceFactoryChallengeSignParams = {
+  digest: string;
+};
+
+const FACTORY_SERIAL_MAX_UTF8_BYTES = 24;
+const FACTORY_CERTIFICATE_MAX_BYTES = 512;
+const FACTORY_PRIVATE_KEY_BYTES = 32;
+const FACTORY_CHALLENGE_DIGEST_BYTES = 32;
+
+const getUtf8ByteLength = (value: string) =>
+  Array.from(value).reduce((length, character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint <= 0x7f) return length + 1;
+    if (codePoint <= 0x7ff) return length + 2;
+    if (codePoint <= 0xffff) return length + 3;
+    return length + 4;
+  }, 0);
+
+const validateRequiredBoolean = (value: unknown, name: string): boolean => {
+  if (typeof value !== 'boolean') {
+    throw invalidParameter(`Parameter [${name}] is required and must be a boolean.`);
+  }
+  return value;
+};
+
+const validateIntegerInRange = (
+  value: unknown,
+  name: string,
+  minimum: number,
+  maximum: number
+): number => {
+  if (
+    typeof value !== 'number' ||
+    !Number.isSafeInteger(value) ||
+    value < minimum ||
+    value > maximum
+  ) {
+    throw invalidParameter(
+      `Parameter [${name}] must be an integer between ${minimum} and ${maximum}.`
+    );
+  }
+  return value;
+};
+
+const validateHexBytes = (
+  value: unknown,
+  name: string,
+  options: { exactBytes?: number; maxBytes?: number }
+): string => {
+  const hex = validateNonEmptyString(value, name).trim();
+  if (!/^(?:[0-9a-fA-F]{2})+$/.test(hex)) {
+    throw invalidParameter(`Parameter [${name}] must be an even-length hexadecimal string.`);
+  }
+  const byteLength = hex.length / 2;
+  if (options.exactBytes !== undefined && byteLength !== options.exactBytes) {
+    throw invalidParameter(`Parameter [${name}] must contain exactly ${options.exactBytes} bytes.`);
+  }
+  if (options.maxBytes !== undefined && byteLength > options.maxBytes) {
+    throw invalidParameter(`Parameter [${name}] must not exceed ${options.maxBytes} bytes.`);
+  }
+  return hex;
+};
+
+export function validateDeviceFactoryInfoSetParams(
+  payload: Partial<DeviceFactoryInfoSetParams>
+): DeviceFactoryInfoSetParams {
+  const serialNumber = validateNonEmptyString(payload.serial_number, 'serial_number').trim();
+  if (getUtf8ByteLength(serialNumber) > FACTORY_SERIAL_MAX_UTF8_BYTES) {
+    throw invalidParameter(
+      `Parameter [serial_number] must not exceed ${FACTORY_SERIAL_MAX_UTF8_BYTES} UTF-8 bytes.`
+    );
+  }
+
+  const time = payload.manufacture_time;
+  if (!time || typeof time !== 'object') {
+    throw invalidParameter('Parameter [manufacture_time] is required.');
+  }
+  const manufactureTime = {
+    year: validateIntegerInRange(time.year, 'manufacture_time.year', 2000, 9999),
+    month: validateIntegerInRange(time.month, 'manufacture_time.month', 1, 12),
+    day: validateIntegerInRange(time.day, 'manufacture_time.day', 1, 31),
+    hour: validateIntegerInRange(time.hour, 'manufacture_time.hour', 0, 23),
+    minute: validateIntegerInRange(time.minute, 'manufacture_time.minute', 0, 59),
+    second: validateIntegerInRange(time.second, 'manufacture_time.second', 0, 59),
+  };
+  const normalizedDate = new Date(
+    Date.UTC(
+      manufactureTime.year,
+      manufactureTime.month - 1,
+      manufactureTime.day,
+      manufactureTime.hour,
+      manufactureTime.minute,
+      manufactureTime.second
+    )
+  );
+  if (
+    normalizedDate.getUTCFullYear() !== manufactureTime.year ||
+    normalizedDate.getUTCMonth() + 1 !== manufactureTime.month ||
+    normalizedDate.getUTCDate() !== manufactureTime.day
+  ) {
+    throw invalidParameter('Parameter [manufacture_time] must be a valid calendar date.');
+  }
+
+  return {
+    version: validateIntegerInRange(payload.version, 'version', 0, 255),
+    serial_number: serialNumber,
+    burn_in_completed: validateRequiredBoolean(payload.burn_in_completed, 'burn_in_completed'),
+    factory_test_completed: validateRequiredBoolean(
+      payload.factory_test_completed,
+      'factory_test_completed'
+    ),
+    manufacture_time: manufactureTime,
+  };
+}
+
+export function validateDeviceFactoryCertificateWriteParams(
+  payload: Partial<DeviceFactoryCertificateWriteParams>
+): DeviceFactoryCertificateWriteParams {
+  return {
+    certificate: validateHexBytes(payload.certificate, 'certificate', {
+      maxBytes: FACTORY_CERTIFICATE_MAX_BYTES,
+    }),
+    ...(payload.privateKey === undefined
+      ? {}
+      : {
+          privateKey: validateHexBytes(payload.privateKey, 'privateKey', {
+            exactBytes: FACTORY_PRIVATE_KEY_BYTES,
+          }),
+        }),
+  };
+}
+
+export function validateDeviceFactoryChallengeSignParams(
+  payload: Partial<DeviceFactoryChallengeSignParams>
+): DeviceFactoryChallengeSignParams {
+  return {
+    digest: validateHexBytes(payload.digest, 'digest', {
+      exactBytes: FACTORY_CHALLENGE_DIGEST_BYTES,
+    }),
+  };
+}
+
 const DEVICE_REBOOT_TYPES: Record<string, DeviceRebootType> = {
   Normal: DeviceRebootType.Normal,
   normal: DeviceRebootType.Normal,

package/src/api/testMethods.ts

@@ -0,0 +1,95 @@
+export { default as btcGetOwnershipId } from './btc/BTCGetOwnershipId';
+export { default as btcGetOwnershipProof } from './btc/BTCGetOwnershipProof';
+export { default as btcAuthorizeCoinJoin } from './btc/BTCAuthorizeCoinJoin';
+
+export { default as cryptoBatchGetPublickeys } from './crypto/CryptoBatchGetPublickeys';
+export { default as cryptoCipherKeyValue } from './crypto/CryptoCipherKeyValue';
+export { default as cryptoCosiCommit } from './crypto/CryptoCosiCommit';
+export { default as cryptoCosiSign } from './crypto/CryptoCosiSign';
+export { default as cryptoGetECDHSessionKey } from './crypto/CryptoGetECDHSessionKey';
+export { default as cryptoSignIdentity } from './crypto/CryptoSignIdentity';
+
+export { default as evmGetAddressTrezor } from './evmTrezor/EVMGetAddress';
+export { default as evmGetPublicKeyTrezor } from './evmTrezor/EVMGetPublicKey';
+export { default as evmSignMessageTrezor } from './evmTrezor/EVMSignMessage';
+export { default as evmSignTransactionTrezor } from './evmTrezor/EVMSignTransaction';
+export { default as evmSignTypedDataTrezor } from './evmTrezor/EVMSignTypedData';
+export { default as evmVerifyMessageTrezor } from './evmTrezor/EVMVerifyMessage';
+
+export { default as nemDecryptMessage } from './nem/NEMDecryptMessage';
+
+export { default as deviceSpiFlashWrite } from './manager/DeviceSpiFlashWrite';
+export { default as deviceSpiFlashRead } from './manager/DeviceSpiFlashRead';
+export { default as deviceInfoSettings } from './manager/DeviceInfoSettings';
+export { default as deviceGetInfo } from './manager/GetDeviceInfoSettings';
+export { default as deviceReadSEPublicCert } from './manager/DeviceReadSEPublicCert';
+export { default as deviceWriteSEPrivateKey } from './manager/DeviceWriteSEPrivateKey';
+export { default as deviceWriteSEPublicCert } from './manager/DeviceWriteSEPublicCert';
+export { default as deviceSESignMessage } from './manager/DeviceSESignMessage';
+export { default as devicePing } from './manager/DevicePing';
+export { default as deviceGetEntropy } from './manager/DeviceGetEntropy';
+export { default as deviceGetFirmwareHash } from './manager/DeviceGetFirmwareHash';
+export { default as deviceUnlockPath } from './manager/DeviceUnlockPath';
+export { default as deviceSdProtect } from './manager/DeviceSdProtect';
+export { default as deviceChangeWipeCode } from './manager/DeviceChangeWipeCode';
+export { default as deviceEndSession } from './manager/DeviceEndSession';
+export { default as deviceLoad } from './manager/DeviceLoad';
+export { default as deviceDoPreauthorized } from './manager/DeviceDoPreauthorized';
+export { default as deviceCancelAuthorization } from './manager/DeviceCancelAuthorization';
+
+export { default as emmcDirList } from './emmc/EmmcDirList';
+export { default as emmcDirMake } from './emmc/EmmcDirMake';
+export { default as emmcDirRemove } from './emmc/EmmcDirRemove';
+export { default as emmcFileDelete } from './emmc/EmmcFileDelete';
+export { default as emmcFileRead } from './emmc/EmmcFileRead';
+export { default as emmcFileWrite } from './emmc/EmmcFileWrite';
+export { default as emmcFixPermission } from './emmc/EmmcFixPermission';
+export { default as emmcPathInfo } from './emmc/EmmcPathInfo';
+
+export { default as debugLinkDecision } from './debug/DebugLinkDecision';
+export { default as debugLinkEraseSdCard } from './debug/DebugLinkEraseSdCard';
+export { default as debugLinkFlashErase } from './debug/DebugLinkFlashErase';
+export { default as debugLinkGetState } from './debug/DebugLinkGetState';
+export { default as debugLinkMemoryRead } from './debug/DebugLinkMemoryRead';
+export { default as debugLinkMemoryWrite } from './debug/DebugLinkMemoryWrite';
+export { default as debugLinkRecordScreen } from './debug/DebugLinkRecordScreen';
+export { default as debugLinkReseedRandom } from './debug/DebugLinkReseedRandom';
+export { default as debugLinkStop } from './debug/DebugLinkStop';
+export { default as debugLinkWatchLayout } from './debug/DebugLinkWatchLayout';
+
+export { default as firmwareErase } from './firmware/FirmwareErase';
+export { default as firmwareEraseEx } from './firmware/FirmwareEraseEx';
+export { default as firmwareUpdateEmmcTest } from './firmware/FirmwareUpdateEmmcTest';
+export { default as firmwareUploadTest } from './firmware/FirmwareUploadTest';
+export { default as reboot } from './firmware/Reboot';
+export { default as selfTest } from './firmware/SelfTest';
+
+export { default as tezosGetAddress } from './tezos/TezosGetAddress';
+export { default as tezosGetPublicKey } from './tezos/TezosGetPublicKey';
+export { default as tezosSignTx } from './tezos/TezosSignTx';
+
+export { default as moneroGetAddress } from './monero/MoneroGetAddress';
+export { default as moneroGetWatchKey } from './monero/MoneroGetWatchKey';
+
+export { default as eosGetPublicKey } from './eos/EosGetPublicKey';
+export { default as eosSignTx } from './eos/EosSignTx';
+
+export { default as binanceGetAddress } from './binance/BinanceGetAddress';
+export { default as binanceGetPublicKey } from './binance/BinanceGetPublicKey';
+export { default as binanceSignTx } from './binance/BinanceSignTx';
+
+export { default as webAuthnAddResidentCredential } from './WebAuthnAddResidentCredential';
+export { default as webAuthnListResidentCredentials } from './WebAuthnListResidentCredentials';
+export { default as webAuthnRemoveResidentCredential } from './WebAuthnRemoveResidentCredential';
+
+export { default as getPublicKeyMultiple } from './manager/GetPublicKeyMultiple';
+export { default as listResDir } from './manager/ListResDir';
+export { default as nftWriteData } from './manager/NFTWriteData';
+export { default as nftWriteInfo } from './manager/NFTWriteInfo';
+export { default as readSEPublicKey } from './manager/ReadSEPublicKey';
+export { default as resourceUpdate } from './manager/ResourceUpdate';
+
+export { default as bixinBackupDevice } from './BixinBackupDevice';
+export { default as bixinLoadDevice } from './BixinLoadDevice';
+export { default as bixinMessageSE } from './BixinMessageSE';
+export { default as bixinVerifyDeviceRequest } from './BixinVerifyDeviceRequest';

package/src/api/tezos/TezosGetAddress.ts

@@ -0,0 +1,64 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+import type { TezosGetAddress as HardwareTezosGetAddress } from '@onekeyfe/hd-transport';
+import type { StellarAddress } from '../../types';
+
+export default class TezosGetAddress extends BaseMethod<HardwareTezosGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: any) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  async run() {
+    const responses: StellarAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('TezosGetAddress', 'TezosAddress', {
+        ...param,
+      });
+
+      const { address } = res.message;
+
+      const result = {
+        path: serializedPath(param.address_n),
+        address,
+      };
+      responses.push(result);
+
+      this.postPreviousAddressMessage(result);
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}