@onekeyfe/hd-core 0.1.53 → 0.1.55

package/src/api/firmware/uploadFirmware.ts

@@ -1,9 +1,16 @@
+import { blake2s } from '@noble/hashes/blake2s';
+import JSZip from 'jszip';
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { Success } from '@onekeyfe/hd-transport';
+import { wait, getLogger, LoggerNames } from '../../utils/index';
 import { DEVICE, CoreMessage, createUiMessage, UI_REQUEST } from '../../events';
 import { PROTO } from '../../constants';
 import type { Device } from '../../device/Device';
-import type { TypedCall } from '../../device/DeviceCommands';
+import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommands';
 import { KnownDevice } from '../../types';
+import { bytesToHex } from '../helpers/hexUtils';
+
+const Log = getLogger(LoggerNames.Device);
 
 const postConfirmationMessage = (device: Device) => {
   // only if firmware is already installed. fresh device does not require button confirmation
@@ -25,6 +32,28 @@ const postProgressMessage = (
   );
 };
 
+const postProgressTip = (
+  device: Device,
+  message: string,
+  postMessage: (message: CoreMessage) => void
+) => {
+  postMessage(
+    createUiMessage(UI_REQUEST.FIRMWARE_TIP, {
+      device: device.toMessageObject() as KnownDevice,
+      data: {
+        message,
+      },
+    })
+  );
+};
+
+export const waitBleInstall = async (updateType: string) => {
+  if (updateType === 'ble') {
+    // wait for device install
+    await wait(10 * 1000);
+  }
+};
+
 export const uploadFirmware = async (
   updateType: 'firmware' | 'ble',
   typedCall: TypedCall,
@@ -34,21 +63,27 @@ export const uploadFirmware = async (
 ) => {
   if (device.features?.major_version === 1) {
     postConfirmationMessage(device);
+    postProgressTip(device, 'ConfirmOnDevice', postMessage);
     const eraseCommand = updateType === 'firmware' ? 'FirmwareErase' : 'FirmwareErase_ex';
     await typedCall(eraseCommand as unknown as any, 'Success', {});
+    postProgressTip(device, 'FirmwareEraseSuccess', postMessage);
     postProgressMessage(device, 0, postMessage);
     const { message } = await typedCall('FirmwareUpload', 'Success', {
       payload,
     });
     postProgressMessage(device, 100, postMessage);
+
+    await waitBleInstall(updateType);
     return message;
   }
 
   if (device.features?.major_version === 2) {
     postConfirmationMessage(device);
+    postProgressTip(device, 'ConfirmOnDevice', postMessage);
     const length = payload.byteLength;
 
     let response = await typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], { length });
+    postProgressTip(device, 'FirmwareEraseSuccess', postMessage);
     while (response.type !== 'Success') {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       const start = response.message.offset!;
@@ -66,8 +101,91 @@ export const uploadFirmware = async (
     }
 
     postProgressMessage(device, 100, postMessage);
+
+    await waitBleInstall(updateType);
     return response.message;
   }
 
   throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'uploadFirmware: unknown major_version');
 };
