@ckb-ccc/core 0.0.0-canary-20250214032000

package/dist/ckb/transactionLumos.d.ts

@@ -0,0 +1,30 @@
+import { CellDepLike, CellOutputLike, OutPointLike } from "../ckb/index.js";
+import { HexLike } from "../hex/index.js";
+export interface LumosTransactionSkeletonType {
+    cellDeps: {
+        toArray(): CellDepLike[];
+    };
+    headerDeps: {
+        toArray(): HexLike[];
+    };
+    inputs: {
+        toArray(): {
+            outPoint?: OutPointLike;
+            cellOutput: CellOutputLike;
+            data: HexLike;
+        }[];
+    };
+    inputSinces: {
+        get(i: number, defaultVal: string): HexLike;
+    };
+    outputs: {
+        toArray(): {
+            cellOutput: CellOutputLike;
+            data: HexLike;
+        }[];
+    };
+    witnesses: {
+        toArray(): HexLike[];
+    };
+}
+//# sourceMappingURL=transactionLumos.d.ts.map

package/dist/ckb/transactionLumos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactionLumos.d.ts","sourceRoot":"","sources":["../../src/ckb/transactionLumos.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC5E,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE1C,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE;QACR,OAAO,IAAI,WAAW,EAAE,CAAC;KAC1B,CAAC;IACF,UAAU,EAAE;QACV,OAAO,IAAI,OAAO,EAAE,CAAC;KACtB,CAAC;IACF,MAAM,EAAE;QACN,OAAO,IAAI;YACT,QAAQ,CAAC,EAAE,YAAY,CAAC;YACxB,UAAU,EAAE,cAAc,CAAC;YAC3B,IAAI,EAAE,OAAO,CAAC;SACf,EAAE,CAAC;KACL,CAAC;IACF,WAAW,EAAE;QACX,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC;KAC7C,CAAC;IACF,OAAO,EAAE;QACP,OAAO,IAAI;YAAE,UAAU,EAAE,cAAc,CAAC;YAAC,IAAI,EAAE,OAAO,CAAA;SAAE,EAAE,CAAC;KAC5D,CAAC;IACF,SAAS,EAAE;QACT,OAAO,IAAI,OAAO,EAAE,CAAC;KACtB,CAAC;CACH"}

package/dist/ckb/transactionLumos.js

@@ -0,0 +1 @@
+export {};

package/dist/client/advanced.d.ts

@@ -0,0 +1,6 @@
+export * from "./cache/advanced.js";
+export * from "./clientPublicMainnet.advanced.js";
+export * from "./clientPublicTestnet.advanced.js";
+export * from "./clientTypes.advanced.js";
+export * from "./jsonRpc/advanced.js";
+//# sourceMappingURL=advanced.d.ts.map

package/dist/client/advanced.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced.d.ts","sourceRoot":"","sources":["../../src/client/advanced.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC"}

package/dist/client/advanced.js

@@ -0,0 +1,5 @@
+export * from "./cache/advanced.js";
+export * from "./clientPublicMainnet.advanced.js";
+export * from "./clientPublicTestnet.advanced.js";
+export * from "./clientTypes.advanced.js";
+export * from "./jsonRpc/advanced.js";

package/dist/client/cache/advanced.d.ts

@@ -0,0 +1,2 @@
+export * from "./memory.advanced.js";
+//# sourceMappingURL=advanced.d.ts.map

package/dist/client/cache/advanced.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced.d.ts","sourceRoot":"","sources":["../../../src/client/cache/advanced.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC"}

package/dist/client/cache/advanced.js

@@ -0,0 +1 @@
+export * from "./memory.advanced.js";

package/dist/client/cache/cache.d.ts

