@ukeyfe/hardware-core 1.1.13

package/src/api/kaspa/helpers/SignatureType.ts

@@ -0,0 +1,7 @@
+export enum SignatureType {
+  SIGHASH_ALL = 0x01,
+  SIGHASH_NONE = 0x02,
+  SIGHASH_SINGLE = 0x03,
+  SIGHASH_FORKID = 0x40,
+  SIGHASH_ANYONECANPAY = 0x80,
+}

package/src/api/kaspa/helpers/TransferSerialize.ts

@@ -0,0 +1,143 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import {
+  KaspaSignTransactionParams,
+  KaspaSignInputParams,
+  KaspaSignOutputParams,
+} from '../../../types';
+import { SignatureType } from './SignatureType';
+import { HashWriter } from './HashWriter';
+
+export function zeroHash() {
+  return Buffer.alloc(32);
+}
+
+export function zeroSubnetworkID() {
+  return Buffer.alloc(20);
+}
+
+function isSighashAnyoneCanPay(sighashType: number) {
+  // eslint-disable-next-line no-bitwise
+  return (sighashType & SignatureType.SIGHASH_ANYONECANPAY) === SignatureType.SIGHASH_ANYONECANPAY;
+}
+
+function isSighashSingle(sighashType: number) {
+  // eslint-disable-next-line no-bitwise
+  return (sighashType & 31) === SignatureType.SIGHASH_SINGLE;
+}
+
+function isSighashNone(sighashType: number) {
+  // eslint-disable-next-line no-bitwise
+  return (sighashType & 31) === SignatureType.SIGHASH_NONE;
+}
+
+function hashOutpoint(hashWriter: HashWriter, input: KaspaSignInputParams) {
+  hashWriter.writeHash(Buffer.from(input.prevTxId, 'hex'));
+  hashWriter.writeUInt32LE(input.outputIndex);
+}
+
+function getPreviousOutputsHash(
+  transaction: KaspaSignTransactionParams,
+  sighashType: SignatureType
+) {
+  if (isSighashAnyoneCanPay(sighashType)) {
+    return zeroHash();
+  }
+
+  const hashWriter = new HashWriter();
+  transaction.inputs.forEach(input => hashOutpoint(hashWriter, input));
+  return hashWriter.finalize();
+}
+
+function getSequencesHash(transaction: KaspaSignTransactionParams, sighashType: SignatureType) {
+  if (
+    isSighashSingle(sighashType) ||
+    isSighashAnyoneCanPay(sighashType) ||
+    isSighashNone(sighashType)
+  ) {
+    return zeroHash();
+  }
+
+  const hashWriter = new HashWriter();
+  transaction.inputs.forEach(input => hashWriter.writeUInt64LE(input.sequenceNumber));
+  return hashWriter.finalize();
+}
+
+function getSigOpCountsHash(transaction: KaspaSignTransactionParams, sighashType: SignatureType) {
+  if (isSighashAnyoneCanPay(sighashType)) {
+    return zeroHash();
+  }
+
+  const hashWriter = new HashWriter();
+  transaction.inputs.forEach(input => hashWriter.writeUInt8(input.sigOpCount!));
+  return hashWriter.finalize();
+}
+
+function hashTxOut(hashWriter: HashWriter, output: KaspaSignOutputParams) {
+  hashWriter.writeUInt64LE(output.satoshis);
+  hashWriter.writeUInt16LE(0); // TODO: USE REAL SCRIPT VERSION
+  hashWriter.writeVarBytes(Buffer.from(output.script, 'hex'));
+}
+
+function getOutputsHash(
+  transaction: KaspaSignTransactionParams,
+  inputNumber: number,
+  sighashType: SignatureType
+) {
+  if (isSighashNone(sighashType)) {
+    return zeroHash();
+  }
+
+  // SigHashSingle: If the relevant output exists - return its hash, otherwise return zero-hash
+  if (isSighashSingle(sighashType)) {
+    if (inputNumber >= transaction.outputs.length) {
+      return zeroHash();
+    }
+
+    const hashWriter = new HashWriter();
+    return hashWriter.finalize();
+  }
+
+  const hashWriter = new HashWriter();
+  transaction.outputs.forEach(output => hashTxOut(hashWriter, output));
+  return hashWriter.finalize();
+}
+
+/**
+ * Returns a buffer of length 32 bytes with the hash that needs to be signed
+ * for OP_CHECKSIG.
+ *
+ * @name serialize
+ * @param {Transaction} transaction the transaction to sign
+ * @param {number} sighashType the type of the hash
+ * @param {number} inputNumber the input index for the signature
+ * @param {Script} subscript the script that will be signed
+ * @param {satoshisBN} input's amount (for  ForkId signatures)
+ *
+ */
+export function serialize(transaction: KaspaSignTransactionParams, inputNumber: number) {
+  const hashWriter = new HashWriter();
+
+  hashWriter.writeUInt16LE(transaction.version);
+  hashWriter.writeHash(getPreviousOutputsHash(transaction, transaction.sigHashType!));
+  hashWriter.writeHash(getSequencesHash(transaction, transaction.sigHashType!));
+  hashWriter.writeHash(getSigOpCountsHash(transaction, transaction.sigHashType!));
+
+  const input = transaction.inputs[inputNumber];
+  hashOutpoint(hashWriter, input);
+  hashWriter.writeUInt16LE(0); // TODO: USE REAL SCRIPT VERSION
+  hashWriter.writeVarBytes(Buffer.from(input.output.script, 'hex'));
+  hashWriter.writeUInt64LE(input.output.satoshis);
+  hashWriter.writeUInt64LE(input.sequenceNumber);
+  hashWriter.writeUInt8(transaction.sigOpCount ?? 1); // sigOpCount
+  hashWriter.writeHash(getOutputsHash(transaction, inputNumber, transaction.sigHashType!));
+  hashWriter.writeUInt64LE(transaction.lockTime);
+  hashWriter.writeHash(zeroSubnetworkID()); // TODO: USE REAL SUBNETWORK ID
+  hashWriter.writeUInt64LE(0); // TODO: USE REAL GAS
+  hashWriter.writeHash(zeroHash()); // TODO: USE REAL PAYLOAD HASH
+  hashWriter.writeUInt8(transaction.sigHashType!);
+
+  return {
+    hash: hashWriter.finalize(),
+    raw: hashWriter.toBuffer(),
+  };
+}

