@onekeyfe/hd-core 0.2.50-alpha.1 → 0.2.51

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/core/index.ts

@@ -89,7 +89,6 @@ export const callAPI = async (message: CoreMessage) => {
       const response = await method.run();
       return createResponseMessage(method.responseID, true, response);
     } catch (error) {
-      console.log('!method.useDevice error =====>>> ', error);
       return createResponseMessage(method.responseID, false, { error });
     }
   }
@@ -337,6 +336,7 @@ export const callAPI = async (message: CoreMessage) => {
     cleanup();
 
     removeDeviceListener(device);
+    // TODO: 方法执行后，检查队列内是否有等待调用的 API，依次调用
   }
 };
 
@@ -580,7 +580,7 @@ const cleanup = () => {
 
 const removeDeviceListener = (device: Device) => {
   device.removeAllListeners();
-  DevicePool.emitter.removeAllListeners(DEVICE.CONNECT);
+  DevicePool.emitter.removeListener(DEVICE.CONNECT, onDeviceConnectHandler);
   // DevicePool.emitter.removeListener(DEVICE.DISCONNECT, onDeviceDisconnectHandler);
 };
 

package/src/data/messages/messages.json

@@ -4468,6 +4468,122 @@
         }
       }
     },
+    "KaspaGetAddress": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "show_display": {
+          "type": "bool",
+          "id": 2
+        },
+        "prefix": {
+          "type": "string",
+          "id": 3,
+          "options": {
+            "default": "kaspa"
+          }
+        },
+        "scheme": {
+          "type": "string",
+          "id": 4,
+          "options": {
+            "default": "schnorr"
+          }
+        }
+      }
+    },
+    "KaspaAddress": {
+      "fields": {
+        "address": {
+          "rule": "required",
+          "type": "string",
+          "id": 1
+        }
+      }
+    },
+    "KaspaSignTx": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "raw_message": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 2
+        },
+        "scheme": {
+          "type": "string",
+          "id": 3,
+          "options": {
+            "default": "schnorr"
+          }
+        },
+        "prefix": {
+          "type": "string",
+          "id": 4,
+          "options": {
+            "default": "kaspa"
+          }
+        },
+        "input_count": {
+          "type": "uint32",
+          "id": 5,
+          "options": {
+            "default": 1
+          }
+        }
+      }
+    },
+    "KaspaTxInputRequest": {
+      "fields": {
+        "request_index": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 1
+        },
+        "signature": {
+          "type": "bytes",
+          "id": 2
+        }
+      }
+    },
+    "KaspaTxInputAck": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "raw_message": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 2
+        }
+      }
+    },
+    "KaspaSignedTx": {
+      "fields": {
+        "signature": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 2
+        }
+      }
+    },
     "BackupType": {
       "values": {
         "Bip39": 0,
@@ -4743,6 +4859,10 @@
         "build_id": {
           "type": "string",
           "id": 518
+        },
+        "battery_level": {
+          "type": "uint32",
+          "id": 520
         }
       },
       "nested": {
@@ -8936,6 +9056,12 @@
         "MessageType_FilecoinAddress": 11201,
         "MessageType_FilecoinSignTx": 11202,
         "MessageType_FilecoinSignedTx": 11203,
+        "MessageType_KaspaGetAddress": 11300,
+        "MessageType_KaspaAddress": 11301,
+        "MessageType_KaspaSignTx": 11302,
+        "MessageType_KaspaSignedTx": 11303,
+        "MessageType_KaspaTxInputRequest": 11304,
+        "MessageType_KaspaTxInputAck": 11305,
         "MessageType_DeviceBackToBoot": 903,
         "MessageType_DeviceInfoSettings": 10001,
         "MessageType_GetDeviceInfo": 10002,

package/src/data-manager/DataManager.ts

@@ -123,7 +123,6 @@ export default class DataManager {
   static getBootloaderTargetVersion = (features: Features): IVersionArray | undefined => {
     const deviceType = getDeviceType(features);
 
-    if (deviceType !== 'pro' && deviceType !== 'touch') return undefined;
     const firmwareUpdateField = getFirmwareUpdateField(features, 'firmware') as FirmwareField;
     const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
     const targetDeviceConfig = targetDeviceConfigList.filter(item => !!item.bootloaderResource);
@@ -131,6 +130,19 @@ export default class DataManager {
     return targetDeviceConfig?.[0]?.bootloaderVersion ?? undefined;
   };
 
+  static getBootloaderRelatedFirmwareVersion = (features: Features): IVersionArray | undefined => {
+    const deviceType = getDeviceType(features);
+
+    if (deviceType !== 'classic') return undefined;
+    const firmwareUpdateField = getFirmwareUpdateField(features, 'firmware') as FirmwareField;
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
+    const targetDeviceConfig = targetDeviceConfigList.filter(
+      item => !!item.bootloaderRelatedFirmwareVersion
+    );
+
+    return targetDeviceConfig?.[0]?.bootloaderRelatedFirmwareVersion ?? undefined;
+  };
+
   static getFirmwareChangelog = (features: Features) => {
     const deviceType = getDeviceType(features);
     const deviceFirmwareVersion = getDeviceFirmwareVersion(features);

package/src/index.ts

@@ -1,11 +1,6 @@
 import { inject, InjectApi } from './inject';
-import { lowLevelInject, LowLevelInjectApi, LowLevelCoreApi } from './lowLevelInject';
-import { topLevelInject } from './topLevelInject';
 import { CoreApi } from './types/api';
 
-export type { LowLevelCoreApi, LowLevelInjectApi } from './lowLevelInject';
-export type { TopLevelInjectApi } from './topLevelInject';
-
 export { default as Core, init as initCore } from './core';
 
 export * from './constants';
@@ -31,27 +26,4 @@ const HardwareSdk = ({
     cancel,
   });
 
-const HardwareSDKLowLevel = ({
-  init,
-  call,
-  dispose,
-  eventEmitter,
-  addHardwareGlobalEventListener,
-  uiResponse,
-  cancel,
-}: LowLevelInjectApi): LowLevelCoreApi =>
-  lowLevelInject({
-    init,
-    call,
-    dispose,
-    eventEmitter,
-    addHardwareGlobalEventListener,
-    uiResponse,
-    cancel,
-  });
-
-const HardwareTopLevelSdk = (): CoreApi => topLevelInject();
-
-export { HardwareTopLevelSdk, HardwareSDKLowLevel };
-
 export default HardwareSdk;