Metacall utility func + contracts getters

.github/workflows/ci.yml

@@ -23,17 +23,5 @@ jobs:
         if: runner.os == 'Linux'
         run: sudo apt update && sudo apt install build-essential
 
-      - uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cache/go-build
-            ~/Library/Caches/go-build
-            ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: ${{ runner.os }}-go-
-
-      - name: Build
-        run: CGO_ENABLED=0 GOOS=linux go build -o ./atlas-sdk-go
-
       - name: Test
         run: make test

core/atlas.go

@@ -0,0 +1,59 @@
+package core
+
+import (
+	"errors"
+
+	"github.com/FastLane-Labs/atlas-sdk-go/contract/atlas"
+	"github.com/FastLane-Labs/atlas-sdk-go/types"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	gethTypes "github.com/ethereum/go-ethereum/core/types"
+)
+
+func (sdk *AtlasSdk) Metacall(chainId uint64, transactOpts *bind.TransactOpts, userOp *types.UserOperation, solverOps types.SolverOperations, dAppOp *types.DAppOperation) (*gethTypes.Transaction, error) {
+	contract, ok := sdk.atlasContract[chainId]
+	if !ok {
+		return nil, errors.New("atlas contract not found")
+	}
+
+	userOp.Sanitize()
+	solverOps.Sanitize()
+	dAppOp.Sanitize()
+
+	_dAppOp := atlas.DAppOperation{
+		From:          dAppOp.From,
+		To:            dAppOp.To,
+		Nonce:         dAppOp.Nonce,
+		Deadline:      dAppOp.Deadline,
+		Control:       dAppOp.Control,
+		Bundler:       dAppOp.Bundler,
+		UserOpHash:    dAppOp.UserOpHash,
+		CallChainHash: dAppOp.CallChainHash,
+		Signature:     dAppOp.Signature,
+	}
+
+	_solverOps := make([]atlas.SolverOperation, len(solverOps))
+	for i, solverOp := range solverOps {
+		_solverOps[i] = atlas.SolverOperation{
+			From:         solverOp.From,
+			To:           solverOp.To,
+			Value:        solverOp.Value,
+			Gas:          solverOp.Gas,
+			MaxFeePerGas: solverOp.MaxFeePerGas,
+			Deadline:     solverOp.Deadline,
+			Solver:       solverOp.Solver,
+			Control:      solverOp.Control,
+			UserOpHash:   solverOp.UserOpHash,
+			BidToken:     solverOp.BidToken,
+			BidAmount:    solverOp.BidAmount,
+			Data:         solverOp.Data,
+			Signature:    solverOp.Signature,
+		}
+	}
+
+	tx, err := contract.Metacall(transactOpts, atlas.UserOperation(*userOp), _solverOps, _dAppOp)
+	if err != nil {
+		return nil, err
+	}
+
+	return tx, nil
+}

core/sdk.go

@@ -88,3 +88,39 @@ func (sdk *AtlasSdk) getEthClient(chainId uint64) (*ethclient.Client, error) {
 
 	return client, nil
 }
+
+func (sdk *AtlasSdk) GetAtlasContract(chainId uint64) (*atlas.Atlas, error) {
+	contract, ok := sdk.atlasContract[chainId]
+	if !ok {
+		return nil, fmt.Errorf("atlas contract not found for chain id %d", chainId)
+	}
+
+	return contract, nil
+}
+
+func (sdk *AtlasSdk) GetAtlasVerificationContract(chainId uint64) (*atlasverification.AtlasVerification, error) {
+	contract, ok := sdk.atlasVerificationContract[chainId]
+	if !ok {
+		return nil, fmt.Errorf("atlas verification contract not found for chain id %d", chainId)
+	}
+
+	return contract, nil
+}
+
+func (sdk *AtlasSdk) GetSimulatorContract(chainId uint64) (*simulator.Simulator, error) {
+	contract, ok := sdk.simulatorContract[chainId]
+	if !ok {
+		return nil, fmt.Errorf("simulator contract not found for chain id %d", chainId)
+	}
+
+	return contract, nil
+}
+
+func (sdk *AtlasSdk) GetSorterContract(chainId uint64) (*sorter.Sorter, error) {
+	contract, ok := sdk.sorterContract[chainId]
+	if !ok {
+		return nil, fmt.Errorf("sorter contract not found for chain id %d", chainId)
+	}
+
+	return contract, nil
+}

types/solver_operation.go

@@ -247,6 +247,12 @@ func (s SolverOperations) EncodeToRaw() SolverOperationsRaw {
 	return solverOps
 }
 
+func (s SolverOperations) Sanitize() {
+	for _, solverOp := range s {
+		solverOp.Sanitize()
+	}
+}
+
 func (s SolverOperationsRaw) Decode() SolverOperations {
 	solverOps := make([]*SolverOperation, len(s))
 	for i, solverOp := range s {