package/src/api/lightning/LnurlAuth.ts

@@ -0,0 +1,51 @@
+import { LnurlAuth as ILnurlAuth } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { bytesToHex } from '../helpers/hexUtils';
+
+export default class LnurlAuth1 extends BaseMethod<ILnurlAuth> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const { payload } = this;
+    validateParams(payload, [
+      { name: 'domain', type: 'string', required: true },
+      { name: 'k1', type: 'string', required: true },
+    ]);
+
+    this.params = {
+      domain: bytesToHex(Buffer.from(payload.domain, 'utf-8')),
+      data: bytesToHex(Buffer.from(payload.k1, 'hex')),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.7.0',
+      },
+      model_touch: {
+        min: '4.8.0',
+      },
+    };
+  }
+
+  async run() {
+    const { message } = await this.device.commands.typedCall(
+      'LnurlAuth',
+      'LnurlAuthResp',
+      this.params
+    );
+
+    validateResult(message, ['publickey', 'path']);
+
+    return {
+      ...message,
+      pub: message.publickey,
+    };
+  }
+}

package/src/api/near/NearGetAddress.ts

@@ -0,0 +1,74 @@
+import { NearGetAddress as HardwareNearGetAddress } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { NearGetAddressParams, NearAddress } from '../../types';
+
+export default class NearGetAddress extends BaseMethod<HardwareNearGetAddress[]> {
+  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: NearGetAddressParams) => {
+      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.5.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: NearAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('NearGetAddress', 'NearAddress', {
+        ...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/near/NearSignTransaction.ts

@@ -0,0 +1,45 @@
+import { NearSignTx as HardwareNearSignTx } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+export default class NearSignTransaction extends BaseMethod<HardwareNearSignTx> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'rawTx', type: 'hexString', required: true },
+    ]);
+
+    const { path, rawTx } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      raw_tx: formatAnyHex(rawTx),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.5.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('NearSignTx', 'NearSignedTx', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/nem/NEMGetAddress.ts

@@ -0,0 +1,71 @@
+import { NEMGetAddress as HardwareNEMGetAddress } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath, serializedPath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { NEMAddress, NEMGetAddressParams } from '../../types';
+
+const MAINNET = 0x68; // 104
+
+export default class NEMGetAddress extends BaseMethod<HardwareNEMGetAddress[]> {
+  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: NEMGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'network', type: 'number' },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        network: batch.network || MAINNET,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  async run() {
+    const responses: NEMAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('NEMGetAddress', 'NEMAddress', {
+        ...param,
+      });
+
+      const path = serializedPath(param.address_n);
+      responses.push({
+        path,
+        ...res.message,
+      });
+      this.postPreviousAddressMessage({
+        path,
+        address: res.message.address,
+      });
+    }
+
+    validateResult(responses, ['address'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/nem/NEMSignTransaction.ts

@@ -0,0 +1,250 @@
+import {
+  NEMAggregateModification,
+  NEMImportanceTransfer,
+  NEMMosaicCreation,
+  NEMMosaicDefinition,
+  NEMMosaicSupplyChange,
+  NEMProvisionNamespace,
+  NEMSignTx,
+  NEMTransactionCommon,
+  NEMTransfer,
+} from '@ukeyfe/hardware-transport';
+
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import {
+  NEMAggregateModificationTransaction,
+  NEMImportanceTransaction,
+  NEMMosaicCreationTransaction,
+  NEMProvisionNamespaceTransaction,
+  NEMSupplyChangeTransaction,
+  NEMTransaction,
+  NEMTransferTransaction,
+} from '../../types';
+
+const NEM_TRANSFER = 0x0101;
+const NEM_COSIGNING = 0x0102;
+const NEM_IMPORTANCE_TRANSFER = 0x0801;
+const NEM_AGGREGATE_MODIFICATION = 0x1001;
+const NEM_MULTISIG_SIGNATURE = 0x1002;
+const NEM_MULTISIG = 0x1004;
+const NEM_PROVISION_NAMESPACE = 0x2001;
+const NEM_MOSAIC_CREATION = 0x4001;
+const NEM_SUPPLY_CHANGE = 0x4002;
+
+export default class NEMSignTransaction extends BaseMethod<NEMSignTx> {
+  NEM_MOSAIC_LEVY_TYPES: Record<number, string> = {
+    1: 'MosaicLevy_Absolute',
+    2: 'MosaicLevy_Percentile',
+  };
+
+  NEM_SUPPLY_CHANGE_TYPES: Record<number, string> = {
+    1: 'SupplyChange_Increase',
+    2: 'SupplyChange_Decrease',
+  };
+
+  NEM_AGGREGATE_MODIFICATION_TYPES: Record<number, string> = {
+    1: 'CosignatoryModification_Add',
+    2: 'CosignatoryModification_Delete',
+  };
+
+  NEM_IMPORTANCE_TRANSFER_MODES: Record<number, string> = {
+    1: 'ImportanceTransfer_Activate',
+    2: 'ImportanceTransfer_Deactivate',
+  };
+
+  getCommon = (tx: NEMTransaction, address_n?: number[]): NEMTransactionCommon => ({
+    address_n,
+    // eslint-disable-next-line no-bitwise
+    network: (tx.version >> 24) & 0xff,
+    timestamp: tx.timeStamp,
+    fee: tx.fee,
+    deadline: tx.deadline ?? 0,
+    signer: address_n ? undefined : tx.signer,
+  });
+
+  transferMessage = (tx: NEMTransferTransaction): NEMTransfer => {
+    const mosaics = tx.mosaics
+      ? tx.mosaics.map(mosaic => ({
+          namespace: mosaic.mosaicId.namespaceId,
+          mosaic: mosaic.mosaicId.name,
+          quantity: mosaic.quantity,
+        }))
+      : undefined;
+
+    return {
+      recipient: tx.recipient,
+      amount: tx.amount,
+      payload: tx.message ? tx.message.payload : undefined,
+      public_key: tx.message && tx.message.type === 0x02 ? tx.message.publicKey : undefined,
+      mosaics,
+    };
+  };
+
+  importanceTransferMessage = (tx: NEMImportanceTransaction): NEMImportanceTransfer => ({
+    // @ts-expect-error
+    mode: this.NEM_IMPORTANCE_TRANSFER_MODES[tx.importanceTransfer.mode],
+    public_key: tx.importanceTransfer.publicKey,
+  });
+
+  aggregateModificationMessage = (
+    tx: NEMAggregateModificationTransaction
+  ): NEMAggregateModification => {
+    const modifications = tx.modifications
+      ? tx.modifications.map(modification => ({
+          type: this.NEM_AGGREGATE_MODIFICATION_TYPES[modification.modificationType],
+          public_key: modification.cosignatoryAccount,
+        }))
+      : undefined;
+
+    return {
+      // @ts-expect-error
+      modifications,
+      relative_change: tx.minCosignatories.relativeChange,
+    };
+  };
+
+  provisionNamespaceMessage = (tx: NEMProvisionNamespaceTransaction): NEMProvisionNamespace => ({
+    namespace: tx.newPart ?? '',
+    parent: tx.parent || undefined,
+    sink: tx.rentalFeeSink ?? '',
+    fee: tx.rentalFee ?? 0,
+  });
+
+  mosaicCreationMessage = (tx: NEMMosaicCreationTransaction): NEMMosaicCreation => {
+    const { levy } = tx.mosaicDefinition;
+
+    const definition: NEMMosaicDefinition = {
+      namespace: tx.mosaicDefinition.id.namespaceId,
+      mosaic: tx.mosaicDefinition.id.name,
+      // @ts-expect-error
+      levy: levy && levy.type ? this.NEM_MOSAIC_LEVY_TYPES[levy.type] : undefined,
+      fee: levy && levy.fee,
+      levy_address: levy && levy.recipient,
+      levy_namespace: levy && levy.mosaicId && levy.mosaicId.namespaceId,
+      levy_mosaic: levy && levy.mosaicId && levy.mosaicId.name,
+      description: tx.mosaicDefinition.description,
+    };
+
+    const { properties } = tx.mosaicDefinition;
+    if (Array.isArray(properties)) {
+      properties.forEach(property => {
+        const { name, value } = property;
+        switch (name) {
+          case 'divisibility':
+            definition.divisibility = parseInt(value);
+            break;
+
+          case 'initialSupply':
+            definition.supply = parseInt(value);
+            break;
+
+          case 'supplyMutable':
+            definition.mutable_supply = value === 'true';
+            break;
+
+          case 'transferable':
+            definition.transferable = value === 'true';
+            break;
+          default:
+        }
+      });
+    }
+
+    return {
+      definition,
+      sink: tx.creationFeeSink ?? '',
+      fee: tx.creationFee ?? 0,
+    };
+  };
+
+  supplyChangeMessage = (tx: NEMSupplyChangeTransaction): NEMMosaicSupplyChange => ({
+    namespace: tx.mosaicId.namespaceId,
+    mosaic: tx.mosaicId.name,
+    // @ts-expect-error
+    type: this.NEM_SUPPLY_CHANGE_TYPES[tx.supplyType],
+    delta: tx.delta ?? 0,
+  });
+
+  parseTx = (tx: NEMTransaction, address_n: number[]) => {
+    let transaction = tx;
+    const message: NEMSignTx = {
+      transaction: this.getCommon(tx, address_n),
+      transfer: undefined,
+      importance_transfer: undefined,
+      aggregate_modification: undefined,
+      provision_namespace: undefined,
+      mosaic_creation: undefined,
+      supply_change: undefined,
+    };
+
+    if (
+      tx.type === NEM_COSIGNING ||
+      tx.type === NEM_MULTISIG ||
+      tx.type === NEM_MULTISIG_SIGNATURE
+    ) {
+      message.cosigning = tx.type === NEM_COSIGNING || tx.type === NEM_MULTISIG_SIGNATURE;
+      transaction = tx.otherTrans;
+      message.multisig = this.getCommon(transaction);
+    }
+
+    switch (transaction.type) {
+      case NEM_TRANSFER:
+        message.transfer = this.transferMessage(transaction);
+        break;
+
+      case NEM_IMPORTANCE_TRANSFER:
+        message.importance_transfer = this.importanceTransferMessage(transaction);
+        break;
+
+      case NEM_AGGREGATE_MODIFICATION:
+        message.aggregate_modification = this.aggregateModificationMessage(transaction);
+        break;
+
+      case NEM_PROVISION_NAMESPACE:
+        message.provision_namespace = this.provisionNamespaceMessage(transaction);
+        break;
+
+      case NEM_MOSAIC_CREATION:
+        message.mosaic_creation = this.mosaicCreationMessage(transaction);
+        break;
+
+      case NEM_SUPPLY_CHANGE:
+        message.supply_change = this.supplyChangeMessage(transaction);
+        break;
+
+      default:
+        throw ERRORS.TypedError(
+          HardwareErrorCode.CallMethodInvalidParameter,
+          'Unknown transaction type'
+        );
+    }
+
+    return message;
+  };
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'transaction', type: 'object', required: true },
+    ]);
+    const { path, transaction } = this.payload;
+    const addressN = validatePath(path, 3);
+
+    this.params = this.parseTx(transaction, addressN);
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('NEMSignTx', 'NEMSignedTx', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res);
+  }
+}