@onekeyfe/hd-core 0.0.8 → 0.1.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');
 
@@ -51,6 +57,7 @@ export const callAPI = async (message: CoreMessage) => {
   try {
     method = findMethod(message as IFrameCallMessage);
     method.connector = _connector;
+    method.postMessage = postMessage;
     method.init();
   } catch (error) {
     return Promise.reject(error);
@@ -100,11 +107,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 +183,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;
 

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

@@ -225,6 +225,10 @@ export class Device extends EventEmitter {
     }
   }
 
+  getCommands() {
+    return this.commands;
+  }
+
   getInternalState() {
     return this.internalState[this.instance];
   }

package/src/device/DeviceCommands.ts

@@ -205,3 +205,5 @@ export class DeviceCommands {
     });
   }
 }
+
+export type TypedCall = DeviceCommands['typedCall'];

package/src/events/ui-request.ts

@@ -14,6 +14,8 @@ export const UI_REQUEST = {
 
   BLUETOOTH_PERMISSION: 'ui-bluetooth_permission',
   LOCATION_PERMISSION: 'ui-location_permission',
+
+  FIRMWARE_PROGRESS: 'ui-firmware-progress',
 } as const;
 
 export interface UiRequestWithoutPayload {
@@ -37,7 +39,19 @@ export interface UiRequestButton {
   payload: DeviceButtonRequest['payload'];
 }
 
-export type UiEvent = UiRequestWithoutPayload | UiRequestDeviceAction | UiRequestButton;
+export interface FirmwareProgress {
+  type: typeof UI_REQUEST.FIRMWARE_PROGRESS;
+  payload: {
+    device: Device;
+    progress: number;
+  };
+}
+
+export type UiEvent =
+  | UiRequestWithoutPayload
+  | UiRequestDeviceAction
+  | UiRequestButton
+  | FirmwareProgress;
 
 export type UiEventMessage = UiEvent & { event: typeof UI_EVENT };
 

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,21 @@ 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' }),
+
+    firmwareUpdate: (connectId, params) => call({ ...params, connectId, method: 'firmwareUpdate' }),
   };
   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/firmwareUpdate.ts

@@ -0,0 +1,21 @@
+import type { PROTO } from '../../constants';
+import type { Params, Response } from '../params';
+
+export interface FirmwareUpdateBinary {
+  binary: ArrayBuffer;
+}
+
+export interface FirmwareUpdate {
+  version: number[];
+  btcOnly?: boolean;
+  updateType: 'firmware' | 'ble';
+}
+
+export declare function firmwareUpdate(
+  connectId: string | undefined,
+  params: Params<FirmwareUpdate>
+): Response<PROTO.Success>;
+export declare function firmwareUpdate(
+  connectId: string | undefined,
+  params: Params<FirmwareUpdateBinary>
+): Response<PROTO.Success>;

package/src/types/api/index.ts

@@ -32,6 +32,14 @@ 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';
+import { firmwareUpdate } from './firmwareUpdate';
 
 export * from './export';
 
@@ -61,6 +69,8 @@ export type CoreApi = {
 
   checkTransportRelease: typeof checkTransportRelease;
 
+  cipherKeyValue: typeof cipherKeyValue;
+
   deviceBackup: typeof deviceBackup;
   deviceChangePin: typeof deviceChangePin;
   deviceFlags: typeof deviceFlags;
@@ -90,4 +100,15 @@ 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;
+
+  firmwareUpdate: typeof firmwareUpdate;
 };

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

package/src/types/api/nemSignTransaction.ts

@@ -0,0 +1,117 @@
+import { NEMSignedTx } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+type MosaicID = {
+  namespaceId: string;
+  name: string;
+};
+
+type MosaicDefinition = {
+  levy?: {
+    type?: number;
+    fee?: number;
+    recipient?: string;
+    mosaicId?: MosaicID;
+  };
+  id: MosaicID;
+  description: string;
+  properties?: Array<{
+    name: 'divisibility' | 'initialSupply' | 'supplyMutable' | 'transferable';
+    value: string;
+  }>;
+};
+
+export type NEMMosaic = {
+  mosaicId: MosaicID;
+  quantity: number;
+};
+
+type Modification = {
+  modificationType: number;
+  cosignatoryAccount: string;
+};
+
+type Message = {
+  payload?: string;
+  type?: number;
+  publicKey?: string;
+};
+
+type TransactionCommon = {
+  version: number;
+  timeStamp: number;
+  fee: number;
+  deadline?: number;
+  signer?: string;
+};
+
+export type NEMTransferTransaction = TransactionCommon & {
+  type: 0x0101;
+  recipient: string;
+  amount: number | string;
+  mosaics?: NEMMosaic[];
+  message?: Message;
+};
+
+export type NEMImportanceTransaction = TransactionCommon & {
+  type: 0x0801;
+  importanceTransfer: {
+    mode: number;
+    publicKey: string;
+  };
+};
+
+export type NEMAggregateModificationTransaction = TransactionCommon & {
+  type: 0x1001;
+  modifications?: Modification[];
+  minCosignatories: {
+    relativeChange: number;
+  };
+};
+
+export type NEMProvisionNamespaceTransaction = TransactionCommon & {
+  type: 0x2001;
+  newPart?: string;
+  parent?: string;
+  rentalFeeSink?: string;
+  rentalFee?: number;
+};
+
+export type NEMMosaicCreationTransaction = TransactionCommon & {
+  type: 0x4001;
+  mosaicDefinition: MosaicDefinition;
+  creationFeeSink?: string;
+  creationFee?: number;
+};
+
+export type NEMSupplyChangeTransaction = TransactionCommon & {
+  type: 0x4002;
+  mosaicId: MosaicID;
+  supplyType: number;
+  delta?: number;
+};
+
+type Transaction =
+  | NEMTransferTransaction
+  | NEMImportanceTransaction
+  | NEMAggregateModificationTransaction
+  | NEMProvisionNamespaceTransaction
+  | NEMMosaicCreationTransaction
+  | NEMSupplyChangeTransaction;
+
+export type NEMMultisigTransaction = TransactionCommon & {
+  type: 0x0102 | 0x1002 | 0x1004;
+  otherTrans: Transaction;
+};
+
+export type NEMTransaction = Transaction | NEMMultisigTransaction;
+
+export type NEMSignTransactionParams = {
+  path: string | number[];
+  transaction: NEMTransaction;
+};
+
+export declare function nemSignTransaction(
+  connectId: string,
+  params: CommonParams & NEMSignTransactionParams
+): Response<NEMSignedTx>;

