@onekeyfe/hd-core 0.3.40 → 0.3.41

package/src/api/btc/BTCSignMessage.ts

@@ -5,6 +5,7 @@ import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
 import { getCoinAndScriptType } from './helpers/btcParamsUtils';
+import { getBitcoinForkVersionRange } from './helpers/versionLimit';
 
 export default class BTCSignMessage extends BaseMethod<SignMessage> {
   init() {
@@ -33,6 +34,10 @@ export default class BTCSignMessage extends BaseMethod<SignMessage> {
     };
   }
 
+  getVersionRange() {
+    return getBitcoinForkVersionRange([this.params.coin_name]);
+  }
+
   async run() {
     const res = await this.device.commands.typedCall('SignMessage', 'MessageSignature', {
       ...this.params,

package/src/api/btc/BTCSignTransaction.ts

@@ -14,6 +14,7 @@ import {
 import signtx from './helpers/signtx';
 import signtxLegacy from './helpers/signtxLegacy';
 import { getCoinInfo } from './helpers/btcParamsUtils';
+import { getBitcoinForkVersionRange } from './helpers/versionLimit';
 
 type Params = {
   inputs: TxInputType[];
@@ -120,6 +121,10 @@ export default class BTCSignTransaction extends BaseMethod<Params> {
     };
   }
 
+  getVersionRange() {
+    return getBitcoinForkVersionRange([this.params.coinName]);
+  }
+
   async run() {
     const { device, params } = this;
 

package/src/api/btc/BTCVerifyMessage.ts

@@ -5,6 +5,7 @@ import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
 import { getCoinInfo } from './helpers/btcParamsUtils';
+import { getBitcoinForkVersionRange } from './helpers/versionLimit';
 
 export default class BTCVerifyMessage extends BaseMethod<VerifyMessage> {
   init() {
@@ -31,6 +32,10 @@ export default class BTCVerifyMessage extends BaseMethod<VerifyMessage> {
     };
   }
 
+  getVersionRange() {
+    return getBitcoinForkVersionRange([this.params.coin_name]);
+  }
+
   async run() {
     const res = await this.device.commands.typedCall('VerifyMessage', 'Success', {
       ...this.params,

package/src/api/btc/helpers/versionLimit.ts

@@ -0,0 +1,25 @@
+function isCoinNameInList(coinName: string, coinNames: (string | undefined)[]) {
+  for (let i = 0; i < coinNames.length; i++) {
+    const coin_name = coinNames[i];
+    if (coin_name?.toLowerCase() === coinName?.toLowerCase()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function getBitcoinForkVersionRange(params: (string | undefined)[]) {
+  if (isCoinNameInList('Neurai', params)) {
+    return {
+      model_mini: {
+        min: '3.7.0',
+      },
+      model_touch: {
+        min: '4.9.0',
+      },
+    };
+  }
+
+  // No version restrictions for other coins
+  return {};
+}

package/src/api/device/DeviceUploadResource.ts

@@ -4,7 +4,7 @@ import { bytesToHex } from '@noble/hashes/utils';
 import { ResourceUpload, Success } from '@onekeyfe/hd-transport';
 import { blake2s } from '@noble/hashes/blake2s';
 import { TypedResponseMessage } from '../../device/DeviceCommands';
-import { DeviceUploadResourceParams } from '../../types';
+import { DeviceModelToTypes, DeviceUploadResourceParams } from '../../types';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { hexToBytes } from '../helpers/hexUtils';
@@ -30,7 +30,7 @@ export default class DeviceUploadResource extends BaseMethod<ResourceUpload> {
   checkUploadNFTSupport() {
     const deviceType = getDeviceType(this.device.features);
     const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
-    if (deviceType !== 'touch') {
+    if (!DeviceModelToTypes.model_touch.includes(deviceType)) {
       throw ERRORS.TypedError(HardwareErrorCode.CallMethodError, 'Device Not Support Upload NFT');
     }
 

package/src/api/index.ts

@@ -113,4 +113,8 @@ export { default as nostrSignEvent } from './nostr/NostrSignEvent';
 export { default as nostrEncryptMessage } from './nostr/NostrEncryptMessage';
 export { default as nostrDecryptMessage } from './nostr/NostrDecryptMessage';
 export { default as nostrSignSchnorr } from './nostr/NostrSignSchnorr';
+
 export { default as lnurlAuth } from './lightning/LnurlAuth';
+
+export { default as nervosGetAddress } from './nervos/NervosGetAddress';
+export { default as nervosSignTransaction } from './nervos/NervosSignTransaction';

package/src/api/nervos/NervosGetAddress.ts

@@ -0,0 +1,76 @@
+import type { NervosGetAddress as HardwareNervosGetAddress } 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 type { NervosGetAddressParams, NervosAddress } from '../../types';
+
+export default class NervosGetAddress extends BaseMethod<HardwareNervosGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.notAllowDeviceMode = [...this.notAllowDeviceMode, UI_REQUEST.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: NervosGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+        { name: 'network', type: 'string' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+        network: batch.network,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.7.0',
+      },
+      model_touch: {
+        min: '4.9.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: NervosAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('NervosGetAddress', 'NervosAddress', {
+        ...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/nervos/NervosSignTransaction.ts

@@ -0,0 +1,113 @@
+import type { NervosSignTx as HardwareNervosSignTx, TypedCall } from '@onekeyfe/hd-transport';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import type { NervosSignTransactionParams, NervosSignedTx } from '../../types';
+import { formatAnyHex } from '../helpers/hexUtils';
+import type { TypedResponseMessage } from '../../device/DeviceCommands';
+
+type NervosSignTx = Omit<HardwareNervosSignTx, 'data_initial_chunk' | 'data_length'> & {
+  raw_tx: Buffer;
+};
+
+export default class NervosSignTransaction extends BaseMethod<NervosSignTx> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.notAllowDeviceMode = [...this.notAllowDeviceMode];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'rawTx', type: 'hexString', required: true },
+      { name: 'witnessHex', type: 'hexString', required: true },
+      { name: 'network', type: 'string', required: true },
+    ]);
+
+    // init params
+    const { path, rawTx, witnessHex, network } = this.payload as NervosSignTransactionParams;
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      raw_tx: Buffer.from(formatAnyHex(rawTx), 'hex'),
+      witness_buffer: formatAnyHex(witnessHex),
+      network,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.7.0',
+      },
+      model_touch: {
+        min: '4.9.0',
+      },
+    };
+  }
+
+  chunkByteSize = 1024;
+
+  processTxRequest = async (
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'NervosSignedTx'> | TypedResponseMessage<'NervosTxRequest'>,
+    data: Buffer,
+    offset = 0
+  ): Promise<NervosSignedTx> => {
+    if (res.type === 'NervosSignedTx') {
+      if (!res?.message?.signature) {
+        throw new Error('No signature returned');
+      }
+
+      return {
+        ...res.message,
+        path: serializedPath(this.params.address_n),
+      };
+    }
+
+    const { data_length } = res.message;
+
+    if (!data_length) {
+      if (!res?.message?.signature) {
+        throw new Error('No signature returned');
+      }
+      // sign Done
+      return {
+        ...res.message,
+        path: serializedPath(this.params.address_n),
+      };
+    }
+
+    const payload = data.subarray(offset, offset + data_length);
+    const newOffset = offset + payload.length;
+    const resourceAckParams = {
+      data_chunk: payload.toString('hex'),
+    };
+
+    const response = await typedCall('NervosTxAck', ['NervosSignedTx', 'NervosTxRequest'], {
+      ...resourceAckParams,
+    });
+
+    return this.processTxRequest(typedCall, response, data, newOffset);
+  };
+
+  async run() {
+    const dataLength = this.params.raw_tx.length;
+    const offset = dataLength;
+    const data = this.params.raw_tx;
+
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+
+    const res = await typedCall('NervosSignTx', 'NervosSignedTx', {
+      address_n: this.params.address_n,
+      data_initial_chunk: data.subarray(0, offset).toString('hex'),
+      data_length: dataLength,
+      witness_buffer: this.params.witness_buffer,
+      network: this.params.network,
+    });
+
+    return this.processTxRequest(typedCall, res, data, offset);
+  }
+}

package/src/api/sui/SuiSignTransaction.ts

@@ -9,7 +9,9 @@ import { getDeviceFirmwareVersion, getDeviceType } from '../../utils/deviceFeatu
 import { DeviceModelToTypes } from '../../types';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
 
-export default class SuiSignTransaction extends BaseMethod<HardwareSuiSignTx> {
+type SuiSignTx = Omit<HardwareSuiSignTx, 'data_initial_chunk' | 'data_length'> & HardwareSuiSignTx;
+
+export default class SuiSignTransaction extends BaseMethod<SuiSignTx> {
   init() {
     this.checkDeviceId = true;
     this.notAllowDeviceMode = [...this.notAllowDeviceMode, UI_REQUEST.INITIALIZE];
@@ -59,12 +61,12 @@ export default class SuiSignTransaction extends BaseMethod<HardwareSuiSignTx> {
     return false;
   }
 
-  chunkSize = 1024;
+  chunkByteSize = 1024;
 
   processTxRequest = async (
     typedCall: TypedCall,
     res: TypedResponseMessage<'SuiSignedTx'> | TypedResponseMessage<'SuiTxRequest'>,
-    data: string,
+    data: Buffer,
     offset = 0
   ): Promise<SuiSignedTx> => {
     if (res.type === 'SuiSignedTx') {
@@ -78,10 +80,10 @@ export default class SuiSignTransaction extends BaseMethod<HardwareSuiSignTx> {
       return res.message;
     }
 
-    const payload = data.slice(offset, offset + data_length * 2);
+    const payload = data.subarray(offset, offset + data_length);
     const newOffset = offset + payload.length;
     const resourceAckParams = {
-      data_chunk: payload,
+      data_chunk: payload.toString('hex'),
     };
 
     const response = await typedCall('SuiTxAck', ['SuiSignedTx', 'SuiTxRequest'], {
@@ -93,18 +95,17 @@ export default class SuiSignTransaction extends BaseMethod<HardwareSuiSignTx> {
 
   async run() {
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
-    const dataLength = this.params.raw_tx.length / 2;
     let offset = 0;
-    let data = '';
+    let data: Buffer;
 
     if (this.supportChunkTransfer()) {
-      offset = this.chunkSize;
-      data = this.params.raw_tx;
+      offset = this.chunkByteSize;
+      data = Buffer.from(this.params.raw_tx, 'hex');
       this.params = {
         address_n: this.params.address_n,
         raw_tx: '',
-        data_initial_chunk: this.params.raw_tx.slice(0, this.chunkSize * 2),
-        data_length: dataLength,
+        data_initial_chunk: data.subarray(0, this.chunkByteSize).toString('hex'),
+        data_length: data.length,
       };
     }
 

package/src/data/coins/bitcoin.json

@@ -39,5 +39,6 @@
   { "name": "Viacoin", "label": "VIA", "slip44": 14 },
   { "name": "ZCore", "label": "ZCR", "slip44": 428 },
   { "name": "Zcash", "label": "ZEC", "slip44": 133 },
-  { "name": "Zcash Testnet", "label": "TAZ", "slip44": 1 }
+  { "name": "Zcash Testnet", "label": "TAZ", "slip44": 1 },
+  { "name": "Neurai", "label": "XNA", "slip44": 1900 }
 ]

package/src/data/messages/messages.json

@@ -5686,15 +5686,15 @@
           "type": "bytes",
           "id": 605
         },
-        "onekey_se01_version": {
+        "onekey_se_version": {
           "type": "string",
           "id": 606
         },
-        "onekey_se01_hash": {
+        "onekey_se_hash": {
           "type": "bytes",
           "id": 607
         },
-        "onekey_se01_build_id": {
+        "onekey_se_build_id": {
           "type": "string",
           "id": 608
         },
@@ -5733,110 +5733,6 @@
         "onekey_ble_hash": {
           "type": "bytes",
           "id": 617
-        },
-        "onekey_board_build_id": {
-          "type": "string",
-          "id": 618
-        },
-        "onekey_se01_boot_version": {
-          "type": "string",
-          "id": 619
-        },
-        "onekey_se01_boot_hash": {
-          "type": "bytes",
-          "id": 620
-        },
-        "onekey_se01_boot_build_id": {
-          "type": "string",
-          "id": 621
-        },
-        "onekey_se02_version": {
-          "type": "string",
-          "id": 622
-        },
-        "onekey_se02_hash": {
-          "type": "bytes",
-          "id": 623
-        },
-        "onekey_se02_build_id": {
-          "type": "string",
-          "id": 624
-        },
-        "onekey_se02_boot_version": {
-          "type": "string",
-          "id": 625
-        },
-        "onekey_se02_boot_hash": {
-          "type": "bytes",
-          "id": 626
-        },
-        "onekey_se02_boot_build_id": {
-          "type": "string",
-          "id": 627
-        },
-        "onekey_se03_version": {
-          "type": "string",
-          "id": 628
-        },
-        "onekey_se03_hash": {
-          "type": "bytes",
-          "id": 629
-        },
-        "onekey_se03_build_id": {
-          "type": "string",
-          "id": 630
-        },
-        "onekey_se03_boot_version": {
-          "type": "string",
-          "id": 631
-        },
-        "onekey_se03_boot_hash": {
-          "type": "bytes",
-          "id": 632
-        },
-        "onekey_se03_boot_build_id": {
-          "type": "string",
-          "id": 633
-        },
-        "onekey_se04_version": {
-          "type": "string",
-          "id": 634
-        },
-        "onekey_se04_hash": {
-          "type": "bytes",
-          "id": 635
-        },
-        "onekey_se04_build_id": {
-          "type": "string",
-          "id": 636
-        },
-        "onekey_se04_boot_version": {
-          "type": "string",
-          "id": 637
-        },
-        "onekey_se04_boot_hash": {
-          "type": "bytes",
-          "id": 638
-        },
-        "onekey_se04_boot_build_id": {
-          "type": "string",
-          "id": 639
-        },
-        "onekey_se01_state": {
-          "type": "OneKeySEState",
-          "id": 640
-        },
-        "onekey_se02_state": {
-          "type": "OneKeySEState",
-          "id": 641
-        },
-        "onekey_se03_state": {
-          "type": "OneKeySEState",
-          "id": 642
-        },
-        "onekey_se04_state": {
-          "type": "OneKeySEState",
-          "id": 643
         }
       },
       "nested": {
@@ -5878,12 +5774,6 @@
             "THD89": 0,
             "SE608A": 1
           }
-        },
-        "OneKeySEState": {
-          "values": {
-            "BOOT": 0,
-            "APP": 1
-          }
         }
       }
     },

package/src/inject.ts

@@ -282,4 +282,9 @@ export const createCoreApi = (
     call({ ...params, connectId, deviceId, method: 'nostrSignSchnorr' }),
   lnurlAuth: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'lnurlAuth' }),
+
+  nervosGetAddress: (connectId, deviceId, params) =>
+    call({ ...params, connectId, deviceId, method: 'nervosGetAddress' }),
+  nervosSignTransaction: (connectId, deviceId, params) =>
+    call({ ...params, connectId, deviceId, method: 'nervosSignTransaction' }),
 });

package/src/types/api/deviceUpdateBootloader.ts

@@ -3,7 +3,7 @@ import type { Response } from '../params';
 
 export declare function deviceUpdateBootloader(
   connectId: string,
-  params: {
+  params?: {
     binary?: ArrayBuffer;
   }
 ): Response<Success>;

package/src/types/api/export.ts

@@ -146,3 +146,6 @@ export type {
   NexaSignInputParams,
   NexaSignOutputParams,
 } from './nexaSignTransaction';
+
+export type { NervosAddress, NervosGetAddressParams } from './nervosGetAddress';
+export type { NervosSignedTx, NervosSignTransactionParams } from './nervosSignTransaction';

package/src/types/api/index.ts

@@ -119,6 +119,8 @@ import { nostrDecryptMessage } from './nostrDecryptMessage';
 import { nostrSignSchnorr } from './nostrSignSchnorr';
 
 import { lnurlAuth } from './lnurlAuth';
+import { nervosGetAddress } from './nervosGetAddress';
+import { nervosSignTransaction } from './nervosSignTransaction';
 
 export * from './export';
 
@@ -323,4 +325,10 @@ export type CoreApi = {
    * Lightning Network
    */
   lnurlAuth: typeof lnurlAuth;
+
+  /**
+   * Nervos Network
+   */
+  nervosGetAddress: typeof nervosGetAddress;
+  nervosSignTransaction: typeof nervosSignTransaction;
 };

package/src/types/api/nervosGetAddress.ts

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

package/src/types/api/nervosSignTransaction.ts

@@ -0,0 +1,19 @@
+import type { NervosSignedTx as HardwareNervosSignedTx } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type NervosSignedTx = {
+  path: string;
+} & HardwareNervosSignedTx;
+
+export type NervosSignTransactionParams = {
+  path: string | number[];
+  network: string;
+  rawTx: string;
+  witnessHex: string;
+};
+
+export declare function nervosSignTransaction(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & NervosSignTransactionParams
+): Response<NervosSignedTx>;

package/src/utils/deviceFeaturesUtils.ts

@@ -86,7 +86,7 @@ export const getDeviceTypeByDeviceId = (deviceId?: string): IDeviceType => {
 export const getDeviceUUID = (features: Features) => {
   const deviceType = getDeviceType(features);
 
-  if (features.onekey_serial_no) return features.onekey_serial_no;
+  if (features?.onekey_serial_no) return features.onekey_serial_no;
 
   if (deviceType === 'classic') {
     return features.onekey_serial ?? '';