fix(spore): dedupe lock-proxy outputs and honor empty clusterId

.changeset/fix-spore-lockproxy-and-public-filter.md

@@ -0,0 +1,5 @@
+---
+"@ckb-ccc/spore": patch
+---
+
+fix(spore): restore lock-proxy owner by lock+type+data, keep one owner output per cluster, and treat `clusterId: ""` as public spores only

packages/spore/src/spore/advanced.ts

@@ -3,6 +3,37 @@ import { assembleTransferClusterAction } from "../advanced.js";
 import { assertCluster } from "../cluster/index.js";
 import { Action, SporeDataView } from "../codec/index.js";
 
+const restoredLockProxyInputs = new WeakMap<ccc.CellInput, true>();
+const restoredLockProxyOutPoints = new WeakMap<ccc.Transaction, Set<string>>();
+
+function lockProxyOutPointKey(outPoint: ccc.OutPoint): string {
+  return `${outPoint.txHash}:${outPoint.index.toString()}`;
+}
+
+function hasRestoredLockProxy(
+  tx: ccc.Transaction,
+  input: ccc.CellInput,
+): boolean {
+  if (restoredLockProxyInputs.has(input)) {
+    return true;
+  }
+  return (
+    restoredLockProxyOutPoints
+      .get(tx)
+      ?.has(lockProxyOutPointKey(input.previousOutput)) === true
+  );
+}
+
+function markRestoredLockProxy(
+  tx: ccc.Transaction,
+  input: ccc.CellInput,
+): void {
+  restoredLockProxyInputs.set(input, true);
+  const restored = restoredLockProxyOutPoints.get(tx) ?? new Set<string>();
+  restored.add(lockProxyOutPointKey(input.previousOutput));
+  restoredLockProxyOutPoints.set(tx, restored);
+}
+
 export async function prepareCluster(
   signer: ccc.Signer,
   tx: ccc.Transaction,
@@ -47,11 +78,14 @@ export async function prepareCluster(
         }
       }
 
