@atomiqlabs/chain-starknet 4.0.0-dev.12 → 4.0.0-dev.13

package/dist/starknet/chain/modules/StarknetAccounts.d.ts

@@ -1,6 +1,6 @@
-import { StarknetModule } from "../StarknetModule";
-import { StarknetTx } from "./StarknetTransactions";
-import { DeployAccountContractPayload } from "starknet";
-export declare class StarknetAccounts extends StarknetModule {
-    getAccountDeployTransaction(deploymentData: DeployAccountContractPayload): Promise<StarknetTx>;
-}
+import { StarknetModule } from "../StarknetModule";
+import { StarknetTx } from "./StarknetTransactions";
+import { DeployAccountContractPayload } from "starknet";
+export declare class StarknetAccounts extends StarknetModule {
+    getAccountDeployTransaction(deploymentData: DeployAccountContractPayload): Promise<StarknetTx>;
+}

package/dist/starknet/chain/modules/StarknetAccounts.js

@@ -1,24 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetAccounts = void 0;
-const StarknetModule_1 = require("../StarknetModule");
-class StarknetAccounts extends StarknetModule_1.StarknetModule {
-    async getAccountDeployTransaction(deploymentData) {
-        const feeDetails = this.root.Fees.getFeeDetails({ l1DataGas: 500, l2Gas: 5000 * 40000, l1Gas: 0 }, await this.root.Fees.getFeeRate());
-        const details = {
-            ...feeDetails,
-            walletAddress: deploymentData.contractAddress,
-            cairoVersion: "1",
-            chainId: this.root.starknetChainId,
-            nonce: 0,
-            accountDeploymentData: [],
-            skipValidate: false
-        };
-        return {
-            type: "DEPLOY_ACCOUNT",
-            tx: deploymentData,
-            details
-        };
-    }
-}
-exports.StarknetAccounts = StarknetAccounts;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetAccounts = void 0;
+const StarknetModule_1 = require("../StarknetModule");
+class StarknetAccounts extends StarknetModule_1.StarknetModule {
+    async getAccountDeployTransaction(deploymentData) {
+        const feeDetails = this.root.Fees.getFeeDetails({ l1DataGas: 500, l2Gas: 5000 * 40000, l1Gas: 0 }, await this.root.Fees.getFeeRate());
+        const details = {
+            ...feeDetails,
+            walletAddress: deploymentData.contractAddress,
+            cairoVersion: "1",
+            chainId: this.root.starknetChainId,
+            nonce: 0,
+            accountDeploymentData: [],
+            skipValidate: false
+        };
+        return {
+            type: "DEPLOY_ACCOUNT",
+            tx: deploymentData,
+            details
+        };
+    }
+}
+exports.StarknetAccounts = StarknetAccounts;

package/dist/starknet/chain/modules/StarknetAddresses.d.ts

@@ -1,9 +1,9 @@
-import { StarknetModule } from "../StarknetModule";
-export declare class StarknetAddresses extends StarknetModule {
-    /**
-     * Checks whether an address is a valid starknet address
-     *
-     * @param value
-     */
-    static isValidAddress(value: string): boolean;
-}
+import { StarknetModule } from "../StarknetModule";
+export declare class StarknetAddresses extends StarknetModule {
+    /**
+     * Checks whether an address is a valid starknet address
+     *
+     * @param value
+     */
+    static isValidAddress(value: string): boolean;
+}

package/dist/starknet/chain/modules/StarknetAddresses.js

@@ -1,26 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetAddresses = void 0;
-const StarknetModule_1 = require("../StarknetModule");
-const starknet_1 = require("starknet");
-class StarknetAddresses extends StarknetModule_1.StarknetModule {
-    ///////////////////
-    //// Address utils
-    /**
-     * Checks whether an address is a valid starknet address
-     *
-     * @param value
-     */
-    static isValidAddress(value) {
-        if (value.length !== 66)
-            return false;
-        try {
-            (0, starknet_1.validateAndParseAddress)(value);
-            return true;
-        }
-        catch (e) {
-            return false;
-        }
-    }
-}
-exports.StarknetAddresses = StarknetAddresses;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetAddresses = void 0;
+const StarknetModule_1 = require("../StarknetModule");
+const starknet_1 = require("starknet");
+class StarknetAddresses extends StarknetModule_1.StarknetModule {
+    ///////////////////
+    //// Address utils
+    /**
+     * Checks whether an address is a valid starknet address
+     *
+     * @param value
+     */
+    static isValidAddress(value) {
+        if (value.length !== 66)
+            return false;
+        try {
+            (0, starknet_1.validateAndParseAddress)(value);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+}
+exports.StarknetAddresses = StarknetAddresses;

package/dist/starknet/chain/modules/StarknetBlocks.d.ts

@@ -1,20 +1,20 @@
-import { StarknetModule } from "../StarknetModule";
-export type StarknetBlockTag = "pending" | "latest";
-export declare class StarknetBlocks extends StarknetModule {
-    private BLOCK_CACHE_TIME;
-    private blockCache;
-    /**
-     * Initiates fetch of a given block & saves it to cache
-     *
-     * @private
-     * @param blockTag
-     */
-    private fetchAndSaveBlockTime;
-    private cleanupBlocks;
-    /**
-     * Gets the block for a given blocktag, with caching
-     *
-     * @param blockTag
-     */
-    getBlockTime(blockTag: StarknetBlockTag | number): Promise<number>;
-}
+import { StarknetModule } from "../StarknetModule";
+export type StarknetBlockTag = "pre_confirmed" | "latest";
+export declare class StarknetBlocks extends StarknetModule {
+    private BLOCK_CACHE_TIME;
+    private blockCache;
+    /**
+     * Initiates fetch of a given block & saves it to cache
+     *
+     * @private
+     * @param blockTag
+     */
+    private fetchAndSaveBlockTime;
+    private cleanupBlocks;
+    /**
+     * Gets the block for a given blocktag, with caching
+     *
+     * @param blockTag
+     */
+    getBlockTime(blockTag: StarknetBlockTag | number): Promise<number>;
+}

package/dist/starknet/chain/modules/StarknetBlocks.js

@@ -1,64 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetBlocks = void 0;
-const StarknetModule_1 = require("../StarknetModule");
-class StarknetBlocks extends StarknetModule_1.StarknetModule {
-    constructor() {
-        super(...arguments);
-        this.BLOCK_CACHE_TIME = 5 * 1000;
-        this.blockCache = {};
-    }
-    /**
-     * Initiates fetch of a given block & saves it to cache
-     *
-     * @private
-     * @param blockTag
-     */
-    fetchAndSaveBlockTime(blockTag) {
-        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
-        };
-    }
-    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
-     */
-    getBlockTime(blockTag) {
-        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;
-    }
-}
-exports.StarknetBlocks = StarknetBlocks;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetBlocks = void 0;
+const StarknetModule_1 = require("../StarknetModule");
+class StarknetBlocks extends StarknetModule_1.StarknetModule {
+    constructor() {
+        super(...arguments);
+        this.BLOCK_CACHE_TIME = 5 * 1000;
+        this.blockCache = {};
+    }
+    /**
+     * Initiates fetch of a given block & saves it to cache
+     *
+     * @private
+     * @param blockTag
+     */
+    fetchAndSaveBlockTime(blockTag) {
+        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
+        };
+    }
+    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
+     */
+    getBlockTime(blockTag) {
+        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;
+    }
+}
+exports.StarknetBlocks = StarknetBlocks;

