From 03ba2c5d60f067c21b37c659dac68648ea0f3161 Mon Sep 17 00:00:00 2001
From: ashuralyk <ashuralyk@live.com>
Date: Thu, 3 Jul 2025 18:14:45 +0800
Subject: [PATCH 1/9] feat: add SignerCkbMultisig module and dependent features

---
 packages/core/src/ckb/script.ts               | 105 ++++++++-
 packages/core/src/ckb/transaction.ts          |  36 ++-
 packages/core/src/client/client.ts            |   4 +
 .../core/src/client/clientPublicMainnet.ts    |  16 ++
 .../core/src/client/clientPublicTestnet.ts    |  16 ++
 packages/core/src/hex/index.ts                |  18 +-
 packages/core/src/signer/ckb/index.ts         |   1 +
 .../core/src/signer/ckb/signerCkbMultisig.ts  | 223 ++++++++++++++++++
 packages/examples/src/transferToMultisig.ts   |   0
 9 files changed, 414 insertions(+), 5 deletions(-)
 create mode 100644 packages/core/src/signer/ckb/signerCkbMultisig.ts
 create mode 100644 packages/examples/src/transferToMultisig.ts

diff --git a/packages/core/src/ckb/script.ts b/packages/core/src/ckb/script.ts
index 1de3c7ac0..9dd6f8d90 100644
--- a/packages/core/src/ckb/script.ts
+++ b/packages/core/src/ckb/script.ts
@@ -1,7 +1,8 @@
+import { Since, SinceLike, hashCkb } from "../barrel.js";
 import { Bytes, BytesLike, bytesFrom } from "../bytes/index.js";
 import type { Client } from "../client/index.js";
 import { KnownScript } from "../client/knownScript.js";
-import { Hex, HexLike, hexFrom } from "../hex/index.js";
+import { Hex, HexLike, hexConcat, hexFrom } from "../hex/index.js";
 import { mol } from "../molecule/index.js";
 import {
   HASH_TYPES,
@@ -97,6 +98,57 @@ export function hashTypeFromBytes(bytes: BytesLike): HashType {
   return NUM_TO_HASH_TYPE[bytesFrom(bytes)[0]];
 }
 
+/**
+ * Generate the metadata and script args of a multisig script.
+ * @public
+ *
+ * @param pubkeys - The public keys engaged in the multisig script.
+ * @param threshold - The threshold of the signatures.
+ * @param mustMatch - The first nth must match of the public keys.
+ * @returns The serialized multisig information, known as metadata.
+ *
+ * @example
+ * ```typescript
+ * const { metadata, scriptArgs } = multisigMetadataFromPubkeys({
+ *   pubkeys: ["0x1234...", "0x5678...", "0x90ab...", "0xabcd..."],
+ *   threshold: 2,
+ *   mustMatch: 1,
+ * });
+ * ```
+ */
+
+export function multisigMetadataFromPubkeys(
+  pubkeys: HexLike[],
+  threshold: number,
+  mustMatch: number,
+): Hex {
+  if (threshold < 0 || threshold > 255) {
+    throw new Error("`threshold` must be positive and less than 256!");
+  }
+  if (mustMatch < 0 || mustMatch > 255) {
+    throw new Error("`mustMatch` must be positive and less than 256!");
+  }
+  if (
+    pubkeys.length < mustMatch ||
+    pubkeys.length < threshold ||
+    pubkeys.length > 255
+  ) {
+    throw new Error(
+      "length of `pubkeys` must be greater than or equal to `mustMatch` and `threshold` and less than 256!",
+    );
+  }
+  const pubkeyBlake160Hashes = pubkeys.map((pubkey) =>
+    hashCkb(hexFrom(pubkey)).slice(0, 20),
+  );
+  return hexConcat(
+    "0x00",
+    hexFrom(("00" + mustMatch.toString(16)).slice(-2)),
+    hexFrom(("00" + threshold.toString(16)).slice(-2)),
+    hexFrom(("00" + pubkeyBlake160Hashes.length.toString(16)).slice(-2)),
+    ...pubkeyBlake160Hashes.map((h) => h.slice(2)),
+  );
+}
+
 /**
  * @public
  */
@@ -225,10 +277,57 @@ export class Script extends mol.Entity.Base<ScriptLike, Script>() {
   }
 
   /**
-   * Converts the Script instance to molecule data format.
+   * Creates a Script instance from known multisig script.
+   *
+   * @param client - A Client instance.
+   * @param metadata - The metadata of the multisig script.
+   * @param since - The since of the multisig script.
+   * @param multisigScript - A KnownScript enum.
+   * @returns A promise that resolves to the script instance.
    *
-   * @returns An object representing the script in molecule data format.
+   * @example
+   * ```typescript
+   * const metadata = multisigMetadataFromPubkeys(
+   *   ["0x1234...", "0x5678...", "0x90ab..."],
+   *   2,
+   *   1,
+   * );
+   * const script = await Script.fromKnownMultisigScript(
+   *   client,
+   *   metadata,
+   *   {
+   *     relative: "absolute",
+   *     metric: "blockNumber",
+   *     value: 1000,
+   *   }
+   * );
+   * ```
    */
+
+  static async fromKnownMultisigScript(
+    client: Client,
+    metadata: HexLike,
+    since?: SinceLike,
+    multisigScript:
+      | KnownScript.Secp256k1Multisig
+      | KnownScript.Secp256k1MultisigV2 = KnownScript.Secp256k1MultisigV2,
+  ): Promise<Script> {
+    if (multisigScript === KnownScript.Secp256k1Multisig) {
+      console.warn(
+        "Secp256k1Multisig has detected bugs and marked as **Deprecated**. Please use Secp256k1MultisigV2 instead.",
+      );
+    }
+    const args = (() => {
+      const metadataHash = hashCkb(metadata);
+      if (since) {
+        const sinceBytes = Since.from(since).toBytes();
+        return hexConcat(metadataHash, hexFrom(sinceBytes));
+      } else {
+        return metadataHash;
+      }
+    })();
+    return await Script.fromKnownScript(client, multisigScript, args);
+  }
 }
 
 export const ScriptOpt = mol.option(Script);
diff --git a/packages/core/src/ckb/transaction.ts b/packages/core/src/ckb/transaction.ts
index df0e84c34..0b86807fe 100644
--- a/packages/core/src/ckb/transaction.ts
+++ b/packages/core/src/ckb/transaction.ts
@@ -9,7 +9,7 @@ import {
 import { KnownScript } from "../client/knownScript.js";
 import { Zero, fixedPointFrom } from "../fixedPoint/index.js";
 import { Hasher, HasherCkb, hashCkb } from "../hasher/index.js";
-import { Hex, HexLike, hexFrom } from "../hex/index.js";
+import { Hex, HexLike, hexConcat, hexFrom } from "../hex/index.js";
 import { mol } from "../molecule/index.js";
 import {
   Num,
@@ -1879,6 +1879,40 @@ export class Transaction extends mol.Entity.Base<
     this.setWitnessArgsAt(position, witness);
   }
 
+  /**
+   * Prepare multisig witness
+   *
+   * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
+   * @param multisigMetadata - The metadata of the multisig script.
+   * @param threshold - The threshold of the multisig script.
+   * @param client - The client for complete extra infos in the transaction.
+   * @returns A promise that resolves to the prepared transaction
+   *
+   * @example
+   * ```typescript
+   * await tx.prepareMultisigWitness(script, multisigMetadata, threshold, client);
+   * ```
+   */
+  async prepareMultisigWitness(
+    scriptLike: ScriptLike,
+    multisigMetadata: HexLike,
+    threshold: number,
+    client: Client,
+  ): Promise<void> {
+    const position = await this.findInputIndexByLock(scriptLike, client);
+    if (position === undefined) {
+      return;
+    }
+
+    const emptySignature = hexFrom(Array.from(new Array(65), () => 0));
+    const witness = this.getWitnessArgsAt(position) ?? WitnessArgs.from({});
+    witness.lock = hexConcat(
+      multisigMetadata,
+      ...Array.from(new Array(threshold), () => emptySignature),
+    );
+    this.setWitnessArgsAt(position, witness);
+  }
+
   async getInputsCapacityExtra(client: Client): Promise<Num> {
     return reduceAsync(
       this.inputs,
diff --git a/packages/core/src/client/client.ts b/packages/core/src/client/client.ts
index 87de6a687..48e6f0f42 100644
--- a/packages/core/src/client/client.ts
+++ b/packages/core/src/client/client.ts
@@ -52,6 +52,10 @@ export abstract class Client {
 
   abstract getKnownScript(script: KnownScript): Promise<ScriptInfo>;
 
+  abstract findKnownScript(
+    scriptLike: ScriptLike,
+  ): Promise<ScriptInfo | undefined>;
+
   abstract getFeeRateStatistics(
     blockRange?: NumLike,
   ): Promise<{ mean?: Num; median?: Num }>;
diff --git a/packages/core/src/client/clientPublicMainnet.ts b/packages/core/src/client/clientPublicMainnet.ts
index 27a3271e8..3d9e06e18 100644
--- a/packages/core/src/client/clientPublicMainnet.ts
+++ b/packages/core/src/client/clientPublicMainnet.ts
@@ -1,4 +1,5 @@
 import WebSocket from "isomorphic-ws";
+import { Script, ScriptLike } from "../index.js";
 import { MAINNET_SCRIPTS } from "./clientPublicMainnet.advanced.js";
 import { ScriptInfo, ScriptInfoLike } from "./clientTypes.js";
 import { ClientJsonRpc, ClientJsonRpcConfig } from "./jsonRpc/index.js";
@@ -52,4 +53,19 @@ export class ClientPublicMainnet extends ClientJsonRpc {
     }
     return ScriptInfo.from(found);
   }
+
+  async findKnownScript(
+    scriptLike: ScriptLike,
+  ): Promise<ScriptInfo | undefined> {
+    const script = Script.from(scriptLike);
+    const scriptInfo = Object.values(this.scripts).find((scriptInfo) => {
+      if (
+        scriptInfo?.codeHash === script.codeHash &&
+        scriptInfo.hashType === script.hashType
+      ) {
+        return scriptInfo;
+      }
+    });
+    return scriptInfo ? ScriptInfo.from(scriptInfo) : undefined;
+  }
 }
diff --git a/packages/core/src/client/clientPublicTestnet.ts b/packages/core/src/client/clientPublicTestnet.ts
index 3e3aed174..717633f82 100644
--- a/packages/core/src/client/clientPublicTestnet.ts
+++ b/packages/core/src/client/clientPublicTestnet.ts
@@ -1,4 +1,5 @@
 import WebSocket from "isomorphic-ws";
+import { Script, ScriptLike } from "../index.js";
 import { TESTNET_SCRIPTS } from "./clientPublicTestnet.advanced.js";
 import { ScriptInfo, ScriptInfoLike } from "./clientTypes.js";
 import { ClientJsonRpc, ClientJsonRpcConfig } from "./jsonRpc/index.js";
@@ -52,4 +53,19 @@ export class ClientPublicTestnet extends ClientJsonRpc {
     }
     return ScriptInfo.from(found);
   }
+
+  async findKnownScript(
+    scriptLike: ScriptLike,
+  ): Promise<ScriptInfo | undefined> {
+    const script = Script.from(scriptLike);
+    const scriptInfo = Object.values(this.scripts).find((scriptInfo) => {
+      if (
+        scriptInfo?.codeHash === script.codeHash &&
+        scriptInfo.hashType === script.hashType
+      ) {
+        return scriptInfo;
+      }
+    });
+    return scriptInfo ? ScriptInfo.from(scriptInfo) : undefined;
+  }
 }
