@ckb-ccc/spore 0.1.0-alpha.4 → 0.1.0

package/src/cluster/index.ts

@@ -4,7 +4,12 @@ import {
   assembleTransferClusterAction,
   prepareSporeTransaction,
 } from "../advanced.js";
-import { ClusterData, packRawClusterData } from "../codec/index.js";
+import {
+  ClusterData,
+  ClusterDataV1,
+  ClusterDataView,
+  packRawClusterData,
+} from "../codec/index.js";
 import {
   findSingletonCellByArgs,
   injectOneCapacityCell,
@@ -66,7 +71,7 @@ export async function assertCluster(
  */
 export async function createSporeCluster(params: {
   signer: ccc.Signer;
-  data: ClusterData;
+  data: ClusterDataView;
   to?: ccc.ScriptLike;
   tx?: ccc.TransactionLike;
   scriptInfo?: SporeScriptInfoLike;
@@ -178,3 +183,55 @@ export async function transferSporeCluster(params: {
     tx: await prepareSporeTransaction(signer, tx, actions),
   };
 }
+
+/**
+ * Search on-chain clusters under the signer's control
+ *
+ * @param signer the owner of clusters
+ * @param order the order in creation time of clusters
+ * @param scriptInfos the deployed script infos of clusters
+ */
+export async function* findSporeClustersBySigner(params: {
+  signer: ccc.Signer;
+  order?: "asc" | "desc";
+  scriptInfos?: SporeScriptInfoLike[];
+}): AsyncGenerator<{
+  cluster: ccc.Cell;
+  clusterData: ClusterDataView;
+}> {
+  const { signer, order, scriptInfos } = params;
+  for (const scriptInfo of scriptInfos ??
+    Object.values(getClusterScriptInfos(signer.client))) {
+    if (!scriptInfo) {
+      continue;
+    }
+    for await (const cluster of signer.findCells(
+      {
+        script: {
+          ...scriptInfo,
+          args: [],
+        },
+      },
+      true,
+      order,
+      10,
+    )) {
+      let clusterData: ClusterDataView;
+      try {
+        clusterData = ClusterData.decode(cluster.outputData);
+      } catch (_) {
+        try {
+          clusterData = ClusterDataV1.decode(cluster.outputData);
+        } catch (e: unknown) {
+          throw new Error(
+            `Cluster data decode failed: ${(e as Error).toString()}`,
+          );
+        }
+      }
+      yield {
+        cluster,
+        clusterData,
+      };
+    }
+  }
+}

package/src/cobuild/index.ts

@@ -1,5 +1,4 @@
-import { ccc } from "@ckb-ccc/core";
-import { UnpackResult } from "@ckb-lumos/codec";
+import { ccc, mol } from "@ckb-ccc/core";
 import {
   Action,
   ActionVec,
@@ -12,21 +11,21 @@ export function assembleCreateSporeAction(
   sporeOutput: ccc.CellOutputLike,
   sporeData: ccc.BytesLike,
   scriptInfoHash: ccc.HexLike = DEFAULT_COBUILD_INFO_HASH,
-): UnpackResult<typeof Action> {
+): mol.EncodableType<typeof Action> {
   if (!sporeOutput.type) {
     throw new Error("Spore cell must have a type script");
   }
   const sporeType = ccc.Script.from(sporeOutput.type);
   const sporeTypeHash = sporeType.hash();
-  const actionData = SporeAction.pack({
+  const actionData = SporeAction.encode({
     type: "CreateSpore",
     value: {
       sporeId: sporeType.args,
-      dataHash: ccc.hashCkb(sporeData),
       to: {
         type: "Script",
-        value: ccc.Script.from(sporeOutput.lock),
+        value: sporeOutput.lock,
       },
+      dataHash: ccc.hashCkb(sporeData),
     },
   });
   return {
@@ -40,24 +39,24 @@ export function assembleTransferSporeAction(
   sporeInput: ccc.CellOutputLike,
   sporeOutput: ccc.CellOutputLike,
   scriptInfoHash: ccc.HexLike = DEFAULT_COBUILD_INFO_HASH,
-): UnpackResult<typeof Action> {
+): mol.EncodableType<typeof Action> {
   if (!sporeInput.type || !sporeOutput.type) {
     throw new Error("Spore cell must have a type script");
   }
 
   const sporeType = ccc.Script.from(sporeOutput.type);
   const sporeTypeHash = sporeType.hash();
-  const actionData = SporeAction.pack({
+  const actionData = SporeAction.encode({
     type: "TransferSpore",
     value: {
       sporeId: sporeType.args,
       from: {
         type: "Script",
-        value: ccc.Script.from(sporeInput.lock),
+        value: sporeInput.lock,
       },
       to: {
         type: "Script",
-        value: ccc.Script.from(sporeOutput.lock),
+        value: sporeOutput.lock,
       },
     },
   });
@@ -71,19 +70,19 @@ export function assembleTransferSporeAction(
 export function assembleMeltSporeAction(
   sporeInput: ccc.CellOutputLike,
   scriptInfoHash: ccc.HexLike = DEFAULT_COBUILD_INFO_HASH,
-): UnpackResult<typeof Action> {
+): mol.EncodableType<typeof Action> {
   if (!sporeInput.type) {
     throw new Error("Spore cell must have a type script");
   }
   const sporeType = ccc.Script.from(sporeInput.type);
   const sporeTypeHash = sporeType.hash();
-  const actionData = SporeAction.pack({
+  const actionData = SporeAction.encode({
     type: "MeltSpore",
     value: {
       sporeId: sporeType.args,
       from: {
         type: "Script",
-        value: ccc.Script.from(sporeInput.lock),
+        value: sporeInput.lock,
       },
     },
   });
@@ -98,21 +97,21 @@ export function assembleCreateClusterAction(
   clusterOutput: ccc.CellOutputLike,
   clusterData: ccc.BytesLike,
   scriptInfoHash: ccc.HexLike = DEFAULT_COBUILD_INFO_HASH,
-): UnpackResult<typeof Action> {
+): mol.EncodableType<typeof Action> {
   if (!clusterOutput.type) {
     throw new Error("Cluster cell must have a type script");
   }
   const clusterType = ccc.Script.from(clusterOutput.type);
   const clusterTypeHash = clusterType.hash();
-  const actionData = SporeAction.pack({
+  const actionData = SporeAction.encode({
     type: "CreateCluster",
     value: {
       clusterId: clusterType.args,
-      dataHash: ccc.hashCkb(clusterData),
       to: {
         type: "Script",
-        value: ccc.Script.from(clusterOutput.lock),
+        value: clusterOutput.lock,
       },
+      dataHash: ccc.hashCkb(clusterData),
     },
   });
   return {
@@ -126,23 +125,23 @@ export function assembleTransferClusterAction(
   clusterInput: ccc.CellOutputLike,
   clusterOutput: ccc.CellOutputLike,
   scriptInfoHash: ccc.HexLike = DEFAULT_COBUILD_INFO_HASH,
-): UnpackResult<typeof Action> {
+): mol.EncodableType<typeof Action> {
   if (!clusterInput.type || !clusterOutput.type) {
     throw new Error("Cluster cell must have a type script");
   }
   const clusterType = ccc.Script.from(clusterOutput.type);
   const clusterTypeHash = clusterType.hash();
-  const actionData = SporeAction.pack({
+  const actionData = SporeAction.encode({
     type: "TransferCluster",
     value: {
       clusterId: clusterType.args,
       from: {
         type: "Script",
-        value: ccc.Script.from(clusterInput.lock),
+        value: clusterInput.lock,
       },
       to: {
         type: "Script",
-        value: ccc.Script.from(clusterOutput.lock),
+        value: clusterOutput.lock,
       },
     },
   });
@@ -156,7 +155,7 @@ export function assembleTransferClusterAction(
 export async function prepareSporeTransaction(
   signer: ccc.Signer,
   txLike: ccc.TransactionLike,
-  actions: UnpackResult<typeof ActionVec>,
+  actions: mol.EncodableType<typeof ActionVec>,
 ): Promise<ccc.Transaction> {
   let tx = ccc.Transaction.from(txLike);
 
@@ -172,9 +171,9 @@ export async function prepareSporeTransaction(
 
 export function unpackCommonCobuildProof(
   data: ccc.HexLike,
-): UnpackResult<typeof WitnessLayout> | undefined {
+): mol.EncodableType<typeof WitnessLayout> | undefined {
   try {
-    return WitnessLayout.unpack(ccc.bytesFrom(data));
+    return WitnessLayout.decode(ccc.bytesFrom(data));
   } catch {
     return;
   }
@@ -182,7 +181,7 @@ export function unpackCommonCobuildProof(
 
 export function extractCobuildActionsFromTx(
   tx: ccc.Transaction,
-): UnpackResult<typeof ActionVec> {
+): mol.EncodableType<typeof ActionVec> {
   if (tx.witnesses.length === 0) {
     return [];
   }
@@ -193,7 +192,7 @@ export function extractCobuildActionsFromTx(
     return [];
   }
   if (witnessLayout.type !== "SighashAll") {
-    throw new Error("Invalid cobuild proof type: " + witnessLayout.type);
+    throw new Error("Invalid cobuild proof type: SighashAll");
   }
 
   // Remove existed cobuild witness
@@ -203,10 +202,10 @@ export function extractCobuildActionsFromTx(
 
 export function injectCobuild(
   tx: ccc.Transaction,
-  actions: UnpackResult<typeof ActionVec>,
+  actions: mol.EncodableType<typeof ActionVec>,
 ): void {
   const witnessLayout = ccc.hexFrom(
-    WitnessLayout.pack({
+    WitnessLayout.encode({
       type: "SighashAll",
       value: {
         seal: "0x",

package/src/codec/cluster.ts

@@ -1,58 +1,53 @@
-import { ccc } from "@ckb-ccc/core";
-import { blockchain } from "@ckb-lumos/base";
-import { molecule } from "@ckb-lumos/codec";
-import { RawString } from "./base.js";
+import { ccc, mol } from "@ckb-ccc/core";
 
-export const MolClusterDataV1 = molecule.table(
-  {
-    name: RawString,
-    description: RawString,
-  },
-  ["name", "description"],
-);
-export const MolClusterDataV2 = molecule.table(
-  {
-    name: RawString,
-    description: RawString,
-    mutantId: blockchain.BytesOpt,
-  },
-  ["name", "description", "mutantId"],
-);
-
-export interface ClusterDataV1 {
+export interface ClusterDataV1View {
   name: string;
   description: string;
 }
-export interface ClusterDataV2 {
+
+export const ClusterDataV1: mol.Codec<ClusterDataV1View> = mol.table({
+  name: mol.String,
+  description: mol.String,
+});
+
+export interface ClusterDataV2View {
   name: string;
   description: string;
   mutantId?: ccc.HexLike;
 }
-export type ClusterData = ClusterDataV2;
+
+export const ClusterDataV2: mol.Codec<ClusterDataV2View> = mol.table({
+  name: mol.String,
+  description: mol.String,
+  mutantId: mol.BytesOpt,
+});
+
+export type ClusterDataView = ClusterDataV2View;
 
 export type ClusterDataVersion = "v1" | "v2";
 
+export const ClusterData = ClusterDataV2;
+
 /**
  * Pack RawClusterData to Uint8Array.
  * Pass an optional "version" field to select a specific packing version.
  */
-export function packRawClusterData(packable: ClusterData): Uint8Array;
+export function packRawClusterData(packable: ClusterDataView): Uint8Array;
 export function packRawClusterData(
-  packable: ClusterDataV1,
+  packable: ClusterDataV1View,
   version: "v1",
 ): Uint8Array;
 export function packRawClusterData(
-  packable: ClusterDataV2,
+  packable: ClusterDataV2View,
   version: "v2",
 ): Uint8Array;
 export function packRawClusterData(
-  packable: ClusterDataV1 | ClusterDataV2,
+  packable: ClusterDataV1View | ClusterDataV2View,
   version?: ClusterDataVersion,
 ): Uint8Array {
   if (!version) {
     return packRawClusterDataV2(packable);
   }
-
   switch (version) {
     case "v1":
       return packRawClusterDataV1(packable);
@@ -60,33 +55,41 @@ export function packRawClusterData(
       return packRawClusterDataV2(packable);
   }
 }
-export function packRawClusterDataV1(packable: ClusterDataV1): Uint8Array {
-  return MolClusterDataV1.pack({
-    name: packable.name,
-    description: packable.description,
-  });
+
+export function packRawClusterDataV1(packable: ClusterDataV1View): Uint8Array {
+  return ccc.bytesFrom(
+    ClusterDataV1.encode({
+      name: packable.name,
+      description: packable.description,
+    }),
+  );
 }
-export function packRawClusterDataV2(packable: ClusterDataV2): Uint8Array {
-  return MolClusterDataV2.pack({
-    name: packable.name,
-    description: packable.description,
-    mutantId: packable.mutantId,
-  });
+
+export function packRawClusterDataV2(packable: ClusterDataV2View): Uint8Array {
+  return ccc.bytesFrom(
+    ClusterDataV2.encode({
+      name: packable.name,
+      description: packable.description,
+      mutantId: packable.mutantId,
+    }),
+  );
 }
 
 /**
  * Unpack Hex/Bytes to RawClusterData.
  * Pass an optional "version" field to select a specific unpacking version.
  */
-export function unpackToRawClusterData(unpackable: ccc.BytesLike): ClusterData;
+export function unpackToRawClusterData(
+  unpackable: ccc.BytesLike,
+): ClusterDataView;
 export function unpackToRawClusterData(
   unpackable: ccc.BytesLike,
   version: "v1",
-): ClusterDataV1;
+): ClusterDataV1View;
 export function unpackToRawClusterData(
   unpackable: ccc.BytesLike,
   version: "v2",
-): ClusterDataV2;
+): ClusterDataV2View;
 export function unpackToRawClusterData(
   unpackable: ccc.BytesLike,
   version?: ClusterDataVersion,
@@ -99,7 +102,6 @@ export function unpackToRawClusterData(
         return unpackToRawClusterDataV2(unpackable);
     }
   }
-
   try {
     return unpackToRawClusterDataV2(unpackable);
   } catch {
@@ -112,22 +114,15 @@ export function unpackToRawClusterData(
     }
   }
 }
+
 export function unpackToRawClusterDataV1(
   unpackable: ccc.BytesLike,
-): ClusterDataV1 {
-  const decoded = MolClusterDataV1.unpack(unpackable);
-  return {
-    name: decoded.name,
-    description: decoded.description,
-  };
+): ClusterDataV1View {
+  return ClusterDataV1.decode(unpackable);
 }
+
 export function unpackToRawClusterDataV2(
   unpackable: ccc.BytesLike,
-): ClusterDataV2 {
-  const decoded = MolClusterDataV2.unpack(unpackable);
-  return {
-    name: decoded.name,
-    description: decoded.description,
-    mutantId: ccc.apply(ccc.hexFrom, decoded.mutantId),
-  };
+): ClusterDataV2View {
+  return ClusterDataV2.decode(unpackable);
 }

package/src/codec/cobuild/buildingPacket.ts

@@ -1,72 +1,41 @@
-import { blockchain } from "@ckb-lumos/base";
-import { molecule, number } from "@ckb-lumos/codec";
-import { RawString } from "../base.js";
-
-const Uint32Opt = molecule.option(number.Uint32LE);
-
-const Hash = blockchain.Byte32;
-
-export const Action = molecule.table(
-  {
-    scriptInfoHash: Hash,
-    scriptHash: Hash,
-    data: blockchain.Bytes,
-  },
-  ["scriptInfoHash", "scriptHash", "data"],
-);
-
-export const ActionVec = molecule.vector(Action);
-
-export const Message = molecule.table(
-  {
-    actions: ActionVec,
-  },
-  ["actions"],
-);
-
-export const ResolvedInputs = molecule.table(
-  {
-    outputs: blockchain.CellOutputVec,
-    outputsData: blockchain.BytesVec,
-  },
-  ["outputs", "outputsData"],
-);
-
-export const ScriptInfo = molecule.table(
-  {
-    name: RawString,
-    url: RawString,
-    scriptHash: Hash,
-    schema: RawString,
-    messageType: RawString,
-  },
-  ["name", "url", "scriptHash", "schema", "messageType"],
-);
-
-export const ScriptInfoVec = molecule.vector(ScriptInfo);
-
-export const BuildingPacketV1 = molecule.table(
-  {
-    message: Message,
-    payload: blockchain.Transaction,
-    resolvedInputs: ResolvedInputs,
-    changeOutput: Uint32Opt,
-    scriptInfos: ScriptInfoVec,
-    lockActions: ActionVec,
-  },
-  [
-    "message",
-    "payload",
-    "resolvedInputs",
-    "changeOutput",
-    "scriptInfos",
-    "lockActions",
-  ],
-);
-
-export const BuildingPacket = molecule.union(
-  {
-    BuildingPacketV1,
-  },
-  ["BuildingPacketV1"],
-);
+import { mol } from "@ckb-ccc/core";
+
+export const Action = mol.table({
+  scriptInfoHash: mol.Hash,
+  scriptHash: mol.Hash,
+  data: mol.Bytes,
+});
+
+export const ActionVec = mol.vector(Action);
+
+export const Message = mol.table({
+  actions: ActionVec,
+});
+
+export const ResolvedInputs = mol.table({
+  outputs: mol.CellOutputVec,
+  outputsData: mol.BytesVec,
+});
+
+export const ScriptInfo = mol.table({
+  name: mol.String,
+  url: mol.String,
+  scriptHash: mol.Hash,
+  schema: mol.String,
+  messageType: mol.String,
+});
+
+export const ScriptInfoVec = mol.vector(ScriptInfo);
+
+export const BuildingPacketV1 = mol.table({
+  message: Message,
+  payload: mol.Transaction,
+  resolvedInputs: ResolvedInputs,
+  changeOutput: mol.Uint32Opt,
+  scriptInfos: ScriptInfoVec,
+  lockActions: ActionVec,
+});
+
+export const BuildingPacket = mol.union({
+  BuildingPacketV1,
+});