@ckb-ccc/core 1.13.0 → 1.15.0

package/src/num/index.ts

@@ -1,4 +1,5 @@
 import { Bytes, BytesLike, bytesConcat, bytesFrom } from "../bytes/index.js";
+import { Zero } from "../fixedPoint/index.js";
 import { Hex, HexLike, hexFrom } from "../hex/index.js";
 
 /**
@@ -90,19 +91,31 @@ export function numFrom(val: NumLike): Num {
 }
 
 /**
- * Converts a NumLike value to a hexadecimal string.
+ * Converts a {@link NumLike} value into its hexadecimal string representation, prefixed with `0x`.
+ *
+ * @remarks
+ * This function returns the direct hexadecimal representation of the number, which may have an odd number of digits.
+ * For a full-byte representation (an even number of hex digits), consider using {@link numToBytes}, {@link numLeToBytes}, or {@link numBeToBytes} and then converting the resulting byte array to a hex string.
+ *
  * @public
  *
  * @param val - The value to convert, which can be a string, number, bigint, or HexLike.
- * @returns A Hex string representing the numeric value.
+ * @returns A Hex string representing the number.
+ *
+ * @throws {Error} If the normalized numeric value is negative.
  *
  * @example
  * ```typescript
- * const hex = numToHex(12345); // Outputs "0x3039"
+ * const hex = numToHex(4660); // "0x1234"
+ * const oddLengthHex = numToHex(10); // "0xa"
  * ```
  */
 export function numToHex(val: NumLike): Hex {
-  return `0x${numFrom(val).toString(16)}`;
+  const v = numFrom(val);
+  if (v < Zero) {
+    throw new Error("value must be non-negative");
+  }
+  return `0x${v.toString(16)}`;
 }
 
 /**

package/src/signer/ckb/index.ts

@@ -1,5 +1,7 @@
+export * from "./secp256k1Signing.js";
 export * from "./signerCkbPrivateKey.js";
 export * from "./signerCkbPublicKey.js";
 export * from "./signerCkbScriptReadonly.js";
-export * from "./verifyCkbSecp256k1.js";
+export * from "./signerMultisigCkbPrivateKey.js";
+export * from "./signerMultisigCkbReadonly.js";
 export * from "./verifyJoyId.js";

package/src/signer/ckb/secp256k1Signing.ts

@@ -0,0 +1,94 @@
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { bytesConcat, bytesFrom, BytesLike } from "../../bytes/index.js";
+import { hashCkb } from "../../hasher/index.js";
+import { Hex, hexFrom } from "../../hex/index.js";
+
+export const SECP256K1_SIGNATURE_LENGTH = 65;
+
+/**
+ * Sign a message using Secp256k1.
+ *
+ * @param message - The message to sign.
+ * @param privateKey - The private key.
+ * @returns The signature.
+ * @public
+ */
+export function signMessageSecp256k1(
+  message: BytesLike,
+  privateKey: BytesLike,
+): Hex {
+  const signature = secp256k1.sign(bytesFrom(message), bytesFrom(privateKey), {
+    format: "recovered",
+    prehash: false,
+  });
+  return hexFrom(bytesConcat(signature.slice(1), signature.slice(0, 1)));
+}
+
+/**
+ * Verify a message using Secp256k1.
+ *
+ * @param message - The message to verify.
+ * @param signature - The signature.
+ * @param publicKey - The public key.
+ * @returns True if the signature is valid, false otherwise.
+ * @public
+ */
+export function verifyMessageSecp256k1(
+  message: BytesLike,
+  signature: BytesLike,
+  publicKey: BytesLike,
+): boolean {
+  const signatureBytes = bytesFrom(signature);
+  return secp256k1.verify(
+    bytesConcat(signatureBytes.slice(64), signatureBytes.slice(0, 64)),
+    bytesFrom(message),
+    bytesFrom(publicKey),
+    { format: "recovered", prehash: false },
+  );
+}
+
+/**
+ * Recover the public key from a Secp256k1 signature.
+ *
+ * @param message - The message.
+ * @param signature - The signature.
+ * @returns The recovered public key.
+ * @public
+ */
+export function recoverMessageSecp256k1(
+  message: BytesLike,
+  signature: BytesLike,
+): Hex {
+  const signatureBytes = bytesFrom(signature);
+  return hexFrom(
+    secp256k1.recoverPublicKey(
+      bytesConcat(signatureBytes.slice(64), signatureBytes.slice(0, 64)),
+      bytesFrom(message),
+      { prehash: false },
+    ),
+  );
+}
+
+/**
+ * @public
+ */
+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);
+}
+
+/**
+ * @public
+ */
+export function verifyMessageCkbSecp256k1(
+  message: string | BytesLike,
+  signature: string,
+  publicKey: string,
+): boolean {
+  return verifyMessageSecp256k1(
+    messageHashCkbSecp256k1(message),
+    signature,
+    publicKey,
+  );
+}