package/dist/starknet/chain/modules/StarknetEvents.d.ts

@@ -1,44 +1,44 @@
-import { StarknetModule } from "../StarknetModule";
-export type StarknetEvent = {
-    block_hash: string;
-    block_number: number;
-    transaction_hash: string;
-    from_address: string;
-    keys: string[];
-    data: string[];
-};
-export declare class StarknetEvents extends StarknetModule {
-    readonly EVENTS_LIMIT = 100;
-    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
-     */
-    getBlockEvents(contract: string, keys: string[][], startBlock?: number, endBlock?: number, abortSignal?: AbortSignal): Promise<StarknetEvent[]>;
-    /**
-     * 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
-     */
-    findInEvents<T>(contract: string, keys: string[][], processor: (signatures: StarknetEvent[]) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
-    /**
-     * 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
-     */
-    findInEventsForward<T>(contract: string, keys: string[][], processor: (signatures: StarknetEvent[]) => Promise<T>, abortSignal?: AbortSignal, logFetchLimit?: number): Promise<T>;
-}
+import { StarknetModule } from "../StarknetModule";
+export type StarknetEvent = {
+    block_hash: string;
+    block_number: number;
+    transaction_hash: string;
+    from_address: string;
+    keys: string[];
+    data: string[];
+};
+export declare class StarknetEvents extends StarknetModule {
+    readonly EVENTS_LIMIT = 100;
+    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
+     */
+    getBlockEvents(contract: string, keys: string[][], startBlock?: number, endBlock?: number, abortSignal?: AbortSignal): Promise<StarknetEvent[]>;
+    /**
+     * 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
+     */
+    findInEvents<T>(contract: string, keys: string[][], processor: (signatures: StarknetEvent[]) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
+    /**
+     * 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
+     */
+    findInEventsForward<T>(contract: string, keys: string[][], processor: (signatures: StarknetEvent[]) => Promise<T>, abortSignal?: AbortSignal, logFetchLimit?: number): Promise<T>;
+}

package/dist/starknet/chain/modules/StarknetEvents.js

@@ -1,88 +1,88 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetEvents = void 0;
-const StarknetModule_1 = require("../StarknetModule");
-class StarknetEvents extends StarknetModule_1.StarknetModule {
-    constructor() {
-        super(...arguments);
-        this.EVENTS_LIMIT = 100;
-        this.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
-     */
-    async getBlockEvents(contract, keys, startBlock, endBlock = startBlock, abortSignal) {
-        const events = [];
-        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
-     */
-    async findInEvents(contract, keys, processor, abortSignal) {
-        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 = 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
-     */
-    async findInEventsForward(contract, keys, processor, abortSignal, logFetchLimit) {
-        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 = await processor(eventsResult.events);
-            if (result != null)
-                return result;
-        }
-        return null;
-    }
-}
-exports.StarknetEvents = StarknetEvents;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetEvents = void 0;
+const StarknetModule_1 = require("../StarknetModule");
+class StarknetEvents extends StarknetModule_1.StarknetModule {
+    constructor() {
+        super(...arguments);
+        this.EVENTS_LIMIT = 100;
+        this.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
+     */
+    async getBlockEvents(contract, keys, startBlock, endBlock = startBlock, abortSignal) {
+        const events = [];
+        let result = null;
+        while (result == null || result?.continuation_token != null) {
+            result = await this.root.provider.getEvents({
+                address: contract,
+                from_block: startBlock == null ? "latest" : { block_number: startBlock },
+                to_block: endBlock == null ? "latest" : { 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
+     */
+    async findInEvents(contract, keys, processor, abortSignal) {
+        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 = 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
+     */
+    async findInEventsForward(contract, keys, processor, abortSignal, logFetchLimit) {
+        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 = await processor(eventsResult.events);
+            if (result != null)
+                return result;
+        }
+        return null;
+    }
+}
+exports.StarknetEvents = StarknetEvents;