@ckb-ccc/core 0.0.5-alpha.8 → 0.0.7-alpha.0

package/src/client/advanced.ts

@@ -1,3 +1,5 @@
+export * from "./client.advanced";
 export * from "./clientPublicMainnet.advanced";
 export * from "./clientPublicTestnet.advanced";
+export * from "./clientTypes.advanced";
 export * from "./jsonRpc/advanced";

package/src/client/client.advanced.ts

@@ -0,0 +1,134 @@
+import { bytesFrom } from "../bytes";
+import { Cell, CellLike, Script, ScriptLike } from "../ckb";
+import { HexLike, hexFrom } from "../hex";
+import { NumLike, numFrom } from "../num";
+import { ClientIndexerSearchKey } from "./clientTypes";
+import {
+  ClientCollectableSearchKeyLike,
+  clientSearchKeyRangeFrom,
+} from "./clientTypes.advanced";
+
+export function filterData(
+  dataLike: HexLike,
+  filterLike: HexLike | undefined,
+  filterMode: "exact" | "prefix" | "partial",
+): boolean {
+  if (!filterLike) {
+    return true;
+  }
+
+  const data = hexFrom(dataLike);
+  const filter = hexFrom(filterLike);
+  if (
+    (filterMode === "exact" && data !== filter) ||
+    (filterMode === "prefix" && !data.startsWith(filter)) ||
+    (filterMode === "partial" && data.search(filter) === -1)
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
+export function filterScript(
+  valueLike: ScriptLike | undefined,
+  filterLike: ScriptLike | undefined,
+  filterMode: "prefix" | "exact" | "partial",
+): boolean {
+  if (!filterLike) {
+    return true;
+  }
+  if (!valueLike) {
+    return false;
+  }
+
+  const value = Script.from(valueLike);
+  const filter = Script.from(filterLike);
+  if (
+    value.codeHash !== filter.codeHash ||
+    value.hashType !== filter.hashType
+  ) {
+    return false;
+  }
+
+  return filterData(value.args, filter?.args, filterMode);
+}
+
+export function filterNumByRange(
+  lengthLike: NumLike,
+  range: [NumLike, NumLike] | undefined,
+) {
+  if (!range) {
+    return true;
+  }
+  const length = numFrom(lengthLike);
+  const [lower, upper] = clientSearchKeyRangeFrom(range);
+
+  return lower <= length && length < upper;
+}
+
+export function filterScriptByLenRange(
+  valueLike?: ScriptLike,
+  scriptLenRange?: [NumLike, NumLike],
+): boolean {
+  if (!scriptLenRange) {
+    return true;
+  }
+
+  const len = (() => {
+    if (!valueLike) {
+      return 0;
+    }
+    return bytesFrom(Script.from(valueLike).args).length + 33;
+  })();
+  return filterNumByRange(len, scriptLenRange);
+}
+
+export function filterCell(
+  searchKeyLike: ClientCollectableSearchKeyLike,
+  cellLike: CellLike,
+): boolean {
+  const key = ClientIndexerSearchKey.from(searchKeyLike);
+  const cell = Cell.from(cellLike);
+
+  if (key.scriptType === "lock") {
+    if (
+      !filterScript(cell.cellOutput.lock, key.script, key.scriptSearchMode) ||
+      !filterScript(cell.cellOutput.type, key.filter?.script, "prefix") ||
+      !filterScriptByLenRange(cell.cellOutput.type, key.filter?.scriptLenRange)
+    ) {
+      return false;
+    }
+  }
+  if (key.scriptType === "type") {
+    if (
+      !filterScript(cell.cellOutput.type, key.script, key.scriptSearchMode) ||
+      !filterScript(cell.cellOutput.lock, key.filter?.script, "prefix") ||
+      !filterScriptByLenRange(cell.cellOutput.lock, key.filter?.scriptLenRange)
+    ) {
+      return false;
+    }
+  }
+
+  if (
+    !filterData(
+      cell.outputData,
+      key.filter?.outputData,
+      key.filter?.outputDataSearchMode ?? "prefix",
+    ) ||
+    !filterNumByRange(
+      bytesFrom(cell.outputData).length,
+      key.filter?.outputDataLenRange,
+    )
+  ) {
+    return false;
+  }
+
+  if (
+    !filterNumByRange(cell.cellOutput.capacity, key.filter?.outputCapacityRange)
+  ) {
+    return false;
+  }
+
+  return true;
+}

package/src/client/client.ts

@@ -1,47 +1,115 @@
 import {
   Cell,
+  CellDep,
+  CellDepLike,
+  CellLike,
+  OutPoint,
   OutPointLike,
   Script,
   ScriptLike,
+  Transaction,
   TransactionLike,
 } from "../ckb";
 import { Zero } from "../fixedPoint";
-import { Hex, HexLike } from "../hex";
+import { Hex, HexLike, hexFrom } from "../hex";
 import { Num, NumLike, numFrom } from "../num";
+import { apply, reduceAsync } from "../utils";
+import { filterCell } from "./client.advanced";
 import {
   ClientFindCellsResponse,
+  ClientIndexerSearchKey,
   ClientIndexerSearchKeyLike,
   ClientTransactionResponse,
   OutputsValidator,
 } from "./clientTypes";
+import { ClientCollectableSearchKeyLike } from "./clientTypes.advanced";
 
 export enum KnownScript {
-  Secp256k1Blake160,
-  Secp256k1Multisig,
-  AnyoneCanPay,
-  JoyId,
-  COTA,
-  OmniLock,
+  Secp256k1Blake160 = "Secp256k1Blake160",
+  Secp256k1Multisig = "Secp256k1Multisig",
+  AnyoneCanPay = "AnyoneCanPay",
+  TypeId = "TypeId",
+  XUdt = "XUdt",
+  JoyId = "JoyId",
+  COTA = "COTA",
+  OmniLock = "OmniLock",
+  NostrLock = "NostrLock",
+  SingleUseLock = "SingleUseLock",
+  OutputTypeProxyLock = "OutputTypeProxyLock",
+}
+
+export type CellDepInfoLike = {
+  cellDep: CellDepLike;
+  type?: ScriptLike;
+};
+
+export class CellDepInfo {
+  constructor(
+    public cellDep: CellDep,
+    public type?: Script,
+  ) {}
+
+  static from(cellDepInfoLike: CellDepInfoLike): CellDepInfo {
+    return new CellDepInfo(
+      CellDep.from(cellDepInfoLike.cellDep),
+      apply(Script.from, cellDepInfoLike.type),
+    );
+  }
 }
 
 export abstract class Client {
+  private readonly cachedTransactions: Transaction[] = [];
+  private readonly unusableOutPoints: OutPoint[] = [];
+  private readonly usableCells: Cell[] = [];
+  private readonly knownCells: Cell[] = [];
+
   abstract get url(): string;
   abstract get addressPrefix(): string;
 
   abstract getKnownScript(
     script: KnownScript,
-  ): Promise<Pick<Script, "codeHash" | "hashType">>;
+  ): Promise<
+    Pick<Script, "codeHash" | "hashType"> & { cellDeps: CellDepInfo[] }
+  >;
+
+  async markUsable(cellLike: CellLike): Promise<void> {
+    const cell = Cell.from(cellLike).clone();
+    this.usableCells.push(cell);
+    this.knownCells.push(cell);
 
-  abstract sendTransaction(
+    const index = this.unusableOutPoints.findIndex((o) => cell.outPoint.eq(o));
+    if (index !== -1) {
+      this.unusableOutPoints.splice(index, 1);
+    }
+  }
+
+  async markUnusable(outPointLike: OutPointLike): Promise<void> {
+    const outPoint = OutPoint.from(outPointLike);
+    this.unusableOutPoints.push(outPoint.clone());
+
+    const index = this.usableCells.findIndex((c) => c.outPoint.eq(outPoint));
+    if (index !== -1) {
+      this.usableCells.splice(index, 1);
+    }
+  }
+
+  abstract sendTransactionNoCache(
     transaction: TransactionLike,
     validator?: OutputsValidator,
   ): Promise<Hex>;
-  abstract getTransaction(
+  abstract getTransactionNoCache(
     txHash: HexLike,
   ): Promise<ClientTransactionResponse | null>;
 
-  async getCell(outPoint: OutPointLike): Promise<Cell | null> {
-    const transaction = await this.getTransaction(outPoint.txHash);
+  async getCell(outPointLike: OutPointLike): Promise<Cell | null> {
+    const outPoint = OutPoint.from(outPointLike);
+    const cached = this.knownCells.find((cell) => cell.outPoint.eq(outPoint));
+
+    if (cached) {
+      return cached.clone();
+    }
+
+    const transaction = await this.getTransactionNoCache(outPoint.txHash);
     if (!transaction) {
       return null;
     }
@@ -51,20 +119,31 @@ export abstract class Client {
       return null;
     }
 
-    return Cell.from({
+    const cell = Cell.from({
       outPoint,
       cellOutput: transaction.transaction.outputs[index],
       outputData: transaction.transaction.outputsData[index] ?? "0x",
-      blockNumber: transaction.blockNumber,
     });
+    this.knownCells.push(cell);
+    return cell.clone();
   }
 
-  abstract findCellsPaged(
+  abstract findCellsPagedNoCache(
     key: ClientIndexerSearchKeyLike,
     order?: "asc" | "desc",
     limit?: NumLike,
     after?: string,
   ): Promise<ClientFindCellsResponse>;
+  async findCellsPaged(
+    key: ClientIndexerSearchKeyLike,
+    order?: "asc" | "desc",
+    limit?: NumLike,
+    after?: string,
+  ): Promise<ClientFindCellsResponse> {
+    const res = await this.findCellsPagedNoCache(key, order, limit, after);
+    this.knownCells.push(...res.cells);
+    return res;
+  }
 
   async *findCells(
     key: ClientIndexerSearchKeyLike,
@@ -90,20 +169,105 @@ export abstract class Client {
     }
   }
 
+  /**
+   * Find cells by search key designed for collectable cells.
+   *
+   * @param key - The search key.
+   * @returns A async generator for yielding cells.
+   */
+  async *findCellsByCollectableSearchKey(
+    keyLike: ClientCollectableSearchKeyLike,
+    order?: "asc" | "desc",
+    limit = 10,
+  ): AsyncGenerator<Cell> {
+    const key = ClientIndexerSearchKey.from(keyLike);
+    for (const cell of this.usableCells) {
+      if (filterCell(key, cell)) {
+        yield cell;
+      }
+    }
+
+    for await (const cell of this.findCells(key, order, limit)) {
+      if (!this.unusableOutPoints.some((o) => o.eq(cell.outPoint))) {
+        yield cell;
+      }
+    }
+  }
+
   findCellsByLockAndType(
     lock: ScriptLike,
     type: ScriptLike,
     withData = true,
+    order?: "asc" | "desc",
+    limit = 10,
   ): AsyncGenerator<Cell> {
-    return this.findCells({
-      script: lock,
-      scriptType: "lock",
-      scriptSearchMode: "exact",
-      filter: {
+    return this.findCellsByCollectableSearchKey(
+      {
+        script: lock,
+        scriptType: "lock",
+        scriptSearchMode: "exact",
+        filter: {
+          script: type,
+        },
+        withData,
+      },
+      order,
+      limit,
+    );
+  }
+
+  findCellsByType(
+    type: ScriptLike,
+    withData = true,
+    order?: "asc" | "desc",
+    limit = 10,
+  ): AsyncGenerator<Cell> {
+    return this.findCellsByCollectableSearchKey(
+      {
         script: type,
+        scriptType: "type",
+        scriptSearchMode: "exact",
+        withData,
       },
+      order,
+      limit,
+    );
+  }
+
+  async findSingletonCellByType(
+    type: ScriptLike,
+    withData = false,
+  ): Promise<Cell | undefined> {
+    for await (const cell of this.findCellsByType(
+      type,
       withData,
-    });
+      undefined,
+      1,
+    )) {
+      return cell;
+    }
+  }
+
+  async getCellDeps(
+    ...cellDepsInfoLike: (CellDepInfoLike | CellDepInfoLike[])[]
+  ): Promise<CellDep[]> {
+    return Promise.all(
+      cellDepsInfoLike.flat().map(async (infoLike) => {
+        const { cellDep, type } = CellDepInfo.from(infoLike);
+        if (type === undefined) {
+          return cellDep;
+        }
+        const found = await this.findSingletonCellByType(type);
+        if (!found) {
+          return cellDep;
+        }
+
+        return CellDep.from({
+          outPoint: found.outPoint,
+          depType: cellDep.depType,
+        });
+      }),
+    );
   }
 
   abstract getCellsCapacity(key: ClientIndexerSearchKeyLike): Promise<Num>;
@@ -121,10 +285,57 @@ export abstract class Client {
   }
 
   async getBalance(locks: ScriptLike[]): Promise<Num> {
-    return locks.reduce(
-      (res: Promise<Num>, lock) =>
-        this.getBalanceSingle(lock).then((a) => res.then((b) => a + b)),
-      Promise.resolve(Zero),
+    return reduceAsync(
+      locks,
+      async (acc, lock) => acc + (await this.getBalanceSingle(lock)),
+      Zero,
+    );
+  }
+
+  async sendTransaction(
+    transaction: TransactionLike,
+    validator?: OutputsValidator,
+  ): Promise<Hex> {
+    const tx = Transaction.from(transaction);
+
+    const txHash = await this.sendTransactionNoCache(tx, validator);
+
+    this.cachedTransactions.push(tx.clone());
+    await Promise.all(
+      tx.inputs.map((i) => this.markUnusable(i.previousOutput)),
+    );
+    await Promise.all(
+      tx.outputs.map((o, i) =>
+        this.markUsable({
+          cellOutput: o,
+          outputData: tx.outputsData[i],
+          outPoint: {
+            txHash,
+            index: i,
+          },
+        }),
+      ),
     );
+    return txHash;
+  }
+
+  async getTransaction(
+    txHashLike: HexLike,
+  ): Promise<ClientTransactionResponse | null> {
+    const txHash = hexFrom(txHashLike);
+    const res = await this.getTransactionNoCache(txHash);
+    if (res !== null) {
+      return res;
+    }
+
+    const tx = this.cachedTransactions.find((t) => t.hash() === txHash);
+    if (!tx) {
+      return null;
+    }
+
+    return {
+      transaction: tx,
+      status: "proposed",
+    };
   }
 }

package/src/client/clientPublicMainnet.advanced.ts

@@ -1,38 +1,153 @@
 import { Script } from "../ckb";
-import { KnownScript } from "./client";
+import { CellDepInfoLike, KnownScript } from "./client";
 
 export const MAINNET_SCRIPTS: Record<
   KnownScript,
-  Pick<Script, "codeHash" | "hashType">
+  | (Pick<Script, "codeHash" | "hashType"> & { cellDeps: CellDepInfoLike[] })
+  | undefined
 > = {
   [KnownScript.Secp256k1Blake160]: {
     codeHash:
       "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
     hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0x71a7ba8fc96349fea0ed3a5c47992e3b4084b031a42264a018e0072e8172e46c",
+            index: 0,
+          },
+          depType: "depGroup",
+        },
+      },
+    ],
   },
   [KnownScript.Secp256k1Multisig]: {
     codeHash:
       "0x5c5069eb0857efc65e1bca0c07df34c31663b3622fd3876c876320fc9634e2a8",
     hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0x71a7ba8fc96349fea0ed3a5c47992e3b4084b031a42264a018e0072e8172e46c",
+            index: 1,
+          },
+          depType: "depGroup",
+        },
+      },
+    ],
   },
   [KnownScript.AnyoneCanPay]: {
     codeHash:
       "0xd369597ff47f29fbc0d47d2e3775370d1250b85140c670e4718af712983a2354",
     hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0x4153a2014952d7cac45f285ce9a7c5c0c0e1b21f2d378b82ac1433cb11c25c4d",
+            index: 0,
+          },
+          depType: "depGroup",
+        },
+      },
+    ],
+  },
+  [KnownScript.TypeId]: {
+    codeHash:
+      "0x00000000000000000000000000000000000000000000000000545950455f4944",
+    hashType: "type",
+    cellDeps: [],
+  },
+  [KnownScript.XUdt]: {
+    codeHash:
+      "0x50bd8d6680b8b9cf98b73f3c08faf8b2a21914311954118ad6609be6e78a1b95",
+    hashType: "data1",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0xc07844ce21b38e4b071dd0e1ee3b0e27afd8d7532491327f39b786343f558ab7",
+            index: 0,
+          },
+          depType: "code",
+        },
+      },
+    ],
   },
   [KnownScript.JoyId]: {
     codeHash:
       "0xd00c84f0ec8fd441c38bc3f87a371f547190f2fcff88e642bc5bf54b9e318323",
     hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0xf05188e5f3a6767fc4687faf45ba5f1a6e25d3ada6129dae8722cb282f262493",
+            index: 0,
+          },
+          depType: "depGroup",
+        },
+      },
+    ],
   },
   [KnownScript.COTA]: {
     codeHash:
       "0x1122a4fb54697cf2e6e3a96c9d80fd398a936559b90954c6e88eb7ba0cf652df",
     hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0xabaa25237554f0d6c586dc010e7e85e6870bcfd9fb8773257ecacfbe1fd738a0",
+            index: 0,
+          },
+          depType: "depGroup",
+        },
+      },
+    ],
   },
   [KnownScript.OmniLock]: {
     codeHash:
       "0x9b819793a64463aed77c615d6cb226eea5487ccfc0783043a587254cda2b6f26",
     hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0x71a7ba8fc96349fea0ed3a5c47992e3b4084b031a42264a018e0072e8172e46c",
+            index: 0,
+          },
+          depType: "depGroup",
+        },
+      },
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0xc76edf469816aa22f416503c38d0b533d2a018e253e379f134c3985b3472c842",
+            index: 0,
+          },
+          depType: "code",
+        },
+        type: {
+          codeHash:
+            "0x00000000000000000000000000000000000000000000000000545950455f4944",
+          hashType: "type",
+          args: "0x855508fe0f0ca25b935b070452ecaee48f6c9f1d66cd15f046616b99e948236a",
+        },
+      },
+    ],
   },
