@onekeyfe/hd-core 0.1.58 → 0.2.0

package/src/api/cosmos/CosmosSignTransaction.ts

@@ -0,0 +1,51 @@
+import { CosmosSignTx as HardwareCosmosSignTx } from '@onekeyfe/hd-transport';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { CosmosSignTransactionParams } from '../../types';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+export default class CosmosSignTransaction extends BaseMethod<HardwareCosmosSignTx> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'rawTx', type: 'hexString', required: true },
+    ]);
+
+    // init params
+    const { path, rawTx } = this.payload as CosmosSignTransactionParams;
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      raw_tx: formatAnyHex(rawTx),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.6.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('CosmosSignTx', 'CosmosSignedTx', {
+      ...this.params,
+    });
+
+    const { signature } = res.message;
+
+    return {
+      path: serializedPath(this.params.address_n),
+      signature,
+    };
+  }
+}

package/src/api/index.ts

@@ -68,3 +68,10 @@ 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';
+export { default as aptosSignMessage } from './aptos/AptosSignMessage';
+
+export { default as algoGetAddress } from './algo/AlgoGetAddress';
+export { default as algoSignTransaction } from './algo/AlgoSignTransaction';
+
+export { default as cosmosGetAddress } from './cosmos/CosmosGetAddress';
+export { default as cosmosSignTransaction } from './cosmos/CosmosSignTransaction';

package/src/core/index.ts

@@ -19,7 +19,7 @@ import { DeviceList } from '../device/DeviceList';
 import { DevicePool } from '../device/DevicePool';
 import { findMethod } from '../api/utils';
 import { DataManager } from '../data-manager';
-import { enableLog, getLogger, LoggerNames, setLoggerPostMessage } from '../utils';
+import { enableLog, getLogger, LoggerNames, setLoggerPostMessage, wait } from '../utils';
 import {
   CoreMessage,
   createResponseMessage,
@@ -387,6 +387,26 @@ function initDeviceForBle(method: BaseMethod) {
   return device;
 }
 
+/**
+ * If the Bluetooth connection times out, retry 6 times
+ */
+let bleTimeoutRetry = 0;
+async function connectDeviceForBle(method: BaseMethod, device: Device) {
+  try {
+    await device.acquire();
+    await device.initialize(parseInitOptions(method));
+  } catch (err) {
+    if (err.errorCode === HardwareErrorCode.BleTimeoutError && bleTimeoutRetry <= 5) {
+      bleTimeoutRetry += 1;
+      Log.debug(`Bletooth connect timeout and will retry, retry count: ${bleTimeoutRetry}`);
+      await wait(3000);
+      await connectDeviceForBle(method, device);
+    } else {
+      throw err;
+    }
+  }
+}
+
 type IPollFn<T> = (time?: number) => T;
 // eslint-disable-next-line @typescript-eslint/require-await
 const ensureConnected = async (method: BaseMethod, pollingId: number) => {
@@ -455,8 +475,8 @@ const ensureConnected = async (method: BaseMethod, pollingId: number) => {
            * Bluetooth should call initialize here
            */
           if (env === 'react-native') {
-            await device.acquire();
-            await device.initialize(parseInitOptions(method));
+            bleTimeoutRetry = 0;
+            await connectDeviceForBle(method, device);
           }
           resolve(device);
           return;
@@ -470,6 +490,7 @@ const ensureConnected = async (method: BaseMethod, pollingId: number) => {
             HardwareErrorCode.BleLocationServicesDisabled,
             HardwareErrorCode.BleDeviceNotBonded,
             HardwareErrorCode.BleCharacteristicNotifyError,
+            HardwareErrorCode.BleTimeoutError,
             HardwareErrorCode.BleWriteCharacteristicError,
             HardwareErrorCode.BleAlreadyConnected,
             HardwareErrorCode.FirmwareUpdateLimitOneDevice,

package/src/data/messages/messages.json

@@ -1,5 +1,55 @@
 {
   "nested": {
+    "AlgorandGetAddress": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "show_display": {
+          "type": "bool",
+          "id": 3
+        }
+      }
+    },
+    "AlgorandAddress": {
+      "fields": {
+        "address": {
+          "type": "string",
+          "id": 1
+        }
+      }
+    },
+    "AlgorandSignTx": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "raw_tx": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 2
+        }
+      }
+    },
+    "AlgorandSignedTx": {
+      "fields": {
+        "signature": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 1
+        }
+      }
+    },
     "AptosGetAddress": {
       "fields": {
         "address_n": {
@@ -55,6 +105,65 @@
         }
       }
     },