package/src/signer/ckb/signerCkbPrivateKey.ts

@@ -1,10 +1,13 @@
 import { secp256k1 } from "@noble/curves/secp256k1.js";
-import { bytesConcat, bytesFrom, BytesLike } from "../../bytes/index.js";
+import { bytesFrom, BytesLike } from "../../bytes/index.js";
 import { Transaction, TransactionLike, WitnessArgs } from "../../ckb/index.js";
 import { Client } from "../../client/index.js";
 import { Hex, hexFrom, HexLike } from "../../hex/index.js";
+import {
+  messageHashCkbSecp256k1,
+  signMessageSecp256k1,
+} from "./secp256k1Signing.js";
 import { SignerCkbPublicKey } from "./signerCkbPublicKey.js";
-import { messageHashCkbSecp256k1 } from "./verifyCkbSecp256k1.js";
 
 /**
  * @public
@@ -23,15 +26,7 @@ export class SignerCkbPrivateKey extends SignerCkbPublicKey {
   }
 
   async _signMessage(message: HexLike): Promise<Hex> {
-    const signature = secp256k1.sign(
-      bytesFrom(message),
-      bytesFrom(this.privateKey),
-      {
-        format: "recovered",
-        prehash: false,
-      },
-    );
-    return hexFrom(bytesConcat(signature.slice(1), signature.slice(0, 1)));
+    return signMessageSecp256k1(message, this.privateKey);
   }
 
   async signMessageRaw(message: string | BytesLike): Promise<Hex> {

package/src/signer/ckb/signerCkbPublicKey.ts

@@ -2,9 +2,10 @@ import { Address } from "../../address/index.js";
 import { bytesFrom } from "../../bytes/index.js";
 import { Script, Transaction, TransactionLike } from "../../ckb/index.js";
 import { CellDepInfo, Client, KnownScript } from "../../client/index.js";
-import { hashCkb } from "../../hasher/index.js";
+import { hashCkbShort } from "../../hasher/index.js";
 import { Hex, HexLike, hexFrom } from "../../hex/index.js";
 import { Signer, SignerSignType, SignerType } from "../signer/index.js";
+import { SECP256K1_SIGNATURE_LENGTH } from "./secp256k1Signing.js";
 
 /**
  * @public
@@ -47,7 +48,7 @@ export class SignerCkbPublicKey extends Signer {
     return Address.fromKnownScript(
       this.client,
       KnownScript.Secp256k1Blake160,
-      bytesFrom(hashCkb(this.publicKey)).slice(0, 20),
+      hashCkbShort(this.publicKey),
     );
   }
 
@@ -140,7 +141,11 @@ export class SignerCkbPublicKey extends Signer {
 
     await Promise.all(
       (await this.getRelatedScripts(tx)).map(async ({ script, cellDeps }) => {
-        await tx.prepareSighashAllWitness(script, 65, this.client);
+        await tx.prepareSighashAllWitness(
+          script,
+          SECP256K1_SIGNATURE_LENGTH,
+          this.client,
+        );
         await tx.addCellDepInfos(this.client, cellDeps);
       }),
     );

package/src/signer/ckb/signerMultisigCkbPrivateKey.ts

@@ -0,0 +1,129 @@
+import { SinceLike, Transaction, TransactionLike } from "../../ckb/index.js";
+import { Client, KnownScript, ScriptInfoLike } from "../../client/index.js";
+import { hashCkbShort } from "../../hasher/index.js";
+import { Hex, hexFrom, HexLike } from "../../hex/index.js";
+import { signMessageSecp256k1 } from "./secp256k1Signing.js";
+import { SignerCkbPrivateKey } from "./signerCkbPrivateKey.js";
+import {
+  MultisigCkbWitnessLike,
+  SignerMultisigCkbReadonly,
+} from "./signerMultisigCkbReadonly.js";
+
+/**
+ * A class extending Signer that provides access to a CKB multisig script and supports signing operations.
+ * @public
+ */
+export class SignerMultisigCkbPrivateKey extends SignerMultisigCkbReadonly {
+  private readonly privateKey: Hex;
+  private readonly signer: SignerCkbPrivateKey;
+
+  /**
+   * Creates an instance of SignerMultisigCkbPrivateKey.
+   *
+   * @param client - The client instance.
+   * @param privateKey - The private key.
+   * @param multisigInfo - The multisig information.
+   * @param options - The options.
+   */
+  constructor(
+    client: Client,
+    privateKey: HexLike,
+    multisigInfo: MultisigCkbWitnessLike,
+    options?: {
+      since?: SinceLike | null;
+      scriptInfos?: (KnownScript | ScriptInfoLike)[] | null;
+    } | null,
+  ) {
+    super(client, multisigInfo, options);
+
+    this.privateKey = hexFrom(privateKey);
+    this.signer = new SignerCkbPrivateKey(client, this.privateKey);
+  }
+
+  /**
+   * Sign a transaction only (without preparing).
+   *
+   * @param txLike - The transaction to sign.
+   * @returns The signed transaction.
+   */
+  async signOnlyTransaction(txLike: TransactionLike): Promise<Transaction> {
+    let tx = Transaction.from(txLike);
+
+    const thisPubkeyHash = hashCkbShort(this.signer.publicKey);
+
+    const index = this.multisigInfo.publicKeyHashes.indexOf(thisPubkeyHash);
+    if (index === -1) {
+      return tx;
+    }
+    const isSelfRequired = index < this.multisigInfo.mustMatch;
+
+    for (const { script } of await this.scriptInfos) {
+      const info = await this.getSignInfo(tx, script);
+      if (!info) {
+        continue;
+      }
+
+      // === Find a position for the signature ===
+      tx = await this.prepareWitnessArgsAt(
+        tx,
+        info.position,
+        async (witness) => {
+          // We re-evaluate the signatures to filter invalid / excessive signatures
+          const signatures: Hex[] = [];
+          let requiredCount = 0;
+          let isSignNeeded = true;
+
+          for (const {
+            pubkeyHash,
+            signature,
+            isRequired,
+          } of witness.generatePublicKeyHashesFromSignatures(info.message)) {
+            if (pubkeyHash === thisPubkeyHash) {
+              if (!isSignNeeded) {
+                // Has signed and added to the signatures list already. We will not add it again.
+                continue;
+              }
+              isSignNeeded = false;
+            }
+
+            if (isRequired) {
+              requiredCount += 1;
+            } else if (
+              signatures.length - requiredCount >=
+              this.multisigInfo.flexibleThreshold
+            ) {
+              // Too many flexible signatures
+              continue;
+            }
+
+            signatures.push(signature);
+            if (signatures.length >= this.multisigInfo.threshold) {
+              // We have got enough signatures
+              isSignNeeded = false;
+              break;
+            }
+          }
+
+          if (
+            isSignNeeded &&
+            (isSelfRequired ||
+              signatures.length - requiredCount <
+                this.multisigInfo.flexibleThreshold)
+          ) {
+            // Add the signature from this signer only when
+            // 1. The signature is needed
+            // 2. It's required or...
+            // 3. We haven't got enough flexible signatures
+            signatures.push(
+              signMessageSecp256k1(info.message, this.privateKey),
+            );
+          }
+          witness.signatures = signatures;
+          return witness;
+        },
+      );
+    }
+
+    return tx;
+  }
+}