@onetokenfe/hd-core 1.1.23

package/src/api/helpers/typeNameUtils.ts

@@ -0,0 +1,137 @@
+/* eslint-disable prefer-regex-literals */
+
+import { EthereumDataType } from '@onetokenfe/hd-transport';
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+
+import { intToHex } from './bigNumberUtils';
+import { formatAnyHex } from './hexUtils';
+
+import type { EthereumSignTypedDataTypes } from '../../types/api/evmSignTypedData';
+import type { EthereumFieldType } from '@onetokenfe/hd-transport';
+
+// Copied from https://github.com/ethers-io/ethers.js/blob/v5.5.2/packages/abi/src.ts/fragments.ts#L249
+const paramTypeArray = new RegExp(/^(.*)\[([0-9]*)\]$/);
+const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
+const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
+
+/**
+ * Parse the given EIP-712 array type into its entries, and its length (if not dynamic)
+ * E.g. `uint16[32]` will return `{entryTypeName: 'uint16', arraySize: 32}`.
+ */
+export const parseArrayType = (
+  arrayTypeName: string
+): {
+  entryTypeName: string;
+  arraySize: number | null;
+} => {
+  const arrayMatch = paramTypeArray.exec(arrayTypeName);
+  if (arrayMatch === null) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `typename ${arrayTypeName} could not be parsed as an EIP-712 array`
+    );
+  }
+  const [_, entryTypeName, arraySize] = arrayMatch;
+  return {
+    entryTypeName,
+    arraySize: parseInt(arraySize, 10) || null,
+  };
+};
+
+/**
+ * Encodes the given primitive data to a big-endian hex string.
+ *
+ * @param typeName - Primitive Solidity data type (e.g. `uint16`)
+ * @param data - The actual data to convert.
+ * @returns Hex string of the data.
+ */
+export const encodeData = (typeName: string, data: any): string => {
+  if (paramTypeBytes.test(typeName) || typeName === 'address') {
+    return formatAnyHex(data);
+  }
+  if (typeName === 'string') {
+    return Buffer.from(data, 'utf-8').toString('hex');
+  }
+  const numberMatch = paramTypeNumber.exec(typeName);
+  if (numberMatch) {
+    const [_, intType, bits] = numberMatch;
+    const bytes = Math.ceil(parseInt(bits, 10) / 8);
+    return intToHex(data, bytes, intType === 'int');
+  }
+  if (typeName === 'bool') {
+    return data ? '01' : '00';
+  }
+
+  // We should be receiving only atomic, non-array types
+  throw ERRORS.TypedError(
+    HardwareErrorCode.RuntimeError,
+    `Unsupported data type for direct field encoding: ${typeName}`
+  );
+};
+
+// these are simple types, so we can just do a string-match
+const paramTypesMap: Record<string, EthereumDataType> = {
+  string: EthereumDataType.STRING,
+  bool: EthereumDataType.BOOL,
+  address: EthereumDataType.ADDRESS,
+};
+
+/**
+ * Converts the given EIP-712 typename into a Protobuf package.
+ *
+ * @param typeName - The EIP-712 typename (e.g. `uint16` for simple types, `Example` for structs)
+ * @param types - Map of types, required for recursive (`struct`) types.
+ */
+export const getFieldType = (
+  typeName: string,
+  types: EthereumSignTypedDataTypes
+): EthereumFieldType => {
+  const arrayMatch = paramTypeArray.exec(typeName);
+  if (arrayMatch) {
+    const [_, arrayItemTypeName, arraySize] = arrayMatch;
+    const entryType = getFieldType(arrayItemTypeName, types);
+    return {
+      data_type: EthereumDataType.ARRAY,
+      size: parseInt(arraySize, 10) || undefined,
+      entry_type: entryType,
+    };
+  }
+
+  const numberMatch = paramTypeNumber.exec(typeName);
+  if (numberMatch) {
+    const [_, type, bits] = numberMatch;
+    return {
+      data_type: type === 'uint' ? EthereumDataType.UINT : EthereumDataType.INT,
+      size: Math.floor(parseInt(bits, 10) / 8),
+    };
+  }
+
+  const bytesMatch = paramTypeBytes.exec(typeName);
+  if (bytesMatch) {
+    const [_, size] = bytesMatch;
+    return {
+      data_type: EthereumDataType.BYTES,
+      size: parseInt(size, 10) || undefined,
+    };
+  }
+
+  const fixedSizeTypeMatch = paramTypesMap[typeName];
+  if (fixedSizeTypeMatch) {
+    return {
+      data_type: fixedSizeTypeMatch,
+    };
+  }
+
+  if (typeName in types) {
+    return {
+      data_type: EthereumDataType.STRUCT,
+      size: types[typeName].length,
+      struct_name: typeName,
+    };
+  }
+
+  throw ERRORS.TypedError(
+    HardwareErrorCode.RuntimeError,
+    `No type definition specified: ${typeName}`
+  );
+};

