@ckb-ccc/core 0.0.7-alpha.2 → 0.0.8-alpha.3

package/dist.commonjs/client/client.js

@@ -10,194 +10,227 @@ const client_advanced_1 = require("./client.advanced");
 const clientTypes_1 = require("./clientTypes");
 var KnownScript;
 (function (KnownScript) {
-    KnownScript["Secp256k1Blake160"] = "Secp256k1Blake160";
-    KnownScript["Secp256k1Multisig"] = "Secp256k1Multisig";
-    KnownScript["AnyoneCanPay"] = "AnyoneCanPay";
-    KnownScript["TypeId"] = "TypeId";
-    KnownScript["XUdt"] = "XUdt";
-    KnownScript["JoyId"] = "JoyId";
-    KnownScript["COTA"] = "COTA";
-    KnownScript["OmniLock"] = "OmniLock";
-    KnownScript["NostrLock"] = "NostrLock";
-    KnownScript["SingleUseLock"] = "SingleUseLock";
-    KnownScript["OutputTypeProxyLock"] = "OutputTypeProxyLock";
+  KnownScript["Secp256k1Blake160"] = "Secp256k1Blake160";
+  KnownScript["Secp256k1Multisig"] = "Secp256k1Multisig";
+  KnownScript["AnyoneCanPay"] = "AnyoneCanPay";
+  KnownScript["TypeId"] = "TypeId";
+  KnownScript["XUdt"] = "XUdt";
+  KnownScript["JoyId"] = "JoyId";
+  KnownScript["COTA"] = "COTA";
+  KnownScript["OmniLock"] = "OmniLock";
+  KnownScript["NostrLock"] = "NostrLock";
+  KnownScript["SingleUseLock"] = "SingleUseLock";
+  KnownScript["OutputTypeProxyLock"] = "OutputTypeProxyLock";
 })(KnownScript || (exports.KnownScript = KnownScript = {}));
 class CellDepInfo {
-    constructor(cellDep, type) {
-        this.cellDep = cellDep;
-        this.type = type;
-    }
-    static from(cellDepInfoLike) {
-        return new CellDepInfo(ckb_1.CellDep.from(cellDepInfoLike.cellDep), (0, utils_1.apply)(ckb_1.Script.from, cellDepInfoLike.type));
-    }
+  constructor(cellDep, type) {
+    this.cellDep = cellDep;
+    this.type = type;
+  }
+  static from(cellDepInfoLike) {
+    return new CellDepInfo(
+      ckb_1.CellDep.from(cellDepInfoLike.cellDep),
+      (0, utils_1.apply)(ckb_1.Script.from, cellDepInfoLike.type),
+    );
+  }
 }
 exports.CellDepInfo = CellDepInfo;
 class Client {
-    constructor() {
-        this.cachedTransactions = [];
-        this.unusableOutPoints = [];
-        this.usableCells = [];
-        this.knownCells = [];
-    }
-    async markUsable(cellLike) {
-        const cell = ckb_1.Cell.from(cellLike).clone();
-        this.usableCells.push(cell);
-        this.knownCells.push(cell);
-        const index = this.unusableOutPoints.findIndex((o) => cell.outPoint.eq(o));
-        if (index !== -1) {
-            this.unusableOutPoints.splice(index, 1);
-        }
-    }
-    async markUnusable(outPointLike) {
-        const outPoint = ckb_1.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);
-        }
-    }
-    async getCell(outPointLike) {
-        const outPoint = ckb_1.OutPoint.from(outPointLike);
-        const cached = this.knownCells.find((cell) => cell.outPoint.eq(outPoint));
-        if (cached) {
-            return cached.clone();
+  constructor() {
+    this.cachedTransactions = [];
+    this.unusableOutPoints = [];
+    this.usableCells = [];
+    this.knownCells = [];
+  }
+  async markUsable(cellLike) {
+    const cell = ckb_1.Cell.from(cellLike).clone();
+    this.usableCells.push(cell);
+    this.knownCells.push(cell);
+    const index = this.unusableOutPoints.findIndex((o) => cell.outPoint.eq(o));
+    if (index !== -1) {
+      this.unusableOutPoints.splice(index, 1);
+    }
+  }
+  async markUnusable(outPointLike) {
+    const outPoint = ckb_1.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);
+    }
+  }
+  async getCell(outPointLike) {
+    const outPoint = ckb_1.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;
+    }
+    const index = Number((0, num_1.numFrom)(outPoint.index));
+    if (index >= transaction.transaction.outputs.length) {
+      return null;
+    }
+    const cell = ckb_1.Cell.from({
+      outPoint,
+      cellOutput: transaction.transaction.outputs[index],
+      outputData: transaction.transaction.outputsData[index] ?? "0x",
+    });
+    this.knownCells.push(cell);
+    return cell.clone();
+  }
+  async findCellsPaged(key, order, limit, after) {
+    const res = await this.findCellsPagedNoCache(key, order, limit, after);
+    this.knownCells.push(...res.cells);
+    return res;
+  }
+  async *findCells(key, order, limit = 10) {
+    let last = undefined;
+    while (true) {
+      const { cells, lastCursor } = await this.findCellsPaged(
+        key,
+        order,
+        limit,
+        last,
+      );
+      for (const cell of cells) {
+        yield cell;
+      }
+      if (cells.length === 0 || cells.length < limit) {
+        return;
+      }
+      last = lastCursor;
+    }
+  }
+  /**
+   * Find cells by search key designed for collectable cells.
+   *
+   * @param key - The search key.
+   * @returns A async generator for yielding cells.
+   */
+  async *findCellsByCollectableSearchKey(keyLike, order, limit = 10) {
+    const key = clientTypes_1.ClientIndexerSearchKey.from(keyLike);
+    for (const cell of this.usableCells) {
+      if ((0, client_advanced_1.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, type, withData = true, order, limit = 10) {
+    return this.findCellsByCollectableSearchKey(
+      {
+        script: lock,
+        scriptType: "lock",
+        scriptSearchMode: "exact",
+        filter: {
+          script: type,
+        },
+        withData,
+      },
+      order,
+      limit,
+    );
+  }
+  findCellsByType(type, withData = true, order, limit = 10) {
+    return this.findCellsByCollectableSearchKey(
+      {
+        script: type,
+        scriptType: "type",
+        scriptSearchMode: "exact",
+        withData,
+      },
+      order,
+      limit,
+    );
+  }
+  async findSingletonCellByType(type, withData = false) {
+    for await (const cell of this.findCellsByType(
+      type,
+      withData,
+      undefined,
+      1,
+    )) {
+      return cell;
+    }
+  }
+  async getCellDeps(...cellDepsInfoLike) {
+    return Promise.all(
+      cellDepsInfoLike.flat().map(async (infoLike) => {
+        const { cellDep, type } = CellDepInfo.from(infoLike);
+        if (type === undefined) {
+          return cellDep;
         }
-        const transaction = await this.getTransactionNoCache(outPoint.txHash);
-        if (!transaction) {
-            return null;
+        const found = await this.findSingletonCellByType(type);
+        if (!found) {
+          return cellDep;
         }
-        const index = Number((0, num_1.numFrom)(outPoint.index));
-        if (index >= transaction.transaction.outputs.length) {
-            return null;
-        }
-        const cell = ckb_1.Cell.from({
-            outPoint,
-            cellOutput: transaction.transaction.outputs[index],
-            outputData: transaction.transaction.outputsData[index] ?? "0x",
+        return ckb_1.CellDep.from({
+          outPoint: found.outPoint,
+          depType: cellDep.depType,
         });
-        this.knownCells.push(cell);
-        return cell.clone();
-    }
-    async findCellsPaged(key, order, limit, after) {
-        const res = await this.findCellsPagedNoCache(key, order, limit, after);
-        this.knownCells.push(...res.cells);
-        return res;
-    }
-    async *findCells(key, order, limit = 10) {
-        let last = undefined;
-        while (true) {
-            const { cells, lastCursor } = await this.findCellsPaged(key, order, limit, last);
-            for (const cell of cells) {
-                yield cell;
-            }
-            if (cells.length === 0 || cells.length < limit) {
-                return;
-            }
-            last = lastCursor;
-        }
-    }
-    /**
-     * Find cells by search key designed for collectable cells.
-     *
-     * @param key - The search key.
-     * @returns A async generator for yielding cells.
-     */
-    async *findCellsByCollectableSearchKey(keyLike, order, limit = 10) {
-        const key = clientTypes_1.ClientIndexerSearchKey.from(keyLike);
-        for (const cell of this.usableCells) {
-            if ((0, client_advanced_1.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, type, withData = true, order, limit = 10) {
-        return this.findCellsByCollectableSearchKey({
-            script: lock,
-            scriptType: "lock",
-            scriptSearchMode: "exact",
-            filter: {
-                script: type,
-            },
-            withData,
-        }, order, limit);
-    }
-    findCellsByType(type, withData = true, order, limit = 10) {
-        return this.findCellsByCollectableSearchKey({
-            script: type,
-            scriptType: "type",
-            scriptSearchMode: "exact",
-            withData,
-        }, order, limit);
-    }
-    async findSingletonCellByType(type, withData = false) {
-        for await (const cell of this.findCellsByType(type, withData, undefined, 1)) {
-            return cell;
-        }
-    }
-    async getCellDeps(...cellDepsInfoLike) {
-        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 ckb_1.CellDep.from({
-                outPoint: found.outPoint,
-                depType: cellDep.depType,
-            });
-        }));
-    }
-    async getBalanceSingle(lock) {
-        return this.getCellsCapacity({
-            script: lock,
-            scriptType: "lock",
-            scriptSearchMode: "exact",
-            filter: {
-                scriptLenRange: [0, 1],
-                outputDataLenRange: [0, 1],
-            },
-        });
-    }
-    async getBalance(locks) {
-        return (0, utils_1.reduceAsync)(locks, async (acc, lock) => acc + (await this.getBalanceSingle(lock)), fixedPoint_1.Zero);
-    }
-    async sendTransaction(transaction, validator) {
-        const tx = ckb_1.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) {
-        const txHash = (0, hex_1.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",
-        };
-    }
+      }),
+    );
+  }
+  async getBalanceSingle(lock) {
+    return this.getCellsCapacity({
+      script: lock,
+      scriptType: "lock",
+      scriptSearchMode: "exact",
+      filter: {
+        scriptLenRange: [0, 1],
+        outputDataLenRange: [0, 1],
+      },
+    });
+  }
+  async getBalance(locks) {
+    return (0, utils_1.reduceAsync)(
+      locks,
+      async (acc, lock) => acc + (await this.getBalanceSingle(lock)),
+      fixedPoint_1.Zero,
+    );
+  }
+  async sendTransaction(transaction, validator) {
+    const tx = ckb_1.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) {
+    const txHash = (0, hex_1.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",
+    };
+  }
 }
 exports.Client = Client;

package/dist.commonjs/client/clientPublicMainnet.advanced.d.ts

@@ -1,6 +1,10 @@
 import { Script } from "../ckb";
 import { CellDepInfoLike, KnownScript } from "./client";
-export declare const MAINNET_SCRIPTS: Record<KnownScript, (Pick<Script, "codeHash" | "hashType"> & {
-    cellDeps: CellDepInfoLike[];
-}) | undefined>;
-//# sourceMappingURL=clientPublicMainnet.advanced.d.ts.map
+export declare const MAINNET_SCRIPTS: Record<
+  KnownScript,
+  | (Pick<Script, "codeHash" | "hashType"> & {
+      cellDeps: CellDepInfoLike[];
+    })
+  | undefined
+>;
+//# sourceMappingURL=clientPublicMainnet.advanced.d.ts.map