@atomiqlabs/chain-evm 2.1.12 → 2.2.0

package/dist/evm/chain/EVMChainInterface.d.ts

@@ -13,8 +13,17 @@ import { EVMSigner } from "../wallet/EVMSigner";
  * @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;
 };
 /**
@@ -22,16 +31,53 @@ 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;
     };
 };
@@ -42,15 +88,24 @@ export type EVMConfiguration = {
 export declare class EVMChainInterface<ChainId extends string = string> implements ChainInterface<EVMTx, SignedEVMTx, EVMSigner, ChainId, Signer> {
     readonly chainId: ChainId;
     readonly provider: JsonRpcApiProvider;
-    readonly retryPolicy?: EVMRetryPolicy;
     readonly evmChainId: number;
-    readonly config: EVMConfiguration;
+    /**
+     * @internal
+     */
+    readonly _retryPolicy?: EVMRetryPolicy;
+    /**
+     * @internal
+     */
+    readonly _config: EVMConfiguration;
     Fees: EVMFees;
     Tokens: EVMTokens;
     Transactions: EVMTransactions;
     Signatures: EVMSignatures;
     Events: EVMEvents;
     Blocks: EVMBlocks;
+    /**
+     * @internal
+     */
     protected logger: LoggerType;
     constructor(chainId: ChainId, evmChainId: number, provider: JsonRpcApiProvider, config: EVMConfiguration, retryPolicy?: EVMRetryPolicy, evmFeeEstimator?: EVMFees);
     /**
@@ -105,6 +160,10 @@ export declare class EVMChainInterface<ChainId extends string = string> implemen
      * @inheritDoc
      */
     sendSignedAndConfirm(signedTxs: Transaction[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
+    /**
+     * @inheritDoc
+     */
+    prepareTxs(txs: EVMTx[]): Promise<EVMTx[]>;
     /**
      * @inheritDoc
      */

package/dist/evm/chain/EVMChainInterface.js

@@ -22,12 +22,12 @@ class EVMChainInterface {
         this.chainId = chainId;
         this.evmChainId = evmChainId;
         this.provider = provider;
-        this.retryPolicy = retryPolicy;
-        this.config = config;
-        (_a = this.config).safeBlockTag ?? (_a.safeBlockTag = "safe");
-        (_b = this.config).finalizedBlockTag ?? (_b.finalizedBlockTag = "finalized");
-        (_c = this.config).finalityCheckStrategy ?? (_c.finalityCheckStrategy = { type: "timer" });
-        (_d = this.config.finalityCheckStrategy).delayMs ?? (_d.delayMs = 1000);
+        this._retryPolicy = retryPolicy;
+        this._config = config;
+        (_a = this._config).safeBlockTag ?? (_a.safeBlockTag = "safe");
+        (_b = this._config).finalizedBlockTag ?? (_b.finalizedBlockTag = "finalized");
+        (_c = this._config).finalityCheckStrategy ?? (_c.finalityCheckStrategy = { type: "timer" });
+        (_d = this._config.finalityCheckStrategy).delayMs ?? (_d.delayMs = 1000);
         this.logger = (0, Utils_1.getLogger)("EVMChainInterface(" + this.evmChainId + "): ");
         this.Fees = evmFeeEstimator;
         this.Tokens = new EVMTokens_1.EVMTokens(this);
@@ -118,6 +118,13 @@ class EVMChainInterface {
     sendSignedAndConfirm(signedTxs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
         return this.Transactions.sendSignedAndConfirm(signedTxs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
     }
+    /**
+     * @inheritDoc
+     */
+    async prepareTxs(txs) {
+        await this.Transactions.prepareTransactions(txs);
+        return txs;
+    }
     /**
      * @inheritDoc
      */
@@ -158,7 +165,7 @@ class EVMChainInterface {
      * @inheritDoc
      */
     async getFinalizedBlock() {
-        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/dist/evm/chain/EVMModule.d.ts

@@ -1,5 +1,10 @@
 import { JsonRpcApiProvider } from "ethers";
 import { EVMChainInterface, EVMRetryPolicy } from "./EVMChainInterface";
+/**
+ * Base module class shared by EVM chain submodules.
+ *
+ * @category Internal/Chain
+ */
 export declare class EVMModule<ChainId extends string = string> {
     protected readonly provider: JsonRpcApiProvider;
     protected readonly retryPolicy?: EVMRetryPolicy;

package/dist/evm/chain/EVMModule.js

@@ -2,11 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVMModule = void 0;
 const Utils_1 = require("../../utils/Utils");
+/**
+ * Base module class shared by EVM chain submodules.
+ *
+ * @category Internal/Chain
+ */
 class EVMModule {
     constructor(root) {
         this.logger = (0, Utils_1.getLogger)(this.constructor.name + ": ");
         this.provider = root.provider;
-        this.retryPolicy = root.retryPolicy;
+        this.retryPolicy = root._retryPolicy;
         this.root = root;
     }
 }

package/dist/evm/chain/modules/EVMBlocks.d.ts

@@ -1,7 +1,14 @@
 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 declare class EVMBlocks extends EVMModule<any> {

package/dist/evm/chain/modules/EVMBlocks.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVMBlocks = void 0;
 const EVMModule_1 = require("../EVMModule");
 /**
+ * Cached block lookup helper for block and timestamp access.
+ *
  * @category Internal/Chain
  */
 class EVMBlocks extends EVMModule_1.EVMModule {

package/dist/evm/chain/modules/EVMEvents.js

@@ -58,17 +58,17 @@ class EVMEvents extends EVMModule_1.EVMModule {
             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);
+            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));
+                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;
                 }
             }
@@ -76,9 +76,9 @@ class EVMEvents extends EVMModule_1.EVMModule {
         }
         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;
                 }
             }
@@ -97,13 +97,13 @@ class EVMEvents extends EVMModule_1.EVMModule {
      * @param genesisHeight Height when the contract was deployed
      */
     async findInEvents(contract, topics, processor, abortSignal, genesisHeight) {
-        const latestBlock = await this.provider.getBlock(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}`);
+            throw new Error(`Cannot find block ${this.root._config.safeBlockTag}`);
         let promises = [];
-        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), blockNumber));
-            if (promises.length >= this.root.config.maxParallelLogRequests) {
+        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), blockNumber));
+            if (promises.length >= this.root._config.maxParallelLogRequests) {
                 const eventsResult = (await Promise.all(promises)).map(arr => arr.reverse() //Oldest events first
                 ).flat();
                 promises = [];
@@ -134,13 +134,13 @@ class EVMEvents extends EVMModule_1.EVMModule {
      * @param startHeight Blockheight at which to start
      */
     async findInEventsForward(contract, topics, processor, abortSignal, startHeight) {
-        const latestBlock = await this.provider.getBlock(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}`);
+            throw new Error(`Cannot find block ${this.root._config.safeBlockTag}`);
         let promises = [];
-        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)));
-            if (promises.length >= this.root.config.maxParallelLogRequests) {
+        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)));
+            if (promises.length >= this.root._config.maxParallelLogRequests) {
                 const eventsResult = (await Promise.all(promises)).flat();
                 promises = [];
                 if (abortSignal != null)

package/dist/evm/chain/modules/EVMFees.d.ts

@@ -1,19 +1,50 @@
 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 declare class EVMFees {
+    /**
+     * @internal
+     */
     protected MAX_FEE_AGE: number;
+    /**
+     * @internal
+     */
     protected readonly logger: import("../../../utils/Utils").LoggerType;
+    /**
+     * @internal
+     */
     protected readonly provider: JsonRpcApiProvider;
+    /**
+     * @internal
+     */
     protected readonly maxFeeRatePerGas: bigint;
+    /**
+     * @internal
+     */
     protected readonly priorityFee: bigint;
+    /**
+     * @internal
+     */
     protected readonly feeMultiplierPPM: bigint;
     private blockFeeCache?;
+    /**
+     * @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, priorityFee?: bigint, feeMultiplier?: number);
     /**
      * Gets evm fee rate
@@ -23,17 +54,22 @@ export declare class EVMFees {
      */
     private _getFeeRate;
     /**
-     * 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>`
      */
     getFeeRate(): Promise<string>;
     /**
      * 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>`
      */
     static getGasFee(gas: number, feeRate: string): bigint;
+    /**
+     * 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>`
+     */
     static applyFeeRate(tx: TransactionRequest, gas: number | null, feeRate: string): void;
 }

package/dist/evm/chain/modules/EVMFees.js

@@ -3,11 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVMFees = void 0;
 const Utils_1 = require("../../../utils/Utils");
 /**
+ * Fee estimation service for EVM chains.
+ *
  * @category Chain Interface
  */
 class EVMFees {
+    /**
+     * @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, maxFeeRatePerGas = 500n * 1000000000n, priorityFee = 1n * 1000000000n, feeMultiplier = 1.25) {
+        /**
+         * @internal
+         */
         this.MAX_FEE_AGE = 5000;
+        /**
+         * @internal
+         */
         this.logger = (0, Utils_1.getLogger)("EVMFees: ");
         this.provider = provider;
         this.maxFeeRatePerGas = maxFeeRatePerGas;
@@ -31,9 +45,7 @@ class EVMFees {
         return baseFee;
     }
     /**
-     * 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>`
      */
     async getFeeRate() {
         if (this.blockFeeCache == null || Date.now() - this.blockFeeCache.timestamp > this.MAX_FEE_AGE) {
@@ -57,8 +69,8 @@ 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>`
      */
     static getGasFee(gas, feeRate) {
         if (feeRate == null)
@@ -66,6 +78,13 @@ class EVMFees {
         const [baseFee, priorityFee] = feeRate.split(",");
         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>`
+     */
     static applyFeeRate(tx, gas, feeRate) {
         if (feeRate == null)
             return;

package/dist/evm/chain/modules/EVMTokens.d.ts

@@ -11,7 +11,7 @@ export declare class EVMTokens extends EVMModule<any> {
     };
     private getContract;
     /**
-     * Checks if the provided string is a valid starknet token
+     * Checks if the provided string is a valid EVM token address.
      *
      * @param token
      */

package/dist/evm/chain/modules/EVMTokens.js

@@ -16,7 +16,7 @@ class EVMTokens extends EVMModule_1.EVMModule {
     ///////////////////
     //// 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/dist/evm/chain/modules/EVMTransactions.d.ts

@@ -1,8 +1,23 @@
 import { EVMModule } from "../EVMModule";
 import { Transaction, TransactionRequest } from "ethers";
 import { EVMSigner } from "../../wallet/EVMSigner";
+/**
+ * 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;
@@ -16,6 +31,8 @@ export type EVMTxTrace = {
     type: "CREATE" | "CALL" | "STATICCALL";
 };
 /**
+ * Transaction service for preparing, signing, broadcasting and confirming EVM transactions.
+ *
  * @category Internal/Chain
  */
 export declare class EVMTransactions extends EVMModule<any> {
@@ -36,14 +53,14 @@ export declare class EVMTransactions extends EVMModule<any> {
     private confirmTransaction;
     private applyAccessList;
     /**
-     * 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
+     * @param signer
      * @param useAccessList Whether to use access lists for sending txns
-     * @private
      */
-    private prepareTransactions;
+    prepareTransactions(txs: TransactionRequest[], signer?: EVMSigner, useAccessList?: boolean): Promise<void>;
     /**
      * Sends out a signed transaction to the RPC
      *
@@ -93,7 +110,7 @@ export declare class EVMTransactions extends EVMModule<any> {
      */
     deserializeSignedTx(signedTxData: string): Transaction;
     /**
-     * Gets the status of the raw starknet transaction
+     * Gets the status of a raw signed EVM transaction.
      *
      * @param tx
      */

package/dist/evm/chain/modules/EVMTransactions.js

@@ -7,6 +7,8 @@ const Utils_1 = require("../../../utils/Utils");
 const base_1 = require("@atomiqlabs/base");
 const MAX_UNCONFIRMED_TXNS = 10;
 /**
+ * Transaction service for preparing, signing, broadcasting and confirming EVM transactions.
+ *
  * @category Internal/Chain
  */
 class EVMTransactions extends EVMModule_1.EVMModule {
@@ -59,7 +61,7 @@ class EVMTransactions extends EVMModule_1.EVMModule {
                 }
                 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;
                 }
@@ -97,9 +99,9 @@ class EVMTransactions extends EVMModule_1.EVMModule {
                         value: (0, ethers_1.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) {
@@ -112,21 +114,27 @@ class EVMTransactions extends EVMModule_1.EVMModule {
             tx.accessList = accessListResponse.accessList;
     }
     /**
-     * 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
+     * @param signer
      * @param useAccessList Whether to use access lists for sending txns
-     * @private
      */
-    async prepareTransactions(signer, txs, useAccessList) {
+    async prepareTransactions(txs, signer, useAccessList) {
+        if (txs.length === 0)
+            return;
+        const signerAddress = signer?.getAddress()
+            ?? (txs[0].from == null ? null : await (0, ethers_1.resolveAddress)(txs[0].from, this.provider));
+        if (signerAddress == null)
+            throw new Error("Cannot get tx sender address!");
         for (let tx of txs) {
             tx.chainId = this.root.evmChainId;
-            tx.from = signer.getAddress();
+            tx.from = signerAddress;
         }
-        if (!signer.isManagingNoncesInternally) {
-            let nonce = await this.root.provider.getTransactionCount(signer.getAddress(), "pending");
-            const latestKnownNonce = this.latestPendingNonces[signer.getAddress()];
+        if (signer == null || !signer.isManagingNoncesInternally) {
+            let nonce = await this.root.provider.getTransactionCount(signerAddress, "pending");
+            const latestKnownNonce = this.latestPendingNonces[signerAddress];
             if (latestKnownNonce != null && latestKnownNonce > nonce) {
                 this.logger.debug("prepareTransactions(): Using nonce from local cache!");
                 nonce = latestKnownNonce;
@@ -136,20 +144,21 @@ class EVMTransactions extends EVMModule_1.EVMModule {
                 if (tx.nonce != null)
                     nonce = tx.nonce; //Take the nonce from last tx
                 if (nonce == null)
-                    nonce = await this.root.provider.getTransactionCount(signer.getAddress(), "pending"); //Fetch the nonce
+                    nonce = await this.root.provider.getTransactionCount(signerAddress, "pending"); //Fetch the nonce
                 if (tx.nonce == null)
                     tx.nonce = nonce;
                 this.logger.debug("sendAndConfirm(): transaction prepared (" + (i + 1) + "/" + txs.length + "), nonce: " + tx.nonce);
                 nonce++;
             }
         }
-        for (let tx of txs) {
-            if (useAccessList)
-                await this.applyAccessList(tx);
-            for (let callback of this.cbksBeforeTxSigned) {
-                await callback(tx);
+        if (signer != null)
+            for (let tx of txs) {
+                if (useAccessList)
+                    await this.applyAccessList(tx);
+                for (let callback of this.cbksBeforeTxSigned) {
+                    await callback(tx);
+                }
             }
-        }
     }
     /**
      * Sends out a signed transaction to the RPC
@@ -188,7 +197,7 @@ class EVMTransactions extends EVMModule_1.EVMModule {
      * @param useAccessLists
      */
     async sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish, useAccessLists) {
-        await this.prepareTransactions(signer, txs, useAccessLists ?? this.root.config.useAccessLists);
+        await this.prepareTransactions(txs, signer, useAccessLists ?? this.root._config.useAccessLists);
         const signedTxs = [];
         //Don't separate the signing process from the sending when using browser-based wallet
         if (signer.signTransaction != null)
@@ -361,7 +370,7 @@ class EVMTransactions extends EVMModule_1.EVMModule {
         return ethers_1.Transaction.from(signedTxData);
     }
     /**
-     * Gets the status of the raw starknet transaction
+     * Gets the status of a raw signed EVM transaction.
      *
      * @param tx
      */
@@ -381,9 +390,9 @@ class EVMTransactions extends EVMModule_1.EVMModule {
         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)
         ]);
         if (txReceipt == null || (safeBlockNumber != null && txReceipt.blockNumber > safeBlockNumber))