@atomiqlabs/chain-starknet 4.0.0-dev.3 → 4.0.0-dev.31

package/src/starknet/contract/StarknetContractBase.ts

@@ -1,26 +1,30 @@
-import {StarknetChainInterface} from "../chain/StarknetChainInterface";
-import {Contract, TypedContractV2} from "starknet";
-import {Abi} from "abi-wan-kanabi";
-import {StarknetContractEvents} from "./modules/StarknetContractEvents";
-
-/**
- * Base class providing program specific utilities
- */
-export class StarknetContractBase<T extends Abi> {
-
-    contract: TypedContractV2<T>;
-
-    public readonly Events: StarknetContractEvents<T>;
-    public readonly Chain: StarknetChainInterface;
-
-    constructor(
-        chainInterface: StarknetChainInterface,
-        contractAddress: string,
-        contractAbi: T
-    ) {
-        this.Chain = chainInterface;
-        this.contract = new Contract(contractAbi, contractAddress, chainInterface.provider).typedv2(contractAbi);
-        this.Events = new StarknetContractEvents(chainInterface, this, contractAbi);
-    }
-
-}
+import {StarknetChainInterface} from "../chain/StarknetChainInterface";
+import {Contract, TypedContractV2} from "starknet";
+import {Abi} from "abi-wan-kanabi";
+import {StarknetContractEvents} from "./modules/StarknetContractEvents";
+
+/**
+ * Base class providing program specific utilities
+ */
+export class StarknetContractBase<T extends Abi> {
+
+    contract: TypedContractV2<T>;
+
+    public readonly Events: StarknetContractEvents<T>;
+    public readonly Chain: StarknetChainInterface;
+
+    constructor(
+        chainInterface: StarknetChainInterface,
+        contractAddress: string,
+        contractAbi: T
+    ) {
+        this.Chain = chainInterface;
+        this.contract = new Contract({
+            abi: contractAbi,
+            address: contractAddress,
+            providerOrAccount: chainInterface.provider
+        }).typedv2(contractAbi);
+        this.Events = new StarknetContractEvents(chainInterface, this, contractAbi);
+    }
+
+}

package/src/starknet/contract/StarknetContractModule.ts

@@ -1,16 +1,16 @@
-import {Abi} from "abi-wan-kanabi";
-import {StarknetContractBase} from "./StarknetContractBase";
-import {StarknetChainInterface} from "../chain/StarknetChainInterface";
-import {StarknetModule} from "../chain/StarknetModule";
-
-
-export class StarknetContractModule<TAbi extends Abi> extends StarknetModule {
-
-    readonly contract: StarknetContractBase<TAbi>;
-
-    constructor(chainInterface: StarknetChainInterface, contract: StarknetContractBase<TAbi>) {
-        super(chainInterface)
-        this.contract = contract;
-    }
-
-}
+import {Abi} from "abi-wan-kanabi";
+import {StarknetContractBase} from "./StarknetContractBase";
+import {StarknetChainInterface} from "../chain/StarknetChainInterface";
+import {StarknetModule} from "../chain/StarknetModule";
+
+
+export class StarknetContractModule<TAbi extends Abi> extends StarknetModule {
+
+    readonly contract: StarknetContractBase<TAbi>;
+
+    constructor(chainInterface: StarknetChainInterface, contract: StarknetContractBase<TAbi>) {
+        super(chainInterface)
+        this.contract = contract;
+    }
+
+}

package/src/starknet/contract/modules/StarknetContractEvents.ts

