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

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

@@ -1,5 +1,5 @@
 import { StarknetModule } from "../StarknetModule";
-export type StarknetBlockTag = "pending" | "latest";
+export type StarknetBlockTag = "pre_confirmed" | "latest";
 export declare class StarknetBlocks extends StarknetModule {
     private BLOCK_CACHE_TIME;
     private blockCache;

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

@@ -23,8 +23,8 @@ class StarknetEvents extends StarknetModule_1.StarknetModule {
         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 },
+                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

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

@@ -57,19 +57,19 @@ export declare class StarknetFees {
         version: "0x3";
         resourceBounds: {
             l1_gas: {
-                max_amount: string;
-                max_price_per_unit: string;
+                max_amount: bigint;
+                max_price_per_unit: bigint;
             };
             l2_gas: {
-                max_amount: string;
-                max_price_per_unit: string;
+                max_amount: bigint;
+                max_price_per_unit: bigint;
             };
             l1_data_gas: {
-                max_amount: string;
-                max_price_per_unit: string;
+                max_amount: bigint;
+                max_price_per_unit: bigint;
             };
         };
-        tip: string;
+        tip: bigint;
         paymasterData: any[];
         nonceDataAvailabilityMode: "L1" | "L2";
         feeDataAvailabilityMode: "L1" | "L2";

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

@@ -100,11 +100,11 @@ class StarknetFees {
         return {
             version: "0x3",
             resourceBounds: {
-                l1_gas: { max_amount: (0, Utils_1.toHex)(gas.l1Gas, 16), max_price_per_unit: (0, Utils_1.toHex)(BigInt(l1GasCostStr), 16) },
-                l2_gas: { max_amount: (0, Utils_1.toHex)(gas.l2Gas, 16), max_price_per_unit: (0, Utils_1.toHex)(BigInt(l2GasCostStr), 16) },
-                l1_data_gas: { max_amount: (0, Utils_1.toHex)(gas.l1DataGas, 16), max_price_per_unit: (0, Utils_1.toHex)(BigInt(l1DataGasCostStr), 16) }
+                l1_gas: { max_amount: BigInt(gas.l1Gas), max_price_per_unit: BigInt(l1GasCostStr) },
+                l2_gas: { max_amount: BigInt(gas.l2Gas), max_price_per_unit: BigInt(l2GasCostStr) },
+                l1_data_gas: { max_amount: BigInt(gas.l1DataGas), max_price_per_unit: BigInt(l1DataGasCostStr) }
             },
-            tip: "0x0",
+            tip: 0n,
             paymasterData: [],
             nonceDataAvailabilityMode: this.nonceDA,
             feeDataAvailabilityMode: this.feeDA

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

@@ -9,7 +9,11 @@ const Utils_1 = require("../../../utils/Utils");
 const StarknetAddresses_1 = require("./StarknetAddresses");
 class StarknetTokens extends StarknetModule_1.StarknetModule {
     getContract(address) {
-        return new starknet_1.Contract(ERC20Abi_1.ERC20Abi, address, this.root.provider).typedv2(ERC20Abi_1.ERC20Abi);
+        return new starknet_1.Contract({
+            abi: ERC20Abi_1.ERC20Abi,
+            address: address,
+            providerOrAccount: this.root.provider
+        }).typedv2(ERC20Abi_1.ERC20Abi);
     }
     /**
      * Action for transferring the erc20 token

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

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StarknetTransactions = void 0;
 const StarknetModule_1 = require("../StarknetModule");
+const starknet_1 = require("starknet");
 const Utils_1 = require("../../../utils/Utils");
+const MAX_UNCONFIRMED_TXS = 25;
 class StarknetTransactions extends StarknetModule_1.StarknetModule {
     constructor() {
         super(...arguments);
@@ -154,7 +156,7 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
             " waitForConfirmation: " + waitForConfirmation + " parallel: " + parallel);
         const txIds = [];
         if (parallel) {
-            const promises = [];
+            let promises = [];
             for (let i = 0; i < txs.length; i++) {
                 const signedTx = txs[i];
                 const txId = await this.sendSignedTransaction(signedTx, onBeforePublish, signer);
@@ -162,6 +164,10 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
                     promises.push(this.confirmTransaction(signedTx, abortSignal));
                 txIds.push(txId);
                 this.logger.debug("sendAndConfirm(): transaction sent (" + (i + 1) + "/" + txs.length + "): " + signedTx.txId);
+                if (promises.length >= MAX_UNCONFIRMED_TXS) {
+                    await Promise.all(promises);
+                    promises = [];
+                }
             }
             if (promises.length > 0)
                 await Promise.all(promises);
@@ -224,11 +230,11 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
         });
         if (status == null)
             return "not_found";
-        if (status.finality_status === "RECEIVED")
+        if (status.finality_status === starknet_1.ETransactionStatus.RECEIVED)
             return "pending";
-        if (status.finality_status === "REJECTED")
+        if (status.finality_status === starknet_1.ETransactionStatus.REJECTED)
             return "rejected";
-        if (status.execution_status === "SUCCEEDED") {
+        if (status.execution_status === starknet_1.ETransactionExecutionStatus.SUCCEEDED) {
             return "success";
         }
         return "reverted";

package/dist/starknet/contract/StarknetContractBase.js

@@ -9,7 +9,11 @@ const StarknetContractEvents_1 = require("./modules/StarknetContractEvents");
 class StarknetContractBase {
     constructor(chainInterface, contractAddress, contractAbi) {
         this.Chain = chainInterface;
-        this.contract = new starknet_1.Contract(contractAbi, contractAddress, chainInterface.provider).typedv2(contractAbi);
+        this.contract = new starknet_1.Contract({
+            abi: contractAbi,
+            address: contractAddress,
+            providerOrAccount: chainInterface.provider
+        }).typedv2(contractAbi);
         this.Events = new StarknetContractEvents_1.StarknetContractEvents(chainInterface, this, contractAbi);
     }
 }

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

@@ -14,7 +14,7 @@ class StarknetContractEvents extends StarknetEvents_1.StarknetEvents {
         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);
+        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) => {

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

@@ -61,10 +61,9 @@ export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetS
      * @param events
      * @param currentBlockNumber
      * @param currentBlockTimestamp
-     * @param pendingEventTime
      * @protected
      */
-    protected processEvents(events: (StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Initialize" | "escrow_manager::events::Refund" | "escrow_manager::events::Claim"> | StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Opened" | "spv_swap_vault::events::Deposited" | "spv_swap_vault::events::Fronted" | "spv_swap_vault::events::Claimed" | "spv_swap_vault::events::Closed">)[], currentBlockNumber: number, currentBlockTimestamp: number, pendingEventTime: number): Promise<void>;
+    protected processEvents(events: (StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Initialize" | "escrow_manager::events::Refund" | "escrow_manager::events::Claim"> | StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Opened" | "spv_swap_vault::events::Deposited" | "spv_swap_vault::events::Fronted" | "spv_swap_vault::events::Claimed" | "spv_swap_vault::events::Closed">)[], currentBlockNumber: number, currentBlockTimestamp: number): Promise<void>;
     protected checkEventsEcrowManager(lastTxHash: string, lastBlockNumber?: number, currentBlock?: {
         timestamp: number;
         block_number: number;

package/dist/starknet/events/StarknetChainEventsBrowser.js

@@ -145,10 +145,9 @@ class StarknetChainEventsBrowser {
      * @param events
      * @param currentBlockNumber
      * @param currentBlockTimestamp
-     * @param pendingEventTime
      * @protected
      */
-    async processEvents(events, currentBlockNumber, currentBlockTimestamp, pendingEventTime) {
+    async processEvents(events, currentBlockNumber, currentBlockTimestamp) {
         const blockTimestampsCache = {};
         const getBlockTimestamp = async (blockNumber) => {
             if (blockNumber === currentBlockNumber)
@@ -188,7 +187,10 @@ class StarknetChainEventsBrowser {
             }
             if (parsedEvent == null)
                 continue;
-            const timestamp = event.blockNumber == null ? pendingEventTime : await getBlockTimestamp(event.blockNumber);
+            //We are not trusting pre-confs for events, so this shall never happen
+            if (event.blockNumber == null)
+                throw new Error("Event block number cannot be null!");
+            const timestamp = await getBlockTimestamp(event.blockNumber);
             parsedEvent.meta = {
                 blockTime: timestamp,
                 txId: event.txHash,
@@ -213,7 +215,7 @@ class StarknetChainEventsBrowser {
             }
         }
         if (events.length > 0) {
-            await this.processEvents(events, currentBlock?.block_number, currentBlock?.timestamp, Math.floor(Date.now() / 1000));
+            await this.processEvents(events, currentBlock?.block_number, currentBlock?.timestamp);
             lastTxHash = events[events.length - 1].txHash;
         }
         return lastTxHash;
@@ -231,14 +233,14 @@ class StarknetChainEventsBrowser {
             }
         }
         if (events.length > 0) {
-            await this.processEvents(events, currentBlock?.block_number, currentBlock?.timestamp, Math.floor(Date.now() / 1000));
+            await this.processEvents(events, currentBlock?.block_number, currentBlock?.timestamp);
             lastTxHash = events[events.length - 1].txHash;
         }
         return lastTxHash;
     }
     async checkEvents(lastBlockNumber, lastTxHashes) {
         lastTxHashes ?? (lastTxHashes = []);
-        const currentBlock = await this.provider.getBlockWithTxHashes("latest");
+        const currentBlock = await this.provider.getBlockWithTxHashes(starknet_1.BlockTag.LATEST);
         const currentBlockNumber = currentBlock.block_number;
         lastTxHashes[0] = await this.checkEventsEcrowManager(lastTxHashes[0], lastBlockNumber, currentBlock);
         lastTxHashes[1] = await this.checkEventsSpvVaults(lastTxHashes[1], lastBlockNumber, currentBlock);

package/dist/starknet/swaps/modules/StarknetSwapInit.d.ts

@@ -60,13 +60,20 @@ export declare class StarknetSwapInit extends StarknetSwapModule {
      */
     getSignatureExpiry(timeout: string): Promise<number>;
     /**
-     * Checks whether signature is expired for good, compares the timestamp to the current "pending" block timestamp
+     * Checks whether signature is soft expired, compares the timestamp to the current "pre-confirmed" block timestamp
      *
      * @param timeout
      * @param preFetchData
      * @public
      */
-    isSignatureExpired(timeout: string, preFetchData?: StarknetPreFetchVerification): Promise<boolean>;
+    isSignatureSoftExpired(timeout: string, preFetchData?: StarknetPreFetchVerification): Promise<boolean>;
+    /**
+     * Checks whether signature is expired for good, compares the timestamp to the current "latest" block timestamp
+     *
+     * @param timeout
+     * @public
+     */
+    isSignatureExpired(timeout: string): Promise<boolean>;
     /**
      * Creates init transaction with a valid signature from an LP
      *

package/dist/starknet/swaps/modules/StarknetSwapInit.js

@@ -50,7 +50,7 @@ class StarknetSwapInit extends StarknetSwapModule_1.StarknetSwapModule {
     }
     async preFetchForInitSignatureVerification() {
         return {
-            pendingBlockTime: await this.root.Blocks.getBlockTime("pending")
+            pendingBlockTime: await this.root.Blocks.getBlockTime(starknet_1.BlockTag.PRE_CONFIRMED)
         };
     }
     /**
@@ -121,7 +121,7 @@ class StarknetSwapInit extends StarknetSwapModule_1.StarknetSwapModule {
         const isExpired = (timeoutBN - currentTimestamp) < BigInt(this.contract.authGracePeriod);
         if (isExpired)
             throw new base_1.SignatureVerificationError("Authorization expired!");
-        if (await this.isSignatureExpired(timeout, preFetchData))
+        if (await this.isSignatureSoftExpired(timeout, preFetchData))
             throw new base_1.SignatureVerificationError("Authorization expired!");
         const valid = await this.root.Signatures.isValidSignature(signature, signer, Initialize, "Initialize", {
             "Swap hash": "0x" + swapData.getEscrowHash(),
@@ -167,18 +167,28 @@ class StarknetSwapInit extends StarknetSwapModule_1.StarknetSwapModule {
         return timeoutExpiryTime;
     }
     /**
-     * Checks whether signature is expired for good, compares the timestamp to the current "pending" block timestamp
+     * Checks whether signature is soft expired, compares the timestamp to the current "pre-confirmed" block timestamp
      *
      * @param timeout
      * @param preFetchData
      * @public
      */
-    async isSignatureExpired(timeout, preFetchData) {
+    async isSignatureSoftExpired(timeout, preFetchData) {
         if (preFetchData == null || preFetchData.pendingBlockTime == null) {
             preFetchData = await this.preFetchForInitSignatureVerification();
         }
         return preFetchData.pendingBlockTime > parseInt(timeout);
     }
+    /**
+     * Checks whether signature is expired for good, compares the timestamp to the current "latest" block timestamp
+     *
+     * @param timeout
+     * @public
+     */
+    async isSignatureExpired(timeout) {
+        const blockTime = await this.root.Blocks.getBlockTime(starknet_1.BlockTag.LATEST);
+        return blockTime > parseInt(timeout);
+    }
     /**
      * Creates init transaction with a valid signature from an LP
      *

package/dist/starknet/wallet/StarknetKeypairWallet.js

@@ -12,7 +12,12 @@ class StarknetKeypairWallet extends starknet_1.Account {
         // Calculate future address of the account
         const OZaccountConstructorCallData = starknet_1.CallData.compile({ publicKey });
         const OZcontractAddress = starknet_1.hash.calculateContractAddressFromHash(publicKey, OZaccountClassHash, OZaccountConstructorCallData, 0);
-        super(provider, OZcontractAddress, privateKey, "1");
+        super({
+            provider,
+            address: OZcontractAddress,
+            signer: privateKey,
+            cairoVersion: "1"
+        });
         this.publicKey = publicKey;
     }
     getDeploymentData() {

package/dist/starknet/wallet/StarknetSigner.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StarknetSigner = void 0;
+const starknet_1 = require("starknet");
 const Utils_1 = require("../../utils/Utils");
 class StarknetSigner {
     constructor(account) {
@@ -19,7 +20,7 @@ class StarknetSigner {
     //TODO: Introduce proper nonce management!
     async getNonce() {
         try {
-            return BigInt(await this.account.getNonceForAddress(this.getAddress(), "pending"));
+            return BigInt(await this.account.getNonceForAddress(this.getAddress(), starknet_1.BlockTag.PRE_CONFIRMED));
         }
         catch (e) {
             if (e.message != null && e.message.includes("20: Contract not found")) {

package/dist/utils/Utils.js

@@ -117,7 +117,6 @@ function calculateHash(tx) {
             return tx.txId = starknet_1.hash.calculateDeployAccountTransactionHash({
                 contractAddress: tx.tx.contractAddress,
                 classHash: tx.signed.classHash,
-                constructorCalldata: deployAccountData,
                 compiledConstructorCalldata: deployAccountData,
                 salt: tx.signed.addressSalt,
                 ...commonData

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@atomiqlabs/chain-starknet",
-  "version": "4.0.0-dev.11",
+  "version": "4.0.0-dev.13",
   "description": "Starknet specific base implementation",
   "main": "./dist/index.js",
-  "types:": "./dist/index.d.ts",
+  "types": "./dist/index.d.ts",
   "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "files": [
@@ -21,6 +23,10 @@
   ],
   "author": "adambor",
   "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/atomiqlabs/atomiq-chain-starknet.git"
+  },
   "dependencies": {
     "@atomiqlabs/base": "^10.0.0-dev.9",
     "@noble/hashes": "^1.7.1",
@@ -29,7 +35,7 @@
     "buffer": "6.0.3"
   },
   "peerDependencies": {
-    "starknet": "^7.5.0"
+    "starknet": "^8.5.0"
   },
   "devDependencies": {
     "typescript": "4.9.5"

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

@@ -1,6 +1,7 @@
 import {StarknetModule} from "../StarknetModule";
 
-export type StarknetBlockTag = "pending" | "latest";
+// https://github.com/starkware-libs/starknet-specs/blob/c2e93098b9c2ca0423b7f4d15b201f52f22d8c36/api/starknet_api_openrpc.json#L1234
+export type StarknetBlockTag = "pre_confirmed" | "latest";
 
 export class StarknetBlocks extends StarknetModule {
 

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

@@ -29,8 +29,8 @@ export class StarknetEvents extends StarknetModule {
         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},
+                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

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

@@ -141,11 +141,11 @@ export class StarknetFees {
         return {
             version: "0x3" as const,
             resourceBounds: {
-                l1_gas: {max_amount: toHex(gas.l1Gas, 16), max_price_per_unit: toHex(BigInt(l1GasCostStr), 16)},
-                l2_gas: {max_amount: toHex(gas.l2Gas, 16), max_price_per_unit: toHex(BigInt(l2GasCostStr), 16)},
-                l1_data_gas: {max_amount: toHex(gas.l1DataGas, 16), max_price_per_unit: toHex(BigInt(l1DataGasCostStr), 16)}
+                l1_gas: {max_amount: BigInt(gas.l1Gas), max_price_per_unit: BigInt(l1GasCostStr)},
+                l2_gas: {max_amount: BigInt(gas.l2Gas), max_price_per_unit: BigInt(l2GasCostStr)},
+                l1_data_gas: {max_amount: BigInt(gas.l1DataGas), max_price_per_unit: BigInt(l1DataGasCostStr)}
             },
-            tip: "0x0",
+            tip: 0n,
             paymasterData: [],
             nonceDataAvailabilityMode: this.nonceDA,
             feeDataAvailabilityMode: this.feeDA

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

@@ -17,7 +17,11 @@ export class StarknetTokens extends StarknetModule {
     };
 
     private getContract(address: string) {
-        return new Contract(ERC20Abi, address, this.root.provider).typedv2(ERC20Abi);
+        return new Contract({
+            abi: ERC20Abi,
+            address: address,
+            providerOrAccount: this.root.provider
+        }).typedv2(ERC20Abi);
     }
 
     /**

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

@@ -3,7 +3,9 @@ import {
     Call,
     DeployAccountContractPayload, DeployAccountContractTransaction,
     Invocation, InvocationsSignerDetails,
-    BigNumberish
+    BigNumberish,
+    ETransactionStatus,
+    ETransactionExecutionStatus
 } from "starknet";
 import {StarknetSigner} from "../../wallet/StarknetSigner";
 import {calculateHash, timeoutPromise, toBigInt, toHex, tryWithRetries} from "../../../utils/Utils";
@@ -21,6 +23,8 @@ export type StarknetTx = ({
     txId?: string
 };
 
+const MAX_UNCONFIRMED_TXS = 25;
+
 export class StarknetTransactions extends StarknetModule {
 
     private readonly latestConfirmedNonces: {[address: string]: bigint} = {};
@@ -178,13 +182,17 @@ export class StarknetTransactions extends StarknetModule {
 
         const txIds: string[] = [];
         if(parallel) {
-            const promises: Promise<void>[] = [];
+            let promises: Promise<void>[] = [];
             for(let i=0;i<txs.length;i++) {
                 const signedTx = txs[i];
                 const txId = await this.sendSignedTransaction(signedTx, onBeforePublish, signer);
                 if(waitForConfirmation) promises.push(this.confirmTransaction(signedTx, abortSignal));
                 txIds.push(txId);
                 this.logger.debug("sendAndConfirm(): transaction sent ("+(i+1)+"/"+txs.length+"): "+signedTx.txId);
+                if(promises.length >= MAX_UNCONFIRMED_TXS) {
+                    await Promise.all(promises);
+                    promises = [];
+                }
             }
             if(promises.length>0) await Promise.all(promises);
         } else {
@@ -247,9 +255,9 @@ export class StarknetTransactions extends StarknetModule {
             throw e;
         });
         if(status==null) return "not_found";
-        if(status.finality_status==="RECEIVED") return "pending";
-        if(status.finality_status==="REJECTED") return "rejected";
-        if(status.execution_status==="SUCCEEDED"){
+        if(status.finality_status===ETransactionStatus.RECEIVED) return "pending";
+        if(status.finality_status===ETransactionStatus.REJECTED) return "rejected";
+        if(status.execution_status===ETransactionExecutionStatus.SUCCEEDED){
             return "success";
         }
         return "reverted";

package/src/starknet/contract/StarknetContractBase.ts

@@ -19,7 +19,11 @@ export class StarknetContractBase<T extends Abi> {
         contractAbi: T
     ) {
         this.Chain = chainInterface;
-        this.contract = new Contract(contractAbi, contractAddress, chainInterface.provider).typedv2(contractAbi);
+        this.contract = new Contract({
+            abi: contractAbi,
+            address: contractAddress,
+            providerOrAccount: chainInterface.provider
+        }).typedv2(contractAbi);
         this.Events = new StarknetContractEvents(chainInterface, this, contractAbi);
     }
 

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

@@ -1,7 +1,7 @@
 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 {CallData, events, hash, createAbiParser} from "starknet";
 import {StarknetContractBase} from "../StarknetContractBase";
 import {toHex} from "../../../utils/Utils";
 import {StarknetChainInterface} from "../../chain/StarknetChainInterface";
@@ -32,7 +32,7 @@ export class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
         const abiStructs = CallData.getAbiStruct(this.abi);
         const abiEnums = CallData.getAbiEnum(this.abi);
 
-        const result = events.parseEvents(blockEvents, abiEvents, abiStructs, abiEnums);
+        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];

package/src/starknet/events/StarknetChainEventsBrowser.ts

@@ -17,7 +17,7 @@ import {
     toHex
 } from "../../utils/Utils";
 import {StarknetSwapContract} from "../swaps/StarknetSwapContract";
-import {BigNumberish, hash, Provider} from "starknet";
+import {BigNumberish, BlockTag, hash, Provider} from "starknet";
 import {StarknetAbiEvent} from "../contract/modules/StarknetContractEvents";
 import {EscrowManagerAbiType} from "../swaps/EscrowManagerAbi";
 import {ExtractAbiFunctionNames} from "abi-wan-kanabi/dist/kanabi";
@@ -229,7 +229,6 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
      * @param events
      * @param currentBlockNumber
      * @param currentBlockTimestamp
-     * @param pendingEventTime
      * @protected
      */
     protected async processEvents(
@@ -241,8 +240,7 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
             "spv_swap_vault::events::Opened" | "spv_swap_vault::events::Deposited" | "spv_swap_vault::events::Fronted" | "spv_swap_vault::events::Claimed" | "spv_swap_vault::events::Closed"
         >)[],
         currentBlockNumber: number,
-        currentBlockTimestamp: number,
-        pendingEventTime: number
+        currentBlockTimestamp: number
     ) {
         const blockTimestampsCache: {[blockNumber: string]: number} = {};
         const getBlockTimestamp: (blockNumber: number) => Promise<number> = async (blockNumber: number)=> {
@@ -283,7 +281,9 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
                     break;
             }
             if(parsedEvent==null) continue;
-            const timestamp = event.blockNumber==null ? pendingEventTime : await getBlockTimestamp(event.blockNumber);
+            //We are not trusting pre-confs for events, so this shall never happen
+            if(event.blockNumber==null) throw new Error("Event block number cannot be null!");
+            const timestamp = await getBlockTimestamp(event.blockNumber);
             parsedEvent.meta = {
                 blockTime: timestamp,
                 txId: event.txHash,
@@ -315,7 +315,7 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
             }
         }
         if(events.length>0) {
-            await this.processEvents(events, currentBlock?.block_number, currentBlock?.timestamp, Math.floor(Date.now()/1000));
+            await this.processEvents(events, currentBlock?.block_number, currentBlock?.timestamp);
             lastTxHash = events[events.length-1].txHash;
         }
         return lastTxHash;
@@ -339,7 +339,7 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
             }
         }
         if(events.length>0) {
-            await this.processEvents(events, currentBlock?.block_number, currentBlock?.timestamp, Math.floor(Date.now()/1000));
+            await this.processEvents(events, currentBlock?.block_number, currentBlock?.timestamp);
             lastTxHash = events[events.length-1].txHash;
         }
         return lastTxHash;
@@ -348,8 +348,8 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
     protected async checkEvents(lastBlockNumber: number, lastTxHashes: string[]): Promise<{txHashes: string[], blockNumber: number}> {
         lastTxHashes ??= [];
 
-        const currentBlock = await this.provider.getBlockWithTxHashes("latest");
-        const currentBlockNumber: number = (currentBlock as any).block_number;
+        const currentBlock = await this.provider.getBlockWithTxHashes(BlockTag.LATEST);
+        const currentBlockNumber: number = currentBlock.block_number;
 
         lastTxHashes[0] = await this.checkEventsEcrowManager(lastTxHashes[0], lastBlockNumber, currentBlock as any);
         lastTxHashes[1] = await this.checkEventsSpvVaults(lastTxHashes[1], lastBlockNumber, currentBlock as any);

package/src/starknet/swaps/modules/StarknetSwapInit.ts

@@ -4,7 +4,7 @@ import {Buffer} from "buffer";
 import {StarknetSwapData} from "../StarknetSwapData";
 import {StarknetAction} from "../../chain/StarknetAction";
 import {StarknetSwapModule} from "../StarknetSwapModule";
-import {BigNumberish, cairo} from "starknet";
+import {BigNumberish, cairo, BlockTag} from "starknet";
 import {StarknetSigner} from "../../wallet/StarknetSigner";
 import {StarknetFees} from "../../chain/modules/StarknetFees";
 import {StarknetTx} from "../../chain/modules/StarknetTransactions";
@@ -74,7 +74,7 @@ export class StarknetSwapInit extends StarknetSwapModule {
 
     public async preFetchForInitSignatureVerification(): Promise<StarknetPreFetchVerification> {
         return {
-            pendingBlockTime: await this.root.Blocks.getBlockTime("pending")
+            pendingBlockTime: await this.root.Blocks.getBlockTime(BlockTag.PRE_CONFIRMED)
         };
     }
 
@@ -162,7 +162,7 @@ export class StarknetSwapInit extends StarknetSwapModule {
         const timeoutBN = BigInt(timeout);
         const isExpired = (timeoutBN - currentTimestamp) < BigInt(this.contract.authGracePeriod);
         if (isExpired) throw new SignatureVerificationError("Authorization expired!");
-        if(await this.isSignatureExpired(timeout, preFetchData)) throw new SignatureVerificationError("Authorization expired!");
+        if(await this.isSignatureSoftExpired(timeout, preFetchData)) throw new SignatureVerificationError("Authorization expired!");
 
         const valid = await this.root.Signatures.isValidSignature(signature, signer, Initialize, "Initialize", {
             "Swap hash": "0x"+swapData.getEscrowHash(),
@@ -214,13 +214,13 @@ export class StarknetSwapInit extends StarknetSwapModule {
     }
 
     /**
-     * Checks whether signature is expired for good, compares the timestamp to the current "pending" block timestamp
+     * Checks whether signature is soft expired, compares the timestamp to the current "pre-confirmed" block timestamp
      *
      * @param timeout
      * @param preFetchData
      * @public
      */
-    public async isSignatureExpired(
+    public async isSignatureSoftExpired(
         timeout: string,
         preFetchData?: StarknetPreFetchVerification
     ): Promise<boolean> {
@@ -230,6 +230,19 @@ export class StarknetSwapInit extends StarknetSwapModule {
         return preFetchData.pendingBlockTime > parseInt(timeout);
     }
 
+    /**
+     * Checks whether signature is expired for good, compares the timestamp to the current "latest" block timestamp
+     *
+     * @param timeout
+     * @public
+     */
+    public async isSignatureExpired(
+        timeout: string
+    ): Promise<boolean> {
+        const blockTime = await this.root.Blocks.getBlockTime(BlockTag.LATEST);
+        return blockTime > parseInt(timeout);
+    }
+
     /**
      * Creates init transaction with a valid signature from an LP
      *

package/src/starknet/wallet/StarknetKeypairWallet.ts

@@ -19,7 +19,12 @@ export class StarknetKeypairWallet extends Account {
             OZaccountConstructorCallData,
             0
         );
-        super(provider, OZcontractAddress, privateKey, "1");
+        super({
+            provider,
+            address: OZcontractAddress,
+            signer: privateKey,
+            cairoVersion: "1"
+        });
         this.publicKey = publicKey;
     }
 

package/src/starknet/wallet/StarknetSigner.ts

@@ -1,5 +1,5 @@
 import {AbstractSigner} from "@atomiqlabs/base";
-import {Account, DeployAccountContractPayload} from "starknet";
+import {Account, DeployAccountContractPayload, BlockTag} from "starknet";
 import {toHex} from "../../utils/Utils";
 
 export class StarknetSigner implements AbstractSigner {
@@ -27,7 +27,7 @@ export class StarknetSigner implements AbstractSigner {
     //TODO: Introduce proper nonce management!
     async getNonce(): Promise<bigint> {
         try {
-            return BigInt(await this.account.getNonceForAddress(this.getAddress(), "pending"));
+            return BigInt(await this.account.getNonceForAddress(this.getAddress(), BlockTag.PRE_CONFIRMED));
         } catch (e) {
             if(e.message!=null && e.message.includes("20: Contract not found")) {
                 return BigInt(0);

package/src/utils/Utils.ts

@@ -120,7 +120,6 @@ export function calculateHash(tx: StarknetTx): string {
             return tx.txId = hash.calculateDeployAccountTransactionHash({
                 contractAddress: tx.tx.contractAddress,
                 classHash: tx.signed.classHash,
-                constructorCalldata: deployAccountData,
                 compiledConstructorCalldata: deployAccountData,
                 salt: tx.signed.addressSalt,
                 ...commonData