dequanto 0.2.37 → 0.2.40

package/lib/types/class/PackedRanges.d.ts

@@ -1,7 +1,7 @@
 /**
  * Defines a RANGE: [FROM_NUMBER, TO_NUMBER | Infinity)
  *
- * - Walking/Iterating/Visiting through the range marks the visited number as ADD.
+ * - Walking/Iterating/Visiting through the range marks the visited number as ADD
  *
  * - Possible to ADD the number manually, for example for persistence/restore properties
  *
@@ -20,16 +20,16 @@ export declare class PackedRanges {
     total(): number;
     totalAdded(): number;
     /**
-     * Calculates the number of elements remaining to be visited/added in the range.
-     * This is the difference between the total capacity and the number of elements already tracked.
+     * Calculates the number of elements remaining to be visited/added in the range
+     * This is the difference between the total capacity and the number of elements already tracked
      */
     totalLeft(): number;
     /**
-     * Gets the next unvisited number in the range and marks it as visited.
+     * Gets the next unvisited number in the range and marks it as visited
      *
      * This method finds the next number that hasn't been added to the tracked ranges yet,
      * automatically adds it to the ranges, and returns it. It respects the boundaries
-     * defined by `from` and `to` properties.
+     * defined by `from` and `to` properties
      *
      * The method works by:
      * - Starting from `this.from` if no ranges exist
@@ -42,27 +42,27 @@ export declare class PackedRanges {
      */
     next(): number;
     /**
-     * Gets the maximum (upper bound) value from all tracked ranges.
+     * Gets the maximum (upper bound) value from all tracked ranges
      *
-     * This method returns the highest number that has been visited/added to the ranges.
-     * It retrieves the upper bound of the last range in the sorted ranges array.
+     * This method returns the highest number that has been visited/added to the ranges
+     * It retrieves the upper bound of the last range in the sorted ranges array
      *
      * @returns The maximum value in the tracked ranges, or `null` if no ranges have been added yet
      */
     getMax(): number;
     /**
-     * Checks if a specific number has been visited/added to the tracked ranges.
+     * Checks if a specific number has been visited/added to the tracked ranges
      *
      * This method searches through all tracked ranges to determine if the given number
      * falls within any of them. It performs a linear search through the ranges array,
-     * checking if the number is within the bounds (inclusive) of any range.
+     * checking if the number is within the bounds (inclusive) of any range
      *
      * @param nr - The number to check for inclusion in the tracked ranges
      * @returns `true` if the number exists within any of the tracked ranges, `false` otherwise
      */
     includes(nr: number): boolean;
     /**
-     * Adds a number to the tracked ranges, marking it as visited.
+     * Adds a number to the tracked ranges, marking it as visited
      *
      * This method intelligently adds a number to the ranges by either:
      * - Extending an existing range if the number is adjacent to it
@@ -70,7 +70,7 @@ export declare class PackedRanges {
      * - Doing nothing if the number is already included in an existing range
      *
      * The method maintains the sorted order of ranges and automatically merges
-     * adjacent numbers into contiguous ranges for efficient storage.
+     * adjacent numbers into contiguous ranges for efficient storage
      *
      * @param nr - The number to add to the tracked ranges
      * @returns `true` if the number was successfully added (new or extended a range),
@@ -78,22 +78,22 @@ export declare class PackedRanges {
      */
     add(nr: number): boolean;
     /**
-     * Adds a complete range to the tracked ranges and compacts the result.
+     * Adds a complete range to the tracked ranges and compacts the result
      *
      * This method adds an entire range [min, max] to the tracked ranges array,
      * then automatically compacts the ranges to merge any overlapping or adjacent
      * ranges. This is useful for bulk operations where you want to mark multiple
-     * consecutive numbers as visited at once.
+     * consecutive numbers as visited at once
      *
      * Unlike the `add()` method which adds individual numbers, this method adds
      * a complete range tuple and ensures the internal ranges array remains optimized
-     * by calling `compact()` after insertion.
+     * by calling `compact()` after insertion
      *
      * @param range - A tuple [min, max] representing the range to add, where both bounds are inclusive
      */
     addRange(range: [number, number]): void;
     /**
-     * Removes a specific number from the tracked ranges, marking it as unvisited.
+     * Removes a specific number from the tracked ranges, marking it as unvisited
      *
      * This method searches for the number within the tracked ranges and removes it by either:
      * - Removing the entire range if it contains only the target number
@@ -102,7 +102,7 @@ export declare class PackedRanges {
      * - Splitting the range into two separate ranges if the number is in the middle
      *
      * The method maintains the sorted order of ranges and ensures efficient storage
-     * by handling all edge cases appropriately.
+     * by handling all edge cases appropriately
      *
      * @param nr - The number to remove from the tracked ranges
      * @returns `true` if the number was found and successfully removed from the ranges,
@@ -110,36 +110,36 @@ export declare class PackedRanges {
      */
     remove(nr: number): boolean;
     /**
-     * Removes a range of numbers from the tracked ranges, marking them as unvisited.
+     * Removes a range of numbers from the tracked ranges, marking them as unvisited
      *
      * This method subtracts the specified range from all tracked ranges, effectively
      * removing all numbers within the given range from the visited/added set. It handles
-     * overlapping ranges by splitting or trimming existing ranges as needed.
+     * overlapping ranges by splitting or trimming existing ranges as needed
      *
      * The method maintains the sorted order of ranges and ensures efficient storage
-     * by delegating to the `Ranges.subtract()` utility function.
+     * by delegating to the `Ranges.subtract()` utility function
      *
      * @param range - A tuple [min, max] representing the range to remove, where both bounds are inclusive
      * @returns The current `PackedRanges` instance for method chaining
      */
     subtractRange(range: [number, number]): this;
     /**
-     * Removes multiple ranges of numbers from the tracked ranges, marking them as unvisited.
+     * Removes multiple ranges of numbers from the tracked ranges, marking them as unvisited
      *
      * This method subtracts all specified ranges from the tracked ranges, effectively
      * removing all numbers within the given ranges from the visited/added set. It handles
      * overlapping ranges by splitting or trimming existing ranges as needed for each
-     * range in the input array.
+     * range in the input array
      *
      * The method maintains the sorted order of ranges and ensures efficient storage
-     * by delegating to the `Ranges.subtractMany()` utility function.
+     * by delegating to the `Ranges.subtractMany()` utility function
      *
      * @param ranges - An array of tuples [min, max] representing the ranges to remove, where both bounds are inclusive
      * @returns The current `PackedRanges` instance for method chaining
      */
     subtractRanges(ranges: [number, number][]): this;
     /**
-     * Compacts the tracked ranges by merging overlapping and adjacent ranges.
+     * Compacts the tracked ranges by merging overlapping and adjacent ranges
      *
      * This method optimizes the internal ranges array by:
      * - Merging overlapping ranges into single contiguous ranges
@@ -148,67 +148,67 @@ export declare class PackedRanges {
      * - Removing redundant range entries
      *
      * This operation is useful after bulk modifications to ensure the ranges
-     * array remains in its most efficient form for storage and querying.
+     * array remains in its most efficient form for storage and querying
      */
     compact(): void;
     /**
-     * Sets the tracked ranges to a new array of ranges and compacts them.
+     * Sets the tracked ranges to a new array of ranges and compacts them
      *
      * This method replaces the entire internal ranges array with the provided ranges,
-     * then automatically compacts them to merge any overlapping or adjacent ranges.
-     * This is useful for bulk initialization or restoration of ranges from a saved state.
+     * then automatically compacts them to merge any overlapping or adjacent ranges
+     * This is useful for bulk initialization or restoration of ranges from a saved state
      *
      * After setting the ranges, the method ensures the internal ranges array is optimized
-     * by calling `compact()`, which merges overlapping ranges and joins adjacent ones.
+     * by calling `compact()`, which merges overlapping ranges and joins adjacent ones
      *
      * @param ranges - An array of tuples [min, max] representing the ranges to set, where both bounds are inclusive
      */
     set(ranges: [number, number][]): void;
     /**
-     * Serializes the tracked ranges to a JSON string representation.
+     * Serializes the tracked ranges to a JSON string representation
      *
      * This method converts the internal ranges array into a JSON string format,
-     * which can be used for persistence, transmission, or storage purposes.
+     * which can be used for persistence, transmission, or storage purposes
      * The serialized string can later be parsed and used to restore the ranges
-     * via the constructor's `ranges` option.
+     * via the constructor's `ranges` option
      *
      * @returns A JSON string representation of the tracked ranges array
      */
     serialize(): string;
     /**
-     * Creates a new PackedRanges instance containing only the ranges starting from a specified number.
+     * Creates a new PackedRanges instance containing only the ranges starting from a specified number
      *
      * This method filters the tracked ranges to include only those that contain or come after
      * the specified `from` value. If a range overlaps with the `from` value, it is trimmed
-     * to start at `from`. All ranges before `from` are excluded from the result.
+     * to start at `from`. All ranges before `from` are excluded from the result
      *
      * The original PackedRanges instance remains unchanged; a new instance is returned with
-     * the filtered ranges.
+     * the filtered ranges
      *
      * @param from - The starting number from which to pick ranges (inclusive)
      * @returns A new PackedRanges instance containing only the ranges from the specified number onwards
      */
     pickFrom(from: number): PackedRanges;
     /**
-     * Creates a new PackedRanges instance containing only the ranges up to a specified number.
+     * Creates a new PackedRanges instance containing only the ranges up to a specified number
      *
      * This method filters the tracked ranges to include only those that contain or come before
      * the specified `to` value. If a range overlaps with the `to` value, it is trimmed
-     * to end at `to`. All ranges after `to` are excluded from the result.
+     * to end at `to`. All ranges after `to` are excluded from the result
      *
      * The original PackedRanges instance remains unchanged; a new instance is returned with
-     * the filtered ranges.
+     * the filtered ranges
      *
      * @param to - The ending number up to which to pick ranges (inclusive)
      * @returns A new PackedRanges instance containing only the ranges up to the specified number
      */
     pickTo(to: number): PackedRanges;
     /**
-     * Computes the intersection of multiple range arrays, returning only the ranges that are common to all inputs.
+     * Computes the intersection of multiple range arrays, returning only the ranges that are common to all inputs
      *
      * This method performs a set intersection operation across multiple arrays of ranges,
      * finding only those number ranges that appear in every input array. The result is
-     * compacted to merge any overlapping or adjacent ranges for efficient storage.
+     * compacted to merge any overlapping or adjacent ranges for efficient storage
      *
      * For example:
      * - Input: [[[1,5], [10,15]], [[3,7], [12,20]]]
@@ -219,11 +219,11 @@ export declare class PackedRanges {
      */
     static intersection(rangesArr: ([number, number][])[]): [number, number][];
     /**
-     * Computes the union of multiple range arrays, returning all ranges that appear in any of the inputs.
+     * Computes the union of multiple range arrays, returning all ranges that appear in any of the inputs
      *
      * This method performs a set union operation across multiple arrays of ranges,
      * combining all number ranges from every input array. The result is compacted to
-     * merge any overlapping or adjacent ranges for efficient storage.
+     * merge any overlapping or adjacent ranges for efficient storage
      *
      * For example:
      * - Input: [[[1,5], [10,15]], [[3,7], [12,20]]]
@@ -234,12 +234,12 @@ export declare class PackedRanges {
      */
     static union(rangesArr: ([number, number][])[]): [number, number][];
     /**
-     * Computes the difference between two range arrays, removing all ranges in B from ranges in A.
+     * Computes the difference between two range arrays, removing all ranges in B from ranges in A
      *
      * This method performs a set difference operation (A − B), subtracting all number ranges
      * in `rangesB` from `rangesA`. The result contains only those portions of `rangesA` that
      * do not overlap with any range in `rangesB`. The result is compacted to merge any
-     * overlapping or adjacent ranges for efficient storage.
+     * overlapping or adjacent ranges for efficient storage
      *
      * For example:
      * - Input: rangesA = [[1,10], [20,30]], rangesB = [[5,15], [25,35]]

package/lib/types/clients/ClientPool.d.ts

@@ -14,15 +14,15 @@ import { DataLike } from '../utils/types';
 export interface IRpcConfig {
     url?: string;
     options?: TTransport.Options.Http | TTransport.Options.Ws;
-    /** Will be a preferred node for submitting transactions */
+    /** Preferred node for submitting transactions */
     safe?: boolean;
     distinct?: boolean;
     wallet?: boolean;
     web3?: TTransport.Transport | Promise<TTransport.Transport>;
     name?: string;
