@onetokenfe/hd-core 1.1.23

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

@@ -0,0 +1,177 @@
+import BigNumber from 'bignumber.js';
+import { Buffer } from 'buffer';
+
+function isBuffer(arg: any) {
+  return Buffer.isBuffer(arg) || arg instanceof Uint8Array;
+}
+
+function bigNumberToBuffer(bn: BigNumber, options: { size: number }): Buffer {
+  const hex = bn.toString(16);
+  const paddedHex = hex.padStart(options.size * 2, '0');
+  return Buffer.from(paddedHex, 'hex');
+}
+
+class BufferWriter {
+  bufLen: number;
+
+  // @ts-expect-error
+  bufs: Buffer[];
+
+  constructor(obj?: Partial<BufferWriter>) {
+    this.bufLen = 0;
+    if (obj) {
+      this.set(obj);
+    } else {
+      this.bufs = [];
+    }
+  }
+
+  public set(obj: Partial<BufferWriter>): this {
+    this.bufs = obj.bufs || this.bufs || [];
+    this.bufLen = this.bufs.reduce((prev, buf) => prev + buf.length, 0);
+    return this;
+  }
+
+  public toBuffer(): Buffer {
+    return this.concat();
+  }
+
+  public concat(): Buffer {
+    return Buffer.concat(this.bufs, this.bufLen);
+  }
+
+  public write(buf: Buffer): this {
+    if (!isBuffer(buf)) throw new Error('BufferWriter.write: Invalid type');
+    this.bufs.push(buf);
+    this.bufLen += buf.length;
+    return this;
+  }
+
+  public writeReverse(buf: Buffer): this {
+    if (!isBuffer(buf)) throw new Error('BufferWriter.write: Invalid type');
+    this.bufs.push(buf.reverse());
+    this.bufLen += buf.length;
+    return this;
+  }
+
+  public writeVarBytes(buf: Buffer): this {
+    if (!isBuffer(buf)) throw new Error('BufferWriter.write: Invalid type');
+    this.writeUInt64LE(new BigNumber(buf.length));
+    this.write(buf);
+    return this;
+  }
+
+  public writeUInt8(n: number): this {
+    const buf = Buffer.alloc(1);
+    buf.writeUInt8(n, 0);
+    this.write(buf);
+    return this;
+  }
+
+  public writeUInt16BE(n: number): this {
+    const buf = Buffer.alloc(2);
+    buf.writeUInt16BE(n, 0);
+    this.write(buf);
+    return this;
+  }
+
+  public writeUInt16LE(n: number): this {
+    const buf = Buffer.alloc(2);
+    buf.writeUInt16LE(n, 0);
+    this.write(buf);
+    return this;
+  }
+
+  public writeUInt32BE(n: number): this {
+    const buf = Buffer.alloc(4);
+    buf.writeUInt32BE(n, 0);
+    this.write(buf);
+    return this;
+  }
+
+  public writeInt32LE(n: number): this {
+    const buf = Buffer.alloc(4);
+    buf.writeInt32LE(n, 0);
+    this.write(buf);
+    return this;
+  }
+
+  public writeUInt32LE(n: number): this {
+    const buf = Buffer.alloc(4);
+    buf.writeUInt32LE(n, 0);
+    this.write(buf);
+    return this;
+  }
+
+  public writeUInt64BEBN(bn: BigNumber): this {
+    const buf = bigNumberToBuffer(bn, { size: 8 });
+    this.write(buf);
+    return this;
+  }
+
+  public writeUInt64LE(bn: BigNumber): this {
+    const buf = bigNumberToBuffer(bn, { size: 8 });
+    this.writeReverse(buf);
+    return this;
+  }
+
+  public writeVarintNum(n: number): this {
+    const buf = BufferWriter.varintBufNum(n);
+    this.write(buf);
+    return this;
+  }
+
+  public writeVarintBN(bn: BigNumber): this {
+    const buf = BufferWriter.varintBufBN(bn);
+    this.write(buf);
+    return this;
+  }
+
+  public static varintBufNum(n: number): Buffer {
+    let buf: Buffer;
+    if (n < 253) {
+      buf = Buffer.alloc(1);
+      buf.writeUInt8(n, 0);
+    } else if (n < 0x10000) {
+      buf = Buffer.alloc(1 + 2);
+      buf.writeUInt8(253, 0);
+      buf.writeUInt16LE(n, 1);
+    } else if (n < 0x100000000) {
+      buf = Buffer.alloc(1 + 4);
+      buf.writeUInt8(254, 0);
+      buf.writeUInt32LE(n, 1);
+    } else {
+      buf = Buffer.alloc(1 + 8);
+      buf.writeUInt8(255, 0);
+      // eslint-disable-next-line no-bitwise
+      buf.writeInt32LE(n & -1, 1);
+      buf.writeUInt32LE(Math.floor(n / 0x100000000), 5);
+    }
+    return buf;
+  }
+
+  public static varintBufBN(bn: BigNumber): Buffer {
+    let buf: Buffer;
+    const n = bn.toNumber();
+    if (n < 253) {
+      buf = Buffer.alloc(1);
+      buf.writeUInt8(n, 0);
+    } else if (n < 0x10000) {
+      buf = Buffer.alloc(1 + 2);
+      buf.writeUInt8(253, 0);
+      buf.writeUInt16LE(n, 1);
+    } else if (n < 0x100000000) {
+      buf = Buffer.alloc(1 + 4);
+      buf.writeUInt8(254, 0);
+      buf.writeUInt32LE(n, 1);
+    } else {
+      const bw = new BufferWriter();
+      bw.writeUInt8(255);
+      bw.writeUInt64LE(bn);
+      buf = bw.concat();
+    }
+    return buf;
+  }
+}
+
+export default BufferWriter;

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

