@ckb-ccc/core 0.0.10-alpha.0 → 0.0.10-alpha.5

package/src/client/clientTypes.ts

@@ -23,7 +23,7 @@ export type ClientTransactionResponse = {
 
 export type ClientIndexerSearchKeyFilterLike =
   ClientCollectableSearchKeyFilterLike & {
-    blockRange?: [NumLike, NumLike];
+    blockRange?: [NumLike, NumLike] | null;
   };
 export class ClientIndexerSearchKeyFilter {
   constructor(
@@ -43,7 +43,7 @@ export class ClientIndexerSearchKeyFilter {
       apply(Script.from, filterLike.script),
       apply(clientSearchKeyRangeFrom, filterLike.scriptLenRange),
       apply(hexFrom, filterLike.outputData),
-      filterLike.outputDataSearchMode,
+      filterLike.outputDataSearchMode ?? undefined,
       apply(clientSearchKeyRangeFrom, filterLike.outputDataLenRange),
       apply(clientSearchKeyRangeFrom, filterLike.outputCapacityRange),
       apply(clientSearchKeyRangeFrom, filterLike.blockRange),
@@ -52,7 +52,7 @@ export class ClientIndexerSearchKeyFilter {
 }
 
 export type ClientIndexerSearchKeyLike = ClientCollectableSearchKeyLike & {
-  filter?: ClientIndexerSearchKeyFilterLike;
+  filter?: ClientIndexerSearchKeyFilterLike | null;
 };
 
 export class ClientIndexerSearchKey {
@@ -70,7 +70,7 @@ export class ClientIndexerSearchKey {
       keyLike.scriptType,
       keyLike.scriptSearchMode,
       apply(ClientIndexerSearchKeyFilter.from, keyLike.filter),
-      keyLike.withData,
+      keyLike.withData ?? undefined,
     );
   }
 }

package/src/signer/ckb/index.ts

@@ -1,3 +1,5 @@
 export * from "./signerCkbPrivateKey";
+export * from "./signerCkbPublicKey";
 export * from "./signerCkbScriptReadonly";
+export * from "./verifyCkbSecp256k1";
 export * from "./verifyJoyId";

package/src/signer/ckb/signerCkbPrivateKey.ts

@@ -1,57 +1,32 @@
 import { secp256k1 } from "@noble/curves/secp256k1";
-import { Address } from "../../address";
-import { Bytes, bytesConcat, bytesFrom, BytesLike } from "../../bytes";
+import { bytesConcat, bytesFrom, BytesLike } from "../../bytes";
 import { Transaction, TransactionLike, WitnessArgs } from "../../ckb";
-import { Client, KnownScript } from "../../client";
+import { Client } from "../../client";
 import { hashCkb } from "../../hasher";
 import { Hex, hexFrom, HexLike } from "../../hex";
 import { numBeToBytes } from "../../num";
-import { Signer, SignerSignType, SignerType } from "../signer";
+import { SignerCkbPublicKey } from "./signerCkbPublicKey";
 
-export class SignerCkbPrivateKey extends Signer {
-  get type(): SignerType {
-    return SignerType.CKB;
-  }
-
-  get signType(): SignerSignType {
-    return SignerSignType.CkbSecp256k1;
-  }
-
-  private readonly privateKey: Hex;
+export class SignerCkbPrivateKey extends SignerCkbPublicKey {
+  public readonly privateKey: Hex;
 
   constructor(client: Client, privateKey: HexLike) {
-    super(client);
-    this.privateKey = hexFrom(privateKey);
-
-    if (bytesFrom(this.privateKey).length !== 32) {
+    const pk = hexFrom(privateKey);
+    if (bytesFrom(pk).length !== 32) {
       throw new Error("Private key must be 32 bytes!");
     }
-  }
 
-  async connect(): Promise<void> {}
-
-  async isConnected(): Promise<boolean> {
-    return true;
-  }
-
-  async getInternalAddress(): Promise<string> {
-    return this.getRecommendedAddress();
-  }
-
-  async getAddressObjs(): Promise<Address[]> {
-    const publicKey = this.getPublicKey();
-    return [
-      await Address.fromKnownScript(
-        this.client,
-        KnownScript.Secp256k1Blake160,
-        bytesFrom(hashCkb(publicKey)).slice(0, 20),
-      ),
-    ];
+    super(client, secp256k1.getPublicKey(bytesFrom(pk), true));
+    this.privateKey = pk;
   }
 
   async signMessageRaw(message: string | BytesLike): Promise<Hex> {
+    const msg = typeof message === "string" ? message : hexFrom(message);
+    const buffer = bytesFrom(`Nervos Message:${msg}`, "utf8");
+    const hash = hashCkb(buffer);
+
     const signature = secp256k1.sign(
-      bytesFrom(message),
+      bytesFrom(hash),
       bytesFrom(this.privateKey),
     );
     const { r, s, recovery } = signature;
@@ -65,21 +40,6 @@ export class SignerCkbPrivateKey extends Signer {
     );
   }
 
-  getPublicKey(): Bytes {
-    return secp256k1.getPublicKey(bytesFrom(this.privateKey), true);
-  }
-
-  async prepareTransaction(txLike: TransactionLike): Promise<Transaction> {
-    const tx = Transaction.from(txLike);
-    const { script } = await this.getRecommendedAddressObj();
-    await tx.addCellDepsOfKnownScripts(
-      this.client,
-      KnownScript.Secp256k1Blake160,
-    );
-    await tx.prepareSighashAllWitness(script, 65, this.client);
-    return tx;
-  }
-
   async signOnlyTransaction(txLike: TransactionLike): Promise<Transaction> {
     const tx = Transaction.from(txLike);
     const { script } = await this.getRecommendedAddressObj();

package/src/signer/ckb/signerCkbPublicKey.ts

@@ -0,0 +1,63 @@
+import { Address } from "../../address";
+import { bytesFrom } from "../../bytes";
+import { Transaction, TransactionLike } from "../../ckb";
+import { Client, KnownScript } from "../../client";
+import { hashCkb } from "../../hasher";
+import { Hex, HexLike, hexFrom } from "../../hex";
+import { Signer, SignerSignType, SignerType } from "../signer";
+
+export class SignerCkbPublicKey extends Signer {
+  get type(): SignerType {
+    return SignerType.CKB;
+  }
+
+  get signType(): SignerSignType {
+    return SignerSignType.CkbSecp256k1;
+  }
+
+  public readonly publicKey: Hex;
+
+  constructor(client: Client, publicKey: HexLike) {
+    super(client);
+    this.publicKey = hexFrom(publicKey);
+
+    if (bytesFrom(this.publicKey).length !== 33) {
+      throw new Error("Public key must be 33 bytes!");
+    }
+  }
+
+  async connect(): Promise<void> {}
+
+  async isConnected(): Promise<boolean> {
+    return true;
+  }
+
+  async getInternalAddress(): Promise<string> {
+    return this.getRecommendedAddress();
+  }
+
+  async getIdentity(): Promise<string> {
+    return this.publicKey;
+  }
+
+  async getAddressObjs(): Promise<Address[]> {
+    return [
+      await Address.fromKnownScript(
+        this.client,
+        KnownScript.Secp256k1Blake160,
+        bytesFrom(hashCkb(this.publicKey)).slice(0, 20),
+      ),
+    ];
+  }
+
+  async prepareTransaction(txLike: TransactionLike): Promise<Transaction> {
+    const tx = Transaction.from(txLike);
+    const { script } = await this.getRecommendedAddressObj();
+    await tx.addCellDepsOfKnownScripts(
+      this.client,
+      KnownScript.Secp256k1Blake160,
+    );
+    await tx.prepareSighashAllWitness(script, 65, this.client);
+    return tx;
+  }
+}

package/src/signer/ckb/verifyCkbSecp256k1.ts

@@ -0,0 +1,27 @@
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { BytesLike, bytesFrom } from "../../bytes";
+import { hashCkb } from "../../hasher";
+import { Hex, hexFrom } from "../../hex";
+import { numFrom } from "../../num";
+
+export function messageHashCkbSecp256k1(message: string | BytesLike): Hex {
+  const msg = typeof message === "string" ? message : hexFrom(message);
+  const buffer = bytesFrom(`Nervos Message:${msg}`, "utf8");
+  return hashCkb(buffer);
+}
+
+export function verifyMessageCkbSecp256k1(
+  message: string | BytesLike,
+  signature: string,
+  publicKey: string,
+): boolean {
+  const signatureBytes = bytesFrom(signature);
+  return secp256k1.verify(
+    new secp256k1.Signature(
+      numFrom(signatureBytes.slice(0, 32)),
+      numFrom(signatureBytes.slice(32, 64)),
+    ).addRecoveryBit(Number(numFrom(signatureBytes.slice(64, 65)))),
+    bytesFrom(messageHashCkbSecp256k1(message)),
+    bytesFrom(publicKey),
+  );
+}

package/src/signer/signer/index.ts

@@ -5,6 +5,7 @@ import { Client } from "../../client";
 import { Hex } from "../../hex";
 import { Num } from "../../num";
 import { verifyMessageBtcEcdsa } from "../btc";
+import { verifyMessageCkbSecp256k1 } from "../ckb/verifyCkbSecp256k1";
 import { verifyMessageJoyId } from "../ckb/verifyJoyId";
 import { verifyMessageEvmPersonal } from "../evm/verify";
 import { verifyMessageNostrEvent } from "../nostr/verify";
@@ -118,6 +119,11 @@ export abstract class Signer {
           signature.identity,
         );
       case SignerSignType.CkbSecp256k1:
+        return verifyMessageCkbSecp256k1(
+          message,
+          signature.signature,
+          signature.identity,
+        );
       case SignerSignType.Unknown:
         throw new Error("Unknown signer sign type");
     }

package/src/utils/index.ts

@@ -3,7 +3,7 @@
  *
  * @param transformer - The transformer.
  * @param value - The value to be transformed.
- * @returns If the value is empty, it remains its type. Otherwise it will be transformed.
+ * @returns If the value is empty, it becomes undefined. Otherwise it will be transformed.
  */
 export function apply<T, R>(
   transformer: (val: T) => R,
@@ -14,15 +14,15 @@ export function apply<T, R>(
  *
  * @param transformer - The transformer.
  * @param value - The value to be transformed.
- * @returns If the value is empty, it remains its type. Otherwise it will be transformed.
+ * @returns If the value is empty, it becomes undefined. Otherwise it will be transformed.
  */
-export function apply<T, R>(transformer: (val: T) => R, value: null): null;
+export function apply<T, R>(transformer: (val: T) => R, value: null): undefined;
 /**
  * A type safe way to apply a transformer on a value if it's not empty.
  *
  * @param transformer - The transformer.
  * @param value - The value to be transformed.
- * @returns If the value is empty, it remains its type. Otherwise it will be transformed.
+ * @returns If the value is empty, it becomes undefined. Otherwise it will be transformed.
  */
 export function apply<T, R>(transformer: (val: T) => R, value: T): R;
 /**
@@ -30,7 +30,7 @@ export function apply<T, R>(transformer: (val: T) => R, value: T): R;
  *
  * @param transformer - The transformer.
  * @param value - The value to be transformed.
- * @returns If the value is empty, it remains its type. Otherwise it will be transformed.
+ * @returns If the value is empty, it becomes undefined. Otherwise it will be transformed.
  */
 export function apply<T, R>(
   transformer: (val: T) => R,
@@ -41,36 +41,48 @@ export function apply<T, R>(
  *
  * @param transformer - The transformer.
  * @param value - The value to be transformed.
- * @returns If the value is empty, it remains its type. Otherwise it will be transformed.
+ * @returns If the value is empty, it becomes undefined. Otherwise it will be transformed.
  */
 export function apply<T, R>(
   transformer: (val: T) => R,
   value: T | null,
-): R | null;
+): R | undefined;
 /**
  * A type safe way to apply a transformer on a value if it's not empty.
  *
  * @param transformer - The transformer.
  * @param value - The value to be transformed.
- * @returns If the value is empty, it remains its type. Otherwise it will be transformed.
+ * @returns If the value is empty, it becomes undefined. Otherwise it will be transformed.
  */
 export function apply<T, R>(
   transformer: (val: T) => R,
   value: undefined | null,
-): undefined | null;
+): undefined;
+/**
+/**
+ * A type safe way to apply a transformer on a value if it's not empty.
+ *
+ * @param transformer - The transformer.
+ * @param value - The value to be transformed.
+ * @returns If the value is empty, it becomes undefined. Otherwise it will be transformed.
+ */
+export function apply<T, R>(
+  transformer: (val: T) => R,
+  value: T | undefined | null,
+): R | undefined;
 /**
  * A type safe way to apply a transformer on a value if it's not empty.
  *
  * @param transformer - The transformer.
  * @param value - The value to be transformed.
- * @returns If the value is empty, it remains its type. Otherwise it will be transformed.
+ * @returns If the value is empty, it becomes undefined. Otherwise it will be transformed.
  */
 export function apply<T, R>(
   transformer: (val: T) => R,
   value: T | undefined | null,
-): R | undefined | null {
+): R | undefined {
   if (value == null) {
-    return value as undefined | null;
+    return undefined;
   }
 
   return transformer(value);