package/src/api/index.ts

@@ -0,0 +1,161 @@
+export { default as testInitializeDeviceDuration } from './test/TestInitializeDeviceDuration';
+
+export { default as searchDevices } from './SearchDevices';
+export { default as getFeatures } from './GetFeatures';
+export { default as getonetokenfeatures } from './Getonetokenfeatures';
+export { default as getPassphraseState } from './GetPassphraseState';
+export { default as getLogs } from './GetLogs';
+export { default as checkFirmwareRelease } from './CheckFirmwareRelease';
+export { default as checkBLEFirmwareRelease } from './CheckBLEFirmwareRelease';
+export { default as checkBridgeStatus } from './CheckBridgeStatus';
+export { default as checkBridgeRelease } from './CheckBridgeRelease';
+export { default as checkBootloaderRelease } from './CheckBootloaderRelease';
+export { default as checkAllFirmwareRelease } from './CheckAllFirmwareRelease';
+export { default as checkFirmwareTypeAvailable } from './CheckFirmwareTypeAvailable';
+export { default as deviceBackup } from './device/DeviceBackup';
+export { default as deviceChangePin } from './device/DeviceChangePin';
+export { default as deviceFlags } from './device/DeviceFlags';
+export { default as deviceRebootToBootloader } from './device/DeviceRebootToBootloader';
+export { default as deviceRebootToBoardloader } from './device/DeviceRebootToBoardloader';
+export { default as deviceRecovery } from './device/DeviceRecovery';
+export { default as deviceReset } from './device/DeviceReset';
+export { default as deviceSettings } from './device/DeviceSettings';
+export { default as deviceUpdateReboot } from './device/DeviceUpdateReboot';
+export { default as deviceUploadResource } from './device/DeviceUploadResource';
+export { default as deviceSupportFeatures } from './device/DeviceSupportFeatures';
+export { default as deviceVerify } from './device/DeviceVerify';
+export { default as deviceWipe } from './device/DeviceWipe';
+export { default as deviceFullyUploadResource } from './device/DeviceFullyUploadResource';
+export { default as deviceUpdateBootloader } from './device/DeviceUpdateBootloader';
+export { default as deviceLock } from './device/DeviceLock';
+export { default as deviceUnlock } from './device/DeviceUnlock';
+export { default as deviceCancel } from './device/DeviceCancel';
+
+export { default as setU2FCounter } from './u2f/SetU2FCounter';
+export { default as getNextU2FCounter } from './u2f/GetNextU2FCounter';
+
+export { default as firmwareUpdate } from './FirmwareUpdate';
+export { default as firmwareUpdateV2 } from './FirmwareUpdateV2';
+export { default as firmwareUpdateV3 } from './FirmwareUpdateV3';
+export { default as promptWebDeviceAccess } from './PromptWebDeviceAccess';
+
+export { default as cipherKeyValue } from './CipherKeyValue';
+
+export { default as allNetworkGetAddress } from './allnetwork/AllNetworkGetAddress';
+export { default as allNetworkGetAddressByLoop } from './allnetwork/AllNetworkGetAddressByLoop';
+
+export { default as btcGetAddress } from './btc/BTCGetAddress';
+export { default as btcGetPublicKey } from './btc/BTCGetPublicKey';
+export { default as btcSignMessage } from './btc/BTCSignMessage';
+export { default as btcSignPsbt } from './btc/BTCSignPsbt';
+export { default as btcSignTransaction } from './btc/BTCSignTransaction';
+export { default as btcVerifyMessage } from './btc/BTCVerifyMessage';
+
+export { default as confluxGetAddress } from './conflux/ConfluxGetAddress';
+export { default as confluxSignMessage } from './conflux/ConfluxSignMessage';
+export { default as confluxSignMessageCIP23 } from './conflux/ConfluxSignMessageCIP23';
+export { default as confluxSignTransaction } from './conflux/ConfluxSignTransaction';
+
+export { default as evmGetAddress } from './evm/EVMGetAddress';
+export { default as evmGetPublicKey } from './evm/EVMGetPublicKey';
+export { default as evmSignMessage } from './evm/EVMSignMessage';
+export { default as evmSignMessageEIP712 } from './evm/EVMSignMessageEIP712';
+export { default as evmSignTransaction } from './evm/EVMSignTransaction';
+export { default as evmSignTypedData } from './evm/EVMSignTypedData';
+export { default as evmVerifyMessage } from './evm/EVMVerifyMessage';
+
+export { default as starcoinGetAddress } from './starcoin/StarcoinGetAddress';
+export { default as starcoinGetPublicKey } from './starcoin/StarcoinGetPublicKey';
+export { default as starcoinSignMessage } from './starcoin/StarcoinSignMessage';
+export { default as starcoinSignTransaction } from './starcoin/StarcoinSignTransaction';
+export { default as starcoinVerifyMessage } from './starcoin/StarcoinVerifyMessage';
+
+export { default as nemGetAddress } from './nem/NEMGetAddress';
+export { default as nemSignTransaction } from './nem/NEMSignTransaction';
+
+export { default as solGetAddress } from './solana/SolGetAddress';
+export { default as solSignTransaction } from './solana/SolSignTransaction';
+export { default as solSignOffchainMessage } from './solana/SolSignOffchainMessage';
+export { default as solSignMessage } from './solana/SolSignMessage';
+
+export { default as stellarGetAddress } from './stellar/StellarGetAddress';
+export { default as stellarSignTransaction } from './stellar/StellarSignTransaction';
+
+export { default as tronGetAddress } from './tron/TronGetAddress';
+export { default as tronSignMessage } from './tron/TronSignMessage';
+export { default as tronSignTransaction } from './tron/TronSignTransaction';
+
+export { default as nearGetAddress } from './near/NearGetAddress';
+export { default as nearSignTransaction } from './near/NearSignTransaction';
+
+export { default as aptosGetAddress } from './aptos/AptosGetAddress';
+export { default as aptosGetPublicKey } from './aptos/AptosGetPublicKey';
+export { default as aptosSignTransaction } from './aptos/AptosSignTransaction';
+export { default as aptosSignMessage } from './aptos/AptosSignMessage';
+export { default as aptosSignInMessage } from './aptos/AptosSignInMessage';
+
+export { default as algoGetAddress } from './algo/AlgoGetAddress';
+export { default as algoSignTransaction } from './algo/AlgoSignTransaction';
+
+export { default as cosmosGetAddress } from './cosmos/CosmosGetAddress';
+export { default as cosmosGetPublicKey } from './cosmos/CosmosGetPublicKey';
+export { default as cosmosSignTransaction } from './cosmos/CosmosSignTransaction';
+
+export { default as xrpGetAddress } from './xrp/XrpGetAddress';
+export { default as xrpSignTransaction } from './xrp/XrpSignTransaction';
+
+export { default as suiGetAddress } from './sui/SuiGetAddress';
+export { default as suiGetPublicKey } from './sui/SuiGetPublicKey';
+export { default as suiSignMessage } from './sui/SuiSignMessage';
+export { default as suiSignTransaction } from './sui/SuiSignTransaction';
+
+export { default as cardanoGetAddress } from './cardano/CardanoGetAddress';
+export { default as cardanoGetPublicKey } from './cardano/CardanoGetPublicKey';
+export { default as cardanoSignTransaction } from './cardano/CardanoSignTransaction';
+export { default as cardanoSignMessage } from './cardano/CardanoSignMessage';
+
+export { default as filecoinGetAddress } from './filecoin/FilecoinGetAddress';
+export { default as filecoinSignTransaction } from './filecoin/FilecoinSignTransaction';
+
+export { default as polkadotGetAddress } from './polkadot/PolkadotGetAddress';
+export { default as polkadotSignTransaction } from './polkadot/PolkadotSignTransaction';
+
+export { default as kaspaGetAddress } from './kaspa/KaspaGetAddress';
+export { default as kaspaSignTransaction } from './kaspa/KaspaSignTransaction';
+
+export { default as nexaGetAddress } from './nexa/NexaGetAddress';
+export { default as nexaSignTransaction } from './nexa/NexaSignTransaction';
+
+export { default as nostrGetPublicKey } from './nostr/NostrGetPublicKey';
+export { default as nostrSignEvent } from './nostr/NostrSignEvent';
+export { default as nostrEncryptMessage } from './nostr/NostrEncryptMessage';
+export { default as nostrDecryptMessage } from './nostr/NostrDecryptMessage';
+export { default as nostrSignSchnorr } from './nostr/NostrSignSchnorr';
+
+export { default as lnurlAuth } from './lightning/LnurlAuth';
+
+export { default as nervosGetAddress } from './nervos/NervosGetAddress';
+export { default as nervosSignTransaction } from './nervos/NervosSignTransaction';
+
+export { default as dnxGetAddress } from './dynex/DnxGetAddress';
+export { default as dnxSignTransaction } from './dynex/DnxSignTransaction';
+
+export { default as tonGetAddress } from './ton/TonGetAddress';
+export { default as tonSignMessage } from './ton/TonSignMessage';
+export { default as tonSignProof } from './ton/TonSignProof';
+
+export { default as scdoGetAddress } from './scdo/ScdoGetAddress';
+export { default as scdoSignTransaction } from './scdo/ScdoSignTransaction';
+export { default as scdoSignMessage } from './scdo/ScdoSignMessage';
+
+export { default as alephiumGetAddress } from './alephium/AlephiumGetAddress';
+export { default as alephiumSignTransaction } from './alephium/AlephiumSignTransaction';
+export { default as alephiumSignMessage } from './alephium/AlephiumSignMessage';
+
+export { default as benfenGetAddress } from './benfen/BenfenGetAddress';
+export { default as benfenGetPublicKey } from './benfen/BenfenGetPublicKey';
+export { default as benfenSignMessage } from './benfen/BenfenSignMessage';
+export { default as benfenSignTransaction } from './benfen/BenfenSignTransaction';
+
+export { default as neoGetAddress } from './neo/NeoGetAddress';
+export { default as neoSignTransaction } from './neo/NeoSignTransaction';