-    /** Will be used only if manually requested with .getWeb3, or .getNodeUrl */
+    /** Used only when manually requested with .getWeb3 or .getNodeUrl */
     manual?: boolean;
-    /** max block range per request when getting for example the past logs*/
+    /** Max block range per request, for example when fetching past logs */
     fetchableBlockRange?: number;
     /** True if the node supports traceTransaction calls */
     traceable?: boolean;
@@ -37,7 +37,7 @@ export interface IRpcConfig {
 export interface IPoolWeb3Request {
     ws?: boolean;
     preferSafe?: boolean;
-    /** Request wallet node to submit unsigned transactions */
+    /** Request a wallet node to submit unsigned transactions */
     wallet?: boolean;
     distinct?: boolean;
     name?: string;
@@ -49,7 +49,7 @@ export interface IPoolWeb3Request {
         /** Supports traceTransaction */
         traceable?: boolean;
     };
-    /** RPC method - will find the node that has the configuration */
+    /** RPC method; finds the node that has the configuration */
     method?: string;
     batchRequestCount?: number;
     blockRangeCount?: number;
@@ -93,10 +93,10 @@ export declare class ClientPool {
     private next;
     private getClientWithLowestWaitTime;
     /**
-     * We may have tens of Nodes to communicate with. Discover LIVE and operating nodes.
-     * Resolves when first 3 active nodes are discovered, to prevent waiting for all of them.
+     * We may have tens of nodes to communicate with. Discover live and operating nodes
+     * Resolves when the first 3 active nodes are discovered to avoid waiting for all of them
      * @returns
-     * - Ready Promise - in case 3 clients look good
+     * - Ready Promise - when 3 clients look good
      * - Complete Promise - when all clients are resolved
      */
     private discoverLive;
@@ -113,7 +113,7 @@ export declare class WClient {
     rpc: Rpc;
     config: IRpcConfig;
     rateLimitGuard: RateLimitGuard;
-    /** For getLogs method, as some providers limit the range request or page result value */
+    /** For the getLogs method, as some providers limit the range request or paged result size */
     blockRangeLimits: {
         blocks?: number;
         results?: number;
@@ -149,7 +149,7 @@ export declare class WClient {
     ensureConnected(): Promise<Error>;
     getRequestCount(): number;
     /**
-     * Checks the rate limit wait time, so that the POOL can select the wClient with shortest wait time
+     * Checks the rate limit wait time so the pool can select the wClient with the shortest wait time
      **/
     getRateLimitGuardTime(): number;
     private getSpanLimit;

package/lib/types/clients/WalletClient.d.ts

@@ -3,7 +3,7 @@ import { Rpc, RpcTypes } from '../rpc/Rpc';
 import { DataLike } from '../utils/types';
 import { EIP6963ProviderDetail, EIP6963ProviderFactory } from '../wallets/EIP6963ProviderFactory';
 import { WClient } from './ClientPool';
-/** Wallet actions only. For all Node (Chain) related actions - Web3Client should be used */
+/** Wallet actions only. Use Web3Client for all node/chain-related actions */
 export declare class WalletClient {
     factory: EIP6963ProviderFactory;
     constructor(factory?: EIP6963ProviderFactory);
@@ -11,7 +11,7 @@ export declare class WalletClient {
     getProvider(uuid?: string): Promise<EIP6963ProviderDetail>;
     getProviders(): Promise<EIP6963ProviderDetail[]>;
     getAccounts(uuid?: string): Promise<TEth.Address[]>;
-    /** Find the provider by UUID or use the first one to connect to and to requestAccounts */
+    /** Finds the provider by UUID, or uses the first one to connect and request accounts */
     connect(uuid?: string): Promise<TEth.Address[]>;
     disconnect(): Promise<void>;
     isConnected(address?: TEth.Address): boolean;

package/lib/types/clients/Web3Client.d.ts

@@ -94,17 +94,17 @@ export declare abstract class Web3Client implements IWeb3Client {
     getBlockNumberCached(): Promise<number>;
     getPastLogs(filter: RpcTypes.Filter, options?: {
         /**
-         * For large block ranges and huge amounts of logs, streaming should be used, we pass the loaded logs in batches direct to onProgress
-         * and do not aggregate to a final logs array to prevent memory issues.
+         * For large block ranges and huge amounts of logs, streaming should be used. Loaded logs are passed directly to onProgress in batches
+         * and do not aggregate to a final logs array to prevent memory issues
          */
         streamed?: boolean;
         /**
-         * Override the default block range limits for all underlying RPC clients, otherwise the config will be used or
-         * the RPC exception will be parsed.
+         * Overrides the default block range limits for all underlying RPC clients. Otherwise, the config will be used or
+         * the RPC exception will be parsed
          */
         blockRangeLimits?: WClient['blockRangeLimits'];
         /**
-         * When loading in batches the cb will be called with fetched and parsed logs on each iteration
+         * When loading in batches, the callback will be called with fetched and parsed logs on each iteration
          */
         onProgress?(info: TLogsRangeProgress<TEth.Log>): void;
     }): Promise<TEth.Log[]>;
@@ -124,7 +124,7 @@ export declare abstract class Web3Client implements IWeb3Client {
 }
 export type TLogsRangeProgress<TLogParsed> = {
     logs: TLogParsed[];
-    /** @deprecated Use logs for current logs buffer */
+    /** @deprecated Use logs for the current logs buffer */
     paged: TLogParsed[];
     latestBlock: number;
     blocks: {

package/lib/types/clients/Web3ClientFactory.d.ts

@@ -3,6 +3,6 @@ import { IWeb3EndpointOptions } from './interfaces/IWeb3EndpointOptions';
 import { EvmWeb3Client } from './EvmWeb3Client';
 export declare namespace Web3ClientFactory {
     function get(platform: TPlatform | number, opts?: IWeb3EndpointOptions): import("../hardhat/HardhatWeb3Client").HardhatWeb3Client | EvmWeb3Client;
-    /** Same as sync variation, but ensures the config is being fetched */
+    /** Same as the sync variant, but ensures the config is fetched */
     function getAsync(platform: TPlatform | string | number, opts?: IWeb3EndpointOptions): Promise<import("../hardhat/HardhatWeb3Client").HardhatWeb3Client | EvmWeb3Client>;
 }

package/lib/types/clients/handlers/RateLimitGuard.d.ts

@@ -45,9 +45,9 @@ export declare class RateLimitGuard {
     private onThrottle;
 }
 /**
- * In short epoch rate limiter (1s, 1m, 1h) we track each request
+ * In the short-epoch rate limiter (1s, 1m, 1h), we track each request
  *
- * sliding(rolling) window | fixed window
+ * sliding (rolling) window | fixed window
  */
 declare class ShortEpochRateLimitData {
     spanMs: number;
@@ -69,9 +69,9 @@ declare class ShortEpochRateLimitData {
     printStatus(): void;
     addRequests(amount: number, time: number): void;
     /**
-     * The server has own request time, with `addTicks` we save the time BEFORE sending to the server
-     * Here we should update the times AFTER the response received,
-     * otherwise the Request could be removed locally from TimeWindow earlier, as it has been cleared on the backend.
+     * The server has its own request time. With `addTicks`, we save the time BEFORE sending to the server
+     * Here we should update the times AFTER the response is received,
+     * otherwise the request could be removed locally from TimeWindow earlier than it is cleared on the backend
      */
     updateRequests(tick: number, newTick: number): void;
     getWaitTimeFor(ticksCount: number): number;

package/lib/types/clients/model/PromiEventWrap.d.ts

@@ -6,7 +6,7 @@ export declare class PromiseEventWrap extends class_Dfr {
     on(event: any, cb: any): this;
     once(event: any, cb: any): this;
     emit(event: any, ...args: any[]): void;
-    /** Attach this wrapper to the promiseEvent */
+    /** Attaches this wrapper to the promiseEvent */
     bind(promiseEvent: PromiseEvent<any>): void;
     private bindOn;
     private bindOnOnce;

package/lib/types/clients/utils/$web3Abi.d.ts

@@ -1,6 +1,6 @@
 import type { TAbiItem } from '../../types/TAbi';
 export declare namespace $web3Abi {
-    /** Normalize user input by normalizing to the array of TAbiItems */
+    /** Normalizes user input into an array of TAbiItems */
     function ensureAbis(abi: string | TAbiItem | TAbiItem[]): (TAbiItem & {
         signature?: any;
     })[];

package/lib/types/clients/utils/ClientErrorUtil.d.ts

@@ -10,4 +10,5 @@ export declare namespace ClientErrorUtil {
     function IsInsufficientFunds(error: Error): boolean;
     function IsNonceTooLow(error: Error): boolean;
     function IsNonceTooHigh(error: Error): boolean;
+    function IsUnderpriced(error: Error): boolean;
 }

package/lib/types/config/Config.d.ts

@@ -1,9 +1,10 @@
+import type { Config as Appcfg } from 'appcfg/Config';
 import { TConfigParamsBrowser, TConfigParamsNode } from './AConfigBase';
 import { IConfigData } from './interface/IConfigData';
 export declare class Config {
-    static fetch(parameters?: TConfigParamsNode | TConfigParamsBrowser): Promise<import("appcfg/Config").Config<any> & IConfigData>;
+    static fetch(parameters?: TConfigParamsNode | TConfigParamsBrowser): Promise<Appcfg<IConfigData> & IConfigData>;
     /** Will return a config that was previously loaded by fetch with any parameters or will trigger fetch with default parameters  */
-    static get(): Promise<IConfigData>;
+    static get(): Promise<Appcfg<IConfigData> & IConfigData>;
     static extend(json: any): Promise<void>;
 }
 export declare const config: IConfigData;

package/lib/types/contracts/ContractBase.d.ts

@@ -20,7 +20,7 @@ export declare abstract class ContractBase {
     explorer: IBlockchainExplorer;
     private blockNumber?;
     private blockDate?;
-    /** 1.4 for medium*/
+    /** 1.4 for medium */
     private gasPriorityFee?;
     protected builderConfig?: ITxBuilderOptions;
     protected writerConfig?: ITxWriterOptions;
@@ -98,9 +98,9 @@ export declare abstract class ContractBase {
             [key: string]: any;
         };
         onProgress?(info: TLogsRangeProgress<ITxLogItem>): any;
-        /** if TRUE the data will be only forwarded via onProgress callback.
-         * And the final array will be undefined.
-         * This will handle big queries to hold huge arrays in memory
+        /** If TRUE, data will only be forwarded via the onProgress callback.
+         * The final array will be undefined.
+         * This handles large queries without holding huge arrays in memory.
          * */
         streamed?: boolean;
         blockRangeLimits?: WClient['blockRangeLimits'];

package/lib/types/contracts/ContractReader.d.ts

@@ -37,10 +37,10 @@ export declare class ContractReader implements IContractReader {
         onProgress?(info: TLogsRangeProgress<TEth.Log>): any;
     }): Promise<TEth.Log[]>;
     getLogsFilter(abi: TAbiItem | string | '*' | TAbiItem[], options: {
-        /** Can be UNDEFINED, then the logs will be searched globally */
+        /** Can be UNDEFINED; then the logs will be searched globally. */
         address?: TAddress | TAddress[];
         /**
-         * "deployment": get the contracts deployment date to skip lots of blocks (in case we use pagination to fetch logs)
+         * "deployment": get the contract deployment date to skip many blocks when paginating logs.
          */
         fromBlock?: number | Date | 'deployment';
         toBlock?: number | Date;

package/lib/types/contracts/ContractWriter.d.ts

@@ -18,9 +18,9 @@ export declare class ContractWriter implements IContractWriter {
     constructor(address: TAddress, client: Web3Client, builderConfig?: ITxBuilderOptions, writerConfig?: ITxWriterOptions);
     $config(builderConfig?: ITxBuilderOptions, writerConfig?: ITxWriterOptions): this;
     /**
-    * We split Tx sending in two awaitable steps
-    * 1. This method prepares(gas, nonce, etc) - and sends the Tx
-    * 2. With returned writer you can subscribe to events and/or wait for Tx to be mined
+    * We split transaction sending into two awaitable steps:
+    * 1. This method prepares gas, nonce, etc., and sends the transaction.
+    * 2. With the returned writer, you can subscribe to events and/or wait for the transaction to be mined.
     * @param account
     * @param interfaceAbi
     * @param params

package/lib/types/contracts/deploy/Deployments.d.ts

@@ -2,16 +2,17 @@ import { Web3Client } from '../../clients/Web3Client';
 import { ContractBase } from '../ContractBase';
 import { IAccount } from '../../models/TAccount';
 import { TEth } from '../../models/TEth';
-import { ParametersFromSecond } from '../../utils/types';
-import { Constructor } from '../../utils/types';
+import { Constructor, ParametersFromSecond } from '../../utils/types';
+import { TAddress } from '../../models/TAddress';
 import { IBeacon, IBeaconProxy, IProxy, IProxyAdmin } from './proxy/ProxyDeployment';
 import { DeploymentsStorage, IDeployment } from './storage/DeploymentsStorage';
-import { TAddress } from '../../models/TAddress';
 type TDeploymentOptions = {
     id?: string;
-    /** Will deploy the contract */
+    immutablesKey?: string;
+    checkImmutables?: boolean;
+    /** Deploys the contract. */
     force?: boolean;
-    /** Will check if local bytecode has changed and will deploy */
+    /** Checks whether the local bytecode has changed and deploys if needed. */
     latest?: boolean;
     verification?: boolean | 'silent';
     proxyFor?: TAddress;
@@ -76,7 +77,7 @@ export declare class Deployments {
     }): Promise<T>;
     private getOrNull;
     /**
-     * Get the deployment for Ctor, but returns the CtorWrapped instance. Useful for proxies, etc.
+     * Gets the deployment for Ctor, but returns the CtorWrapped instance. Useful for proxies, etc.
      * e.g. deployments.getAs(SomeProxy, SomeImplementation);
      */
     getAs<TDeployed extends ContractBase, TWrapped extends ContractBase>(Ctor: Constructor<TDeployed>, CtorWrapped: Constructor<TWrapped>, opts?: {
@@ -97,11 +98,7 @@ export declare class Deployments {
         receipt?: TEth.TxReceipt;
         deployment: IDeployment;
     }>;
-    ensureWithProxy<T extends (TContract & {
-        initialize?: TInit;
-    }), TInit extends TInitializer>(CtorImpl: Constructor<T>, opts?: TConstructorArgs<T> & TDeploymentOptions & {
-        initialize?: ParametersFromSecond<T['initialize']>;
-    }): Promise<{
+    ensureWithProxy<T extends TContract>(CtorImpl: Constructor<T>, opts?: TConstructorArgs<T> & TDeploymentOptions & TInitializerParams<T>): Promise<{
         contract: T;
         contractReceipt?: TEth.TxReceipt;
         contractProxy: IProxy;
@@ -110,12 +107,12 @@ export declare class Deployments {
         deployment: IDeployment;
     }>;
     /**
-     * Deploys the Beacon contract. Implementation is the target contract (can be a proxy or normal contract)
+     * Deploys the Beacon contract. The implementation is the target contract (can be a proxy or normal contract).
      * https://docs.openzeppelin.com/contracts/5.x/api/proxy#beacon
      **/
     ensureWithBeacon<T extends (TContract & {
         initialize?: TInit;
-    }), TInit extends TInitializer>(CtorImpl: Constructor<T>, opts: TConstructorArgs<T> & TDeploymentOptions & {
+    }), TInit extends TFunction>(CtorImpl: Constructor<T>, opts: TConstructorArgs<T> & TDeploymentOptions & {
         id: string;
         initialize?: ParametersFromSecond<T['initialize']>;
     }): Promise<{
@@ -132,7 +129,7 @@ export declare class Deployments {
     fixBytecodeHashesByReread(): Promise<void>;
     private getBytecodeHash;
     /**
-     * A simple method to configure the contracts state
+     * A simple method to configure contract state.
      */
     configure<T extends TContract, TValue>(Ctor: Constructor<T> | T, opts: {
         id?: string;
@@ -143,7 +140,15 @@ export declare class Deployments {
         title?: string;
     }): Promise<void>;
 }
-type TInitializer = (...args: any[]) => any;
+type TFunction = (...args: any[]) => any;
+type TInitializerName = 'initialize' | `initializeV${number}`;
+type TInitializerParams<T> = {
+    initialize?: T extends {
+        initialize: infer TInit;
+    } ? TInit extends TFunction ? ParametersFromSecond<TInit> : never : any[];
+} & {
+    [K in Extract<keyof T, TInitializerName>]?: T[K] extends TFunction ? ParametersFromSecond<T[K]> : never;
+};
 type TContract = ContractBase & {
     $constructor?: (...args: any[]) => any;
 };

package/lib/types/contracts/deploy/proxy/ProxyDeployment.d.ts

@@ -27,6 +27,8 @@ interface IDeploymentCtx {
     implementation: {
         address: TAddress;
         initData: TEth.Hex;
+        migrationData: TEth.Hex;
+        migrationV?: number;
     };
     options?: {
         skipStorageLayoutCheck?: boolean;

package/lib/types/contracts/deploy/storage/DeploymentsStorage.d.ts

@@ -8,6 +8,7 @@ import { IAccount } from '../../../models/TAccount';
 export interface IDeployment {
     id: string;
     name: string;
+    immutablesKey?: string;
     main: string;
     address: TAddress;
     implementation?: TAddress;
@@ -61,6 +62,7 @@ export declare class DeploymentsStorage {
     saveDeployment(contract: ContractBase, info: {
         id: string;
         name: string;
+        immutablesKey?: string;
         bytecodeHash?: TEth.Hex;
     }, receipt?: TEth.TxReceipt): Promise<IDeployment>;
     getStorageLayoutInfo(id: string): Promise<IProxyStorageLayout>;

package/lib/types/explorer/BlockchainExplorerFactory.d.ts

@@ -4,7 +4,7 @@ import { IBlockchainExplorerFactoryParams } from './BlockchainExplorer';
 import { TPlatform } from '../models/TPlatform';
 import { TExplorerDefinition } from '../models/TExplorer';
 /**
- * @obsolete Use BlockchainExplorer class instead.
+ * @obsolete Use BlockchainExplorer class instead
  */
 export declare namespace BlockchainExplorerFactory {
     function register(platform: TPlatform, explorer: IBlockchainExplorer | Constructor<IBlockchainExplorer>): void;

package/lib/types/explorer/Evmscan.d.ts

@@ -1,5 +1,5 @@
 import { BlockchainExplorer } from './BlockchainExplorer';
 /**
- * @obsolete Use BlockchainExplorer class instead.
+ * @obsolete Use BlockchainExplorer class instead
  */
 export declare const Evmscan: typeof BlockchainExplorer;