@onekeyfe/hd-core 1.1.34-alpha.2 → 1.1.34-alpha.3

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

@@ -0,0 +1,203 @@
+import { DeviceRebootType } from '@onekeyfe/hd-transport';
+
+import { invalidParameter, validateNonEmptyString } from '../helpers/filesystemValidation';
+import { ProtocolV2FirmwareTargetType } from '../../protocols/protocol-v2/firmware';
+
+import type {
+  DeviceFirmwareTarget,
+  DeviceFirmwareTargetType,
+  DeviceFirmwareUpdateRecordFields,
+  TransportCallOptions,
+} from '@onekeyfe/hd-transport';
+
+export type RebootTypeInput = DeviceRebootType | keyof typeof DeviceRebootType | string | number;
+
+export type DeviceRebootParams = {
+  rebootType?: RebootTypeInput;
+  reboot_type?: RebootTypeInput;
+};
+
+export type DeviceFirmwareTargetInput =
+  | DeviceFirmwareTarget
+  | {
+      targetId?: DeviceFirmwareTargetType | string | number;
+      target_id?: DeviceFirmwareTargetType | string | number;
+      path: string;
+    };
+
+export type DeviceFirmwareUpdateParams = {
+  targets?: DeviceFirmwareTargetInput[];
+  targetId?: DeviceFirmwareTargetType | string | number;
+  target_id?: DeviceFirmwareTargetType | string | number;
+  path?: string;
+};
+
+export type DeviceFirmwareUpdateStatusGetParams = {
+  fields?: DeviceFirmwareUpdateRecordFields;
+};
+
+export type DeviceFactoryInfoSetParams = {
+  version?: number;
+  serial_number?: string;
+  burn_in_completed?: boolean;
+  factory_test_completed?: boolean;
+  manufacture_time?: {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+  };
+};
+
+const DEVICE_REBOOT_TYPES: Record<string, DeviceRebootType> = {
+  Normal: DeviceRebootType.Normal,
+  normal: DeviceRebootType.Normal,
+  Romloader: DeviceRebootType.Romloader,
+  romloader: DeviceRebootType.Romloader,
+  Boardloader: DeviceRebootType.Romloader,
+  boardloader: DeviceRebootType.Romloader,
+  Bootloader: DeviceRebootType.Bootloader,
+  bootloader: DeviceRebootType.Bootloader,
+};
+
+export const PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS: TransportCallOptions = {
+  intermediateTypes: ['DeviceFirmwareUpdateStatus'],
+};
+
+export const PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES: (
+  | 'Success'
+  | 'DeviceFirmwareUpdateStatus'
+)[] = ['Success', 'DeviceFirmwareUpdateStatus'];
+
+export const getProtocolV2UnknownErrorText = (error: unknown) => {
+  if (!error) {
+    return '';
+  }
+  if (typeof error === 'string') {
+    return error;
+  }
+
+  const parts: string[] = [];
+  if (error instanceof Error) {
+    parts.push(error.name, error.message);
+  }
+
+  if (typeof error === 'object') {
+    const record = error as Record<string, unknown>;
+    for (const field of ['name', 'message', 'reason', 'code', 'errorCode', 'nativeErrorCode']) {
+      const value = record[field];
+      if (value !== undefined && value !== null) {
+        parts.push(String(value));
+      }
+    }
+  }
+
+  const stringified = String(error);
+  if (stringified && stringified !== '[object Object]') {
+    parts.push(stringified);
+  }
+
+  return parts.filter(Boolean).join(' ');
+};
+
+export const isProtocolV2DeviceDisconnectedError = (error: unknown) => {
+  const message = getProtocolV2UnknownErrorText(error).toLowerCase();
+  const compactMessage = message.replace(/\s+/g, '');
+  return (
+    message.includes('notfounderror') ||
+    (message.includes("failed to execute 'open'") && message.includes('usbdevice')) ||
+    message.includes('device was disconnected') ||
+    message.includes('device disconnected') ||
+    message.includes('device disconnect') ||
+    message.includes('was disconnected') ||
+    message.includes('bledevicedisconnected') ||
+    message.includes('bleconnectederror') ||
+    message.includes('connected error is always runtime error') ||
+    message.includes('connection has timed out unexpectedly') ||
+    message.includes('connection error has occured') ||
+    message.includes('connection error has occurred') ||
+    message.includes('multiplatformbleadapter') ||
+    message.includes('multipalformebleadapter') ||
+    compactMessage.includes('rxerrorerror6') ||
+    message.includes('rxerror error 6')
+  );
+};
+
+export function normalizeRebootType(value: RebootTypeInput | undefined): DeviceRebootType {
+  if (typeof value === 'number') return value;
+  if (typeof value === 'string') {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) return numeric;
+    if (value in DEVICE_REBOOT_TYPES) return DEVICE_REBOOT_TYPES[value];
+  }
+  return DeviceRebootType.Normal;
+}
+
+// 与 firmware-pro2 的 proto_target_to_firmware_target 安装白名单保持一致。
+const INSTALLABLE_FIRMWARE_TARGET_IDS = new Set<number>([
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_CRATE,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE01,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE02,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE03,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04,
+]);
+const FIRMWARE_TARGET_ID_BY_NAME = new Map<string, DeviceFirmwareTargetType>(
+  Object.entries(ProtocolV2FirmwareTargetType).flatMap(([key, value]) =>
+    INSTALLABLE_FIRMWARE_TARGET_IDS.has(value) ? [[key, value as DeviceFirmwareTargetType]] : []
+  )
+);
+
+function normalizeTargetId(
+  value: DeviceFirmwareTargetType | string | number | undefined,
+  name: string
+): DeviceFirmwareTargetType {
+  if (value === undefined || value === null) {
+    throw invalidParameter(`Missing required parameter: ${name}`);
+  }
+  const named = typeof value === 'string' ? FIRMWARE_TARGET_ID_BY_NAME.get(value) : undefined;
+  const numeric = named ?? (typeof value === 'number' ? value : Number(value));
+  if (Number.isSafeInteger(numeric) && INSTALLABLE_FIRMWARE_TARGET_IDS.has(numeric)) {
+    return numeric as DeviceFirmwareTargetType;
+  }
+  throw invalidParameter(
+    `Parameter [${name}] must be an installable firmware target id (one of ${[
+      ...INSTALLABLE_FIRMWARE_TARGET_IDS,
+    ].join(', ')}).`
+  );
+}
+
+export function normalizeFirmwareTargets(
+  params: DeviceFirmwareUpdateParams
+): DeviceFirmwareTarget[] {
+  const targets =
+    params.targets ??
+    (params.path
+      ? [
+          {
+            target_id: params.target_id ?? params.targetId ?? 0,
+            path: params.path,
+          },
+        ]
+      : []);
+
+  if (!Array.isArray(targets) || targets.length === 0) {
+    throw invalidParameter('Parameter [targets] must contain at least one firmware target.');
+  }
+
+  return targets.map((target, index) => {
+    if (!target || typeof target !== 'object') {
+      throw invalidParameter(`Parameter [targets.${index}] must be an object.`);
+    }
+    const targetId = target.target_id ?? target.targetId;
+    return {
+      target_id: normalizeTargetId(targetId, `targets.${index}.target_id`),
+      path: validateNonEmptyString(target.path, `targets.${index}.path`),
+    };
+  });
+}