@@ -0,0 +1,91 @@
+import { Cell, CellLike, OutPointLike, Transaction, TransactionLike } from "../../ckb/index.js";
+import { HexLike } from "../../hex/index.js";
+import { NumLike } from "../../num/index.js";
+import { ClientCollectableSearchKeyLike } from "../clientTypes.advanced.js";
+import { ClientBlock, ClientBlockHeader, ClientBlockHeaderLike, ClientBlockLike, ClientTransactionResponse, ClientTransactionResponseLike } from "../clientTypes.js";
+/**
+ * @public
+ * The ClientCache class is mainly designed for chained transactions.
+ * Consumed & Created cells are "marked" so they can be correctly handled when composing transactions.
+ * It also act as cache for rpc requests to reduce cost, but this is optional.
+ */
+export declare abstract class ClientCache {
+    abstract markUsableNoCache(...cellLikes: (CellLike | CellLike[])[]): Promise<void>;
+    markUsable(...cellLikes: (CellLike | CellLike[])[]): Promise<void>;
+    abstract markUnusable(...outPointLike: (OutPointLike | OutPointLike[])[]): Promise<void>;
+    markTransactions(...transactionLike: (TransactionLike | TransactionLike[])[]): Promise<void>;
+    abstract clear(): Promise<void>;
+    abstract findCells(filter: ClientCollectableSearchKeyLike): AsyncGenerator<Cell>;
+    abstract isUnusable(outPointLike: OutPointLike): Promise<boolean>;
+    /**
+     * Record known cells
+     * Implement this method to enable cells query caching
+     * @param _cells
+     */
+    recordCells(..._cells: (CellLike | CellLike[])[]): Promise<void>;
+    /**
+     * Get a known cell by out point
+     * Implement this method to enable cells query caching
+     * @param _outPoint
+     */
+    getCell(_outPoint: OutPointLike): Promise<Cell | undefined>;
+    /**
+     * Record known transaction responses.
+     * Implement this method to enable transactions query caching
+     * @param _transactions
+     */
+    recordTransactionResponses(..._transactions: (ClientTransactionResponseLike | ClientTransactionResponseLike[])[]): Promise<void>;
+    /**
+     * Get a known transaction response by hash
+     * Implement this method to enable transactions query caching
+     * @param _txHash
+     */
+    getTransactionResponse(_txHash: HexLike): Promise<ClientTransactionResponse | undefined>;
+    /**
+     * Record known transactions.
+     * @param transactions
+     */
+    recordTransactions(...transactions: (TransactionLike | TransactionLike[])[]): Promise<void>;
+    /**
+     * Get a known transaction by hash
+     * @param txHash
+     */
+    getTransaction(txHash: HexLike): Promise<Transaction | undefined>;
+    /**
+     * Record known block headers.
+     * Implement this method to enable block headers query caching
+     * @param _headers
+     */
+    recordHeaders(..._headers: (ClientBlockHeaderLike | ClientBlockHeaderLike[])[]): Promise<void>;
+    /**
+     * Get a known block header by hash
+     * Implement this method to enable block headers query caching
+     * @param _hash
+     */
+    getHeaderByHash(_hash: HexLike): Promise<ClientBlockHeader | undefined>;
+    /**
+     * Get a known block header by number
+     * Implement this method to enable block headers query caching
+     * @param _number
+     */
+    getHeaderByNumber(_number: NumLike): Promise<ClientBlockHeader | undefined>;
+    /**
+     * Record known blocks.
+     * Implement this method to enable blocks query caching
+     * @param _blocks
+     */
+    recordBlocks(..._blocks: (ClientBlockLike | ClientBlockLike[])[]): Promise<void>;
+    /**
+     * Get a known block header by hash
+     * Implement this method to enable block headers query caching
+     * @param _hash
+     */
+    getBlockByHash(_hash: HexLike): Promise<ClientBlock | undefined>;
+    /**
+     * Get a known block header by number
+     * Implement this method to enable block headers query caching
+     * @param _number
+     */
+    getBlockByNumber(_number: NumLike): Promise<ClientBlock | undefined>;
+}
+//# sourceMappingURL=cache.d.ts.map

package/dist/client/cache/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/client/cache/cache.ts"],"names":[],"mappings":"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"}

