@ukeyfe/hardware-core 1.1.13

package/src/api/btc/helpers/xpubUtils.ts

@@ -0,0 +1,131 @@
+import { sha256 } from '@noble/hashes/sha256';
+import type { HDNodeType, InputScriptType } from '@ukeyfe/hardware-transport';
+
+// 定义版本字节常量
+const VERSION_BYTES = {
+  // xpub - (SPENDADDRESS, SPENDMULTISIG)
+  XPUB: 0x0488b21e,
+  // ypub - (SPENDP2SHWITNESS)
+  YPUB: 0x049d7cb2,
+  // zpub - (SPENDWITNESS)
+  ZPUB: 0x04b24746,
+};
+
+export function getVersionBytes(
+  coinName: string,
+  scriptType?: InputScriptType
+): number | undefined {
+  if (coinName.toLowerCase() === 'bitcoin') {
+    switch (scriptType) {
+      case 'SPENDADDRESS':
+      case 'SPENDMULTISIG':
+        // 44、48
+        return VERSION_BYTES.XPUB;
+      case 'SPENDP2SHWITNESS':
+        // 49
+        return VERSION_BYTES.YPUB;
+      case 'SPENDWITNESS':
+        // 84
+        return VERSION_BYTES.ZPUB;
+      default:
+        // 86、10025
+        return VERSION_BYTES.XPUB;
+    }
+  } else if (coinName.toLowerCase() === 'litecoin') {
+    switch (scriptType) {
+      case 'SPENDADDRESS':
+      case 'SPENDMULTISIG':
+        // 44、48
+        return 0x019da462;
+      case 'SPENDP2SHWITNESS':
+        // 49
+        return 0x01b26ef6;
+      case 'SPENDWITNESS':
+        // 84
+        return 0x04b24746;
+      default:
+        // not support 86、10025 path
+        return undefined;
+    }
+  } else if (coinName.toLowerCase() === 'dogecoin') {
+    if (scriptType === 'SPENDADDRESS') {
+      // 44
+      return 0x02facafd;
+    }
+    if (scriptType === 'SPENDMULTISIG') {
+      // 48
+      return 0x0488b21e;
+    }
+    return undefined;
+  }
+  return undefined;
+}
+
+function base58Check(data: Buffer): string {
+  const checksum = sha256(sha256(new Uint8Array(data))).slice(0, 4);
+  const withChecksum = Buffer.concat([new Uint8Array(data), new Uint8Array(checksum)]);
+  const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+
+  let result = '';
+  let num = BigInt(`0x${withChecksum.toString('hex')}`);
+  const base = BigInt(58);
+
+  while (num > 0) {
+    const mod = Number(num % base);
+    num /= base;
+    result = ALPHABET[mod] + result;
+  }
+
+  // 处理前导零字节
+  for (let i = 0; i < withChecksum.length; i++) {
+    if (withChecksum[i] === 0) {
+      result = `1${result}`;
+    } else {
+      break;
+    }
+  }
+
+  return result;
+}
+
+function generateExtendedPublicKey(
+  coinName: string,
+  depth: number,
+  fingerprint: number,
+  childNum: number,
+  chainCode: string,
+  publicKey: string,
+  scriptType?: InputScriptType
+): string {
+  const versionBytes = getVersionBytes(coinName, scriptType);
+
+  if (!versionBytes) {
+    throw new Error(`Invalid coinName, not support generate xpub for scriptType: ${scriptType}`);
+  }
+
+  const buffer = Buffer.alloc(78);
+  buffer.writeUInt32BE(versionBytes, 0);
+  buffer.writeUInt8(depth, 4);
+  buffer.writeUInt32BE(fingerprint, 5);
+  buffer.writeUInt32BE(childNum, 9);
+  buffer.write(chainCode, 13, 'hex');
+  buffer.write(publicKey, 45, 'hex');
+
+  return base58Check(buffer);
+}
+
+export function createExtendedPublicKey(
+  node: HDNodeType,
+  coinName: string,
+  scriptType?: InputScriptType
+): string {
+  return generateExtendedPublicKey(
+    coinName,
+    node.depth,
+    node.fingerprint,
+    node.child_num,
+    node.chain_code,
+    node.public_key,
+    scriptType
+  );
+}