package/src/api/scdo/ScdoGetAddress.ts

@@ -4,7 +4,7 @@ import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
 
 import type { ScdoGetAddress as HardwareScdoGetAddress } from '@onekeyfe/hd-transport';
-import type { ScdoAddress, ScdoGetAddressParams } from '../../types';
+import type { DeviceFirmwareRange, ScdoAddress, ScdoGetAddressParams } from '../../types';
 
 export default class ScdoGetAddress extends BaseMethod<HardwareScdoGetAddress[]> {
   hasBundle = false;
@@ -38,8 +38,12 @@ export default class ScdoGetAddress extends BaseMethod<HardwareScdoGetAddress[]>
     });
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_touch: {
         min: '4.10.0',
       },

package/src/api/scdo/ScdoSignMessage.ts

@@ -5,6 +5,7 @@ import { validateParams } from '../helpers/paramsValidator';
 import { stripHexPrefix } from '../helpers/hexUtils';
 
 import type { ScdoSignMessage as HardwareScdoSignMessage } from '@onekeyfe/hd-transport';
+import type { DeviceFirmwareRange } from '../../types';
 
 export default class ScdoSignMessage extends BaseMethod<HardwareScdoSignMessage> {
   init() {
@@ -28,8 +29,12 @@ export default class ScdoSignMessage extends BaseMethod<HardwareScdoSignMessage>
     };
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_touch: {
         min: '4.10.0',
       },

package/src/api/scdo/ScdoSignTransaction.ts

@@ -6,7 +6,7 @@ import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex, stripHexStartZeroes } from '../helpers/hexUtils';
 