package/src/api/kaspa/KaspaGetAddress.ts

@@ -0,0 +1,103 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+
+import type { KaspaGetAddress as HardwareKaspaGetAddress } from '@onetokenfe/hd-transport';
+import type { KaspaAddress, KaspaGetAddressParams } from '../../types';
+
+export default class KaspaGetAddress extends BaseMethod<HardwareKaspaGetAddress[]> {
+  hasBundle = 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] };
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: KaspaGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneToken', type: 'boolean' },
+        { name: 'prefix', type: 'string' },
+        { name: 'scheme', type: 'string' },
+        { name: 'useTweak', type: 'boolean' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneToken,
+        prefix: batch.prefix,
+        scheme: batch.scheme,
+        use_tweak: batch.useTweak,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.0.0',
+      },
+      model_touch: {
+        min: '4.3.0',
+      },
+    };
+  }
+
+  getUseTweakVersionRange() {
+    return {
+      pro: {
+        min: '4.14.0',
+      },
+      model_classic1s: {
+        min: '3.12.0',
+      },
+    };
+  }
+
+  async run() {
+    this.checkFeatureVersionLimit(
+      // exists use_tweak is false check firmware version
+      () => this.params.some(param => param.use_tweak === false),
+      () => this.getUseTweakVersionRange(),
+      {
+        strictCheckDeviceSupport: true,
+      }
+    );
+
+    const responses: KaspaAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+      const res = await this.device.commands.typedCall('KaspaGetAddress', 'KaspaAddress', {
+        ...param,
+      });
+
+      const { address } = res.message;
+
+      const result = {
+        path: serializedPath(param.address_n),
+        address,
+      };
+      responses.push(result);
+      this.postPreviousAddressMessage(result);
+    }
+
+    validateResult(responses, ['address'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/kaspa/KaspaSignTransaction.ts

@@ -0,0 +1,182 @@
+import { bytesToHex } from '@noble/hashes/utils';
+
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { serialize, zeroSubnetworkID } from './helpers/TransferSerialize';
+import { SignatureType } from './helpers/SignatureType';
+
+import type { TypedResponseMessage } from '../../device/DeviceCommands';
+import type {
+  KaspaSignInputParams,
+  KaspaSignOutputParams,
+  KaspaSignTransactionParams,
+  KaspaSignature,
+} from '../../types';
+import type { TypedCall } from '@onetokenfe/hd-transport';
+
+export default class KaspaSignTransaction extends BaseMethod<KaspaSignTransactionParams> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const payload = this.payload as KaspaSignTransactionParams;
+
+    // check payload
+    validateParams(payload, [
+      { name: 'version', type: 'number' },
+      { name: 'sigHashType', type: 'number', required: true },
+      { name: 'inputs', type: 'array', required: true },
+      { name: 'outputs', type: 'array', required: true },
+      { name: 'lockTime', required: true },
+      { name: 'sigOpCount', type: 'number' },
+      { name: 'subNetworkID', type: 'string' },
+      { name: 'useTweak', type: 'boolean' },
+    ]);
+
+    // if(!payload.inputs.length) throw
+
+    const inputs: KaspaSignInputParams[] = payload.inputs.map(input => {
+      validateParams(input, [
+        { name: 'path', type: 'string', required: true },
+        { name: 'prevTxId', type: 'string', required: true },
+        { name: 'outputIndex', type: 'number', required: true },
+        { name: 'sequenceNumber', required: true },
+      ]);
+
+      const addressN = validatePath(input.path, 3);
+
+      return {
+        ...input,
+        path: addressN,
+        sigOpCount: input.sigOpCount ?? 1, // input.script.getSignatureOperationsCount()) //sigOpCount
+      };
+    });
+
+    const outputs: KaspaSignOutputParams[] = payload.outputs.map(output => {
+      validateParams(output, [
+        { name: 'satoshis', required: true },
+        { name: 'script', type: 'string', required: true },
+        { name: 'scriptVersion', type: 'number' },
+      ]);
+
+      return {
+        ...output,
+        scriptVersion: output.scriptVersion ?? 0,
+      };
+    });
+
+    this.params = {
+      ...payload,
+      inputs,
+      outputs,
+      scheme: payload.scheme ?? 'schnorr',
+      prefix: payload.prefix ?? 'kaspa',
+      // eslint-disable-next-line no-bitwise
+      sigHashType: payload.sigHashType ?? SignatureType.SIGHASH_ALL | SignatureType.SIGHASH_FORKID,
+      sigOpCount: payload.sigOpCount ?? 1,
+      subNetworkID: payload.subNetworkID ?? bytesToHex(zeroSubnetworkID()),
+      useTweak: payload.useTweak,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.0.0',
+      },
+      model_touch: {
+        min: '4.3.0',
+      },
+    };
+  }
+
+  getUseTweakVersionRange() {
+    return {
+      pro: {
+        min: '4.14.0',
+      },
+      model_classic1s: {
+        min: '3.12.0',
+      },
+    };
+  }
+
+  async processTxRequest(
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'KaspaTxInputRequest'> | TypedResponseMessage<'KaspaSignedTx'>,
+    index: number,
+    signature: KaspaSignature[]
+  ): Promise<KaspaSignature[]> {
+    if (res.type === 'KaspaSignedTx') {
+      signature.push({
+        index,
+        signature: res.message.signature,
+      });
+
+      return signature;
+    }
+
+    if (res.type === 'KaspaTxInputRequest') {
+      signature.push({
+        index,
+        signature: res.message.signature ?? '',
+      });
+
+      const nextIndex = res.message.request_index;
+
+      const { raw: rawMessage } = serialize(this.params, nextIndex);
+      const input = this.params.inputs[nextIndex];
+
+      const response = await typedCall(
+        'KaspaTxInputAck',
+        // @ts-expect-error
+        ['KaspaTxInputRequest', 'KaspaSignedTx'],
+        {
+          address_n: input.path,
+          raw_message: bytesToHex(rawMessage),
+        }
+      );
+
+      // @ts-expect-error
+      return this.processTxRequest(typedCall, response, nextIndex, signature);
+    }
+
+    return signature;
+  }
+
+  async run() {
+    this.checkFeatureVersionLimit(
+      // exists use_tweak is false check firmware version
+      () => this.params.useTweak === false,
+      () => this.getUseTweakVersionRange(),
+      {
+        strictCheckDeviceSupport: true,
+      }
+    );
+
+    const { raw: rawMessage } = serialize(this.params, 0);
+    const input = this.params.inputs[0];
+
+    const { device, params } = this;
+
+    // @ts-expect-error
+    const response = await device.commands.typedCall(
+      'KaspaSignTx',
+      ['KaspaTxInputRequest', 'KaspaSignedTx'],
+      {
+        address_n: input.path,
+        raw_message: bytesToHex(rawMessage),
+        scheme: params.scheme,
+        prefix: params.prefix,
+        input_count: params.inputs.length,
+        use_tweak: params.useTweak,
+      }
+    );
+
+    return this.processTxRequest(device.commands.typedCall.bind(device.commands), response, 0, []);
+  }
+}