+
+const processResourceRequest = async (
+  typedCall: TypedCall,
+  res: TypedResponseMessage<'ResourceRequest'> | TypedResponseMessage<'Success'>,
+  data: ArrayBuffer
+): Promise<Success> => {
+  if (res.type === 'Success') {
+    return res.message;
+  }
+
+  const { offset, data_length } = res.message;
+
+  if (offset === undefined) {
+    throw new Error('offset is undefined');
+  }
+
+  const payload = new Uint8Array(
+    data.slice(offset, Math.min(offset + data_length, data.byteLength))
+  );
+  const digest = blake2s(payload);
+
+  const resourceAckParams = {
+    data_chunk: bytesToHex(payload),
+    hash: bytesToHex(digest),
+  };
+
+  const response = await typedCall('ResourceAck', ['ResourceRequest', 'Success'], {
+    ...resourceAckParams,
+  });
+  return processResourceRequest(typedCall, response, data);
+};
+
+// Fixed size
+const INIT_DATA_CHUNK_SIZE = 16 * 1024;
+export const updateResource = async (typedCall: TypedCall, fileName: string, data: ArrayBuffer) => {
+  const chunk = new Uint8Array(data.slice(0, Math.min(INIT_DATA_CHUNK_SIZE, data.byteLength)));
+  const digest = blake2s(chunk);
+
+  const res = await typedCall('ResourceUpdate', ['ResourceRequest', 'Success'], {
+    file_name: fileName,
+    data_length: data.byteLength,
+    initial_data_chunk: bytesToHex(chunk),
+    hash: bytesToHex(digest),
+  });
+
+  return processResourceRequest(typedCall, res, data);
+};
+
+export const updateResources = async (
+  typedCall: TypedCall,
+  postMessage: (message: CoreMessage) => void,
+  device: Device,
+  source: ArrayBuffer
+) => {
+  postProgressTip(device, 'UpdateSysResource', postMessage);
+
+  const zipData = await JSZip.loadAsync(source);
+  const files = Object.entries(zipData.files);
+
+  let progress = 0;
+  const stepProgress = 100 / files.length;
+
+  for (const [fileName, file] of files) {
+    const name = fileName.split('/').pop();
+    if (!file.dir && fileName.indexOf('__MACOSX') === -1 && name) {
+      const data = await file.async('arraybuffer');
+      try {
+        await updateResource(typedCall, name, data);
+      } catch (error) {
+        Log.error(error);
+      }
+    }
+
+    progress += stepProgress;
+    postProgressMessage(device, Math.floor(progress), postMessage);
+  }
+
+  postProgressMessage(device, 100, postMessage);
+  postProgressTip(device, 'UpdateSysResourceSuccess', postMessage);
+  return true;
+};

package/src/api/helpers/hexUtils.ts

@@ -48,7 +48,7 @@ export const formatAnyHex: (value: any) => any = value => {
   return value;
 };
 
-const hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));
+const hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
 /**
  * @example bytesToHex(Uint8Array.from([0xde, 0xad, 0xbe, 0xef]))
  */

package/src/api/index.ts

@@ -14,13 +14,14 @@ export { default as deviceRecovery } from './device/DeviceRecovery';
 export { default as deviceReset } from './device/DeviceReset';
 export { default as deviceSettings } from './device/DeviceSettings';
 export { default as deviceUpdateReboot } from './device/DeviceUpdateReboot';
+export { default as deviceUploadResource } from './device/DeviceUploadResource';
 export { default as deviceSupportFeatures } from './device/DeviceSupportFeatures';
 export { default as deviceVerify } from './device/DeviceVerify';
 export { default as deviceWipe } from './device/DeviceWipe';
 export { default as firmwareUpdate } from './FirmwareUpdate';
+export { default as firmwareUpdateV2 } from './FirmwareUpdateV2';
 export { default as requestWebUsbDevice } from './RequestWebUsbDevice';
 
-export { default as batchGetPublicKey } from './BatchGetPublicKey';
 export { default as cipherKeyValue } from './CipherKeyValue';
 
 export { default as btcGetAddress } from './btc/BTCGetAddress';
@@ -65,4 +66,5 @@ export { default as nearGetAddress } from './near/NearGetAddress';
 export { default as nearSignTransaction } from './near/NearSignTransaction';
 
 export { default as aptosGetAddress } from './aptos/AptosGetAddress';
+export { default as aptosGetPublicKey } from './aptos/AptosGetPublicKey';
 export { default as aptosSignTransaction } from './aptos/AptosSignTransaction';

package/src/constants/ui-request.ts

@@ -9,4 +9,6 @@ export const UI_REQUEST = {
   FIRMWARE_NOT_COMPATIBLE: 'ui-device_firmware_not_compatible',
   FIRMWARE_NOT_INSTALLED: 'ui-device_firmware_not_installed',
   NOT_USE_ONEKEY_DEVICE: 'ui-device_please_use_onekey_device',
+
+  FIRMWARE_TIP: 'ui-firmware-tip',
 } as const;

package/src/core/index.ts