-import type { ScdoSignTransactionParams } from '../../types';
+import type { DeviceFirmwareRange, ScdoSignTransactionParams } from '../../types';
 import type {
   ScdoSignTx as HardwareScdoSignTx,
   ScdoSignedTx,
@@ -51,8 +51,12 @@ export default class ScdoSignTransaction extends BaseMethod<HardwareScdoSignTx>
     };
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_touch: {
         min: '4.10.0',
       },

package/src/api/solana/SolGetAddress.ts

@@ -38,6 +38,10 @@ export default class SolGetAddress extends BaseMethod<SolanaGetAddress[]> {
     });
   }
 
+  getVersionRange() {
+    return {};
+  }
+
   async run() {
     const responses: SolanaAddress[] = [];
 

package/src/api/solana/SolSignMessage.ts

@@ -30,6 +30,9 @@ export default class SolSignMessage extends BaseMethod<HardwareSolSignUnsafeMess
 
   getVersionRange() {
     return {
+      pro2: {
+        min: '0.0.0',
+      },
       pro: {
         min: '4.12.0',
       },

package/src/api/solana/SolSignOffchainMessage.ts

@@ -36,6 +36,9 @@ export default class SolSignOffchainMessage extends BaseMethod<HardwareSolSignOf
 
   getVersionRange() {
     return {
+      pro2: {
+        min: '0.0.0',
+      },
       pro: {
         min: '4.12.0',
       },

package/src/api/solana/SolSignTransaction.ts

@@ -43,6 +43,9 @@ export default class SolSignTransaction extends BaseMethod<HardwareSolanaSignTx[
   getVersionRange() {
     if (this.existsVersionedTx()) {
       return {
+        pro2: {
+          min: '0.0.0',
+        },
         model_mini: {
           min: '3.1.0',
         },
@@ -53,6 +56,9 @@ export default class SolSignTransaction extends BaseMethod<HardwareSolanaSignTx[
     }
 
     return {
+      pro2: {
+        min: '0.0.0',
+      },
       classic: {
         min: '2.1.9',
       },

package/src/api/stellar/StellarGetAddress.ts

@@ -4,7 +4,7 @@ import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
 
 import type { StellarGetAddress as HardwareStellarGetAddress } from '@onekeyfe/hd-transport';
-import type { StellarAddress, StellarGetAddressParams } from '../../types';
+import type { DeviceFirmwareRange, StellarAddress, StellarGetAddressParams } from '../../types';
 
 export default class StellarGetAddress extends BaseMethod<HardwareStellarGetAddress[]> {
   hasBundle = false;
@@ -38,6 +38,15 @@ export default class StellarGetAddress extends BaseMethod<HardwareStellarGetAddr
     });
   }
 
+  getVersionRange(): DeviceFirmwareRange {
+    return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
+    };
+  }
+
   async run() {
     const responses: StellarAddress[] = [];
 

package/src/api/stellar/StellarSignTransaction.ts

@@ -10,7 +10,11 @@ import type {
   StellarSignTx as HardwareStellarSignTx,
   StellarSignedTx,
 } from '@onekeyfe/hd-transport';
-import type { StellarOperation, StellarSignTransactionParams } from '../../types';
+import type {
+  DeviceFirmwareRange,
+  StellarOperation,
+  StellarSignTransactionParams,
+} from '../../types';
 
 // Firmware accepts up to 1024 bytes per chunk; 1 byte = 2 hex chars
 const SOROBAN_CHUNK_BYTES = 1024;
@@ -28,6 +32,15 @@ export default class StellarSignTransaction extends BaseMethod<HardwareStellarSi
     extSent: number;
   };
 
+  getVersionRange(): DeviceFirmwareRange {
+    return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
+    };
+  }
+
   parseOperation = (op: StellarOperation) => {
     switch (op.type) {
       case 'createAccount':

package/src/api/sui/SuiGetAddress.ts

@@ -2,9 +2,8 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
-import { supportBatchPublicKey } from '../../utils/deviceFeaturesUtils';
 import { publicKeyToAddress } from './normalize';
-import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
+import { batchGetPublickeys, supportBatchPublicKeyByDevice } from '../helpers/batchGetPublickeys';
 
 import type { SuiAddress, SuiGetAddressParams } from '../../types';
 import type { SuiGetAddress as HardwareSuiGetAddress } from '@onekeyfe/hd-transport';
@@ -49,6 +48,9 @@ export default class SuiGetAddress extends BaseMethod<HardwareSuiGetAddress[]> {
 
   getVersionRange() {
     return {
+      pro2: {
+        min: '0.0.0',
+      },
       model_mini: {
         min: '3.0.0',
       },
@@ -59,7 +61,7 @@ export default class SuiGetAddress extends BaseMethod<HardwareSuiGetAddress[]> {
   }
 
   async run() {
-    const supportsBatchPublicKey = supportBatchPublicKey(this.device?.features);
+    const supportsBatchPublicKey = supportBatchPublicKeyByDevice(this.device);
     let responses: SuiAddress[] = [];
     if (supportsBatchPublicKey) {
       const publicKeyRes = await batchGetPublickeys(this.device, this.params, 'ed25519', 784);

package/src/api/sui/SuiGetPublicKey.ts

@@ -40,6 +40,9 @@ export default class SuiGetPublicKey extends BaseMethod<any> {
 
   getVersionRange() {
     return {
+      pro2: {
+        min: '0.0.0',
+      },
       model_mini: {
         min: '3.0.0',
       },

package/src/api/sui/SuiSignMessage.ts

@@ -30,6 +30,9 @@ export default class SuiSignMessage extends BaseMethod<HardwareSuiSignMessage> {
 
   getVersionRange() {
     return {
+      pro2: {
+        min: '0.0.0',
+      },
       model_mini: {
         min: '3.4.0',
       },

package/src/api/sui/SuiSignTransaction.ts

@@ -1,20 +1,16 @@
 import semver from 'semver';
 import { bytesToHex } from '@noble/hashes/utils';
+import { EDeviceType } from '@onekeyfe/hd-shared';
 
 import { UI_REQUEST } from '../../constants/ui-request';
 import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
-import { getDeviceFirmwareVersion, getDeviceType } from '../../utils';
 import { DeviceModelToTypes } from '../../types';
 
-import type {
-  SuiSignTx as HardwareSuiSignTx,
-  SuiSignedTx,
-  TypedCall,
-} from '@onekeyfe/hd-transport';
-import type { TypedResponseMessage } from '../../device/DeviceCommands';
+import type { SuiSignTx as HardwareSuiSignTx, SuiSignedTx } from '@onekeyfe/hd-transport';
+import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommands';
 
 type SuiSignTx = Omit<HardwareSuiSignTx, 'data_initial_chunk' | 'data_length'> & HardwareSuiSignTx;
 
@@ -43,6 +39,9 @@ export default class SuiSignTransaction extends BaseMethod<SuiSignTx> {
 
   getVersionRange() {
     return {
+      pro2: {
+        min: '0.0.0',
+      },
       model_mini: {
         min: '3.0.0',
       },
@@ -53,8 +52,12 @@ export default class SuiSignTransaction extends BaseMethod<SuiSignTx> {
   }
 
   supportChunkTransfer() {
-    const deviceType = getDeviceType(this.device.features);
-    const deviceFirmwareVersion = getDeviceFirmwareVersion(this.device.features).join('.');
+    if (this.device.isProtocolV2() || this.device.getCurrentDeviceType() === EDeviceType.Pro2) {
+      return true;
+    }
+
+    const deviceType = this.device.getCurrentDeviceType();
+    const deviceFirmwareVersion = this.device.getCurrentFirmwareVersionString() ?? '0.0.0';
 
     if (DeviceModelToTypes.model_mini.includes(deviceType)) {
       if (semver.valid(deviceFirmwareVersion)) {
@@ -85,7 +88,7 @@ export default class SuiSignTransaction extends BaseMethod<SuiSignTx> {
 
     if (!data_length) {
       // sign Done
-      return res.message;
+      return res.message as SuiSignedTx;
     }
 
     const payload = data.subarray(offset, offset + data_length);
@@ -104,7 +107,7 @@ export default class SuiSignTransaction extends BaseMethod<SuiSignTx> {
   async run() {
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
     let offset = 0;
-    let data: Buffer;
+    let data = Buffer.alloc(0);
 
     if (this.supportChunkTransfer()) {
       offset = this.chunkByteSize;
@@ -121,7 +124,6 @@ export default class SuiSignTransaction extends BaseMethod<SuiSignTx> {
       ...this.params,
     });
 
-    // @ts-expect-error
     return this.processTxRequest(typedCall, res, data, offset);
   }
 }

package/src/api/ton/TonGetAddress.ts

@@ -57,6 +57,9 @@ export default class TonGetAddress extends BaseMethod<HardwareTonGetAddress[]> {
 
   getVersionRange() {
     return {
+      pro2: {
+        min: '0.0.0',
+      },
       model_touch: {
         min: '4.10.0',
       },

package/src/api/ton/TonSignData.ts

@@ -9,9 +9,8 @@ import type { TonSignDataParams } from '../../types/api/tonSignData';
 
 export default class TonSignData extends BaseMethod<HardwareTonSignData> {
   init() {
-    // Keep strict-check off until the firmware release that ships TonSignData
-    // is decided — we don't yet know the min versions for touch/classic1s.
-    // Flip back to true and add getVersionRange() once those numbers land.
+    // Keep strict-check off for touch/classic1s until their firmware release
+    // versions are decided. Pro2 is explicitly allowed by getVersionRange().
     this.strictCheckDeviceSupport = false;
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
@@ -51,6 +50,10 @@ export default class TonSignData extends BaseMethod<HardwareTonSignData> {
     };
   }
 
+  getVersionRange() {
+    return {};
+  }
+
   async run() {
     const res = await this.device.commands.typedCall('TonSignData', 'TonSignedData', {
       ...this.params,

package/src/api/ton/TonSignMessage.ts

@@ -7,7 +7,6 @@ import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { DeviceModelToTypes } from '../../types';
-import { getDeviceFirmwareVersion, getDeviceType, getMethodVersionRange } from '../../utils';
 import { formatAnyHex, stripHexStartZeroes } from '../helpers/hexUtils';
 import { cutString } from '../helpers/stringUtils';
 
@@ -86,6 +85,9 @@ export default class TonSignMessage extends BaseMethod<HardwareTonSignMessage> {
 
   getVersionRange() {
     return {
+      pro2: {
+        min: '0.0.0',
+      },
       model_touch: {
         min: '4.10.0',
       },
@@ -107,9 +109,8 @@ export default class TonSignMessage extends BaseMethod<HardwareTonSignMessage> {
   }
 
   checkSupportJettonAmountBytes() {
-    const firmwareVersion = getDeviceFirmwareVersion(this.device.features)?.join('.');
-    const versionRange = getMethodVersionRange(
-      this.device.features,
+    const firmwareVersion = this.device.getCurrentFirmwareVersionString() ?? '0.0.0';
+    const versionRange = this.device.getCurrentMethodVersionRange(
       type => this.getSupportJettonAmountBytesVersionRange()[type]
     );
 
@@ -167,7 +168,7 @@ export default class TonSignMessage extends BaseMethod<HardwareTonSignMessage> {
     data: string
   ): Promise<TonTxAck | TonSignedMessageResponse> => {
     if (!request.init_data_length) {
-      const deviceType = getDeviceType(this.device.features);
+      const deviceType = this.device.getCurrentDeviceType();
       const hasClassic = DeviceModelToTypes.model_classic1s.includes(deviceType);
       // use signing_message_repr sign, not exists signning_message, skip validate
       const hasSigningMessageRepr = request.signning_message == null;

package/src/api/ton/TonSignProof.ts

@@ -44,6 +44,9 @@ export default class TonSignProof extends BaseMethod<HardwareTonSignProof> {
 
   getVersionRange() {
     return {
+      pro2: {
+        min: '0.0.0',
+      },
       model_touch: {
         min: '4.10.0',
       },

package/src/api/tron/TronSignMessage.ts

@@ -29,7 +29,7 @@ export default class TronSignMessage extends BaseMethod<HardwareTronSignMessage>
     if (this.payload.messageType === 'V1' || this.payload.messageType == null) {
       throw createDeviceNotSupportMethodError(
         'TronSignMessage',
-        getFirmwareType(this.device.features)
+        getFirmwareType(this.device?.features)
       );
     }
 
@@ -45,6 +45,9 @@ export default class TronSignMessage extends BaseMethod<HardwareTronSignMessage>
 
   getVersionRange() {
     return {
+      pro2: {
+        min: '0.0.0',
+      },
       model_mini: {
         min: '2.5.0',
       },

package/src/api/tron/TronSignTransaction.ts

@@ -148,6 +148,9 @@ export default class TronSignTransaction extends BaseMethod<TronSignTx> {
 
   getVersionRange() {
     return {
+      pro2: {
+        min: '0.0.0',
+      },
       model_mini: {
         min: '2.5.0',
       },

package/src/api/utils.ts

@@ -2,16 +2,20 @@ import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import * as ApiMethods from './index';
 
+import type { BaseMethod } from './BaseMethod';
 import type { IFrameCallMessage } from '../events';
 
-export function findMethod(message: IFrameCallMessage & { id?: number }) {
+type MethodConstructor = new (message: IFrameCallMessage & { id?: number }) => BaseMethod<any>;
+
+const publicMethodRegistry = ApiMethods as unknown as Record<string, MethodConstructor>;
+
+export function findMethod(message: IFrameCallMessage & { id?: number }): BaseMethod<any> {
   const { method } = message.payload;
   if (typeof method !== 'string') {
     throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Method is not set');
   }
 
-  // @ts-expect-error
-  const MethodConstructor = ApiMethods[method];
+  const MethodConstructor = publicMethodRegistry[method];
   if (MethodConstructor) {
     return new MethodConstructor(message);
   }

package/src/api/xrp/XrpSignTransaction.ts

@@ -30,7 +30,7 @@ export default class XrpGetAddress extends BaseMethod<XrpSignTransactionParams>
       { name: 'payment', type: 'object' },
     ]);
     validateParams(transaction.payment, [
-      { name: 'amount', type: 'number', required: true },
+      { name: 'amount', type: 'uint', required: true },
       { name: 'destination', type: 'string', required: true },
       { name: 'destinationTag', type: 'number' },
     ]);

package/src/constants/index.ts

@@ -1,2 +1,8 @@
 export { safeThrowError } from './errors';
-export { Messages as PROTO, TonSignDataType } from '@onekeyfe/hd-transport';
+export {
+  Messages as PROTO,
+  ResourceType,
+  TonSignDataType,
+  TonWalletVersion,
+} from '@onekeyfe/hd-transport';
+export type { HDNodeType, Success as DeviceSuccess } from '@onekeyfe/hd-transport';