@onekeyfe/hd-core 0.1.17 → 0.1.20

package/src/device/Device.ts

@@ -1,6 +1,12 @@
 import EventEmitter from 'events';
 import { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
-import { createDeferred, Deferred, HardwareErrorCode, ERRORS } from '@onekeyfe/hd-shared';
+import {
+  createDeferred,
+  Deferred,
+  HardwareErrorCode,
+  ERRORS,
+  HardwareError,
+} from '@onekeyfe/hd-shared';
 
 import DeviceConnector from './DeviceConnector';
 import { DeviceCommands } from './DeviceCommands';
@@ -14,7 +20,7 @@ import {
   getDeviceTypeOnBootloader,
 } from '../utils/deviceFeaturesUtils';
 import type { Features, Device as DeviceTyped, UnavailableCapabilities } from '../types';
-import { DEVICE, DeviceButtonRequestPayload } from '../events';
+import { DEVICE, DeviceButtonRequestPayload, DeviceFeaturesPayload } from '../events';
 import { UI_REQUEST } from '../constants/ui-request';
 import { PROTO } from '../constants';
 import { getLogger, LoggerNames } from '../utils';
@@ -35,6 +41,7 @@ export interface DeviceEvents {
   [DEVICE.PIN]: [Device, PROTO.PinMatrixRequestType | undefined, (err: any, pin: string) => void];
   [DEVICE.PASSPHRASE_ON_DEVICE]: [Device, ((response: any) => void)?];
   [DEVICE.BUTTON]: [Device, DeviceButtonRequestPayload];
+  [DEVICE.FEATURES]: [Device, DeviceFeaturesPayload];
 }
 
 export interface Device {
@@ -186,7 +193,7 @@ export class Device extends EventEmitter {
       }
       this.updateDescriptor({ [mainIdKey]: this.mainId } as unknown as DeviceDescriptor);
       if (this.commands) {
-        this.commands.dispose();
+        await this.commands.dispose(false);
       }
 
       this.commands = new DeviceCommands(this, this.mainId ?? '');
@@ -207,7 +214,7 @@ export class Device extends EventEmitter {
       (this.mainId && env === 'react-native')
     ) {
       if (this.commands) {
-        this.commands.dispose();
+        this.commands.dispose(false);
         if (this.commands.callPromise) {
           try {
             await this.commands.callPromise;
@@ -263,6 +270,7 @@ export class Device extends EventEmitter {
 
     this.features = feat;
     this.featuresNeedsReload = false;
+    this.emit(DEVICE.FEATURES, this, feat);
   }
 
   /**
@@ -298,7 +306,7 @@ export class Device extends EventEmitter {
 
   async run(fn?: () => Promise<void>, options?: RunOptions) {
     if (this.runPromise) {
-      this.interruption();
+      await this.interruptionFromOutside();
       Log.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
     }
 
@@ -317,6 +325,9 @@ export class Device extends EventEmitter {
         }
       } catch (error) {
         this.runPromise = null;
+        if (error instanceof HardwareError) {
+          return Promise.reject(error);
+        }
         return Promise.reject(
           ERRORS.TypedError(
             HardwareErrorCode.DeviceInitializeFailed,
@@ -350,15 +361,24 @@ export class Device extends EventEmitter {
     this.runPromise = null;
   }
 
-  interruption() {
+  async interruptionFromOutside() {
     if (this.commands) {
-      this.commands.dispose();
+      await this.commands.dispose(false);
     }
     if (this.runPromise) {
       this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromOutside));
     }
   }
 
+  async interruptionFromUser() {
+    if (this.commands) {
+      await this.commands.dispose(true);
+    }
+    if (this.runPromise) {
+      this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser));
+    }
+  }
+
   getMode() {
     if (this.features?.bootloader_mode) return 'bootloader';
     if (!this.features?.initialized) return 'initialize';
@@ -429,6 +449,13 @@ export class Device extends EventEmitter {
     }
     return null;
   }
+
+  checkDeviceId(deviceId: string) {
+    if (this.features) {
+      return this.features.device_id === deviceId;
+    }
+    return false;
+  }
 }
 
 export default Device;

package/src/device/DeviceCommands.ts

@@ -54,13 +54,13 @@ export class DeviceCommands {
     this.disposed = false;
   }
 
-  dispose() {
+  async dispose(cancelRequest: boolean) {
     this.disposed = true;
-    if (this._cancelableRequest) {
+    if (cancelRequest && this._cancelableRequest) {
       this._cancelableRequest();
     }
     this._cancelableRequest = undefined;
-    this.transport.cancel?.();
+    await this.transport.cancel?.();
   }
 
   // Sends an async message to the opened device.
@@ -206,7 +206,10 @@ export class DeviceCommands {
     }
 
     if (res.type === 'PassphraseRequest') {
-      // TODO: PassphraseRequest
+      /**
+       * Temporary, callback an empty passphrase
+       */
+      return this._commonCall('PassphraseAck', { passphrase: '' });
     }
 
     // TT fw lower than 2.3.0, device send his current state

package/src/device/DeviceList.ts

@@ -4,7 +4,8 @@ import { Device } from './Device';
 import { getDeviceUUID } from '../utils/deviceFeaturesUtils';
 import { getLogger, LoggerNames } from '../utils';
 
-const cacheDeviceMap = new Map<string, Device>();
+// const cacheDeviceMap = new Map<string, Device>();
+const cacheDeviceMap: Record<string, Device> = {};
 
 const Log = getLogger(LoggerNames.DeviceList);
 
@@ -17,13 +18,28 @@ export class DeviceList extends EventEmitter {
    * 获取已连接的设备列表
    * @returns {OneKeyDeviceInfo[]}
    */
-  async getDeviceLists() {
+  async getDeviceLists(connectId?: string) {
     const deviceDiff = await this.connector?.enumerate();
     const descriptorList = deviceDiff?.descriptors ?? [];
 
     this.devices = {};
     const deviceList = [];
     Log.debug('get device list');
+
+    // find existed device
+    if (connectId) {
+      const device = cacheDeviceMap[connectId];
+      if (device) {
+        const exist = descriptorList.find(d => d.path === device.originalDescriptor.path);
+        if (exist) {
+          device.updateDescriptor(exist, true);
+          Log.debug('find existed Device: ', connectId);
+          this.devices[connectId] = device;
+          return [device];
+        }
+      }
+    }
+
     for await (const descriptor of descriptorList) {
       let device = Device.fromDescriptor(descriptor);
       device.deviceConnector = this.connector;
@@ -35,14 +51,13 @@ export class DeviceList extends EventEmitter {
       deviceList.push(device);
       if (device.features) {
         const uuid = getDeviceUUID(device.features);
-        if (cacheDeviceMap.has(uuid)) {
-          const cache = cacheDeviceMap.get(uuid);
+        if (cacheDeviceMap[uuid]) {
+          const cache = cacheDeviceMap[uuid];
           cache?.updateFromCache(device);
-          device = cache as Device;
-          Log.debug('use cache device: ', uuid);
+          device = cache;
         }
         this.devices[uuid] = device;
-        cacheDeviceMap.set(uuid, device);
+        cacheDeviceMap[uuid] = device;
       }
     }
 

package/src/events/core.ts

@@ -6,6 +6,7 @@ import { IFrameEventMessage } from './iframe';
 import { UiEventMessage } from './ui-request';
 import { UiResponseMessage } from './ui-response';
 import { LogEventMessage } from './log';
+import { FirmwareMessage } from './firmware';
 
 export const CORE_EVENT = 'CORE_EVENT';
 
@@ -20,6 +21,7 @@ export type CoreMessage = {
   | UiEventMessage
   | DeviceEventMessage
   | LogEventMessage
+  | FirmwareMessage
 );
 
 export type PostMessageEvent = MessageEvent<any>;

package/src/events/device.ts

@@ -1,5 +1,5 @@
 import type { PROTO } from '../constants';
-import type { KnownDevice as Device } from '../types/device';
+import type { Features, KnownDevice as Device } from '../types/device';
 import { MessageFactoryFn } from './utils';
 
 export const DEVICE_EVENT = 'DEVICE_EVENT';
@@ -24,6 +24,8 @@ export const DEVICE = {
   PASSPHRASE: 'passphrase',
   PASSPHRASE_ON_DEVICE: 'passphrase_on_device',
   WORD: 'word',
+
+  FEATURES: 'features',
 } as const;
 
 export interface DeviceButtonRequestPayload extends Omit<PROTO.ButtonRequest, 'code'> {
@@ -35,7 +37,14 @@ export interface DeviceButtonRequest {
   payload: DeviceButtonRequestPayload & { device: Device | null };
 }
 
-export type DeviceEvent = DeviceButtonRequest;
+export type DeviceFeaturesPayload = Features;
+
+export interface DeviceSendFeatures {
+  type: typeof DEVICE.FEATURES;
+  payload: DeviceFeaturesPayload;
+}
+
+export type DeviceEvent = DeviceButtonRequest | DeviceSendFeatures;
 
 export type DeviceEventMessage = DeviceEvent & { event: typeof DEVICE_EVENT };
 

package/src/events/firmware.ts

@@ -0,0 +1,38 @@
+import { MessageFactoryFn } from './utils';
+import { getBleFirmwareReleaseInfo, getFirmwareReleaseInfo } from '../api/firmware/releaseHelper';
+import { Features } from '../types';
+
+export const FIRMWARE_EVENT = 'FIRMWARE_EVENT';
+export const FIRMWARE = {
+  RELEASE_INFO: 'firmware-release-info',
+  BLE_RELEASE_INFO: 'ble-firmware-release-info',
+} as const;
+
+export type ReleaseInfoPayload = ReturnType<typeof getFirmwareReleaseInfo> & { features: Features };
+export interface ReleaseInfoEvent {
+  type: typeof FIRMWARE.RELEASE_INFO;
+  payload: ReleaseInfoPayload;
+}
+
+export type BleReleaseInfoPayload = ReturnType<typeof getBleFirmwareReleaseInfo> & {
+  features: Features;
+};
+
+export interface BleReleaseInfoEvent {
+  type: typeof FIRMWARE.BLE_RELEASE_INFO;
+  payload: BleReleaseInfoPayload;
+}
+
+export type FirmwareEvent = ReleaseInfoEvent | BleReleaseInfoEvent;
+
+export type FirmwareMessage = FirmwareEvent & { event: typeof FIRMWARE_EVENT };
+
+export const createFirmwareMessage: MessageFactoryFn<typeof FIRMWARE_EVENT, FirmwareEvent> = (
+  type,
+  payload
+) =>
+  ({
+    event: FIRMWARE_EVENT,
+    type,
+    payload,
+  } as any);

package/src/events/index.ts

@@ -6,3 +6,4 @@ export * from './ui-promise';
 export * from './ui-response';
 export * from './device';
 export * from './log';
+export * from './firmware';

package/src/inject.ts

@@ -73,7 +73,8 @@ export const inject = ({
      */
     checkBridgeStatus: () => call({ method: 'checkBridgeStatus' }),
 
-    cipherKeyValue: (connectId, params) => call({ ...params, connectId, method: 'cipherKeyValue' }),
+    cipherKeyValue: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'cipherKeyValue' }),
 
     deviceBackup: connectId => call({ connectId, method: 'deviceBackup' }),
     deviceChangePin: (connectId, params) =>
@@ -87,51 +88,57 @@ export const inject = ({
     deviceVerify: (connectId, params) => call({ ...params, connectId, method: 'deviceVerify' }),
     deviceWipe: connectId => call({ connectId, method: 'deviceWipe' }),
 
-    evmGetAddress: (connectId, params) => call({ ...params, connectId, method: 'evmGetAddress' }),
-    evmGetPublicKey: (connectId, params) =>
-      call({ ...params, connectId, method: 'evmGetPublicKey' }),
-    evmSignMessage: (connectId, params) => call({ ...params, connectId, method: 'evmSignMessage' }),
-    evmSignMessageEIP712: (connectId, params) =>
-      call({ ...params, connectId, method: 'evmSignMessageEIP712' }),
-    evmSignTransaction: (connectId, params) =>
-      call({ ...params, connectId, method: 'evmSignTransaction' }),
-    evmSignTypedData: (connectId, params) =>
-      call({ ...params, connectId, method: 'evmSignTypedData' }),
-    evmVerifyMessage: (connectId, params) =>
-      call({ ...params, connectId, method: 'evmVerifyMessage' }),
-
-    btcGetAddress: (connectId, params) => call({ ...params, connectId, method: 'btcGetAddress' }),
-    btcGetPublicKey: (connectId, params) =>
-      call({ ...params, connectId, method: 'btcGetPublicKey' }),
-    btcSignMessage: (connectId, params) => call({ ...params, connectId, method: 'btcSignMessage' }),
-    btcSignTransaction: (connectId, params) =>
-      call({ ...params, connectId, method: 'btcSignTransaction' }),
-    btcVerifyMessage: (connectId, params) =>
-      call({ ...params, connectId, method: 'btcVerifyMessage' }),
-
-    starcoinGetAddress: (connectId, params) =>
-      call({ ...params, connectId, method: 'starcoinGetAddress' }),
-    starcoinGetPublicKey: (connectId, params) =>
-      call({ ...params, connectId, method: 'starcoinGetPublicKey' }),
-    starcoinSignMessage: (connectId, params) =>
-      call({ ...params, connectId, method: 'starcoinSignMessage' }),
-    starcoinSignTransaction: (connectId, params) =>
-      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' }),
+    evmGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'evmGetAddress' }),
+    evmGetPublicKey: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'evmGetPublicKey' }),
+    evmSignMessage: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'evmSignMessage' }),
+    evmSignMessageEIP712: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'evmSignMessageEIP712' }),
+    evmSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'evmSignTransaction' }),
+    evmSignTypedData: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'evmSignTypedData' }),
+    evmVerifyMessage: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'evmVerifyMessage' }),
+
+    btcGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'btcGetAddress' }),
+    btcGetPublicKey: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'btcGetPublicKey' }),
+    btcSignMessage: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'btcSignMessage' }),
+    btcSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'btcSignTransaction' }),
+    btcVerifyMessage: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'btcVerifyMessage' }),
+
+    starcoinGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'starcoinGetAddress' }),
+    starcoinGetPublicKey: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'starcoinGetPublicKey' }),
+    starcoinSignMessage: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'starcoinSignMessage' }),
+    starcoinSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'starcoinSignTransaction' }),
+    starcoinVerifyMessage: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'starcoinVerifyMessage' }),
+
+    nemGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'nemGetAddress' }),
+    nemSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'nemSignTransaction' }),
+
+    solGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'solGetAddress' }),
+    solSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'solSignTransaction' }),
+
+    stellarGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'stellarGetAddress' }),
+    stellarSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'stellarSignTransaction' }),
 
     firmwareUpdate: (connectId, params) => call({ ...params, connectId, method: 'firmwareUpdate' }),
   };

