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

package/src/codec/cobuild/sporeAction.ts

@@ -1,153 +1,99 @@
-import { blockchain } from "@ckb-lumos/base";
-import { molecule } from "@ckb-lumos/codec";
+import { mol } from "@ckb-ccc/core";
 
-const Hash = blockchain.Byte32;
-
-export const Address = molecule.union(
-  {
-    Script: blockchain.Script,
-  },
-  ["Script"],
-);
+export const Address = mol.union({
+  Script: mol.Script,
+});
 
 /**
  * Spore
  */
-export const CreateSpore = molecule.table(
-  {
-    sporeId: Hash,
-    to: Address,
-    dataHash: Hash,
-  },
-  ["sporeId", "to", "dataHash"],
-);
-export const TransferSpore = molecule.table(
-  {
-    sporeId: Hash,
-    from: Address,
-    to: Address,
-  },
-  ["sporeId", "from", "to"],
-);
-export const MeltSpore = molecule.table(
-  {
-    sporeId: Hash,
-    from: Address,
-  },
-  ["sporeId", "from"],
-);
+export const CreateSpore = mol.table({
+  sporeId: mol.Hash,
+  to: Address,
+  dataHash: mol.Hash,
+});
+export const TransferSpore = mol.table({
+  sporeId: mol.Hash,
+  from: Address,
+  to: Address,
+});
+export const MeltSpore = mol.table({
+  sporeId: mol.Hash,
+  from: Address,
+});
 
 /**
  * Cluster
  */
-export const CreateCluster = molecule.table(
-  {
-    clusterId: Hash,
-    to: Address,
-    dataHash: Hash,
-  },
-  ["clusterId", "to", "dataHash"],
-);
-export const TransferCluster = molecule.table(
-  {
-    clusterId: Hash,
-    from: Address,
-    to: Address,
-  },
-  ["clusterId", "from", "to"],
-);
+export const CreateCluster = mol.table({
+  clusterId: mol.Hash,
+  to: Address,
+  dataHash: mol.Hash,
+});
+export const TransferCluster = mol.table({
+  clusterId: mol.Hash,
+  from: Address,
+  to: Address,
+});
 
 /**
  * ClusterProxy
  */
-export const CreateClusterProxy = molecule.table(
-  {
-    clusterId: Hash,
-    clusterProxyId: Hash,
-    to: Address,
-  },
-  ["clusterId", "clusterProxyId", "to"],
-);
-export const TransferClusterProxy = molecule.table(
-  {
-    clusterId: Hash,
-    clusterProxyId: Hash,
-    from: Address,
-    to: Address,
-  },
-  ["clusterId", "clusterProxyId", "from", "to"],
-);
-export const MeltClusterProxy = molecule.table(
-  {
-    clusterId: Hash,
-    clusterProxyId: Hash,
-    from: Address,
-  },
-  ["clusterId", "clusterProxyId", "from"],
-);
+export const CreateClusterProxy = mol.table({
+  clusterId: mol.Hash,
+  clusterProxyId: mol.Hash,
+  to: Address,
+});
+export const TransferClusterProxy = mol.table({
+  clusterId: mol.Hash,
+  clusterProxyId: mol.Hash,
+  from: Address,
+  to: Address,
+});
+export const MeltClusterProxy = mol.table({
+  clusterId: mol.Hash,
+  clusterProxyId: mol.Hash,
+  from: Address,
+});
 
 /**
  * ClusterAgent
  */
-export const CreateClusterAgent = molecule.table(
-  {
-    clusterId: Hash,
-    clusterProxyId: Hash,
-    to: Address,
-  },
-  ["clusterId", "clusterProxyId", "to"],
-);
-export const TransferClusterAgent = molecule.table(
-  {
-    clusterId: Hash,
-    from: Address,
-    to: Address,
-  },
-  ["clusterId", "from", "to"],
-);
-export const MeltClusterAgent = molecule.table(
-  {
-    clusterId: Hash,
-    from: Address,
-  },
-  ["clusterId", "from"],
-);
+export const CreateClusterAgent = mol.table({
+  clusterId: mol.Hash,
+  clusterProxyId: mol.Hash,
+  to: Address,
+});
+export const TransferClusterAgent = mol.table({
+  clusterId: mol.Hash,
+  from: Address,
+  to: Address,
+});
+export const MeltClusterAgent = mol.table({
+  clusterId: mol.Hash,
+  from: Address,
+});
 
 /**
  * Spore ScriptInfo Actions
  */
