@atomiqlabs/chain-evm 2.1.12 → 2.1.14

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);
     /**

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);
@@ -158,7 +158,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,7 +53,8 @@ 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
@@ -93,7 +111,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,7 +114,8 @@ 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
@@ -188,7 +191,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(signer, txs, 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 +364,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 +384,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))

package/dist/evm/contract/EVMContractBase.d.ts

@@ -1,22 +1,40 @@
-import { BaseContract, Log, TransactionDescription } from "ethers";
+import { BaseContract, TransactionDescription } from "ethers";
 import { EVMChainInterface } from "../chain/EVMChainInterface";
 import { EVMContractEvents } from "./modules/EVMContractEvents";
-import { TypedContractMethod, TypedEventLog } from "../typechain/common";
+import { TypedContractMethod } from "../typechain/common";
 type __TypechainOutputObject<T> = T extends TypedContractMethod<infer V> ? V : never;
+/**
+ * Typed transaction call decoded from calldata for a specific contract method.
+ *
+ * @category Internal/Contracts
+ */
 export interface TypedFunctionCall<TCMethod extends TypedContractMethod> extends Omit<TransactionDescription, "args"> {
     args: __TypechainOutputObject<TCMethod>;
 }
 /**
- * Base class providing program specific utilities
+ * Base contract wrapper providing typed event and calldata parsing helpers.
+ *
+ * @category Internal/Contracts
  */
 export declare class EVMContractBase<T extends BaseContract> {
-    contract: T;
-    readonly Events: EVMContractEvents<T>;
-    readonly Chain: EVMChainInterface<any>;
-    readonly contractAddress: string;
-    readonly contractDeploymentHeight?: number;
+    readonly contract: T;
+    /**
+     * @internal
+     */
+    readonly _Events: EVMContractEvents<T>;
+    protected readonly Chain: EVMChainInterface<any>;
+    /**
+     * @internal
+     */
+    readonly _contractAddress: string;
+    /**
+     * @internal
+     */
+    readonly _contractDeploymentHeight?: number;
     constructor(chainInterface: EVMChainInterface<any>, contractAddress: string, contractAbi: any, contractDeploymentHeight?: number);
-    toTypedEvent<TEventName extends keyof T["filters"] = keyof T["filters"]>(log: Log): TypedEventLog<T["filters"][TEventName]> | null;
-    parseCalldata<TMethod extends TypedContractMethod>(calldata: string): TypedFunctionCall<TMethod>;
+    /**
+     * @internal
+     */
+    protected parseCalldata<TMethod extends TypedContractMethod>(calldata: string): TypedFunctionCall<TMethod>;
 }
 export {};

package/dist/evm/contract/EVMContractBase.js

@@ -4,30 +4,21 @@ exports.EVMContractBase = void 0;
 const ethers_1 = require("ethers");
 const EVMContractEvents_1 = require("./modules/EVMContractEvents");
 /**
- * Base class providing program specific utilities
+ * Base contract wrapper providing typed event and calldata parsing helpers.
+ *
+ * @category Internal/Contracts
  */
 class EVMContractBase {
     constructor(chainInterface, contractAddress, contractAbi, contractDeploymentHeight) {
         this.Chain = chainInterface;
         this.contract = new ethers_1.Contract(contractAddress, contractAbi, chainInterface.provider);
-        this.Events = new EVMContractEvents_1.EVMContractEvents(chainInterface, this);
-        this.contractAddress = contractAddress;
-        this.contractDeploymentHeight = contractDeploymentHeight;
-    }
-    toTypedEvent(log) {
-        let foundFragment = null;
-        try {
-            foundFragment = this.contract.interface.getEvent(log.topics[0]);
-        }
-        catch (error) { }
-        if (!foundFragment)
-            return null;
-        try {
-            return new ethers_1.EventLog(log, this.contract.interface, foundFragment);
-        }
-        catch (error) { }
-        return null;
+        this._Events = new EVMContractEvents_1.EVMContractEvents(chainInterface, this);
+        this._contractAddress = contractAddress;
+        this._contractDeploymentHeight = contractDeploymentHeight;
     }
+    /**
+     * @internal
+     */
     parseCalldata(calldata) {
         return this.contract.interface.parseTransaction({ data: calldata });
     }

package/dist/evm/contract/EVMContractModule.d.ts

@@ -2,6 +2,11 @@ import { BaseContract } from "ethers";
 import { EVMModule } from "../chain/EVMModule";
 import { EVMChainInterface } from "../chain/EVMChainInterface";
 import { EVMContractBase } from "./EVMContractBase";
+/**
+ * Base module class for EVM components tied to a specific contract wrapper.
+ *
+ * @category Internal/Contracts
+ */
 export declare class EVMContractModule<T extends BaseContract, C extends EVMContractBase<T> = EVMContractBase<T>> extends EVMModule<any> {
     readonly contract: C;
     constructor(chainInterface: EVMChainInterface<any>, contract: C);

package/dist/evm/contract/EVMContractModule.js

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVMContractModule = void 0;
 const EVMModule_1 = require("../chain/EVMModule");
+/**
+ * Base module class for EVM components tied to a specific contract wrapper.
+ *
+ * @category Internal/Contracts
+ */
 class EVMContractModule extends EVMModule_1.EVMModule {
     constructor(chainInterface, contract) {
         super(chainInterface);