diff --git a/packages/core/src/hex/index.ts b/packages/core/src/hex/index.ts
index 41df43d76..ef4dc93e2 100644
--- a/packages/core/src/hex/index.ts
+++ b/packages/core/src/hex/index.ts
@@ -1,4 +1,4 @@
-import { bytesFrom, BytesLike, bytesTo } from "../bytes/index.js";
+import { bytesConcat, bytesFrom, BytesLike, bytesTo } from "../bytes/index.js";
 
 /**
  * Represents a hexadecimal string prefixed with "0x".
@@ -28,3 +28,19 @@ export type HexLike = BytesLike;
 export function hexFrom(hex: HexLike): Hex {
   return `0x${bytesTo(bytesFrom(hex), "hex")}`;
 }
+
+/**
+ * Concatenates multiple HexLike values into a single Hex string.
+ * @public
+ *
+ * @param hexLikes - The HexLike values to concatenate.
+ * @returns A Hex string representing the concatenated values.
+ *
+ * @example
+ * ```typescript
+ * const hexString = hexConcat("0x68656c6c6f", "0x776f726c64"); // Outputs "0x68656c6c6f776f726c64"
+ * ```
+ */
+export function hexConcat(...hexLikes: HexLike[]): Hex {
+  return hexFrom(bytesConcat(...hexLikes));
+}
diff --git a/packages/core/src/signer/ckb/index.ts b/packages/core/src/signer/ckb/index.ts
index 61cec4a3a..d8f431f12 100644
--- a/packages/core/src/signer/ckb/index.ts
+++ b/packages/core/src/signer/ckb/index.ts
@@ -1,3 +1,4 @@
+export * from "./signerCkbMultisig.js";
 export * from "./signerCkbPrivateKey.js";
 export * from "./signerCkbPublicKey.js";
 export * from "./signerCkbScriptReadonly.js";
diff --git a/packages/core/src/signer/ckb/signerCkbMultisig.ts b/packages/core/src/signer/ckb/signerCkbMultisig.ts
new file mode 100644
index 000000000..acc293ee2
--- /dev/null
+++ b/packages/core/src/signer/ckb/signerCkbMultisig.ts
@@ -0,0 +1,223 @@
+import { Address } from "../../address/index.js";
+import {
+  multisigMetadataFromPubkeys,
+  SignerCkbPrivateKey,
+  SinceLike,
+  Transaction,
+  TransactionLike,
+} from "../../barrel.js";
+import { Script } from "../../ckb/index.js";
+import { CellDepInfo, Client, KnownScript } from "../../client/index.js";
+import { Hex, hexConcat, hexFrom, HexLike } from "../../hex/index.js";
+
+export interface MultisigInfo {
+  pubkeys: HexLike[];
+  threshold: number;
+  mustMatch: number;
+  since?: SinceLike;
+  multisigScript?:
+    | KnownScript.Secp256k1Multisig
+    | KnownScript.Secp256k1MultisigV2;
+}
+
+/**
+ * A class extending Signer that provides access to a CKB multisig script.
+ * This class supports signing operations.
+ * @public
+ */
+export class SignerCkbMultisig extends SignerCkbPrivateKey {
+  public readonly multisig: MultisigInfo;
+
+  /**
+   * Creates an instance of SignerCkbMultisig.
+   *
+   * @param client - The client instance used for communication.
+   * @param privateKey - The private key associated with the signer.
+   * @param multisig - The multisig information assembled from pubkeys, threshold, mustMatch and since.
+   */
+  constructor(client: Client, privateKey: HexLike, multisig: MultisigInfo) {
+    super(client, privateKey);
+
+    this.multisig = multisig;
+  }
+
+  async getAddressObjSecp256k1(): Promise<Address> {
+    const multisigScript = await Script.fromKnownMultisigScript(
+      this.client,
+      this.getMultisigMetadata(),
+      this.multisig.since,
+      this.multisig.multisigScript,
+    );
+    return Address.fromScript(multisigScript, this.client);
+  }
+
+  getMultisigInfo(): MultisigInfo {
+    return this.multisig;
+  }
+
+  getMultisigMetadata(): Hex {
+    return multisigMetadataFromPubkeys(
+      this.multisig.pubkeys,
+      this.multisig.threshold,
+      this.multisig.mustMatch,
+    );
+  }
+
+  async getAddressObjs(): Promise<Address[]> {
+    const secp256k1 = await this.getAddressObjSecp256k1();
+    return [secp256k1];
+  }
+
+  async getRelatedScripts(
+    txLike: TransactionLike,
+  ): Promise<{ script: Script; cellDeps: CellDepInfo[] }[]> {
+    const tx = Transaction.from(txLike);
+    const secp256k1 = await this.getAddressObjSecp256k1();
+
+    const scripts: { script: Script; cellDeps: CellDepInfo[] }[] = [];
+    for (const input of tx.inputs) {
+      const {
+        cellOutput: { lock },
+      } = await input.getCell(this.client);
+
+      if (scripts.some(({ script }) => script.eq(lock))) {
+        continue;
+      }
+
+      if (lock.eq(secp256k1.script)) {
+        const scriptInfo = await this.client.findKnownScript(lock);
+        if (scriptInfo) {
+          scripts.push({
+            script: lock,
+            cellDeps: scriptInfo.cellDeps,
+          });
+        }
+      }
+    }
+
+    return scripts;
+  }
+
+  /**
+   * @warning
+   * Since transaction preparation will be automatically done in signOnlyTransaction, so
+   * this method is not recommended to explicitly use.
+   */
+  async prepareTransaction(txLike: TransactionLike): Promise<Transaction> {
+    const tx = Transaction.from(txLike);
+    const metadata = this.getMultisigMetadata();
+
+    await Promise.all(
+      (await this.getRelatedScripts(tx)).map(async ({ script, cellDeps }) => {
+        await tx.prepareMultisigWitness(
+          script,
+          metadata,
+          this.multisig.threshold,
+          this.client,
+        );
+        await tx.addCellDepInfos(this.client, cellDeps);
+      }),
+    );
+    return tx;
+  }
+
+  async signOnlyTransaction(txLike: TransactionLike): Promise<Transaction> {
+    let lastIndex = -1;
+    let tx = Transaction.from(txLike);
+    const metadata = this.getMultisigMetadata();
+    const emptySignature = hexFrom(Array.from(new Array(65), () => 0));
+
+    for (const { script } of await this.getRelatedScripts(tx)) {
+      const index = await tx.findInputIndexByLock(script, this.client);
+      if (!index) {
+        return tx;
+      }
+      if (index === lastIndex) {
+        continue;
+      } else {
+        lastIndex = index;
+      }
+
+      let witness = tx.getWitnessArgsAt(index);
+      if (!witness || !witness.lock?.startsWith(metadata)) {
+        tx = await this.prepareTransaction(tx);
+      }
+
+      witness = tx.getWitnessArgsAt(index);
+      if (!witness || !witness.lock) {
+        throw new Error("Multisig witness not prepared");
+      }
+
+      // Signatures array is placed after the multisig metadata, in 65 bytes per signature
+      const signatures =
+        witness.lock
+          .slice(metadata.length)
+          .match(/.{1,130}/g)
+          ?.map(hexFrom) || [];
+      const insertIndex = signatures.findIndex((sig) => sig === emptySignature);
+      if (signatures.length < this.multisig.threshold) {
+        throw new Error("Not enough signature slots to threshold");
+      }
+      if (insertIndex === -1) {
+        throw new Error("Signatures have been filled");
+      }
+
+      // Empty multisig witness for current signing
+      witness.lock = hexConcat(
+        metadata,
+        ...Array.from(new Array(this.multisig.threshold), () => emptySignature),
+      );
+      tx.setWitnessArgsAt(index, witness);
+      const info = await tx.getSignHashInfo(script, this.client);
+      if (!info) {
+        return tx;
+      }
+
+      const signature = await this._signMessage(info.message);
+      signatures[insertIndex] = signature;
+
+      witness.lock = hexConcat(metadata, ...signatures);
+      tx.setWitnessArgsAt(index, witness);
+    }
+
+    return tx;
+  }
+
+  /**
+   * Check if the multisig witness is fulfilled
+   *
+   * @param txLike - The transaction to check.
+   * @returns A promise that resolves to true if the multisig witness is fulfilled, false otherwise.
+   */
+  async signaturesFulfilled(txLike: TransactionLike): Promise<boolean> {
+    const tx = Transaction.from(txLike);
+    const metadata = this.getMultisigMetadata();
+    const emptySignature = hexFrom(Array.from(new Array(65), () => 0));
+
+    for (const { script } of await this.getRelatedScripts(tx)) {
+      const index = await tx.findInputIndexByLock(script, this.client);
+      if (!index) {
+        return false;
+      }
+
+      const witness = tx.getWitnessArgsAt(index);
+      if (!witness || !witness.lock?.startsWith(metadata)) {
+        return false;
+      }
+
+      const signatures =
+        witness.lock
+          .slice(metadata.length)
+          .match(/.{1,130}/g)
+          ?.map(hexFrom) || [];
+      if (
+        signatures.length < this.multisig.threshold ||
+        signatures.some((sig) => sig === emptySignature)
+      ) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+}
diff --git a/packages/examples/src/transferToMultisig.ts b/packages/examples/src/transferToMultisig.ts
new file mode 100644
index 000000000..e69de29bb

From 275947f5a81be9d680f5232e77f9936f91cc4a18 Mon Sep 17 00:00:00 2001
From: ashuralyk <ashuralyk@live.com>
Date: Fri, 4 Jul 2025 12:26:55 +0800
Subject: [PATCH 2/9] chore: fix bugs and complete playground test

---
 .changeset/large-icons-dream.md               |  6 ++
 .changeset/stale-clowns-kiss.md               |  6 ++
 packages/core/src/ckb/script.ts               | 16 ++--
 .../core/src/signer/ckb/signerCkbMultisig.ts  | 52 ++++++++----
 packages/examples/src/transferFromMultisig.ts | 85 +++++++++++++++++++
 packages/examples/src/transferToMultisig.ts   | 51 +++++++++++
 6 files changed, 193 insertions(+), 23 deletions(-)
 create mode 100644 .changeset/large-icons-dream.md
 create mode 100644 .changeset/stale-clowns-kiss.md
 create mode 100644 packages/examples/src/transferFromMultisig.ts

diff --git a/.changeset/large-icons-dream.md b/.changeset/large-icons-dream.md
new file mode 100644
index 000000000..051d984dd
--- /dev/null
+++ b/.changeset/large-icons-dream.md
@@ -0,0 +1,6 @@
+---
+"@ckb-ccc/core": patch
+---
+
+Add SignerCkbMultisig module for simplifying multisig transaction construction
+  
\ No newline at end of file
diff --git a/.changeset/stale-clowns-kiss.md b/.changeset/stale-clowns-kiss.md
new file mode 100644
index 000000000..fd52f8cc1
--- /dev/null
+++ b/.changeset/stale-clowns-kiss.md
@@ -0,0 +1,6 @@
+---
+"@ckb-ccc/examples": patch
+---
+
+Add examples for new signer of SignerCkbMultisig
+  
\ No newline at end of file
diff --git a/packages/core/src/ckb/script.ts b/packages/core/src/ckb/script.ts
index 9dd6f8d90..a9ead1cab 100644
--- a/packages/core/src/ckb/script.ts
+++ b/packages/core/src/ckb/script.ts
@@ -138,14 +138,14 @@ export function multisigMetadataFromPubkeys(
     );
   }
   const pubkeyBlake160Hashes = pubkeys.map((pubkey) =>
-    hashCkb(hexFrom(pubkey)).slice(0, 20),
+    hashCkb(hexFrom(pubkey)).slice(0, 42),
   );
   return hexConcat(
     "0x00",
-    hexFrom(("00" + mustMatch.toString(16)).slice(-2)),
-    hexFrom(("00" + threshold.toString(16)).slice(-2)),
-    hexFrom(("00" + pubkeyBlake160Hashes.length.toString(16)).slice(-2)),
-    ...pubkeyBlake160Hashes.map((h) => h.slice(2)),
+    hexFrom(mustMatch.toString(16)),
+    hexFrom(threshold.toString(16)),
+    hexFrom(pubkeyBlake160Hashes.length.toString(16)),
+    ...pubkeyBlake160Hashes,
   );
 }
 
