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

package/dist/starknet/contract/StarknetContractModule.js

@@ -1,11 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetContractModule = void 0;
-const StarknetModule_1 = require("../chain/StarknetModule");
-class StarknetContractModule extends StarknetModule_1.StarknetModule {
-    constructor(chainInterface, contract) {
-        super(chainInterface);
-        this.contract = contract;
-    }
-}
-exports.StarknetContractModule = StarknetContractModule;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetContractModule = void 0;
+const StarknetModule_1 = require("../chain/StarknetModule");
+class StarknetContractModule extends StarknetModule_1.StarknetModule {
+    constructor(chainInterface, contract) {
+        super(chainInterface);
+        this.contract = contract;
+    }
+}
+exports.StarknetContractModule = StarknetContractModule;

package/dist/starknet/contract/modules/StarknetContractEvents.d.ts

@@ -1,51 +1,51 @@
-import { Abi } from "abi-wan-kanabi";
-import { EventToPrimitiveType, ExtractAbiEventNames } from "abi-wan-kanabi/dist/kanabi";
-import { StarknetEvents } from "../../chain/modules/StarknetEvents";
-import { StarknetContractBase } from "../StarknetContractBase";
-import { StarknetChainInterface } from "../../chain/StarknetChainInterface";
-export type StarknetAbiEvent<TAbi extends Abi, TEventName extends ExtractAbiEventNames<TAbi>> = {
-    name: TEventName;
-    params: EventToPrimitiveType<TAbi, TEventName>;
-    txHash: string;
-    blockHash: string;
-    blockNumber: number;
-    keys: string[];
-    data: string[];
-};
-export declare class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
-    readonly contract: StarknetContractBase<TAbi>;
-    readonly abi: TAbi;
-    constructor(chainInterface: StarknetChainInterface, contract: StarknetContractBase<TAbi>, abi: TAbi);
-    private toStarknetAbiEvents;
-    private toFilter;
-    /**
-     * Returns the events occuring in a range of starknet block as identified by the contract and keys,
-     *  returns pending events if no startHeight & endHeight is passed
-     *
-     * @param events
-     * @param keys
-     * @param startBlockHeight
-     * @param endBlockHeight
-     */
-    getContractBlockEvents<T extends ExtractAbiEventNames<TAbi>>(events: T[], keys: string[], startBlockHeight?: number, endBlockHeight?: number): Promise<StarknetAbiEvent<TAbi, T>[]>;
-    /**
-     * Runs a search backwards in time, processing the events for a specific topic public key
-     *
-     * @param events
-     * @param keys
-     * @param processor called for every event, should return a value if the correct event was found, or null
-     *  if the search should continue
-     * @param abortSignal
-     */
-    findInContractEvents<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: string[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
-    /**
-     * Runs a search forwards in time, processing the events for a specific topic public key
-     *
-     * @param events
-     * @param keys
-     * @param processor called for every event, should return a value if the correct event was found, or null
-     *  if the search should continue
-     * @param abortSignal
-     */
-    findInContractEventsForward<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: string[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
-}
+import { Abi } from "abi-wan-kanabi";
+import { EventToPrimitiveType, ExtractAbiEventNames } from "abi-wan-kanabi/dist/kanabi";
+import { StarknetEvents } from "../../chain/modules/StarknetEvents";
+import { StarknetContractBase } from "../StarknetContractBase";
+import { StarknetChainInterface } from "../../chain/StarknetChainInterface";
+export type StarknetAbiEvent<TAbi extends Abi, TEventName extends ExtractAbiEventNames<TAbi>> = {
+    name: TEventName;
+    params: EventToPrimitiveType<TAbi, TEventName>;
+    txHash: string;
+    blockHash: string;
+    blockNumber: number;
+    keys: string[];
+    data: string[];
+};
+export declare class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
+    readonly contract: StarknetContractBase<TAbi>;
+    readonly abi: TAbi;
+    constructor(chainInterface: StarknetChainInterface, contract: StarknetContractBase<TAbi>, abi: TAbi);
+    private toStarknetAbiEvents;
+    private toFilter;
+    /**
+     * Returns the events occuring in a range of starknet block as identified by the contract and keys,
+     *  returns pending events if no startHeight & endHeight is passed
+     *
+     * @param events
+     * @param keys
+     * @param startBlockHeight
+     * @param endBlockHeight
+     */
+    getContractBlockEvents<T extends ExtractAbiEventNames<TAbi>>(events: T[], keys: string[], startBlockHeight?: number, endBlockHeight?: number): Promise<StarknetAbiEvent<TAbi, T>[]>;
+    /**
+     * Runs a search backwards in time, processing the events for a specific topic public key
+     *
+     * @param events
+     * @param keys
+     * @param processor called for every event, should return a value if the correct event was found, or null
+     *  if the search should continue
+     * @param abortSignal
+     */
+    findInContractEvents<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: string[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
+    /**
+     * Runs a search forwards in time, processing the events for a specific topic public key
+     *
+     * @param events
+     * @param keys
+     * @param processor called for every event, should return a value if the correct event was found, or null
+     *  if the search should continue
+     * @param abortSignal
+     */
+    findInContractEventsForward<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: string[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
+}

package/dist/starknet/contract/modules/StarknetContractEvents.js

@@ -1,97 +1,97 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetContractEvents = void 0;
-const StarknetEvents_1 = require("../../chain/modules/StarknetEvents");
-const starknet_1 = require("starknet");
-const Utils_1 = require("../../../utils/Utils");
-class StarknetContractEvents extends StarknetEvents_1.StarknetEvents {
-    constructor(chainInterface, contract, abi) {
-        super(chainInterface);
-        this.contract = contract;
-        this.abi = abi;
-    }
-    toStarknetAbiEvents(blockEvents) {
-        const abiEvents = starknet_1.events.getAbiEvents(this.abi);
-        const abiStructs = starknet_1.CallData.getAbiStruct(this.abi);
-        const abiEnums = starknet_1.CallData.getAbiEnum(this.abi);
-        const result = starknet_1.events.parseEvents(blockEvents, abiEvents, abiStructs, abiEnums);
-        if (result.length !== blockEvents.length)
-            throw new Error("Invalid event detected, please check provided ABI");
-        return result.map((value, index) => {
-            const starknetEvent = blockEvents[index];
-            const name = Object.keys(value)[0];
-            return {
-                name: name,
-                txHash: starknetEvent.transaction_hash,
-                params: value[name],
-                blockNumber: starknetEvent.block_number,
-                blockHash: starknetEvent.block_hash,
-                data: starknetEvent.data,
-                keys: starknetEvent.keys
-            };
-        });
-    }
-    toFilter(events, keys) {
-        const filterArray = [];
-        filterArray.push(events.map(name => {
-            const arr = name.split(":");
-            const eventName = arr[arr.length - 1];
-            return (0, Utils_1.toHex)(starknet_1.hash.starknetKeccak(eventName));
-        }));
-        if (keys != null)
-            keys.forEach(key => filterArray.push(key == null ? [] : [key]));
-        return filterArray;
-    }
-    /**
-     * Returns the events occuring in a range of starknet block as identified by the contract and keys,
-     *  returns pending events if no startHeight & endHeight is passed
-     *
-     * @param events
-     * @param keys
-     * @param startBlockHeight
-     * @param endBlockHeight
-     */
-    async getContractBlockEvents(events, keys, startBlockHeight, endBlockHeight = startBlockHeight) {
-        const blockEvents = await super.getBlockEvents(this.contract.contract.address, this.toFilter(events, keys), startBlockHeight, endBlockHeight);
-        return this.toStarknetAbiEvents(blockEvents);
-    }
-    /**
-     * Runs a search backwards in time, processing the events for a specific topic public key
-     *
-     * @param events
-     * @param keys
-     * @param processor called for every event, should return a value if the correct event was found, or null
-     *  if the search should continue
-     * @param abortSignal
-     */
-    async findInContractEvents(events, keys, processor, abortSignal) {
-        return this.findInEvents(this.contract.contract.address, this.toFilter(events, keys), async (events) => {
-            const parsedEvents = this.toStarknetAbiEvents(events);
-            for (let event of parsedEvents) {
-                const result = await processor(event);
-                if (result != null)
-                    return result;
-            }
-        }, abortSignal);
-    }
-    /**
-     * Runs a search forwards in time, processing the events for a specific topic public key
-     *
-     * @param events
-     * @param keys
-     * @param processor called for every event, should return a value if the correct event was found, or null
-     *  if the search should continue
-     * @param abortSignal
-     */
-    async findInContractEventsForward(events, keys, processor, abortSignal) {
-        return this.findInEventsForward(this.contract.contract.address, this.toFilter(events, keys), async (events) => {
-            const parsedEvents = this.toStarknetAbiEvents(events);
-            for (let event of parsedEvents) {
-                const result = await processor(event);
-                if (result != null)
-                    return result;
-            }
-        }, abortSignal);
-    }
-}
-exports.StarknetContractEvents = StarknetContractEvents;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetContractEvents = void 0;
+const StarknetEvents_1 = require("../../chain/modules/StarknetEvents");
+const starknet_1 = require("starknet");
+const Utils_1 = require("../../../utils/Utils");
+class StarknetContractEvents extends StarknetEvents_1.StarknetEvents {
+    constructor(chainInterface, contract, abi) {
+        super(chainInterface);
+        this.contract = contract;
+        this.abi = abi;
+    }
+    toStarknetAbiEvents(blockEvents) {
+        const abiEvents = starknet_1.events.getAbiEvents(this.abi);
+        const abiStructs = starknet_1.CallData.getAbiStruct(this.abi);
+        const abiEnums = starknet_1.CallData.getAbiEnum(this.abi);
+        const result = starknet_1.events.parseEvents(blockEvents, abiEvents, abiStructs, abiEnums, (0, starknet_1.createAbiParser)(this.abi));
+        if (result.length !== blockEvents.length)
+            throw new Error("Invalid event detected, please check provided ABI");
+        return result.map((value, index) => {
+            const starknetEvent = blockEvents[index];
+            const name = Object.keys(value)[0];
+            return {
+                name: name,
+                txHash: starknetEvent.transaction_hash,
+                params: value[name],
+                blockNumber: starknetEvent.block_number,
+                blockHash: starknetEvent.block_hash,
+                data: starknetEvent.data,
+                keys: starknetEvent.keys
+            };
+        });
+    }
+    toFilter(events, keys) {
+        const filterArray = [];
+        filterArray.push(events.map(name => {
+            const arr = name.split(":");
+            const eventName = arr[arr.length - 1];
+            return (0, Utils_1.toHex)(starknet_1.hash.starknetKeccak(eventName));
+        }));
+        if (keys != null)
+            keys.forEach(key => filterArray.push(key == null ? [] : [key]));
+        return filterArray;
+    }
+    /**
+     * Returns the events occuring in a range of starknet block as identified by the contract and keys,
+     *  returns pending events if no startHeight & endHeight is passed
+     *
+     * @param events
+     * @param keys
+     * @param startBlockHeight
+     * @param endBlockHeight
+     */
+    async getContractBlockEvents(events, keys, startBlockHeight, endBlockHeight = startBlockHeight) {
+        const blockEvents = await super.getBlockEvents(this.contract.contract.address, this.toFilter(events, keys), startBlockHeight, endBlockHeight);
+        return this.toStarknetAbiEvents(blockEvents);
+    }
+    /**
+     * Runs a search backwards in time, processing the events for a specific topic public key
+     *
+     * @param events
+     * @param keys
+     * @param processor called for every event, should return a value if the correct event was found, or null
+     *  if the search should continue
+     * @param abortSignal
+     */
+    async findInContractEvents(events, keys, processor, abortSignal) {
+        return this.findInEvents(this.contract.contract.address, this.toFilter(events, keys), async (events) => {
+            const parsedEvents = this.toStarknetAbiEvents(events);
+            for (let event of parsedEvents) {
+                const result = await processor(event);
+                if (result != null)
+                    return result;
+            }
+        }, abortSignal);
+    }
+    /**
+     * Runs a search forwards in time, processing the events for a specific topic public key
+     *
+     * @param events
+     * @param keys
+     * @param processor called for every event, should return a value if the correct event was found, or null
+     *  if the search should continue
+     * @param abortSignal
+     */
+    async findInContractEventsForward(events, keys, processor, abortSignal) {
+        return this.findInEventsForward(this.contract.contract.address, this.toFilter(events, keys), async (events) => {
+            const parsedEvents = this.toStarknetAbiEvents(events);
+            for (let event of parsedEvents) {
+                const result = await processor(event);
+                if (result != null)
+                    return result;
+            }
+        }, abortSignal);
+    }
+}
+exports.StarknetContractEvents = StarknetContractEvents;

package/dist/starknet/events/StarknetChainEvents.d.ts

@@ -1,21 +1,21 @@
-import { StarknetChainEventsBrowser } from "./StarknetChainEventsBrowser";
-import { StarknetSwapContract } from "../swaps/StarknetSwapContract";
-import { StarknetChainInterface } from "../chain/StarknetChainInterface";
-import { StarknetSpvVaultContract } from "../spv_swap/StarknetSpvVaultContract";
-export declare class StarknetChainEvents extends StarknetChainEventsBrowser {
-    private readonly directory;
-    constructor(directory: string, chainInterface: StarknetChainInterface, starknetSwapContract: StarknetSwapContract, starknetSpvVaultContract: StarknetSpvVaultContract, pollIntervalSeconds?: number);
-    /**
-     * Retrieves last signature & slot from filesystem
-     *
-     * @private
-     */
-    private getLastEventData;
-    /**
-     * Saves last signature & slot to the filesystem
-     *
-     * @private
-     */
-    private saveLastEventData;
-    init(): Promise<void>;
-}
+import { StarknetChainEventsBrowser } from "./StarknetChainEventsBrowser";
+import { StarknetSwapContract } from "../swaps/StarknetSwapContract";
+import { StarknetChainInterface } from "../chain/StarknetChainInterface";
+import { StarknetSpvVaultContract } from "../spv_swap/StarknetSpvVaultContract";
+export declare class StarknetChainEvents extends StarknetChainEventsBrowser {
+    private readonly directory;
+    constructor(directory: string, chainInterface: StarknetChainInterface, starknetSwapContract: StarknetSwapContract, starknetSpvVaultContract: StarknetSpvVaultContract, pollIntervalSeconds?: number);
+    /**
+     * Retrieves last signature & slot from filesystem
+     *
+     * @private
+     */
+    private getLastEventData;
+    /**
+     * Saves last signature & slot to the filesystem
+     *
+     * @private
+     */
+    private saveLastEventData;
+    init(): Promise<void>;
+}

package/dist/starknet/events/StarknetChainEvents.js

@@ -1,52 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetChainEvents = void 0;
-const StarknetChainEventsBrowser_1 = require("./StarknetChainEventsBrowser");
-//@ts-ignore
-const fs = require("fs/promises");
-const BLOCKHEIGHT_FILENAME = "/strk-blockheight.txt";
-class StarknetChainEvents extends StarknetChainEventsBrowser_1.StarknetChainEventsBrowser {
-    constructor(directory, chainInterface, starknetSwapContract, starknetSpvVaultContract, pollIntervalSeconds) {
-        super(chainInterface, starknetSwapContract, starknetSpvVaultContract, pollIntervalSeconds);
-        this.directory = directory;
-    }
-    /**
-     * Retrieves last signature & slot from filesystem
-     *
-     * @private
-     */
-    async getLastEventData() {
-        try {
-            const txt = (await fs.readFile(this.directory + BLOCKHEIGHT_FILENAME)).toString();
-            const arr = txt.split(";");
-            if (arr.length < 2)
-                return {
-                    blockNumber: parseInt(arr[0]),
-                    txHashes: null
-                };
-            return {
-                blockNumber: parseInt(arr[0]),
-                txHashes: arr.slice(1)
-            };
-        }
-        catch (e) {
-            return {
-                blockNumber: null,
-                txHashes: null
-            };
-        }
-    }
-    /**
-     * Saves last signature & slot to the filesystem
-     *
-     * @private
-     */
-    saveLastEventData(blockNumber, txHashes) {
-        return fs.writeFile(this.directory + BLOCKHEIGHT_FILENAME, blockNumber.toString() + ";" + txHashes.join(";"));
-    }
-    async init() {
-        const { blockNumber, txHashes } = await this.getLastEventData();
-        await this.setupPoll(blockNumber, txHashes, (blockNumber, txHashes) => this.saveLastEventData(blockNumber, txHashes));
-    }
-}
-exports.StarknetChainEvents = StarknetChainEvents;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetChainEvents = void 0;
+const StarknetChainEventsBrowser_1 = require("./StarknetChainEventsBrowser");
+//@ts-ignore
+const fs = require("fs/promises");
+const BLOCKHEIGHT_FILENAME = "/strk-blockheight.txt";
+class StarknetChainEvents extends StarknetChainEventsBrowser_1.StarknetChainEventsBrowser {
+    constructor(directory, chainInterface, starknetSwapContract, starknetSpvVaultContract, pollIntervalSeconds) {
+        super(chainInterface, starknetSwapContract, starknetSpvVaultContract, pollIntervalSeconds);
+        this.directory = directory;
+    }
+    /**
+     * Retrieves last signature & slot from filesystem
+     *
+     * @private
+     */
+    async getLastEventData() {
+        try {
+            const txt = (await fs.readFile(this.directory + BLOCKHEIGHT_FILENAME)).toString();
+            const arr = txt.split(";");
+            if (arr.length < 2)
+                return {
+                    blockNumber: parseInt(arr[0]),
+                    txHashes: null
+                };
+            return {
+                blockNumber: parseInt(arr[0]),
+                txHashes: arr.slice(1)
+            };
+        }
+        catch (e) {
+            return {
+                blockNumber: null,
+                txHashes: null
+            };
+        }
+    }
+    /**
+     * Saves last signature & slot to the filesystem
+     *
+     * @private
+     */
+    saveLastEventData(blockNumber, txHashes) {
+        return fs.writeFile(this.directory + BLOCKHEIGHT_FILENAME, blockNumber.toString() + ";" + txHashes.join(";"));
+    }
+    async init() {
+        const { blockNumber, txHashes } = await this.getLastEventData();
+        await this.setupPoll(blockNumber, txHashes, (blockNumber, txHashes) => this.saveLastEventData(blockNumber, txHashes));
+    }
+}
+exports.StarknetChainEvents = StarknetChainEvents;