@onekeyfe/hd-core 0.1.57 → 0.1.59

package/src/api/aptos/AptosSignMessage.ts

@@ -0,0 +1,78 @@
+import { AptosSignMessage as HardwareAptosSignMessage } from '@onekeyfe/hd-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { AptosMessageSignature, AptosSignMessageParams } from '../../types';
+
+export default class AptosSignMessage extends BaseMethod<HardwareAptosSignMessage> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'payload', type: 'object', required: true },
+    ]);
+
+    const { path, payload } = this.payload as AptosSignMessageParams;
+    const addressN = validatePath(path, 3);
+
+    validateParams(payload, [
+      { name: 'address', type: 'string' },
+      { name: 'chainId', type: 'string' },
+      { name: 'application', type: 'string' },
+      { name: 'nonce', type: 'string', required: true },
+      { name: 'message', type: 'string', required: true },
+    ]);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      payload: {
+        address: payload.address,
+        chain_id: payload.chainId,
+        application: payload.application,
+        nonce: payload.nonce,
+        message: payload.message,
+      },
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.6.0',
+      },
+    };
+  }
+
+  async run() {
+    let fullMessage = 'APTOS\n';
+    if (this.params.payload.address) {
+      fullMessage += `address: ${this.params.payload.address}\n`;
+    }
+    if (this.params.payload.application) {
+      fullMessage += `application: ${this.params.payload.application}\n`;
+    }
+    if (this.params.payload.chain_id) {
+      fullMessage += `chainId: ${this.params.payload.chain_id}\n`;
+    }
+    fullMessage += `message: ${this.params.payload.message}\n`;
+    fullMessage += `nonce: ${this.params.payload.nonce}`;
+
+    const res = await this.device.commands.typedCall('AptosSignMessage', 'AptosMessageSignature', {
+      ...this.params,
+    });
+
+    const { address, signature } = res.message;
+
+    return Promise.resolve<AptosMessageSignature>({
+      path: serializedPath(this.params.address_n),
+      address,
+      signature,
+      fullMessage,
+    });
+  }
+}

package/src/api/cosmos/CosmosGetAddress.ts

@@ -0,0 +1,68 @@
+import { CosmosGetAddress as HardwareCosmosGetAddress } from '@onekeyfe/hd-transport';
+
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { CosmosAddress, CosmosGetAddressParams } from '../../types';
+
+export default class CosmosGetAddress extends BaseMethod<HardwareCosmosGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode];
+
+    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: CosmosGetAddressParams) => {
+      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,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.6.0',
+      },
+    };
+  }
+
+  async run() {
+    // TODO: add batch support
+    const responses: CosmosAddress[] = [];
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('CosmosGetAddress', 'CosmosAddress', {
+        ...param,
+      });
+
+      const { address } = res.message;
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        address,
+      });
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[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/firmware/uploadFirmware.ts

@@ -174,11 +174,7 @@ export const updateResources = async (
     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);
-      }
+      await updateResource(typedCall, name, data);
     }
 
     progress += stepProgress;

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

@@ -150,6 +150,11 @@ export const callAPI = async (message: CoreMessage) => {
       if (versionRange && device.features) {
         const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
         if (semver.valid(versionRange.min) && semver.lt(currentVersion, versionRange.min)) {
+          const newVersionUnReleased = DataManager.getFirmwareStatus(device.features);
+          if (newVersionUnReleased === 'none' || newVersionUnReleased === 'valid') {
+            throw ERRORS.TypedError(HardwareErrorCode.NewFirmwareUnRelease);
+          }
+
           return Promise.reject(
             ERRORS.TypedError(
               HardwareErrorCode.CallMethodNeedUpgradeFirmware,

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/device/DeviceCommands.ts

@@ -144,7 +144,16 @@ export class DeviceCommands {
     res: DefaultMessageResponse,
     callType: MessageKey
   ): Promise<DefaultMessageResponse> {
-    Log.debug('_filterCommonTypes: ', res);
+    try {
+      if (DataManager.getSettings('env') === 'react-native') {
+        Log.debug('_filterCommonTypes: ', JSON.stringify(res));
+      } else {
+        Log.debug('_filterCommonTypes: ', res);
+      }
+    } catch (error) {
+      // ignore
+    }
+
     if (res.type === 'Failure') {
       const { code, message } = res.message as {
         code?: string | FailureType;

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;
 };