@mentaproject/client 0.0.10 → 0.1.1

package/dist/structures/MentaClient.d.ts

@@ -1,13 +1,14 @@
-import type { CoreClient, CoreClientConfig } from "@mentaproject/core/types";
+import type { CoreClient } from "@mentaproject/core/types";
 import { BlockManager } from "../managers/BlockManager";
 import { TransactionManager } from "../managers/TransactionManager";
 import { ContractManager } from "../managers/ContractManager";
 import { AccountManager } from "../managers/AccountManager";
+import { MentaClientConfig } from "src/types/MentaClient";
 export declare class MentaClient {
     rpcClient: CoreClient;
     blocks: BlockManager;
     transactions: TransactionManager;
     contracts: ContractManager;
     accounts: AccountManager;
-    constructor(params: CoreClientConfig);
+    constructor(params: MentaClientConfig);
 }

package/dist/structures/MentaClient.js

@@ -3,9 +3,12 @@ import { BlockManager } from "../managers/BlockManager";
 import { TransactionManager } from "../managers/TransactionManager";
 import { ContractManager } from "../managers/ContractManager";
 import { AccountManager } from "../managers/AccountManager";
+import { withCache } from "src/utils/withCache";
 export class MentaClient {
     constructor(params) {
         this.rpcClient = createClient(params);
+        if (params.cache)
+            this.rpcClient = withCache(this.rpcClient, params.cache);
         this.blocks = new BlockManager(this.rpcClient);
         this.transactions = new TransactionManager(this.rpcClient);
         this.contracts = new ContractManager(this.rpcClient);

package/dist/types/Cache.d.ts

@@ -0,0 +1,17 @@
+import { Methods } from "./JsonRPC";
+export interface ICacheEntry<T> {
+    value: T;
+    expiry: bigint;
+}
+export interface ICacheConfig {
+    maxSize: number;
+    defaultTtl: number;
+    ttlPolicies: Partial<Record<Methods, number>>;
+}
+export interface ICache {
+    config: ICacheConfig;
+    setBlockNumber(blockNumber: bigint): void;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    has(key: string): Promise<boolean>;
+}

package/dist/types/Cache.js

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

package/dist/types/JsonRPC.d.ts

@@ -0,0 +1,5 @@
+export type StandardMethods = "eth_accounts" | "eth_blobBaseFee" | "eth_blockNumber" | "eth_call" | "eth_chainId" | "eth_createAccessList" | "eth_estimateGas" | "eth_feeHistory" | "eth_gasPrice" | "eth_getBalance" | "eth_getBlockByHash" | "eth_getBlockByNumber" | "eth_getBlockReceipts" | "eth_getBlockTransactionCountByHash" | "eth_getBlockTransactionCountByNumber" | "eth_getCode" | "eth_getLogs" | "eth_getProof" | "eth_getStorageAt" | "eth_getTransactionByBlockHashAndIndex" | "eth_getTransactionByBlockNumberAndIndex" | "eth_getTransactionByHash" | "eth_getTransactionCount" | "eth_getTransactionReceipt" | "eth_getUncleByBlockHashAndIndex" | "eth_getUncleByBlockNumberAndIndex" | "eth_getUncleCountByBlockHash" | "eth_getUncleCountByBlockNumber" | "eth_getWork" | "eth_hashrate" | "eth_maxPriorityFeePerGas" | "eth_mining" | "eth_protocolVersion" | "eth_sendRawTransaction" | "eth_simulateV1" | "eth_submitWork" | "eth_syncing";
+export type filterMethods = "eth_getFilterChanges" | "eth_getFilterLogs" | "eth_newBlockFilter" | "eth_newFilter" | "eth_uninstallFilter";
+export type subscriptionMethods = "eth_subscribe" | "eth_unsubscribe";
+export type traceMethods = "trace_block" | "trace_call" | "trace_callMany" | "trace_filter" | "trace_transaction";
+export type Methods = StandardMethods | filterMethods | subscriptionMethods | traceMethods;

package/dist/types/JsonRPC.js

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

package/dist/types/MentaClient.d.ts

@@ -0,0 +1,8 @@
+import { CoreClientConfig } from "src/structures";
+import { ICache } from "./Cache";
+export interface CacheConfig {
+    ttl_policies: Record<string, number>;
+}
+export interface MentaClientConfig extends CoreClientConfig {
+    cache: ICache;
+}

package/dist/types/MentaClient.js

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

package/dist/utils/Cache.d.ts

@@ -0,0 +1,13 @@
+import { ICache, ICacheConfig } from '../types/Cache';
+export declare class Cache implements ICache {
+    private cache;
+    config: ICacheConfig;
+    private blockNumber;
+    constructor(blockNumber: bigint, options?: Partial<ICacheConfig>);
+    protected isExpired(expiry: bigint): boolean;
+    setBlockNumber(blockNumber: bigint): void;
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    get<T>(key: string): Promise<T | undefined>;
+    has(key: string): Promise<boolean>;
+    private evict;
+}

package/dist/utils/Cache.js

@@ -0,0 +1,57 @@
+export class Cache {
+    constructor(blockNumber, options) {
+        this.cache = new Map();
+        this.blockNumber = blockNumber;
+        this.config = {
+            maxSize: 500,
+            defaultTtl: 1,
+            ttlPolicies: options?.ttlPolicies || {},
+            ...options,
+        };
+    }
+    ;
+    isExpired(expiry) {
+        return this.blockNumber > expiry;
+    }
+    ;
+    setBlockNumber(blockNumber) {
+        this.blockNumber = blockNumber;
+    }
+    async set(key, value, ttl = this.config.defaultTtl) {
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        if (this.cache.size >= this.config.maxSize)
+            this.evict();
+        const expiry = this.blockNumber + BigInt(ttl);
+        this.cache.set(key, { value, expiry });
+    }
+    async get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return undefined;
+        if (this.isExpired(entry.expiry)) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        this.cache.delete(key);
+        this.cache.set(key, entry);
+        return entry.value;
+    }
+    async has(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return false;
+        if (this.isExpired(entry.expiry)) {
+            this.cache.delete(key);
+            return false;
+        }
+        return true;
+    }
+    evict() {
+        const oldestKey = this.cache.keys().next().value;
+        if (!oldestKey)
+            return;
+        this.cache.delete(oldestKey);
+    }
+}

package/dist/utils/withCache.d.ts

@@ -0,0 +1,3 @@
+import { CoreClient } from "src/types";
+import { ICache } from "src/types/Cache";
+export declare function withCache(client: CoreClient, cache: ICache): CoreClient;

package/dist/utils/withCache.js

@@ -0,0 +1,23 @@
+import { watchBlockNumber } from "@mentaproject/core/actions";
+export function withCache(client, cache) {
+    watchBlockNumber(client, {
+        onBlockNumber: (blockNumber) => {
+            cache.setBlockNumber(blockNumber);
+        }
+    });
+    // 2. On garde une référence à la méthode request originale
+    const originalRequest = client.request;
+    // 3. On remplace la méthode `request` du client
+    client.request = (async (args) => {
+        const { method, params } = args;
+        const cacheKey = `${client.chain.id}:${method}:${JSON.stringify(params || [])}`;
+        if (await cache.has(cacheKey) && method !== "eth_blockNumber")
+            return cache.get(cacheKey);
+        const result = await originalRequest(args);
+        if (result !== null && result !== undefined)
+            await cache.set(cacheKey, result, cache.config.defaultTtl);
+        return result;
+    });
+    return client;
+}
+;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentaproject/client",
-  "version": "0.0.10",
+  "version": "0.1.1",
   "description": "High level EVM library used into the Menta App to facilitate Blockchain interactions. ",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -30,7 +30,7 @@
   "license": "ISC",
   "dependencies": {
     "@mentaproject/contracts": "^0.0.9",
-    "@mentaproject/core": "^0.0.4",
+    "@mentaproject/core": "^0.0.5",
     "@shazow/whatsabi": "^0.21.1"
   },
   "devDependencies": {

package/test.ts

@@ -2,26 +2,30 @@ import { http } from "viem";
 import { MentaClient } from "./src";
 import { privateKeyToAccount, generatePrivateKey } from "viem/accounts"
 import { mainnet } from "@mentaproject/core/chains";
+import { withCache } from "./src/utils/withCache";
+import { MemoryCache } from "./src/utils/Cache";
 
 import { writeFileSync } from "fs";
 
 const viemAccount = privateKeyToAccount(generatePrivateKey());
 
 let time = Date.now();
-
+let counter = 0;
 const client = new MentaClient({
     account: viemAccount,
     transport: http("https://red-nameless-panorama.quiknode.pro/0f30278c4c66afdc9f8679975e13cd5a92c7d937/", {
         batch: {
-            batchSize: 6,
+            batchSize: 5,
             wait: 500,
             waitAsRateLimit: true
         },
         onFetchRequest: async (r) => {
-            const delay = Date.now() - time;
-            time = Date.now();
+            const req = await r.json();
+
+            counter = counter + req.length
+            // console.log(`>> ${counter} requests`);
 
-            console.log(`>> ${r.url}\n>> ${(await r.json()).map(j => j.method).join(', ')}\n>> ${delay / 1000}s\n`)
+            // console.log(`>> ${r.url}\n>> ${req.map(j => j.method).join(', ')}\n>> ${delay / 1000}s\n`)
         },
         // onFetchResponse: (r) => console.log(`<<: ${r.url}`),
     }),
@@ -29,8 +33,18 @@ const client = new MentaClient({
 });
 
 (async () => {
+    const lastBlock = await client.blocks.get({ blockTag: "latest" });
+
+    const cache = new MemoryCache(lastBlock.number!, { maxSize: 1000, defaultTtl: 1 });
+    client.rpcClient = withCache(client.rpcClient, cache);
+
     const firstTx = await client.transactions.get({ hash: "0x48e6f527c659c6e2c5a504864fc269599047e151dd35fc509387599fe4b82370" });
     const json = await firstTx.toJSON(1);
 
+    const elapsed = Date.now() - time;
+
+    console.log(`Elapsed time: ${elapsed / 1000}s`);
+    console.log(`Effective RPC calls: ${counter}`);
+
     writeFileSync("./test.json", JSON.stringify(json, null, 2));
 })()