@pushchain/core 6.0.26 → 6.0.27-alpha.0

package/src/lib/vm-client/evm-client.js

@@ -205,12 +205,19 @@ class EvmClient {
         const resolveGas = async () => {
             if (explicitGas)
                 return explicitGas;
-            const estimate = () => this.publicClient.estimateGas({
-                account: signer.account.address,
-                to,
-                data,
-                value,
-            });
+            const estimate = async () => {
+                const estimatedGas = await this.publicClient.estimateGas({
+                    account: signer.account.address,
+                    to,
+                    data,
+                    value,
+                });
+                // Leave headroom for nested calls and state changes before inclusion,
+                // as on the EIP-7702 batch path. Donut can return an estimate that
+                // reverts inside an AGW -> gateway -> token call even at the same state.
+                // This is the Push execution limit, separate from destination gas.
+                return (estimatedGas * BigInt(120) + BigInt(99)) / BigInt(100);
+            };
             if (data !== '0x')
                 return estimate();
             // A plain native transfer to a code-free EOA always costs 21k. Empty
@@ -323,30 +330,37 @@ class EvmClient {
         catch (err) {
             throw new EIP7702NotSupportedError(err);
         }
-        // Estimate gas against the delegated account: override the EOA's code with
-        // the 7702 delegation designator (0xef0100 || executor) so estimation runs
-        // the executor. Fall back to a safe ceiling if the node rejects overrides.
+        // Prefer authorization-aware estimation of the actual type-4 transaction.
+        // Some RPCs reject that format or state overrides. An ordinary estimate is
+        // valid only if the account is already delegated to this exact executor.
+        // Never guess a per-call ceiling: contract deployment/grants vary in cost.
+        const delegation = ('0xef0100' + executor.slice(2));
         let gas;
         try {
             gas = await this.publicClient.estimateGas({
                 account,
                 to: account,
                 data,
-                stateOverride: [
-                    {
-                        address: account,
-                        code: ('0xef0100' + executor.slice(2)),
-                    },
-                ],
+                authorizationList: [authorization],
             });
-            gas = (gas * BigInt(120)) / BigInt(100); // headroom for delegation + auth
         }
         catch {
-            // Estimation unavailable (e.g. node rejects state overrides). Scale the
-            // ceiling with the batch size so large batches don't OOG — the legacy
-            // per-call loop budgeted ~500k gas per call; mirror that plus overhead.
-            gas = BigInt(500_000) * BigInt(calls.length) + BigInt(100_000);
+            const code = await this.publicClient.getCode({ address: account });
+            if (code?.toLowerCase() === delegation.toLowerCase()) {
+                gas = await this.publicClient.estimateGas({ account, to: account, data });
+            }
+            else {
+                gas = await this.publicClient.estimateGas({
+                    account,
+                    to: account,
+                    data,
+                    stateOverride: [{ address: account, code: delegation }],
+                });
+            }
         }
+        // The fallback estimates omit authorization processing (25k intrinsic).
+        // Include it conservatively on every path, plus 20% execution headroom.
+        gas = (gas * BigInt(120) + BigInt(99)) / BigInt(100) + BigInt(25_000);
         const unsignedTx = (0, viem_1.serializeTransaction)({
             chainId,
             type: 'eip7702',