@onekeyfe/hd-core 1.2.0-alpha.55 → 1.2.0-alpha.57

package/src/api/binance/BinanceGetPublicKey.ts

@@ -0,0 +1,26 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+
+import type { BinanceGetPublicKey as HardwareBinanceGetPublicKey } from '@onekeyfe/hd-transport';
+
+export default class BinanceGetPublicKey extends BaseMethod<HardwareBinanceGetPublicKey> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // init params
+    this.params = {
+      address_n: validatePath(this.payload.path, 3),
+      show_display: this.payload.showOnOneKey ?? true,
+    };
+  }
+
+  async run() {
+    return this.device.commands.typedCall('BinanceGetPublicKey', 'BinancePublicKey', {
+      ...this.params,
+    });
+  }
+}

package/src/api/binance/BinanceSignTx.ts

@@ -0,0 +1,35 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+
+import type { BinanceSignTx as HardwareBinanceSignTx } from '@onekeyfe/hd-transport';
+
+export default class BinanceSignTx extends BaseMethod<HardwareBinanceSignTx> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const { path } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      msg_count: this.payload.msg_count,
+      account_number: this.payload.account_number,
+      chain_id: this.payload.chain_id,
+      memo: this.payload.memo,
+      sequence: this.payload.sequence,
+      source: this.payload.source,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('BinanceSignTx', 'BinanceTxRequest', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/btc/BTCAuthorizeCoinJoin.ts

@@ -0,0 +1,37 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { getCoinAndScriptType } from './helpers/btcParamsUtils';
+
+import type { AuthorizeCoinJoin } from '@onekeyfe/hd-transport';
+
+export default class BTCAuthorizeCoinJoin extends BaseMethod<AuthorizeCoinJoin> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const { path, coin } = this.payload;
+
+    const addressN = validatePath(path);
+
+    const { coinName, scriptType } = getCoinAndScriptType(addressN, coin, false);
+
+    this.params = {
+      address_n: addressN,
+      coin_name: coinName,
+      script_type: scriptType || 'SPENDADDRESS',
+      coordinator: this.payload.coordinator,
+      max_total_fee: this.payload.max_total_fee,
+      fee_per_anonymity: this.payload.fee_per_anonymity,
+      amount_unit: this.payload.amount_unit,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('AuthorizeCoinJoin', 'Success', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/btc/BTCGetOwnershipId.ts

@@ -0,0 +1,34 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { getCoinAndScriptType } from './helpers/btcParamsUtils';
+
+import type { GetOwnershipId } from '@onekeyfe/hd-transport';
+
+export default class BTCGetOwnershipId extends BaseMethod<GetOwnershipId> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const { path, coin } = this.payload;
+
+    const addressN = validatePath(path);
+
+    const { coinName, scriptType } = getCoinAndScriptType(addressN, coin, false);
+
+    this.params = {
+      address_n: addressN,
+      coin_name: coinName,
+      multisig: this.payload.multisig,
+      script_type: scriptType || 'SPENDADDRESS',
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('GetOwnershipId', 'OwnershipId', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/btc/BTCGetOwnershipProof.ts

@@ -0,0 +1,37 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { getCoinAndScriptType } from './helpers/btcParamsUtils';
+
+import type { GetOwnershipProof } from '@onekeyfe/hd-transport';
+
+export default class BTCGetOwnershipProof extends BaseMethod<GetOwnershipProof> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const { path, coin } = this.payload;
+
+    const addressN = validatePath(path);
+
+    const { coinName, scriptType } = getCoinAndScriptType(addressN, coin, false);
+
+    this.params = {
+      address_n: addressN,
+      coin_name: coinName,
+      multisig: this.payload.multisig,
+      script_type: scriptType || 'SPENDADDRESS',
+      user_confirmation: this.payload.user_confirmation,
+      ownership_ids: this.payload.ownership_ids,
+      commitment_data: this.payload.commitment_data,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('GetOwnershipProof', 'OwnershipProof', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/crypto/CryptoBatchGetPublickeys.ts

@@ -0,0 +1,30 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+
+import type { BatchGetPublickeys } from '@onekeyfe/hd-transport';
+
+export default class CryptoBatchGetPublickeys extends BaseMethod<BatchGetPublickeys> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // init params
+    this.params = {
+      ecdsa_curve_name: this.payload.ecdsa_curve_name,
+      paths: this.payload.paths.map((path: string) => {
+        const addressN = validatePath(path);
+        return {
+          address_n: addressN,
+          show_display: this.payload.show_display,
+        };
+      }),
+    };
+  }
+
+  async run() {
+    return this.device.commands.typedCall('BatchGetPublickeys', 'EcdsaPublicKeys', this.params);
+  }
+}

package/src/api/crypto/CryptoCipherKeyValue.ts

@@ -0,0 +1,29 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+
+import type { CipherKeyValue } from '@onekeyfe/hd-transport';
+
+export default class CryptoCipherKeyValue extends BaseMethod<CipherKeyValue> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    const addressN = validatePath(this.payload.path);
+    // init params
+    this.params = {
+      address_n: addressN,
+      key: this.payload.key,
+      value: this.payload.key,
+      encrypt: this.payload.key,
+      ask_on_encrypt: this.payload.key,
+      ask_on_decrypt: this.payload.key,
+      iv: this.payload.key,
+    };
+  }
+
+  async run() {
+    return this.device.commands.typedCall('CipherKeyValue', 'CipheredKeyValue', this.params);
+  }
+}

package/src/api/crypto/CryptoCosiCommit.ts

@@ -0,0 +1,24 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+
+import type { CosiCommit } from '@onekeyfe/hd-transport';
+
+export default class CryptoCosiCommit extends BaseMethod<CosiCommit> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    const addressN = validatePath(this.payload.path);
+    // init params
+    this.params = {
+      address_n: addressN,
+      data: this.payload.data,
+    };
+  }
+
+  async run() {
+    return this.device.commands.typedCall('CosiCommit', 'CosiCommitment', this.params);
+  }
+}

package/src/api/crypto/CryptoCosiSign.ts

@@ -0,0 +1,26 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+
+import type { CosiSign } from '@onekeyfe/hd-transport';
+
+export default class CryptoCosiSign extends BaseMethod<CosiSign> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    const addressN = validatePath(this.payload.path);
+    // init params
+    this.params = {
+      address_n: addressN,
+      data: this.payload.data,
+      global_commitment: this.payload.global_commitment,
+      global_pubkey: this.payload.global_pubkey,
+    };
+  }
+
+  async run() {
+    return this.device.commands.typedCall('CosiSign', 'CosiSignature', this.params);
+  }
+}