package/dist/client/cache/cache.js

@@ -0,0 +1,128 @@
+import { Transaction, } from "../../ckb/index.js";
+/**
+ * @public
+ * The ClientCache class is mainly designed for chained transactions.
+ * Consumed & Created cells are "marked" so they can be correctly handled when composing transactions.
+ * It also act as cache for rpc requests to reduce cost, but this is optional.
+ */
+export class ClientCache {
+    async markUsable(...cellLikes) {
+        await this.recordCells(...cellLikes);
+        return this.markUsableNoCache(...cellLikes);
+    }
+    async markTransactions(...transactionLike) {
+        await Promise.all([
+            this.recordTransactionResponses(transactionLike.flat().map((transaction) => ({
+                transaction: transaction,
+                status: "sent",
+            }))),
+            ...transactionLike.flat().map((transactionLike) => {
+                const tx = Transaction.from(transactionLike);
+                const txHash = tx.hash();
+                return Promise.all([
+                    ...tx.inputs.map((i) => this.markUnusable(i.previousOutput)),
+                    ...tx.outputs.map((o, i) => this.markUsable({
+                        cellOutput: o,
+                        outputData: tx.outputsData[i],
+                        outPoint: {
+                            txHash,
+                            index: i,
+                        },
+                    })),
+                ]);
+            }),
+        ]);
+    }
+    // ======
+    // Following methods are for requests caching and optional.
+    // ======
+    /**
+     * Record known cells
+     * Implement this method to enable cells query caching
+     * @param _cells
+     */
+    async recordCells(..._cells) { }
+    /**
+     * Get a known cell by out point
+     * Implement this method to enable cells query caching
+     * @param _outPoint
+     */
+    async getCell(_outPoint) {
+        return;
+    }
+    /**
+     * Record known transaction responses.
+     * Implement this method to enable transactions query caching
+     * @param _transactions
+     */
+    async recordTransactionResponses(..._transactions) { }
+    /**
+     * Get a known transaction response by hash
+     * Implement this method to enable transactions query caching
+     * @param _txHash
+     */
+    async getTransactionResponse(_txHash) {
+        return;
+    }
+    /**
+     * Record known transactions.
+     * @param transactions
+     */
+    async recordTransactions(...transactions) {
+        return this.recordTransactionResponses(transactions.flat().map((transaction) => ({
+            transaction,
+            status: "unknown",
+        })));
+    }
+    /**
+     * Get a known transaction by hash
+     * @param txHash
+     */
+    async getTransaction(txHash) {
+        return (await this.getTransactionResponse(txHash))?.transaction;
+    }
+    /**
+     * Record known block headers.
+     * Implement this method to enable block headers query caching
+     * @param _headers
+     */
+    async recordHeaders(..._headers) { }
+    /**
+     * Get a known block header by hash
+     * Implement this method to enable block headers query caching
+     * @param _hash
+     */
+    async getHeaderByHash(_hash) {
+        return;
+    }
+    /**
+     * Get a known block header by number
+     * Implement this method to enable block headers query caching
+     * @param _number
+     */
+    async getHeaderByNumber(_number) {
+        return;
+    }
+    /**
+     * Record known blocks.
+     * Implement this method to enable blocks query caching
+     * @param _blocks
+     */
+    async recordBlocks(..._blocks) { }
+    /**
+     * Get a known block header by hash
+     * Implement this method to enable block headers query caching
+     * @param _hash
+     */
+    async getBlockByHash(_hash) {
+        return;
+    }
+    /**
+     * Get a known block header by number
+     * Implement this method to enable block headers query caching
+     * @param _number
+     */
+    async getBlockByNumber(_number) {
+        return;
+    }
+}

package/dist/client/cache/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./cache.js";
+export * from "./memory.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/client/cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/cache/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC"}

package/dist/client/cache/index.js

@@ -0,0 +1,2 @@
+export * from "./cache.js";
+export * from "./memory.js";

