@onekeyfe/hd-core 0.0.7 → 0.0.10

package/src/api/device/DeviceRebootToBootloader.ts

@@ -5,6 +5,17 @@ import { BaseMethod } from '../BaseMethod';
 export default class DeviceRebootToBootloader extends BaseMethod<RebootToBootloader> {
   init() {}
 
+  getVersionRange() {
+    return {
+      classic: {
+        min: '2.1.11',
+      },
+      mini: {
+        min: '2.1.11',
+      },
+    };
+  }
+
   async run() {
     const res = await this.device.commands.typedCall('RebootToBootloader', 'Success');
 

package/src/api/evm/EVMSignMessageEIP712.ts

@@ -26,6 +26,14 @@ export default class EVMSignMessageEIP712 extends BaseMethod<EthereumSignMessage
     };
   }
 
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.1.9',
+      },
+    };
+  }
+
   async run() {
     const res = await this.device.commands.typedCall(
       'EthereumSignMessageEIP712',

package/src/api/evm/EVMSignTransaction.ts

@@ -178,6 +178,21 @@ export default class EVMSignTransaction extends BaseMethod {
     return this.processTxRequest(response.message, rest, chainId);
   };
 
+  getVersionRange() {
+    if (this.isEIP1559) {
+      return {
+        model_mini: {
+          min: '2.1.11',
+        },
+      };
+    }
+    return {
+      model_mini: {
+        min: '1.0.0',
+      },
+    };
+  }
+
   async run() {
     const { addressN, isEIP1559, formattedTx } = this;
 

package/src/api/evm/EVMSignTypedData.ts

@@ -1,4 +1,6 @@
+import semver from 'semver';
 import {
+  EthereumMessageSignature,
   EthereumTypedDataSignature,
   EthereumTypedDataStructAck,
   MessageKey,
@@ -14,6 +16,8 @@ import {
   EthereumSignTypedDataMessage,
   EthereumSignTypedDataTypes,
 } from '../../types/api/evmSignTypedData';
+import { getDeviceFirmwareVersion, getDeviceType } from '../../utils/deviceFeaturesUtils';
+import { TypedResponseMessage } from '../../device/DeviceCommands';
 
 export type EVMSignTypedDataParams = {
   addressN: number[];
@@ -23,14 +27,14 @@ export type EVMSignTypedDataParams = {
   messageHash?: string;
 };
 
-export default class EVMSignMessageEIP712 extends BaseMethod<EVMSignTypedDataParams> {
+export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams> {
   init() {
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
 
     validateParams(this.payload, [
       { name: 'path', required: true },
-      { name: 'metamaskV4Compat', type: 'boolean', required: true },
-      { name: 'data', type: 'object', required: true },
+      { name: 'metamaskV4Compat', type: 'boolean' },
+      { name: 'data', type: 'object' },
       { name: 'domainHash', type: 'hexString' },
       { name: 'messageHash', type: 'hexString' },
     ]);
@@ -49,7 +53,7 @@ export default class EVMSignMessageEIP712 extends BaseMethod<EVMSignTypedDataPar
       this.params.domainHash = formatAnyHex(domainHash);
       if (messageHash) {
         this.params.messageHash = formatAnyHex(messageHash);
-      } else if (!data.primaryType || data.primaryType !== 'EIP712Domain') {
+      } else if (!!data && (!data.primaryType || data.primaryType !== 'EIP712Domain')) {
         throw ERRORS.TypedError(
           'Method_InvalidParameter',
           'message_hash should only be empty when data.primaryType=EIP712Domain'
@@ -173,6 +177,28 @@ export default class EVMSignMessageEIP712 extends BaseMethod<EVMSignTypedDataPar
   //   };
   // }
 
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.1.9',
+      },
+    };
+  }
+
+  supportSignTyped() {
+    const deviceType = getDeviceType(this.device.features);
+    if (deviceType === 'classic' || deviceType === 'mini') {
+      const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
+      const supportSignTypedVersion = '2.2.0';
+
+      if (semver.lt(currentVersion, supportSignTypedVersion)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
   async run() {
     if (!this.device.features) {
       throw ERRORS.TypedError(
@@ -184,23 +210,37 @@ export default class EVMSignMessageEIP712 extends BaseMethod<EVMSignTypedDataPar
     const { addressN } = this.params;
 
     // For Classic、Mini device we use EthereumSignTypedData
-    if (this.device.features.model === '1') {
+    const deviceType = getDeviceType(this.device.features);
+    if (deviceType === 'classic' || deviceType === 'mini') {
       validateParams(this.params, [
         { name: 'domainHash', type: 'hexString', required: true },
-        { name: 'messageHash', type: 'hexString' },
+        { name: 'messageHash', type: 'hexString', required: true },
       ]);
 
       const { domainHash, messageHash } = this.params;
 
-      const response = await this.device.commands.typedCall(
-        'EthereumSignTypedHash',
-        'EthereumTypedDataSignature',
-        {
-          address_n: addressN,
-          domain_separator_hash: domainHash ?? '',
-          message_hash: messageHash,
-        }
-      );
+      let response;
+      if (this.supportSignTyped()) {
+        response = await this.device.commands.typedCall(
+          'EthereumSignTypedHash',
+          'EthereumTypedDataSignature',
+          {
+            address_n: addressN,
+            domain_separator_hash: domainHash ?? '',
+            message_hash: messageHash,
+          }
+        );
+      } else {
+        response = await this.device.commands.typedCall(
+          'EthereumSignMessageEIP712',
+          'EthereumMessageSignature',
+          {
+            address_n: addressN,
+            domain_hash: domainHash ?? '',
+            message_hash: messageHash ?? '',
+          }
+        );
+      }
 
       return Promise.resolve(response.message);
     }

package/src/api/helpers/hexUtils.ts

@@ -44,7 +44,6 @@ export const formatAnyHex: (value: any) => any = value => {
   if (typeof value === 'object') {
     return modifyValues(value, value => formatAnyHex(value));
   }
-  console.log('unexpected value', value);
 
   return value;
 };

package/src/api/index.ts

@@ -1,5 +1,6 @@
 export { default as searchDevices } from './SearchDevices';
 export { default as getFeatures } from './GetFeatures';
+export { default as cipherKeyValue } from './CipherKeyValue';
 export { default as btcGetAddress } from './btc/BTCGetAddress';
 export { default as btcGetPublicKey } from './btc/BTCGetPublicKey';
 export { default as btcSignMessage } from './btc/BTCSignMessage';
@@ -29,3 +30,12 @@ export { default as starcoinGetPublicKey } from './starcoin/StarcoinGetPublicKey
 export { default as starcoinSignMessage } from './starcoin/StarcoinSignMessage';
 export { default as starcoinSignTransaction } from './starcoin/StarcoinSignTransaction';
 export { default as starcoinVerifyMessage } from './starcoin/StarcoinVerifyMessage';
+
+export { default as nemGetAddress } from './nem/NEMGetAddress';
+export { default as nemSignTransaction } from './nem/NEMSignTransaction';
+
+export { default as solGetAddress } from './solana/SolGetAddress';
+export { default as solSignTransaction } from './solana/SolSignTransaction';
+
+export { default as stellarGetAddress } from './stellar/StellarGetAddress';
+export { default as stellarSignTransaction } from './stellar/StellarSignTransaction';

package/src/api/nem/NEMGetAddress.ts

@@ -0,0 +1,61 @@
+import { NEMGetAddress as HardwareNEMGetAddress } from '@onekeyfe/hd-transport/src/types/messages';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath, serializedPath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { NEMAddress, NEMGetAddressParams } from '../../types';
+
+const MAINNET = 0x68; // 104
+
+export default class NEMGetAddress extends BaseMethod<HardwareNEMGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, 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: NEMGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'network', type: 'number' },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        network: batch.network || MAINNET,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  async run() {
+    const responses: NEMAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('NEMGetAddress', 'NEMAddress', {
+        ...param,
+      });
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        ...res.message,
+      });
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/nem/NEMSignTransaction.ts

@@ -0,0 +1,246 @@
+import {
+  NEMAggregateModification,
+  NEMImportanceTransfer,
+  NEMMosaicCreation,
+  NEMMosaicDefinition,
+  NEMMosaicSupplyChange,
+  NEMProvisionNamespace,
+  NEMSignTx,
+  NEMTransactionCommon,
+  NEMTransfer,
+} from '@onekeyfe/hd-transport/src/types/messages';
+
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import {
+  NEMAggregateModificationTransaction,
+  NEMImportanceTransaction,
+  NEMMosaicCreationTransaction,
+  NEMProvisionNamespaceTransaction,
+  NEMSupplyChangeTransaction,
+  NEMTransaction,
+  NEMTransferTransaction,
+} from '../../types';
+import { ERRORS } from '../../constants';
+
+const NEM_TRANSFER = 0x0101;
+const NEM_COSIGNING = 0x0102;
+const NEM_IMPORTANCE_TRANSFER = 0x0801;
+const NEM_AGGREGATE_MODIFICATION = 0x1001;
+const NEM_MULTISIG_SIGNATURE = 0x1002;
+const NEM_MULTISIG = 0x1004;
+const NEM_PROVISION_NAMESPACE = 0x2001;
+const NEM_MOSAIC_CREATION = 0x4001;
+const NEM_SUPPLY_CHANGE = 0x4002;
+
+export default class NEMSignTransaction extends BaseMethod<NEMSignTx> {
+  NEM_MOSAIC_LEVY_TYPES: Record<number, string> = {
+    1: 'MosaicLevy_Absolute',
+    2: 'MosaicLevy_Percentile',
+  };
+
+  NEM_SUPPLY_CHANGE_TYPES: Record<number, string> = {
+    1: 'SupplyChange_Increase',
+    2: 'SupplyChange_Decrease',
+  };
+
+  NEM_AGGREGATE_MODIFICATION_TYPES: Record<number, string> = {
+    1: 'CosignatoryModification_Add',
+    2: 'CosignatoryModification_Delete',
+  };
+
+  NEM_IMPORTANCE_TRANSFER_MODES: Record<number, string> = {
+    1: 'ImportanceTransfer_Activate',
+    2: 'ImportanceTransfer_Deactivate',
+  };
+
+  getCommon = (tx: NEMTransaction, address_n?: number[]): NEMTransactionCommon => ({
+    address_n,
+    // eslint-disable-next-line no-bitwise
+    network: (tx.version >> 24) & 0xff,
+    timestamp: tx.timeStamp,
+    fee: tx.fee,
+    deadline: tx.deadline ?? 0,
+    signer: address_n ? undefined : tx.signer,
+  });
+
+  transferMessage = (tx: NEMTransferTransaction): NEMTransfer => {
+    const mosaics = tx.mosaics
+      ? tx.mosaics.map(mosaic => ({
+          namespace: mosaic.mosaicId.namespaceId,
+          mosaic: mosaic.mosaicId.name,
+          quantity: mosaic.quantity,
+        }))
+      : undefined;
+
+    return {
+      recipient: tx.recipient,
+      amount: tx.amount,
+      payload: tx.message ? tx.message.payload : undefined,
+      public_key: tx.message && tx.message.type === 0x02 ? tx.message.publicKey : undefined,
+      mosaics,
+    };
+  };
+
+  importanceTransferMessage = (tx: NEMImportanceTransaction): NEMImportanceTransfer => ({
+    // @ts-expect-error
+    mode: this.NEM_IMPORTANCE_TRANSFER_MODES[tx.importanceTransfer.mode],
+    public_key: tx.importanceTransfer.publicKey,
+  });
+
+  aggregateModificationMessage = (
+    tx: NEMAggregateModificationTransaction
+  ): NEMAggregateModification => {
+    const modifications = tx.modifications
+      ? tx.modifications.map(modification => ({
+          type: this.NEM_AGGREGATE_MODIFICATION_TYPES[modification.modificationType],
+          public_key: modification.cosignatoryAccount,
+        }))
+      : undefined;
+
+    return {
+      // @ts-expect-error
+      modifications,
+      relative_change: tx.minCosignatories.relativeChange,
+    };
+  };
+
+  provisionNamespaceMessage = (tx: NEMProvisionNamespaceTransaction): NEMProvisionNamespace => ({
+    namespace: tx.newPart ?? '',
+    parent: tx.parent || undefined,
+    sink: tx.rentalFeeSink ?? '',
+    fee: tx.rentalFee ?? 0,
+  });
+
+  mosaicCreationMessage = (tx: NEMMosaicCreationTransaction): NEMMosaicCreation => {
+    const { levy } = tx.mosaicDefinition;
+
+    const definition: NEMMosaicDefinition = {
+      namespace: tx.mosaicDefinition.id.namespaceId,
+      mosaic: tx.mosaicDefinition.id.name,
+      // @ts-expect-error
+      levy: levy && levy.type ? this.NEM_MOSAIC_LEVY_TYPES[levy.type] : undefined,
+      fee: levy && levy.fee,
+      levy_address: levy && levy.recipient,
+      levy_namespace: levy && levy.mosaicId && levy.mosaicId.namespaceId,
+      levy_mosaic: levy && levy.mosaicId && levy.mosaicId.name,
+      description: tx.mosaicDefinition.description,
+    };
+
+    const { properties } = tx.mosaicDefinition;
+    if (Array.isArray(properties)) {
+      properties.forEach(property => {
+        const { name, value } = property;
+        switch (name) {
+          case 'divisibility':
+            definition.divisibility = parseInt(value);
+            break;
+
+          case 'initialSupply':
+            definition.supply = parseInt(value);
+            break;
+
+          case 'supplyMutable':
+            definition.mutable_supply = value === 'true';
+            break;
+
+          case 'transferable':
+            definition.transferable = value === 'true';
+            break;
+          default:
+        }
+      });
+    }
+
+    return {
+      definition,
+      sink: tx.creationFeeSink ?? '',
+      fee: tx.creationFee ?? 0,
+    };
+  };
+
+  supplyChangeMessage = (tx: NEMSupplyChangeTransaction): NEMMosaicSupplyChange => ({
+    namespace: tx.mosaicId.namespaceId,
+    mosaic: tx.mosaicId.name,
+    // @ts-expect-error
+    type: this.NEM_SUPPLY_CHANGE_TYPES[tx.supplyType],
+    delta: tx.delta ?? 0,
+  });
+
+  parseTx = (tx: NEMTransaction, address_n: number[]) => {
+    let transaction = tx;
+    const message: NEMSignTx = {
+      transaction: this.getCommon(tx, address_n),
+      transfer: undefined,
+      importance_transfer: undefined,
+      aggregate_modification: undefined,
+      provision_namespace: undefined,
+      mosaic_creation: undefined,
+      supply_change: undefined,
+    };
+
+    if (
+      tx.type === NEM_COSIGNING ||
+      tx.type === NEM_MULTISIG ||
+      tx.type === NEM_MULTISIG_SIGNATURE
+    ) {
+      message.cosigning = tx.type === NEM_COSIGNING || tx.type === NEM_MULTISIG_SIGNATURE;
+      transaction = tx.otherTrans;
+      message.multisig = this.getCommon(transaction);
+    }
+
+    switch (transaction.type) {
+      case NEM_TRANSFER:
+        message.transfer = this.transferMessage(transaction);
+        break;
+
+      case NEM_IMPORTANCE_TRANSFER:
+        message.importance_transfer = this.importanceTransferMessage(transaction);
+        break;
+
+      case NEM_AGGREGATE_MODIFICATION:
+        message.aggregate_modification = this.aggregateModificationMessage(transaction);
+        break;
+
+      case NEM_PROVISION_NAMESPACE:
+        message.provision_namespace = this.provisionNamespaceMessage(transaction);
+        break;
+
+      case NEM_MOSAIC_CREATION:
+        message.mosaic_creation = this.mosaicCreationMessage(transaction);
+        break;
+
+      case NEM_SUPPLY_CHANGE:
+        message.supply_change = this.supplyChangeMessage(transaction);
+        break;
+
+      default:
+        throw ERRORS.TypedError('Method_InvalidParameter', 'Unknown transaction type');
+    }
+
+    return message;
+  };
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'transaction', type: 'object', required: true },
+    ]);
+    const { path, transaction } = this.payload;
+    const addressN = validatePath(path, 3);
+
+    this.params = this.parseTx(transaction, addressN);
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('NEMSignTx', 'NEMSignedTx', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res);
+  }
+}

package/src/api/solana/SolGetAddress.ts

@@ -0,0 +1,59 @@
+import { SolanaGetAddress } from '@onekeyfe/hd-transport/src/types/messages';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { SolanaAddress, SolanaGetAddressParams } from '../../types';
+
+export default class SolGetAddress extends BaseMethod<SolanaGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, 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: SolanaGetAddressParams) => {
+      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,
+      });
+    });
+  }
+
+  async run() {
+    const responses: SolanaAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('SolanaGetAddress', 'SolanaAddress', {
+        ...param,
+      });
+
+      const { address } = res.message;
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        address,
+      });
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/solana/SolSignTransaction.ts

@@ -0,0 +1,69 @@
+import { SolanaSignTx as HardwareSolanaSignTx } from '@onekeyfe/hd-transport/src/types/messages';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { SolanaSignedTx, SolanaSignTransactionParams } from '../../types';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+export default class SolSignTransaction extends BaseMethod<HardwareSolanaSignTx[]> {
+  hasBundle = false;
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, 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: SolanaSignTransactionParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'rawTx', type: 'hexString', required: true },
+      ]);
+
+      this.params.push({
+        address_n: addressN,
+        raw_tx: formatAnyHex(batch.rawTx),
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      classic: {
+        min: '2.1.9',
+      },
+      mini: {
+        min: '2.1.9',
+      },
+    };
+  }
+
+  async run() {
+    const responses: SolanaSignedTx[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('SolanaSignTx', 'SolanaSignedTx', {
+        ...param,
+      });
+
+      const { signature } = res.message;
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        signature,
+      });
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}