@ukeyfe/hardware-core 1.1.13

package/src/api/tron/TronSignTransaction.ts

@@ -0,0 +1,203 @@
+import { TronSignTx } from '@ukeyfe/hardware-transport';
+import { isEmpty } from 'lodash';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { TronTransaction } from '../../types/api/tronSignTransaction';
+import { formatAnyHex } from '../helpers/hexUtils';
+import { DeviceFirmwareRange } from '../../types';
+
+export default class TronSignTransaction extends BaseMethod<TronSignTx> {
+  parseTx(tx: TronTransaction, address_n: number[]): TronSignTx {
+    const unSignTx = {
+      address_n,
+      data: tx.data,
+      timestamp: tx.timestamp,
+      fee_limit: tx.feeLimit,
+      ref_block_bytes: tx.refBlockBytes,
+      ref_block_hash: tx.refBlockHash,
+      expiration: tx.expiration,
+      contract: {},
+    };
+
+    if (tx.contract) {
+      if (tx.contract.transferContract) {
+        unSignTx.contract = {
+          transfer_contract: {
+            to_address: tx.contract.transferContract.toAddress,
+            amount: tx.contract.transferContract.amount,
+          },
+        };
+      }
+      if (tx.contract.triggerSmartContract) {
+        unSignTx.contract = {
+          trigger_smart_contract: {
+            contract_address: tx.contract.triggerSmartContract.contractAddress,
+            call_value: tx.contract.triggerSmartContract.callValue,
+            data: tx.contract.triggerSmartContract.data,
+            call_token_value: tx.contract.triggerSmartContract.callTokenValue,
+            asset_id: tx.contract.triggerSmartContract.assetId,
+          },
+        };
+      }
+
+      if (tx.contract.freezeBalanceV2Contract) {
+        unSignTx.contract = {
+          freeze_balance_v2_contract: {
+            frozen_balance: tx.contract.freezeBalanceV2Contract.frozenBalance,
+            resource: tx.contract.freezeBalanceV2Contract.resource,
+          },
+        };
+      }
+
+      if (tx.contract.unfreezeBalanceV2Contract) {
+        unSignTx.contract = {
+          unfreeze_balance_v2_contract: {
+            unfreeze_balance: tx.contract.unfreezeBalanceV2Contract.unfreezeBalance,
+            resource: tx.contract.unfreezeBalanceV2Contract.resource,
+          },
+        };
+      }
+
+      if (tx.contract.delegateResourceContract) {
+        unSignTx.contract = {
+          delegate_resource_contract: {
+            resource: tx.contract.delegateResourceContract.resource,
+            balance: tx.contract.delegateResourceContract.balance,
+            receiver_address: tx.contract.delegateResourceContract.receiverAddress,
+            lock: tx.contract.delegateResourceContract.lock,
+            lock_period: tx.contract.delegateResourceContract.lockPeriod,
+          },
+        };
+      }
+
+      if (tx.contract.unDelegateResourceContract) {
+        unSignTx.contract = {
+          undelegate_resource_contract: {
+            resource: tx.contract.unDelegateResourceContract.resource,
+            balance: tx.contract.unDelegateResourceContract.balance,
+            receiver_address: tx.contract.unDelegateResourceContract.receiverAddress,
+          },
+        };
+      }
+
+      if (tx.contract.withdrawExpireUnfreezeContract) {
+        unSignTx.contract = {
+          withdraw_expire_unfreeze_contract: {},
+        };
+      }
+
+      if (tx.contract.withdrawBalanceContract) {
+        unSignTx.contract = {
+          withdraw_balance_contract: {
+            owner_address: tx.contract.withdrawBalanceContract.ownerAddress,
+          },
+        };
+      }
+
+      if (tx.contract.voteWitnessContract) {
+        unSignTx.contract = {
+          vote_witness_contract: {
+            votes: tx.contract.voteWitnessContract.votes?.map(vote => ({
+              vote_address: vote.voteAddress,
+              vote_count: vote.voteCount,
+            })),
+            support: tx.contract.voteWitnessContract.support,
+          },
+        };
+      }
+
+      if (tx.contract.cancelAllUnfreezeV2Contract) {
+        unSignTx.contract = {
+          cancel_all_unfreeze_v2_contract: {},
+        };
+      }
+    }
+
+    return unSignTx;
+  }
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'transaction', type: 'object', required: true },
+    ]);
+
+    const { path, transaction } = this.payload;
+    const addressN = validatePath(path, 3);
+
+    validateParams(transaction, [
+      { name: 'refBlockBytes', type: 'hexString', required: true },
+      { name: 'refBlockHash', type: 'hexString', required: true },
+      { name: 'expiration', type: 'number', required: true },
+      { name: 'timestamp', type: 'number', required: true },
+      { name: 'contract', type: 'object', required: true },
+    ]);
+
+    // init params
+    this.params = this.parseTx(formatAnyHex(transaction), addressN);
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.5.0',
+      },
+    };
+  }
+
+  getFixDataTypeVersionRange(): DeviceFirmwareRange {
+    return {
+      pro: {
+        min: '4.13.0',
+      },
+      model_classic1s: {
+        min: '3.12.0',
+      },
+    };
+  }
+
+  checkFixDataTypeSupportVoteWitnessError() {
+    const { data } = this.payload;
+    const { cancel_all_unfreeze_v2_contract, vote_witness_contract } = this.params.contract;
+    this.checkFeatureVersionLimit(
+      () => !isEmpty(data) || !!cancel_all_unfreeze_v2_contract || !!vote_witness_contract,
+      () => this.getFixDataTypeVersionRange()
+    );
+  }
+
+  supportDelegateResourceLockPeriodVersionRange(): DeviceFirmwareRange {
+    return {
+      pro: {
+        min: '4.15.0',
+      },
+    };
+  }
+
+  checkSupportDelegateContractLockPeriod() {
+    const { delegate_resource_contract } = this.params.contract;
+    this.checkFeatureVersionLimit(
+      () =>
+        !!delegate_resource_contract &&
+        delegate_resource_contract.lock_period !== undefined &&
+        delegate_resource_contract.lock_period !== null,
+      () => this.supportDelegateResourceLockPeriodVersionRange()
+    );
+  }
+
+  async run() {
+    this.checkFixDataTypeSupportVoteWitnessError();
+    this.checkSupportDelegateContractLockPeriod();
+
+    const response = await this.device.commands.typedCall('TronSignTx', 'TronSignedTx', {
+      ...this.params,
+    });
+
+    return Promise.resolve(response.message);
+  }
+}