package/dist/client/cache/memory.advanced.d.ts

@@ -0,0 +1,22 @@
+import { Cell, CellLike, ScriptLike } from "../../ckb/index.js";
+import { HexLike } from "../../hex/index.js";
+import { NumLike } from "../../num/index.js";
+import { ClientCollectableSearchKeyLike } from "../clientTypes.advanced.js";
+export type CellRecord = [
+    false,
+    Pick<Cell, "outPoint"> & Partial<Pick<Cell, "cellOutput" | "outputData">>
+] | [true, Cell] | [undefined, Cell];
+export declare function filterData(dataLike: HexLike, filterLike: HexLike | undefined, filterMode: "exact" | "prefix" | "partial"): boolean;
+export declare function filterScript(valueLike: ScriptLike | undefined, filterLike: ScriptLike | undefined, filterMode: "prefix" | "exact" | "partial"): boolean;
+export declare function filterNumByRange(lengthLike: NumLike, range: [NumLike, NumLike] | undefined): boolean;
+export declare function filterScriptByLenRange(valueLike?: ScriptLike, scriptLenRange?: [NumLike, NumLike]): boolean;
+export declare function filterCell(searchKeyLike: ClientCollectableSearchKeyLike, cellLike: CellLike): boolean;
+export declare class MapLru<K, V> extends Map<K, V> {
+    private readonly capacity;
+    private readonly lru;
+    constructor(capacity: number);
+    get(key: K): (V & ({} | null)) | undefined;
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+}
+//# sourceMappingURL=memory.advanced.d.ts.map

package/dist/client/cache/memory.advanced.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.advanced.d.ts","sourceRoot":"","sources":["../../../src/client/cache/memory.advanced.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAU,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,EAAE,OAAO,EAAW,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,OAAO,EAAW,MAAM,oBAAoB,CAAC;AACtD,OAAO,EACL,8BAA8B,EAE/B,MAAM,4BAA4B,CAAC;AAIpC,MAAM,MAAM,UAAU,GAClB;IACE,KAAK;IACL,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CAAC,CAAC;CAC1E,GACD,CAAC,IAAI,EAAE,IAAI,CAAC,GACZ,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;AAEtB,wBAAgB,UAAU,CACxB,QAAQ,EAAE,OAAO,EACjB,UAAU,EAAE,OAAO,GAAG,SAAS,EAC/B,UAAU,EAAE,OAAO,GAAG,QAAQ,GAAG,SAAS,GACzC,OAAO,CAgBT;AAED,wBAAgB,YAAY,CAC1B,SAAS,EAAE,UAAU,GAAG,SAAS,EACjC,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,UAAU,EAAE,QAAQ,GAAG,OAAO,GAAG,SAAS,GACzC,OAAO,CAkBT;AAED,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,OAAO,EACnB,KAAK,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,SAAS,GACpC,OAAO,CAQT;AAED,wBAAgB,sBAAsB,CACpC,SAAS,CAAC,EAAE,UAAU,EACtB,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,GAClC,OAAO,CAYT;AAED,wBAAgB,UAAU,CACxB,aAAa,EAAE,8BAA8B,EAC7C,QAAQ,EAAE,QAAQ,GACjB,OAAO,CA4CT;AAED,qBAAa,MAAM,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;IAG7B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAFrC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAW;gBAEF,QAAQ,EAAE,MAAM;IAI7C,GAAG,CAAC,GAAG,EAAE,CAAC;IAmBV,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC;IAOpB,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;CAYxB"}

package/dist/client/cache/memory.advanced.js