+    "AptosSignMessage": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "payload": {
+          "rule": "required",
+          "type": "AptosMessagePayload",
+          "id": 2
+        }
+      },
+      "nested": {
+        "AptosMessagePayload": {
+          "fields": {
+            "address": {
+              "type": "string",
+              "id": 2
+            },
+            "chain_id": {
+              "type": "string",
+              "id": 3
+            },
+            "application": {
+              "type": "string",
+              "id": 4
+            },
+            "nonce": {
+              "rule": "required",
+              "type": "string",
+              "id": 5
+            },
+            "message": {
+              "rule": "required",
+              "type": "string",
+              "id": 6
+            }
+          }
+        }
+      }
+    },
+    "AptosMessageSignature": {
+      "fields": {
+        "signature": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 1
+        },
+        "address": {
+          "rule": "required",
+          "type": "string",
+          "id": 2
+        }
+      }
+    },
     "BinanceGetAddress": {
       "fields": {
         "address_n": {
@@ -2827,6 +2936,60 @@
         }
       }
     },
+    "CosmosGetAddress": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "hrp": {
+          "type": "string",
+          "id": 2
+        },
+        "show_display": {
+          "type": "bool",
+          "id": 3
+        }
+      }
+    },
+    "CosmosAddress": {
+      "fields": {
+        "address": {
+          "type": "string",
+          "id": 1
+        }
+      }
+    },
+    "CosmosSignTx": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "raw_tx": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 2
+        }
+      }
+    },
+    "CosmosSignedTx": {
+      "fields": {
+        "signature": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 1
+        }
+      }
+    },
     "CipherKeyValue": {
       "fields": {
         "address_n": {
@@ -8508,6 +8671,8 @@
         "MessageType_AptosAddress": 10601,
         "MessageType_AptosSignTx": 10602,
         "MessageType_AptosSignedTx": 10603,
+        "MessageType_AptosSignMessage": 10604,
+        "MessageType_AptosMessageSignature": 10605,
         "MessageType_WebAuthnListResidentCredentials": 800,
         "MessageType_WebAuthnCredentials": 801,
         "MessageType_WebAuthnAddResidentCredential": 802,
@@ -8548,6 +8713,14 @@
         "MessageType_NearAddress": 10702,
         "MessageType_NearSignTx": 10703,
         "MessageType_NearSignedTx": 10704,
+        "MessageType_CosmosGetAddress": 10800,
+        "MessageType_CosmosAddress": 10801,
+        "MessageType_CosmosSignTx": 10802,
+        "MessageType_CosmosSignedTx": 10803,
+        "MessageType_AlgorandGetAddress": 10900,
+        "MessageType_AlgorandAddress": 10901,
+        "MessageType_AlgorandSignTx": 10902,
+        "MessageType_AlgorandSignedTx": 10903,
         "MessageType_DeviceBackToBoot": 903,
         "MessageType_DeviceInfoSettings": 10001,
         "MessageType_GetDeviceInfo": 10002,

package/src/data-manager/DataManager.ts

@@ -68,7 +68,7 @@ export default class DataManager {
    * Touch、Pro System UI Resource Update
    * ** Interval upgrade is not considered **
    */
-  static getSysResourcesLatestRelease = (features: Features) => {
+  static getSysResourcesLatestRelease = (features: Features, forcedUpdateRes?: boolean) => {
     const deviceType = getDeviceType(features);
     const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
 
@@ -76,8 +76,10 @@ export default class DataManager {
 
     const targetDeviceConfigList = this.deviceMap[deviceType]?.firmware ?? [];
     const currentVersion = deviceFirmwareVersion.join('.');
-    const targetDeviceConfig = targetDeviceConfigList.filter(
-      item => semver.gt(item.version.join('.'), currentVersion) && !!item.resource
+    const targetDeviceConfig = targetDeviceConfigList.filter(item =>
+      forcedUpdateRes
+        ? !!item.resource
+        : semver.gt(item.version.join('.'), currentVersion) && !!item.resource
     );
 
     return findLatestRelease(targetDeviceConfig)?.resource;

package/src/inject.ts

@@ -175,8 +175,20 @@ export const inject = ({
       call({ ...params, connectId, deviceId, method: 'aptosGetAddress' }),
     aptosGetPublicKey: (connectId, deviceId, params) =>
       call({ ...params, connectId, deviceId, method: 'aptosGetPublicKey' }),
+    aptosSignMessage: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'aptosSignMessage' }),
     aptosSignTransaction: (connectId, deviceId, params) =>
       call({ ...params, connectId, deviceId, method: 'aptosSignTransaction' }),
+
+    algoGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'algoGetAddress' }),
+    algoSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'algoSignTransaction' }),
+
+    cosmosGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'cosmosGetAddress' }),
+    cosmosSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'cosmosSignTransaction' }),
   };
   return api;
 };

package/src/types/api/algoGetAddress.ts

@@ -0,0 +1,23 @@
+import { AlgorandAddress as HardwareAlgoGetAddress } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type AlgoAddress = {
+  path: string;
+} & HardwareAlgoGetAddress;
+
+export type AlgoGetAddressParams = {
+  path: string | number[];
+  showOnOneKey?: boolean;
+};
+
+export declare function algoGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & AlgoGetAddressParams
+): Response<AlgoAddress>;
+
+export declare function algoGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: AlgoGetAddressParams[] }
+): Response<Array<AlgoAddress>>;

package/src/types/api/algoSignTransaction.ts