@@ -1,134 +1,134 @@
-import {Abi} from "abi-wan-kanabi";
-import {EventToPrimitiveType, ExtractAbiEventNames} from "abi-wan-kanabi/dist/kanabi";
-import {StarknetEvent, StarknetEvents} from "../../chain/modules/StarknetEvents";
-import {CallData, events, hash} from "starknet";
-import {StarknetContractBase} from "../StarknetContractBase";
-import {toHex} from "../../../utils/Utils";
-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 class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
-
-    readonly contract: StarknetContractBase<TAbi>;
-    readonly abi: TAbi;
-
-    constructor(chainInterface: StarknetChainInterface, contract: StarknetContractBase<TAbi>, abi: TAbi) {
-        super(chainInterface);
-        this.contract = contract;
-        this.abi = abi;
-    }
-
-    private toStarknetAbiEvents<T extends ExtractAbiEventNames<TAbi>>(blockEvents: StarknetEvent[]): StarknetAbiEvent<TAbi, T>[] {
-        const abiEvents = events.getAbiEvents(this.abi);
-        const abiStructs = CallData.getAbiStruct(this.abi);
-        const abiEnums = CallData.getAbiEnum(this.abi);
-
-        const result = 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 as T,
-                txHash: starknetEvent.transaction_hash,
-                params: value[name] as any,
-                blockNumber: starknetEvent.block_number,
-                blockHash: starknetEvent.block_hash,
-                data: starknetEvent.data,
-                keys: starknetEvent.keys
-            }
-        });
-    }
-
-    private toFilter<T extends ExtractAbiEventNames<TAbi>>(
-        events: T[],
-        keys: string[],
-    ): string[][] {
-        const filterArray: string[][] = [];
-        filterArray.push(events.map(name => {
-            const arr = name.split(":");
-            const eventName = arr[arr.length-1];
-            return toHex(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
-     */
-    public async getContractBlockEvents<T extends ExtractAbiEventNames<TAbi>>(
-        events: T[],
-        keys: string[],
-        startBlockHeight?: number,
-        endBlockHeight: number = startBlockHeight
-    ): Promise<StarknetAbiEvent<TAbi, T>[]> {
-        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
-     */
-    public async findInContractEvents<T, TEvent extends ExtractAbiEventNames<TAbi>>(
-        events: TEvent[],
-        keys: string[],
-        processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>,
-        abortSignal?: AbortSignal
-    ) {
-        return this.findInEvents<T>(this.contract.contract.address, this.toFilter(events, keys), async (events: StarknetEvent[]) => {
-            const parsedEvents = this.toStarknetAbiEvents<TEvent>(events);
-            for(let event of parsedEvents) {
-                const result: T = 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
-     */
-    public async findInContractEventsForward<T, TEvent extends ExtractAbiEventNames<TAbi>>(
-        events: TEvent[],
-        keys: string[],
-        processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>,
-        abortSignal?: AbortSignal
-    ) {
-        return this.findInEventsForward<T>(this.contract.contract.address, this.toFilter(events, keys), async (events: StarknetEvent[]) => {
-            const parsedEvents = this.toStarknetAbiEvents<TEvent>(events);
-            for(let event of parsedEvents) {
-                const result: T = await processor(event);
-                if(result!=null) return result;
-            }
-        }, abortSignal);
-    }
-
-}
-
+import {Abi} from "abi-wan-kanabi";
+import {EventToPrimitiveType, ExtractAbiEventNames} from "abi-wan-kanabi/dist/kanabi";
+import {StarknetEvent, StarknetEvents} from "../../chain/modules/StarknetEvents";
+import {CallData, events, hash, createAbiParser} from "starknet";
+import {StarknetContractBase} from "../StarknetContractBase";
+import {toHex} from "../../../utils/Utils";
+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 class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
+
+    readonly contract: StarknetContractBase<TAbi>;
+    readonly abi: TAbi;
+
+    constructor(chainInterface: StarknetChainInterface, contract: StarknetContractBase<TAbi>, abi: TAbi) {
+        super(chainInterface);
+        this.contract = contract;
+        this.abi = abi;
+    }
+
+    private toStarknetAbiEvents<T extends ExtractAbiEventNames<TAbi>>(blockEvents: StarknetEvent[]): StarknetAbiEvent<TAbi, T>[] {
+        const abiEvents = events.getAbiEvents(this.abi);
+        const abiStructs = CallData.getAbiStruct(this.abi);
+        const abiEnums = CallData.getAbiEnum(this.abi);
+
+        const result = events.parseEvents(blockEvents, abiEvents, abiStructs, abiEnums, 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 as T,
+                txHash: starknetEvent.transaction_hash,
+                params: value[name] as any,
+                blockNumber: starknetEvent.block_number,
+                blockHash: starknetEvent.block_hash,
+                data: starknetEvent.data,
+                keys: starknetEvent.keys
+            }
+        });
+    }
+
+    private toFilter<T extends ExtractAbiEventNames<TAbi>>(
+        events: T[],
+        keys: (string | string[])[],
+    ): string[][] {
+        const filterArray: string[][] = [];
+        filterArray.push(events.map(name => {
+            const arr = name.split(":");
+            const eventName = arr[arr.length-1];
+            return toHex(hash.starknetKeccak(eventName))
+        }));
+        if(keys!=null) keys.forEach(key => filterArray.push(key==null ? [] : Array.isArray(key) ? key : [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
+     */
+    public async getContractBlockEvents<T extends ExtractAbiEventNames<TAbi>>(
+        events: T[],
+        keys: (string | string[])[],
+        startBlockHeight?: number,
+        endBlockHeight: number = startBlockHeight
+    ): Promise<StarknetAbiEvent<TAbi, T>[]> {
+        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
+     */
+    public async findInContractEvents<T, TEvent extends ExtractAbiEventNames<TAbi>>(
+        events: TEvent[],
+        keys: (string | string[])[],
+        processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>,
+        abortSignal?: AbortSignal
+    ) {
+        return this.findInEvents<T>(this.contract.contract.address, this.toFilter(events, keys), async (events: StarknetEvent[]) => {
+            const parsedEvents = this.toStarknetAbiEvents<TEvent>(events);
+            for(let event of parsedEvents) {
+                const result: T = 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
+     */
+    public async findInContractEventsForward<T, TEvent extends ExtractAbiEventNames<TAbi>>(
+        events: TEvent[],
+        keys: (string | string[])[],
+        processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>,
+        abortSignal?: AbortSignal
+    ) {
+        return this.findInEventsForward<T>(this.contract.contract.address, this.toFilter(events, keys), async (events: StarknetEvent[]) => {
+            const parsedEvents = this.toStarknetAbiEvents<TEvent>(events);
+            for(let event of parsedEvents) {
+                const result: T = await processor(event);
+                if(result!=null) return result;
+            }
+        }, abortSignal);
+    }
+
+}
+

package/src/starknet/events/StarknetChainEvents.ts

@@ -1,68 +1,68 @@
-import {StarknetChainEventsBrowser} from "./StarknetChainEventsBrowser";
-//@ts-ignore
-import * as fs from "fs/promises";
-import {StarknetSwapContract} from "../swaps/StarknetSwapContract";
-import {StarknetChainInterface} from "../chain/StarknetChainInterface";
-import {StarknetSpvVaultContract} from "../spv_swap/StarknetSpvVaultContract";
-
-const BLOCKHEIGHT_FILENAME = "/strk-blockheight.txt";
-
-export class StarknetChainEvents extends StarknetChainEventsBrowser {
-
-    private readonly directory: string;
-
-    constructor(
-        directory: string,
-        chainInterface: StarknetChainInterface,
-        starknetSwapContract: StarknetSwapContract,
-        starknetSpvVaultContract: StarknetSpvVaultContract,
-        pollIntervalSeconds?: number
-    ) {
-        super(chainInterface, starknetSwapContract, starknetSpvVaultContract, pollIntervalSeconds);
-        this.directory = directory;
-    }
-
-    /**
-     * Retrieves last signature & slot from filesystem
-     *
-     * @private
-     */
-    private async getLastEventData(): Promise<{blockNumber: number, txHashes: string[]}> {
-        try {
-            const txt: string = (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
-     */
-    private saveLastEventData(blockNumber: number, txHashes: string[]): Promise<void> {
-        return fs.writeFile(this.directory+BLOCKHEIGHT_FILENAME, blockNumber.toString()+";"+txHashes.join(";"));
-    }
-
-    async init(): Promise<void> {
-        const {blockNumber, txHashes} = await this.getLastEventData();
-        await this.setupPoll(
-            blockNumber,
-            txHashes,
-            (blockNumber: number, txHashes: string[]) => this.saveLastEventData(blockNumber, txHashes)
-        );
-    }
-
+import {StarknetChainEventsBrowser} from "./StarknetChainEventsBrowser";
+//@ts-ignore
+import * as fs from "fs/promises";
+import {StarknetSwapContract} from "../swaps/StarknetSwapContract";
+import {StarknetChainInterface} from "../chain/StarknetChainInterface";
+import {StarknetSpvVaultContract} from "../spv_swap/StarknetSpvVaultContract";
+
+const BLOCKHEIGHT_FILENAME = "/strk-blockheight.txt";
+
+export class StarknetChainEvents extends StarknetChainEventsBrowser {
+
+    private readonly directory: string;
+
+    constructor(
+        directory: string,
+        chainInterface: StarknetChainInterface,
+        starknetSwapContract: StarknetSwapContract,
+        starknetSpvVaultContract: StarknetSpvVaultContract,
+        pollIntervalSeconds?: number
+    ) {
+        super(chainInterface, starknetSwapContract, starknetSpvVaultContract, pollIntervalSeconds);
+        this.directory = directory;
+    }
+
+    /**
+     * Retrieves last signature & slot from filesystem
+     *
+     * @private
+     */
+    private async getLastEventData(): Promise<{blockNumber: number, txHashes: string[]}> {
+        try {
+            const txt: string = (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
+     */
+    private saveLastEventData(blockNumber: number, txHashes: string[]): Promise<void> {
+        return fs.writeFile(this.directory+BLOCKHEIGHT_FILENAME, blockNumber.toString()+";"+txHashes.join(";"));
+    }
+
+    async init(): Promise<void> {
+        const {blockNumber, txHashes} = await this.getLastEventData();
+        await this.setupPoll(
+            blockNumber,
+            txHashes,
+            (blockNumber: number, txHashes: string[]) => this.saveLastEventData(blockNumber, txHashes)
+        );
+    }
+
 }