-export const SporeAction = molecule.union(
-  {
-    // Spore
-    CreateSpore,
-    TransferSpore,
-    MeltSpore,
+export const SporeAction = mol.union({
+  // Spore
+  CreateSpore,
+  TransferSpore,
+  MeltSpore,
 
-    // Cluster
-    CreateCluster,
-    TransferCluster,
+  // Cluster
+  CreateCluster,
+  TransferCluster,
 
-    // ClusterProxy
-    CreateClusterProxy,
-    TransferClusterProxy,
-    MeltClusterProxy,
+  // ClusterProxy
+  CreateClusterProxy,
+  TransferClusterProxy,
+  MeltClusterProxy,
 
-    // ClusterAgent
-    CreateClusterAgent,
-    TransferClusterAgent,
-    MeltClusterAgent,
-  },
-  [
-    "CreateSpore",
-    "TransferSpore",
-    "MeltSpore",
-    "CreateCluster",
-    "TransferCluster",
-    "CreateClusterProxy",
-    "TransferClusterProxy",
-    "MeltClusterProxy",
-    "CreateClusterAgent",
-    "TransferClusterAgent",
-    "MeltClusterAgent",
-  ],
-);
+  // ClusterAgent
+  CreateClusterAgent,
+  TransferClusterAgent,
+  MeltClusterAgent,
+});

package/src/codec/cobuild/witnessLayout.ts

@@ -1,26 +1,20 @@
-import { blockchain } from "@ckb-lumos/base";
-import { molecule } from "@ckb-lumos/codec";
+import { mol } from "@ckb-ccc/core";
 import { Message } from "./buildingPacket.js";
 
-export const SighashAll = molecule.table(
-  {
-    seal: blockchain.Bytes,
-    message: Message,
-  },
-  ["seal", "message"],
-);
-export const SighashAllOnly = molecule.table(
-  {
-    seal: blockchain.Bytes,
-  },
-  ["seal"],
-);
+export const SighashAll = mol.table({
+  seal: mol.Bytes,
+  message: Message,
+});
+
+export const SighashAllOnly = mol.table({
+  seal: mol.Bytes,
+});
 
 /**
  * Otx related are not implemented yet, so just placeholders.
  */
