@ckb-ccc/core 0.0.7-alpha.0 → 0.0.7-alpha.2

package/dist.commonjs/client/client.js

@@ -10,227 +10,194 @@ 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();
-    }
-    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;
+    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 found = await this.findSingletonCellByType(type);
-        if (!found) {
-          return cellDep;
+        const transaction = await this.getTransactionNoCache(outPoint.txHash);
+        if (!transaction) {
+            return null;
         }
-        return ckb_1.CellDep.from({
-          outPoint: found.outPoint,
-          depType: cellDep.depType,
+        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",
         });
-      }),
-    );
-  }
-  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",
-    };
-  }
+        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",
+        };
+    }
 }
 exports.Client = Client;

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

@@ -1,10 +1,6 @@
 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