@@ -0,0 +1,74 @@
+import { blake2b } from '@noble/hashes/blake2b';
+import BigNumber from 'bignumber.js';
+
+import BufferWriter from './BufferWriter';
+
+import type { Hash } from '@noble/hashes/utils';
+
+const TransactionSigningHashKey = Buffer.from('TransactionSigningHash');
+
+class HashWriter {
+  private blake2b: Hash<any>;
+
+  bw: BufferWriter;
+
+  hash: {
+    update: (buf: Buffer) => void;
+    digest: () => Buffer;
+  };
+
+  constructor() {
+    this.bw = new BufferWriter();
+    this.blake2b = blake2b.create({ dkLen: 32, key: TransactionSigningHashKey });
+    this.hash = {
+      update: (buf: Buffer) => {
+        this.bw.write(buf);
+        this.blake2b.update(buf);
+      },
+      digest: () => Buffer.from(this.blake2b.digest()),
+    };
+  }
+
+  writeUInt8(value: number): void {
+    const buf = new BufferWriter();
+    buf.writeUInt8(value);
+    this.hash.update(buf.toBuffer());
+  }
+
+  writeUInt16LE(value: number): void {
+    const buf = new BufferWriter();
+    buf.writeUInt16LE(value);
+    this.hash.update(buf.toBuffer());
+  }
+
+  writeUInt32LE(value: number): void {
+    const buf = new BufferWriter();
+    buf.writeUInt32LE(value);
+    this.hash.update(buf.toBuffer());
+  }
+
+  writeUInt64LE(value: BigNumber.Value): void {
+    const buf = new BufferWriter();
+    buf.writeUInt64LE(new BigNumber(value));
+    this.hash.update(buf.toBuffer());
+  }
+
+  writeVarBytes(buf: Buffer): void {
+    this.writeUInt64LE(buf.length);
+    this.hash.update(buf);
+  }
+
+  writeHash(buf: Buffer): void {
+    this.hash.update(buf);
+  }
+
+  finalize(): Buffer {
+    return this.hash.digest();
+  }
+
+  toBuffer(): Buffer {
+    return this.bw.toBuffer();
+  }
+}
+
+export { HashWriter };

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,144 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { SignatureType } from './SignatureType';
+import { HashWriter } from './HashWriter';
+
+import type {
+  KaspaSignInputParams,
+  KaspaSignOutputParams,
+  KaspaSignTransactionParams,
+} from '../../../types';
+
+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,52 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { bytesToHex } from '../helpers/hexUtils';
+
+import type { LnurlAuth as ILnurlAuth } from '@onetokenfe/hd-transport';
+
+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,75 @@
+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 { NearGetAddress as HardwareNearGetAddress } from '@onetokenfe/hd-transport';
+import type { NearAddress, NearGetAddressParams } 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: 'showOnOneToken', type: 'boolean' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneToken,
+      });
+    });
+  }
+
+  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,46 @@
+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';
+
+import type { NearSignTx as HardwareNearSignTx } from '@onetokenfe/hd-transport';
+
+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,72 @@
+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 { NEMGetAddress as HardwareNEMGetAddress } from '@onetokenfe/hd-transport';
+import type { 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: 'showOnOneToken', type: 'boolean' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        network: batch.network || MAINNET,
+        show_display: showOnOneToken,
+      });
+    });
+  }
+
+  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]);
+  }
+}