Feat: Add Helpers For Batched Calls

Author: zacksfF

pkg/batching/batching.go

@@ -0,0 +1,100 @@
+package batching
+
+import (
+	"errors"
+	"fmt"
+	"math/big"
+	"strings"
+	"sync"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+)
+
+const executeBatchABIJSON = `[
+  {
+    "type": "function",
+    "name": "executeBatch",
+    "stateMutability": "payable",
+    "inputs": [
+      {
+        "name": "calls",
+        "type": "tuple[]",
+        "components": [
+          {"name": "target", "type": "address"},
+          {"name": "value", "type": "uint256"},
+          {"name": "data", "type": "bytes"}
+        ]
+      }
+    ],
+    "outputs": []
+  }
+]`
+
+type executeCall struct {
+	Target common.Address `abi:"target"`
+	Value  *big.Int       `abi:"value"`
+	Data   []byte         `abi:"data"`
+}
+
+// Call represents one low-level call executed by a batch delegate contract.
+type Call struct {
+	Target common.Address
+	Value  *big.Int
+	Data   []byte
+}
+
+var (
+	onceBatchABI sync.Once
+	batchABI     abi.ABI
+	batchABIErr  error
+)
+
+func getExecuteBatchABI() (abi.ABI, error) {
+	onceBatchABI.Do(func() {
+		batchABI, batchABIErr = abi.JSON(strings.NewReader(executeBatchABIJSON))
+	})
+	return batchABI, batchABIErr
+}
+
+// EncodeExecuteBatch encodes calldata for executeBatch((address,uint256,bytes)[] calls).
+func EncodeExecuteBatch(calls []Call) ([]byte, error) {
+	if len(calls) == 0 {
+		return nil, errors.New("calls must not be empty")
+	}
+	execCalls := make([]executeCall, len(calls))
+	for i, c := range calls {
+		value := c.Value
+		if value == nil {
+			value = big.NewInt(0)
+		}
+		execCalls[i] = executeCall{
+			Target: c.Target,
+			Value:  value,
+			Data:   c.Data,
+		}
+	}
+
+	parsedABI, err := getExecuteBatchABI()
+	if err != nil {
+		return nil, fmt.Errorf("parse executeBatch ABI: %w", err)
+	}
+	data, err := parsedABI.Pack("executeBatch", execCalls)
+	if err != nil {
+		return nil, fmt.Errorf("pack executeBatch calldata: %w", err)
+	}
+	return data, nil
+}
+
+// EncodeFunctionCall is a small helper for example programs.
+func EncodeFunctionCall(abiJSON string, method string, args ...any) ([]byte, error) {
+	parsedABI, err := abi.JSON(strings.NewReader(abiJSON))
+	if err != nil {
+		return nil, fmt.Errorf("parse ABI: %w", err)
+	}
+	out, err := parsedABI.Pack(method, args...)
+	if err != nil {
+		return nil, fmt.Errorf("pack %s: %w", method, err)
+	}
+	return out, nil
+}

pkg/batching/batching_test.go

@@ -0,0 +1,35 @@
+package batching_test
+
+import (
+	"bytes"
+	"math/big"
+	"testing"
+
+	"github.com/eipcodelab/eip7702-go/pkg/batching"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+func TestEncodeExecuteBatch(t *testing.T) {
+	calls := []batching.Call{
+		{Target: common.HexToAddress("0x0000000000000000000000000000000000000001"), Value: big.NewInt(0), Data: []byte{0x01}},
+		{Target: common.HexToAddress("0x0000000000000000000000000000000000000002"), Value: big.NewInt(1), Data: []byte{0x02}},
+	}
+	calldata, err := batching.EncodeExecuteBatch(calls)
+	if err != nil {
+		t.Fatalf("encode: %v", err)
+	}
+	if len(calldata) < 4 {
+		t.Fatal("calldata is too short")
+	}
+	methodID := crypto.Keccak256([]byte("executeBatch((address,uint256,bytes)[])"))[:4]
+	if !bytes.Equal(methodID, calldata[:4]) {
+		t.Fatalf("unexpected selector: got %x want %x", calldata[:4], methodID)
+	}
+}
+
+func TestEncodeExecuteBatchRejectsEmptyCalls(t *testing.T) {
+	if _, err := batching.EncodeExecuteBatch(nil); err == nil {
+		t.Fatal("expected error for empty call list")
+	}
+}