-export const Otx = molecule.table({}, []);
-export const OtxStart = molecule.table({}, []);
+export const Otx = mol.table({});
+export const OtxStart = mol.table({});
 
 export const WitnessLayoutFieldTags = {
   SighashAll: 4278190081,
@@ -29,7 +23,7 @@ export const WitnessLayoutFieldTags = {
   OtxStart: 4278190084,
 } as const;
 
-export const WitnessLayout = molecule.union(
+export const WitnessLayout = mol.union(
   {
     SighashAll,
     SighashAllOnly,

package/src/codec/spore.ts

@@ -1,36 +1,27 @@
-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 MolSporeData = molecule.table(
-  {
-    contentType: RawString,
-    content: blockchain.Bytes,
-    clusterId: blockchain.BytesOpt,
-  },
-  ["contentType", "content", "clusterId"],
-);
-
-export interface SporeData {
+export interface SporeDataView {
   contentType: string;
   content: ccc.BytesLike;
   clusterId?: ccc.HexLike;
 }
 
-export function packRawSporeData(packable: SporeData): Uint8Array {
-  return MolSporeData.pack({
-    contentType: packable.contentType,
-    content: packable.content,
-    clusterId: packable.clusterId,
-  });
+export const SporeData: mol.Codec<SporeDataView> = mol.table({
+  contentType: mol.String,
+  content: mol.Bytes,
+  clusterId: mol.BytesOpt,
+});
+
+export function packRawSporeData(packable: SporeDataView): Uint8Array {
+  return ccc.bytesFrom(
+    SporeData.encode({
+      contentType: packable.contentType,
+      content: packable.content,
+      clusterId: packable.clusterId,
+    }),
+  );
 }
 
-export function unpackToRawSporeData(unpackable: ccc.BytesLike): SporeData {
-  const unpacked = MolSporeData.unpack(unpackable);
-  return {
-    contentType: unpacked.contentType,
-    content: unpacked.content,
-    clusterId: ccc.apply(ccc.hexFrom, unpacked.clusterId),
-  };
+export function unpackToRawSporeData(unpackable: ccc.BytesLike): SporeDataView {
+  return SporeData.decode(unpackable);
 }

package/src/spore/advanced.ts

@@ -1,17 +1,16 @@
-import { ccc } from "@ckb-ccc/core";
-import { UnpackResult } from "@ckb-lumos/codec";
+import { ccc, mol } from "@ckb-ccc/core";
 import { assembleTransferClusterAction } from "../advanced.js";
 import { assertCluster } from "../cluster/index.js";
-import { Action, SporeData } from "../codec/index.js";
+import { Action, SporeDataView } from "../codec/index.js";
 import { searchOneCellBySigner } from "../helper/index.js";
 
 export async function prepareCluster(
   signer: ccc.Signer,
   tx: ccc.Transaction,
-  data: SporeData,
+  data: SporeDataView,
   clusterMode?: "lockProxy" | "clusterCell" | "skip",
   scriptInfoHash?: ccc.HexLike,
-): Promise<UnpackResult<typeof Action> | undefined> {
+): Promise<mol.EncodableType<typeof Action> | undefined> {
   // skip if the spore is not belong to a cluster
   if (!data.clusterId || clusterMode === "skip") {
     return;

package/src/spore/index.ts

@@ -5,7 +5,7 @@ import {
   assembleTransferSporeAction,
   prepareSporeTransaction,
 } from "../advanced.js";
-import { SporeData, packRawSporeData } from "../codec/index.js";
+import { SporeData, SporeDataView, packRawSporeData } from "../codec/index.js";
 import {
   findSingletonCellByArgs,
   injectOneCapacityCell,
@@ -73,7 +73,7 @@ export async function assertSpore(
  */
 export async function createSpore(params: {
   signer: ccc.Signer;
-  data: SporeData;
+  data: SporeDataView;
   to?: ccc.ScriptLike;
   clusterMode?: "lockProxy" | "clusterCell" | "skip";
   tx?: ccc.TransactionLike;
@@ -234,3 +234,59 @@ export async function meltSpore(params: {
     tx: await prepareSporeTransaction(signer, tx, actions),
   };
 }
+
+/**
+ * Search on-chain spores under the signer's control, if cluster provided, filter spores belonging to this cluster
+ *
+ * @param signer the owner of spores
+ * @param order the order in creation time of spores
+ * @param clusterId the cluster that spores belong to
+ * @param scriptInfos the deployed script infos of spores
+ * @returns speific spore cells
+ */
+export async function* findSporesBySigner(params: {
+  signer: ccc.Signer;
+  order?: "asc" | "desc";
+  clusterId?: ccc.HexLike;
+  scriptInfos?: SporeScriptInfoLike[];
+}): AsyncGenerator<{
+  spore: ccc.Cell;
+  sporeData: SporeDataView;
+}> {
+  const { signer, clusterId, scriptInfos, order } = params;
+  for (const scriptInfo of scriptInfos ??
+    Object.values(getSporeScriptInfos(signer.client))) {
+    if (!scriptInfo) {
+      continue;
+    }
+    for await (const spore of signer.findCells(
+      {
+        script: {
+          ...scriptInfo,
+          args: [],
+        },
+      },
+      true,
+      order,
+      10,
+    )) {
+      try {
+        const sporeData = SporeData.decode(spore.outputData);
+        if (!clusterId) {
+          yield {
+            spore,
+            sporeData,
+          };
+        }
+        if (sporeData.clusterId === clusterId) {
+          return {
+            spore,
+            sporeData,
+          };
+        }
+      } catch (e: unknown) {
+        throw new Error(`Spore data decode failed: ${(e as Error).toString()}`);
+      }
+    }
+  }
+}

package/dist/codec/base.d.ts

@@ -1,6 +0,0 @@
-/**
- * The codec for packing/unpacking UTF-8 raw strings.
- * Should be packed like so: String.pack('something')
- */
-export declare const RawString: import("@ckb-lumos/codec/lib/base").BytesCodec<string, string>;
-//# sourceMappingURL=base.d.ts.map

package/dist/codec/base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/codec/base.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,eAAO,MAAM,SAAS,gEAGpB,CAAC"}

package/dist/codec/base.js

@@ -1,10 +0,0 @@
-import { ccc } from "@ckb-ccc/core";
-import { molecule } from "@ckb-lumos/codec";
-/**
- * The codec for packing/unpacking UTF-8 raw strings.
- * Should be packed like so: String.pack('something')
- */
-export const RawString = molecule.byteVecOf({
-    pack: (packable) => ccc.bytesFrom(packable, "utf8"),
-    unpack: (unpackable) => ccc.bytesTo(unpackable, "utf8"),
-});

package/dist.commonjs/codec/base.d.ts

@@ -1,6 +0,0 @@
-/**
- * The codec for packing/unpacking UTF-8 raw strings.
- * Should be packed like so: String.pack('something')
- */
-export declare const RawString: import("@ckb-lumos/codec/lib/base").BytesCodec<string, string>;
-//# sourceMappingURL=base.d.ts.map

package/dist.commonjs/codec/base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/codec/base.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,eAAO,MAAM,SAAS,gEAGpB,CAAC"}

package/dist.commonjs/codec/base.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RawString = void 0;
-const core_1 = require("@ckb-ccc/core");
-const codec_1 = require("@ckb-lumos/codec");
-/**
- * The codec for packing/unpacking UTF-8 raw strings.
- * Should be packed like so: String.pack('something')
- */
-exports.RawString = codec_1.molecule.byteVecOf({
-    pack: (packable) => core_1.ccc.bytesFrom(packable, "utf8"),
-    unpack: (unpackable) => core_1.ccc.bytesTo(unpackable, "utf8"),
-});

package/src/codec/base.ts

@@ -1,11 +0,0 @@
-import { ccc } from "@ckb-ccc/core";
-import { molecule } from "@ckb-lumos/codec";
-
-/**
- * The codec for packing/unpacking UTF-8 raw strings.
- * Should be packed like so: String.pack('something')
- */
-export const RawString = molecule.byteVecOf({
-  pack: (packable: string) => ccc.bytesFrom(packable, "utf8"),
-  unpack: (unpackable: ccc.BytesLike) => ccc.bytesTo(unpackable, "utf8"),
-});