package/src/types/api/solGetAddress.ts

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

package/src/types/api/solSignTransaction.ts

@@ -0,0 +1,21 @@
+import { SolanaSignedTx as HardwareSolanaSignedTx } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type SolanaSignedTx = {
+  path: string;
+} & HardwareSolanaSignedTx;
+
+export type SolanaSignTransactionParams = {
+  path: string | number[];
+  rawTx?: string;
+};
+
+export declare function solSignTransaction(
+  connectId: string,
+  params: CommonParams & SolanaSignTransactionParams
+): Response<SolanaSignedTx>;
+
+export declare function solSignTransaction(
+  connectId: string,
+  params: CommonParams & { bundle?: SolanaSignTransactionParams[] }
+): Response<Array<SolanaSignedTx>>;

package/src/types/api/stellarGetAddress.ts

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

package/src/types/api/stellarSignTransaction.ts

@@ -0,0 +1,153 @@
+import { StellarSignedTx } from '@onekeyfe/hd-transport/src/types/messages';
+import { CommonParams, Response } from '../params';
+
+export type StellarAsset = {
+  type: 0 | 1 | 2; // 0: native, 1: credit_alphanum4, 2: credit_alphanum12
+  code: string;
+  issuer?: string;
+};
+
+type StellarCreateAccountOperation = {
+  type: 'createAccount';
+  source?: string;
+  destination: string;
+  startingBalance: string;
+};
+
+type StellarPaymentOperation = {
+  type: 'payment';
+  source?: string;
+  destination: string;
+  asset?: StellarAsset | typeof undefined;
+  amount: string;
+};
+
+type StellarPathPaymentOperation = {
+  type: 'pathPayment';
+  source?: string;
+  sendAsset: StellarAsset;
+  sendMax: string;
+  destination: string;
+  destAsset: StellarAsset;
+  destAmount: string;
+  path?: StellarAsset[];
+};
+
+type StellarPassiveOfferOperation = {
+  type: 'createPassiveOffer';
+  source?: string;
+  buying: StellarAsset;
+  selling: StellarAsset;
+  amount: string;
+  price: { n: number; d: number };
+};
+
+type StellarManageOfferOperation = {
+  type: 'manageOffer';
+  source?: string;
+  buying: StellarAsset;
+  selling: StellarAsset;
+  amount: string;
+  offerId?: string;
+  price: { n: number; d: number };
+};
+
+type StellarSetOptionsOperation = {
+  type: 'setOptions';
+  source?: string;
+  signer?: {
+    type: 0 | 1 | 2;
+    key: string | Buffer;
+    weight?: number;
+  };
+  inflationDest?: string;
+  clearFlags?: number;
+  setFlags?: number;
+  masterWeight?: number | string;
+  lowThreshold?: number | string;
+  medThreshold?: number | string;
+  highThreshold?: number | string;
+  homeDomain?: string;
+};
+
+type StellarChangeTrustOperation = {
+  type: 'changeTrust';
+  source?: string;
+  line: StellarAsset;
+  limit?: string;
+};
+
+type StellarAllowTrustOperation = {
+  type: 'allowTrust';
+  source?: string;
+  trustor: string;
+  assetCode: string;
+  assetType: number;
+  authorize?: boolean | typeof undefined;
+};
+
+type StellarAccountMergeOperation = {
+  type: 'accountMerge';
+  source?: string;
+  destination: string;
+};
+
+type StellarManageDataOperation = {
+  type: 'manageData';
+  source?: string;
+  name: string;
+  value?: Buffer | string;
+};
+
+type StellarBumpSequenceOperation = {
+  type: 'bumpSequence';
+  source?: string;
+  bumpTo: string;
+};
+
+type StellarInflationOperation = {
+  type: 'inflation';
+  source?: string;
+};
+
+export type StellarOperation =
+  | StellarCreateAccountOperation
+  | StellarPaymentOperation
+  | StellarPathPaymentOperation
+  | StellarPassiveOfferOperation
+  | StellarManageOfferOperation
+  | StellarSetOptionsOperation
+  | StellarChangeTrustOperation
+  | StellarAllowTrustOperation
+  | StellarAccountMergeOperation
+  | StellarInflationOperation
+  | StellarManageDataOperation
+  | StellarBumpSequenceOperation;
+
+export type StellarTransaction = {
+  source: string;
+  fee: number;
+  sequence: string | number;
+  timebounds?: {
+    minTime: number;
+    maxTime: number;
+  };
+  memo?: {
+    type: 0 | 1 | 2 | 3 | 4;
+    id?: string;
+    text?: string;
+    hash?: string | Buffer;
+  };
+  operations: StellarOperation[];
+};
+
+export type StellarSignTransactionParams = {
+  path: string | number[];
+  networkPassphrase: string;
+  transaction: StellarTransaction;
+};
+
+export declare function stellarSignTransaction(
+  connectId: string,
+  params: CommonParams & StellarSignTransactionParams
+): Response<StellarSignedTx>;