@woof-software/contracts-tools-sdk-ethers 0.0.8 → 0.0.11

package/lib/contract/base-contract.d.ts

@@ -14,6 +14,7 @@ export declare class BaseContract {
     get signer(): Signer | null;
     get interface(): Interface;
     call<T>(method: string, args?: any[], options?: ContractCallOptions): Promise<Awaited<T>>;
+    estimate(method: string, args?: any[], options?: ContractCallOptions): Promise<bigint>;
     getCall(methodName: string, args?: any[], callData?: {}): ContractCall;
     listenEvent(eventName: string, listener: Listener): Promise<EthersContract>;
     getLogs(fromBlock: number, eventsNames?: string[], toBlock?: number, options?: ContractGetLogsOptions): Promise<LogDescription[]>;

package/lib/contract/base-contract.js

@@ -1,9 +1,9 @@
-import { Contract as EthersContract, Wallet, WebSocketProvider, } from "ethers";
+import { Contract as EthersContract, WebSocketProvider, } from "ethers";
 import { config } from "../config.js";
 import { CONTRACTS_ERRORS } from "../errors/index.js";
-import { isSigner, isStaticMethod } from "../helpers/index.js";
+import { isSigner, isStaticMethod, priorityCall, priorityCallEstimate, } from "../helpers/index.js";
 import { CallMutability, } from "../types/index.js";
-import { checkSignals, createTimeoutSignal, priorityCall, raceWithSignals, waitWithSignals, } from "../utils/index.js";
+import { checkSignals, createTimeoutSignal, raceWithSignals, waitWithSignals, } from "../utils/index.js";
 import { contractCreateCallName } from "./contract-create-call-name.js";
 export class BaseContract {
     static createAutoClass(abi, address, driver, options) {
@@ -43,7 +43,7 @@ export class BaseContract {
         this.address = address;
         this.driver = driver;
         this.isCallable = !!address && !!driver;
-        this.isReadonly = !this.isCallable || !(driver instanceof Wallet);
+        this.isReadonly = !this.isCallable || !isSigner(driver);
         this.contract = new EthersContract(address, abi, driver);
         this.contractOptions = {
             staticCallsTimeoutMs: config.contract.staticCalls.timeoutMs,
@@ -107,6 +107,42 @@ export class BaseContract {
             return tx;
         }
     }
+    async estimate(method, args = [], options = {}) {
+        if (!this.isCallable)
+            throw CONTRACTS_ERRORS.NON_CALLABLE_CONTRACT_INVOCATION;
+        const methodFn = this.contract[method];
+        if (!methodFn)
+            throw CONTRACTS_ERRORS.METHOD_NOT_DEFINED(method);
+        const functionFragment = this.contract.interface.getFunction(method);
+        if (!functionFragment)
+            throw CONTRACTS_ERRORS.FRAGMENT_NOT_DEFINED(method);
+        if (isStaticMethod(functionFragment.stateMutability))
+            throw CONTRACTS_ERRORS.ESTIMATE_STATIC_CALL(method);
+        const callOptions = {
+            highPriorityTx: this.contractOptions.highPriorityTxs,
+            priorityOptions: this.contractOptions.priorityOptions,
+            ...options,
+        };
+        const localSignals = [];
+        if (callOptions.signals)
+            localSignals.push(...callOptions.signals);
+        if (callOptions.timeoutMs)
+            localSignals.push(this.getTimeoutSignal(false, callOptions.timeoutMs));
+        if (this.isReadonly)
+            throw CONTRACTS_ERRORS.READ_ONLY_CONTRACT_MUTATION;
+        let estimate;
+        if (callOptions.highPriorityTx) {
+            const provider = this.driver?.provider;
+            estimate = await raceWithSignals(() => priorityCallEstimate(provider, this.driver, this.contract, method, args, {
+                signals: localSignals,
+                ...options.priorityOptions,
+            }), localSignals);
+        }
+        else {
+            estimate = await raceWithSignals(() => this.contract[method].estimateGas(...args), localSignals);
+        }
+        return estimate;
+    }
     getCall(methodName, args = [], callData = {}) {
         if (!this.address)
             throw CONTRACTS_ERRORS.NON_CALLABLE_CONTRACT_INVOCATION;

package/lib/errors/contracts-errors.d.ts

@@ -6,4 +6,5 @@ export declare const CONTRACTS_ERRORS: {
     FRAGMENT_NOT_DEFINED: (methodName: any) => Error;
     MISSING_WEBSOCKET_PROVIDER: Error;
     MISSING_PROVIDER: Error;
+    ESTIMATE_STATIC_CALL: (methodName: any) => Error;
 };

package/lib/errors/contracts-errors.js

@@ -6,4 +6,5 @@ export const CONTRACTS_ERRORS = {
     FRAGMENT_NOT_DEFINED: (methodName) => new Error(`Fragment for method "${methodName}" was not found on the contract!`),
     MISSING_WEBSOCKET_PROVIDER: new Error("Attempted to listen for contract events, but no WebSocketProvider was provided!"),
     MISSING_PROVIDER: new Error("A provider is required, but none was provided!"),
+    ESTIMATE_STATIC_CALL: (methodName) => new Error(`Cannot estimate gas for static (view/pure) method "${methodName}"!`),
 };

package/lib/helpers/is-signer.d.ts

@@ -1,2 +1,2 @@
-import type { Signer } from "ethers";
-export declare const isSigner: (driver: Signer) => boolean;
+import type { Provider, Signer } from "ethers";
+export declare const isSigner: (driver: Signer | Provider) => boolean;

package/lib/helpers/is-signer.js

@@ -1,3 +1,4 @@
 export const isSigner = (driver) => {
-    return typeof driver?.getAddress === "function";
+    // @ts-ignore
+    return typeof driver.getAddress === "function";
 };

package/lib/helpers/priority-call.d.ts

@@ -1,5 +1,4 @@
-import type { Contract, Provider, TransactionRequest } from "ethers";
+import type { Contract, Provider, Signer } from "ethers";
 import type { PriorityCallOptions } from "../types";
-export declare function priorityCall(provider: Provider, signer: {
-    sendTransaction: (txn: TransactionRequest) => Promise<any>;
-}, contract: Contract, method: string, args?: any[], options?: PriorityCallOptions): Promise<any>;
+export declare function priorityCall(provider: Provider, signer: Signer, contract: Contract, method: string, args?: any[], options?: PriorityCallOptions): Promise<any>;
+export declare function priorityCallEstimate(provider: Provider, signer: Signer, contract: Contract, method: string, args?: any[], options?: PriorityCallOptions): Promise<bigint>;

package/lib/helpers/priority-call.js

@@ -1,8 +1,16 @@
-import { DEFAULT_PRIORITY_CALL_MULTIPLIER } from "../constant.js";
+import { config } from "../config.js";
 import { checkSignals, createTimeoutSignal } from "../utils/index.js";
 export async function priorityCall(provider, signer, contract, method, args = [], options = {}) {
+    const txn = await formTx(provider, signer, contract, method, args, options);
+    return signer.sendTransaction(txn);
+}
+export async function priorityCallEstimate(provider, signer, contract, method, args = [], options = {}) {
+    const txn = await formTx(provider, signer, contract, method, args, options);
+    return signer.estimateGas(txn);
+}
+async function formTx(provider, signer, contract, method, args = [], options = {}) {
     const localOptions = {
-        multiplier: DEFAULT_PRIORITY_CALL_MULTIPLIER,
+        multiplier: config.priorityCalls.multiplier,
         ...options,
     };
     const localSignals = [];
@@ -16,9 +24,7 @@ export async function priorityCall(provider, signer, contract, method, args = []
     const maxPriorityFeePerGas = Math.ceil(localOptions.multiplier * Number(originalFeeData.maxPriorityFeePerGas));
     const gasLimit = Math.ceil(localOptions.multiplier * Number(originalGasLimit));
     checkSignals(localSignals);
-    const txn = await contract
-        .getFunction(method)
-        .populateTransaction(...args, {
+    const txn = await contract.getFunction(method).populateTransaction(...args, {
         gasLimit,
         maxFeePerGas,
         maxPriorityFeePerGas,
@@ -31,11 +37,11 @@ export async function priorityCall(provider, signer, contract, method, args = []
         const network = await provider.getNetwork();
         txn.chainId = network.chainId;
     }
-    else if (localOptions.chainId) {
-        txn.chainId = localOptions.chainId;
+    else {
+        if (localOptions.chainId)
+            txn.chainId = localOptions.chainId;
     }
-    checkSignals(localSignals);
-    return signer.sendTransaction(txn);
+    return txn;
 }
 async function gatherOriginalData(provider, contract, method, args = [], asynchronous, signals) {
     let originalFeeData;

package/lib/multicall/multicall-unit.d.ts

@@ -30,8 +30,11 @@ export declare class MulticallUnit extends BaseContract {
     getArray<T>(tags: MulticallTags, deep?: boolean): T | null;
     getArrayOrThrow<T>(tags: MulticallTags, deep?: boolean): T;
     run(options?: Partial<MulticallOptions>): Promise<boolean>;
+    estimateRun(options?: MulticallOptions): Promise<bigint[]>;
+    private splitCalls;
     private processStaticCalls;
     private processMutableCalls;
+    private estimateMutableCallsBatch;
     private saveResponse;
     getOrThrow<T>(tags: MulticallTags, deep?: boolean): T;
     get<T>(tags: MulticallTags, deep?: boolean): T | null;

package/lib/multicall/multicall-unit.js

@@ -119,35 +119,7 @@ export class MulticallUnit extends BaseContract {
         this._response = Array(tags.length).fill([undefined, null]);
         try {
             checkSignals(runOptions.signals);
-            let staticCalls;
-            let staticIndexes;
-            let mutableCalls;
-            let mutableTags;
-            let mutableIndexes;
-            if (runOptions.forceMutability) {
-                if (runOptions.forceMutability === CallMutability.Static) {
-                    staticCalls = calls;
-                    staticIndexes = Array.from({ length: calls.length }, (_, i) => i);
-                    mutableCalls = [];
-                    mutableTags = [];
-                    mutableIndexes = [];
-                }
-                else {
-                    staticCalls = [];
-                    staticIndexes = [];
-                    mutableCalls = calls;
-                    mutableTags = tags;
-                    mutableIndexes = Array.from({ length: calls.length }, (_, i) => i);
-                }
-            }
-            else {
-                const split = multicallSplitCalls(calls, tags);
-                staticCalls = split.staticCalls;
-                staticIndexes = split.staticIndexes;
-                mutableCalls = split.mutableCalls;
-                mutableTags = split.mutableTags;
-                mutableIndexes = split.mutableIndexes;
-            }
+            const { staticCalls, staticIndexes, mutableCalls, mutableTags, mutableIndexes, } = this.splitCalls(calls, tags, options.forceMutability);
             // Process mutable
             for (let i = 0; i < mutableCalls.length; i += runOptions.maxMutableCallsStack) {
                 checkSignals(runOptions.signals);
@@ -180,6 +152,65 @@ export class MulticallUnit extends BaseContract {
         }
         return this._lastSuccess ?? false;
     }
+    async estimateRun(options = {}) {
+        const runOptions = {
+            ...this._multicallOptions,
+            ...options,
+        };
+        const tags = this.tags;
+        const calls = this.calls;
+        checkSignals(runOptions.signals);
+        const { mutableCalls, mutableTags } = this.splitCalls(calls, tags, options.forceMutability);
+        const estimates = [];
+        // Process mutable
+        for (let i = 0; i < mutableCalls.length; i += runOptions.maxMutableCallsStack) {
+            checkSignals(runOptions.signals);
+            const border = Math.min(i + runOptions.maxMutableCallsStack, mutableCalls.length);
+            const iterationCalls = mutableCalls.slice(i, border); // half-opened interval
+            const iterationTags = mutableTags.slice(i, border);
+            const estimation = await this.estimateMutableCallsBatch(iterationCalls, iterationTags, runOptions);
+            estimates.push(estimation);
+        }
+        return estimates;
+    }
+    splitCalls(calls, tags, forceMutability) {
+        let staticCalls;
+        let staticIndexes;
+        let mutableCalls;
+        let mutableTags;
+        let mutableIndexes;
+        if (forceMutability) {
+            if (forceMutability === CallMutability.Static) {
+                staticCalls = calls;
+                staticIndexes = Array.from({ length: calls.length }, (_, i) => i);
+                mutableCalls = [];
+                mutableTags = [];
+                mutableIndexes = [];
+            }
+            else {
+                staticCalls = [];
+                staticIndexes = [];
+                mutableCalls = calls;
+                mutableTags = tags;
+                mutableIndexes = Array.from({ length: calls.length }, (_, i) => i);
+            }
+        }
+        else {
+            const split = multicallSplitCalls(calls, tags);
+            staticCalls = split.staticCalls;
+            staticIndexes = split.staticIndexes;
+            mutableCalls = split.mutableCalls;
+            mutableTags = split.mutableTags;
+            mutableIndexes = split.mutableIndexes;
+        }
+        return {
+            staticCalls,
+            staticIndexes,
+            mutableCalls,
+            mutableTags,
+            mutableIndexes,
+        };
+    }
     async processStaticCalls(iterationCalls, runOptions) {
         const result = await this.call(aggregate3, [iterationCalls], {
             forceMutability: CallMutability.Static,
@@ -217,6 +248,15 @@ export class MulticallUnit extends BaseContract {
         }
         return result;
     }
+    async estimateMutableCallsBatch(iterationCalls, iterationTags, runOptions) {
+        return this.estimate(aggregate3, [iterationCalls], {
+            forceMutability: CallMutability.Mutable,
+            highPriorityTx: runOptions.highPriorityTxs,
+            priorityOptions: runOptions.priorityOptions,
+            signals: runOptions.signals,
+            timeoutMs: runOptions.mutableCallsTimeoutMs,
+        });
+    }
     saveResponse(iterationResponse, iterationIndexes, globalTags) {
         iterationResponse.forEach((el, index) => {
             const [success, data] = el;

package/lib/utils/index.d.ts

@@ -1,6 +1,5 @@
 export * from "./create-timeout-signal";
 export * from "./race-with-signals";
 export * from "./create-signals-promise";
-export * from "../helpers/priority-call";
 export * from "./check-signals";
 export * from "./wait-with-signals";

package/lib/utils/index.js

@@ -1,6 +1,5 @@
 export * from "./create-timeout-signal.js";
 export * from "./race-with-signals.js";
 export * from "./create-signals-promise.js";
-export * from "../helpers/priority-call.js";
 export * from "./check-signals.js";
 export * from "./wait-with-signals.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@woof-software/contracts-tools-sdk-ethers",
   "description": "Module simplify smart contract interactions and multicall3 aggregation on the Ethereum blockchain and other EVM-compatible networks.",
-  "version": "0.0.8",
+  "version": "0.0.11",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/woof-compound/sandbox-sdks.git"
@@ -26,7 +26,7 @@
   },
   "devDependencies": {
     "typescript": "^5.7.2",
-    "vitest": "^3.0.5"
+    "vitest": "^3.0.6"
   },
   "publishConfig": {
     "access": "public"
@@ -34,6 +34,7 @@
   "scripts": {
     "prepublish": "$npm_execpath build",
     "build": "tsc --build tsconfig.build.json --force && node ../../scripts/compile/post-compile.js",
+    "anvil": "cp ./test/local/anvil-data ./anvil-data-tmp && anvil --state ./anvil-data-tmp --block-time 3",
     "test": "vitest run --coverage --config test/vitest-config/vitest.config.unit.ts",
     "test:unit": "vitest run --coverage --config test/vitest-config/vitest.config.unit.ts",
     "test:e2e": "vitest run --coverage --config test/vitest-config/vitest.config.e2e.ts",