@onekeyfe/hd-core 0.0.6 → 0.0.9

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]);
+  }
+}

package/src/api/stellar/StellarGetAddress.ts

@@ -0,0 +1,59 @@
+import { StellarGetAddress as HardwareStellarGetAddress } 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 { StellarGetAddressParams, StellarAddress } from '../../types';
+
+export default class StellarGetAddress extends BaseMethod<HardwareStellarGetAddress[]> {
+  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: StellarGetAddressParams) => {
+      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: StellarAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('StellarGetAddress', 'StellarAddress', {
+        ...param,
+      });
+
+      const { address } = res.message;
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        address,
+      });
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/stellar/StellarSignTransaction.ts

@@ -0,0 +1,213 @@
+import {
+  StellarSignedTx,
+  StellarSignTx as HardwareStellarSignTx,
+} 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 { StellarOperation, StellarSignTransactionParams } from '../../types';
+
+export default class StellarSignTransaction extends BaseMethod<HardwareStellarSignTx> {
+  operations: any[] = [];
+
+  parseOperation = (op: StellarOperation) => {
+    switch (op.type) {
+      case 'createAccount':
+        validateParams(op, [
+          { name: 'destination', type: 'string', required: true },
+          { name: 'startingBalance', type: 'bigNumber', required: true },
+        ]);
+        return {
+          type: 'StellarCreateAccountOp',
+          source_account: op.source,
+          new_account: op.destination,
+          starting_balance: op.startingBalance,
+        };
+
+      case 'payment':
+        validateParams(op, [
+          { name: 'destination', type: 'string', required: true },
+          { name: 'amount', type: 'bigNumber', required: true },
+          { name: 'asset', required: true },
+        ]);
+        return {
+          type: 'StellarPaymentOp',
+          source_account: op.source,
+          destination_account: op.destination,
+          asset: op.asset,
+          amount: op.amount,
+        };
+
+      case 'pathPayment':
+        validateParams(op, [{ name: 'destAmount', type: 'bigNumber', required: true }]);
+        return {
+          type: 'StellarPathPaymentOp',
+          source_account: op.source,
+          send_asset: op.sendAsset,
+          send_max: op.sendMax,
+          destination_account: op.destination,
+          destination_asset: op.destAsset,
+          destination_amount: op.destAmount,
+          paths: op.path,
+        };
+
+      case 'createPassiveOffer':
+        validateParams(op, [{ name: 'amount', type: 'bigNumber', required: true }]);
+        return {
+          type: 'StellarCreatePassiveOfferOp',
+          source_account: op.source,
+          buying_asset: op.buying,
+          selling_asset: op.selling,
+          amount: op.amount,
+          price_n: op.price.n,
+          price_d: op.price.d,
+        };
+
+      case 'manageOffer':
+        validateParams(op, [{ name: 'amount', type: 'bigNumber', required: true }]);
+        return {
+          type: 'StellarManageOfferOp',
+          source_account: op.source,
+          buying_asset: op.buying,
+          selling_asset: op.selling,
+          amount: op.amount,
+          offer_id: op.offerId,
+          price_n: op.price.n,
+          price_d: op.price.d,
+        };
+
+      case 'setOptions': {
+        const signer = op.signer
+          ? {
+              signer_type: op.signer.type,
+              signer_key: op.signer.key,
+              signer_weight: op.signer.weight,
+            }
+          : undefined;
+        return {
+          type: 'StellarSetOptionsOp',
+          source_account: op.source,
+          clear_flags: op.clearFlags,
+          set_flags: op.setFlags,
+          master_weight: op.masterWeight,
+          low_threshold: op.lowThreshold,
+          medium_threshold: op.medThreshold,
+          high_threshold: op.highThreshold,
+          home_domain: op.homeDomain,
+          inflation_destination_account: op.inflationDest,
+          ...signer,
+        };
+      }
+
+      case 'changeTrust':
+        validateParams(op, [{ name: 'limit', type: 'bigNumber' }]);
+        return {
+          type: 'StellarChangeTrustOp',
+          source_account: op.source,
+          asset: op.line,
+          limit: op.limit,
+        };
+
+      case 'allowTrust':
+        return {
+          type: 'StellarAllowTrustOp',
+          source_account: op.source,
+          trusted_account: op.trustor,
+          asset_type: op.assetType,
+          asset_code: op.assetCode,
+          is_authorized: op.authorize ? 1 : 0,
+        };
+
+      case 'accountMerge':
+        return {
+          type: 'StellarAccountMergeOp',
+          source_account: op.source,
+          destination_account: op.destination,
+        };
+
+      case 'manageData':
+        return {
+          type: 'StellarManageDataOp',
+          source_account: op.source,
+          key: op.name,
+          value: op.value,
+        };
+
+      case 'bumpSequence':
+        return {
+          type: 'StellarBumpSequenceOp',
+          source_account: op.source,
+          bump_to: op.bumpTo,
+        };
+      default:
+        return {};
+    }
+  };
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'networkPassphrase', type: 'string', required: true },
+      { name: 'transaction', type: 'object', required: true },
+    ]);
+
+    // init params
+    const addressN = validatePath(this.payload.path, 3);
+    const { transaction, networkPassphrase } = this.payload as StellarSignTransactionParams;
+
+    this.params = {
+      address_n: addressN,
+      network_passphrase: networkPassphrase,
+      source_account: transaction.source,
+      fee: transaction.fee,
+      sequence_number: transaction.sequence,
+      num_operations: transaction.operations.length,
+    };
+
+    if (transaction.timebounds) {
+      this.params.timebounds_start = transaction.timebounds.minTime;
+      this.params.timebounds_end = transaction.timebounds.maxTime;
+    }
+
+    if (transaction.memo) {
+      this.params.memo_type = transaction.memo.type;
+      this.params.memo_text = transaction.memo.text;
+      this.params.memo_id = transaction.memo.id;
+      this.params.memo_hash = transaction.memo.hash;
+    }
+
+    transaction.operations.forEach(op => {
+      const transformed = this.parseOperation(op);
+      if (transformed) {
+        this.operations.push(transformed);
+      }
+    });
+
+    console.log('StellarSignTransactionParams', this.params);
+    console.log('StellarSignTransactionOperations', this.operations);
+  }
+
+  processTxRequest = async (operations: any, index: number): Promise<StellarSignedTx> => {
+    const isLastOp = index + 1 >= operations.length;
+    const { type, ...op } = operations[index];
+
+    if (isLastOp) {
+      const response = await this.device.commands.typedCall(type, 'StellarSignedTx', op);
+      return response.message;
+    }
+
+    await this.device.commands.typedCall(type, 'StellarTxOpRequest', op);
+
+    return this.processTxRequest(operations, index + 1);
+  };
+
+  async run() {
+    await this.device.commands.typedCall('StellarSignTx', 'StellarTxOpRequest', { ...this.params });
+
+    return this.processTxRequest(this.operations, 0);
+  }
+}