package/src/api/crypto/CryptoGetECDHSessionKey.ts

@@ -0,0 +1,24 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { BaseMethod } from '../BaseMethod';
+
+import type { GetECDHSessionKey } from '@onekeyfe/hd-transport';
+
+export default class CryptoGetECDHSessionKey extends BaseMethod<GetECDHSessionKey> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // init params
+    this.params = {
+      identity: this.payload.identity,
+      peer_public_key: this.payload.peer_public_key,
+      ecdsa_curve_name: this.payload.ecdsa_curve_name,
+    };
+  }
+
+  async run() {
+    return this.device.commands.typedCall('GetECDHSessionKey', 'ECDHSessionKey', this.params);
+  }
+}

package/src/api/crypto/CryptoSignIdentity.ts

@@ -0,0 +1,25 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { BaseMethod } from '../BaseMethod';
+
+import type { SignIdentity } from '@onekeyfe/hd-transport';
+
+export default class CryptoSignIdentity extends BaseMethod<SignIdentity> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // init params
+    this.params = {
+      identity: this.payload.identity,
+      challenge_hidden: this.payload.challenge_hidden,
+      challenge_visual: this.payload.challenge_visual,
+      ecdsa_curve_name: this.payload.ecdsa_curve_name,
+    };
+  }
+
+  async run() {
+    return this.device.commands.typedCall('SignIdentity', 'ECDHSessionKey', this.params);
+  }
+}

package/src/api/debug/DebugLinkDecision.ts

@@ -0,0 +1,25 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { DebugLinkDecision as HardwareDebugLinkDecision } from '@onekeyfe/hd-transport';
+
+export default class DebugLinkDecision extends BaseMethod<HardwareDebugLinkDecision> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      yes_no: this.payload.yes_no,
+      swipe: this.payload.swipe,
+      input: this.payload.input,
+      x: this.payload.x,
+      y: this.payload.y,
+      wait: this.payload.wait,
+      hold_ms: this.payload.hold_ms,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('DebugLinkDecision', 'Success', this.params);
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/debug/DebugLinkEraseSdCard.ts

@@ -0,0 +1,23 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { DebugLinkEraseSdCard as HardwareDebugLinkEraseSdCard } from '@onekeyfe/hd-transport';
+
+export default class DebugLinkEraseSdCard extends BaseMethod<HardwareDebugLinkEraseSdCard> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      format: this.payload.format,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'DebugLinkEraseSdCard',
+      'Success',
+      this.params
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/debug/DebugLinkFlashErase.ts

@@ -0,0 +1,23 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { DebugLinkFlashErase as HardwareDebugLinkFlashErase } from '@onekeyfe/hd-transport';
+
+export default class DebugLinkFlashErase extends BaseMethod<HardwareDebugLinkFlashErase> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      sector: this.payload.sector,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'DebugLinkFlashErase',
+      'DebugLinkLayout',
+      this.params
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/debug/DebugLinkGetState.ts

@@ -0,0 +1,21 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { DebugLinkGetState as HardwareDebugLinkGetState } from '@onekeyfe/hd-transport';
+
+export default class DebugLinkGetState extends BaseMethod<HardwareDebugLinkGetState> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {};
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'DebugLinkGetState',
+      'DebugLinkLog',
+      this.params
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/debug/DebugLinkMemoryRead.ts