-      // Add the output only if there's not already one with proxy lock
-      if (!tx.outputs.some((output) => output.lock === lock)) {
-        tx.addOutput(
-          await tx.getInput(lockProxyInputIndex)!.getCell(signer.client),
-        );
+      // Restore this selected proxy input, not an arbitrary owner-locked
+      // output. A same-lock payment or Spore (even with the same type, data,
+      // and capacity) is independent and must not skip the restore. Track the
+      // input/outPoint so a second spore of this cluster reuses that restore.
+      const proxyInput = tx.getInput(lockProxyInputIndex)!;
+      if (!hasRestoredLockProxy(tx, proxyInput)) {
+        tx.addOutput(await proxyInput.getCell(signer.client));
+        markRestoredLockProxy(tx, proxyInput);
       }
 
       tx.addCellDeps({

packages/spore/src/spore/index.ts

@@ -246,6 +246,23 @@ export async function meltSpore(params: {
   };
 }
 
+/** `undefined` matches every spore. `""` matches spores with no cluster id. */
+function matchClusterFilter(
+  sporeClusterId: ccc.HexLike | undefined,
+  clusterId: ccc.HexLike | undefined,
+): boolean {
+  // No filter: every spore matches.
+  if (clusterId === undefined) {
+    return true;
+  }
+  // `""` keeps public spores only. Do not pass `""` to `hexFrom`.
+  if (clusterId === "" || !sporeClusterId) {
+    return clusterId === "" && !sporeClusterId;
+  }
+  // Any other cluster id is compared as hex.
+  return ccc.hexFrom(sporeClusterId) === ccc.hexFrom(clusterId);
+}
+
 /**
  * Search on-chain spores under the signer's control, if cluster provided, filter spores belonging to this cluster
  *
@@ -285,11 +302,7 @@ export async function* findSporesBySigner(params: {
       limit,
     )) {
       const sporeData = unpackToRawSporeData(spore.outputData);
-      if (
-        !clusterId ||
-        (clusterId === "" && !sporeData.clusterId) ||
-        sporeData.clusterId === ccc.hexFrom(clusterId)
-      ) {
+      if (matchClusterFilter(sporeData.clusterId, clusterId)) {
         yield {
           cell: spore,
           spore,
@@ -350,11 +363,7 @@ export async function* findSpores(params: {
       limit,
     )) {
       const sporeData = unpackToRawSporeData(spore.outputData);
-      if (
-        !clusterId ||
-        (clusterId === "" && !sporeData.clusterId) ||
-        sporeData.clusterId === ccc.hexFrom(clusterId)
-      ) {
+      if (matchClusterFilter(sporeData.clusterId, clusterId)) {
         yield {
           cell: spore,
           spore,

packages/spore/src/spore/lockProxy.test.ts

@@ -0,0 +1,197 @@
+import { ccc } from "@ckb-ccc/core";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { packRawClusterData } from "../codec/cluster.js";
+import {
+  getClusterScriptInfo,
+  getSporeScriptInfo,
+} from "../predefined/index.js";
+import { prepareCluster } from "./advanced.js";
+import { createSpore } from "./index.js";
+
+const lock = {
+  codeHash: `0x${"00".repeat(32)}`,
+  hashType: "type",
+  args: "0x",
+} as const;
+const payerLock = {
+  codeHash: `0x${"00".repeat(32)}`,
+  hashType: "type",
+  args: "0x01",
+} as const;
+const clusterId = `0x${"66".repeat(32)}`;
+const ownerType = {
+  codeHash: `0x${"11".repeat(32)}`,
+  hashType: "type",
+  args: `0x${"22".repeat(32)}`,
+} as const;
+const ownerData = "0xabcd";
+
+function offlineTestnet(): ccc.ClientPublicTestnet {
+  const client = ccc.ClientPublicTestnet.new({
+    cache: new ccc.ClientCacheMemory(),
+    transport: {
+      request: async () => {
+        throw new Error("Unexpected request");
+      },
+    },
+  });
+  // Search the cells marked usable below. Do not ask a node.
+  vi.spyOn(client, "findCellsOnChain").mockImplementation(
+    async function* () {},
+  );
+  return client;
+}
+
+async function cacheCluster(client: ccc.ClientPublicTestnet): Promise<void> {
+  await client.cache.markUsable({
+    outPoint: { txHash: `0x${"77".repeat(32)}`, index: 0 },
+    cellOutput: {
+      lock,
+      type: { ...getClusterScriptInfo(client), args: clusterId },
+    },
+    outputData: packRawClusterData({ name: "", description: "" }),
+  });
+}
+
+function matchingOutputs(
+  tx: ccc.Transaction,
+  type: ccc.ScriptLike | undefined,
+  outputData: ccc.HexLike,
+): ccc.CellAny[] {
+  const typeScript = type ? ccc.Script.from(type) : undefined;
+  const data = ccc.hexFrom(outputData);
+  return [...tx.outputCells].filter((output) => {
+    const sameType = typeScript
+      ? output.cellOutput.type?.eq(typeScript) === true
+      : !output.cellOutput.type;
+    return (
+      output.cellOutput.lock.eq(lock) && sameType && output.outputData === data
+    );
+  });
+}
+
+describe("prepareCluster lockProxy", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("adds one cluster-owner output when two spores share a cluster", async () => {
+    const client = offlineTestnet();
+    await cacheCluster(client);
+    const tx = ccc.Transaction.from({
+      inputs: [
+        {
+          previousOutput: { txHash: `0x${"88".repeat(32)}`, index: 0 },
+          cellOutput: { capacity: 0, lock },
+          outputData: "0x",
+        },
+      ],
+    });
+    const signer = new ccc.SignerCkbScriptReadonly(client, lock);
+    const spore = { contentType: "", content: "0x", clusterId };
+
+    await prepareCluster(signer, tx, spore, "lockProxy");
+    expect(tx.inputs).toHaveLength(1);
+    expect(tx.outputs).toHaveLength(1);
+
+    await prepareCluster(signer, tx, spore, "lockProxy");
+
+    expect(tx.inputs).toHaveLength(1);
+    expect(tx.outputs).toHaveLength(1);
+    expect(matchingOutputs(tx, undefined, "0x")).toHaveLength(1);
+  });
+
+  it("restores a typed owner input when createSpore mints to the cluster owner", async () => {
+    const client = offlineTestnet();
+    await cacheCluster(client);
+    const ownerCapacity = ccc.fixedPointFrom(200);
+    const tx = ccc.Transaction.from({
+      inputs: [
+        {
+          previousOutput: { txHash: `0x${"99".repeat(32)}`, index: 0 },
+          cellOutput: { capacity: ownerCapacity, lock, type: ownerType },
+          outputData: ownerData,
+        },
+      ],
+    });
+    const signer = new ccc.SignerCkbScriptReadonly(client, lock);
+    const spore = { contentType: "", content: "0x", clusterId };
+    const createParams = {
+      signer,
+      data: spore,
+      to: lock,
+      clusterMode: "lockProxy" as const,
+    };
+
+    const { tx: created } = await createSpore({ ...createParams, tx });
+    const { tx: createdTwice } = await createSpore({
+      ...createParams,
+      tx: created,
+    });
+
+    const sporeType = {
+      ...getSporeScriptInfo(client),
+      args: createdTwice.outputs[0].type!.args,
+    };
+    expect(
+      matchingOutputs(createdTwice, sporeType, createdTwice.outputsData[0]),
+    ).toHaveLength(1);
+    const ownerOutputs = matchingOutputs(createdTwice, ownerType, ownerData);
+    expect(ownerOutputs).toHaveLength(1);
+    expect(ownerOutputs[0].cellOutput.capacity).toBe(ownerCapacity);
+  });
+
+  it.each([
+    { label: "a smaller", paymentCkb: 61 },
+    { label: "an equal", paymentCkb: 1000 },
+  ])(
+    "restores the proxy input in addition to $label owner payment",
+    async ({ paymentCkb }) => {
+      const client = offlineTestnet();
+      await cacheCluster(client);
+      const paymentCapacity = ccc.fixedPointFrom(paymentCkb);
+      const proxyCapacity = ccc.fixedPointFrom(1000);
+      const tx = ccc.Transaction.from({
+        inputs: [
+          {
+            previousOutput: { txHash: `0x${"aa".repeat(32)}`, index: 0 },
+            cellOutput: { capacity: proxyCapacity, lock },
+            outputData: "0x",
+          },
+          {
+            previousOutput: { txHash: `0x${"bb".repeat(32)}`, index: 0 },
+            cellOutput: {
+              capacity: ccc.fixedPointFrom(2000),
+              lock: payerLock,
+            },
+            outputData: "0x",
+          },
+        ],
+        outputs: [{ capacity: paymentCapacity, lock }],
+        outputsData: ["0x"],
+      });
+      const signer = new ccc.SignerCkbScriptReadonly(client, payerLock);
+      const spore = { contentType: "", content: "0x", clusterId };
+      const createParams = {
+        signer,
+        data: spore,
+        clusterMode: "lockProxy" as const,
+      };
+
+      const { tx: created } = await createSpore({ ...createParams, tx });
+      const { tx: createdTwice } = await createSpore({
+        ...createParams,
+        tx: created,
+      });
+      await createdTwice.completeFeeBy(signer, 1000n);
+
+      const ownerUntyped = createdTwice.outputs.filter(
+        (output) => output.lock.eq(lock) && !output.type,
+      );
+      expect(ownerUntyped).toHaveLength(2);
+      expect(
+        ownerUntyped.reduce((sum, output) => sum + output.capacity, 0n),
+      ).toBe(paymentCapacity + proxyCapacity);
+    },
+  );
+});