package/src/core/index.ts

@@ -1,3 +1,4 @@
+import semver from 'semver';
 import EventEmitter from 'events';
 import { OneKeyDeviceInfo } from '@onekeyfe/hd-transport';
 import { ERRORS } from '../constants';
@@ -25,6 +26,11 @@ import type { BaseMethod } from '../api/BaseMethod';
 import type { ConnectSettings, KnownDevice } from '../types';
 import TransportManager from '../data-manager/TransportManager';
 import DeviceConnector from '../device/DeviceConnector';
+import {
+  getDeviceFirmwareVersion,
+  getDeviceModel,
+  getDeviceType,
+} from '../utils/deviceFeaturesUtils';
 
 const Log = initLog('Core');
 
@@ -100,11 +106,38 @@ export const callAPI = async (message: CoreMessage) => {
 
   try {
     const inner = async (): Promise<void> => {
-      // check firmware status
-      // const firmwareException = method.checkFirmwareRange();
-      // if (firmwareException) {
-      //   return Promise.reject(ERRORS.TypedError('Device_FwException', firmwareException));
-      // }
+      // check firmware version
+      const deviceType = getDeviceType(device.features);
+      const deviceModel = getDeviceModel(device.features);
+      const versionRangeType = method.getVersionRange()[deviceType];
+      const versionRangeModel = method.getVersionRange()[deviceModel];
+
+      // Type has a higher priority than Model
+      const versionRange = versionRangeType ?? versionRangeModel;
+
+      if (versionRange && device.features) {
+        const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
+        if (semver.valid(versionRange.min) && semver.lt(currentVersion, versionRange.min)) {
+          return Promise.reject(
+            ERRORS.TypedError(
+              'Device_FwException',
+              `Device firmware version is too low, please update to ${versionRange.min}`
+            )
+          );
+        }
+        if (
+          versionRange.max &&
+          semver.valid(versionRange.max) &&
+          semver.gt(currentVersion, versionRange.max)
+        ) {
+          return Promise.reject(
+            ERRORS.TypedError(
+              'Device_FwException',
+              `Device firmware version is too high, this method has been deprecated in ${versionRange.max}`
+            )
+          );
+        }
+      }
 
       // check call method mode
       const unexpectedMode = device.hasUnexpectedMode(
@@ -149,6 +182,7 @@ export const callAPI = async (message: CoreMessage) => {
   } catch (error) {
     messageResponse = createResponseMessage(method.responseID, false, error);
     _callPromise?.reject(ERRORS.TypedError('Call_API', error));
+    Log.debug('Call API - Run Error: ', error);
   } finally {
     const response = messageResponse;
 
@@ -251,7 +285,17 @@ const onDevicePinHandler = async (...[device, type, callback]: DeviceEvents['pin
 
 const onDeviceButtonHandler = (...[device, request]: [...DeviceEvents['button']]) => {
   postMessage(createDeviceMessage(DEVICE.BUTTON, { ...request, device: device.toMessageObject() }));
-  postMessage(createUiMessage(UI_REQUEST.REQUEST_BUTTON, { device: device.toMessageObject() }));
+
+  if (request.code === 'ButtonRequest_PinEntry') {
+    postMessage(
+      createUiMessage(UI_REQUEST.REQUEST_PIN, {
+        device: device.toMessageObject() as KnownDevice,
+        type: 'ButtonRequest_PinEntry',
+      })
+    );
+  } else {
+    postMessage(createUiMessage(UI_REQUEST.REQUEST_BUTTON, { device: device.toMessageObject() }));
+  }
 };
 
 /**

package/src/data/version.ts

@@ -1,3 +1,3 @@
 export const VERSION = '1.0.0-alpha.1';
 
-export const DEFAULT_DOMAIN = `https://localhost:8088/`;
+export const DEFAULT_DOMAIN = `https://hardware-sdk.onekey.so/`;

package/src/events/ui-request.ts

@@ -28,7 +28,7 @@ export type UiRequestDeviceAction = {
   type: typeof UI_REQUEST.REQUEST_PIN;
   payload: {
     device: Device;
-    type?: PROTO.PinMatrixRequestType;
+    type?: PROTO.PinMatrixRequestType | 'ButtonRequest_PinEntry';
   };
 };
 

package/src/inject.ts

@@ -66,6 +66,8 @@ export const inject = ({
      */
     checkTransportRelease: () => call({ method: 'checkTransportRelease' }),
 
+    cipherKeyValue: (connectId, params) => call({ ...params, connectId, method: 'cipherKeyValue' }),
+
     deviceBackup: connectId => call({ connectId, method: 'deviceBackup' }),
     deviceChangePin: (connectId, params) =>
       call({ ...params, connectId, method: 'deviceChangePin' }),
@@ -109,6 +111,19 @@ export const inject = ({
       call({ ...params, connectId, method: 'starcoinSignTransaction' }),
     starcoinVerifyMessage: (connectId, params) =>
       call({ ...params, connectId, method: 'starcoinVerifyMessage' }),
+
+    nemGetAddress: (connectId, params) => call({ ...params, connectId, method: 'nemGetAddress' }),
+    nemSignTransaction: (connectId, params) =>
+      call({ ...params, connectId, method: 'nemSignTransaction' }),
+
+    solGetAddress: (connectId, params) => call({ ...params, connectId, method: 'solGetAddress' }),
+    solSignTransaction: (connectId, params) =>
+      call({ ...params, connectId, method: 'solSignTransaction' }),
+
+    stellarGetAddress: (connectId, params) =>
+      call({ ...params, connectId, method: 'stellarGetAddress' }),
+    stellarSignTransaction: (connectId, params) =>
+      call({ ...params, connectId, method: 'stellarSignTransaction' }),
   };
   return api;
 };

package/src/types/api/cipherKeyValue.ts

@@ -0,0 +1,26 @@
+import { CipheredKeyValue as HardwareCipheredKeyValue } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type CipheredKeyValue = {
+  path: string;
+} & HardwareCipheredKeyValue;
+
+export type CipheredKeyValueParams = {
+  path: string | number[];
+  key: string;
+  value: string;
+  encrypt?: boolean;
+  askOnEncrypt?: boolean;
+  askOnDecrypt?: boolean;
+  iv?: string;
+};
+
+export declare function cipherKeyValue(
+  connectId: string,
+  params: CommonParams & CipheredKeyValueParams
+): Response<CipheredKeyValue>;
+
+export declare function cipherKeyValue(
+  connectId: string,
+  params: CommonParams & { bundle?: CipheredKeyValueParams[] }
+): Response<Array<CipheredKeyValue>>;

package/src/types/api/export.ts

@@ -11,6 +11,8 @@ export type {
   TransactionOptions,
 } from './btcSignTransaction';
 
+export type { CipheredKeyValue, CipheredKeyValueParams } from './cipherKeyValue';
+
 export type { DeviceChangePinParams } from './deviceChangePin';
 export type { DeviceFlagsParams } from './deviceFlags';
 export type { DeviceRecoveryParams } from './deviceRecovery';
@@ -41,3 +43,28 @@ export type { StarcoinPublicKey, StarcoinGetPublicKeyParams } from './starcoinGe
 export type { StarcoinSignMessageParams } from './starcoinSignMessage';
 export type { StarcoinSignTransactionParams } from './starcoinSignTransaction';
 export type { StarcoinVerifyMessageParams } from './starcoinVerifyMessage';
+
+export type { NEMAddress, NEMGetAddressParams } from './nemGetAddress';
+export type {
+  NEMAggregateModificationTransaction,
+  NEMImportanceTransaction,
+  NEMMosaic,
+  NEMMosaicCreationTransaction,
+  NEMMultisigTransaction,
+  NEMProvisionNamespaceTransaction,
+  NEMSupplyChangeTransaction,
+  NEMTransferTransaction,
+  NEMTransaction,
+  NEMSignTransactionParams,
+} from './nemSignTransaction';
+
+export type { SolanaAddress, SolanaGetAddressParams } from './solGetAddress';
+export type { SolanaSignedTx, SolanaSignTransactionParams } from './solSignTransaction';
+
+export type { StellarAddress, StellarGetAddressParams } from './stellarGetAddress';
+export type {
+  StellarAsset,
+  StellarOperation,
+  StellarTransaction,
+  StellarSignTransactionParams,
+} from './stellarSignTransaction';

package/src/types/api/index.ts

@@ -32,6 +32,13 @@ import { starcoinGetPublicKey } from './starcoinGetPublicKey';
 import { starcoinSignMessage } from './starcoinSignMessage';
 import { starcoinSignTransaction } from './starcoinSignTransaction';
 import { starcoinVerifyMessage } from './starcoinVerifyMessage';
+import { nemGetAddress } from './nemGetAddress';
+import { nemSignTransaction } from './nemSignTransaction';
+import { solGetAddress } from './solGetAddress';
+import { solSignTransaction } from './solSignTransaction';
+import { stellarGetAddress } from './stellarGetAddress';
+import { stellarSignTransaction } from './stellarSignTransaction';
+import { cipherKeyValue } from './cipherKeyValue';
 
 export * from './export';
 
@@ -61,6 +68,8 @@ export type CoreApi = {
 
   checkTransportRelease: typeof checkTransportRelease;
 
+  cipherKeyValue: typeof cipherKeyValue;
+
   deviceBackup: typeof deviceBackup;
   deviceChangePin: typeof deviceChangePin;
   deviceFlags: typeof deviceFlags;
@@ -90,4 +99,13 @@ export type CoreApi = {
   starcoinSignMessage: typeof starcoinSignMessage;
   starcoinSignTransaction: typeof starcoinSignTransaction;
   starcoinVerifyMessage: typeof starcoinVerifyMessage;
+
+  nemGetAddress: typeof nemGetAddress;
+  nemSignTransaction: typeof nemSignTransaction;
+
+  solGetAddress: typeof solGetAddress;
+  solSignTransaction: typeof solSignTransaction;
+
+  stellarGetAddress: typeof stellarGetAddress;
+  stellarSignTransaction: typeof stellarSignTransaction;
 };

package/src/types/api/nemGetAddress.ts

@@ -0,0 +1,22 @@
+import { NEMAddress as HardwareNEMAddress } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type NEMAddress = {
+  path: string;
+} & HardwareNEMAddress;
+
+export type NEMGetAddressParams = {
+  path: string | number[];
+  network?: number;
+  showOnOneKey?: boolean;
+};
+
+export declare function nemGetAddress(
+  connectId: string,
+  params: CommonParams & NEMGetAddressParams
+): Response<NEMAddress>;
+
+export declare function nemGetAddress(
+  connectId: string,
+  params: CommonParams & { bundle?: NEMGetAddressParams[] }
+): Response<Array<NEMAddress>>;