@onekeyfe/hd-core 0.2.50 → 0.2.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "0.2.50",
+  "version": "0.2.51",
   "description": "> TODO: description",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -24,8 +24,8 @@
     "url": "https://github.com/OneKeyHQ/hardware-js-sdk/issues"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "^0.2.50",
-    "@onekeyfe/hd-transport": "^0.2.50",
+    "@onekeyfe/hd-shared": "^0.2.51",
+    "@onekeyfe/hd-transport": "^0.2.51",
     "axios": "^0.27.2",
     "bignumber.js": "^9.0.2",
     "bytebuffer": "^5.0.1",
@@ -43,5 +43,5 @@
     "@types/semver": "^7.3.9",
     "ripple-keypairs": "^1.1.4"
   },
-  "gitHead": "edbce169a20c259028bfc281dade30e75fedd826"
+  "gitHead": "38873db4d18b60e2a330e26deb155210860b9e54"
 }

package/src/api/index.ts

@@ -99,3 +99,6 @@ export { default as filecoinSignTransaction } from './filecoin/FilecoinSignTrans
 
 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';

package/src/api/kaspa/KaspaGetAddress.ts

@@ -0,0 +1,77 @@
+import { KaspaGetAddress as HardwareKaspaGetAddress } from '@onekeyfe/hd-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { KaspaGetAddressParams, KaspaAddress } from '../../types';
+
+export default class KaspaGetAddress extends BaseMethod<HardwareKaspaGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.notAllowDeviceMode = [...this.notAllowDeviceMode, UI_REQUEST.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: 'showOnOneKey', type: 'boolean' },
+        { name: 'prefix', type: 'string' },
+        { name: 'scheme', type: 'string' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+        prefix: batch.prefix,
+        scheme: batch.scheme,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.0.0',
+      },
+      model_touch: {
+        min: '4.3.0',
+      },
+    };
+  }
+
+  async run() {
+    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);
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/kaspa/KaspaSignTransaction.ts

@@ -0,0 +1,157 @@
+import { bytesToHex } from '@noble/hashes/utils';
+import { TypedCall } from '@onekeyfe/hd-transport';
+import { TypedResponseMessage } from '../../device/DeviceCommands';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import {
+  KaspaSignInputParams,
+  KaspaSignOutputParams,
+  KaspaSignTransactionParams,
+  KaspaSignature,
+} from '../../types';
+import { zeroSubnetworkID, serialize } from './helpers/TransferSerialize';
+import { SignatureType } from './helpers/SignatureType';
+
+export default class KaspaSignTransaction extends BaseMethod<KaspaSignTransactionParams> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.notAllowDeviceMode = [...this.notAllowDeviceMode, UI_REQUEST.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' },
+    ]);
+
+    // 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()),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.0.0',
+      },
+      model_touch: {
+        min: '4.3.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() {
+    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,
+      }
+    );
+
+    return this.processTxRequest(device.commands.typedCall.bind(device.commands), response, 0, []);
+  }
+}

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,72 @@
+import { blake2b } from '@noble/hashes/blake2b';
+import BigNumber from 'bignumber.js';
+import { Hash } from '@noble/hashes/utils';
+import BufferWriter from './BufferWriter';
+
+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,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/inject.ts

@@ -230,6 +230,11 @@ export const inject = ({
       call({ ...params, connectId, deviceId, method: 'polkadotGetAddress' }),
     polkadotSignTransaction: (connectId, deviceId, params) =>
       call({ ...params, connectId, deviceId, method: 'polkadotSignTransaction' }),
+
+    kaspaGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'kaspaGetAddress' }),
+    kaspaSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'kaspaSignTransaction' }),
   };
   return api;
 };

package/src/types/api/export.ts

@@ -123,3 +123,11 @@ export type { FilecoinSignTransactionParams, FilecoinSignedTx } from './filecoin
 
 export type { PolkadotAddress, PolkadotGetAddressParams } from './polkadotGetAddress';
 export type { PolkadotSignedTx, PolkadotSignTransactionParams } from './polkadotSignTransaction';
+
+export type { KaspaAddress, KaspaGetAddressParams } from './kaspaGetAddress';
+export type {
+  KaspaSignature,
+  KaspaSignTransactionParams,
+  KaspaSignInputParams,
+  KaspaSignOutputParams,
+} from './kaspaSignTransaction';