package/src/api/cardano/CardanoGetAddress.ts

@@ -0,0 +1,138 @@
+import { BaseMethod } from '../BaseMethod';
+import { PROTO } from '../../constants';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import {
+  validateAddressParameters,
+  addressParametersToProto,
+  addressParametersFromProto,
+} from './helper/addressParameters';
+import { serializedPath } from '../helpers/pathUtils';
+import { CardanoGetAddressParams, CardanoAddress } from '../../types/api/cardanoGetAddress';
+import { CardanoGetAddressMethodParams } from '../../types';
+
+export default class CardanoGetAddress extends BaseMethod<CardanoGetAddressParams[]> {
+  hasBundle?: boolean;
+
+  isCheck?: boolean;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    this.isCheck = this.hasBundle
+      ? !!this.payload?.bundle.every((i: CardanoGetAddressMethodParams) => !!i.isCheck)
+      : !!this.payload?.isCheck;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    this.params = payload.bundle.map((batch: any) => {
+      // validate incoming parameters for each batch
+      validateParams(batch, [
+        { name: 'addressParameters', type: 'object', required: true },
+        { name: 'networkId', type: 'number', required: true },
+        { name: 'protocolMagic', type: 'number', required: true },
+        { name: 'derivationType', type: 'number' },
+        { name: 'address', type: 'string' },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      validateAddressParameters(batch.addressParameters);
+
+      return {
+        address_parameters: addressParametersToProto(batch.addressParameters),
+        address: batch.address,
+        protocol_magic: batch.protocolMagic,
+        network_id: batch.networkId,
+        derivation_type:
+          typeof batch.derivationType !== 'undefined'
+            ? batch.derivationType
+            : PROTO.CardanoDerivationType.ICARUS,
+        show_display: typeof batch.showOnOneKey === 'boolean' ? !!batch.showOnOneKey : true,
+      };
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.0.0',
+      },
+      model_touch: {
+        min: '4.1.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: CardanoAddress[] = [];
+
+    for (const batch of this.params) {
+      const { address_parameters, protocol_magic, network_id, derivation_type, show_display } =
+        batch;
+      const response = await this.device.commands.typedCall('CardanoGetAddress', 'CardanoAddress', {
+        address_parameters,
+        protocol_magic,
+        network_id,
+        derivation_type,
+        show_display,
+      });
+
+      let xpub;
+      let stakeAddress;
+      if (address_parameters.address_type === PROTO.CardanoAddressType.BASE && !this.isCheck) {
+        const publicKeyRes = await this.device.commands.typedCall(
+          'CardanoGetPublicKey',
+          'CardanoPublicKey',
+          {
+            address_n: address_parameters.address_n.slice(0, 3),
+            derivation_type,
+            show_display: false,
+          }
+        );
+        xpub = publicKeyRes.message.xpub;
+
+        const stakeAddressRes = await this.device.commands.typedCall(
+          'CardanoGetAddress',
+          'CardanoAddress',
+          {
+            address_parameters: {
+              address_type: PROTO.CardanoAddressType.REWARD,
+              address_n: [],
+              address_n_staking: address_parameters.address_n_staking,
+            },
+            protocol_magic,
+            network_id,
+            derivation_type,
+            show_display: false,
+          }
+        );
+
+        stakeAddress = stakeAddressRes.message.address;
+      }
+
+      const path = serializedPath(batch.address_parameters.address_n);
+      responses.push({
+        addressParameters: addressParametersFromProto(batch.address_parameters),
+        protocolMagic: batch.protocol_magic,
+        networkId: batch.network_id,
+        serializedPath: path,
+        serializedStakingPath: serializedPath(batch.address_parameters.address_n_staking),
+        address: response.message.address,
+        xpub,
+        stakeAddress,
+      });
+
+      this.postPreviousAddressMessage({
+        path,
+        address: response.message.address,
+      });
+    }
+
+    validateResult(responses, ['serializedPath', 'serializedStakingPath', 'address'], {
+      expectedLength: this.params.length,
+    });
+
+    return this.hasBundle ? responses : responses[0];
+  }
+}

package/src/api/cardano/CardanoGetPublicKey.ts

@@ -0,0 +1,71 @@
+import { BaseMethod } from '../BaseMethod';
+import { PROTO } from '../../constants';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { CardanoPublicKeyParams, CardanoPublicKey } from '../../types/api/cardanoGetPublicKey';
+
+export default class CardanoGetPublicKey extends BaseMethod<CardanoPublicKeyParams[]> {
+  hasBundle?: boolean;
+
+  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] };
+
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    this.params = payload.bundle.map((batch: any) => {
+      // validate incoming parameters for each batch
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'derivationType', type: 'number' },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const path = validatePath(batch.path, 3);
+      return {
+        address_n: path,
+        derivation_type:
+          typeof batch.derivationType !== 'undefined'
+            ? batch.derivationType
+            : PROTO.CardanoDerivationType.ICARUS,
+        show_display: typeof batch.showOnOneKey === 'boolean' ? batch.showOnOneKey : false,
+      };
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.0.0',
+      },
+      model_touch: {
+        min: '4.1.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: CardanoPublicKey[] = [];
+    const cmd = this.device.getCommands();
+    for (let i = 0; i < this.params.length; i++) {
+      const batch = this.params[i];
+      const { message } = await cmd.typedCall('CardanoGetPublicKey', 'CardanoPublicKey', batch);
+      responses.push({
+        path: batch.address_n,
+        serializedPath: serializedPath(batch.address_n),
+        xpub: message.xpub,
+        node: message.node,
+      });
+    }
+
+    validateResult(responses, ['xpub'], {
+      expectedLength: this.params.length,
+    });
+
+    return this.hasBundle ? responses : responses[0];
+  }
+}

package/src/api/cardano/CardanoSignMessage.ts

@@ -0,0 +1,70 @@
+import { BaseMethod } from '../BaseMethod';
+import { PROTO } from '../../constants';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validateParams } from '../helpers/paramsValidator';
+import { validatePath } from '../helpers/pathUtils';
+import { CardanoSignMessageParams } from '../../types/api/cardanoSignMessage';
+
+export default class CardanoSignMessage extends BaseMethod<CardanoSignMessageParams> {
+  hasBundle?: boolean;
+
+  isCheck?: boolean;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const { payload } = this;
+    validateParams(payload, [
+      { name: 'path', type: 'string', required: true },
+      { name: 'message', type: 'string', required: true },
+      { name: 'derivationType', type: 'number' },
+      { name: 'networkId', type: 'number', required: true },
+      { name: 'addressType', type: 'number' },
+    ]);
+
+    const addressN = validatePath(payload.path, 3);
+
+    this.params = {
+      address_n: addressN,
+      message: payload.message,
+      derivation_type:
+        typeof payload.derivationType !== 'undefined'
+          ? payload.derivationType
+          : PROTO.CardanoDerivationType.ICARUS,
+      network_id: payload.networkId,
+      address_type: payload.addressType,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_touch: {
+        min: '4.10.0',
+      },
+    };
+  }
+
+  getAddressTypeVersionRange() {
+    return {
+      pro: {
+        min: '4.9.3',
+      },
+    };
+  }
+
+  async run() {
+    this.checkFeatureVersionLimit(
+      () => this.params.address_type !== null && this.params.address_type !== undefined,
+      () => this.getAddressTypeVersionRange()
+    );
+
+    const res = await this.device.commands.typedCall(
+      'CardanoSignMessage',
+      'CardanoMessageSignature',
+      this.params
+    );
+
+    return res.message;
+  }
+}