@onekeyfe/hd-core 0.2.50 → 0.2.52

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/data-manager/DataManager.ts

@@ -22,7 +22,7 @@ import type {
 } from '../types';
 import { getReleaseChangelog, getReleaseStatus, findLatestRelease } from '../utils/release';
 
-type FirmwareField = 'firmware' | 'firmware-v3';
+type FirmwareField = 'firmware' | 'firmware-v2' | 'firmware-v3';
 
 export default class DataManager {
   static deviceMap: DeviceTypeMap = {

package/src/device/DevicePool.ts

@@ -89,7 +89,7 @@ export class DevicePool extends EventEmitter {
     connectId?: string,
     initOptions?: InitOptions
   ) {
-    Log.debug('get device list: connectId: ', connectId);
+    // Log.debug('get device list: connectId: ', connectId);
 
     const devices: Record<string, Device> = {};
     const deviceList = [];
@@ -101,7 +101,7 @@ export class DevicePool extends EventEmitter {
       if (device) {
         const exist = descriptorList.find(d => d.path === device.originalDescriptor.path);
         if (exist) {
-          Log.debug('find existed Device: ', connectId);
+          // Log.debug('find existed Device: ', connectId);
           device.updateDescriptor(exist, true);
           devices[connectId] = device;
           deviceList.push(device);
@@ -128,15 +128,15 @@ export class DevicePool extends EventEmitter {
       deviceList.push(device);
     }
     // Log.debug('get devices result : ', devices, deviceList);
-    console.log('device poll -> connected: ', this.connectedPool);
-    console.log('device poll -> disconnected: ', this.disconnectPool);
+    // console.log('device poll -> connected: ', this.connectedPool);
+    // console.log('device poll -> disconnected: ', this.disconnectPool);
     await this._checkDevicePool(initOptions);
     return { devices, deviceList };
   }
 
   static clearDeviceCache(connectId?: string) {
-    Log.debug('clear device pool cache: connectId', connectId);
-    Log.debug('clear device pool cache: ', this.devicesCache);
+    // Log.debug('clear device pool cache: connectId', connectId);
+    // Log.debug('clear device pool cache: ', this.devicesCache);
     if (connectId) {
       delete this.devicesCache[connectId];
     }

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';

package/src/types/api/index.ts

@@ -104,6 +104,9 @@ import { filecoinSignTransaction } from './filecoinSignTransaction';
 import { polkadotGetAddress } from './polkadotGetAddress';
 import { polkadotSignTransaction } from './polkadotSignTransaction';
 
+import { kaspaGetAddress } from './kaspaGetAddress';
+import { kaspaSignTransaction } from './kaspaSignTransaction';
+
 export * from './export';
 
 export type CoreApi = {
@@ -277,4 +280,10 @@ export type CoreApi = {
    */
   polkadotGetAddress: typeof polkadotGetAddress;
   polkadotSignTransaction: typeof polkadotSignTransaction;
+
+  /**
+   * Kaspa function
+   */
+  kaspaGetAddress: typeof kaspaGetAddress;
+  kaspaSignTransaction: typeof kaspaSignTransaction;
 };

package/src/types/api/kaspaGetAddress.ts

@@ -0,0 +1,25 @@
+import { KaspaAddress as HardwareKaspaAddress } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type KaspaAddress = {
+  path: string;
+} & HardwareKaspaAddress;
+
+export type KaspaGetAddressParams = {
+  path: string | number[];
+  prefix?: string;
+  scheme?: string;
+  showOnOneKey?: boolean;
+};
+
+export declare function kaspaGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & KaspaGetAddressParams
+): Response<KaspaAddress>;
+
+export declare function kaspaGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: KaspaGetAddressParams[] }
+): Response<Array<KaspaAddress>>;

package/src/types/api/kaspaSignTransaction.ts

@@ -0,0 +1,43 @@
+import { SignatureType } from '../../api/kaspa/helpers/SignatureType';
+import type { CommonParams, Response } from '../params';
+
+export type KaspaSignature = {
+  index: number;
+  signature: string;
+};
+
+export type KaspaSignInputParams = {
+  path: string | number[];
+  prevTxId: string;
+  outputIndex: number;
+  sequenceNumber: number | string;
+  output: {
+    satoshis: number | string;
+    script: string;
+  };
+  sigOpCount?: number;
+};
+
+export type KaspaSignOutputParams = {
+  satoshis: number | string;
+  script: string;
+  scriptVersion: number;
+};
+
+export type KaspaSignTransactionParams = {
+  version: number;
+  inputs: KaspaSignInputParams[];
+  outputs: KaspaSignOutputParams[];
+  lockTime: number | string;
+  sigHashType?: SignatureType;
+  sigOpCount?: number;
+  subNetworkID?: string;
+  scheme?: string;
+  prefix?: string;
+};
+
+export declare function kaspaSignTransaction(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & KaspaSignTransactionParams
+): Response<KaspaSignature[]>;

package/src/types/api/suiGetAddress.ts

@@ -14,11 +14,11 @@ export type SuiGetAddressParams = {
 export declare function suiGetAddress(
   connectId: string,
   deviceId: string,
-  params: CommonParams & HardwareSuiAddress
+  params: CommonParams & SuiGetAddressParams
 ): Response<SuiAddress>;
 
 export declare function suiGetAddress(
   connectId: string,
   deviceId: string,
-  params: CommonParams & { bundle?: HardwareSuiAddress[] }
+  params: CommonParams & { bundle?: SuiGetAddressParams[] }
 ): Response<Array<SuiAddress>>;

package/src/types/settings.ts

@@ -64,6 +64,7 @@ export type IBLEFirmwareReleaseInfo = {
 export type DeviceTypeMap = {
   [k in IDeviceType]: {
     firmware: IFirmwareReleaseInfo[];
+    'firmware-v2'?: IFirmwareReleaseInfo[];
     'firmware-v3'?: IFirmwareReleaseInfo[];
     ble: IBLEFirmwareReleaseInfo[];
   };

package/src/utils/deviceFeaturesUtils.ts

@@ -180,6 +180,10 @@ export const getFirmwareUpdateField = (features: Features, updateType: 'firmware
     return 'ble';
   }
 
+  if (deviceType === 'classic') {
+    return 'firmware-v2';
+  }
+
   if (deviceType === 'touch') {
     if (semver.lt(deviceFirmwareVersion.join('.'), '3.4.0')) return 'firmware';
     return 'firmware-v3';