@atomiqlabs/chain-starknet 1.0.0-beta.0

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetContractEvents = void 0;
+const StarknetEvents_1 = require("../../base/modules/StarknetEvents");
+const starknet_1 = require("starknet");
+const Utils_1 = require("../../../utils/Utils");
+class StarknetContractEvents extends StarknetEvents_1.StarknetEvents {
+    constructor(root, abi) {
+        super(root);
+        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.root.contract.address, this.toFilter(events, keys), startBlockHeight, endBlockHeight);
+        return this.toStarknetAbiEvents(blockEvents);
+    }
+    /**
+     * Runs a search forawrds 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.root.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

@@ -0,0 +1,19 @@
+import { StarknetChainEventsBrowser } from "./StarknetChainEventsBrowser";
+import { StarknetSwapContract } from "../swaps/StarknetSwapContract";
+export declare class StarknetChainEvents extends StarknetChainEventsBrowser {
+    private readonly directory;
+    constructor(directory: string, starknetSwapContract: StarknetSwapContract, 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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetChainEvents = void 0;
+const StarknetChainEventsBrowser_1 = require("./StarknetChainEventsBrowser");
+const fs = require("fs/promises");
+const BLOCKHEIGHT_FILENAME = "/strk-blockheight.txt";
+class StarknetChainEvents extends StarknetChainEventsBrowser_1.StarknetChainEventsBrowser {
+    constructor(directory, starknetSwapContract, pollIntervalSeconds) {
+        super(starknetSwapContract, 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]),
+                    txHash: null
+                };
+            return {
+                blockNumber: parseInt(arr[0]),
+                txHash: arr[1]
+            };
+        }
+        catch (e) {
+            return {
+                blockNumber: null,
+                txHash: null
+            };
+        }
+    }
+    /**
+     * Saves last signature & slot to the filesystem
+     *
+     * @private
+     */
+    saveLastEventData(blockNumber, txHash) {
+        return fs.writeFile(this.directory + BLOCKHEIGHT_FILENAME, blockNumber.toString() + ";" + txHash);
+    }
+    async init() {
+        const { blockNumber, txHash } = await this.getLastEventData();
+        await this.setupPoll(blockNumber, txHash, (blockNumber, txHash) => this.saveLastEventData(blockNumber, txHash));
+    }
+}
+exports.StarknetChainEvents = StarknetChainEvents;

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