@@ -0,0 +1,118 @@
+import { bytesFrom } from "../../bytes/index.js";
+import { Cell, Script } from "../../ckb/index.js";
+import { hexFrom } from "../../hex/index.js";
+import { numFrom } from "../../num/index.js";
+import { clientSearchKeyRangeFrom, } from "../clientTypes.advanced.js";
+import { ClientIndexerSearchKey } from "../clientTypes.js";
+export function filterData(dataLike, filterLike, filterMode) {
+    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, filterLike, filterMode) {
+    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, range) {
+    if (!range) {
+        return true;
+    }
+    const length = numFrom(lengthLike);
+    const [lower, upper] = clientSearchKeyRangeFrom(range);
+    return lower <= length && length < upper;
+}
+export function filterScriptByLenRange(valueLike, scriptLenRange) {
+    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, cellLike) {
+    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;
+}
+export class MapLru extends Map {
+    constructor(capacity) {
+        super();
+        this.capacity = capacity;
+        this.lru = [];
+    }
+    get(key) {
+        const val = super.get(key);
+        if (val === undefined) {
+            return;
+        }
+        const index = this.lru.indexOf(key);
+        if (index !== -1) {
+            this.lru.splice(index, 1);
+        }
+        this.lru.push(key);
+        if (this.lru.length > this.capacity) {
+            this.delete(this.lru[0]);
+            this.lru.shift();
+        }
+        return val;
+    }
+    set(key, value) {
+        this.get(key);
+        super.set(key, value);
+        return this;
+    }
+    delete(key) {
+        if (!super.delete(key)) {
+            return false;
+        }
+        const index = this.lru.indexOf(key);
+        if (index !== -1) {
+            this.lru.splice(index, 1);
+        }
+        return true;
+    }
+}

package/dist/client/cache/memory.d.ts