package/src/types/api/btcGetAddress.ts

@@ -1,8 +1,4 @@
-import {
-  Address,
-  InputScriptType,
-  MultisigRedeemScriptType,
-} from '@onekeyfe/hd-transport';
+import { Address, InputScriptType, MultisigRedeemScriptType } from '@onekeyfe/hd-transport';
 import type { CommonParams, Response } from '../params';
 
 export type BTCAddress = {
@@ -19,10 +15,12 @@ export type BTCGetAddressParams = {
 
 export declare function btcGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & BTCGetAddressParams
 ): Response<BTCAddress>;
 
 export declare function btcGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: BTCGetAddressParams[] }
 ): Response<Array<BTCAddress>>;

package/src/types/api/btcGetPublicKey.ts

@@ -14,10 +14,12 @@ export type BTCGetPublicKeyParams = {
 
 export declare function btcGetPublicKey(
   connectId: string,
+  deviceId: string,
   params: CommonParams & BTCGetPublicKeyParams
 ): Response<BTCPublicKey>;
 
 export declare function btcGetPublicKey(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: BTCGetPublicKeyParams[] }
 ): Response<Array<BTCPublicKey>>;

package/src/types/api/btcSignMessage.ts

@@ -9,5 +9,6 @@ export type BTCSignMessageParams = {
 
 export declare function btcSignMessage(
   connectId: string,
+  deviceId: string,
   params: CommonParams & BTCSignMessageParams
 ): Response<MessageSignature>;

package/src/types/api/btcSignTransaction.ts

@@ -93,5 +93,6 @@ export type BTCSignTransactionParams = {
 
 export declare function btcSignTransaction(
   connectId: string,
+  deviceId: string,
   params: CommonParams & BTCSignTransactionParams
 ): Response<SignedTransaction>;

package/src/types/api/btcVerifyMessage.ts

@@ -10,5 +10,6 @@ export type BTCVerifyMessageParams = {
 
 export declare function btcVerifyMessage(
   connectId: string,
+  deviceId: string,
   params: CommonParams & BTCVerifyMessageParams
 ): Response<Success>;

package/src/types/api/cipherKeyValue.ts

@@ -17,10 +17,12 @@ export type CipheredKeyValueParams = {
 
 export declare function cipherKeyValue(
   connectId: string,
+  deviceId: string,
   params: CommonParams & CipheredKeyValueParams
 ): Response<CipheredKeyValue>;
 
 export declare function cipherKeyValue(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: CipheredKeyValueParams[] }
 ): Response<Array<CipheredKeyValue>>;

package/src/types/api/evmGetAddress.ts

@@ -12,10 +12,12 @@ export type EVMGetAddressParams = {
 
 export declare function evmGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & EVMGetAddressParams
 ): Response<EVMAddress>;
 
 export declare function evmGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: EVMGetAddressParams[] }
 ): Response<Array<EVMAddress>>;

package/src/types/api/evmGetPublicKey.ts

@@ -12,10 +12,12 @@ export type EVMGetPublicKeyParams = {
 
 export declare function evmGetPublicKey(
   connectId: string,
+  deviceId: string,
   params: CommonParams & EVMGetPublicKeyParams
 ): Response<EVMPublicKey>;
 
 export declare function evmGetPublicKey(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: EVMGetPublicKeyParams[] }
 ): Response<Array<EVMPublicKey>>;

package/src/types/api/evmSignMessage.ts

@@ -8,5 +8,6 @@ export type EVMSignMessageParams = {
 
 export declare function evmSignMessage(
   connectId: string,
+  deviceId: string,
   params: CommonParams & EVMSignMessageParams
 ): Response<EthereumMessageSignature>;

package/src/types/api/evmSignMessageEIP712.ts

@@ -9,5 +9,6 @@ export type EVMSignMessageEIP712Params = {
 
 export declare function evmSignMessageEIP712(
   connectId: string,
+  deviceId: string,
   params: CommonParams & EVMSignMessageEIP712Params
 ): Response<EthereumMessageSignature>;

package/src/types/api/evmSignTransaction.ts

@@ -44,5 +44,6 @@ export type EVMSignTransactionParams = {
 
 export declare function evmSignTransaction(
   connectId: string,
+  deviceId: string,
   params: CommonParams & EVMSignTransactionParams
 ): Response<EVMSignedTx>;

package/src/types/api/evmSignTypedData.ts

@@ -36,5 +36,6 @@ export type EVMSignTypedDataParams = {
 
 export declare function evmSignTypedData(
   connectId: string,
+  deviceId: string,
   params: CommonParams & EVMSignTypedDataParams
 ): Response<EthereumMessageSignature>;

package/src/types/api/evmVerifyMessage.ts

@@ -9,5 +9,6 @@ export type EVMVerifyMessageParams = {
 
 export declare function evmVerifyMessage(
   connectId: string,
+  deviceId: string,
   params: CommonParams & EVMVerifyMessageParams
 ): Response<Success>;

package/src/types/api/nemGetAddress.ts

@@ -13,10 +13,12 @@ export type NEMGetAddressParams = {
 
 export declare function nemGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & NEMGetAddressParams
 ): Response<NEMAddress>;
 
 export declare function nemGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: NEMGetAddressParams[] }
 ): Response<Array<NEMAddress>>;

package/src/types/api/nemSignTransaction.ts

@@ -113,5 +113,6 @@ export type NEMSignTransactionParams = {
 
 export declare function nemSignTransaction(
   connectId: string,
+  deviceId: string,
   params: CommonParams & NEMSignTransactionParams
 ): Response<NEMSignedTx>;

package/src/types/api/solGetAddress.ts

@@ -12,10 +12,12 @@ export type SolanaGetAddressParams = {
 
 export declare function solGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & SolanaGetAddressParams
 ): Response<SolanaAddress>;
 
 export declare function solGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: SolanaGetAddressParams[] }
 ): Response<Array<SolanaAddress>>;

package/src/types/api/solSignTransaction.ts

@@ -12,10 +12,12 @@ export type SolanaSignTransactionParams = {
 
 export declare function solSignTransaction(
   connectId: string,
+  deviceId: string,
   params: CommonParams & SolanaSignTransactionParams
 ): Response<SolanaSignedTx>;
 
 export declare function solSignTransaction(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: SolanaSignTransactionParams[] }
 ): Response<Array<SolanaSignedTx>>;

package/src/types/api/starcoinGetAddress.ts

@@ -12,10 +12,12 @@ export type StarcoinGetAddressParams = {
 
 export declare function starcoinGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & StarcoinGetAddressParams
 ): Response<StarcoinAddress>;
 
 export declare function starcoinGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: StarcoinGetAddressParams[] }
 ): Response<Array<StarcoinAddress>>;

package/src/types/api/starcoinGetPublicKey.ts

@@ -12,10 +12,12 @@ export type StarcoinGetPublicKeyParams = {
 
 export declare function starcoinGetPublicKey(
   connectId: string,
+  deviceId: string,
   params: CommonParams & StarcoinGetPublicKeyParams
 ): Response<StarcoinPublicKey>;
 
 export declare function starcoinGetPublicKey(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: StarcoinGetPublicKeyParams[] }
 ): Response<Array<StarcoinPublicKey>>;

package/src/types/api/starcoinSignMessage.ts

@@ -8,5 +8,6 @@ export type StarcoinSignMessageParams = {
 
 export declare function starcoinSignMessage(
   connectId: string,
+  deviceId: string,
   params: CommonParams & StarcoinSignMessageParams
 ): Response<StarcoinMessageSignature>;

package/src/types/api/starcoinSignTransaction.ts

@@ -8,5 +8,6 @@ export type StarcoinSignTransactionParams = {
 
 export declare function starcoinSignTransaction(
   connectId: string,
+  deviceId: string,
   params: CommonParams & StarcoinSignTransactionParams
 ): Response<StarcoinSignedTx>;

package/src/types/api/starcoinVerifyMessage.ts

@@ -9,5 +9,6 @@ export type StarcoinVerifyMessageParams = {
 
 export declare function starcoinVerifyMessage(
   connectId: string,
+  deviceId: string,
   params: CommonParams & StarcoinVerifyMessageParams
 ): Response<Success>;