+  [KnownScript.NostrLock]: undefined,
+  [KnownScript.SingleUseLock]: undefined,
+  [KnownScript.OutputTypeProxyLock]: undefined,
 };

package/src/client/clientPublicMainnet.ts

@@ -1,5 +1,5 @@
 import { Script } from "../ckb";
-import { KnownScript } from "./client";
+import { CellDepInfo, KnownScript } from "./client";
 import { MAINNET_SCRIPTS } from "./clientPublicMainnet.advanced";
 import { ClientJsonRpc } from "./jsonRpc";
 
@@ -14,7 +14,18 @@ export class ClientPublicMainnet extends ClientJsonRpc {
 
   async getKnownScript(
     script: KnownScript,
-  ): Promise<Pick<Script, "codeHash" | "hashType">> {
-    return { ...MAINNET_SCRIPTS[script] };
+  ): Promise<
+    Pick<Script, "codeHash" | "hashType"> & { cellDeps: CellDepInfo[] }
+  > {
+    const found = MAINNET_SCRIPTS[script];
+    if (!found) {
+      throw new Error(
+        `No script information was found for ${script} on ${this.addressPrefix}`,
+      );
+    }
+    return {
+      ...found,
+      cellDeps: found.cellDeps.map((c) => CellDepInfo.from(c)),
+    };
   }
 }