@@ -0,0 +1,44 @@
+import { Cell, CellLike, OutPointLike } from "../../ckb/index.js";
+import { HexLike } from "../../hex/index.js";
+import { NumLike } from "../../num/index.js";
+import { ClientCollectableSearchKeyLike } from "../clientTypes.advanced.js";
+import { ClientBlock, ClientBlockHeader, ClientBlockHeaderLike, ClientBlockLike, ClientTransactionResponse, ClientTransactionResponseLike } from "../clientTypes.js";
+import { ClientCache } from "./cache.js";
+export declare class ClientCacheMemory extends ClientCache {
+    private readonly maxCells;
+    private readonly maxTxs;
+    private readonly maxBlocks;
+    /**
+     * OutPoint => [isLive, Cell | OutPoint]
+     */
+    private readonly cells;
+    /**
+     * TX Hash => Transaction Response
+     */
+    private readonly knownTransactions;
+    /**
+     * Block Number => Block Hash
+     */
+    private readonly knownBlockHashes;
+    /**
+     * Block Hash => Block Header / Full Block
+     */
+    private readonly knownBlocks;
+    constructor(maxCells?: number, maxTxs?: number, maxBlocks?: number);
+    markUsableNoCache(...cellLikes: (CellLike | CellLike[])[]): Promise<void>;
+    markUnusable(...outPointLikes: (OutPointLike | OutPointLike[])[]): Promise<void>;
+    clear(): Promise<void>;
+    findCells(keyLike: ClientCollectableSearchKeyLike): AsyncGenerator<Cell>;
+    isUnusable(outPointLike: OutPointLike): Promise<boolean>;
+    recordCells(...cells: (CellLike | CellLike[])[]): Promise<void>;
+    getCell(outPointLike: OutPointLike): Promise<Cell | undefined>;
+    recordTransactionResponses(...transactions: (ClientTransactionResponseLike | ClientTransactionResponseLike[])[]): Promise<void>;
+    getTransactionResponse(txHashLike: HexLike): Promise<ClientTransactionResponse | undefined>;
+    recordHeaders(...headers: (ClientBlockHeaderLike | ClientBlockHeaderLike[])[]): Promise<void>;
+    getHeaderByHash(hashLike: HexLike): Promise<ClientBlockHeader | undefined>;
+    getHeaderByNumber(numberLike: NumLike): Promise<ClientBlockHeader | undefined>;
+    recordBlocks(...blocks: (ClientBlockLike | ClientBlockLike[])[]): Promise<void>;
+    getBlockByHash(hashLike: HexLike): Promise<ClientBlock | undefined>;
+    getBlockByNumber(numberLike: NumLike): Promise<ClientBlock | undefined>;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/client/cache/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/client/cache/memory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAY,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,EAAW,OAAO,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAgB,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,EACf,yBAAyB,EACzB,6BAA6B,EAC9B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGzC,qBAAa,iBAAkB,SAAQ,WAAW;IAyB9C,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IA1B5B;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA6B;IAEnD;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA4C;IAE9E;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAsB;IAEvD;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAG1B;gBAGiB,QAAQ,SAAM,EACd,MAAM,SAAM,EACZ,SAAS,SAAM;IAe5B,iBAAiB,CACrB,GAAG,SAAS,EAAE,CAAC,QAAQ,GAAG,QAAQ,EAAE,CAAC,EAAE,GACtC,OAAO,CAAC,IAAI,CAAC;IASV,YAAY,CAChB,GAAG,aAAa,EAAE,CAAC,YAAY,GAAG,YAAY,EAAE,CAAC,EAAE,GAClD,OAAO,CAAC,IAAI,CAAC;IAcV,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAKrB,SAAS,CACd,OAAO,EAAE,8BAA8B,GACtC,cAAc,CAAC,IAAI,CAAC;IAcjB,UAAU,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAMxD,WAAW,CAAC,GAAG,KAAK,EAAE,CAAC,QAAQ,GAAG,QAAQ,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAW/D,OAAO,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC;IAS9D,0BAA0B,CAC9B,GAAG,YAAY,EAAE,CACb,6BAA6B,GAC7B,6BAA6B,EAAE,CAClC,EAAE,GACF,OAAO,CAAC,IAAI,CAAC;IAMV,sBAAsB,CAC1B,UAAU,EAAE,OAAO,GAClB,OAAO,CAAC,yBAAyB,GAAG,SAAS,CAAC;IAK3C,aAAa,CACjB,GAAG,OAAO,EAAE,CAAC,qBAAqB,GAAG,qBAAqB,EAAE,CAAC,EAAE,GAC9D,OAAO,CAAC,IAAI,CAAC;IAaV,eAAe,CACnB,QAAQ,EAAE,OAAO,GAChB,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;IAQnC,iBAAiB,CACrB,UAAU,EAAE,OAAO,GAClB,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;IAUnC,YAAY,CAChB,GAAG,MAAM,EAAE,CAAC,eAAe,GAAG,eAAe,EAAE,CAAC,EAAE,GACjD,OAAO,CAAC,IAAI,CAAC;IAQV,cAAc,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC;IAWnE,gBAAgB,CACpB,UAAU,EAAE,OAAO,GAClB,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC;CASpC"}

package/dist/client/cache/memory.js

@@ -0,0 +1,137 @@
+import { Cell, OutPoint } from "../../ckb/index.js";
+import { hexFrom } from "../../hex/index.js";
+import { numFrom } from "../../num/index.js";
+import { ClientBlock, ClientBlockHeader, ClientTransactionResponse, } from "../clientTypes.js";
+import { ClientCache } from "./cache.js";
+import { filterCell, MapLru } from "./memory.advanced.js";
+export class ClientCacheMemory extends ClientCache {
+    constructor(maxCells = 512, maxTxs = 256, maxBlocks = 128) {
+        super();
+        this.maxCells = maxCells;
+        this.maxTxs = maxTxs;
+        this.maxBlocks = maxBlocks;
+        this.cells = new MapLru(this.maxCells);
+        this.knownTransactions = new MapLru(this.maxTxs);
+        this.knownBlockHashes = new MapLru(this.maxBlocks);
+        this.knownBlocks = new MapLru(this.maxBlocks);
+    }
+    async markUsableNoCache(...cellLikes) {
+        cellLikes.flat().forEach((cellLike) => {
+            const cell = Cell.from(cellLike).clone();
+            const outPointStr = hexFrom(cell.outPoint.toBytes());
+            this.cells.set(outPointStr, [true, cell]);
+        });
+    }
+    async markUnusable(...outPointLikes) {
+        outPointLikes.flat().forEach((outPointLike) => {
+            const outPoint = OutPoint.from(outPointLike);
+            const outPointStr = hexFrom(outPoint.toBytes());
+            const existed = this.cells.get(outPointStr);
+            if (existed) {
+                existed[0] = false;
+                return;
+            }
+            this.cells.set(outPointStr, [false, { outPoint }]);
+        });
+    }
+    async clear() {
+        this.cells.clear();
+        this.knownTransactions.clear();
+    }
+    async *findCells(keyLike) {
+        for (const [key, [isLive, cell]] of this.cells.entries()) {
+            if (!isLive) {
+                continue;
+            }
+            if (!filterCell(keyLike, cell)) {
+                continue;
+            }
+            this.cells.get(key);
+            yield cell.clone();
+        }
+    }
+    async isUnusable(outPointLike) {
+        const outPoint = OutPoint.from(outPointLike);
+        return !(this.cells.get(hexFrom(outPoint.toBytes()))?.[0] ?? true);
+    }
+    async recordCells(...cells) {
+        cells.flat().map((cellLike) => {
+            const cell = Cell.from(cellLike);
+            const outPointStr = hexFrom(cell.outPoint.toBytes());
+            if (this.cells.get(outPointStr)) {
+                return;
+            }
+            this.cells.set(outPointStr, [undefined, cell]);
+        });
+    }
+    async getCell(outPointLike) {
+        const outPoint = OutPoint.from(outPointLike);
+        const cell = this.cells.get(hexFrom(outPoint.toBytes()))?.[1];
+        if (cell && cell.cellOutput && cell.outputData) {
+            return Cell.from(cell.clone());
+        }
+    }
+    async recordTransactionResponses(...transactions) {
+        transactions.flat().map((txLike) => {
+            const tx = ClientTransactionResponse.from(txLike);
+            this.knownTransactions.set(tx.transaction.hash(), tx);
+        });
+    }
+    async getTransactionResponse(txHashLike) {
+        const txHash = hexFrom(txHashLike);
+        return this.knownTransactions.get(txHash)?.clone();
+    }
+    async recordHeaders(...headers) {
+        headers.flat().map((headerLike) => {
+            const header = ClientBlockHeader.from(headerLike);
+            this.knownBlockHashes.set(header.number, header.hash);
+            const existed = this.knownBlocks.get(header.hash);
+            if (existed) {
+                return;
+            }
+            this.knownBlocks.set(header.hash, { header });
+        });
+    }
+    async getHeaderByHash(hashLike) {
+        const hash = hexFrom(hashLike);
+        const block = this.knownBlocks.get(hash);
+        if (block) {
+            this.knownBlockHashes.get(block.header.number); // For LRU
+        }
+        return block?.header;
+    }
+    async getHeaderByNumber(numberLike) {
+        const number = numFrom(numberLike);
+        const hash = this.knownBlockHashes.get(number);
+        if (!hash) {
+            return;
+        }
+        return this.getHeaderByHash(hash);
+    }
+    async recordBlocks(...blocks) {
+        blocks.flat().map((blockLike) => {
+            const block = ClientBlock.from(blockLike);
+            this.knownBlockHashes.set(block.header.number, block.header.hash);
+            this.knownBlocks.set(block.header.hash, block);
+        });
+    }
+    async getBlockByHash(hashLike) {
+        const hash = hexFrom(hashLike);
+        const block = this.knownBlocks.get(hash);
+        if (block) {
+            this.knownBlockHashes.get(block.header.number); // For LRU
+            if ("transactions" in block) {
+                return block;
+            }
+        }
+        return;
+    }
+    async getBlockByNumber(numberLike) {
+        const number = numFrom(numberLike);
+        const hash = this.knownBlockHashes.get(number);
+        if (!hash) {
+            return;
+        }
+        return this.getBlockByHash(hash);
+    }
+}