@atomiqlabs/chain-evm 2.1.12 → 2.1.14

package/src/evm/btcrelay/headers/EVMBtcStoredHeader.ts

@@ -3,7 +3,12 @@ import {EVMBtcHeader, EVMBtcHeaderType} from "./EVMBtcHeader";
 import {Buffer} from "buffer";
 import {keccak256} from "ethers";
 
-export type StarknetBtcStoredHeaderType = {
+/**
+ * Constructor payload for a stored bitcoin header committed in EVM BTC relay contract state.
+ *
+ * @category BTC Relay
+ */
+export type EVMBtcStoredHeaderType = {
     blockheader: EVMBtcHeader | EVMBtcHeaderType,
     blockHash: Buffer,
     chainWork: bigint,
@@ -13,18 +18,23 @@ export type StarknetBtcStoredHeaderType = {
 }
 
 /**
+ * Represents a bitcoin header already committed inside EVM BTC relay contract state.
+ *
  * @category BTC Relay
  */
 export class EVMBtcStoredHeader implements BtcStoredHeader<EVMBtcHeader> {
 
-    blockheader: EVMBtcHeader;
-    blockHash: Buffer;
-    chainWork: bigint;
-    blockHeight: number;
-    lastDiffAdjustment: number;
-    prevBlockTimestamps: number[];
+    private readonly blockheader: EVMBtcHeader;
+    private readonly blockHash: Buffer;
+    private readonly chainWork: bigint;
+    private readonly blockHeight: number;
+    private readonly lastDiffAdjustment: number;
+    private readonly prevBlockTimestamps: number[];
 
-    constructor(obj: StarknetBtcStoredHeaderType) {
+    /**
+     * @internal
+     */
+    constructor(obj: EVMBtcStoredHeaderType) {
         this.blockheader = obj.blockheader instanceof EVMBtcHeader ? obj.blockheader : new EVMBtcHeader(obj.blockheader);
         this.blockHash = obj.blockHash;
         this.chainWork = obj.chainWork;
@@ -33,26 +43,44 @@ export class EVMBtcStoredHeader implements BtcStoredHeader<EVMBtcHeader> {
         this.prevBlockTimestamps = obj.prevBlockTimestamps;
     }
 
+    /**
+     * @inheritDoc
+     */
     getBlockheight(): number {
         return this.blockHeight;
     }
 
+    /**
+     * @inheritDoc
+     */
     getChainWork(): Buffer {
         return Buffer.from(this.chainWork.toString(16).padStart(64, "0"), "hex");
     }
 
+    /**
+     * @inheritDoc
+     */
     getHeader(): EVMBtcHeader {
         return this.blockheader;
     }
 
+    /**
+     * @inheritDoc
+     */
     getLastDiffAdjustment(): number {
         return this.lastDiffAdjustment;
     }
 
+    /**
+     * @inheritDoc
+     */
     getPrevBlockTimestamps(): number[] {
         return this.prevBlockTimestamps;
     }
 
+    /**
+     * @inheritDoc
+     */
     getBlockHash(): Buffer {
         return Buffer.from([...this.blockHash]).reverse();
     }
@@ -99,8 +127,11 @@ export class EVMBtcStoredHeader implements BtcStoredHeader<EVMBtcHeader> {
         return lastDiffAdjustment;
     }
 
+    /**
+     * @inheritDoc
+     */
     computeNext(header: EVMBtcHeader): EVMBtcStoredHeader {
-        header.previousBlockhash = this.blockHash;
+        header._previousBlockhash = this.blockHash;
         return new EVMBtcStoredHeader({
             chainWork: this.computeNextChainWork(header.getNbits()),
             prevBlockTimestamps: this.computeNextBlockTimestamps(),
@@ -111,10 +142,16 @@ export class EVMBtcStoredHeader implements BtcStoredHeader<EVMBtcHeader> {
         });
     }
 
+    /**
+     * Returns the commitment of this stored head (keccak256 hash), this is what's actually stored on-chain
+     */
     getCommitHash(): string {
         return keccak256(this.serialize());
     }
 
+    /**
+     * Serializes the stored blockheader into the 160-byte binary layout used by the EVM contracts.
+     */
     serialize(): Buffer {
         const buffer = Buffer.alloc(160);
         this.blockheader.serialize().copy(buffer, 0, 0, 80);
@@ -127,6 +164,9 @@ export class EVMBtcStoredHeader implements BtcStoredHeader<EVMBtcHeader> {
         return buffer;
     }
 
+    /**
+     * Serializes the stored blockheader into the contract tuple form (`bytes32[5]` payload).
+     */
     serializeToStruct(): {data: [string, string, string, string, string]} {
         const buffer = this.serialize();
         const result: string[] = [];
@@ -136,6 +176,11 @@ export class EVMBtcStoredHeader implements BtcStoredHeader<EVMBtcHeader> {
         return {data: result as any};
     }
 
+    /**
+     * Deserializes a stored blockheader from the 160-byte binary representation.
+     *
+     * @param data Serialized stored blockheader bytes
+     */
     static deserialize(data: Buffer): EVMBtcStoredHeader {
         if(data.length!==160) throw new Error(`Invalid size Expected 160, got: ${data.length}!`);
         const blockheader = EVMBtcHeader.deserialize(data.subarray(0, 80));
@@ -153,4 +198,4 @@ export class EVMBtcStoredHeader implements BtcStoredHeader<EVMBtcHeader> {
         });
     }
 
-}
+}

package/src/evm/chain/EVMChainInterface.ts

@@ -25,8 +25,17 @@ import {EVMBrowserSigner} from "../wallet/EVMBrowserSigner";
  * @category Chain Interface
  */
 export type EVMRetryPolicy = {
+    /**
+     * Maximum retries to be attempted
+     */
     maxRetries?: number,
+    /**
+     * Default delay between retries
+     */
     delay?: number,
+    /**
+     * Whether the delays should scale exponentially, i.e. 1 second, 2 seconds, 4 seconds, 8 seconds
+     */
     exponential?: boolean
 }
 
@@ -35,18 +44,55 @@ export type EVMRetryPolicy = {
  * @category Chain Interface
  */
 export type EVMConfiguration = {
+    /**
+     * EVM Block tag to be considered safe for financial application, i.e. sending assets on different blockchains
+     */
     safeBlockTag: EVMBlockTag,
+    /**
+     * EVM Block tag to be considered finalized, i.e. the state definitely cannot revert after the blocks gets
+     *  this level of finality
+     */
     finalizedBlockTag: EVMBlockTag,
+    /**
+     * Maximum range of blocks to query when querying `ethereum_getLogs` RPC endpoint.
+     */
     maxLogsBlockRange: number,
+    /**
+     * Maximum number of `ethereum_getLogs` RPC calls to be executed in parallel
+     */
     maxParallelLogRequests: number,
+    /**
+     * Maximum number of parallel contract calls to execute in batch functions
+     */
     maxParallelCalls: number,
+    /**
+     * Maximum number of topics specified in the `ethereum_getLogs` RPC call
+     */
     maxLogTopics: number,
 
+    /**
+     * Whether to use EIP-2930 access lists for transactions, if set to `true` the transaction is simulated before
+     *  sending and the access list is populated for the transaction
+     */
     useAccessLists?: boolean,
+    /**
+     * Default EIP-2930 addresses to add when simulating the transaction initially
+     */
     defaultAccessListAddresses?: string[],
 
+    /**
+     * Strategy for checking finality of transactions or events
+     */
     finalityCheckStrategy?: {
+        /**
+         * Type of the finality checking strategy:
+         * - `"timer"` - periodically checks for the finality status, set the interval period `delayMs`
+         * - `"blocks"` - check for the finality when new block is created
+         */
         type: "timer" | "blocks"
+        /**
+         * Interval in milliseconds to use for the `"timer"` type of finality checking strategy
+         */
         delayMs?: number
     }
 };
@@ -57,14 +103,18 @@ export type EVMConfiguration = {
  */
 export class EVMChainInterface<ChainId extends string = string> implements ChainInterface<EVMTx, SignedEVMTx, EVMSigner, ChainId, Signer> {
 
-    readonly chainId: ChainId;
-
-    readonly provider: JsonRpcApiProvider;
-    readonly retryPolicy?: EVMRetryPolicy;
-
+    public readonly chainId: ChainId;
+    public readonly provider: JsonRpcApiProvider;
     public readonly evmChainId: number;
 
-    public readonly config: EVMConfiguration;
+    /**
+     * @internal
+     */
+    readonly _retryPolicy?: EVMRetryPolicy;
+    /**
+     * @internal
+     */
+    readonly _config: EVMConfiguration;
 
     public Fees: EVMFees;
     public Tokens: EVMTokens;
@@ -73,6 +123,9 @@ export class EVMChainInterface<ChainId extends string = string> implements Chain
     public Events: EVMEvents;
     public Blocks: EVMBlocks;
 
+    /**
+     * @internal
+     */
     protected logger: LoggerType;
 
     constructor(
@@ -86,12 +139,12 @@ export class EVMChainInterface<ChainId extends string = string> implements Chain
         this.chainId = chainId;
         this.evmChainId = evmChainId;
         this.provider = provider;
-        this.retryPolicy = retryPolicy;
-        this.config = config;
-        this.config.safeBlockTag ??= "safe";
-        this.config.finalizedBlockTag ??= "finalized";
-        this.config.finalityCheckStrategy ??= {type: "timer"};
-        this.config.finalityCheckStrategy.delayMs ??= 1000;
+        this._retryPolicy = retryPolicy;
+        this._config = config;
+        this._config.safeBlockTag ??= "safe";
+        this._config.finalizedBlockTag ??= "finalized";
+        this._config.finalityCheckStrategy ??= {type: "timer"};
+        this._config.finalityCheckStrategy.delayMs ??= 1000;
 
         this.logger = getLogger("EVMChainInterface("+this.evmChainId+"): ");
 
@@ -103,7 +156,6 @@ export class EVMChainInterface<ChainId extends string = string> implements Chain
         this.Blocks = new EVMBlocks(this);
     }
 
-
     /**
      * @inheritDoc
      */
@@ -258,7 +310,7 @@ export class EVMChainInterface<ChainId extends string = string> implements Chain
      * @inheritDoc
      */
     async getFinalizedBlock(): Promise<{ height: number; blockHash: string }> {
-        const block = await this.Blocks.getBlock(this.config.finalizedBlockTag);
+        const block = await this.Blocks.getBlock(this._config.finalizedBlockTag);
         return {
             height: block.number,
             blockHash: block.hash!

package/src/evm/chain/EVMModule.ts

@@ -2,6 +2,11 @@ import {getLogger} from "../../utils/Utils";
 import {JsonRpcApiProvider} from "ethers";
 import {EVMChainInterface, EVMRetryPolicy} from "./EVMChainInterface";
 
+/**
+ * Base module class shared by EVM chain submodules.
+ *
+ * @category Internal/Chain
+ */
 export class EVMModule<ChainId extends string = string> {
 
     protected readonly provider: JsonRpcApiProvider;
@@ -14,7 +19,7 @@ export class EVMModule<ChainId extends string = string> {
         root: EVMChainInterface<ChainId>
     ) {
         this.provider = root.provider;
-        this.retryPolicy = root.retryPolicy;
+        this.retryPolicy = root._retryPolicy;
         this.root = root;
     }
 

package/src/evm/chain/modules/EVMBlocks.ts

@@ -1,9 +1,16 @@
 import {EVMModule} from "../EVMModule";
 import {Block} from "ethers";
 
+/**
+ * Supported EVM block tags used for safety/finality aware reads.
+ *
+ * @category Chain Interface
+ */
 export type EVMBlockTag = "safe" | "pending" | "latest" | "finalized";
 
 /**
+ * Cached block lookup helper for block and timestamp access.
+ *
  * @category Internal/Chain
  */
 export class EVMBlocks extends EVMModule<any> {

package/src/evm/chain/modules/EVMEvents.ts

@@ -68,24 +68,24 @@ export class EVMEvents extends EVMModule<any> {
             events = await this.root.provider.getLogs({
                 address: contract,
                 fromBlock: startBlock,
-                toBlock: endBlock==null ? this.root.config.safeBlockTag : endBlock,
+                toBlock: endBlock==null ? this.root._config.safeBlockTag : endBlock,
                 topics
             });
         } else if(endBlock==null) {
-            const safeBlock = await this.root.provider.getBlock(this.root.config.safeBlockTag);
-            if(safeBlock==null) throw new Error(`Cannot retrieve '${this.root.config.safeBlockTag}' block`);
-            if(safeBlock.number - startBlock > this.root.config.maxLogsBlockRange) {
-                for(let i = startBlock + this.root.config.maxLogsBlockRange; i < safeBlock.number; i += this.root.config.maxLogsBlockRange) {
-                    events.push(...await this.getLogs(contract, topics, i - this.root.config.maxLogsBlockRange, i));
+            const safeBlock = await this.root.provider.getBlock(this.root._config.safeBlockTag);
+            if(safeBlock==null) throw new Error(`Cannot retrieve '${this.root._config.safeBlockTag}' block`);
+            if(safeBlock.number - startBlock > this.root._config.maxLogsBlockRange) {
+                for(let i = startBlock + this.root._config.maxLogsBlockRange; i < safeBlock.number; i += this.root._config.maxLogsBlockRange) {
+                    events.push(...await this.getLogs(contract, topics, i - this.root._config.maxLogsBlockRange, i));
                     startBlock = i;
                 }
             }
             events.push(...await this.getLogs(contract, topics, startBlock, safeBlock.number));
         } else {
             //Both numeric
-            if(endBlock - startBlock > this.root.config.maxLogsBlockRange) {
-                for(let i = startBlock + this.root.config.maxLogsBlockRange; i < endBlock; i += this.root.config.maxLogsBlockRange) {
-                    events.push(...await this.getLogs(contract, topics, i - this.root.config.maxLogsBlockRange, i));
+            if(endBlock - startBlock > this.root._config.maxLogsBlockRange) {
+                for(let i = startBlock + this.root._config.maxLogsBlockRange; i < endBlock; i += this.root._config.maxLogsBlockRange) {
+                    events.push(...await this.getLogs(contract, topics, i - this.root._config.maxLogsBlockRange, i));
                     startBlock = i;
                 }
             }
@@ -111,19 +111,19 @@ export class EVMEvents extends EVMModule<any> {
         abortSignal?: AbortSignal,
         genesisHeight?: number
     ): Promise<T | null> {
-        const latestBlock = await this.provider.getBlock(this.root.config.safeBlockTag);
-        if(latestBlock==null) throw new Error(`Cannot find block ${this.root.config.safeBlockTag}`);
+        const latestBlock = await this.provider.getBlock(this.root._config.safeBlockTag);
+        if(latestBlock==null) throw new Error(`Cannot find block ${this.root._config.safeBlockTag}`);
 
         let promises: Promise<Log[]>[] = [];
-        for(let blockNumber = latestBlock.number; blockNumber >= (genesisHeight ?? 0); blockNumber-=this.root.config.maxLogsBlockRange) {
+        for(let blockNumber = latestBlock.number; blockNumber >= (genesisHeight ?? 0); blockNumber-=this.root._config.maxLogsBlockRange) {
             promises.push(this.getLogs(
                 contract,
                 topics,
-                Math.max(blockNumber-this.root.config.maxLogsBlockRange, 0),
+                Math.max(blockNumber-this.root._config.maxLogsBlockRange, 0),
                 blockNumber
             ));
 
-            if(promises.length>=this.root.config.maxParallelLogRequests) {
+            if(promises.length>=this.root._config.maxParallelLogRequests) {
                 const eventsResult = (await Promise.all(promises)).map(
                     arr => arr.reverse() //Oldest events first
                 ).flat();
@@ -162,18 +162,18 @@ export class EVMEvents extends EVMModule<any> {
         abortSignal?: AbortSignal,
         startHeight?: number
     ): Promise<T | null> {
-        const latestBlock = await this.provider.getBlock(this.root.config.safeBlockTag);
-        if(latestBlock==null) throw new Error(`Cannot find block ${this.root.config.safeBlockTag}`);
+        const latestBlock = await this.provider.getBlock(this.root._config.safeBlockTag);
+        if(latestBlock==null) throw new Error(`Cannot find block ${this.root._config.safeBlockTag}`);
 
         let promises: Promise<Log[]>[] = [];
-        for(let blockNumber = startHeight ?? 0; blockNumber < latestBlock.number; blockNumber += this.root.config.maxLogsBlockRange) {
+        for(let blockNumber = startHeight ?? 0; blockNumber < latestBlock.number; blockNumber += this.root._config.maxLogsBlockRange) {
             promises.push(this.getLogs(
                 contract,
                 topics,
                 blockNumber,
-                Math.min(blockNumber + this.root.config.maxLogsBlockRange, latestBlock.number)
+                Math.min(blockNumber + this.root._config.maxLogsBlockRange, latestBlock.number)
             ));
-            if(promises.length>=this.root.config.maxParallelLogRequests) {
+            if(promises.length>=this.root._config.maxParallelLogRequests) {
                 const eventsResult = (await Promise.all(promises)).flat();
                 promises = [];
                 if(abortSignal!=null) abortSignal.throwIfAborted();

package/src/evm/chain/modules/EVMFees.ts

@@ -1,23 +1,48 @@
 import { getLogger } from "../../../utils/Utils";
 import {JsonRpcApiProvider, TransactionRequest} from "ethers";
 
+/**
+ * Parsed EIP-1559 fee rate components.
+ *
+ * @category Chain Interface
+ */
 export type EVMFeeRate = {
     maxFeePerGas: bigint;
     maxPriorityFee: bigint;
 };
 
 /**
+ * Fee estimation service for EVM chains.
+ *
  * @category Chain Interface
  */
 export class EVMFees {
+    /**
+     * @internal
+     */
     protected MAX_FEE_AGE = 5000;
 
+    /**
+     * @internal
+     */
     protected readonly logger = getLogger("EVMFees: ");
 
+    /**
+     * @internal
+     */
     protected readonly provider: JsonRpcApiProvider;
+    /**
+     * @internal
+     */
     protected readonly maxFeeRatePerGas: bigint;
+    /**
+     * @internal
+     */
     protected readonly priorityFee: bigint;
 
+    /**
+     * @internal
+     */
     protected readonly feeMultiplierPPM: bigint;
 
     private blockFeeCache?: {
@@ -25,6 +50,12 @@ export class EVMFees {
         feeRate: Promise<bigint>
     };
 
+    /**
+     * @param provider Underlying RPC provider providing read access to the EVM network
+     * @param maxFeeRatePerGas Maximum fee rate for a transaction, default to 500 GWei
+     * @param priorityFee Priority fee (or tip) to add to the transactions, default to 1 GWei
+     * @param feeMultiplier Fee multiplier to multiply the RPC-returned fee rate with
+     */
     constructor(
         provider: JsonRpcApiProvider,
         maxFeeRatePerGas: bigint = 500n * 1_000_000_000n,
@@ -55,9 +86,7 @@ export class EVMFees {
     }
 
     /**
-     * Gets the gas price with caching, format: <base fee Wei>,<priority fee Wei>
-     *
-     * @private
+     * Gets the gas price with caching, format: `<base fee Wei>,<priority fee Wei>`
      */
     public async getFeeRate(): Promise<string> {
         if(this.blockFeeCache==null || Date.now() - this.blockFeeCache.timestamp > this.MAX_FEE_AGE) {
@@ -87,8 +116,8 @@ export class EVMFees {
     /**
      * Calculates the total gas fee paid for a given gas limit at a given fee rate
      *
-     * @param gas
-     * @param feeRate
+     * @param gas Gas limit to add to the transaction
+     * @param feeRate Serialized fee rate to add to the transaction, in format: `<baseFee>,<priorityFee>`
      */
     public static getGasFee(gas: number, feeRate: string): bigint {
         if(feeRate==null) return 0n;
@@ -98,6 +127,13 @@ export class EVMFees {
         return BigInt(gas) * (BigInt(baseFee) + BigInt(priorityFee));
     }
 
+    /**
+     * Applies the gas limit and fee rate to a transaction
+     *
+     * @param tx EVM Transaction to apply the fee rate to
+     * @param gas Gas limit to add to the transaction
+     * @param feeRate Serialized fee rate to add to the transaction, in format: `<baseFee>,<priorityFee>`
+     */
     public static applyFeeRate(tx: TransactionRequest, gas: number | null, feeRate: string): void {
         if(feeRate==null) return;
 

package/src/evm/chain/modules/EVMTokens.ts

@@ -24,7 +24,7 @@ export class EVMTokens extends EVMModule<any> {
     ///////////////////
     //// Tokens
     /**
-     * Checks if the provided string is a valid starknet token
+     * Checks if the provided string is a valid EVM token address.
      *
      * @param token
      */

package/src/evm/chain/modules/EVMTransactions.ts

@@ -10,9 +10,25 @@ import {timeoutPromise} from "../../../utils/Utils";
 import {EVMSigner} from "../../wallet/EVMSigner";
 import {TransactionRevertedError} from "@atomiqlabs/base";
 
+/**
+ * Unsigned EVM transaction type used by chain modules.
+ *
+ * @category Chain Interface
+ */
 export type EVMTx = TransactionRequest;
+
+/**
+ * Signed EVM transaction type as produced by ethers.
+ *
+ * @category Chain Interface
+ */
 export type SignedEVMTx = Transaction;
 
+/**
+ * Simplified call-trace structure returned by `debug_traceTransaction` with `callTracer`.
+ *
+ * @category Internal/Chain
+ */
 export type EVMTxTrace = {
     from: string,
     gas: string,
@@ -29,6 +45,8 @@ export type EVMTxTrace = {
 const MAX_UNCONFIRMED_TXNS = 10;
 
 /**
+ * Transaction service for preparing, signing, broadcasting and confirming EVM transactions.
+ *
  * @category Internal/Chain
  */
 export class EVMTransactions extends EVMModule<any> {
@@ -84,7 +102,7 @@ export class EVMTransactions extends EVMModule<any> {
                 }
                 this.logger.warn("confirmTransaction(): All transactions not found, fetching the latest account nonce...");
                 const _latestConfirmedNonce = this.latestConfirmedNonces[tx.from!];
-                const currentLatestNonce = await this.provider.getTransactionCount(tx.from!, this.root.config.safeBlockTag);
+                const currentLatestNonce = await this.provider.getTransactionCount(tx.from!, this.root._config.safeBlockTag);
                 if(_latestConfirmedNonce==null || _latestConfirmedNonce < currentLatestNonce) {
                     this.latestConfirmedNonces[tx.from!] = currentLatestNonce;
                 }
@@ -126,9 +144,9 @@ export class EVMTransactions extends EVMModule<any> {
                     value: toBeHex(tx.value ?? 0n),
                     input: tx.data,
                     data: tx.data,
-                    accessList: this.root.config.defaultAccessListAddresses==null
+                    accessList: this.root._config.defaultAccessListAddresses==null
                         ? undefined
-                        : this.root.config.defaultAccessListAddresses.map(val => ({address: val, storageKeys: []}))
+                        : this.root._config.defaultAccessListAddresses.map(val => ({address: val, storageKeys: []}))
                 }, "pending"]);
             } catch (e: any) {
                 //Unable to create access list, fuck it
@@ -140,7 +158,8 @@ export class EVMTransactions extends EVMModule<any> {
     }
 
     /**
-     * Prepares starknet transactions, checks if the account is deployed, assigns nonces if needed & calls beforeTxSigned callback
+     * Prepares EVM transactions, assigns nonces when needed, and optionally applies access lists
+     * before signing.
      *
      * @param signer
      * @param txs
@@ -227,7 +246,7 @@ export class EVMTransactions extends EVMModule<any> {
         abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>,
         useAccessLists?: boolean
     ): Promise<string[]> {
-        await this.prepareTransactions(signer, txs, useAccessLists ?? this.root.config.useAccessLists);
+        await this.prepareTransactions(signer, txs, useAccessLists ?? this.root._config.useAccessLists);
         const signedTxs: Transaction[] = [];
 
         //Don't separate the signing process from the sending when using browser-based wallet
@@ -415,7 +434,7 @@ export class EVMTransactions extends EVMModule<any> {
     }
 
     /**
-     * Gets the status of the raw starknet transaction
+     * Gets the status of a raw signed EVM transaction.
      *
      * @param tx
      */
@@ -435,9 +454,9 @@ export class EVMTransactions extends EVMModule<any> {
         if(txResponse.blockHash==null) return "pending";
 
         const [safeBlockNumber, txReceipt] = await Promise.all([
-            this.root.config.safeBlockTag==="latest"
+            this.root._config.safeBlockTag==="latest"
                 ? Promise.resolve(null)
-                : this.provider.getBlock(this.root.config.safeBlockTag).then(res => res?.number ?? 0),
+                : this.provider.getBlock(this.root._config.safeBlockTag).then(res => res?.number ?? 0),
             this.provider.getTransactionReceipt(txId)
         ]);