@@ -318,12 +318,12 @@ export class Script extends mol.Entity.Base<ScriptLike, Script>() {
       );
     }
     const args = (() => {
-      const metadataHash = hashCkb(metadata);
+      const metadataBlake160Hash = hashCkb(metadata).slice(0, 42);
       if (since) {
         const sinceBytes = Since.from(since).toBytes();
-        return hexConcat(metadataHash, hexFrom(sinceBytes));
+        return hexConcat(metadataBlake160Hash, hexFrom(sinceBytes));
       } else {
-        return metadataHash;
+        return metadataBlake160Hash;
       }
     })();
     return await Script.fromKnownScript(client, multisigScript, args);
diff --git a/packages/core/src/signer/ckb/signerCkbMultisig.ts b/packages/core/src/signer/ckb/signerCkbMultisig.ts
index acc293ee2..6b3ab19db 100644
--- a/packages/core/src/signer/ckb/signerCkbMultisig.ts
+++ b/packages/core/src/signer/ckb/signerCkbMultisig.ts
@@ -1,14 +1,14 @@
 import { Address } from "../../address/index.js";
 import {
   multisigMetadataFromPubkeys,
-  SignerCkbPrivateKey,
+  Script,
   SinceLike,
   Transaction,
   TransactionLike,
-} from "../../barrel.js";
-import { Script } from "../../ckb/index.js";
+} from "../../ckb/index.js";
 import { CellDepInfo, Client, KnownScript } from "../../client/index.js";
 import { Hex, hexConcat, hexFrom, HexLike } from "../../hex/index.js";