@@ -345,7 +345,11 @@ function initDevice(method: BaseMethod) {
   } else if (allDevices.length === 1) {
     [device] = allDevices;
   } else if (allDevices.length > 1) {
-    throw ERRORS.TypedError(HardwareErrorCode.SelectDevice);
+    throw ERRORS.TypedError(
+      method.name === 'firmwareUpdateV2'
+        ? HardwareErrorCode.FirmwareUpdateLimitOneDevice
+        : HardwareErrorCode.SelectDevice
+    );
   }
 
   if (!device) {
@@ -463,6 +467,7 @@ const ensureConnected = async (method: BaseMethod, pollingId: number) => {
             HardwareErrorCode.BleCharacteristicNotifyError,
             HardwareErrorCode.BleWriteCharacteristicError,
             HardwareErrorCode.BleAlreadyConnected,
+            HardwareErrorCode.FirmwareUpdateLimitOneDevice,
           ].includes(error.errorCode)
         ) {
           reject(error);

package/src/data/coins/bitcoin.json

@@ -4,6 +4,7 @@
   { "name": "Testnet", "label": "TEST", "slip44": 1 },
   { "name": "Actinium", "label": "ACM", "slip44": 228 },
   { "name": "Axe", "label": "AXE", "slip44": 4242 },
+  { "name": "Bcash", "label": "BCH", "slip44": 145 },
   { "name": "Bitcore", "label": "BTX", "slip44": 160 },
   { "name": "Dash", "label": "DASH", "slip44": 5 },
   { "name": "Dash Testnet", "label": "tDASH", "slip44": 1 },

package/src/data/messages/messages.json

@@ -5011,7 +5011,7 @@
         }
       }
     },
-    "BixinReboot": {
+    "DeviceBackToBoot": {
       "fields": {}
     },
     "BixinBackupRequest": {
@@ -5281,6 +5281,104 @@
         }
       }
     },
