Direct RPC call

Author: kubasiemion

ecsigner/ecsigner.go

@@ -81,3 +81,8 @@ func Unmarshal(bt []byte) (signer.Signer, error) {
 	ecsigner.SignerAddress = common.BytesToAddress(crypto.PubkeyToAddress(privkey.PublicKey).Bytes())
 	return ecsigner, nil
 }
+
+// KeyContainer function
+func (ecsigner *ECSigner) GetKey() *ecdsa.PrivateKey {
+	return ecsigner.SignerKey
+}

rpccalls/call.go

@@ -0,0 +1,60 @@
+package rpccalls
+
+import (
+	"context"
+	"crypto/ecdsa"
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/san-lab/go4337/state"
+)
+
+type KeyContainer interface {
+	GetKey() *ecdsa.PrivateKey
+}
+
+func CreateSignedTransaction(rpc *state.RPCEndpoint, from, to common.Address, value *big.Int, calldata []byte, gasLimit uint64, key *ecdsa.PrivateKey) (*types.Transaction, error) {
+	client, err := ethclient.Dial(rpc.URL)
+	if err != nil {
+		return nil, err
+	}
+
+	gasPrice, err := client.SuggestGasPrice(context.Background())
+	if err != nil {
+		return nil, fmt.Errorf("could not get gas price: %v", err)
+	}
+
+	nonce, err := client.PendingNonceAt(context.Background(), from)
+	if err != nil {
+		return nil, fmt.Errorf("could not get nonce: %v", err)
+	}
+
+	tx := types.NewTransaction(nonce, to, value, gasLimit, gasPrice, calldata)
+
+	return types.SignTx(tx, types.NewEIP155Signer(rpc.ChainId), key)
+
+}
+
+func SendTransaction(rpc *state.RPCEndpoint, signedTx *types.Transaction) (*common.Hash, error) {
+	client, err := ethclient.Dial(rpc.URL)
+	if err != nil {
+		return nil, fmt.Errorf("could not connect to rpc: %v", err)
+	}
+	err = client.SendTransaction(context.Background(), signedTx)
+	if err != nil {
+		return nil, fmt.Errorf("could not send tx: %v", err)
+	}
+	h := signedTx.Hash()
+	return &h, nil
+}
+
+func CreateAndSendTransaction(rpc *state.RPCEndpoint, from, to common.Address, value *big.Int, calldata []byte, gasLimit uint64, key KeyContainer) (*common.Hash, error) {
+	signedTx, err := CreateSignedTransaction(rpc, from, to, value, calldata, gasLimit, key.GetKey())
+	if err != nil {
+		return nil, fmt.Errorf("could not create signed tx: %v", err)
+	}
+	return SendTransaction(rpc, signedTx)
+}

state/state.go