+import { SignerCkbPrivateKey } from "./signerCkbPrivateKey.js";
 
 export interface MultisigInfo {
   pubkeys: HexLike[];
@@ -64,15 +64,15 @@ export class SignerCkbMultisig extends SignerCkbPrivateKey {
   }
 
   async getAddressObjs(): Promise<Address[]> {
-    const secp256k1 = await this.getAddressObjSecp256k1();
-    return [secp256k1];
+    const multisig = await this.getAddressObjSecp256k1();
+    return [multisig];
   }
 
   async getRelatedScripts(
     txLike: TransactionLike,
   ): Promise<{ script: Script; cellDeps: CellDepInfo[] }[]> {
     const tx = Transaction.from(txLike);
-    const secp256k1 = await this.getAddressObjSecp256k1();
+    const multisig = await this.getAddressObjSecp256k1();
 
     const scripts: { script: Script; cellDeps: CellDepInfo[] }[] = [];
     for (const input of tx.inputs) {
@@ -84,7 +84,7 @@ export class SignerCkbMultisig extends SignerCkbPrivateKey {
         continue;
       }
 
-      if (lock.eq(secp256k1.script)) {
+      if (lock.eq(multisig.script)) {
         const scriptInfo = await this.client.findKnownScript(lock);
         if (scriptInfo) {
           scripts.push({
@@ -104,6 +104,12 @@ export class SignerCkbMultisig extends SignerCkbPrivateKey {
    * this method is not recommended to explicitly use.
    */
   async prepareTransaction(txLike: TransactionLike): Promise<Transaction> {
+    return Transaction.from(txLike);
+  }
+
+  private async _prepareTransaction(
+    txLike: TransactionLike,
+  ): Promise<Transaction> {
     const tx = Transaction.from(txLike);
     const metadata = this.getMultisigMetadata();
 
@@ -129,7 +135,7 @@ export class SignerCkbMultisig extends SignerCkbPrivateKey {
 
     for (const { script } of await this.getRelatedScripts(tx)) {
       const index = await tx.findInputIndexByLock(script, this.client);
-      if (!index) {
+      if (index === undefined) {
         return tx;
       }
       if (index === lastIndex) {
@@ -140,7 +146,7 @@ export class SignerCkbMultisig extends SignerCkbPrivateKey {
 
       let witness = tx.getWitnessArgsAt(index);
       if (!witness || !witness.lock?.startsWith(metadata)) {
-        tx = await this.prepareTransaction(tx);
+        tx = await this._prepareTransaction(tx);
       }
 
       witness = tx.getWitnessArgsAt(index);
@@ -159,7 +165,8 @@ export class SignerCkbMultisig extends SignerCkbPrivateKey {
         throw new Error("Not enough signature slots to threshold");
       }
       if (insertIndex === -1) {
-        throw new Error("Signatures have been filled");
+        // Signatures have been filled
+        continue;
       }
 
       // Empty multisig witness for current signing
@@ -170,7 +177,7 @@ export class SignerCkbMultisig extends SignerCkbPrivateKey {
       tx.setWitnessArgsAt(index, witness);
       const info = await tx.getSignHashInfo(script, this.client);
       if (!info) {
-        return tx;
+        continue;
       }
 
       const signature = await this._signMessage(info.message);
@@ -187,16 +194,23 @@ export class SignerCkbMultisig extends SignerCkbPrivateKey {
    * Check if the multisig witness is fulfilled
    *
    * @param txLike - The transaction to check.
+   * @param restrict - If true, throw an error if the multisig script is not found in Inputs.
    * @returns A promise that resolves to true if the multisig witness is fulfilled, false otherwise.
    */
-  async signaturesFulfilled(txLike: TransactionLike): Promise<boolean> {
+  async signaturesFulfilled(
+    txLike: TransactionLike,
+    restrict: boolean = false,
+  ): Promise<boolean> {
     const tx = Transaction.from(txLike);
     const metadata = this.getMultisigMetadata();
     const emptySignature = hexFrom(Array.from(new Array(65), () => 0));
 
     for (const { script } of await this.getRelatedScripts(tx)) {
       const index = await tx.findInputIndexByLock(script, this.client);
-      if (!index) {
+      if (index === undefined) {
+        if (restrict) {
+          throw new Error("Multisig script not found in Inputs");
+        }
         return false;
       }
 
@@ -210,9 +224,17 @@ export class SignerCkbMultisig extends SignerCkbPrivateKey {
           .slice(metadata.length)
           .match(/.{1,130}/g)
           ?.map(hexFrom) || [];
+      if (signatures.length !== this.multisig.threshold) {
+        if (restrict) {
+          throw new Error(
+            "Bad multisig witness: not enough signatures to threshold",
+          );
+        }
+        return false;
+      }
       if (
-        signatures.length < this.multisig.threshold ||
-        signatures.some((sig) => sig === emptySignature)
+        signatures.filter((sig) => sig !== emptySignature).length <
+        this.multisig.threshold
       ) {
         return false;
       }
diff --git a/packages/examples/src/transferFromMultisig.ts b/packages/examples/src/transferFromMultisig.ts
new file mode 100644
index 000000000..8ae058fa2
--- /dev/null
+++ b/packages/examples/src/transferFromMultisig.ts
@@ -0,0 +1,85 @@
+import { ccc } from "@ckb-ccc/ccc";
+import { render, signer } from "@ckb-ccc/playground";
+
+const ALICE_PRIVATE_KEY =
+  "0x2c56a92a03d767542222432e4f2a0584f01e516311f705041d86b1af7573751f";
+const BOB_PRIVATE_KEY =
+  "0x3bc65932a75f76c5b6a04660e4d0b85c2d9b5114efa78e6e5cf7ad0588ca09c8";
+const CHARLES_PRIVATE_KEY =
+  "0xbe06025fbd8c74f65a513a28e62ac56f3227fcb307307a0f2a0ef34d4a66e81f";
+
+const signers = [
+  new ccc.SignerCkbPrivateKey(signer.client, ALICE_PRIVATE_KEY),
+  new ccc.SignerCkbPrivateKey(signer.client, BOB_PRIVATE_KEY),
+  new ccc.SignerCkbPrivateKey(signer.client, CHARLES_PRIVATE_KEY),
+];
+const publicKeys = signers.map((signer) => signer.publicKey);
+
+// Create multisig signers for ALICE, BOB, and CHARLES
+const multisigSigners = signers.map(
+  (signer) =>
+    new ccc.SignerCkbMultisig(signer.client, signer.privateKey, {
+      pubkeys: publicKeys,
+      threshold: 2,
+      mustMatch: 0,
+    }),
+);
+
+// The receiver is the signer itself
+const receiver = await signer.getRecommendedAddress();
+console.log("receiver", receiver);
+
+// Parse the receiver script from an address
+const { script: lock } = await ccc.Address.fromString(receiver, signer.client);
+
+// Describe what we want
+let tx = ccc.Transaction.from({
+  outputs: [{ capacity: ccc.fixedPointFrom(200), lock }],
+});
+await render(tx);
+
+// Complete missing parts: Fill inputs
+await tx.completeInputsByCapacity(multisigSigners[0]);
+await render(tx);
+
+// Complete missing parts: Pay fee
+await tx.completeFeeBy(multisigSigners[0]);
+await render(tx);
+
+// Alice checks if the transaction is fulfilled before signing
+if (await multisigSigners[0].signaturesFulfilled(tx, true)) {
+  console.log("Transaction is fulfilled");
+} else {
+  console.log("Transaction is not fulfilled");
+}
+
+// Alice signs the transaction
+tx = await multisigSigners[0].signTransaction(tx);
+
+// Alice checks if the transaction is fulfilled
+if (await multisigSigners[0].signaturesFulfilled(tx)) {
+  console.log("Alice: signature is fulfilled");
+} else {
+  console.log("Alice: signature is not fulfilled");
+}
+
+// Bob signs the transaction
+tx = await multisigSigners[1].signTransaction(tx);
+
+// Bob checks if the transaction is fulfilled
+if (await multisigSigners[1].signaturesFulfilled(tx)) {
+  console.log("Bob: signature is fulfilled");
+} else {
+  console.log("Bob: signature is not fulfilled");
+}
+
+// Charles checks if the transaction is fulfilled
+if (await multisigSigners[2].signaturesFulfilled(tx)) {
+  console.log("Charles: signature is fulfilled");
+} else {
+  console.log("Charles: signature is not fulfilled");
+}
+
+// Charles sends the transaction
+const txHash = await multisigSigners[2].sendTransaction(tx);
+console.log("txHash", txHash);
diff --git a/packages/examples/src/transferToMultisig.ts b/packages/examples/src/transferToMultisig.ts
index e69de29bb..1b245d5cd 100644
--- a/packages/examples/src/transferToMultisig.ts
+++ b/packages/examples/src/transferToMultisig.ts
@@ -0,0 +1,51 @@
+import { ccc } from "@ckb-ccc/ccc";
+import { render, signer } from "@ckb-ccc/playground";
+
+const ALICE_PRIVATE_KEY =
+  "0x2c56a92a03d767542222432e4f2a0584f01e516311f705041d86b1af7573751f";
+const BOB_PRIVATE_KEY =
+  "0x3bc65932a75f76c5b6a04660e4d0b85c2d9b5114efa78e6e5cf7ad0588ca09c8";
+const CHARLES_PRIVATE_KEY =
+  "0xbe06025fbd8c74f65a513a28e62ac56f3227fcb307307a0f2a0ef34d4a66e81f";
+
+const signers = [
+  new ccc.SignerCkbPrivateKey(signer.client, ALICE_PRIVATE_KEY),
+  new ccc.SignerCkbPrivateKey(signer.client, BOB_PRIVATE_KEY),
+  new ccc.SignerCkbPrivateKey(signer.client, CHARLES_PRIVATE_KEY),
+];
+
+// Create a multisig lock script for 2 of 3 signers with 0 must match
+const threshold = 2;
+const firstNthMustMatch = 0;
+
+const publicKeys = signers.map((signer) => signer.publicKey);
+const metadata = ccc.multisigMetadataFromPubkeys(
+  publicKeys,
+  threshold,
+  firstNthMustMatch,
+);
+const multisigLockScript = await ccc.Script.fromKnownMultisigScript(
+  signer.client,
+  metadata,
+);
+
+// Check the multisig address
+const multisigAddress = ccc.Address.fromScript(
+  multisigLockScript,
+  signer.client,
+);
+console.log("multisig address:", multisigAddress.toString());
+
+// Create a transaction to transfer 1000 CKB to the multisig address
+const tx = ccc.Transaction.from({
+  outputs: [{ capacity: ccc.fixedPointFrom(1000), lock: multisigLockScript }],
+});
+await render(tx);
+
+// Complete missing parts: Fill inputs
+await tx.completeInputsByCapacity(signer);
+await render(tx);
+
+// Complete missing parts: Pay fee
+await tx.completeFeeBy(signer);
+await render(tx);

From b34995988fa4b22cda454abb1038eb71e3f91c9c Mon Sep 17 00:00:00 2001
From: ashuralyk <ashuralyk@live.com>
Date: Fri, 4 Jul 2025 14:39:15 +0800
Subject: [PATCH 3/9] chore: adjust multisig signer preparation process

---
 packages/core/src/ckb/transaction.ts           | 18 ++++++++++++++----
 .../core/src/signer/ckb/signerCkbMultisig.ts   | 13 +------------
 2 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/packages/core/src/ckb/transaction.ts b/packages/core/src/ckb/transaction.ts
index 0b86807fe..12a08ce7a 100644
--- a/packages/core/src/ckb/transaction.ts
+++ b/packages/core/src/ckb/transaction.ts
@@ -1880,7 +1880,7 @@ export class Transaction extends mol.Entity.Base<
   }
 
   /**
-   * Prepare multisig witness
+   * Prepare multisig witness, if the existence of multisig witness is detected, nothing happens.
    *
    * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
    * @param multisigMetadata - The metadata of the multisig script.
@@ -1904,12 +1904,22 @@ export class Transaction extends mol.Entity.Base<
       return;
     }
 
+    const metadata = hexFrom(multisigMetadata);
     const emptySignature = hexFrom(Array.from(new Array(65), () => 0));
-    const witness = this.getWitnessArgsAt(position) ?? WitnessArgs.from({});
-    witness.lock = hexConcat(
-      multisigMetadata,
+    const signaturePlaceholder = hexConcat(
       ...Array.from(new Array(threshold), () => emptySignature),
     );
+
+    const witness = this.getWitnessArgsAt(position) ?? WitnessArgs.from({});
+    if (
+      witness.lock?.startsWith(metadata) &&
+      witness.lock.length ===
+        metadata.length + signaturePlaceholder.slice(2).length
+    ) {
+      return;
+    }
+
+    witness.lock = hexConcat(metadata, signaturePlaceholder);
     this.setWitnessArgsAt(position, witness);
   }
 
diff --git a/packages/core/src/signer/ckb/signerCkbMultisig.ts b/packages/core/src/signer/ckb/signerCkbMultisig.ts
index 6b3ab19db..725d73af0 100644
--- a/packages/core/src/signer/ckb/signerCkbMultisig.ts
+++ b/packages/core/src/signer/ckb/signerCkbMultisig.ts
@@ -98,18 +98,7 @@ export class SignerCkbMultisig extends SignerCkbPrivateKey {
     return scripts;
   }
 
-  /**
-   * @warning
-   * Since transaction preparation will be automatically done in signOnlyTransaction, so
-   * this method is not recommended to explicitly use.
-   */
   async prepareTransaction(txLike: TransactionLike): Promise<Transaction> {
-    return Transaction.from(txLike);
-  }
-
-  private async _prepareTransaction(
-    txLike: TransactionLike,
-  ): Promise<Transaction> {
     const tx = Transaction.from(txLike);
     const metadata = this.getMultisigMetadata();
 
@@ -146,7 +135,7 @@ export class SignerCkbMultisig extends SignerCkbPrivateKey {
 
       let witness = tx.getWitnessArgsAt(index);
       if (!witness || !witness.lock?.startsWith(metadata)) {
-        tx = await this._prepareTransaction(tx);
+        tx = await this.prepareTransaction(tx);
       }
 
       witness = tx.getWitnessArgsAt(index);

From 8dd1713f2a5c4e32aa12a7e1c0733cba7aebb602 Mon Sep 17 00:00:00 2001
From: ashuralyk <ashuralyk@live.com>
Date: Sat, 5 Jul 2025 14:52:03 +0800
Subject: [PATCH 4/9] chore: put all of multisig related implementations into
 seperate two signers

---
 packages/core/src/ckb/script.ts               | 108 +-----
 packages/core/src/ckb/transaction.ts          |  46 +--
 packages/core/src/signer/ckb/index.ts         |   1 +
 .../core/src/signer/ckb/signerCkbMultisig.ts  | 202 ++---------
 .../signer/ckb/signerCkbMultisigReadonly.ts   | 320 ++++++++++++++++++
 packages/core/src/signer/signer/index.ts      |   2 +
 packages/examples/src/transferToMultisig.ts   |  11 +-
 7 files changed, 360 insertions(+), 330 deletions(-)
 create mode 100644 packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts

diff --git a/packages/core/src/ckb/script.ts b/packages/core/src/ckb/script.ts
index a9ead1cab..6890f8308 100644
--- a/packages/core/src/ckb/script.ts
+++ b/packages/core/src/ckb/script.ts
@@ -1,8 +1,7 @@
-import { Since, SinceLike, hashCkb } from "../barrel.js";
 import { Bytes, BytesLike, bytesFrom } from "../bytes/index.js";
 import type { Client } from "../client/index.js";
 import { KnownScript } from "../client/knownScript.js";
-import { Hex, HexLike, hexConcat, hexFrom } from "../hex/index.js";
+import { Hex, HexLike, hexFrom } from "../hex/index.js";
 import { mol } from "../molecule/index.js";
 import {
   HASH_TYPES,
@@ -97,58 +96,6 @@ export function hashTypeToBytes(hashType: HashTypeLike): Bytes {
 export function hashTypeFromBytes(bytes: BytesLike): HashType {
   return NUM_TO_HASH_TYPE[bytesFrom(bytes)[0]];
 }
-
-/**
- * Generate the metadata and script args of a multisig script.
- * @public
- *
- * @param pubkeys - The public keys engaged in the multisig script.
- * @param threshold - The threshold of the signatures.
- * @param mustMatch - The first nth must match of the public keys.
- * @returns The serialized multisig information, known as metadata.
- *
- * @example
- * ```typescript
- * const { metadata, scriptArgs } = multisigMetadataFromPubkeys({
- *   pubkeys: ["0x1234...", "0x5678...", "0x90ab...", "0xabcd..."],
- *   threshold: 2,
- *   mustMatch: 1,
- * });
- * ```
- */
-
-export function multisigMetadataFromPubkeys(
-  pubkeys: HexLike[],
-  threshold: number,
-  mustMatch: number,
-): Hex {
-  if (threshold < 0 || threshold > 255) {
-    throw new Error("`threshold` must be positive and less than 256!");
-  }
-  if (mustMatch < 0 || mustMatch > 255) {
-    throw new Error("`mustMatch` must be positive and less than 256!");
-  }
-  if (
-    pubkeys.length < mustMatch ||
-    pubkeys.length < threshold ||
-    pubkeys.length > 255
-  ) {
-    throw new Error(
-      "length of `pubkeys` must be greater than or equal to `mustMatch` and `threshold` and less than 256!",
-    );
-  }
-  const pubkeyBlake160Hashes = pubkeys.map((pubkey) =>
-    hashCkb(hexFrom(pubkey)).slice(0, 42),
-  );
-  return hexConcat(
-    "0x00",
-    hexFrom(mustMatch.toString(16)),
-    hexFrom(threshold.toString(16)),
-    hexFrom(pubkeyBlake160Hashes.length.toString(16)),
-    ...pubkeyBlake160Hashes,
-  );
-}
-
 /**
  * @public
  */
@@ -275,59 +222,6 @@ export class Script extends mol.Entity.Base<ScriptLike, Script>() {
     const script = await client.getKnownScript(knownScript);
     return new Script(script.codeHash, script.hashType, hexFrom(args));
   }
-
-  /**
-   * Creates a Script instance from known multisig script.
-   *
-   * @param client - A Client instance.
-   * @param metadata - The metadata of the multisig script.
-   * @param since - The since of the multisig script.
-   * @param multisigScript - A KnownScript enum.
-   * @returns A promise that resolves to the script instance.
-   *
-   * @example
-   * ```typescript
-   * const metadata = multisigMetadataFromPubkeys(
-   *   ["0x1234...", "0x5678...", "0x90ab..."],
-   *   2,
-   *   1,
-   * );
-   * const script = await Script.fromKnownMultisigScript(
-   *   client,
-   *   metadata,
-   *   {
-   *     relative: "absolute",
-   *     metric: "blockNumber",
-   *     value: 1000,
-   *   }
-   * );
-   * ```
-   */
-
-  static async fromKnownMultisigScript(
-    client: Client,
-    metadata: HexLike,
-    since?: SinceLike,
-    multisigScript:
-      | KnownScript.Secp256k1Multisig
-      | KnownScript.Secp256k1MultisigV2 = KnownScript.Secp256k1MultisigV2,
-  ): Promise<Script> {
-    if (multisigScript === KnownScript.Secp256k1Multisig) {
-      console.warn(
-        "Secp256k1Multisig has detected bugs and marked as **Deprecated**. Please use Secp256k1MultisigV2 instead.",
-      );
-    }
-    const args = (() => {
-      const metadataBlake160Hash = hashCkb(metadata).slice(0, 42);
-      if (since) {
-        const sinceBytes = Since.from(since).toBytes();
-        return hexConcat(metadataBlake160Hash, hexFrom(sinceBytes));
-      } else {
-        return metadataBlake160Hash;
-      }
-    })();
-    return await Script.fromKnownScript(client, multisigScript, args);
-  }
 }
 
 export const ScriptOpt = mol.option(Script);
diff --git a/packages/core/src/ckb/transaction.ts b/packages/core/src/ckb/transaction.ts
index 12a08ce7a..df0e84c34 100644
--- a/packages/core/src/ckb/transaction.ts
+++ b/packages/core/src/ckb/transaction.ts
@@ -9,7 +9,7 @@ import {
 import { KnownScript } from "../client/knownScript.js";
 import { Zero, fixedPointFrom } from "../fixedPoint/index.js";
 import { Hasher, HasherCkb, hashCkb } from "../hasher/index.js";
-import { Hex, HexLike, hexConcat, hexFrom } from "../hex/index.js";
+import { Hex, HexLike, hexFrom } from "../hex/index.js";
 import { mol } from "../molecule/index.js";
 import {
   Num,
@@ -1879,50 +1879,6 @@ export class Transaction extends mol.Entity.Base<
     this.setWitnessArgsAt(position, witness);
   }
 
-  /**
-   * Prepare multisig witness, if the existence of multisig witness is detected, nothing happens.
-   *
-   * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
-   * @param multisigMetadata - The metadata of the multisig script.
-   * @param threshold - The threshold of the multisig script.
-   * @param client - The client for complete extra infos in the transaction.
-   * @returns A promise that resolves to the prepared transaction
-   *
-   * @example
-   * ```typescript
-   * await tx.prepareMultisigWitness(script, multisigMetadata, threshold, client);
-   * ```
-   */
-  async prepareMultisigWitness(
-    scriptLike: ScriptLike,
-    multisigMetadata: HexLike,
-    threshold: number,
-    client: Client,
-  ): Promise<void> {
-    const position = await this.findInputIndexByLock(scriptLike, client);
-    if (position === undefined) {
-      return;
-    }
-
-    const metadata = hexFrom(multisigMetadata);
-    const emptySignature = hexFrom(Array.from(new Array(65), () => 0));
-    const signaturePlaceholder = hexConcat(
-      ...Array.from(new Array(threshold), () => emptySignature),
-    );
-
-    const witness = this.getWitnessArgsAt(position) ?? WitnessArgs.from({});
-    if (
-      witness.lock?.startsWith(metadata) &&
-      witness.lock.length ===
-        metadata.length + signaturePlaceholder.slice(2).length
-    ) {
-      return;
-    }
-
-    witness.lock = hexConcat(metadata, signaturePlaceholder);
-    this.setWitnessArgsAt(position, witness);
-  }
-
   async getInputsCapacityExtra(client: Client): Promise<Num> {
     return reduceAsync(
       this.inputs,
diff --git a/packages/core/src/signer/ckb/index.ts b/packages/core/src/signer/ckb/index.ts
index d8f431f12..9bedc28a1 100644
--- a/packages/core/src/signer/ckb/index.ts
+++ b/packages/core/src/signer/ckb/index.ts
@@ -1,4 +1,5 @@
 export * from "./signerCkbMultisig.js";
+export * from "./signerCkbMultisigReadonly.js";
 export * from "./signerCkbPrivateKey.js";
 export * from "./signerCkbPublicKey.js";
 export * from "./signerCkbScriptReadonly.js";
diff --git a/packages/core/src/signer/ckb/signerCkbMultisig.ts b/packages/core/src/signer/ckb/signerCkbMultisig.ts
index 725d73af0..e1c950ed3 100644
--- a/packages/core/src/signer/ckb/signerCkbMultisig.ts
+++ b/packages/core/src/signer/ckb/signerCkbMultisig.ts
@@ -1,125 +1,31 @@
-import { Address } from "../../address/index.js";
+import { Transaction, TransactionLike } from "../../ckb/index.js";
+import { Client } from "../../client/index.js";
+import { hexConcat, hexFrom, HexLike } from "../../hex/index.js";
 import {
-  multisigMetadataFromPubkeys,
-  Script,
-  SinceLike,
-  Transaction,
-  TransactionLike,
-} from "../../ckb/index.js";
-import { CellDepInfo, Client, KnownScript } from "../../client/index.js";
-import { Hex, hexConcat, hexFrom, HexLike } from "../../hex/index.js";
+  MultisigInfoLike,
+  SignerCkbMultisigReadonly,
+} from "./signerCkbMultisigReadonly.js";
 import { SignerCkbPrivateKey } from "./signerCkbPrivateKey.js";
 
-export interface MultisigInfo {
-  pubkeys: HexLike[];
-  threshold: number;
-  mustMatch: number;
-  since?: SinceLike;
-  multisigScript?:
-    | KnownScript.Secp256k1Multisig
-    | KnownScript.Secp256k1MultisigV2;
-}
-
 /**
- * A class extending Signer that provides access to a CKB multisig script.
- * This class supports signing operations.
+ * A class extending Signer that provides access to a CKB multisig script and supports signing operations.
  * @public
  */
-export class SignerCkbMultisig extends SignerCkbPrivateKey {
-  public readonly multisig: MultisigInfo;
-
-  /**
-   * Creates an instance of SignerCkbMultisig.
-   *
-   * @param client - The client instance used for communication.
-   * @param privateKey - The private key associated with the signer.
-   * @param multisig - The multisig information assembled from pubkeys, threshold, mustMatch and since.
-   */
-  constructor(client: Client, privateKey: HexLike, multisig: MultisigInfo) {
-    super(client, privateKey);
-
-    this.multisig = multisig;
-  }
-
-  async getAddressObjSecp256k1(): Promise<Address> {
-    const multisigScript = await Script.fromKnownMultisigScript(
-      this.client,
-      this.getMultisigMetadata(),
-      this.multisig.since,
-      this.multisig.multisigScript,
-    );
-    return Address.fromScript(multisigScript, this.client);
-  }
-
-  getMultisigInfo(): MultisigInfo {
-    return this.multisig;
-  }
-
-  getMultisigMetadata(): Hex {
-    return multisigMetadataFromPubkeys(
-      this.multisig.pubkeys,
-      this.multisig.threshold,
-      this.multisig.mustMatch,
-    );
-  }
-
-  async getAddressObjs(): Promise<Address[]> {
-    const multisig = await this.getAddressObjSecp256k1();
-    return [multisig];
-  }
-
-  async getRelatedScripts(
-    txLike: TransactionLike,
-  ): Promise<{ script: Script; cellDeps: CellDepInfo[] }[]> {
-    const tx = Transaction.from(txLike);
-    const multisig = await this.getAddressObjSecp256k1();
-
-    const scripts: { script: Script; cellDeps: CellDepInfo[] }[] = [];
-    for (const input of tx.inputs) {
-      const {
-        cellOutput: { lock },
-      } = await input.getCell(this.client);
-
-      if (scripts.some(({ script }) => script.eq(lock))) {
-        continue;
-      }
-
-      if (lock.eq(multisig.script)) {
-        const scriptInfo = await this.client.findKnownScript(lock);
-        if (scriptInfo) {
-          scripts.push({
-            script: lock,
-            cellDeps: scriptInfo.cellDeps,
-          });
-        }
-      }
-    }
-
-    return scripts;
-  }
-
-  async prepareTransaction(txLike: TransactionLike): Promise<Transaction> {
-    const tx = Transaction.from(txLike);
-    const metadata = this.getMultisigMetadata();
-
-    await Promise.all(
-      (await this.getRelatedScripts(tx)).map(async ({ script, cellDeps }) => {
-        await tx.prepareMultisigWitness(
-          script,
-          metadata,
-          this.multisig.threshold,
-          this.client,
-        );
-        await tx.addCellDepInfos(this.client, cellDeps);
-      }),
-    );
-    return tx;
+export class SignerCkbMultisig extends SignerCkbMultisigReadonly {
+  public readonly signer: SignerCkbPrivateKey;
+
+  constructor(
+    client: Client,
+    privateKey: HexLike,
+    multisigInfoLike: MultisigInfoLike,
+  ) {
+    super(client, multisigInfoLike);
+    this.signer = new SignerCkbPrivateKey(client, privateKey);
   }
 
   async signOnlyTransaction(txLike: TransactionLike): Promise<Transaction> {
     let lastIndex = -1;
     let tx = Transaction.from(txLike);
-    const metadata = this.getMultisigMetadata();
     const emptySignature = hexFrom(Array.from(new Array(65), () => 0));
 
     for (const { script } of await this.getRelatedScripts(tx)) {
@@ -134,7 +40,7 @@ export class SignerCkbMultisig extends SignerCkbPrivateKey {
       }
 
       let witness = tx.getWitnessArgsAt(index);
-      if (!witness || !witness.lock?.startsWith(metadata)) {
+      if (!witness || !witness.lock?.startsWith(this.multisigInfo.metadata)) {
         tx = await this.prepareTransaction(tx);
       }
 
@@ -146,12 +52,14 @@ export class SignerCkbMultisig extends SignerCkbPrivateKey {
       // Signatures array is placed after the multisig metadata, in 65 bytes per signature
       const signatures =
         witness.lock
-          .slice(metadata.length)
+          .slice(this.multisigInfo.metadata.length)
           .match(/.{1,130}/g)
           ?.map(hexFrom) || [];
       const insertIndex = signatures.findIndex((sig) => sig === emptySignature);
-      if (signatures.length < this.multisig.threshold) {
-        throw new Error("Not enough signature slots to threshold");
+      if (signatures.length !== this.multisigInfo.threshold) {
+        throw new Error(
+          `Not enough signature slots to threshold (${signatures.length}/${this.multisigInfo.threshold})`,
+        );
       }
       if (insertIndex === -1) {
         // Signatures have been filled
@@ -160,8 +68,11 @@ export class SignerCkbMultisig extends SignerCkbPrivateKey {
 
       // Empty multisig witness for current signing
       witness.lock = hexConcat(
-        metadata,
-        ...Array.from(new Array(this.multisig.threshold), () => emptySignature),
+        this.multisigInfo.metadata,
+        ...Array.from(
+          new Array(this.multisigInfo.threshold),
+          () => emptySignature,
+        ),
       );
       tx.setWitnessArgsAt(index, witness);
       const info = await tx.getSignHashInfo(script, this.client);
@@ -169,66 +80,13 @@ export class SignerCkbMultisig extends SignerCkbPrivateKey {
         continue;
       }
 
-      const signature = await this._signMessage(info.message);
+      const signature = await this.signer._signMessage(info.message);
       signatures[insertIndex] = signature;
 
-      witness.lock = hexConcat(metadata, ...signatures);
+      witness.lock = hexConcat(this.multisigInfo.metadata, ...signatures);
       tx.setWitnessArgsAt(index, witness);
     }
 
     return tx;
   }
-
-  /**
-   * Check if the multisig witness is fulfilled
-   *
-   * @param txLike - The transaction to check.
-   * @param restrict - If true, throw an error if the multisig script is not found in Inputs.
-   * @returns A promise that resolves to true if the multisig witness is fulfilled, false otherwise.
-   */
-  async signaturesFulfilled(
-    txLike: TransactionLike,
-    restrict: boolean = false,
-  ): Promise<boolean> {
-    const tx = Transaction.from(txLike);
-    const metadata = this.getMultisigMetadata();
-    const emptySignature = hexFrom(Array.from(new Array(65), () => 0));
-
-    for (const { script } of await this.getRelatedScripts(tx)) {
-      const index = await tx.findInputIndexByLock(script, this.client);
-      if (index === undefined) {
-        if (restrict) {
-          throw new Error("Multisig script not found in Inputs");
-        }
-        return false;
-      }
-
-      const witness = tx.getWitnessArgsAt(index);
-      if (!witness || !witness.lock?.startsWith(metadata)) {
-        return false;
-      }
-
-      const signatures =
-        witness.lock
-          .slice(metadata.length)
-          .match(/.{1,130}/g)
-          ?.map(hexFrom) || [];
-      if (signatures.length !== this.multisig.threshold) {
-        if (restrict) {
-          throw new Error(
-            "Bad multisig witness: not enough signatures to threshold",
-          );
-        }
-        return false;
-      }
-      if (
-        signatures.filter((sig) => sig !== emptySignature).length <
-        this.multisig.threshold
-      ) {
-        return false;
-      }
-    }
-
-    return true;
-  }
 }
diff --git a/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts b/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts
new file mode 100644
index 000000000..f52e05237
--- /dev/null
+++ b/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts
@@ -0,0 +1,320 @@
+import { Address } from "../../address/index.js";
+import {
+  Script,
+  SinceLike,
+  Transaction,
+  TransactionLike,
+} from "../../ckb/index.js";
+import { CellDepInfo, Client, KnownScript } from "../../client/index.js";
+import { Hex, hexConcat, hexFrom, HexLike } from "../../hex/index.js";
+import {
+  hashCkb,
+  numToBytes,
+  ScriptLike,
+  Since,
+  WitnessArgs,
+} from "../../index.js";
+import { Signer, SignerSignType, SignerType } from "../signer/index.js";
+
+export const MULTISIG_SCRIPT_DEFAULT = KnownScript.Secp256k1MultisigV2;
+export const MULTISIG_SCRIPTS = [
+  KnownScript.Secp256k1MultisigV2,
+  KnownScript.Secp256k1Multisig,
+];
+
+export type MultisigInfoLike = {
+  pubkeys: HexLike[];
+  threshold: number;
+  mustMatch: number;
+  since?: SinceLike;
+  multisigScript?:
+    | KnownScript.Secp256k1Multisig
+    | KnownScript.Secp256k1MultisigV2;
+};
+
+/**
+ * A class representing multisig information, holding information ingredients and containing utilities.
+ * @public
+ */
+export class MultisigInfo {
+  public readonly pubkeys: Hex[];
+  public readonly threshold: number;
+  public readonly mustMatch: number;
+  public readonly since?: Since;
+  public readonly knownMultisigScript:
+    | KnownScript.Secp256k1Multisig
+    | KnownScript.Secp256k1MultisigV2;
+
+  public readonly pubkeyBlake160Hashes: Hex[];
+  public readonly metadata: Hex;
+
+  private constructor(multisig: MultisigInfoLike) {
+    this.pubkeys = multisig.pubkeys.map(hexFrom);
+    this.threshold = multisig.threshold;
+    this.mustMatch = multisig.mustMatch;
+    this.since = multisig.since ? Since.from(multisig.since) : undefined;
+    this.knownMultisigScript =
+      multisig.multisigScript ?? MULTISIG_SCRIPT_DEFAULT;
+    if (this.knownMultisigScript !== MULTISIG_SCRIPT_DEFAULT) {
+      console.warn(
+        `Multisig script '${this.knownMultisigScript}' is marked as **Deprecated**, please using '${MULTISIG_SCRIPT_DEFAULT}' instead`,
+      );
+    }
+    if (this.threshold < 0 || this.threshold > 255) {
+      throw new Error("`threshold` must be positive and less than 256!");
+    }
+    if (this.mustMatch < 0 || this.mustMatch > 255) {
+      throw new Error("`mustMatch` must be positive and less than 256!");
+    }
+    if (this.mustMatch > this.threshold) {
+      throw new Error("`mustMatch` must be less than or equal to `threshold`!");
+    }
+    if (
+      this.pubkeys.length < this.mustMatch ||
+      this.pubkeys.length < this.threshold ||
+      this.pubkeys.length > 255
+    ) {
+      throw new Error(
+        "length of `pubkeys` must be greater than or equal to `mustMatch` and `threshold` and less than 256!",
+      );
+    }
+    this.pubkeyBlake160Hashes = this.pubkeys.map(
+      (pubkey) => hashCkb(hexFrom(pubkey)).slice(0, 42) as Hex,
+    );
+    this.metadata = hexConcat(
+      "0x00",
+      hexFrom(numToBytes(this.mustMatch)),
+      hexFrom(numToBytes(this.threshold)),
+      hexFrom(numToBytes(this.pubkeyBlake160Hashes.length)),
+      ...this.pubkeyBlake160Hashes,
+    );
+  }
+
+  static from(multisig: MultisigInfoLike): MultisigInfo {
+    return new MultisigInfo(multisig);
+  }
+
+  multisigScriptArgs(): Hex {
+    const metadataBlake160Hash = hashCkb(this.metadata).slice(0, 42) as Hex;
+    if (this.since) {
+      const sinceBytes = this.since.toBytes();
+      return hexConcat(metadataBlake160Hash, hexFrom(sinceBytes));
+    } else {
+      return metadataBlake160Hash;
+    }
+  }
+
+  async defaultMultisigScript(client: Client): Promise<Script> {
+    return await Script.fromKnownScript(
+      client,
+      this.knownMultisigScript,
+      this.multisigScriptArgs(),
+    );
+  }
+
+  async multisigScripts(client: Client): Promise<Script[]> {
+    const args = this.multisigScriptArgs();
+    return await Promise.all(
+      MULTISIG_SCRIPTS.map(async (script) => {
+        return await Script.fromKnownScript(client, script, args);
+      }),
+    );
+  }
+}
+
+/**
+ * A class extending Signer that provides access to a CKB multisig script.
+ * This class does not support signing operations.
+ * @public
+ */
+export class SignerCkbMultisigReadonly extends Signer {
+  get type(): SignerType {
+    return SignerType.CKB;
+  }
+
+  get signType(): SignerSignType {
+    return SignerSignType.CkbMultisigSecp256k1;
+  }
+
+  public readonly multisigInfo: MultisigInfo;
+
+  /**
+   * Creates an instance of SignerCkbMultisig.
+   *
+   * @param client - The client instance used for communication.
+   * @param privateKey - The private key associated with the signer.
+   * @param multisigInfoLike - The multisig information assembled from pubkeys, threshold, mustMatch and since.
+   */
+  constructor(client: Client, multisigInfoLike: MultisigInfoLike) {
+    super(client);
+
+    this.multisigInfo = MultisigInfo.from(multisigInfoLike);
+  }
+
+  async connect(): Promise<void> {}
+
+  async isConnected(): Promise<boolean> {
+    return true;
+  }
+
+  async getInternalAddress(): Promise<string> {
+    return this.getRecommendedAddress();
+  }
+
+  async getAddressObjSecp256k1(): Promise<Address> {
+    const multisigScript = await this.multisigInfo.defaultMultisigScript(
+      this.client,
+    );
+    return Address.fromScript(multisigScript, this.client);
+  }
+
+  async getAddressObjs(): Promise<Address[]> {
+    const multisigScripts = await this.multisigInfo.multisigScripts(
+      this.client,
+    );
+    return multisigScripts.map((script) =>
+      Address.fromScript(script, this.client),
+    );
+  }
+
+  async getRelatedScripts(
+    txLike: TransactionLike,
+  ): Promise<{ script: Script; cellDeps: CellDepInfo[] }[]> {
+    const tx = Transaction.from(txLike);
+    const multisig = await this.getAddressObjSecp256k1();
+
+    const scripts: { script: Script; cellDeps: CellDepInfo[] }[] = [];
+    for (const input of tx.inputs) {
+      const {
+        cellOutput: { lock },
+      } = await input.getCell(this.client);
+
+      if (scripts.some(({ script }) => script.eq(lock))) {
+        continue;
+      }
+
+      if (lock.eq(multisig.script)) {
+        const scriptInfo = await this.client.findKnownScript(lock);
+        if (scriptInfo) {
+          scripts.push({
+            script: lock,
+            cellDeps: scriptInfo.cellDeps,
+          });
+        }
+      }
+    }
+
+    return scripts;
+  }
+
+  /**
+   * Prepare multisig witness, if the existence of multisig witness is detected, nothing happens
+   *
+   * @param txLike - The transaction to prepare.
+   * @param scriptLike - The script to prepare.
+   * @returns A promise that resolves to the prepared transaction
+   */
+  async prepareTxMultisigWitness(
+    txLike: TransactionLike,
+    scriptLike: ScriptLike,
+  ) {
+    const tx = Transaction.from(txLike);
+    const position = await tx.findInputIndexByLock(scriptLike, this.client);
+    if (position === undefined) {
+      return;
+    }
+
+    // Prepare signature placeholder
+    const emptySignature = hexFrom(Array.from(new Array(65), () => 0));
+    const signaturePlaceholder = hexConcat(
+      ...Array.from(
+        new Array(this.multisigInfo.threshold),
+        () => emptySignature,
+      ),
+    );
+
+    // Check if the multisig witness is already prepared
+    const witness = tx.getWitnessArgsAt(position) ?? WitnessArgs.from({});
+    if (
+      witness.lock?.startsWith(this.multisigInfo.metadata) &&
+      witness.lock.length ===
+        this.multisigInfo.metadata.length + signaturePlaceholder.slice(2).length
+    ) {
+      return;
+    }
+
+    // Reset multisig witness to signature placeholder
+    witness.lock = hexConcat(this.multisigInfo.metadata, signaturePlaceholder);
+    tx.setWitnessArgsAt(position, witness);
+  }
+
+  /**
+   * Prepare transaction for multisig witness and adding related cell deps
+   *
+   * @param txLike - The transaction to prepare.
+   * @returns A promise that resolves to the prepared transaction
+   */
+  async prepareTransaction(txLike: TransactionLike): Promise<Transaction> {
+    const tx = Transaction.from(txLike);
+
+    await Promise.all(
+      (await this.getRelatedScripts(tx)).map(async ({ script, cellDeps }) => {
+        await this.prepareTxMultisigWitness(tx, script);
+        await tx.addCellDepInfos(this.client, cellDeps);
+      }),
+    );
+    return tx;
+  }
+
+  /**
+   * Check if the multisig witness is fulfilled
+   *
+   * @param txLike - The transaction to check.
+   * @param restrict - If true, throw an error if the multisig script is not found in Inputs.
+   * @returns A promise that resolves to true if the multisig witness is fulfilled, false otherwise.
+   */
+  async signaturesFulfilled(
+    txLike: TransactionLike,
+    restrict: boolean = false,
+  ): Promise<boolean> {
+    const tx = Transaction.from(txLike);
+    const emptySignature = hexFrom(Array.from(new Array(65), () => 0));
+
+    for (const { script } of await this.getRelatedScripts(tx)) {
+      const index = await tx.findInputIndexByLock(script, this.client);
+      if (index === undefined) {
+        if (restrict) {
+          throw new Error("Multisig script not found in Inputs");
+        }
+        return false;
+      }
+
+      const witness = tx.getWitnessArgsAt(index);
+      if (!witness || !witness.lock?.startsWith(this.multisigInfo.metadata)) {
+        return false;
+      }
+
+      const signatures =
+        witness.lock
+          .slice(this.multisigInfo.metadata.length)
+          .match(/.{1,130}/g)
+          ?.map(hexFrom) || [];
+      if (signatures.length !== this.multisigInfo.threshold) {
+        if (restrict) {
+          throw new Error(
+            `Not enough signatures to threshold (${signatures.length}/${this.multisigInfo.threshold})`,
+          );
+        }
+        return false;
+      }
+      if (
+        signatures.filter((sig) => sig !== emptySignature).length <
+        this.multisigInfo.threshold
+      ) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+}
diff --git a/packages/core/src/signer/signer/index.ts b/packages/core/src/signer/signer/index.ts
index 819af378d..12e7a0203 100644
--- a/packages/core/src/signer/signer/index.ts
+++ b/packages/core/src/signer/signer/index.ts
@@ -28,6 +28,7 @@ export enum SignerSignType {
   NostrEvent = "NostrEvent",
   CkbSecp256k1 = "CkbSecp256k1",
   DogeEcdsa = "DogeEcdsa",
+  CkbMultisigSecp256k1 = "CkbMultisigSecp256k1",
 }
 
 /**
@@ -139,6 +140,7 @@ export abstract class Signer {
           signature.signature,
           signature.identity,
         );
+      case SignerSignType.CkbMultisigSecp256k1:
       case SignerSignType.CkbSecp256k1:
         return verifyMessageCkbSecp256k1(
           message,
diff --git a/packages/examples/src/transferToMultisig.ts b/packages/examples/src/transferToMultisig.ts
index 1b245d5cd..10ac3872b 100644
--- a/packages/examples/src/transferToMultisig.ts
+++ b/packages/examples/src/transferToMultisig.ts
@@ -19,14 +19,13 @@ const threshold = 2;
 const firstNthMustMatch = 0;
 
 const publicKeys = signers.map((signer) => signer.publicKey);
-const metadata = ccc.multisigMetadataFromPubkeys(
-  publicKeys,
+const multisigInfo = ccc.MultisigInfo.from({
+  pubkeys: publicKeys,
   threshold,
-  firstNthMustMatch,
-);
-const multisigLockScript = await ccc.Script.fromKnownMultisigScript(
+  mustMatch: firstNthMustMatch,
+});
+const multisigLockScript = await multisigInfo.defaultMultisigScript(
   signer.client,
-  metadata,
 );
 
 // Check the multisig address

From 69a92c48b3a98b0e7efe676115bf2c6f326c6ff8 Mon Sep 17 00:00:00 2001
From: ashuralyk <ashuralyk@live.com>
Date: Wed, 27 Aug 2025 21:00:33 +0800
Subject: [PATCH 5/9] feat: extend multisigScript to support personal defined
 script

---
 .../signer/ckb/signerCkbMultisigReadonly.ts   | 48 ++++++++++++++++---
 1 file changed, 41 insertions(+), 7 deletions(-)

diff --git a/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts b/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts
index f52e05237..4049bb2fd 100644
--- a/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts
+++ b/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts
@@ -10,6 +10,7 @@ import { Hex, hexConcat, hexFrom, HexLike } from "../../hex/index.js";
 import {
   hashCkb,
   numToBytes,
+  ScriptInfoLike,
   ScriptLike,
   Since,
   WitnessArgs,
@@ -28,6 +29,7 @@ export type MultisigInfoLike = {
   mustMatch: number;
   since?: SinceLike;
   multisigScript?:
+    | ScriptInfoLike
     | KnownScript.Secp256k1Multisig
     | KnownScript.Secp256k1MultisigV2;
 };
@@ -42,6 +44,7 @@ export class MultisigInfo {
   public readonly mustMatch: number;
   public readonly since?: Since;
   public readonly knownMultisigScript:
+    | ScriptInfoLike
     | KnownScript.Secp256k1Multisig
     | KnownScript.Secp256k1MultisigV2;
 
@@ -55,7 +58,10 @@ export class MultisigInfo {
     this.since = multisig.since ? Since.from(multisig.since) : undefined;
     this.knownMultisigScript =
       multisig.multisigScript ?? MULTISIG_SCRIPT_DEFAULT;
-    if (this.knownMultisigScript !== MULTISIG_SCRIPT_DEFAULT) {
+    if (
+      typeof this.knownMultisigScript === "string" &&
+      this.knownMultisigScript !== MULTISIG_SCRIPT_DEFAULT
+    ) {
       console.warn(
         `Multisig script '${this.knownMultisigScript}' is marked as **Deprecated**, please using '${MULTISIG_SCRIPT_DEFAULT}' instead`,
       );
@@ -105,20 +111,35 @@ export class MultisigInfo {
   }
 
   async defaultMultisigScript(client: Client): Promise<Script> {
-    return await Script.fromKnownScript(
-      client,
-      this.knownMultisigScript,
-      this.multisigScriptArgs(),
-    );
+    const args = this.multisigScriptArgs();
+    if (typeof this.knownMultisigScript === "string") {
+      return await Script.fromKnownScript(
+        client,
+        this.knownMultisigScript,
+        args,
+      );
+    }
+    return Script.from({
+      ...this.knownMultisigScript,
+      args,
+    });
   }
 
   async multisigScripts(client: Client): Promise<Script[]> {
     const args = this.multisigScriptArgs();
-    return await Promise.all(
+    const builtInScripts = await Promise.all(
       MULTISIG_SCRIPTS.map(async (script) => {
         return await Script.fromKnownScript(client, script, args);
       }),
     );
+    if (typeof this.knownMultisigScript === "string") {
+      return builtInScripts;
+    }
+    const manualScript = Script.from({
+      ...this.knownMultisigScript,
+      args,
+    });
+    return [manualScript, ...builtInScripts];
   }
 }
 
@@ -200,6 +221,19 @@ export class SignerCkbMultisigReadonly extends Signer {
             script: lock,
             cellDeps: scriptInfo.cellDeps,
           });
+        } else {
+          if (typeof this.multisigInfo.knownMultisigScript === "string") {
+            // Generally, this branch could not be reached
+            throw new Error(
+              `Unsupported multisig script: ${this.multisigInfo.knownMultisigScript}`,
+            );
+          }
+          scripts.push({
+            script: lock,
+            cellDeps: this.multisigInfo.knownMultisigScript.cellDeps.map(
+              (cellDep) => CellDepInfo.from(cellDep),
+            ),
+          });
         }
       }
     }

From f5dccd7aac00ff832eb75294dfff0d05fd873582 Mon Sep 17 00:00:00 2001
From: ashuralyk <ashuralyk@live.com>
Date: Thu, 4 Sep 2025 09:45:16 +0800
Subject: [PATCH 6/9] chore: gemini review report

---
 packages/core/src/client/clientPublicMainnet.ts | 11 ++++-------
 packages/core/src/client/clientPublicTestnet.ts | 11 ++++-------
 2 files changed, 8 insertions(+), 14 deletions(-)

diff --git a/packages/core/src/client/clientPublicMainnet.ts b/packages/core/src/client/clientPublicMainnet.ts
index 3d9e06e18..4dc94b8cb 100644
--- a/packages/core/src/client/clientPublicMainnet.ts
+++ b/packages/core/src/client/clientPublicMainnet.ts
@@ -58,14 +58,11 @@ export class ClientPublicMainnet extends ClientJsonRpc {
     scriptLike: ScriptLike,
   ): Promise<ScriptInfo | undefined> {
     const script = Script.from(scriptLike);
-    const scriptInfo = Object.values(this.scripts).find((scriptInfo) => {
-      if (
+    const scriptInfo = Object.values(this.scripts).find(
+      (scriptInfo) =>
         scriptInfo?.codeHash === script.codeHash &&
-        scriptInfo.hashType === script.hashType
-      ) {
-        return scriptInfo;
-      }
-    });
+        scriptInfo.hashType === script.hashType,
+    );
     return scriptInfo ? ScriptInfo.from(scriptInfo) : undefined;
   }
 }
diff --git a/packages/core/src/client/clientPublicTestnet.ts b/packages/core/src/client/clientPublicTestnet.ts
index 717633f82..49d5cd30b 100644
--- a/packages/core/src/client/clientPublicTestnet.ts
+++ b/packages/core/src/client/clientPublicTestnet.ts
@@ -58,14 +58,11 @@ export class ClientPublicTestnet extends ClientJsonRpc {
     scriptLike: ScriptLike,
   ): Promise<ScriptInfo | undefined> {
     const script = Script.from(scriptLike);
-    const scriptInfo = Object.values(this.scripts).find((scriptInfo) => {
-      if (
+    const scriptInfo = Object.values(this.scripts).find(
+      (scriptInfo) =>
         scriptInfo?.codeHash === script.codeHash &&
-        scriptInfo.hashType === script.hashType
-      ) {
-        return scriptInfo;
-      }
-    });
+        scriptInfo.hashType === script.hashType,
+    );
     return scriptInfo ? ScriptInfo.from(scriptInfo) : undefined;
   }
 }

From 7ab86a8ce55f4055502f2bcf10312f6df4694e83 Mon Sep 17 00:00:00 2001
From: ashuralyk <ashuralyk@live.com>
Date: Thu, 4 Sep 2025 12:32:34 +0800
Subject: [PATCH 7/9] chore: getRelatedScripts adapts to all available scripts

---
 .../signer/ckb/signerCkbMultisigReadonly.ts   | 58 ++++++++++---------
 1 file changed, 30 insertions(+), 28 deletions(-)

diff --git a/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts b/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts
index 4049bb2fd..2c4fe8352 100644
--- a/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts
+++ b/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts
@@ -202,38 +202,40 @@ export class SignerCkbMultisigReadonly extends Signer {
     txLike: TransactionLike,
   ): Promise<{ script: Script; cellDeps: CellDepInfo[] }[]> {
     const tx = Transaction.from(txLike);
-    const multisig = await this.getAddressObjSecp256k1();
+    const availableMultisigs = await this.getAddressObjs();
 
     const scripts: { script: Script; cellDeps: CellDepInfo[] }[] = [];
-    for (const input of tx.inputs) {
-      const {
-        cellOutput: { lock },
-      } = await input.getCell(this.client);
-
-      if (scripts.some(({ script }) => script.eq(lock))) {
-        continue;
-      }
+    for (const multisig of availableMultisigs) {
+      for (const input of tx.inputs) {
+        const {
+          cellOutput: { lock },
+        } = await input.getCell(this.client);
+
+        if (scripts.some(({ script }) => script.eq(lock))) {
+          continue;
+        }
 
-      if (lock.eq(multisig.script)) {
-        const scriptInfo = await this.client.findKnownScript(lock);
-        if (scriptInfo) {
-          scripts.push({
-            script: lock,
-            cellDeps: scriptInfo.cellDeps,
-          });
-        } else {
-          if (typeof this.multisigInfo.knownMultisigScript === "string") {
-            // Generally, this branch could not be reached
-            throw new Error(
-              `Unsupported multisig script: ${this.multisigInfo.knownMultisigScript}`,
-            );
+        if (lock.eq(multisig.script)) {
+          const scriptInfo = await this.client.findKnownScript(lock);
+          if (scriptInfo) {
+            scripts.push({
+              script: lock,
+              cellDeps: scriptInfo.cellDeps,
+            });
+          } else {
+            if (typeof this.multisigInfo.knownMultisigScript === "string") {
+              // Generally, this branch could not be reached
+              throw new Error(
+                `Unsupported multisig script: ${this.multisigInfo.knownMultisigScript}`,
+              );
+            }
+            scripts.push({
+              script: lock,
+              cellDeps: this.multisigInfo.knownMultisigScript.cellDeps.map(
+                (cellDep) => CellDepInfo.from(cellDep),
+              ),
+            });
           }
-          scripts.push({
-            script: lock,
-            cellDeps: this.multisigInfo.knownMultisigScript.cellDeps.map(
-              (cellDep) => CellDepInfo.from(cellDep),
-            ),
-          });
         }
       }
     }

From c01180c2fe800324534f5f348636578233870d09 Mon Sep 17 00:00:00 2001
From: ashuralyk <ashuralyk@live.com>
Date: Thu, 4 Sep 2025 15:47:16 +0800
Subject: [PATCH 8/9] bug: fix circular dependency issue

---
 .../signer/ckb/signerCkbMultisigReadonly.ts   | 24 ++++++++-----------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts b/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts
index 2c4fe8352..b2b52be2b 100644
--- a/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts
+++ b/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts
@@ -17,12 +17,6 @@ import {
 } from "../../index.js";
 import { Signer, SignerSignType, SignerType } from "../signer/index.js";
 
-export const MULTISIG_SCRIPT_DEFAULT = KnownScript.Secp256k1MultisigV2;
-export const MULTISIG_SCRIPTS = [
-  KnownScript.Secp256k1MultisigV2,
-  KnownScript.Secp256k1Multisig,
-];
-
 export type MultisigInfoLike = {
   pubkeys: HexLike[];
   threshold: number;
@@ -45,8 +39,8 @@ export class MultisigInfo {
   public readonly since?: Since;
   public readonly knownMultisigScript:
     | ScriptInfoLike
-    | KnownScript.Secp256k1Multisig
-    | KnownScript.Secp256k1MultisigV2;
+    | KnownScript.Secp256k1MultisigV2
+    | KnownScript.Secp256k1Multisig;
 
   public readonly pubkeyBlake160Hashes: Hex[];
   public readonly metadata: Hex;
@@ -57,13 +51,13 @@ export class MultisigInfo {
     this.mustMatch = multisig.mustMatch;
     this.since = multisig.since ? Since.from(multisig.since) : undefined;
     this.knownMultisigScript =
-      multisig.multisigScript ?? MULTISIG_SCRIPT_DEFAULT;
+      multisig.multisigScript ?? KnownScript.Secp256k1MultisigV2;
     if (
       typeof this.knownMultisigScript === "string" &&
-      this.knownMultisigScript !== MULTISIG_SCRIPT_DEFAULT
+      this.knownMultisigScript !== KnownScript.Secp256k1MultisigV2
     ) {
       console.warn(
-        `Multisig script '${this.knownMultisigScript}' is marked as **Deprecated**, please using '${MULTISIG_SCRIPT_DEFAULT}' instead`,
+        `Multisig script '${this.knownMultisigScript}' is marked as **Deprecated**, please using '${KnownScript.Secp256k1MultisigV2}' instead`,
       );
     }
     if (this.threshold < 0 || this.threshold > 255) {
@@ -128,9 +122,11 @@ export class MultisigInfo {
   async multisigScripts(client: Client): Promise<Script[]> {
     const args = this.multisigScriptArgs();
     const builtInScripts = await Promise.all(
-      MULTISIG_SCRIPTS.map(async (script) => {
-        return await Script.fromKnownScript(client, script, args);
-      }),
+      [KnownScript.Secp256k1MultisigV2, KnownScript.Secp256k1Multisig].map(
+        async (script) => {
+          return await Script.fromKnownScript(client, script, args);
+        },
+      ),
     );
     if (typeof this.knownMultisigScript === "string") {
       return builtInScripts;

From 3ef9c6065d7dae38167370b29c9a549706ac5cb2 Mon Sep 17 00:00:00 2001
From: ashuralyk <ashuralyk@live.com>
Date: Thu, 4 Sep 2025 18:48:37 +0800
Subject: [PATCH 9/9] chore: optimize based on gemini reports

---
 .../signer/ckb/signerCkbMultisigReadonly.ts   | 61 ++++++++++---------
 1 file changed, 31 insertions(+), 30 deletions(-)

diff --git a/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts b/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts
index b2b52be2b..0c7b4a3df 100644
--- a/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts
+++ b/packages/core/src/signer/ckb/signerCkbMultisigReadonly.ts
@@ -198,40 +198,41 @@ export class SignerCkbMultisigReadonly extends Signer {
     txLike: TransactionLike,
   ): Promise<{ script: Script; cellDeps: CellDepInfo[] }[]> {
     const tx = Transaction.from(txLike);
-    const availableMultisigs = await this.getAddressObjs();
+    const multisigs = await this.getAddressObjs();
+    if (multisigs.length === 0) {
+      return [];
+    }
 
     const scripts: { script: Script; cellDeps: CellDepInfo[] }[] = [];
-    for (const multisig of availableMultisigs) {
-      for (const input of tx.inputs) {
-        const {
-          cellOutput: { lock },
-        } = await input.getCell(this.client);
-
-        if (scripts.some(({ script }) => script.eq(lock))) {
-          continue;
-        }
+    for (const input of tx.inputs) {
+      const {
+        cellOutput: { lock },
+      } = await input.getCell(this.client);
+
+      if (scripts.some(({ script }) => script.eq(lock))) {
+        continue;
+      }
 
-        if (lock.eq(multisig.script)) {
-          const scriptInfo = await this.client.findKnownScript(lock);
-          if (scriptInfo) {
-            scripts.push({
-              script: lock,
-              cellDeps: scriptInfo.cellDeps,
-            });
-          } else {
-            if (typeof this.multisigInfo.knownMultisigScript === "string") {
-              // Generally, this branch could not be reached
-              throw new Error(
-                `Unsupported multisig script: ${this.multisigInfo.knownMultisigScript}`,
-              );
-            }
-            scripts.push({
-              script: lock,
-              cellDeps: this.multisigInfo.knownMultisigScript.cellDeps.map(
-                (cellDep) => CellDepInfo.from(cellDep),
-              ),
-            });
+      if (multisigs.some(({ script }) => script.eq(lock))) {
+        const scriptInfo = await this.client.findKnownScript(lock);
+        if (scriptInfo) {
+          scripts.push({
+            script: lock,
+            cellDeps: scriptInfo.cellDeps,
+          });
+        } else {
+          if (typeof this.multisigInfo.knownMultisigScript === "string") {
+            // Generally, this branch could not be reached
+            throw new Error(
+              `Unsupported multisig script: ${this.multisigInfo.knownMultisigScript}`,
+            );
           }
+          scripts.push({
+            script: lock,
+            cellDeps: this.multisigInfo.knownMultisigScript.cellDeps.map(
+              (cellDep) => CellDepInfo.from(cellDep),
+            ),
+          });
         }
       }
     }