+    "ResourceUpload": {
+      "fields": {
+        "extension": {
+          "rule": "required",
+          "type": "string",
+          "id": 1
+        },
+        "data_length": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 2
+        },
+        "res_type": {
+          "rule": "required",
+          "type": "ResourceType",
+          "id": 3
+        },
+        "zoom_data_length": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 5
+        },
+        "nft_meta_data": {
+          "type": "bytes",
+          "id": 4
+        }
+      },
+      "nested": {
+        "ResourceType": {
+          "values": {
+            "WallPaper": 0,
+            "Nft": 1
+          }
+        }
+      }
+    },
+    "ZoomRequest": {
+      "fields": {
+        "offset": {
+          "type": "uint32",
+          "id": 1
+        },
+        "data_length": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 2
+        }
+      }
+    },
+    "ResourceRequest": {
+      "fields": {
+        "offset": {
+          "type": "uint32",
+          "id": 1
+        },
+        "data_length": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 2
+        }
+      }
+    },
+    "ResourceAck": {
+      "fields": {
+        "data_chunk": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 1
+        },
+        "hash": {
+          "type": "bytes",
+          "id": 2
+        }
+      }
+    },
+    "ResourceUpdate": {
+      "fields": {
+        "file_name": {
+          "rule": "required",
+          "type": "string",
+          "id": 1
+        },
+        "data_length": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 2
+        },
+        "initial_data_chunk": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 3
+        },
+        "hash": {
+          "type": "bytes",
+          "id": 4
+        }
+      }
+    },
     "NFTWriteInfo": {
       "fields": {
         "index": {
@@ -6277,6 +6375,7 @@
           }
         },
         "raw_tx": {
+          "rule": "required",
           "type": "bytes",
           "id": 2
         }
@@ -8405,16 +8504,6 @@
         "MessageType_StarcoinSignMessage": 10306,
         "MessageType_StarcoinMessageSignature": 10307,
         "MessageType_StarcoinVerifyMessage": 10308,
-        "MessageType_ConfluxGetAddress": 10401,
-        "MessageType_ConfluxAddress": 10402,
-        "MessageType_ConfluxSignTx": 10403,
-        "MessageType_ConfluxTxRequest": 10404,
-        "MessageType_ConfluxTxAck": 10405,
-        "MessageType_ConfluxSignMessage": 10406,
-        "MessageType_ConfluxSignMessageCIP23": 10407,
-        "MessageType_ConfluxMessageSignature": 10408,
-        "MessageType_ConfluxVerifyMessage": 10409,
-        "MessageType_ConfluxVerifyMessageCIP23": 10410,
         "MessageType_AptosGetAddress": 10600,
         "MessageType_AptosAddress": 10601,
         "MessageType_AptosSignTx": 10602,
@@ -8425,7 +8514,6 @@
         "MessageType_WebAuthnRemoveResidentCredential": 803,
         "MessageType_BixinSeedOperate": 901,
         "MessageType_BixinMessageSE": 902,
-        "MessageType_BixinReboot": 903,
         "MessageType_BixinOutMessageSE": 904,
         "MessageType_BixinBackupRequest": 905,
         "MessageType_BixinBackupAck": 906,
@@ -8442,6 +8530,14 @@
         "MessageType_EthereumSignMessageEIP712": 10200,
         "MessageType_GetPublicKeyMultiple": 10210,
         "MessageType_PublicKeyMultiple": 10211,
+        "MessageType_ConfluxGetAddress": 10112,
+        "MessageType_ConfluxAddress": 10113,
+        "MessageType_ConfluxSignTx": 10114,
+        "MessageType_ConfluxTxRequest": 10115,
+        "MessageType_ConfluxTxAck": 10116,
+        "MessageType_ConfluxSignMessage": 10117,
+        "MessageType_ConfluxSignMessageCIP23": 10118,
+        "MessageType_ConfluxMessageSignature": 10119,
         "MessageType_TronGetAddress": 10501,
         "MessageType_TronAddress": 10502,
         "MessageType_TronSignTx": 10503,
@@ -8452,6 +8548,7 @@
         "MessageType_NearAddress": 10702,
         "MessageType_NearSignTx": 10703,
         "MessageType_NearSignedTx": 10704,
+        "MessageType_DeviceBackToBoot": 903,
         "MessageType_DeviceInfoSettings": 10001,
         "MessageType_GetDeviceInfo": 10002,
         "MessageType_DeviceInfo": 10003,
@@ -8466,7 +8563,12 @@
         "MessageType_SESignMessage": 10012,
         "MessageType_SEMessageSignature": 10013,
         "MessageType_NFTWriteInfo": 10014,
-        "MessageType_NFTWriteData": 10015
+        "MessageType_NFTWriteData": 10015,
+        "MessageType_ResourceUpload": 10018,
+        "MessageType_ZoomRequest": 10019,
+        "MessageType_ResourceRequest": 10020,
+        "MessageType_ResourceAck": 10021,
+        "MessageType_ResourceUpdate": 10022
       }
     },
     "google": {

package/src/data-manager/DataManager.ts

@@ -18,7 +18,7 @@ import type {
   IDeviceBLEFirmwareStatus,
   ITransportStatus,
 } from '../types';
-import { getReleaseChangelog, getReleaseStatus } from '../utils/release';
+import { getReleaseChangelog, getReleaseStatus, findLatestRelease } from '../utils/release';
 
 export default class DataManager {
   static deviceMap: DeviceTypeMap = {
@@ -64,6 +64,25 @@ export default class DataManager {
     return getReleaseStatus(targetDeviceConfigList, currentVersion);
   };
 
+  /**
+   * Touch、Pro System UI Resource Update
+   * ** Interval upgrade is not considered **
+   */
+  static getSysResourcesLatestRelease = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
+
+    if (deviceType !== 'pro' && deviceType !== 'touch') return undefined;
+
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.firmware ?? [];
+    const currentVersion = deviceFirmwareVersion.join('.');
+    const targetDeviceConfig = targetDeviceConfigList.filter(
+      item => semver.gt(item.version.join('.'), currentVersion) && !!item.resource
+    );
+
+    return findLatestRelease(targetDeviceConfig)?.resource;
+  };
+
   static getFirmwareChangelog = (features: Features) => {
     const deviceType = getDeviceType(features);
     const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
@@ -80,10 +99,21 @@ export default class DataManager {
     return getReleaseChangelog(targetDeviceConfigList, currentVersion);
   };
 
-  static getFirmwareLeatestRelease = (features: Features) => {
+  static getFirmwareLatestRelease = (features: Features) => {
     const deviceType = getDeviceType(features);
     const targetDeviceConfigList = this.deviceMap[deviceType]?.firmware ?? [];
-    return targetDeviceConfigList[targetDeviceConfigList.length - 1];
+
+    const target = findLatestRelease(targetDeviceConfigList);
+    if (!target) return target;
+
+    if (!target.resource) {
+      const resource = this.getSysResourcesLatestRelease(features);
+      return {
+        ...target,
+        resource,
+      };
+    }
+    return target;
   };
 
   static getBLEFirmwareStatus = (features: Features): IDeviceBLEFirmwareStatus => {
@@ -113,10 +143,10 @@ export default class DataManager {
     return getReleaseChangelog(targetDeviceConfigList, currentVersion);
   };
 
-  static getBleFirmwareLeatestRelease = (features: Features) => {
+  static getBleFirmwareLatestRelease = (features: Features) => {
     const deviceType = getDeviceType(features);
     const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
-    return targetDeviceConfigList[targetDeviceConfigList.length - 1];
+    return findLatestRelease(targetDeviceConfigList);
   };
 
   static getTransportStatus = (localVersion: string): ITransportStatus => {

package/src/device/Device.ts

@@ -251,6 +251,13 @@ export class Device extends EventEmitter {
     return this.commands;
   }
 
+  private generateStateKey(deviceId: string, passphraseState?: string) {
+    if (passphraseState) {
+      return `${deviceId}@${passphraseState}`;
+    }
+    return deviceId;
+  }
+
   getInternalState(_deviceId?: string) {
     Log.debug(
       'getInternalState session param: ',
@@ -264,19 +271,27 @@ export class Device extends EventEmitter {
     if (!deviceId) return undefined;
     if (!this.passphraseState) return undefined;
 
-    const usePassKey = `${deviceId}@${this.passphraseState}`;
+    const usePassKey = this.generateStateKey(deviceId, this.passphraseState);
+    return deviceSessionCache[usePassKey];
+  }
 
-    if (!deviceSessionCache[usePassKey]) {
-      const key = `${deviceId}`;
-      if (deviceSessionCache[key]) {
-        deviceSessionCache[usePassKey] = deviceSessionCache[key];
-      }
-    }
+  tryFixInternalState(state: string, deviceId: string) {
+    Log.debug(
+      'tryFixInternalState session param: ',
+      `device_id: ${deviceId}`,
+      `passphraseState: ${state}`
+    );
 
-    return deviceSessionCache[usePassKey];
+    const key = `${deviceId}`;
+    const session = deviceSessionCache[key];
+    if (session) {
+      deviceSessionCache[this.generateStateKey(deviceId, state)] = session;
+      delete deviceSessionCache[key];
+    }
+    Log.debug('tryFixInternalState session cache: ', deviceSessionCache);
   }
 
-  setInternalState(state: string, initSession?: boolean) {
+  private setInternalState(state: string, initSession?: boolean) {
     Log.debug(
       'setInternalState session param: ',
       `state: ${state}`,
@@ -288,10 +303,11 @@ export class Device extends EventEmitter {
     if (!this.features) return;
     if (!this.passphraseState && !initSession) return;
 
-    let key = `${this.features.device_id}`;
-    if (this.passphraseState) {
-      key += `@${this.passphraseState}`;
-    }
+    const deviceId = this.features?.device_id;
+    if (!deviceId) return;
+
+    const key = this.generateStateKey(deviceId, this.passphraseState);
+
     if (state) {
       deviceSessionCache[key] = state;
     }
@@ -307,7 +323,7 @@ export class Device extends EventEmitter {
     delete deviceSessionCache[key];
 
     if (this.passphraseState) {
-      const usePassKey = `${deviceId}@${this.passphraseState}`;
+      const usePassKey = this.generateStateKey(deviceId, this.passphraseState);
       delete deviceSessionCache[usePassKey];
     }
   }

package/src/device/DeviceCommands.ts

@@ -1,4 +1,4 @@
-import type { Transport, Messages } from '@onekeyfe/hd-transport';
+import type { Transport, Messages, FailureType } from '@onekeyfe/hd-transport';
 import { ERRORS, HardwareError, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import TransportManager from '../data-manager/TransportManager';
 import DataManager from '../data-manager/DataManager';
@@ -146,7 +146,10 @@ export class DeviceCommands {
   ): Promise<DefaultMessageResponse> {
     Log.debug('_filterCommonTypes: ', res);
     if (res.type === 'Failure') {
-      const { code, message } = res.message;
+      const { code, message } = res.message as {
+        code?: string | FailureType;
+        message?: string;
+      };
       let error: HardwareError | null = null;
       // Model One does not send any message in firmware update
       if (code === 'Failure_FirmwareError' && !message) {

package/src/events/ui-request.ts

@@ -19,6 +19,7 @@ export const UI_REQUEST = {
   LOCATION_SERVICE_PERMISSION: 'ui-location_service_permission',
 
   FIRMWARE_PROGRESS: 'ui-firmware-progress',
+  FIRMWARE_TIP: 'ui-firmware-tip',
 
   NOT_IN_BOOTLOADER: 'ui-device_not_in_bootloader_mode',
 } as const;
@@ -69,13 +70,22 @@ export interface FirmwareProgress {
   };
 }
 
+export interface FirmwareTip {
+  type: typeof UI_REQUEST.FIRMWARE_TIP;
+  payload: {
+    device: Device;
+    data: { message: string };
+  };
+}
+
 export type UiEvent =
   | UiRequestWithoutPayload
   | UiRequestDeviceAction
   | UiRequestButton
   | UiRequestPassphraseOnDevice
+  | UiRequestPassphrase
   | FirmwareProgress
-  | UiRequestPassphrase;
+  | FirmwareTip;
 
 export type UiEventMessage = UiEvent & { event: typeof UI_EVENT };
 

package/src/inject.ts

@@ -53,12 +53,6 @@ export const inject = ({
      */
     getFeatures: connectId => call({ connectId, method: 'getFeatures' }),
 
-    /**
-     * 批量获取公钥
-     */
-    batchGetPublicKey: (connectId, deviceId, params) =>
-      call({ ...params, connectId, deviceId, method: 'batchGetPublicKey' }),
-
     /**
      * 检查固件版本
      */
@@ -91,6 +85,8 @@ export const inject = ({
     deviceReset: (connectId, params) => call({ ...params, connectId, method: 'deviceReset' }),
     deviceSettings: (connectId, params) => call({ ...params, connectId, method: 'deviceSettings' }),
     deviceUpdateReboot: connectId => call({ connectId, method: 'deviceUpdateReboot' }),
+    deviceUploadResource: (connectId, params) =>
+      call({ ...params, connectId, method: 'deviceUploadResource' }),
     deviceSupportFeatures: connectId => call({ connectId, method: 'deviceSupportFeatures' }),
     deviceVerify: (connectId, params) => call({ ...params, connectId, method: 'deviceVerify' }),
     deviceWipe: connectId => call({ connectId, method: 'deviceWipe' }),
@@ -150,6 +146,8 @@ export const inject = ({
       call({ ...params, connectId, deviceId, method: 'stellarSignTransaction' }),
 
     firmwareUpdate: (connectId, params) => call({ ...params, connectId, method: 'firmwareUpdate' }),
+    firmwareUpdateV2: (connectId, params) =>
+      call({ ...params, connectId, method: 'firmwareUpdateV2' }),
     requestWebUsbDevice: () => call({ method: 'requestWebUsbDevice' }),
 
     tronGetAddress: (connectId, deviceId, params) =>
@@ -175,6 +173,8 @@ export const inject = ({
 
     aptosGetAddress: (connectId, deviceId, params) =>
       call({ ...params, connectId, deviceId, method: 'aptosGetAddress' }),
+    aptosGetPublicKey: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'aptosGetPublicKey' }),
     aptosSignTransaction: (connectId, deviceId, params) =>
       call({ ...params, connectId, deviceId, method: 'aptosSignTransaction' }),
   };

package/src/types/api/aptosGetPublicKey.ts

@@ -0,0 +1,23 @@
+import type { CommonParams, Response } from '../params';
+
+export type AptosPublicKey = {
+  path: string;
+  publicKey: string;
+};
+
+export type AptosGetPublicKeyParams = {
+  path: string | number[];
+  showOnOneKey?: boolean;
+};
+
+export declare function aptosGetPublicKey(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & AptosGetPublicKeyParams
+): Response<AptosPublicKey>;
+
+export declare function aptosGetPublicKey(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: AptosGetPublicKeyParams[] }
+): Response<Array<AptosPublicKey>>;