@@ -0,0 +1,73 @@
+import { ChainEvents, ClaimEvent, EventListener, InitializeEvent, RefundEvent } from "@atomiqlabs/base";
+import { StarknetSwapData } from "../swaps/StarknetSwapData";
+import { StarknetSwapContract } from "../swaps/StarknetSwapContract";
+import { BigNumberish, Provider } from "starknet";
+import { StarknetAbiEvent } from "../contract/modules/StarknetContractEvents";
+import { EscrowManagerAbiType } from "../swaps/EscrowManagerAbi";
+import { ExtractAbiFunctionNames } from "abi-wan-kanabi/dist/kanabi";
+import { IClaimHandler } from "../swaps/handlers/claim/ClaimHandlers";
+export type StarknetTraceCall = {
+    calldata: string[];
+    contract_address: string;
+    entry_point_selector: string;
+    calls: StarknetTraceCall[];
+};
+/**
+ * Solana on-chain event handler for front-end systems without access to fs, uses pure WS to subscribe, might lose
+ *  out on some events if the network is unreliable, front-end systems should take this into consideration and not
+ *  rely purely on events
+ */
+export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData> {
+    protected readonly listeners: EventListener<StarknetSwapData>[];
+    protected readonly provider: Provider;
+    protected readonly starknetSwapContract: StarknetSwapContract;
+    protected eventListeners: number[];
+    protected readonly logger: {
+        debug: (msg: any, ...args: any[]) => void;
+        info: (msg: any, ...args: any[]) => void;
+        warn: (msg: any, ...args: any[]) => void;
+        error: (msg: any, ...args: any[]) => void;
+    };
+    protected initFunctionName: ExtractAbiFunctionNames<EscrowManagerAbiType>;
+    protected initEntryPointSelector: bigint;
+    protected stopped: boolean;
+    protected pollIntervalSeconds: number;
+    private timeout;
+    constructor(starknetSwapContract: StarknetSwapContract, pollIntervalSeconds?: number);
+    findInitSwapData(call: StarknetTraceCall, escrowHash: BigNumberish, claimHandler: IClaimHandler<any, any>): StarknetSwapData;
+    /**
+     * Returns async getter for fetching on-demand initialize event swap data
+     *
+     * @param event
+     * @param claimHandler
+     * @private
+     * @returns {() => Promise<StarknetSwapData>} getter to be passed to InitializeEvent constructor
+     */
+    private getSwapDataGetter;
+    protected parseInitializeEvent(event: StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Initialize">): InitializeEvent<StarknetSwapData>;
+    protected parseRefundEvent(event: StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Refund">): RefundEvent<StarknetSwapData>;
+    protected parseClaimEvent(event: StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Claim">): ClaimEvent<StarknetSwapData>;
+    /**
+     * Processes event as received from the chain, parses it & calls event listeners
+     *
+     * @param events
+     * @param currentBlockNumber
+     * @param currentBlockTimestamp
+     * @protected
+     */
+    protected processEvents(events: StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Initialize" | "escrow_manager::events::Refund" | "escrow_manager::events::Claim">[], currentBlockNumber: number, currentBlockTimestamp: number): Promise<void>;
+    protected checkEvents(lastBlockNumber: number, lastTxHash: string): Promise<{
+        txHash: string;
+        blockNumber: number;
+    }>;
+    /**
+     * Sets up event handlers listening for swap events over websocket
+     *
+     * @protected
+     */
+    protected setupPoll(lastBlockNumber?: number, lastTxHash?: string, saveLatestProcessedBlockNumber?: (blockNumber: number, lastTxHash: string) => Promise<void>): Promise<void>;
+    init(): Promise<void>;
+    stop(): Promise<void>;
+    registerListener(cbk: EventListener<StarknetSwapData>): void;
+    unregisterListener(cbk: EventListener<StarknetSwapData>): boolean;
+}

package/dist/starknet/events/StarknetChainEventsBrowser.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetChainEventsBrowser = void 0;
+const base_1 = require("@atomiqlabs/base");
+const Utils_1 = require("../../utils/Utils");
+const starknet_1 = require("starknet");
+/**
+ * Solana on-chain event handler for front-end systems without access to fs, uses pure WS to subscribe, might lose
+ *  out on some events if the network is unreliable, front-end systems should take this into consideration and not
+ *  rely purely on events
+ */
+class StarknetChainEventsBrowser {
+    constructor(starknetSwapContract, pollIntervalSeconds = 5) {
+        this.listeners = [];
+        this.eventListeners = [];
+        this.logger = (0, Utils_1.getLogger)("StarknetChainEventsBrowser: ");
+        this.initFunctionName = "initialize";
+        this.initEntryPointSelector = BigInt(starknet_1.hash.starknetKeccak(this.initFunctionName));
+        this.provider = starknetSwapContract.provider;
+        this.starknetSwapContract = starknetSwapContract;
+        this.pollIntervalSeconds = pollIntervalSeconds;
+    }
+    findInitSwapData(call, escrowHash, claimHandler) {
+        if (BigInt(call.contract_address) === BigInt(this.starknetSwapContract.contract.address) &&
+            BigInt(call.entry_point_selector) === this.initEntryPointSelector) {
+            //Found, check correct escrow hash
+            const { escrow, extraData } = (0, Utils_1.parseInitFunctionCalldata)(call.calldata, claimHandler);
+            if ("0x" + escrow.getEscrowHash() === (0, Utils_1.toHex)(escrowHash)) {
+                if (extraData.length !== 0) {
+                    escrow.setExtraData((0, Utils_1.bytes31SpanToBuffer)(extraData, 42).toString("hex"));
+                }
+                return escrow;
+            }
+        }
+        for (let _call of call.calls) {
+            const found = this.findInitSwapData(_call, escrowHash, claimHandler);
+            if (found != null)
+                return found;
+        }
+        return null;
+    }
+    /**
+     * Returns async getter for fetching on-demand initialize event swap data
+     *
+     * @param event
+     * @param claimHandler
+     * @private
+     * @returns {() => Promise<StarknetSwapData>} getter to be passed to InitializeEvent constructor
+     */
+    getSwapDataGetter(event, claimHandler) {
+        return async () => {
+            const trace = await this.provider.getTransactionTrace(event.txHash);
+            if (trace == null)
+                return null;
+            if (trace.execute_invocation.revert_reason != null)
+                return null;
+            return this.findInitSwapData(trace.execute_invocation, event.params.escrow_hash, claimHandler);
+        };
+    }
+    parseInitializeEvent(event) {
+        const escrowHashBuffer = (0, Utils_1.bigNumberishToBuffer)(event.params.escrow_hash, 32);
+        const escrowHash = escrowHashBuffer.toString("hex");
+        const claimHandlerHex = (0, Utils_1.toHex)(event.params.claim_handler);
+        const claimHandler = this.starknetSwapContract.claimHandlersByAddress[claimHandlerHex];
+        if (claimHandler == null) {
+            this.logger.warn("parseInitializeEvent(" + escrowHash + "): Unknown claim handler with claim: " + claimHandlerHex);
+            return null;
+        }
+        const swapType = claimHandler.getType();
+        this.logger.debug("InitializeEvent claimHash: " + (0, Utils_1.toHex)(event.params.claim_data) + " escrowHash: " + escrowHash);
+        return new base_1.InitializeEvent(escrowHash, swapType, (0, Utils_1.onceAsync)(this.getSwapDataGetter(event, claimHandler)));
+    }
+    parseRefundEvent(event) {
+        const escrowHashBuffer = (0, Utils_1.bigNumberishToBuffer)(event.params.escrow_hash, 32);
+        const escrowHash = escrowHashBuffer.toString("hex");
+        this.logger.debug("RefundEvent claimHash: " + (0, Utils_1.toHex)(event.params.claim_data) + " escrowHash: " + escrowHash);
+        return new base_1.RefundEvent(escrowHash);
+    }
+    parseClaimEvent(event) {
+        const escrowHashBuffer = (0, Utils_1.bigNumberishToBuffer)(event.params.escrow_hash, 32);
+        const escrowHash = escrowHashBuffer.toString("hex");
+        const claimHandlerHex = (0, Utils_1.toHex)(event.params.claim_handler);
+        const claimHandler = this.starknetSwapContract.claimHandlersByAddress[claimHandlerHex];
+        if (claimHandler == null) {
+            this.logger.warn("parseClaimEvent(" + escrowHash + "): Unknown claim handler with claim: " + claimHandlerHex);
+            return null;
+        }
+        const witnessResult = claimHandler.parseWitnessResult(event.params.witness_result);
+        this.logger.debug("ClaimEvent claimHash: " + (0, Utils_1.toHex)(event.params.claim_data) +
+            " witnessResult: " + witnessResult + " escrowHash: " + escrowHash);
+        return new base_1.ClaimEvent(escrowHash, witnessResult);
+    }
+    /**
+     * Processes event as received from the chain, parses it & calls event listeners
+     *
+     * @param events
+     * @param currentBlockNumber
+     * @param currentBlockTimestamp
+     * @protected
+     */
+    async processEvents(events, currentBlockNumber, currentBlockTimestamp) {
+        const blockTimestampsCache = {};
+        const getBlockTimestamp = async (blockNumber) => {
+            const blockNumberString = blockNumber.toString();
+            blockTimestampsCache[blockNumberString] ?? (blockTimestampsCache[blockNumberString] = (await this.provider.getBlockWithTxHashes(blockNumber)).timestamp);
+            return blockTimestampsCache[blockNumberString];
+        };
+        const parsedEvents = [];
+        for (let event of events) {
+            let parsedEvent;
+            switch (event.name) {
+                case "escrow_manager::events::Claim":
+                    parsedEvent = this.parseClaimEvent(event);
+                    break;
+                case "escrow_manager::events::Refund":
+                    parsedEvent = this.parseRefundEvent(event);
+                    break;
+                case "escrow_manager::events::Initialize":
+                    parsedEvent = this.parseInitializeEvent(event);
+                    break;
+            }
+            const timestamp = (event.blockNumber == null || event.blockNumber === currentBlockNumber) ? currentBlockTimestamp : await getBlockTimestamp(event.blockNumber);
+            parsedEvent.meta = {
+                blockTime: timestamp,
+                txId: event.txHash,
+                timestamp //Maybe deprecated
+            };
+            parsedEvents.push(parsedEvent);
+        }
+        for (let listener of this.listeners) {
+            await listener(parsedEvents);
+        }
+    }
+    async checkEvents(lastBlockNumber, lastTxHash) {
+        //Get pending events
+        let pendingEvents = await this.starknetSwapContract.Events.getContractBlockEvents(["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"], []);
+        if (lastTxHash != null) {
+            const latestProcessedEventIndex = (0, Utils_1.findLastIndex)(pendingEvents, val => val.txHash === lastTxHash);
+            if (latestProcessedEventIndex !== -1)
+                pendingEvents.splice(0, latestProcessedEventIndex + 1);
+        }
+        if (pendingEvents.length > 0) {
+            await this.processEvents(pendingEvents, null, Math.floor(Date.now() / 1000));
+            lastTxHash = pendingEvents[pendingEvents.length - 1].txHash;
+        }
+        const currentBlock = await this.provider.getBlockWithTxHashes("latest");
+        const currentBlockNumber = currentBlock.block_number;
+        if (lastBlockNumber != null && currentBlockNumber > lastBlockNumber) {
+            const events = await this.starknetSwapContract.Events.getContractBlockEvents(["escrow_manager::events::Initialize", "escrow_manager::events::Claim", "escrow_manager::events::Refund"], [], lastBlockNumber + 1, currentBlockNumber);
+            if (lastTxHash != null) {
+                const latestProcessedEventIndex = (0, Utils_1.findLastIndex)(events, val => val.txHash === lastTxHash);
+                if (latestProcessedEventIndex !== -1)
+                    events.splice(0, latestProcessedEventIndex + 1);
+            }
+            if (events.length > 0) {
+                await this.processEvents(events, currentBlockNumber, currentBlock.timestamp);
+                lastTxHash = events[events.length - 1].txHash;
+            }
+        }
+        return {
+            txHash: lastTxHash,
+            blockNumber: currentBlockNumber
+        };
+    }
+    /**
+     * Sets up event handlers listening for swap events over websocket
+     *
+     * @protected
+     */
+    async setupPoll(lastBlockNumber, lastTxHash, saveLatestProcessedBlockNumber) {
+        this.stopped = false;
+        let func;
+        func = async () => {
+            await this.checkEvents(lastBlockNumber, lastTxHash).then(({ blockNumber, txHash }) => {
+                lastBlockNumber = blockNumber;
+                lastTxHash = txHash;
+                if (saveLatestProcessedBlockNumber != null)
+                    return saveLatestProcessedBlockNumber(blockNumber, lastTxHash);
+            }).catch(e => {
+                this.logger.error("setupPoll(): Failed to fetch starknet log: ", e);
+            });
+            if (this.stopped)
+                return;
+            this.timeout = setTimeout(func, this.pollIntervalSeconds * 1000);
+        };
+        await func();
+    }
+    init() {
+        this.setupPoll();
+        return Promise.resolve();
+    }
+    async stop() {
+        this.stopped = true;
+        if (this.timeout != null)
+            clearTimeout(this.timeout);
+        this.eventListeners = [];
+    }
+    registerListener(cbk) {
+        this.listeners.push(cbk);
+    }
+    unregisterListener(cbk) {
+        const index = this.listeners.indexOf(cbk);
+        if (index >= 0) {
+            this.listeners.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+}
+exports.StarknetChainEventsBrowser = StarknetChainEventsBrowser;