Fine tune fallback binary search for reliability (#261)

Author: hazim-j

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: "0xdea3d7b717F3A6E634876092470efc281f9b3de7",
+  testGas: "0xc2e76Ee793a194Dd930C18c4cDeC93E7C75d567C",
 };
 
 export default config;

e2e/test/withoutPaymaster.test.ts

@@ -207,28 +207,33 @@ 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();
+    describe("With random gas discount", () => {
+      [1, 2, 3].forEach((depth) =>
+        describe(`At depth equal to ${depth}`, () => {
+          Array.from({ length: 5 }, () =>
+            Math.floor(Math.random() * 100000)
+          ).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);
-        });
-      });
+              expect(event?.args.success).toBe(true);
+            });
+          });
+        })
+      );
     });
 
     describe("With multiple stacks per depth", () => {

pkg/entrypoint/execution/trace.go

@@ -128,9 +128,18 @@ func TraceSimulateHandleOp(in *TraceInput) (*TraceOutput, error) {
 			return out, errors.NewRPCError(errors.EXECUTION_REVERTED, "execution reverted", nil)
 		}
 
-		reason, err := errors.DecodeRevert(data)
-		if err != nil {
-			return out, err
+		reason, revErr := errors.DecodeRevert(data)
+		if revErr != nil {
+			code, panErr := errors.DecodePanic(data)
+			if panErr != nil {
+				return nil, fmt.Errorf("%s, %s", revErr, panErr)
+			}
+
+			return out, errors.NewRPCError(
+				errors.EXECUTION_REVERTED,
+				fmt.Sprintf("panic encountered: %s", code),
+				code,
+			)
 		}
 		return out, errors.NewRPCError(errors.EXECUTION_REVERTED, reason, reason)
 	}

pkg/errors/panic.go

@@ -0,0 +1,35 @@
+package errors
+
+import (
+	"errors"
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+func panicError() abi.Error {
+	code, _ := abi.NewType("uint256", "uint256", nil)
+	return abi.NewError("Panic", abi.Arguments{
+		{Name: "code", Type: code},
+	})
+}
+
+func DecodePanic(data []byte) (string, error) {
+	abi := panicError()
+	panic, err := abi.Unpack(data)
+	if err != nil {
+		return "", fmt.Errorf("panic: %s", err)
+	}
+
+	args, ok := panic.([]any)
+	if !ok {
+		return "", errors.New("panic: cannot assert type: args is not of type []any")
+	}
+	if len(args) != 1 {
+		return "", fmt.Errorf("panic: invalid args length: expected 1, got %d", len(args))
+	}
+
+	return hexutil.EncodeBig(args[0].(*big.Int)), nil
+}

pkg/gas/estimate.go

@@ -156,9 +156,9 @@ func EstimateGas(in *EstimateInput) (verificationGas uint64, callGas uint64, err
 		// 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) {
+		if isExecutionOOG(err) || isExecutionReverted(err) {
 			l := cgl.Int64()
-			r := (l * 150) / 100 // Set upper bound to +50%
+			r := in.MaxGasLimit.Int64()
 			f := int64(0)
 			simErr := err
 			for r-l >= fallBackBinarySearchCutoff {
@@ -180,6 +180,9 @@ func EstimateGas(in *EstimateInput) (verificationGas uint64, callGas uint64, err
 					// CGL too low, go higher.
 					l = m + 1
 					continue
+				} else if err != nil && isPrefundNotPaid(err) {
+					// CGL too high, go lower.
+					r = m - 1
 				} else if err == nil {
 					// CGL too high, go lower.
 					r = m - 1