CGL estimate fallback to a more efficient binary search (#255)

Author: hazim-j

.github/workflows/compliance.yml

@@ -38,7 +38,14 @@ jobs:
 
       - name: Setup bundler spec test
         working-directory: ./bundler-spec-tests
-        run: pdm install && pdm run update-deps
+        run: |
+          pdm install && \
+          cd @account-abstraction && \
+          yarn install --frozen-lockfile && \
+          yarn compile && \
+          cd ../spec && \
+          yarn install --frozen-lockfile && \
+          yarn build
 
       - name: Install Geth
         run: |

e2e/config.ts

@@ -14,7 +14,7 @@ const config: IConfig = {
   bundlerUrl: "http://localhost:4337",
   testERC20Token: "0x3870419Ba2BBf0127060bCB37f69A1b1C090992B",
   // https://github.com/stackup-wallet/contracts/blob/main/contracts/test/TestGas.sol
-  testGas: "0xd98206114295d553625cFF946D8aEc3aa790db3A",
+  testGas: "0xdea3d7b717F3A6E634876092470efc281f9b3de7",
 };
 
 export default config;

e2e/src/abi.ts

@@ -168,6 +168,7 @@ export const testGasABI = [
     inputs: [
       { internalType: "uint256", name: "depth", type: "uint256" },
       { internalType: "uint256", name: "width", type: "uint256" },
+      { internalType: "uint256", name: "discount", type: "uint256" },
       { internalType: "uint256", name: "count", type: "uint256" },
     ],
     name: "recursiveCall",

e2e/test/withoutPaymaster.test.ts

@@ -143,7 +143,7 @@ describe("Without Paymaster", () => {
         acc.execute(
           config.testGas,
           0,
-          testGas.interface.encodeFunctionData("recursiveCall", [32, 0, 32])
+          testGas.interface.encodeFunctionData("recursiveCall", [32, 0, 0, 32])
         ),
         { ...opChecks(provider) }
       );
@@ -157,8 +157,8 @@ describe("Without Paymaster", () => {
       [0, 2, 4, 8, 16].forEach((depth) => {
         test(`Sender can make contract interactions with ${depth} recursive calls`, async () => {
           let opts = opChecks(provider);
-          if (depth === 8) opts = opCheckDeep(1195400);
-          if (depth === 16) opts = opCheckDeep(4364942);
+          if (depth === 8) opts = opCheckDeep(1195897);
+          if (depth === 16) opts = opCheckDeep(4365893);
 
           const response = await client.sendUserOperation(
             acc.execute(
@@ -167,6 +167,7 @@ describe("Without Paymaster", () => {
               testGas.interface.encodeFunctionData("recursiveCall", [
                 depth,
                 0,
+                0,
                 depth,
               ])
             ),
@@ -183,8 +184,8 @@ describe("Without Paymaster", () => {
       [0, 2, 4, 8, 16].forEach((depth) => {
         test(`Sender can make contract interactions with ${depth} recursive calls`, async () => {
           let opts = opChecks(provider);
-          if (depth === 8) opts = opCheckDeep(1261728);
-          if (depth === 16) opts = opCheckDeep(4498665);
+          if (depth === 8) opts = opCheckDeep(1262227);
+          if (depth === 16) opts = opCheckDeep(4499616);
 
           const response = await client.sendUserOperation(
             acc.execute(
@@ -193,6 +194,7 @@ describe("Without Paymaster", () => {
               testGas.interface.encodeFunctionData("recursiveCall", [
                 depth,
                 0,
+                0,
                 depth,
               ])
             ),
@@ -205,12 +207,36 @@ describe("Without Paymaster", () => {
       });
     });
 
+    describe("With gas discount", () => {
+      const depth = 3;
+      [15000, 20000, 25000, 30000, 35000].forEach((discount) => {
+        test(`Sender can make contract interactions with ${discount} gas discount to recursive calls`, async () => {
+          const response = await client.sendUserOperation(
+            acc.execute(
+              config.testGas,
+              0,
+              testGas.interface.encodeFunctionData("recursiveCall", [
+                depth,
+                0,
+                discount,
+                depth,
+              ])
+            ),
+            opChecks(provider)
+          );
+          const event = await response.wait();
+
+          expect(event?.args.success).toBe(true);
+        });
+      });
+    });
+
     describe("With multiple stacks per depth", () => {
       [0, 1, 2, 3].forEach((depth) => {
         test(`Sender can make contract interactions with ${depth} recursive calls`, async () => {
           let opts = opChecks(provider);
-          if (depth === 2) opts = opCheckDeep(865684);
-          if (depth === 3) opts = opCheckDeep(7925084);
+          if (depth === 2) opts = opCheckDeep(866332);
+          if (depth === 3) opts = opCheckDeep(7929055);
 
           const width = depth;
           const response = await client.sendUserOperation(
@@ -220,6 +246,7 @@ describe("Without Paymaster", () => {
               testGas.interface.encodeFunctionData("recursiveCall", [
                 depth,
                 width,
+                0,
                 depth,
               ])
             ),

pkg/gas/estimate.go

@@ -12,6 +12,10 @@ import (
 	"github.com/stackup-wallet/stackup-bundler/pkg/userop"
 )
 
+var (
+	fallBackBinarySearchCutoff = int64(30000)
+)
+
 func isPrefundNotPaid(err error) bool {
 	return strings.HasPrefix(err.Error(), "AA21") || strings.HasPrefix(err.Error(), "AA31")
 }
@@ -24,6 +28,10 @@ func isExecutionOOG(err error) bool {
 	return strings.Contains(err.Error(), "execution OOG")
 }
 
+func isExecutionReverted(err error) bool {
+	return strings.Contains(err.Error(), "execution reverted")
+}
+
 type EstimateInput struct {
 	Rpc         *rpc.Client
 	EntryPoint  common.Address
@@ -145,6 +153,49 @@ func EstimateGas(in *EstimateInput) (verificationGas uint64, callGas uint64, err
 		ChainID:    in.ChainID,
 	})
 	if err != nil {
+		// Execution is successful but one shot tracing has failed. Fallback to binary search with an
+		// efficient range. Hitting this point could mean a contract is passing manual gas limits with a
+		// static discount, e.g. sub(gas(), STATIC_DISCOUNT). This is not yet accounted for in the tracer.
+		if isExecutionOOG(err) {
+			l := cgl.Int64()
+			r := (l * 150) / 100 // Set upper bound to +50%
+			f := int64(0)
+			simErr := err
+			for r-l >= fallBackBinarySearchCutoff {
+				m := (l + r) / 2
+
+				data["callGasLimit"] = hexutil.EncodeBig(big.NewInt(int64(m)))
+				simOp, err := userop.New(data)
+				if err != nil {
+					return 0, 0, err
+				}
+				_, err = execution.TraceSimulateHandleOp(&execution.TraceInput{
+					Rpc:        in.Rpc,
+					EntryPoint: in.EntryPoint,
+					Op:         simOp,
+					ChainID:    in.ChainID,
+				})
+				simErr = err
+				if err != nil && (isExecutionOOG(err) || isExecutionReverted(err)) {
+					// CGL too low, go higher.
+					l = m + 1
+					continue
+				} else if err == nil {
+					// CGL too high, go lower.
+					r = m - 1
+					// Set final.
+					f = m
+					continue
+				} else {
+					// Unexpected error.
+					return 0, 0, err
+				}
+			}
+			if f == 0 {
+				return 0, 0, simErr
+			}
+			return simOp.VerificationGasLimit.Uint64(), big.NewInt(f).Uint64(), nil
+		}
 		return 0, 0, err
 	}
 	return simOp.VerificationGasLimit.Uint64(), simOp.CallGasLimit.Uint64(), nil