@@ -0,0 +1,24 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { DebugLinkMemoryRead as HardwareDebugLinkMemoryRead } from '@onekeyfe/hd-transport';
+
+export default class DebugLinkMemoryRead extends BaseMethod<HardwareDebugLinkMemoryRead> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      address: this.payload.address,
+      length: this.payload.length,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'DebugLinkMemoryRead',
+      'DebugLinkMemory',
+      this.params
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/debug/DebugLinkMemoryWrite.ts

@@ -0,0 +1,25 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { DebugLinkMemoryWrite as HardwareDebugLinkMemoryWrite } from '@onekeyfe/hd-transport';
+
+export default class DebugLinkMemoryWrite extends BaseMethod<HardwareDebugLinkMemoryWrite> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      address: this.payload.address,
+      memory: this.payload.memory,
+      flash: this.payload.flash,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'DebugLinkMemoryWrite',
+      'Success',
+      this.params
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/debug/DebugLinkRecordScreen.ts

@@ -0,0 +1,23 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { DebugLinkRecordScreen as HardwareDebugLinkRecordScreen } from '@onekeyfe/hd-transport';
+
+export default class DebugLinkRecordScreen extends BaseMethod<HardwareDebugLinkRecordScreen> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      target_directory: this.payload.target_directory,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'DebugLinkRecordScreen',
+      'Success',
+      this.params
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/debug/DebugLinkReseedRandom.ts

@@ -0,0 +1,23 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { DebugLinkReseedRandom as HardwareDebugLinkReseedRandom } from '@onekeyfe/hd-transport';
+
+export default class DebugLinkReseedRandom extends BaseMethod<HardwareDebugLinkReseedRandom> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      value: this.payload.value,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'DebugLinkReseedRandom',
+      'Success',
+      this.params
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/debug/DebugLinkStop.ts

@@ -0,0 +1,25 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { DebugLinkStop as HardwareDebugLinkStop } from '@onekeyfe/hd-transport';
+
+export default class DebugLinkStop extends BaseMethod<HardwareDebugLinkStop> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      wait_word_list: this.payload.wait_word_list,
+      wait_word_pos: this.payload.wait_word_pos,
+      wait_layout: this.payload.wait_layout,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'DebugLinkGetState',
+      'DebugLinkState',
+      this.params
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/debug/DebugLinkWatchLayout.ts

@@ -0,0 +1,23 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { DebugLinkWatchLayout as HardwareDebugLinkWatchLayout } from '@onekeyfe/hd-transport';
+
+export default class DebugLinkWatchLayout extends BaseMethod<HardwareDebugLinkWatchLayout> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      watch: this.payload.watch,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'DebugLinkWatchLayout',
+      'Success',
+      this.params
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/device/DeviceVerify.ts

@@ -6,6 +6,7 @@ import { formatAnyHex } from '../helpers/hexUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
 import { DeviceModelToTypes } from '../../types';
+import { UI_REQUEST } from '../../events';
 
 import type { BixinVerifyDeviceRequest } from '@onekeyfe/hd-transport';
 import type { DeviceVerifySignature } from '../../types';
@@ -13,6 +14,7 @@ import type { DeviceVerifySignature } from '../../types';
 export default class DeviceVerify extends BaseMethod<BixinVerifyDeviceRequest> {
   init() {
     this.useDevicePassphraseState = false;
+    this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
 
     // check payload
     validateParams(this.payload, [{ name: 'dataHex', type: 'hexString' }]);

package/src/api/emmc/EmmcDirList.ts

@@ -0,0 +1,20 @@
+import { BaseMethod } from '../BaseMethod';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { EmmcDirList as HardwareEmmcDirList } from '@onekeyfe/hd-transport';
+
+export default class EmmcDirList extends BaseMethod<HardwareEmmcDirList> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.params = {
+      path: this.payload.path,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('EmmcDirList', 'EmmcDir', this.params);
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/emmc/EmmcDirMake.ts

@@ -0,0 +1,20 @@
+import { BaseMethod } from '../BaseMethod';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { EmmcDirMake as HardwareEmmcDirMake } from '@onekeyfe/hd-transport';
+
+export default class EmmcDirMake extends BaseMethod<HardwareEmmcDirMake> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.params = {
+      path: this.payload.path,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('EmmcDirMake', 'Success', this.params);
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/emmc/EmmcDirRemove.ts

@@ -0,0 +1,20 @@
+import { BaseMethod } from '../BaseMethod';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { EmmcDirRemove as HardwareEmmcDirRemove } from '@onekeyfe/hd-transport';
+
+export default class EmmcDirRemove extends BaseMethod<HardwareEmmcDirRemove> {
+  init() {
+    this.useDevicePassphraseState = false;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.params = {
+      path: this.payload.path,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('EmmcDirRemove', 'Success', this.params);
+
+    return Promise.resolve(res.message);
+  }
+}