package/src/api/u2f/GetNextU2FCounter.ts

@@ -0,0 +1,14 @@
+import { GetNextU2FCounter as HardwareGetNextU2FCounter } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+
+export default class GetNextU2FCounter extends BaseMethod<HardwareGetNextU2FCounter> {
+  init() {
+    this.useDevicePassphraseState = false;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('GetNextU2FCounter', 'NextU2FCounter');
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/u2f/SetU2FCounter.ts

@@ -0,0 +1,18 @@
+import { SetU2FCounter as HardwareSetU2FCounter } from '@ukeyfe/hardware-transport';
+import { BaseMethod } from '../BaseMethod';
+
+export default class SetU2FCounter extends BaseMethod<HardwareSetU2FCounter> {
+  init() {
+    this.useDevicePassphraseState = false;
+
+    this.params = {
+      u2f_counter: this.payload.u2f_counter,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('SetU2FCounter', 'Success', this.params);
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/utils.ts

@@ -0,0 +1,21 @@
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import * as ApiMethods from './index';
+import { IFrameCallMessage } from '../events';
+
+export function findMethod(message: IFrameCallMessage & { id?: number }) {
+  const { method } = message.payload;
+  if (typeof method !== 'string') {
+    throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Method is not set');
+  }
+
+  // @ts-expect-error
+  const MethodConstructor = ApiMethods[method];
+  if (MethodConstructor) {
+    return new MethodConstructor(message);
+  }
+
+  throw ERRORS.TypedError(
+    HardwareErrorCode.CallMethodInvalidParameter,
+    `Method ${method} is not set`
+  );
+}

package/src/api/xrp/XrpGetAddress.ts

@@ -0,0 +1,114 @@
+import { deriveAddress } from 'ripple-keypairs';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { XrpAddress, XrpGetAddressParams } from '../../types/api/xrpGetAddress';
+import { supportBatchPublicKey } from '../../utils/deviceFeaturesUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
+
+export default class XrpGetAddress extends BaseMethod<
+  {
+    address_n: number[];
+    show_display: boolean;
+  }[]
+> {
+  hasBundle = false;
+
+  shouldConfirm = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    this.shouldConfirm = this.hasBundle
+      ? this.payload.bundle.some((i: any) => !!i.showOnOneKey)
+      : false;
+
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    this.params = [];
+    payload.bundle.forEach((batch: XrpGetAddressParams) => {
+      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,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.9.0',
+      },
+    };
+  }
+
+  async run() {
+    if (this.hasBundle && supportBatchPublicKey(this.device?.features) && !this.shouldConfirm) {
+      const res = await batchGetPublickeys(this.device, this.params, 'secp256k1', 144);
+      const result = res.public_keys.map((publicKey: string, index: number) => ({
+        path: serializedPath((this.params as unknown as any[])[index].address_n),
+        address: deriveAddress(publicKey),
+        publicKey,
+        pub: publicKey,
+      }));
+
+      validateResult(result, ['address', 'publicKey'], {
+        expectedLength: this.params.length,
+      });
+
+      return Promise.resolve(result);
+    }
+
+    const responses: XrpAddress[] = [];
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('RippleGetAddress', 'RippleAddress', {
+        ...param,
+      });
+      const publicKey = await this.device.commands.typedCall(
+        'BatchGetPublickeys',
+        'EcdsaPublicKeys',
+        {
+          paths: [{ address_n: param.address_n }],
+          ecdsa_curve_name: 'secp256k1',
+        }
+      );
+
+      const { address } = res.message;
+
+      const path = serializedPath(param.address_n);
+      responses.push({
+        path,
+        address,
+        publicKey: publicKey.message?.public_keys?.[0],
+        pub: publicKey.message?.public_keys?.[0],
+      });
+
+      this.postPreviousAddressMessage({
+        path,
+        address,
+      });
+    }
+
+    validateResult(responses, ['address', 'pub'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/xrp/XrpSignTransaction.ts

@@ -0,0 +1,70 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { XrpSignTransactionParams } from '../../types/api/xrpSignTransaction';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { validatePath } from '../helpers/pathUtils';
+
+export default class XrpGetAddress extends BaseMethod<XrpSignTransactionParams> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const { payload } = this;
+    validateParams(payload, [
+      { name: 'path', required: true },
+      { name: 'transaction', required: true },
+    ]);
+
+    const path = validatePath(payload.path, 5);
+
+    const { transaction } = payload;
+    validateParams(transaction, [
+      { name: 'fee', type: 'string' },
+      { name: 'flags', type: 'number' },
+      { name: 'sequence', type: 'number' },
+      { name: 'maxLedgerVersion', type: 'number' },
+      { name: 'payment', type: 'object' },
+    ]);
+    validateParams(transaction.payment, [
+      { name: 'amount', type: 'number', required: true },
+      { name: 'destination', type: 'string', required: true },
+      { name: 'destinationTag', type: 'number' },
+    ]);
+
+    this.params = {
+      address_n: path,
+      fee: transaction.fee,
+      flags: transaction.flags,
+      sequence: transaction.sequence,
+      last_ledger_sequence: transaction.maxLedgerVersion,
+      payment: {
+        amount: transaction.payment.amount,
+        destination: transaction.payment.destination,
+        destination_tag: transaction.payment.destinationTag,
+      },
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.9.0',
+      },
+    };
+  }
+
+  async run() {
+    const { message } = await this.device.commands.typedCall(
+      'RippleSignTx',
+      'RippleSignedTx',
+      this.params
+    );
+
+    return {
+      serializedTx: message.serialized_tx,
+      signature: message.signature,
+    };
+  }
+}

package/src/constants/errors.ts

@@ -0,0 +1,15 @@
+import { HardwareError, ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+
+export const safeThrowError = (error: any) => {
+  if (error instanceof HardwareError) {
+    throw error;
+  } else if (error.code === 'ERR_NETWORK') {
+    throw ERRORS.TypedError(HardwareErrorCode.BridgeNotInstalled);
+  } else if (error.code === 'ECONNABORTED') {
+    throw ERRORS.TypedError(HardwareErrorCode.BridgeTimeoutError);
+  } else if (error.code === 'ERR_BAD_REQUEST') {
+    throw ERRORS.TypedError(HardwareErrorCode.BridgeNetworkError);
+  } else {
+    throw ERRORS.TypedError(error);
+  }
+};

package/src/constants/index.ts

@@ -0,0 +1,2 @@
+export { safeThrowError } from './errors';
+export { Messages as PROTO } from '@ukeyfe/hardware-transport';

package/src/constants/ui-request.ts

@@ -0,0 +1,3 @@
+import { UI_REQUEST } from '../events/ui-request';
+
+export { UI_REQUEST };

package/src/core/RequestQueue.ts

@@ -0,0 +1,133 @@
+import { Deferred } from '@ukeyfe/hardware-shared';
+import type { BaseMethod } from '../api/BaseMethod';
+import { getLogger, LoggerNames } from '../utils';
+
+const Log = getLogger(LoggerNames.Core);
+export type RequestTask = {
+  id: number;
+  method: BaseMethod;
+  callPromise?: Deferred<any> | undefined;
+  abortController?: AbortController;
+};
+
+export default class RequestQueue {
+  private requestQueue = new Map<number, RequestTask>();
+
+  private pendingCallbackTasks = new Map<string, Deferred<void>>();
+
+  // 生成唯一请求ID
+  public generateRequestId = (method?: BaseMethod) => {
+    if (method && method.responseID != null) {
+      return method.responseID;
+    }
+    return Date.now();
+  };
+
+  public createTask(method: BaseMethod): RequestTask {
+    const requestId = this.generateRequestId(method);
+    if (method && method.responseID !== requestId) {
+      method.responseID = requestId;
+    }
+    const abortController = new AbortController();
+    const task = { id: requestId, method, abortController };
+    this.requestQueue.set(requestId, task);
+    return task;
+  }
+
+  public getTask(requestId: number): RequestTask | undefined {
+    return this.requestQueue.get(requestId);
+  }
+
+  // 获取请求的AbortController
+  public getAbortController(requestId: number) {
+    return this.requestQueue.get(requestId)?.abortController;
+  }
+
+  // 取消特定请求
+  public abortRequest(requestId: number) {
+    const request = this.requestQueue.get(requestId);
+    if (request?.abortController) {
+      Log.debug(`Aborting request ${requestId}`);
+      request.abortController.abort();
+      return true;
+    }
+    return false;
+  }
+
+  // 取消与指定connectId相关的所有请求
+  public abortRequestsByConnectId(connectId: string) {
+    let count = 0;
+    this.requestQueue.forEach((request, _) => {
+      if (request.abortController && request.method.connectId === connectId) {
+        request.abortController.abort();
+        request.abortController = undefined;
+        count++;
+      }
+    });
+    return count;
+  }
+
+  // 取消所有请求
+  public abortAllRequests() {
+    let count = 0;
+    this.requestQueue.forEach(request => {
+      if (request.abortController) {
+        request.abortController.abort();
+        count++;
+      }
+    });
+    return count;
+  }
+
+  // 迭代所有请求
+  public getRequestTasksId() {
+    return Array.from(this.requestQueue.keys());
+  }
+
+  // 解析请求
+  public resolveRequest(requestId: number, response: any) {
+    const request = this.requestQueue.get(requestId);
+    if (request) {
+      request.callPromise?.resolve(response);
+    }
+    this.releaseTask(requestId);
+  }
+
+  // 拒绝请求
+  public rejectRequest(requestId: number, error: any) {
+    const request = this.requestQueue.get(requestId);
+    if (request) {
+      request.callPromise?.reject(error);
+    }
+    this.releaseTask(requestId);
+  }
+
+  // 删除请求
+  public releaseTask(requestId: number) {
+    this.requestQueue.delete(requestId);
+  }
+
+  public registerPendingCallbackTask(connectId: string, callbackPromise: Deferred<void>) {
+    this.pendingCallbackTasks.set(connectId, callbackPromise);
+
+    callbackPromise.promise.finally(() => {
+      Log.debug(`Callback task completed for connectId: ${connectId}`);
+      this.pendingCallbackTasks.delete(connectId);
+    });
+  }
+
+  public async waitForPendingCallbackTasks(connectId: string): Promise<void> {
+    const pendingTask = this.pendingCallbackTasks.get(connectId);
+    if (pendingTask) {
+      Log.debug(`Waiting for pending callback task to complete for connectId: ${connectId}`);
+      await pendingTask.promise;
+    }
+  }
+
+  public cancelCallbackTasks(connectId: string) {
+    const pendingTask = this.pendingCallbackTasks.get(connectId);
+    if (pendingTask) {
+      pendingTask.resolve();
+    }
+  }
+}