@atomiqlabs/chain-starknet 3.0.0-dev.8 → 4.0.0-dev.3

package/src/starknet/chain/modules/StarknetAccounts.ts

@@ -1,26 +1,26 @@
-import {StarknetModule} from "../StarknetModule";
-import {StarknetTx} from "./StarknetTransactions";
-import {DeployAccountContractPayload} from "starknet";
-
-
-export class StarknetAccounts extends StarknetModule {
-
-    public async getAccountDeployTransaction(deploymentData: DeployAccountContractPayload): Promise<StarknetTx> {
-        const feeDetails = this.root.Fees.getFeeDetails({l1DataGas: 500, l2Gas: 5_000*40_000, l1Gas: 0}, await this.root.Fees.getFeeRate());
-        const details = {
-            ...feeDetails,
-            walletAddress: deploymentData.contractAddress,
-            cairoVersion: "1" as const,
-            chainId: this.root.starknetChainId,
-            nonce: 0,
-            accountDeploymentData: [],
-            skipValidate: false
-        };
-        return {
-            type: "DEPLOY_ACCOUNT",
-            tx: deploymentData,
-            details
-        };
-    }
-
+import {StarknetModule} from "../StarknetModule";
+import {StarknetTx} from "./StarknetTransactions";
+import {DeployAccountContractPayload} from "starknet";
+
+
+export class StarknetAccounts extends StarknetModule {
+
+    public async getAccountDeployTransaction(deploymentData: DeployAccountContractPayload): Promise<StarknetTx> {
+        const feeDetails = this.root.Fees.getFeeDetails({l1DataGas: 500, l2Gas: 5_000*40_000, l1Gas: 0}, await this.root.Fees.getFeeRate());
+        const details = {
+            ...feeDetails,
+            walletAddress: deploymentData.contractAddress,
+            cairoVersion: "1" as const,
+            chainId: this.root.starknetChainId,
+            nonce: 0,
+            accountDeploymentData: [],
+            skipValidate: false
+        };
+        return {
+            type: "DEPLOY_ACCOUNT",
+            tx: deploymentData,
+            details
+        };
+    }
+
 }

package/src/starknet/chain/modules/StarknetAddresses.ts

@@ -1,23 +1,23 @@
-import {StarknetModule} from "../StarknetModule";
-import {validateAndParseAddress} from "starknet";
-
-export class StarknetAddresses extends StarknetModule {
-
-    ///////////////////
-    //// Address utils
-    /**
-     * Checks whether an address is a valid starknet address
-     *
-     * @param value
-     */
-    static isValidAddress(value: string): boolean {
-        if(value.length!==66) return false;
-        try {
-            validateAndParseAddress(value);
-            return true;
-        } catch (e) {
-            return false;
-        }
-    }
-
+import {StarknetModule} from "../StarknetModule";
+import {validateAndParseAddress} from "starknet";
+
+export class StarknetAddresses extends StarknetModule {
+
+    ///////////////////
+    //// Address utils
+    /**
+     * Checks whether an address is a valid starknet address
+     *
+     * @param value
+     */
+    static isValidAddress(value: string): boolean {
+        if(value.length!==66) return false;
+        try {
+            validateAndParseAddress(value);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
 }

package/src/starknet/chain/modules/StarknetBlocks.ts

@@ -1,59 +1,75 @@
-import {StarknetModule} from "../StarknetModule";
-
-export type StarknetBlockTag = "pending" | "latest";
-
-export class StarknetBlocks extends StarknetModule {
-
-    private BLOCK_CACHE_TIME = 5*1000;
-
-    private blockCache: {
-        [key in StarknetBlockTag]?: {
-            blockTime: Promise<number>,
-            timestamp: number
-        }
-    } = {};
-
-    /**
-     * Initiates fetch of a given block & saves it to cache
-     *
-     * @private
-     * @param blockTag
-     */
-    private fetchAndSaveBlockTime(blockTag: StarknetBlockTag): {
-        blockTime: Promise<number>,
-        timestamp: number
-    } {
-        const blockTimePromise = this.provider.getBlockWithTxHashes(blockTag).then(result => result.timestamp);
-        const timestamp = Date.now();
-        this.blockCache[blockTag] = {
-            blockTime: blockTimePromise,
-            timestamp
-        };
-        blockTimePromise.catch(e => {
-            if(this.blockCache[blockTag]!=null && this.blockCache[blockTag].blockTime===blockTimePromise) delete this.blockCache[blockTag];
-            throw e;
-        })
-        return {
-            blockTime: blockTimePromise,
-            timestamp
-        };
-    }
-
-    ///////////////////
-    //// Slots
-    /**
-     * Gets the block for a given blocktag, with caching
-     *
-     * @param blockTag
-     */
-    public getBlockTime(blockTag: StarknetBlockTag): Promise<number> {
-        let cachedBlockData = this.blockCache[blockTag];
-
-        if(cachedBlockData==null || Date.now()-cachedBlockData.timestamp>this.BLOCK_CACHE_TIME) {
-            cachedBlockData = this.fetchAndSaveBlockTime(blockTag);
-        }
-
-        return cachedBlockData.blockTime;
-    }
-
+import {StarknetModule} from "../StarknetModule";
+
+export type StarknetBlockTag = "pending" | "latest";
+
+export class StarknetBlocks extends StarknetModule {
+
+    private BLOCK_CACHE_TIME = 5*1000;
+
+    private blockCache: {
+        [key: string]: {
+            blockTime: Promise<number>,
+            timestamp: number
+        }
+    } = {};
+
+    /**
+     * Initiates fetch of a given block & saves it to cache
+     *
+     * @private
+     * @param blockTag
+     */
+    private fetchAndSaveBlockTime(blockTag: StarknetBlockTag | number): {
+        blockTime: Promise<number>,
+        timestamp: number
+    } {
+        const blockTagStr = blockTag.toString(10);
+
+        const blockTimePromise = this.provider.getBlockWithTxHashes(blockTag).then(result => result.timestamp);
+        const timestamp = Date.now();
+        this.blockCache[blockTagStr] = {
+            blockTime: blockTimePromise,
+            timestamp
+        };
+        blockTimePromise.catch(e => {
+            if(this.blockCache[blockTagStr]!=null && this.blockCache[blockTagStr].blockTime===blockTimePromise) delete this.blockCache[blockTagStr];
+            throw e;
+        })
+        return {
+            blockTime: blockTimePromise,
+            timestamp
+        };
+    }
+
+    private cleanupBlocks() {
+        const currentTime = Date.now();
+        //Keys are in order that they were added, so we can stop at the first non-expired block
+        for(let key in this.blockCache) {
+            const block = this.blockCache[key];
+            if(currentTime - block.timestamp > this.BLOCK_CACHE_TIME) {
+                delete this.blockCache[key];
+            } else {
+                break;
+            }
+        }
+    }
+
+    ///////////////////
+    //// Blocks
+    /**
+     * Gets the block for a given blocktag, with caching
+     *
+     * @param blockTag
+     */
+    public getBlockTime(blockTag: StarknetBlockTag | number): Promise<number> {
+        this.cleanupBlocks();
+        let cachedBlockData = this.blockCache[blockTag.toString(10)];
+
+        if(cachedBlockData==null || Date.now()-cachedBlockData.timestamp>this.BLOCK_CACHE_TIME) {
+            cachedBlockData = this.fetchAndSaveBlockTime(blockTag);
+        }
+
+        return cachedBlockData.blockTime;
+    }
+
 }

package/src/starknet/chain/modules/StarknetEvents.ts

@@ -1,105 +1,105 @@
-import {StarknetModule} from "../StarknetModule";
-
-export type StarknetEvent = {
-    block_hash: string;
-    block_number: number;
-    transaction_hash: string;
-    from_address: string;
-    keys: string[];
-    data: string[];
-}
-
-export class StarknetEvents extends StarknetModule {
-
-    public readonly EVENTS_LIMIT = 100;
-    public readonly FORWARD_BLOCK_RANGE = 2000;
-
-    /**
-     * Returns the all the events occuring in a block range as identified by the contract and keys
-     *
-     * @param contract
-     * @param keys
-     * @param startBlock
-     * @param endBlock
-     * @param abortSignal
-     */
-    public async getBlockEvents(contract: string, keys: string[][], startBlock?: number, endBlock: number = startBlock, abortSignal?: AbortSignal): Promise<StarknetEvent[]> {
-        const events: StarknetEvent[] = [];
-        let result = null;
-        while(result==null || result?.continuation_token!=null) {
-            result = await this.root.provider.getEvents({
-                address: contract,
-                from_block: startBlock==null ? "pending" : {block_number: startBlock},
-                to_block: endBlock==null ? "pending" : {block_number: endBlock},
-                keys,
-                chunk_size: this.EVENTS_LIMIT,
-                continuation_token: result?.continuation_token
-            });
-            if(abortSignal!=null) abortSignal.throwIfAborted();
-            events.push(...result.events);
-        }
-        return events;
-    }
-
-    /**
-     * Runs a search backwards in time, processing events from a specific contract and keys
-     *
-     * @param contract
-     * @param keys
-     * @param processor called for every batch of returned signatures, should return a value if the correct signature
-     *  was found, or null if the search should continue
-     * @param abortSignal
-     */
-    public async findInEvents<T>(
-        contract: string, keys: string[][],
-        processor: (signatures: StarknetEvent[]) => Promise<T>,
-        abortSignal?: AbortSignal
-    ): Promise<T> {
-        const latestBlockNumber = await this.provider.getBlockNumber();
-
-        for(let blockNumber = latestBlockNumber; blockNumber >= 0; blockNumber-=this.FORWARD_BLOCK_RANGE) {
-            const eventsResult = await this.getBlockEvents(
-                contract, keys,
-                Math.max(blockNumber-this.FORWARD_BLOCK_RANGE, 0), blockNumber===latestBlockNumber ? null : blockNumber,
-                abortSignal
-            );
-            const result: T = await processor(eventsResult.reverse());
-            if(result!=null) return result;
-        }
-        return null;
-    }
-
-    /**
-     * Runs a search forwards in time, processing events from a specific contract and keys
-     *
-     * @param contract
-     * @param keys
-     * @param processor called for every batch of returned signatures, should return a value if the correct signature
-     *  was found, or null if the search should continue
-     * @param abortSignal
-     * @param logFetchLimit
-     */
-    public async findInEventsForward<T>(
-        contract: string, keys: string[][],
-        processor: (signatures: StarknetEvent[]) => Promise<T>,
-        abortSignal?: AbortSignal,
-        logFetchLimit?: number
-    ): Promise<T> {
-        if(logFetchLimit==null || logFetchLimit>this.EVENTS_LIMIT) logFetchLimit = this.EVENTS_LIMIT;
-        let eventsResult = null;
-        while(eventsResult==null || eventsResult?.continuation_token!=null) {
-            eventsResult = await this.root.provider.getEvents({
-                address: contract,
-                to_block: "latest",
-                keys,
-                chunk_size: logFetchLimit ?? this.EVENTS_LIMIT,
-                continuation_token: eventsResult?.continuation_token
-            });
-            if(abortSignal!=null) abortSignal.throwIfAborted();
-            const result: T = await processor(eventsResult.events);
-            if(result!=null) return result;
-        }
-        return null;
-    }
-
+import {StarknetModule} from "../StarknetModule";
+
+export type StarknetEvent = {
+    block_hash: string;
+    block_number: number;
+    transaction_hash: string;
+    from_address: string;
+    keys: string[];
+    data: string[];
+}
+
+export class StarknetEvents extends StarknetModule {
+
+    public readonly EVENTS_LIMIT = 100;
+    public readonly FORWARD_BLOCK_RANGE = 2000;
+
+    /**
+     * Returns the all the events occuring in a block range as identified by the contract and keys
+     *
+     * @param contract
+     * @param keys
+     * @param startBlock
+     * @param endBlock
+     * @param abortSignal
+     */
+    public async getBlockEvents(contract: string, keys: string[][], startBlock?: number, endBlock: number = startBlock, abortSignal?: AbortSignal): Promise<StarknetEvent[]> {
+        const events: StarknetEvent[] = [];
+        let result = null;
+        while(result==null || result?.continuation_token!=null) {
+            result = await this.root.provider.getEvents({
+                address: contract,
+                from_block: startBlock==null ? "pending" : {block_number: startBlock},
+                to_block: endBlock==null ? "pending" : {block_number: endBlock},
+                keys,
+                chunk_size: this.EVENTS_LIMIT,
+                continuation_token: result?.continuation_token
+            });
+            if(abortSignal!=null) abortSignal.throwIfAborted();
+            events.push(...result.events);
+        }
+        return events;
+    }
+
+    /**
+     * Runs a search backwards in time, processing events from a specific contract and keys
+     *
+     * @param contract
+     * @param keys
+     * @param processor called for every batch of returned signatures, should return a value if the correct signature
+     *  was found, or null if the search should continue
+     * @param abortSignal
+     */
+    public async findInEvents<T>(
+        contract: string, keys: string[][],
+        processor: (signatures: StarknetEvent[]) => Promise<T>,
+        abortSignal?: AbortSignal
+    ): Promise<T> {
+        const latestBlockNumber = await this.provider.getBlockNumber();
+
+        for(let blockNumber = latestBlockNumber; blockNumber >= 0; blockNumber-=this.FORWARD_BLOCK_RANGE) {
+            const eventsResult = await this.getBlockEvents(
+                contract, keys,
+                Math.max(blockNumber-this.FORWARD_BLOCK_RANGE, 0), blockNumber===latestBlockNumber ? null : blockNumber,
+                abortSignal
+            );
+            const result: T = await processor(eventsResult.reverse());
+            if(result!=null) return result;
+        }
+        return null;
+    }
+
+    /**
+     * Runs a search forwards in time, processing events from a specific contract and keys
+     *
+     * @param contract
+     * @param keys
+     * @param processor called for every batch of returned signatures, should return a value if the correct signature
+     *  was found, or null if the search should continue
+     * @param abortSignal
+     * @param logFetchLimit
+     */
+    public async findInEventsForward<T>(
+        contract: string, keys: string[][],
+        processor: (signatures: StarknetEvent[]) => Promise<T>,
+        abortSignal?: AbortSignal,
+        logFetchLimit?: number
+    ): Promise<T> {
+        if(logFetchLimit==null || logFetchLimit>this.EVENTS_LIMIT) logFetchLimit = this.EVENTS_LIMIT;
+        let eventsResult = null;
+        while(eventsResult==null || eventsResult?.continuation_token!=null) {
+            eventsResult = await this.root.provider.getEvents({
+                address: contract,
+                to_block: "latest",
+                keys,
+                chunk_size: logFetchLimit ?? this.EVENTS_LIMIT,
+                continuation_token: eventsResult?.continuation_token
+            });
+            if(abortSignal!=null) abortSignal.throwIfAborted();
+            const result: T = await processor(eventsResult.events);
+            if(result!=null) return result;
+        }
+        return null;
+    }
+
 }