@@ -0,0 +1,17 @@
+import { AlgorandSignedTx as HardwareAlgorandSignedTx } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type AlgoSignedTx = {
+  path: string;
+} & HardwareAlgorandSignedTx;
+
+export type AlgoSignTransactionParams = {
+  path: string | number[];
+  rawTx?: string;
+};
+
+export declare function algoSignTransaction(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & AlgoSignTransactionParams
+): Response<AlgoSignedTx>;

package/src/types/api/aptosSignMessage.ts

@@ -0,0 +1,26 @@
+import { AptosMessageSignature as HardwareAptosMessageSignature } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type AptosMessageSignature = {
+  path: string;
+  fullMessage: string;
+} & HardwareAptosMessageSignature;
+
+declare type AptosMessagePayload = {
+  address?: string;
+  chainId?: string;
+  application?: string;
+  nonce: string;
+  message: string;
+};
+
+export type AptosSignMessageParams = {
+  path: string | number[];
+  payload: AptosMessagePayload;
+};
+
+export declare function aptosSignMessage(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & AptosSignMessageParams
+): Response<AptosMessageSignature>;

package/src/types/api/aptosSignTransaction.ts

@@ -13,5 +13,5 @@ export type AptosSignTransactionParams = {
 export declare function aptosSignTransaction(
   connectId: string,
   deviceId: string,
-  params: CommonParams & AptosSignTransactionParams,
+  params: CommonParams & AptosSignTransactionParams
 ): Response<AptosSignedTx>;

package/src/types/api/cosmosGetAddress.ts

@@ -0,0 +1,23 @@
+import { CosmosAddress as HardwareCosmosAddress } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type CosmosAddress = {
+  path: string;
+} & HardwareCosmosAddress;
+
+export type CosmosGetAddressParams = {
+  path: string | number[];
+  showOnOneKey?: boolean;
+};
+
+export declare function cosmosGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & CosmosGetAddressParams
+): Response<CosmosAddress>;
+
+export declare function cosmosGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: CosmosGetAddressParams[] }
+): Response<Array<CosmosAddress>>;

package/src/types/api/cosmosSignTransaction.ts

@@ -0,0 +1,17 @@
+import { CosmosSignedTx as HardwareCosmosSignedTx } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type CosmosSignedTx = {
+  path: string;
+} & HardwareCosmosSignedTx;
+
+export type CosmosSignTransactionParams = {
+  path: string | number[];
+  rawTx?: string;
+};
+
+export declare function cosmosSignTransaction(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & CosmosSignTransactionParams
+): Response<CosmosSignedTx>;

package/src/types/api/export.ts

@@ -97,4 +97,11 @@ export type { NearSignTransactionParams } from './nearSignTransaction';
 
 export type { AptosAddress, AptosGetAddressParams } from './aptosGetAddress';
 export type { AptosPublicKey, AptosGetPublicKeyParams } from './aptosGetPublicKey';
+export type { AptosMessageSignature, AptosSignMessageParams } from './aptosSignMessage';
 export type { AptosSignedTx, AptosSignTransactionParams } from './aptosSignTransaction';
+
+export type { AlgoAddress, AlgoGetAddressParams } from './algoGetAddress';
+export type { AlgoSignedTx, AlgoSignTransactionParams } from './algoSignTransaction';
+
+export type { CosmosAddress, CosmosGetAddressParams } from './cosmosGetAddress';
+export type { CosmosSignedTx, CosmosSignTransactionParams } from './cosmosSignTransaction';

package/src/types/api/firmwareUpdate.ts

@@ -9,6 +9,7 @@ export interface FirmwareUpdateParams {
   version?: number[];
   btcOnly?: boolean;
   updateType: 'firmware' | 'ble';
+  forcedUpdateRes?: boolean;
 }
 
 export declare function firmwareUpdate(

package/src/types/api/index.ts

@@ -72,8 +72,15 @@ import { nearSignTransaction } from './nearSignTransaction';
 
 import { aptosGetAddress } from './aptosGetAddress';
 import { aptosGetPublicKey } from './aptosGetPublicKey';
+import { aptosSignMessage } from './aptosSignMessage';
 import { aptosSignTransaction } from './aptosSignTransaction';
 
+import { algoGetAddress } from './algoGetAddress';
+import { algoSignTransaction } from './algoSignTransaction';
+
+import { cosmosGetAddress } from './cosmosGetAddress';
+import { cosmosSignTransaction } from './cosmosSignTransaction';
+
 export * from './export';
 
 export type CoreApi = {
@@ -195,5 +202,18 @@ export type CoreApi = {
    */
   aptosGetAddress: typeof aptosGetAddress;
   aptosGetPublicKey: typeof aptosGetPublicKey;
+  aptosSignMessage: typeof aptosSignMessage;
   aptosSignTransaction: typeof aptosSignTransaction;
+
+  /**
+   * Algo function
+   */
+  algoGetAddress: typeof algoGetAddress;
+  algoSignTransaction: typeof algoSignTransaction;
+
+  /**
+   * Cosmos function
+   */
+  cosmosGetAddress: typeof cosmosGetAddress;
+  cosmosSignTransaction: typeof cosmosSignTransaction;
 };