@@ -3,6 +3,7 @@ package state
 import (
 	"encoding/json"
 	"fmt"
+	"math/big"
 	"os"
 	"reflect"
 	"sort"
@@ -25,12 +26,13 @@ var PackedUserOpV7Type reflect.Type
 type StateStruct struct {
 	AddressBooks map[string]*AddressBook
 	//Default Gas Costs?
-	Signers    []signer.Signer `json:"-"`
-	SignersRaw []string
-	ABIArts    map[string]*AbiArtifacts //ABI strings memorized
-	UserOps    map[string]*userop.UserOperation
-	ChainID    uint64
-	AlchApiKey string
+	Signers      []signer.Signer `json:"-"`
+	SignersRaw   []string
+	ABIArts      map[string]*AbiArtifacts //ABI strings memorized
+	UserOps      map[string]*userop.UserOperation
+	ChainID      uint64
+	AlchApiKey   string
+	RPCEndpoints map[string]*RPCEndpoint
 }
 
 //type ABIs map[string]string
@@ -50,6 +52,13 @@ type AbiArtifacts struct {
 	MethodCalls     map[string]*MethodCall `json:"-"`
 }
 
+type RPCEndpoint struct {
+	Name    string
+	URL     string
+	ChainId *big.Int
+	APIKey  string
+}
+
 func init() {
 	stateMux.Lock()
 	defer stateMux.Unlock()
@@ -70,6 +79,9 @@ func init() {
 	if State.UserOps == nil {
 		State.UserOps = make(map[string]*userop.UserOperation)
 	}
+	if State.RPCEndpoints == nil {
+		State.RPCEndpoints = make(map[string]*RPCEndpoint)
+	}
 
 	//Add the Entrypoint abis
 	v6arts, err := ParseABI(EntrypointV6, entrypoint.EntryPointV6AbiJson)

ui/abiui.go

@@ -612,32 +612,22 @@ func EncodeConstructorParamsUI(callBackItem *Item, mabi *abi.ABI) (ret bool) {
 		switch sel {
 		case Back.Label:
 			return
-		case encodeItem.Label:
+		case encodeItem.Label, encodeWithBytecodeItem.Label:
 			data, err := userop.EncodeWithParams(mabi, "", values...)
 			if err != nil {
-				fmt.Println("Errrrorrr!!!!!", err)
+				fmt.Println("Error encoding parameters", err)
 				continue
 			}
-			if callBackItem != nil {
-				callBackItem.Value = data
-				ret = true
-				return //a bit controversial hack
+			if sel == encodeWithBytecodeItem.Label {
+				btc := DeployBytecodeItem.Value.([]byte)
+				data = append(btc, data...)
 			}
-			fmt.Printf("Encoded call: 0x%x\n", data)
-		case encodeWithBytecodeItem.Label:
-			data, err := userop.EncodeWithParams(mabi, "", values...)
-			if err != nil {
-				fmt.Println("Error encoding with bytecode!", err)
-				continue
-			}
-			btc := DeployBytecodeItem.Value.([]byte)
-			data = append(btc, data...)
 			if callBackItem != nil {
 				callBackItem.Value = data
 				ret = true
 				return //a bit controversial hack
 			}
-			fmt.Printf("Encoded call with bytecode: 0x%x\n", data)
+			fmt.Printf("Encoded call: 0x%x\n", data)
 
 		default:
 			it, ok := GetItem(sel, items)

ui/addressbookui.go

@@ -15,8 +15,7 @@ func AddressFromBookUI(label string) (*common.Address, bool) {
 	selectToRemove := false
 	abook, ok := state.GetAddressBook(label)
 	if !ok {
-		fmt.Println("Invalid address book: ", label)
-		return nil, false
+		state.State.AddressBooks[label] = &state.AddressBook{}
 	}
 	normalLabel := "Select a " + label
 	removeLabel := "Select a " + label + " to remove"

ui/rootui.go

@@ -2,7 +2,9 @@ package ui
 
 import (
 	"fmt"
+	"os"
 
+	"github.com/chzyer/readline"
 	"github.com/manifoldco/promptui"
 	"github.com/san-lab/go4337/entrypoint"
 	"github.com/san-lab/go4337/state"
@@ -11,6 +13,25 @@ import (
 func init() {
 	EntryPointItem.Value = entrypoint.E7Address
 	ApiKeyItem.Value = state.State.AlchApiKey
+	//Get rid of the bloody bell
+	readline.Stdout = &stderr{}
+}
+
+type stderr struct{}
+
+func (s *stderr) Write(b []byte) (int, error) {
+	if len(b) == 1 && b[0] == 7 {
+		return 0, nil
+	}
+	return os.Stderr.Write(b)
+}
+
+func (s *stderr) Close() error {
+	return os.Stderr.Close()
+}
+
+func init() {
+	readline.Stdout = &stderr{}
 }
 
 var PaymasterItem = &Item{Label: "Paymaster", Details: "Manage Paymaster settings"}
@@ -20,6 +41,7 @@ var SignerItem = &Item{Label: "Signer", Details: "Manage Signer settings"}
 var EntryPointItem = &Item{Label: "Entrypoint", Details: "Set Entrypoint"}
 var ApiKeyItem = &Item{Label: "Alchemy API Key", Details: "Set Alchemy API Key"}
 var SettingsItem = &Item{Label: "Settings", Details: "Paymasters, Signers, ChainID, ..."}
+var RPCEndpointsItem = &Item{Label: "RPC Endpoints", Details: "Manage RPC Endpoints"}
 
 func RootUI() {
 	items := []*Item{
@@ -67,6 +89,7 @@ func SettingsUI() {
 		ChainIDItem,
 		EntryPointItem,
 		ApiKeyItem,
+		RPCEndpointsItem,
 		Back,
 	}
 	prompt := promptui.Select{
@@ -94,6 +117,8 @@ func SettingsUI() {
 		case ApiKeyItem.Label:
 			InputNewStringUI(ApiKeyItem)
 			state.State.AlchApiKey = ApiKeyItem.Value.(string)
+		case RPCEndpointsItem.Label:
+			RPCEndpointsUI(nil)
 		case Back.Label:
 			return
 		default:

ui/rpcui.go

@@ -0,0 +1,108 @@
+package ui
+
+import (
+	"fmt"
+	"math/big"
+	"strings"
+
+	"github.com/manifoldco/promptui"
+	"github.com/san-lab/go4337/state"
+)
+
+// Maintain a map ChainID -> RPC Endpoint
+func RPCEndpointsUI(it *Item) {
+	deleting := false
+	AddRPCEnpointItem := &Item{Label: "Add RPC Endpoint", Details: "Add a new RPC Endpoint"}
+	RemoveRPCEnpointItem := &Item{Label: "Remove RPC Endpoint", Details: "Select an RPC Endpoint to remove"}
+
+	for {
+		items := []*Item{}
+		for _, rpc := range state.State.RPCEndpoints {
+			items = append(items, &Item{Label: fmt.Sprintf("%s/%v", rpc.Name, rpc.ChainId)})
+		}
+		if !deleting {
+			items = append(items, AddRPCEnpointItem, RemoveRPCEnpointItem)
+		}
+		items = append(items, Back)
+		prompt := promptui.Select{Label: "RPC Endpoints", Items: items, Templates: ItemTemplate, Size: 10}
+		_, sel, err := prompt.Run()
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+		switch sel {
+		case Back.Label:
+			return
+		case RemoveRPCEnpointItem.Label:
+			deleting = true
+			continue
+		case AddRPCEnpointItem.Label:
+			AddRPCEnpointUI()
+			return
+		default:
+			name := strings.Split(sel, "/")[0]
+			if deleting {
+				prpt := promptui.Prompt{Label: fmt.Sprintf("Are you sure you want to delete RPC Endpoint %s (yes/no)?", sel), Default: "no"}
+				y, err := prpt.Run()
+				if err == nil && y == "yes" {
+
+					delete(state.State.RPCEndpoints, name)
+					state.State.Save()
+				}
+				deleting = false
+			} else {
+				v := EditRPCEnpointUI(name)
+				if it != nil {
+					it.Value = v
+					return
+				}
+			}
+
+		}
+	}
+
+}
+
+func AddRPCEnpointUI() {
+	tItem := &Item{Label: "RPC Endpoint Name", Details: "Enter a name for the RPC Endpoint"}
+	err := InputNewStringUI(tItem)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	name, ok := tItem.Value.(string)
+	if !ok {
+		fmt.Println("Invalid value")
+		return
+	}
+	tItem.Label = "RPC Endpoint URL"
+	tItem.Details = "Enter the URL for the RPC Endpoint"
+	tItem.Value = ""
+	err = InputNewStringUI(tItem)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	url, ok := tItem.Value.(string)
+	if !ok {
+		fmt.Println("Invalid value")
+		return
+	}
+	tItem.Label = "Chain ID"
+	tItem.Details = "Enter the Chain ID for the RPC Endpoint"
+	tItem.Value = nil
+	err = InputBigInt(tItem)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	chainId, ok := tItem.Value.(*big.Int)
+
+	state.State.RPCEndpoints[name] = &state.RPCEndpoint{Name: name, URL: url, ChainId: chainId}
+	state.State.Save()
+}
+
+// TODO Error handling
+func EditRPCEnpointUI(name string) *state.RPCEndpoint {
+	return state.State.RPCEndpoints[name]
+}