- // userID can be only on second or third position
- if len(parts) != userIDPosition+1 {
- return "", fmt.Errorf("URL structure of the request looks wrong")
- }
- userID = parts[userIDPosition]
-
- // Check if userID has the correct length
- if len(userID) != common.MessageUserIDLen {
- return "", fmt.Errorf(fmt.Sprintf("wrong length of userID from URL. Got: %d, Expected: %d", len(userID), common.MessageUserIDLen))
- }
-
- return userID, nil
-}
-
-func handleEthError(req *common.RPCRequest, conn userconn.UserConn, logger gethlog.Logger, err error) {
- var method string
- id := json.RawMessage("1")
- if req != nil {
- method = req.Method
- id = req.ID
- }
-
- errjson := &common.JSONError{
- Code: 0,
- Message: err.Error(),
- Data: nil,
- }
-
- jsonRPRCError := common.JSONRPCMessage{
- Version: "2.0",
- ID: id,
- Method: method,
- Params: nil,
- Error: errjson,
- Result: nil,
- }
-
- if evmError, ok := err.(errutil.EVMSerialisableError); ok { //nolint: errorlint
- jsonRPRCError.Error.Data = evmError.Reason
- jsonRPRCError.Error.Code = evmError.ErrorCode()
- }
-
- errBytes, err := json.Marshal(jsonRPRCError)
- if err != nil {
- logger.Error("unable to marshal error - %w", log.ErrKey, err)
- return
- }
-
- logger.Info(fmt.Sprintf("Forwarding %s error response from Obscuro node: %s", method, errBytes))
-
- if err = conn.WriteResponse(errBytes); err != nil {
- logger.Error("unable to write response back", log.ErrKey, err)
- }
-}
-
-func handleError(conn userconn.UserConn, logger gethlog.Logger, err error) {
- logger.Warn("error processing request - Forwarding response to user", log.ErrKey, err)
-
- if err = conn.WriteResponse([]byte(err.Error())); err != nil {
- logger.Error("unable to write response back", log.ErrKey, err)
- }
-}
diff --git a/tools/walletextension/cache/RistrettoCache.go b/tools/walletextension/cache/RistrettoCache.go
index af417115b7..a72ca5f606 100644
--- a/tools/walletextension/cache/RistrettoCache.go
+++ b/tools/walletextension/cache/RistrettoCache.go
@@ -9,19 +9,19 @@ import (
)
const (
- numCounters = 1e7 // number of keys to track frequency of (10M).
- maxCost = 1 << 30 // maximum cost of cache (1GB).
- bufferItems = 64 // number of keys per Get buffer.
- defaultConst = 1 // default cost of cache.
+ numCounters = 1e7 // number of keys to track frequency of (10M).
+ maxCost = 1_000_000 // 1 million entries
+ bufferItems = 64 // number of keys per Get buffer.
+ defaultCost = 1 // default cost of cache.
)
-type RistrettoCache struct {
+type ristrettoCache struct {
cache *ristretto.Cache
quit chan struct{}
}
-// NewRistrettoCache returns a new RistrettoCache.
-func NewRistrettoCache(logger log.Logger) (*RistrettoCache, error) {
+// NewRistrettoCache returns a new ristrettoCache.
+func NewRistrettoCache(logger log.Logger) (Cache, error) {
cache, err := ristretto.NewCache(&ristretto.Config{
NumCounters: numCounters,
MaxCost: maxCost,
@@ -32,7 +32,7 @@ func NewRistrettoCache(logger log.Logger) (*RistrettoCache, error) {
return nil, err
}
- c := &RistrettoCache{
+ c := &ristrettoCache{
cache: cache,
quit: make(chan struct{}),
}
@@ -44,29 +44,21 @@ func NewRistrettoCache(logger log.Logger) (*RistrettoCache, error) {
}
// Set adds the key and value to the cache.
-func (c *RistrettoCache) Set(key string, value map[string]interface{}, ttl time.Duration) bool {
- return c.cache.SetWithTTL(key, value, defaultConst, ttl)
+func (c *ristrettoCache) Set(key []byte, value any, ttl time.Duration) bool {
+ return c.cache.SetWithTTL(key, value, defaultCost, ttl)
}
// Get returns the value for the given key if it exists.
-func (c *RistrettoCache) Get(key string) (value map[string]interface{}, ok bool) {
- item, found := c.cache.Get(key)
- if !found {
- return nil, false
- }
-
- // Assuming the item is stored as a map[string]interface{}, otherwise you need to type assert to the correct type.
- value, ok = item.(map[string]interface{})
- if !ok {
- // The item isn't of type map[string]interface{}
- return nil, false
- }
+func (c *ristrettoCache) Get(key []byte) (value any, ok bool) {
+ return c.cache.Get(key)
+}
- return value, true
+func (c *ristrettoCache) Remove(key []byte) {
+ c.cache.Del(key)
}
// startMetricsLogging starts logging cache metrics every hour.
-func (c *RistrettoCache) startMetricsLogging(logger log.Logger) {
+func (c *ristrettoCache) startMetricsLogging(logger log.Logger) {
ticker := time.NewTicker(1 * time.Hour)
for {
select {
diff --git a/tools/walletextension/cache/cache.go b/tools/walletextension/cache/cache.go
index e0886abf9e..c080779305 100644
--- a/tools/walletextension/cache/cache.go
+++ b/tools/walletextension/cache/cache.go
@@ -1,111 +1,17 @@
package cache
import (
- "crypto/sha256"
- "encoding/json"
- "fmt"
"time"
"github.com/ethereum/go-ethereum/log"
-
- "github.com/ten-protocol/go-ten/tools/walletextension/common"
-)
-
-const (
- longCacheTTL = 5 * time.Hour
- shortCacheTTL = 1 * time.Second
)
-// Define a struct to hold the cache TTL and auth requirement
-type RPCMethodCacheConfig struct {
- CacheTTL time.Duration
- RequiresAuth bool
-}
-
-// CacheableRPCMethods is a map of Ethereum JSON-RPC methods that can be cached and their TTL
-var cacheableRPCMethods = map[string]RPCMethodCacheConfig{
- // Ethereum JSON-RPC methods that can be cached long time
- "eth_getBlockByNumber": {longCacheTTL, false},
- "eth_getBlockByHash": {longCacheTTL, false},
- //"eth_getTransactionByHash": {longCacheTTL, true},
- "eth_chainId": {longCacheTTL, false},
-
- // Ethereum JSON-RPC methods that can be cached short time
- "eth_blockNumber": {shortCacheTTL, false},
- "eth_getCode": {shortCacheTTL, true},
- // "eth_getBalance": {longCacheTTL, true},// excluded for test: gen_cor_059
- //"eth_getTransactionReceipt": {shortCacheTTL, true},
- "eth_call": {shortCacheTTL, true},
- "eth_gasPrice": {shortCacheTTL, false},
- // "eth_getTransactionCount": {longCacheTTL, true}, // excluded for test: gen_cor_009
- "eth_estimateGas": {shortCacheTTL, true},
- "eth_feeHistory": {shortCacheTTL, false},
-}
-
type Cache interface {
- Set(key string, value map[string]interface{}, ttl time.Duration) bool
- Get(key string) (value map[string]interface{}, ok bool)
+ Set(key []byte, value any, ttl time.Duration) bool
+ Get(key []byte) (value any, ok bool)
+ Remove(key []byte)
}
func NewCache(logger log.Logger) (Cache, error) {
return NewRistrettoCache(logger)
}
-
-// IsCacheable checks if the given RPC request is cacheable and returns the cache key and TTL
-func IsCacheable(key *common.RPCRequest, encryptionToken string) (bool, string, time.Duration) {
- if key == nil || key.Method == "" {
- return false, "", 0
- }
-
- // Check if the method is cacheable
- methodCacheConfig, isCacheable := cacheableRPCMethods[key.Method]
-
- // If method does not need to be authenticated, we can don't need to cache it per user
- if !methodCacheConfig.RequiresAuth {
- encryptionToken = ""
- }
-
- if isCacheable {
- // method is cacheable - select cache key and ttl
- switch key.Method {
- case "eth_getCode", "eth_getBalance", "eth_estimateGas", "eth_call":
- if len(key.Params) == 1 || len(key.Params) == 2 && (key.Params[1] == "latest" || key.Params[1] == "pending") {
- return true, GenerateCacheKey(key.Method, encryptionToken, key.Params...), methodCacheConfig.CacheTTL
- }
- // in this case, we have a fixed block number, and we can cache the result for a long time
- return true, GenerateCacheKey(key.Method, encryptionToken, key.Params...), longCacheTTL
- case "eth_feeHistory":
- if len(key.Params) == 2 || len(key.Params) == 3 && (key.Params[2] == "latest" || key.Params[2] == "pending") {
- return true, GenerateCacheKey(key.Method, encryptionToken, key.Params...), methodCacheConfig.CacheTTL
- }
- // in this case, we have a fixed block number, and we can cache the result for a long time
- return true, GenerateCacheKey(key.Method, encryptionToken, key.Params...), longCacheTTL
-
- default:
- return true, GenerateCacheKey(key.Method, encryptionToken, key.Params...), methodCacheConfig.CacheTTL
- }
- }
-
- // method is not cacheable
- return false, "", 0
-}
-
-// GenerateCacheKey generates a cache key for the given method, encryptionToken and parameters
-// encryptionToken is used to generate a unique cache key for each user and empty string should be used for public data
-func GenerateCacheKey(method string, encryptionToken string, params ...interface{}) string {
- // Serialize parameters
- paramBytes, err := json.Marshal(params)
- if err != nil {
- return ""
- }
-
- // Concatenate method name and parameters
- rawKey := method + encryptionToken + string(paramBytes)
-
- // Optional: Apply hashing
- hasher := sha256.New()
- hasher.Write([]byte(rawKey))
- hashedKey := fmt.Sprintf("%x", hasher.Sum(nil))
-
- return hashedKey
-}
diff --git a/tools/walletextension/cache/cache_test.go b/tools/walletextension/cache/cache_test.go
deleted file mode 100644
index 8c59d533fd..0000000000
--- a/tools/walletextension/cache/cache_test.go
+++ /dev/null
@@ -1,249 +0,0 @@
-package cache
-
-import (
- "reflect"
- "testing"
- "time"
-
- "github.com/ethereum/go-ethereum/log"
-
- "github.com/ten-protocol/go-ten/tools/walletextension/common"
-)
-
-var tests = map[string]func(t *testing.T){
- "testCacheableMethods": testCacheableMethods,
- "testNonCacheableMethods": testNonCacheableMethods,
- "testMethodsWithLatestOrPendingParameter": testMethodsWithLatestOrPendingParameter,
-}
-
-var cacheTests = map[string]func(cache Cache, t *testing.T){
- "testResultsAreCached": testResultsAreCached,
- "testCacheTTL": testCacheTTL,
- "testCachingAuthenticatedMethods": testCachingAuthenticatedMethods,
- "testCachingNonAuthenticatedMethods": testCachingNonAuthenticatedMethods,
-}
-
-var (
- nonCacheableMethods = []string{"eth_sendrawtransaction", "eth_sendtransaction", "join", "authenticate"}
- encryptionToken = "test"
- encryptionToken2 = "not-test"
-)
-
-func TestGatewayCaching(t *testing.T) {
- for name, test := range tests {
- t.Run(name, func(t *testing.T) {
- test(t)
- })
- }
-
- // cache tests
- for name, test := range cacheTests {
- t.Run(name, func(t *testing.T) {
- logger := log.New()
- cache, err := NewCache(logger)
- if err != nil {
- t.Errorf("failed to create cache: %v", err)
- }
- test(cache, t)
- })
- }
-}
-
-// testCacheableMethods tests if the cacheable methods are cacheable
-func testCacheableMethods(t *testing.T) {
- for method := range cacheableRPCMethods {
- key := &common.RPCRequest{Method: method}
- isCacheable, _, _ := IsCacheable(key, encryptionToken)
- if isCacheable != true {
- t.Errorf("method %s should be cacheable", method)
- }
- }
-}
-
-// testNonCacheableMethods tests if the non-cacheable methods are not cacheable
-func testNonCacheableMethods(t *testing.T) {
- for _, method := range nonCacheableMethods {
- key := &common.RPCRequest{Method: method}
- isCacheable, _, _ := IsCacheable(key, encryptionToken)
- if isCacheable == true {
- t.Errorf("method %s should not be cacheable", method)
- }
- }
-}
-
-// testMethodsWithLatestOrPendingParameter tests if the methods with latest or pending parameter are cacheable
-func testMethodsWithLatestOrPendingParameter(t *testing.T) {
- methods := []string{"eth_getCode", "eth_estimateGas", "eth_call"}
- for _, method := range methods {
- key := &common.RPCRequest{Method: method, Params: []interface{}{"0x123", "latest"}}
- _, _, ttl := IsCacheable(key, encryptionToken)
- if ttl != shortCacheTTL {
- t.Errorf("method %s with latest parameter should have TTL of %s, but %s received", method, shortCacheTTL, ttl)
- }
-
- key = &common.RPCRequest{Method: method, Params: []interface{}{"0x123", "pending"}}
- _, _, ttl = IsCacheable(key, encryptionToken)
- if ttl != shortCacheTTL {
- t.Errorf("method %s with pending parameter should have TTL of %s, but %s received", method, shortCacheTTL, ttl)
- }
- }
-}
-
-// testResultsAreCached tests if the results are cached as expected
-func testResultsAreCached(cache Cache, t *testing.T) {
- // prepare a cacheable request and imaginary response
- req := &common.RPCRequest{Method: "eth_getBlockByNumber", Params: []interface{}{"0x123"}}
- res := map[string]interface{}{"result": "block"}
- isCacheable, key, ttl := IsCacheable(req, encryptionToken)
- if !isCacheable {
- t.Errorf("method %s should be cacheable", req.Method)
- }
- // set the response in the cache with a TTL
- if !cache.Set(key, res, ttl) {
- t.Errorf("failed to set value in cache for %s", req)
- }
-
- time.Sleep(50 * time.Millisecond) // wait for the cache to be set
- value, ok := cache.Get(key)
- if !ok {
- t.Errorf("failed to get cached value for %s", req)
- }
-
- if !reflect.DeepEqual(value, res) {
- t.Errorf("expected %v, got %v", res, value)
- }
-}
-
-// testCacheTTL tests if the cache TTL is working as expected
-func testCacheTTL(cache Cache, t *testing.T) {
- req := &common.RPCRequest{Method: "eth_blockNumber", Params: []interface{}{"0x123"}}
- res := map[string]interface{}{"result": "100"}
- isCacheable, key, ttl := IsCacheable(req, encryptionToken)
-
- if !isCacheable {
- t.Errorf("method %s should be cacheable", req.Method)
- }
-
- if ttl != shortCacheTTL {
- t.Errorf("method %s should have TTL of %s, but %s received", req.Method, shortCacheTTL, ttl)
- }
-
- // set the response in the cache with a TTL
- if !cache.Set(key, res, ttl) {
- t.Errorf("failed to set value in cache for %s", req)
- }
- time.Sleep(50 * time.Millisecond) // wait for the cache to be set
-
- // check if the value is in the cache
- value, ok := cache.Get(key)
- if !ok {
- t.Errorf("failed to get cached value for %s", req)
- }
-
- if !reflect.DeepEqual(value, res) {
- t.Errorf("expected %v, got %v", res, value)
- }
-
- // sleep for the TTL to expire
- time.Sleep(shortCacheTTL + 100*time.Millisecond)
- _, ok = cache.Get(key)
- if ok {
- t.Errorf("value should not be in the cache after TTL")
- }
-}
-
-func testCachingAuthenticatedMethods(cache Cache, t *testing.T) {
- // eth_getTransactionByHash
- authMethods := []string{
- //"eth_getTransactionByHash",
- "eth_getCode",
- //"eth_getTransactionReceipt",
- "eth_call",
- "eth_estimateGas",
- }
- for _, method := range authMethods {
- req := &common.RPCRequest{Method: method, Params: []interface{}{"0x123"}}
- res := map[string]interface{}{"result": "transaction"}
-
- // store the response in cache for the first user using encryptionToken
- isCacheable, key, ttl := IsCacheable(req, encryptionToken)
-
- if !isCacheable {
- t.Errorf("method %s should be cacheable", req.Method)
- }
-
- // set the response in the cache with a TTL
- if !cache.Set(key, res, ttl) {
- t.Errorf("failed to set value in cache for %s", req)
- }
- time.Sleep(50 * time.Millisecond) // wait for the cache to be set
-
- // check if the value is in the cache
- value, ok := cache.Get(key)
- if !ok {
- t.Errorf("failed to get cached value for %s", req)
- }
-
- // for the first error we should have the value in cache
- if !reflect.DeepEqual(value, res) {
- t.Errorf("expected %v, got %v", res, value)
- }
-
- // now check with the second user asking for the same request, but with a different encryptionToken
- _, key2, _ := IsCacheable(req, encryptionToken2)
-
- _, okSecondUser := cache.Get(key2)
- if okSecondUser {
- t.Errorf("another user should not see a value the first user cached %s", req)
- }
- }
-}
-
-func testCachingNonAuthenticatedMethods(cache Cache, t *testing.T) {
- // eth_getTransactionByHash
- nonAuthMethods := []string{
- "eth_getBlockByNumber",
- "eth_getBlockByHash",
- "eth_chainId",
- "eth_blockNumber",
- "eth_gasPrice",
- "eth_feeHistory",
- }
-
- for _, method := range nonAuthMethods {
- req := &common.RPCRequest{Method: method, Params: []interface{}{"0x123"}}
- res := map[string]interface{}{"result": "transaction"}
-
- // store the response in cache for the first user using encryptionToken
- isCacheable, key, ttl := IsCacheable(req, encryptionToken)
-
- if !isCacheable {
- t.Errorf("method %s should be cacheable", req.Method)
- }
-
- // set the response in the cache with a TTL
- if !cache.Set(key, res, ttl) {
- t.Errorf("failed to set value in cache for %s", req)
- }
- time.Sleep(50 * time.Millisecond) // wait for the cache to be set
-
- // check if the value is in the cache
- value, ok := cache.Get(key)
- if !ok {
- t.Errorf("failed to get cached value for %s", req)
- }
-
- // for the first error we should have the value in cache
- if !reflect.DeepEqual(value, res) {
- t.Errorf("expected %v, got %v", res, value)
- }
-
- // now check with the second user asking for the same request, but with a different encryptionToken
- _, key2, _ := IsCacheable(req, encryptionToken2)
-
- _, okSecondUser := cache.Get(key2)
- if !okSecondUser {
- t.Errorf("another user should see a value the first user cached %s", req)
- }
- }
-}
diff --git a/tools/walletextension/common/common.go b/tools/walletextension/common/common.go
index 8a13de5a3d..59cb4b8a4b 100644
--- a/tools/walletextension/common/common.go
+++ b/tools/walletextension/common/common.go
@@ -1,11 +1,12 @@
package common
import (
- "encoding/hex"
"encoding/json"
"fmt"
"os"
+ gethrpc "github.com/ten-protocol/go-ten/lib/gethfork/rpc"
+
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/crypto/ecies"
"github.com/ten-protocol/go-ten/go/common/log"
@@ -34,13 +35,8 @@ func BytesToPrivateKey(keyBytes []byte) (*ecies.PrivateKey, error) {
return eciesPrivateKey, nil
}
-// GetUserIDbyte converts userID from string to correct byte format
-func GetUserIDbyte(userID string) ([]byte, error) {
- return hex.DecodeString(userID)
-}
-
func CreateEncClient(
- hostRPCBindAddr string,
+ conn *gethrpc.Client,
addressBytes []byte,
privateKeyBytes []byte,
signature []byte,
@@ -61,7 +57,7 @@ func CreateEncClient(
SignatureWithAccountKey: signature,
SignatureType: signatureType,
}
- encClient, err := rpc.NewEncNetworkClient(hostRPCBindAddr, vk, logger)
+ encClient, err := rpc.NewEncNetworkClientFromConn(conn, vk, logger)
if err != nil {
return nil, fmt.Errorf("unable to create EncRPCClient: %w", err)
}
diff --git a/tools/walletextension/config/config.go b/tools/walletextension/common/config.go
similarity index 97%
rename from tools/walletextension/config/config.go
rename to tools/walletextension/common/config.go
index 9e423ca476..98092f8c7b 100644
--- a/tools/walletextension/config/config.go
+++ b/tools/walletextension/common/config.go
@@ -1,4 +1,4 @@
-package config
+package common
// Config contains the configuration required by the WalletExtension.
type Config struct {
diff --git a/tools/walletextension/common/constants.go b/tools/walletextension/common/constants.go
index 55d1da0ac4..aa81df8b64 100644
--- a/tools/walletextension/common/constants.go
+++ b/tools/walletextension/common/constants.go
@@ -1,58 +1,39 @@
package common
-import (
- "time"
-)
-
const (
Localhost = "127.0.0.1"
JSONKeyAddress = "address"
- JSONKeyData = "data"
- JSONKeyErr = "error"
- JSONKeyFrom = "from"
JSONKeyID = "id"
JSONKeyMethod = "method"
JSONKeyParams = "params"
- JSONKeyResult = "result"
- JSONKeyRoot = "root"
JSONKeyRPCVersion = "jsonrpc"
JSONKeySignature = "signature"
- JSONKeySubscription = "subscription"
- JSONKeyCode = "code"
- JSONKeyMessage = "message"
JSONKeyType = "type"
JSONKeyEncryptionToken = "encryptionToken"
JSONKeyFormats = "formats"
)
const (
- PathRoot = "/"
+ PathStatic = "/static/"
PathReady = "/ready/"
- PathViewingKeys = "/viewingkeys/"
PathJoin = "/join/"
PathGetMessage = "/getmessage/"
PathAuthenticate = "/authenticate/"
PathQuery = "/query/"
PathRevoke = "/revoke/"
- PathObscuroGateway = "/"
PathHealth = "/health/"
PathNetworkHealth = "/network-health/"
WSProtocol = "ws://"
HTTPProtocol = "http://"
- DefaultUser = "defaultUser"
- UserQueryParameter = "u"
EncryptedTokenQueryParameter = "token"
AddressQueryParameter = "a"
MessageUserIDLen = 40
EthereumAddressLen = 42
- GetStorageAtUserIDRequestMethodName = "getUserID"
+ GetStorageAtUserIDRequestMethodName = "0x0000000000000000000000000000000000000000"
SuccessMsg = "success"
APIVersion1 = "/v1"
- MethodEthSubscription = "eth_subscription"
PathVersion = "/version/"
DeduplicationBufferSize = 20
DefaultGatewayAuthMessageType = "EIP712"
)
-
-var ReaderHeadTimeout = 10 * time.Second
diff --git a/tools/walletextension/common/types.go b/tools/walletextension/common/db_types.go
similarity index 100%
rename from tools/walletextension/common/types.go
rename to tools/walletextension/common/db_types.go
diff --git a/tools/walletextension/common/responses.go b/tools/walletextension/common/responses.go
deleted file mode 100644
index 65b6d77c2f..0000000000
--- a/tools/walletextension/common/responses.go
+++ /dev/null
@@ -1,29 +0,0 @@
-package common
-
-import (
- "errors"
-
- gethrpc "github.com/ten-protocol/go-ten/lib/gethfork/rpc"
-)
-
-func CraftErrorResponse(err error) map[string]interface{} {
- errMap := make(map[string]interface{})
- respMap := make(map[string]interface{})
-
- respMap[JSONKeyErr] = errMap
- errMap[JSONKeyMessage] = err.Error()
-
- var e gethrpc.Error
- ok := errors.As(err, &e)
- if ok {
- errMap[JSONKeyCode] = e.ErrorCode()
- }
-
- var de gethrpc.DataError
- ok = errors.As(err, &de)
- if ok {
- errMap[JSONKeyData] = de.ErrorData()
- }
-
- return respMap
-}
diff --git a/tools/walletextension/container/walletextension_container.go b/tools/walletextension/container/walletextension_container.go
deleted file mode 100644
index 1dccaab400..0000000000
--- a/tools/walletextension/container/walletextension_container.go
+++ /dev/null
@@ -1,209 +0,0 @@
-package container
-
-import (
- "bytes"
- "encoding/hex"
- "errors"
- "fmt"
- "net/http"
- "os"
-
- "github.com/ten-protocol/go-ten/go/common/viewingkey"
-
- "github.com/ethereum/go-ethereum/common"
-
- "github.com/ethereum/go-ethereum/crypto"
-
- "github.com/ten-protocol/go-ten/go/common/log"
- "github.com/ten-protocol/go-ten/go/common/stopcontrol"
- "github.com/ten-protocol/go-ten/go/rpc"
- "github.com/ten-protocol/go-ten/tools/walletextension"
- "github.com/ten-protocol/go-ten/tools/walletextension/api"
- "github.com/ten-protocol/go-ten/tools/walletextension/config"
- "github.com/ten-protocol/go-ten/tools/walletextension/storage"
- "github.com/ten-protocol/go-ten/tools/walletextension/useraccountmanager"
-
- gethlog "github.com/ethereum/go-ethereum/log"
- wecommon "github.com/ten-protocol/go-ten/tools/walletextension/common"
-)
-
-type WalletExtensionContainer struct {
- hostAddr string
- userAccountManager *useraccountmanager.UserAccountManager
- storage storage.Storage
- stopControl *stopcontrol.StopControl
- logger gethlog.Logger
- walletExt *walletextension.WalletExtension
- httpServer *api.Server
- wsServer *api.Server
-}
-
-func NewWalletExtensionContainerFromConfig(config config.Config, logger gethlog.Logger) *WalletExtensionContainer {
- // create the account manager with a single unauthenticated connection
- hostRPCBindAddrWS := wecommon.WSProtocol + config.NodeRPCWebsocketAddress
- hostRPCBindAddrHTTP := wecommon.HTTPProtocol + config.NodeRPCHTTPAddress
- unAuthedClient, err := rpc.NewNetworkClient(hostRPCBindAddrHTTP)
- if err != nil {
- logger.Crit("unable to create temporary client for request ", log.ErrKey, err)
- os.Exit(1)
- }
-
- // start the database
- databaseStorage, err := storage.New(config.DBType, config.DBConnectionURL, config.DBPathOverride)
- if err != nil {
- logger.Crit("unable to create database to store viewing keys ", log.ErrKey, err)
- os.Exit(1)
- }
- userAccountManager := useraccountmanager.NewUserAccountManager(unAuthedClient, logger, databaseStorage, hostRPCBindAddrHTTP, hostRPCBindAddrWS)
-
- // add default user (when no UserID is provided in the query parameter - for WE endpoints)
- defaultUserAccountManager := userAccountManager.AddAndReturnAccountManager(hex.EncodeToString([]byte(wecommon.DefaultUser)))
-
- // add default user to the database (temporary fix before removing wallet extension endpoints)
- accountPrivateKey, err := crypto.GenerateKey()
- if err != nil {
- logger.Error("Unable to generate key pair for default user", log.ErrKey, err)
- os.Exit(1)
- }
-
- // get all users and their private keys from the database
- allUsers, err := databaseStorage.GetAllUsers()
- if err != nil {
- logger.Error(fmt.Errorf("error getting all users from database, %w", err).Error())
- os.Exit(1)
- }
-
- // iterate over users create accountManagers and add all defaultUserAccounts to them per user
- for _, user := range allUsers {
- userAccountManager.AddAndReturnAccountManager(hex.EncodeToString(user.UserID))
- logger.Info(fmt.Sprintf("account manager added for user: %s", hex.EncodeToString(user.UserID)))
-
- // to ensure backwards compatibility we want to load clients for the default user
- // TODO @ziga - this code needs to be removed when removing old wallet extension endpoints
- if bytes.Equal(user.UserID, []byte(wecommon.DefaultUser)) {
- accounts, err := databaseStorage.GetAccounts(user.UserID)
- if err != nil {
- logger.Error(fmt.Errorf("error getting accounts for user: %s, %w", hex.EncodeToString(user.UserID), err).Error())
- os.Exit(1)
- }
- for _, account := range accounts {
- encClient, err := wecommon.CreateEncClient(hostRPCBindAddrWS, account.AccountAddress, user.PrivateKey, account.Signature, viewingkey.SignatureType(account.SignatureType), logger)
- if err != nil {
- logger.Error(fmt.Errorf("error creating new client, %w", err).Error())
- os.Exit(1)
- }
-
- // add a client to default user
- defaultUserAccountManager.AddClient(common.BytesToAddress(account.AccountAddress), encClient)
- }
- }
- }
- // TODO @ziga - remove this when removing wallet extension endpoints
- err = databaseStorage.AddUser([]byte(wecommon.DefaultUser), crypto.FromECDSA(accountPrivateKey))
- if err != nil {
- logger.Error("Unable to save default user to the database", log.ErrKey, err)
- os.Exit(1)
- }
-
- // captures version in the env vars
- version := os.Getenv("OBSCURO_GATEWAY_VERSION")
- if version == "" {
- version = "dev"
- }
-
- stopControl := stopcontrol.New()
- walletExt := walletextension.New(hostRPCBindAddrHTTP, hostRPCBindAddrWS, &userAccountManager, databaseStorage, stopControl, version, logger, &config)
- httpRoutes := api.NewHTTPRoutes(walletExt)
- httpServer := api.NewHTTPServer(fmt.Sprintf("%s:%d", config.WalletExtensionHost, config.WalletExtensionPortHTTP), httpRoutes)
-
- wsRoutes := api.NewWSRoutes(walletExt)
- wsServer := api.NewWSServer(fmt.Sprintf("%s:%d", config.WalletExtensionHost, config.WalletExtensionPortWS), wsRoutes)
- return NewWalletExtensionContainer(
- hostRPCBindAddrWS,
- walletExt,
- &userAccountManager,
- databaseStorage,
- stopControl,
- httpServer,
- wsServer,
- logger,
- )
-}
-
-func NewWalletExtensionContainer(
- hostAddr string,
- walletExt *walletextension.WalletExtension,
- userAccountManager *useraccountmanager.UserAccountManager,
- storage storage.Storage,
- stopControl *stopcontrol.StopControl,
- httpServer *api.Server,
- wsServer *api.Server,
- logger gethlog.Logger,
-) *WalletExtensionContainer {
- return &WalletExtensionContainer{
- hostAddr: hostAddr,
- walletExt: walletExt,
- userAccountManager: userAccountManager,
- storage: storage,
- stopControl: stopControl,
- httpServer: httpServer,
- wsServer: wsServer,
- logger: logger,
- }
-}
-
-// Start starts the wallet extension container
-func (w *WalletExtensionContainer) Start() error {
- httpErrChan := w.httpServer.Start()
- wsErrChan := w.wsServer.Start()
-
- // Start a goroutine for handling HTTP and WS server errors
- go func() {
- for {
- select {
- case err := <-httpErrChan:
- if errors.Is(err, http.ErrServerClosed) {
- err = w.Stop() // Stop the container when the HTTP server is closed
- if err != nil {
- fmt.Printf("failed to stop gracefully - %s\n", err)
- os.Exit(1)
- }
- } else {
- // for other errors, we just log them
- w.logger.Error("HTTP server error: %v", err)
- }
- case err := <-wsErrChan:
- if errors.Is(err, http.ErrServerClosed) {
- err = w.Stop() // Stop the container when the WS server is closed
- if err != nil {
- fmt.Printf("failed to stop gracefully - %s\n", err)
- os.Exit(1)
- }
- } else {
- // for other errors, we just log them
- w.logger.Error("HTTP server error: %v", err)
- }
- case <-w.stopControl.Done():
- return // Exit the goroutine when stop signal is received
- }
- }
- }()
- return nil
-}
-
-func (w *WalletExtensionContainer) Stop() error {
- w.stopControl.Stop()
-
- err := w.httpServer.Stop()
- if err != nil {
- w.logger.Warn("could not shut down wallet extension", log.ErrKey, err)
- }
-
- err = w.wsServer.Stop()
- if err != nil {
- w.logger.Warn("could not shut down wallet extension", log.ErrKey, err)
- }
-
- // todo (@pedro) correctly surface shutdown errors
- return nil
-}
diff --git a/tools/walletextension/frontend/next.config.js b/tools/walletextension/frontend/next.config.js
index 5d5086f7cb..04472f7ff7 100644
--- a/tools/walletextension/frontend/next.config.js
+++ b/tools/walletextension/frontend/next.config.js
@@ -7,6 +7,8 @@ const nextConfig = {
images: {
unoptimized: true,
},
+ // base path for static files should be "" in development but "/static" in production
+ basePath: process.env.NODE_ENV === "development" ? "" : "/static",
};
module.exports = nextConfig;
diff --git a/tools/walletextension/frontend/src/components/layouts/header.tsx b/tools/walletextension/frontend/src/components/layouts/header.tsx
index a04de0fea8..3a2e59b40a 100644
--- a/tools/walletextension/frontend/src/components/layouts/header.tsx
+++ b/tools/walletextension/frontend/src/components/layouts/header.tsx
@@ -14,7 +14,7 @@ export default function Header() {
-
+
diff --git a/tools/walletextension/frontend/src/routes/index.ts b/tools/walletextension/frontend/src/routes/index.ts
index f3ac4438f7..c53c3bc501 100644
--- a/tools/walletextension/frontend/src/routes/index.ts
+++ b/tools/walletextension/frontend/src/routes/index.ts
@@ -8,7 +8,7 @@ export const apiRoutes = {
authenticate: `/${tenGatewayVersion}/authenticate/`,
queryAccountToken: `/${tenGatewayVersion}/query/`,
revoke: `/${tenGatewayVersion}/revoke/`,
- version: `/version/`,
+ version: `/${tenGatewayVersion}/version/`,
// **** INFO ****
getHealthStatus: `/${tenGatewayVersion}/network-health/`,
diff --git a/tools/walletextension/httpapi/README.MD b/tools/walletextension/httpapi/README.MD
new file mode 100644
index 0000000000..90a8e7e823
--- /dev/null
+++ b/tools/walletextension/httpapi/README.MD
@@ -0,0 +1 @@
+todo - the content of this package should be moved to rpcapi to avoid implementing the low-level http logic
\ No newline at end of file
diff --git a/tools/walletextension/api/routes.go b/tools/walletextension/httpapi/routes.go
similarity index 66%
rename from tools/walletextension/api/routes.go
rename to tools/walletextension/httpapi/routes.go
index dad70da1a5..4f05e5b62f 100644
--- a/tools/walletextension/api/routes.go
+++ b/tools/walletextension/httpapi/routes.go
@@ -1,4 +1,4 @@
-package api
+package httpapi
import (
"encoding/hex"
@@ -6,27 +6,24 @@ import (
"fmt"
"net/http"
+ "github.com/status-im/keycard-go/hexutils"
+
"github.com/ten-protocol/go-ten/go/common/viewingkey"
"github.com/ten-protocol/go-ten/lib/gethfork/node"
+ "github.com/ten-protocol/go-ten/tools/walletextension/rpcapi"
"github.com/ten-protocol/go-ten/go/common/log"
"github.com/ten-protocol/go-ten/go/common/httputil"
- "github.com/ten-protocol/go-ten/go/rpc"
- "github.com/ten-protocol/go-ten/tools/walletextension"
"github.com/ten-protocol/go-ten/tools/walletextension/common"
- "github.com/ten-protocol/go-ten/tools/walletextension/userconn"
)
// NewHTTPRoutes returns the http specific routes
-func NewHTTPRoutes(walletExt *walletextension.WalletExtension) []node.Route {
+// todo - move these to the rpc framework.
+func NewHTTPRoutes(walletExt *rpcapi.Services) []node.Route {
return []node.Route{
{
- Name: common.APIVersion1 + common.PathRoot,
- Func: httpHandler(walletExt, ethRequestHandler),
- },
- {
- Name: common.PathReady,
+ Name: common.APIVersion1 + common.PathReady,
Func: httpHandler(walletExt, readyRequestHandler),
},
{
@@ -50,23 +47,23 @@ func NewHTTPRoutes(walletExt *walletextension.WalletExtension) []node.Route {
Func: httpHandler(walletExt, revokeRequestHandler),
},
{
- Name: common.PathHealth,
+ Name: common.APIVersion1 + common.PathHealth,
Func: httpHandler(walletExt, healthRequestHandler),
},
{
- Name: common.PathNetworkHealth,
+ Name: common.APIVersion1 + common.PathNetworkHealth,
Func: httpHandler(walletExt, networkHealthRequestHandler),
},
{
- Name: common.PathVersion,
+ Name: common.APIVersion1 + common.PathVersion,
Func: httpHandler(walletExt, versionRequestHandler),
},
}
}
func httpHandler(
- walletExt *walletextension.WalletExtension,
- fun func(walletExt *walletextension.WalletExtension, conn userconn.UserConn),
+ walletExt *rpcapi.Services,
+ fun func(walletExt *rpcapi.Services, conn UserConn),
) func(resp http.ResponseWriter, req *http.Request) {
return func(resp http.ResponseWriter, req *http.Request) {
httpRequestHandler(walletExt, resp, req, fun)
@@ -74,113 +71,23 @@ func httpHandler(
}
// Overall request handler for http requests
-func httpRequestHandler(walletExt *walletextension.WalletExtension, resp http.ResponseWriter, req *http.Request, fun func(walletExt *walletextension.WalletExtension, conn userconn.UserConn)) {
+func httpRequestHandler(walletExt *rpcapi.Services, resp http.ResponseWriter, req *http.Request, fun func(walletExt *rpcapi.Services, conn UserConn)) {
if walletExt.IsStopping() {
return
}
if httputil.EnableCORS(resp, req) {
return
}
- userConn := userconn.NewUserConnHTTP(resp, req, walletExt.Logger())
+ userConn := NewUserConnHTTP(resp, req, walletExt.Logger())
fun(walletExt, userConn)
}
-// NewWSRoutes returns the WS specific routes
-func NewWSRoutes(walletExt *walletextension.WalletExtension) []node.Route {
- return []node.Route{
- {
- Name: common.PathRoot,
- Func: wsHandler(walletExt, ethRequestHandler),
- },
- {
- Name: common.PathReady,
- Func: wsHandler(walletExt, readyRequestHandler),
- },
- }
-}
-
-func wsHandler(
- walletExt *walletextension.WalletExtension,
- fun func(walletExt *walletextension.WalletExtension, conn userconn.UserConn),
-) func(resp http.ResponseWriter, req *http.Request) {
- return func(resp http.ResponseWriter, req *http.Request) {
- wsRequestHandler(walletExt, resp, req, fun)
- }
-}
-
-// Overall request handler for WS requests
-func wsRequestHandler(walletExt *walletextension.WalletExtension, resp http.ResponseWriter, req *http.Request, fun func(walletExt *walletextension.WalletExtension, conn userconn.UserConn)) {
- if walletExt.IsStopping() {
- return
- }
-
- userConn, err := userconn.NewUserConnWS(resp, req, walletExt.Logger())
- if err != nil {
- return
- }
- // We handle requests in a loop until the connection is closed on the client side.
- for !userConn.IsClosed() {
- fun(walletExt, userConn)
- }
-}
-
-// ethRequestHandler parses the user eth request, passes it on to the WE to proxy it and processes the response
-func ethRequestHandler(walletExt *walletextension.WalletExtension, conn userconn.UserConn) {
- body, err := conn.ReadRequest()
- if err != nil {
- handleEthError(nil, conn, walletExt.Logger(), fmt.Errorf("error reading request - %w", err))
- return
- }
-
- request, err := parseRequest(body)
- if err != nil {
- handleError(conn, walletExt.Logger(), err)
- return
- }
- walletExt.Logger().Debug("REQUEST", "method", request.Method, "body", string(body))
-
- if request.Method == rpc.Subscribe && !conn.SupportsSubscriptions() {
- handleError(conn, walletExt.Logger(), fmt.Errorf("received an %s request but the connection does not support subscriptions", rpc.Subscribe))
- return
- }
-
- // Get userID
- // TODO: @ziga - after removing old wallet extension endpoints we should prevent users doing anything without valid encryption token
- hexUserID, err := getUserID(conn, 1)
- if err != nil || !walletExt.UserExists(hexUserID) {
- walletExt.Logger().Info("user not found in the query params: %w. Using the default user", log.ErrKey, err)
- hexUserID = hex.EncodeToString([]byte(common.DefaultUser)) // todo (@ziga) - this can be removed once old WE endpoints are removed
- }
-
- if len(hexUserID) < 3 {
- handleError(conn, walletExt.Logger(), fmt.Errorf("encryption token length is incorrect"))
- return
- }
-
- // todo (@pedro) remove this conn dependency
- response, err := walletExt.ProxyEthRequest(request, conn, hexUserID)
- if err != nil {
- handleEthError(request, conn, walletExt.Logger(), err)
- return
- }
-
- rpcResponse, err := json.Marshal(response)
- if err != nil {
- handleEthError(request, conn, walletExt.Logger(), err)
- return
- }
-
- walletExt.Logger().Info(fmt.Sprintf("Forwarding %s response from Obscuro node: %s", request.Method, rpcResponse))
- if err = conn.WriteResponse(rpcResponse); err != nil {
- walletExt.Logger().Error("error writing success response", log.ErrKey, err)
- }
-}
-
// readyRequestHandler is used to check whether the server is ready
-func readyRequestHandler(_ *walletextension.WalletExtension, _ userconn.UserConn) {}
+func readyRequestHandler(_ *rpcapi.Services, _ UserConn) {}
// This function handles request to /join endpoint. It is responsible to create new user (new key-pair) and store it to the db
-func joinRequestHandler(walletExt *walletextension.WalletExtension, conn userconn.UserConn) {
+func joinRequestHandler(walletExt *rpcapi.Services, conn UserConn) {
+ // audit()
// todo (@ziga) add protection against DDOS attacks
_, err := conn.ReadRequest()
if err != nil {
@@ -189,14 +96,14 @@ func joinRequestHandler(walletExt *walletextension.WalletExtension, conn usercon
}
// generate new key-pair and store it in the database
- hexUserID, err := walletExt.GenerateAndStoreNewUser()
+ userID, err := walletExt.GenerateAndStoreNewUser()
if err != nil {
handleError(conn, walletExt.Logger(), fmt.Errorf("internal Error"))
walletExt.Logger().Error("error creating new user", log.ErrKey, err)
}
// write hex encoded userID in the response
- err = conn.WriteResponse([]byte(hexUserID))
+ err = conn.WriteResponse([]byte(hexutils.BytesToHex(userID)))
if err != nil {
walletExt.Logger().Error("error writing success response", log.ErrKey, err)
}
@@ -205,7 +112,7 @@ func joinRequestHandler(walletExt *walletextension.WalletExtension, conn usercon
// This function handles request to /authenticate endpoint.
// In the request we receive message, signature and address in JSON as request body and userID and address as query parameters
// We then check if message is in correct format and if signature is valid. If all checks pass we save address and signature against userID
-func authenticateRequestHandler(walletExt *walletextension.WalletExtension, conn userconn.UserConn) {
+func authenticateRequestHandler(walletExt *rpcapi.Services, conn UserConn) {
// read the request
body, err := conn.ReadRequest()
if err != nil {
@@ -248,17 +155,17 @@ func authenticateRequestHandler(walletExt *walletextension.WalletExtension, conn
}
// read userID from query params
- hexUserID, err := getUserID(conn, 2)
+ userID, err := getUserID(conn)
if err != nil {
handleError(conn, walletExt.Logger(), fmt.Errorf("malformed query: 'u' required - representing encryption token - %w", err))
return
}
// check signature and add address and signature for that user
- err = walletExt.AddAddressToUser(hexUserID, address, signature, messageType)
+ err = walletExt.AddAddressToUser(userID, address, signature, messageType)
if err != nil {
handleError(conn, walletExt.Logger(), fmt.Errorf("internal error"))
- walletExt.Logger().Error(fmt.Sprintf("error adding address: %s to user: %s with signature: %s", address, hexUserID, signature))
+ walletExt.Logger().Error(fmt.Sprintf("error adding address: %s to user: %s with signature: %s", address, userID, signature))
return
}
err = conn.WriteResponse([]byte(common.SuccessMsg))
@@ -270,7 +177,7 @@ func authenticateRequestHandler(walletExt *walletextension.WalletExtension, conn
// This function handles request to /query endpoint.
// In the query parameters address and userID are required. We check if provided address is registered for given userID
// and return true/false in json response
-func queryRequestHandler(walletExt *walletextension.WalletExtension, conn userconn.UserConn) {
+func queryRequestHandler(walletExt *rpcapi.Services, conn UserConn) {
// read the request
_, err := conn.ReadRequest()
if err != nil {
@@ -278,7 +185,7 @@ func queryRequestHandler(walletExt *walletextension.WalletExtension, conn userco
return
}
- hexUserID, err := getUserID(conn, 2)
+ userID, err := getUserID(conn)
if err != nil {
handleError(conn, walletExt.Logger(), fmt.Errorf("user ('u') not found in query parameters"))
walletExt.Logger().Info("user not found in the query params", log.ErrKey, err)
@@ -297,10 +204,10 @@ func queryRequestHandler(walletExt *walletextension.WalletExtension, conn userco
}
// check if this account is registered with given user
- found, err := walletExt.UserHasAccount(hexUserID, address)
+ found, err := walletExt.UserHasAccount(userID, address)
if err != nil {
handleError(conn, walletExt.Logger(), fmt.Errorf("internal error"))
- walletExt.Logger().Error("error during checking if account exists for user", "hexUserID", hexUserID, log.ErrKey, err)
+ walletExt.Logger().Error("error during checking if account exists for user", "userID", userID, log.ErrKey, err)
}
// create and write the response
@@ -322,7 +229,7 @@ func queryRequestHandler(walletExt *walletextension.WalletExtension, conn userco
// This function handles request to /revoke endpoint.
// It requires userID as query parameter and deletes given user and all associated viewing keys
-func revokeRequestHandler(walletExt *walletextension.WalletExtension, conn userconn.UserConn) {
+func revokeRequestHandler(walletExt *rpcapi.Services, conn UserConn) {
// read the request
_, err := conn.ReadRequest()
if err != nil {
@@ -330,7 +237,7 @@ func revokeRequestHandler(walletExt *walletextension.WalletExtension, conn userc
return
}
- hexUserID, err := getUserID(conn, 2)
+ userID, err := getUserID(conn)
if err != nil {
handleError(conn, walletExt.Logger(), fmt.Errorf("user ('u') not found in query parameters"))
walletExt.Logger().Info("user not found in the query params", log.ErrKey, err)
@@ -338,10 +245,10 @@ func revokeRequestHandler(walletExt *walletextension.WalletExtension, conn userc
}
// delete user and accounts associated with it from the database
- err = walletExt.DeleteUser(hexUserID)
+ err = walletExt.DeleteUser(userID)
if err != nil {
handleError(conn, walletExt.Logger(), fmt.Errorf("internal error"))
- walletExt.Logger().Error("unable to delete user", "hexUserID", hexUserID, log.ErrKey, err)
+ walletExt.Logger().Error("unable to delete user", "userID", userID, log.ErrKey, err)
return
}
@@ -352,7 +259,7 @@ func revokeRequestHandler(walletExt *walletextension.WalletExtension, conn userc
}
// Handles request to /health endpoint.
-func healthRequestHandler(walletExt *walletextension.WalletExtension, conn userconn.UserConn) {
+func healthRequestHandler(walletExt *rpcapi.Services, conn UserConn) {
// read the request
_, err := conn.ReadRequest()
if err != nil {
@@ -368,7 +275,7 @@ func healthRequestHandler(walletExt *walletextension.WalletExtension, conn userc
}
// Handles request to /network-health endpoint.
-func networkHealthRequestHandler(walletExt *walletextension.WalletExtension, userConn userconn.UserConn) {
+func networkHealthRequestHandler(walletExt *rpcapi.Services, userConn UserConn) {
// read the request
_, err := userConn.ReadRequest()
if err != nil {
@@ -394,7 +301,7 @@ func networkHealthRequestHandler(walletExt *walletextension.WalletExtension, use
}
// Handles request to /version endpoint.
-func versionRequestHandler(walletExt *walletextension.WalletExtension, userConn userconn.UserConn) {
+func versionRequestHandler(walletExt *rpcapi.Services, userConn UserConn) {
// read the request
_, err := userConn.ReadRequest()
if err != nil {
@@ -409,7 +316,7 @@ func versionRequestHandler(walletExt *walletextension.WalletExtension, userConn
}
// getMessageRequestHandler handles request to /get-message endpoint.
-func getMessageRequestHandler(walletExt *walletextension.WalletExtension, conn userconn.UserConn) {
+func getMessageRequestHandler(walletExt *rpcapi.Services, conn UserConn) {
// read the request
body, err := conn.ReadRequest()
if err != nil {
@@ -451,7 +358,12 @@ func getMessageRequestHandler(walletExt *walletextension.WalletExtension, conn u
}
}
- message, err := walletExt.GenerateUserMessageToSign(encryptionToken.(string), formatsSlice)
+ userID := hexutils.HexToBytes(encryptionToken.(string))
+ if len(userID) != viewingkey.UserIDLength {
+ return
+ }
+
+ message, err := walletExt.GenerateUserMessageToSign(userID, formatsSlice)
if err != nil {
handleError(conn, walletExt.Logger(), fmt.Errorf("internal error"))
walletExt.Logger().Error("error getting message", log.ErrKey, err)
diff --git a/tools/walletextension/httpapi/user_conn.go b/tools/walletextension/httpapi/user_conn.go
new file mode 100644
index 0000000000..2244adcfbd
--- /dev/null
+++ b/tools/walletextension/httpapi/user_conn.go
@@ -0,0 +1,72 @@
+package httpapi
+
+import (
+ "fmt"
+ "io"
+ "net/http"
+ "net/url"
+
+ gethlog "github.com/ethereum/go-ethereum/log"
+)
+
+// UserConn represents a connection to a user.
+type UserConn interface {
+ ReadRequest() ([]byte, error)
+ ReadRequestParams() map[string]string
+ WriteResponse(msg []byte) error
+ SupportsSubscriptions() bool
+ IsClosed() bool
+ GetHTTPRequest() *http.Request
+}
+
+// Represents a user's connection over HTTP.
+type userConnHTTP struct {
+ resp http.ResponseWriter
+ req *http.Request
+ logger gethlog.Logger
+}
+
+func NewUserConnHTTP(resp http.ResponseWriter, req *http.Request, logger gethlog.Logger) UserConn {
+ return &userConnHTTP{resp: resp, req: req, logger: logger}
+}
+
+func (h *userConnHTTP) ReadRequest() ([]byte, error) {
+ body, err := io.ReadAll(h.req.Body)
+ if err != nil {
+ return nil, fmt.Errorf("could not read request body: %w", err)
+ }
+ return body, nil
+}
+
+func (h *userConnHTTP) WriteResponse(msg []byte) error {
+ _, err := h.resp.Write(msg)
+ if err != nil {
+ return fmt.Errorf("could not write response: %w", err)
+ }
+ return nil
+}
+
+func (h *userConnHTTP) SupportsSubscriptions() bool {
+ return false
+}
+
+func (h *userConnHTTP) IsClosed() bool {
+ return false
+}
+
+func (h *userConnHTTP) ReadRequestParams() map[string]string {
+ return getQueryParams(h.req.URL.Query())
+}
+
+func (h *userConnHTTP) GetHTTPRequest() *http.Request {
+ return h.req
+}
+
+func getQueryParams(query url.Values) map[string]string {
+ params := make(map[string]string)
+ queryParams := query
+ for key, value := range queryParams {
+ params[key] = value[0]
+ }
+ return params
+}
diff --git a/tools/walletextension/httpapi/utils.go b/tools/walletextension/httpapi/utils.go
new file mode 100644
index 0000000000..cc7c50fe1a
--- /dev/null
+++ b/tools/walletextension/httpapi/utils.go
@@ -0,0 +1,43 @@
+package httpapi
+
+import (
+ "fmt"
+
+ gethlog "github.com/ethereum/go-ethereum/log"
+ "github.com/status-im/keycard-go/hexutils"
+ "github.com/ten-protocol/go-ten/go/common/log"
+ "github.com/ten-protocol/go-ten/tools/walletextension/common"
+)
+
+func getQueryParameter(params map[string]string, selectedParameter string) (string, error) {
+ value, exists := params[selectedParameter]
+ if !exists {
+ return "", fmt.Errorf("parameter '%s' is not in the query params", selectedParameter)
+ }
+
+ return value, nil
+}
+
+// getUserID returns userID from query params / url of the URL
+// it always first tries to get userID from a query parameter `u` or `token` (`u` parameter will become deprecated)
+// if it fails to get userID from a query parameter it tries to get it from the URL and it needs position as the second parameter
+func getUserID(conn UserConn) ([]byte, error) {
+ // try getting userID (`token`) from query parameters and return it if successful
+ userID, err := getQueryParameter(conn.ReadRequestParams(), common.EncryptedTokenQueryParameter)
+ if err == nil {
+ if len(userID) != common.MessageUserIDLen {
+ return nil, fmt.Errorf(fmt.Sprintf("wrong length of userID from URL. Got: %d, Expected: %d", len(userID), common.MessageUserIDLen))
+ }
+ return hexutils.HexToBytes(userID), err
+ }
+
+ return nil, fmt.Errorf("missing token field")
+}
+
+func handleError(conn UserConn, logger gethlog.Logger, err error) {
+ logger.Warn("error processing request - Forwarding response to user", log.ErrKey, err)
+
+ if err = conn.WriteResponse([]byte(err.Error())); err != nil {
+ logger.Error("unable to write response back", log.ErrKey, err)
+ }
+}
diff --git a/tools/walletextension/lib/client_lib.go b/tools/walletextension/lib/client_lib.go
index 42be5c4eb0..3e63a1a22e 100644
--- a/tools/walletextension/lib/client_lib.go
+++ b/tools/walletextension/lib/client_lib.go
@@ -9,6 +9,8 @@ import (
"net/http"
"strings"
+ "github.com/status-im/keycard-go/hexutils"
+
"github.com/ten-protocol/go-ten/integration"
gethcommon "github.com/ethereum/go-ethereum/common"
@@ -31,7 +33,11 @@ func NewTenGatewayLibrary(httpURL, wsURL string) *TGLib {
}
func (o *TGLib) UserID() string {
- return string(o.userID)
+ return hexutils.BytesToHex(o.userID)
+}
+
+func (o *TGLib) UserIDBytes() []byte {
+ return o.userID
}
func (o *TGLib) Join() error {
@@ -40,13 +46,13 @@ func (o *TGLib) Join() error {
if err != nil || statusCode != 200 {
return fmt.Errorf(fmt.Sprintf("Failed to get userID. Status code: %d, err: %s", statusCode, err))
}
- o.userID = userID
+ o.userID = hexutils.HexToBytes(string(userID))
return nil
}
func (o *TGLib) RegisterAccount(pk *ecdsa.PrivateKey, addr gethcommon.Address) error {
// create the registration message
- message, err := viewingkey.GenerateMessage(string(o.userID), integration.TenChainID, 1, viewingkey.EIP712Signature)
+ message, err := viewingkey.GenerateMessage(o.userID, integration.TenChainID, 1, viewingkey.EIP712Signature)
if err != nil {
return err
}
@@ -68,7 +74,7 @@ func (o *TGLib) RegisterAccount(pk *ecdsa.PrivateKey, addr gethcommon.Address) e
req, err := http.NewRequestWithContext(
context.Background(),
http.MethodPost,
- o.httpURL+"/v1/authenticate/?token="+string(o.userID),
+ o.httpURL+"/v1/authenticate/?token="+hexutils.BytesToHex(o.userID),
strings.NewReader(payload),
)
if err != nil {
@@ -96,7 +102,7 @@ func (o *TGLib) RegisterAccount(pk *ecdsa.PrivateKey, addr gethcommon.Address) e
func (o *TGLib) RegisterAccountPersonalSign(pk *ecdsa.PrivateKey, addr gethcommon.Address) error {
// create the registration message
- message, err := viewingkey.GenerateMessage(string(o.userID), integration.TenChainID, viewingkey.PersonalSignVersion, viewingkey.PersonalSign)
+ message, err := viewingkey.GenerateMessage(o.userID, integration.TenChainID, viewingkey.PersonalSignVersion, viewingkey.PersonalSign)
if err != nil {
return err
}
@@ -118,7 +124,7 @@ func (o *TGLib) RegisterAccountPersonalSign(pk *ecdsa.PrivateKey, addr gethcommo
req, err := http.NewRequestWithContext(
context.Background(),
http.MethodPost,
- o.httpURL+"/v1/authenticate/?token="+string(o.userID),
+ o.httpURL+"/v1/authenticate/?token="+hexutils.BytesToHex(o.userID),
strings.NewReader(payload),
)
if err != nil {
@@ -145,9 +151,9 @@ func (o *TGLib) RegisterAccountPersonalSign(pk *ecdsa.PrivateKey, addr gethcommo
}
func (o *TGLib) HTTP() string {
- return fmt.Sprintf("%s/v1/?token=%s", o.httpURL, o.userID)
+ return fmt.Sprintf("%s/v1/?token=%s", o.httpURL, hexutils.BytesToHex(o.userID))
}
func (o *TGLib) WS() string {
- return fmt.Sprintf("%s/v1/?token=%s", o.wsURL, o.userID)
+ return fmt.Sprintf("%s/v1/?token=%s", o.wsURL, hexutils.BytesToHex(o.userID))
}
diff --git a/tools/walletextension/main/cli.go b/tools/walletextension/main/cli.go
index b84b854d90..dbbe72a9a0 100644
--- a/tools/walletextension/main/cli.go
+++ b/tools/walletextension/main/cli.go
@@ -4,7 +4,7 @@ import (
"flag"
"fmt"
- "github.com/ten-protocol/go-ten/tools/walletextension/config"
+ wecommon "github.com/ten-protocol/go-ten/tools/walletextension/common"
)
const (
@@ -61,7 +61,7 @@ const (
storeIncomingTxsUsage = "Flag to enable storing incoming transactions in the database for debugging purposes. Default: true"
)
-func parseCLIArgs() config.Config {
+func parseCLIArgs() wecommon.Config {
walletExtensionHost := flag.String(walletExtensionHostName, walletExtensionHostDefault, walletExtensionHostUsage)
walletExtensionPort := flag.Int(walletExtensionPortName, walletExtensionPortDefault, walletExtensionPortUsage)
walletExtensionPortWS := flag.Int(walletExtensionPortWSName, walletExtensionPortWSDefault, walletExtensionPortWSUsage)
@@ -77,7 +77,7 @@ func parseCLIArgs() config.Config {
storeIncomingTransactions := flag.Bool(storeIncomingTxs, storeIncomingTxsDefault, storeIncomingTxsUsage)
flag.Parse()
- return config.Config{
+ return wecommon.Config{
WalletExtensionHost: *walletExtensionHost,
WalletExtensionPortHTTP: *walletExtensionPort,
WalletExtensionPortWS: *walletExtensionPortWS,
diff --git a/tools/walletextension/main/main.go b/tools/walletextension/main/main.go
index b909f43368..4b200968c0 100644
--- a/tools/walletextension/main/main.go
+++ b/tools/walletextension/main/main.go
@@ -7,9 +7,10 @@ import (
"os"
"time"
+ "github.com/ten-protocol/go-ten/tools/walletextension"
+
"github.com/ten-protocol/go-ten/go/common/log"
"github.com/ten-protocol/go-ten/tools/walletextension/common"
- "github.com/ten-protocol/go-ten/tools/walletextension/container"
gethlog "github.com/ethereum/go-ethereum/log"
)
@@ -58,7 +59,7 @@ func main() {
}
logger := log.New(log.WalletExtCmp, int(logLvl), config.LogPath)
- walletExtContainer := container.NewWalletExtensionContainerFromConfig(config, logger)
+ walletExtContainer := walletextension.NewContainerFromConfig(config, logger)
// Start the wallet extension.
err := walletExtContainer.Start()
diff --git a/tools/walletextension/rpcapi/blockchain_api.go b/tools/walletextension/rpcapi/blockchain_api.go
new file mode 100644
index 0000000000..e9e1d66e3f
--- /dev/null
+++ b/tools/walletextension/rpcapi/blockchain_api.go
@@ -0,0 +1,261 @@
+package rpcapi
+
+import (
+ "context"
+ "encoding/json"
+ "time"
+
+ "github.com/ethereum/go-ethereum/core/types"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ten-protocol/go-ten/go/common/gethapi"
+ "github.com/ten-protocol/go-ten/lib/gethfork/rpc"
+ wecommon "github.com/ten-protocol/go-ten/tools/walletextension/common"
+)
+
+type BlockChainAPI struct {
+ we *Services
+}
+
+func NewBlockChainAPI(we *Services) *BlockChainAPI {
+ return &BlockChainAPI{we}
+}
+
+func (api *BlockChainAPI) ChainId() *hexutil.Big { //nolint:stylecheck
+ chainID, _ := UnauthenticatedTenRPCCall[hexutil.Big](context.Background(), api.we, &CacheCfg{TTL: longCacheTTL}, "eth_chainId")
+ return chainID
+}
+
+func (api *BlockChainAPI) BlockNumber() hexutil.Uint64 {
+ nr, err := UnauthenticatedTenRPCCall[hexutil.Uint64](context.Background(), api.we, &CacheCfg{TTL: shortCacheTTL}, "eth_blockNumber")
+ if err != nil {
+ return hexutil.Uint64(0)
+ }
+ return *nr
+}
+
+func (api *BlockChainAPI) GetBalance(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Big, error) {
+ return ExecAuthRPC[hexutil.Big](
+ ctx,
+ api.we,
+ &ExecCfg{
+ cacheCfg: &CacheCfg{
+ TTLCallback: func() time.Duration {
+ return cacheTTLBlockNumberOrHash(blockNrOrHash)
+ },
+ },
+ account: &address,
+ tryUntilAuthorised: true, // the user can request the balance of a contract account
+ },
+ "eth_getBalance",
+ address,
+ blockNrOrHash,
+ )
+}
+
+// Result structs for GetProof
+type AccountResult struct {
+ Address common.Address `json:"address"`
+ AccountProof []string `json:"accountProof"`
+ Balance *hexutil.Big `json:"balance"`
+ CodeHash common.Hash `json:"codeHash"`
+ Nonce hexutil.Uint64 `json:"nonce"`
+ StorageHash common.Hash `json:"storageHash"`
+ StorageProof []StorageResult `json:"storageProof"`
+}
+
+type StorageResult struct {
+ Key string `json:"key"`
+ Value *hexutil.Big `json:"value"`
+ Proof []string `json:"proof"`
+}
+
+func (s *BlockChainAPI) GetProof(ctx context.Context, address common.Address, storageKeys []string, blockNrOrHash rpc.BlockNumberOrHash) (*AccountResult, error) {
+ return nil, rpcNotImplemented
+}
+
+func (api *BlockChainAPI) GetHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (map[string]interface{}, error) {
+ resp, err := UnauthenticatedTenRPCCall[map[string]interface{}](ctx, api.we, &CacheCfg{TTLCallback: func() time.Duration {
+ return cacheTTLBlockNumber(number)
+ }}, "eth_getHeaderByNumber", number)
+ if resp == nil {
+ return nil, err
+ }
+ return *resp, err
+}
+
+func (api *BlockChainAPI) GetHeaderByHash(ctx context.Context, hash common.Hash) map[string]interface{} {
+ resp, _ := UnauthenticatedTenRPCCall[map[string]interface{}](ctx, api.we, &CacheCfg{TTL: longCacheTTL}, "eth_getHeaderByHash", hash)
+ if resp == nil {
+ return nil
+ }
+ return *resp
+}
+
+func (api *BlockChainAPI) GetBlockByNumber(ctx context.Context, number rpc.BlockNumber, fullTx bool) (map[string]interface{}, error) {
+ resp, err := UnauthenticatedTenRPCCall[map[string]interface{}](
+ ctx,
+ api.we,
+ &CacheCfg{
+ TTLCallback: func() time.Duration {
+ return cacheTTLBlockNumber(number)
+ },
+ }, "eth_getBlockByNumber", number, fullTx)
+ if resp == nil {
+ return nil, err
+ }
+ return *resp, err
+}
+
+func (api *BlockChainAPI) GetBlockByHash(ctx context.Context, hash common.Hash, fullTx bool) (map[string]interface{}, error) {
+ resp, err := UnauthenticatedTenRPCCall[map[string]interface{}](ctx, api.we, &CacheCfg{TTL: longCacheTTL}, "eth_getBlockByHash", hash, fullTx)
+ if resp == nil {
+ return nil, err
+ }
+ return *resp, err
+}
+
+func (api *BlockChainAPI) GetCode(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error) {
+ // todo - must be authenticated
+ resp, err := UnauthenticatedTenRPCCall[hexutil.Bytes](
+ ctx,
+ api.we,
+ &CacheCfg{
+ TTLCallback: func() time.Duration {
+ return cacheTTLBlockNumberOrHash(blockNrOrHash)
+ },
+ },
+ "eth_getCode",
+ address,
+ blockNrOrHash,
+ )
+ if resp == nil {
+ return nil, err
+ }
+ return *resp, err
+}
+
+func (api *BlockChainAPI) GetStorageAt(ctx context.Context, address common.Address, hexKey string, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error) {
+ // GetStorageAt is repurposed to return the userID
+ if address.Hex() == wecommon.GetStorageAtUserIDRequestMethodName {
+ userID, err := extractUserID(ctx, api.we)
+ if err != nil {
+ return nil, err
+ }
+
+ _, err = getUser(userID, api.we)
+ if err != nil {
+ return nil, err
+ }
+ return userID, nil
+ }
+
+ resp, err := ExecAuthRPC[hexutil.Bytes](ctx, api.we, &ExecCfg{account: &address}, "eth_getStorageAt", address, hexKey, blockNrOrHash)
+ if resp == nil {
+ return nil, err
+ }
+ return *resp, err
+}
+
+func (s *BlockChainAPI) GetBlockReceipts(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) ([]map[string]interface{}, error) {
+ return nil, rpcNotImplemented
+}
+
+type OverrideAccount struct {
+ Nonce *hexutil.Uint64 `json:"nonce"`
+ Code *hexutil.Bytes `json:"code"`
+ Balance **hexutil.Big `json:"balance"`
+ State *map[common.Hash]common.Hash `json:"state"`
+ StateDiff *map[common.Hash]common.Hash `json:"stateDiff"`
+}
+type (
+ StateOverride map[common.Address]OverrideAccount
+ BlockOverrides struct {
+ Number *hexutil.Big
+ Difficulty *hexutil.Big
+ Time *hexutil.Uint64
+ GasLimit *hexutil.Uint64
+ Coinbase *common.Address
+ Random *common.Hash
+ BaseFee *hexutil.Big
+ }
+)
+
+func (api *BlockChainAPI) Call(ctx context.Context, args gethapi.TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *StateOverride, blockOverrides *BlockOverrides) (hexutil.Bytes, error) {
+ resp, err := ExecAuthRPC[hexutil.Bytes](ctx, api.we, &ExecCfg{
+ cacheCfg: &CacheCfg{
+ TTLCallback: func() time.Duration {
+ return cacheTTLBlockNumberOrHash(blockNrOrHash)
+ },
+ },
+ computeFromCallback: func(user *GWUser) *common.Address {
+ return searchFromAndData(user.GetAllAddresses(), args)
+ },
+ adjustArgs: func(acct *GWAccount) []any {
+ argsClone := populateFrom(acct, args)
+ return []any{argsClone, blockNrOrHash, overrides, blockOverrides}
+ },
+ tryAll: true,
+ }, "eth_call", args, blockNrOrHash, overrides, blockOverrides)
+ if resp == nil {
+ return nil, err
+ }
+ return *resp, err
+}
+
+func (api *BlockChainAPI) EstimateGas(ctx context.Context, args gethapi.TransactionArgs, blockNrOrHash *rpc.BlockNumberOrHash, overrides *StateOverride) (hexutil.Uint64, error) {
+ resp, err := ExecAuthRPC[hexutil.Uint64](ctx, api.we, &ExecCfg{
+ cacheCfg: &CacheCfg{
+ TTLCallback: func() time.Duration {
+ if blockNrOrHash != nil {
+ return cacheTTLBlockNumberOrHash(*blockNrOrHash)
+ }
+ return shortCacheTTL
+ },
+ },
+ computeFromCallback: func(user *GWUser) *common.Address {
+ return searchFromAndData(user.GetAllAddresses(), args)
+ },
+ adjustArgs: func(acct *GWAccount) []any {
+ argsClone := populateFrom(acct, args)
+ return []any{argsClone, blockNrOrHash, overrides}
+ },
+ // is this a security risk?
+ tryAll: true,
+ }, "eth_estimateGas", args, blockNrOrHash, overrides)
+ if resp == nil {
+ return 0, err
+ }
+ return *resp, err
+}
+
+func populateFrom(acct *GWAccount, args gethapi.TransactionArgs) gethapi.TransactionArgs {
+ // clone the args
+ argsClone := cloneArgs(args)
+ // set the from
+ if args.From == nil || args.From.Hex() == (common.Address{}).Hex() {
+ argsClone.From = acct.address
+ }
+ return argsClone
+}
+
+func cloneArgs(args gethapi.TransactionArgs) gethapi.TransactionArgs {
+ serialised, _ := json.Marshal(args)
+ var argsClone gethapi.TransactionArgs
+ err := json.Unmarshal(serialised, &argsClone)
+ if err != nil {
+ return gethapi.TransactionArgs{}
+ }
+ return argsClone
+}
+
+type accessListResult struct {
+ Accesslist *types.AccessList `json:"accessList"`
+ Error string `json:"error,omitempty"`
+ GasUsed hexutil.Uint64 `json:"gasUsed"`
+}
+
+func (s *BlockChainAPI) CreateAccessList(ctx context.Context, args gethapi.TransactionArgs, blockNrOrHash *rpc.BlockNumberOrHash) (*accessListResult, error) {
+ return nil, rpcNotImplemented
+}
diff --git a/tools/walletextension/rpcapi/debug_api.go b/tools/walletextension/rpcapi/debug_api.go
new file mode 100644
index 0000000000..fc0452611d
--- /dev/null
+++ b/tools/walletextension/rpcapi/debug_api.go
@@ -0,0 +1,55 @@
+package rpcapi
+
+import (
+ "context"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ten-protocol/go-ten/lib/gethfork/rpc"
+)
+
+type DebugAPI struct {
+ we *Services
+}
+
+func NewDebugAPI(we *Services) *DebugAPI {
+ return &DebugAPI{we}
+}
+
+func (api *DebugAPI) GetRawHeader(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error) {
+ return nil, rpcNotImplemented
+}
+
+func (api *DebugAPI) GetRawBlock(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error) {
+ return nil, rpcNotImplemented
+}
+
+func (api *DebugAPI) GetRawReceipts(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) ([]hexutil.Bytes, error) {
+ return nil, rpcNotImplemented
+}
+
+func (s *DebugAPI) GetRawTransaction(ctx context.Context, hash common.Hash) (hexutil.Bytes, error) {
+ return nil, rpcNotImplemented
+}
+
+func (api *DebugAPI) PrintBlock(ctx context.Context, number uint64) (string, error) {
+ return "", rpcNotImplemented
+}
+
+func (api *DebugAPI) ChaindbProperty(property string) (string, error) {
+ return "", rpcNotImplemented
+}
+
+func (api *DebugAPI) ChaindbCompact() error {
+ return rpcNotImplemented
+}
+
+func (api *DebugAPI) SetHead(number hexutil.Uint64) {
+ // not implemented
+}
+
+// EventLogRelevancy - specific to Ten - todo
+func (api *DebugAPI) EventLogRelevancy(_ context.Context, _ common.Hash) (interface{}, error) {
+ // todo
+ return nil, rpcNotImplemented
+}
diff --git a/tools/walletextension/subscriptions/deduplication_circular_buffer.go b/tools/walletextension/rpcapi/deduplication_circular_buffer.go
similarity index 98%
rename from tools/walletextension/subscriptions/deduplication_circular_buffer.go
rename to tools/walletextension/rpcapi/deduplication_circular_buffer.go
index 52a2e23cfe..89b2f2614c 100644
--- a/tools/walletextension/subscriptions/deduplication_circular_buffer.go
+++ b/tools/walletextension/rpcapi/deduplication_circular_buffer.go
@@ -1,4 +1,4 @@
-package subscriptions
+package rpcapi
import "github.com/ethereum/go-ethereum/common"
diff --git a/tools/walletextension/rpcapi/ethereum_api.go b/tools/walletextension/rpcapi/ethereum_api.go
new file mode 100644
index 0000000000..742c5c71c9
--- /dev/null
+++ b/tools/walletextension/rpcapi/ethereum_api.go
@@ -0,0 +1,52 @@
+package rpcapi
+
+import (
+ "context"
+ "time"
+
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/common/math"
+ "github.com/ten-protocol/go-ten/lib/gethfork/rpc"
+)
+
+type EthereumAPI struct {
+ we *Services
+}
+
+func NewEthereumAPI(we *Services,
+) *EthereumAPI {
+ return &EthereumAPI{we}
+}
+
+func (api *EthereumAPI) GasPrice(ctx context.Context) (*hexutil.Big, error) {
+ return UnauthenticatedTenRPCCall[hexutil.Big](ctx, api.we, &CacheCfg{TTL: shortCacheTTL}, "eth_gasPrice")
+}
+
+func (api *EthereumAPI) MaxPriorityFeePerGas(ctx context.Context) (*hexutil.Big, error) {
+ return UnauthenticatedTenRPCCall[hexutil.Big](ctx, api.we, &CacheCfg{TTL: shortCacheTTL}, "eth_maxPriorityFeePerGas")
+}
+
+type FeeHistoryResult struct {
+ OldestBlock *hexutil.Big `json:"oldestBlock"`
+ Reward [][]*hexutil.Big `json:"reward,omitempty"`
+ BaseFee []*hexutil.Big `json:"baseFeePerGas,omitempty"`
+ GasUsedRatio []float64 `json:"gasUsedRatio"`
+}
+
+func (api *EthereumAPI) FeeHistory(ctx context.Context, blockCount math.HexOrDecimal64, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (*FeeHistoryResult, error) {
+ return UnauthenticatedTenRPCCall[FeeHistoryResult](
+ ctx,
+ api.we,
+ &CacheCfg{TTLCallback: func() time.Duration {
+ return cacheTTLBlockNumber(lastBlock)
+ }},
+ "eth_feeHistory",
+ blockCount,
+ lastBlock,
+ rewardPercentiles,
+ )
+}
+
+func (api *EthereumAPI) Syncing() (interface{}, error) {
+ return nil, rpcNotImplemented
+}
diff --git a/tools/walletextension/rpcapi/filter_api.go b/tools/walletextension/rpcapi/filter_api.go
new file mode 100644
index 0000000000..247d235b05
--- /dev/null
+++ b/tools/walletextension/rpcapi/filter_api.go
@@ -0,0 +1,248 @@
+package rpcapi
+
+import (
+ "context"
+ "fmt"
+ "reflect"
+ "sync/atomic"
+ "time"
+
+ pool "github.com/jolestar/go-commons-pool/v2"
+ tenrpc "github.com/ten-protocol/go-ten/go/rpc"
+
+ gethcommon "github.com/ethereum/go-ethereum/common"
+ "github.com/ten-protocol/go-ten/go/common"
+
+ wecommon "github.com/ten-protocol/go-ten/tools/walletextension/common"
+
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ten-protocol/go-ten/lib/gethfork/rpc"
+)
+
+type FilterAPI struct {
+ we *Services
+}
+
+func NewFilterAPI(we *Services) *FilterAPI {
+ return &FilterAPI{we: we}
+}
+
+func (api *FilterAPI) NewPendingTransactionFilter(_ *bool) rpc.ID {
+ return "not supported"
+}
+
+func (api *FilterAPI) NewPendingTransactions(ctx context.Context, fullTx *bool) (*rpc.Subscription, error) {
+ return nil, fmt.Errorf("not supported")
+}
+
+func (api *FilterAPI) NewBlockFilter() rpc.ID {
+ // not implemented
+ return ""
+}
+
+func (api *FilterAPI) NewHeads(ctx context.Context) (*rpc.Subscription, error) {
+ return nil, rpcNotImplemented
+}
+
+func (api *FilterAPI) Logs(ctx context.Context, crit common.FilterCriteria) (*rpc.Subscription, error) {
+ audit(api.we, "start Logs subscription %v", crit)
+ subNotifier, user, err := getUserAndNotifier(ctx, api)
+ if err != nil {
+ return nil, err
+ }
+
+ // determine the accounts to use for the backend subscriptions
+ candidateAddresses := user.GetAllAddresses()
+ if len(candidateAddresses) > 1 {
+ candidateAddresses = searchForAddressInFilterCriteria(crit, user.GetAllAddresses())
+ // when we can't determine which addresses to use based on the criteria, use all of them
+ if len(candidateAddresses) == 0 {
+ candidateAddresses = user.GetAllAddresses()
+ }
+ }
+
+ inputChannels := make([]chan common.IDAndLog, 0)
+ backendSubscriptions := make([]*rpc.ClientSubscription, 0)
+ connections := make([]*tenrpc.EncRPCClient, 0)
+ for _, address := range candidateAddresses {
+ rpcWSClient, err := connectWS(user.accounts[*address], api.we.Logger())
+ if err != nil {
+ return nil, err
+ }
+ connections = append(connections, rpcWSClient)
+
+ inCh := make(chan common.IDAndLog)
+ backendSubscription, err := rpcWSClient.Subscribe(ctx, nil, "eth", inCh, "logs", crit)
+ if err != nil {
+ fmt.Printf("could not connect to backend %s", err)
+ return nil, err
+ }
+
+ inputChannels = append(inputChannels, inCh)
+ backendSubscriptions = append(backendSubscriptions, backendSubscription)
+ }
+
+ dedupeBuffer := NewCircularBuffer(wecommon.DeduplicationBufferSize)
+ subscription := subNotifier.CreateSubscription()
+
+ unsubscribed := atomic.Bool{}
+ go forwardAndDedupe(inputChannels, backendSubscriptions, subscription, subNotifier, &unsubscribed, func(data common.IDAndLog) *types.Log {
+ uniqueLogKey := LogKey{
+ BlockHash: data.Log.BlockHash,
+ TxHash: data.Log.TxHash,
+ Index: data.Log.Index,
+ }
+
+ if !dedupeBuffer.Contains(uniqueLogKey) {
+ dedupeBuffer.Push(uniqueLogKey)
+ return data.Log
+ }
+ return nil
+ })
+
+ go handleUnsubscribe(subscription, backendSubscriptions, connections, api.we.rpcWSConnPool, &unsubscribed)
+
+ return subscription, err
+}
+
+func getUserAndNotifier(ctx context.Context, api *FilterAPI) (*rpc.Notifier, *GWUser, error) {
+ subNotifier, supported := rpc.NotifierFromContext(ctx)
+ if !supported {
+ return nil, nil, fmt.Errorf("creation of subscriptions is not supported")
+ }
+
+ // todo - we might want to allow access to public logs
+ if len(subNotifier.UserID) == 0 {
+ return nil, nil, fmt.Errorf("illegal access")
+ }
+
+ user, err := getUser(subNotifier.UserID, api.we)
+ if err != nil {
+ return nil, nil, fmt.Errorf("illegal access: %s, %w", subNotifier.UserID, err)
+ }
+ return subNotifier, user, nil
+}
+
+func searchForAddressInFilterCriteria(filterCriteria common.FilterCriteria, possibleAddresses []*gethcommon.Address) []*gethcommon.Address {
+ result := make([]*gethcommon.Address, 0)
+ addrMap := toMap(possibleAddresses)
+ for _, topicCondition := range filterCriteria.Topics {
+ for _, topic := range topicCondition {
+ potentialAddr := common.ExtractPotentialAddress(topic)
+ if potentialAddr != nil && addrMap[*potentialAddr] != nil {
+ result = append(result, potentialAddr)
+ }
+ }
+ }
+ return result
+}
+
+// forwardAndDedupe - reads messages from the input channels, and forwards them to the notifier only if they are new
+func forwardAndDedupe[R any, T any](inputChannels []chan R, _ []*rpc.ClientSubscription, outSub *rpc.Subscription, notifier *rpc.Notifier, unsubscribed *atomic.Bool, toForward func(elem R) *T) {
+ inputCases := make([]reflect.SelectCase, len(inputChannels)+1)
+
+ // create a ticker to handle cleanup
+ inputCases[0] = reflect.SelectCase{
+ Dir: reflect.SelectRecv,
+ Chan: reflect.ValueOf(time.NewTicker(10 * time.Second).C),
+ }
+
+ // create a select "case" for each input channel
+ for i, ch := range inputChannels {
+ inputCases[i+1] = reflect.SelectCase{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(ch)}
+ }
+
+ unclosedInputChannels := len(inputCases)
+ for unclosedInputChannels > 0 {
+ chosen, value, ok := reflect.Select(inputCases)
+ if !ok {
+ // The chosen channel has been closed, so zero out the channel to disable the case
+ inputCases[chosen].Chan = reflect.ValueOf(nil)
+ unclosedInputChannels--
+ continue
+ }
+
+ switch v := value.Interface().(type) {
+ case time.Time:
+ // exit the loop to avoid a goroutine loop
+ if unsubscribed.Load() {
+ return
+ }
+ case R:
+ valueToSubmit := toForward(v)
+ if valueToSubmit != nil {
+ err := notifier.Notify(outSub.ID, *valueToSubmit)
+ if err != nil {
+ return
+ }
+ }
+ default:
+ // unexpected element received
+ continue
+ }
+ }
+}
+
+func handleUnsubscribe(connectionSub *rpc.Subscription, backendSubscriptions []*rpc.ClientSubscription, connections []*tenrpc.EncRPCClient, p *pool.ObjectPool, unsubscribed *atomic.Bool) {
+ <-connectionSub.Err()
+ unsubscribed.Store(true)
+ for _, backendSub := range backendSubscriptions {
+ backendSub.Unsubscribe()
+ }
+ for _, connection := range connections {
+ _ = returnConn(p, connection)
+ }
+}
+
+func (api *FilterAPI) NewFilter(crit common.FilterCriteria) (rpc.ID, error) {
+ return rpc.NewID(), rpcNotImplemented
+}
+
+func (api *FilterAPI) GetLogs(ctx context.Context, crit common.FilterCriteria) ([]*types.Log, error) {
+ logs, err := ExecAuthRPC[[]*types.Log](
+ ctx,
+ api.we,
+ &ExecCfg{
+ cacheCfg: &CacheCfg{
+ TTLCallback: func() time.Duration {
+ // when the toBlock is not specified, the request is open-ended
+ if crit.ToBlock != nil && crit.ToBlock.Int64() > 0 {
+ return longCacheTTL
+ }
+ return shortCacheTTL
+ },
+ },
+ tryUntilAuthorised: true,
+ adjustArgs: func(acct *GWAccount) []any {
+ // convert to something serializable
+ return []any{common.FromCriteria(crit)}
+ },
+ },
+ "eth_getLogs",
+ crit,
+ )
+ if logs != nil {
+ return *logs, err
+ }
+ return nil, err
+}
+
+func (api *FilterAPI) UninstallFilter(id rpc.ID) bool {
+ // not implemented
+ return false
+}
+
+func (api *FilterAPI) GetFilterLogs(ctx context.Context, id rpc.ID) ([]*types.Log, error) {
+ //txRec, err := ExecAuthRPC[[]*types.Log](ctx, api.we, "GetFilterLogs", ExecCfg{account: args.From}, id)
+ //if txRec != nil {
+ // return *txRec, err
+ //}
+ //return common.Hash{}, err
+
+ // not implemented
+ return nil, nil
+}
+
+func (api *FilterAPI) GetFilterChanges(id rpc.ID) (interface{}, error) {
+ return nil, rpcNotImplemented
+}
diff --git a/tools/walletextension/rpcapi/from_tx_args.go b/tools/walletextension/rpcapi/from_tx_args.go
new file mode 100644
index 0000000000..996e0b667d
--- /dev/null
+++ b/tools/walletextension/rpcapi/from_tx_args.go
@@ -0,0 +1,66 @@
+package rpcapi
+
+import (
+ "strings"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/status-im/keycard-go/hexutils"
+ "github.com/ten-protocol/go-ten/go/common/gethapi"
+)
+
+func searchFromAndData(possibleAddresses []*common.Address, args gethapi.TransactionArgs) *common.Address {
+ if args.From != nil {
+ return args.From
+ }
+
+ if args.Data == nil {
+ return nil
+ }
+
+ // since the "from" field is not mandatory, we try to find a matching address in the data field
+ addressesMap := toMap(possibleAddresses)
+ return searchDataFieldForAccount(addressesMap, *args.Data)
+}
+
+func searchDataFieldForAccount(addressesMap map[common.Address]*common.Address, data []byte) *common.Address {
+ hexEncodedData := hexutils.BytesToHex(data)
+
+ // We check that the data field is long enough before removing the leading "0x" (1 bytes/2 chars) and the method ID
+ // (4 bytes/8 chars).
+ if len(hexEncodedData) < 10 {
+ return nil
+ }
+ hexEncodedData = hexEncodedData[10:]
+
+ // We split up the arguments in the `data` field.
+ var dataArgs []string
+ for i := 0; i < len(hexEncodedData); i += ethCallPaddedArgLen {
+ if i+ethCallPaddedArgLen > len(hexEncodedData) {
+ break
+ }
+ dataArgs = append(dataArgs, hexEncodedData[i:i+ethCallPaddedArgLen])
+ }
+
+ // We iterate over the arguments, looking for an argument that matches a viewing key address
+ for _, dataArg := range dataArgs {
+ // If the argument doesn't have the correct padding, it's not an address.
+ if !strings.HasPrefix(dataArg, ethCallAddrPadding) {
+ continue
+ }
+
+ maybeAddress := common.HexToAddress(dataArg[len(ethCallAddrPadding):])
+ if _, ok := addressesMap[maybeAddress]; ok {
+ return &maybeAddress
+ }
+ }
+
+ return nil
+}
+
+func toMap(possibleAddresses []*common.Address) map[common.Address]*common.Address {
+ addresses := map[common.Address]*common.Address{}
+ for i := range possibleAddresses {
+ addresses[*possibleAddresses[i]] = possibleAddresses[i]
+ }
+ return addresses
+}
diff --git a/tools/walletextension/rpcapi/gw_user.go b/tools/walletextension/rpcapi/gw_user.go
new file mode 100644
index 0000000000..abd65df0fa
--- /dev/null
+++ b/tools/walletextension/rpcapi/gw_user.go
@@ -0,0 +1,62 @@
+package rpcapi
+
+import (
+ "fmt"
+
+ "github.com/status-im/keycard-go/hexutils"
+ "github.com/ten-protocol/go-ten/go/common/viewingkey"
+
+ "github.com/ethereum/go-ethereum/common"
+)
+
+var userCacheKeyPrefix = []byte{0x0, 0x1, 0x2, 0x3}
+
+type GWAccount struct {
+ user *GWUser
+ address *common.Address
+ signature []byte
+ signatureType viewingkey.SignatureType
+}
+
+type GWUser struct {
+ userID []byte
+ services *Services
+ accounts map[common.Address]*GWAccount
+ userKey []byte
+}
+
+func (u GWUser) GetAllAddresses() []*common.Address {
+ accts := make([]*common.Address, 0)
+ for _, acc := range u.accounts {
+ accts = append(accts, acc.address)
+ }
+ return accts
+}
+
+func userCacheKey(userID []byte) []byte {
+ var key []byte
+ key = append(key, userCacheKeyPrefix...)
+ key = append(key, userID...)
+ return key
+}
+
+func getUser(userID []byte, s *Services) (*GWUser, error) {
+ return withCache(s.Cache, &CacheCfg{TTL: longCacheTTL}, userCacheKey(userID), func() (*GWUser, error) {
+ result := GWUser{userID: userID, services: s, accounts: map[common.Address]*GWAccount{}}
+ userPrivateKey, err := s.Storage.GetUserPrivateKey(userID)
+ if err != nil {
+ return nil, fmt.Errorf("user %s not found. %w", hexutils.BytesToHex(userID), err)
+ }
+ result.userKey = userPrivateKey
+ allAccounts, err := s.Storage.GetAccounts(userID)
+ if err != nil {
+ return nil, err
+ }
+
+ for _, account := range allAccounts {
+ address := common.BytesToAddress(account.AccountAddress)
+ result.accounts[address] = &GWAccount{user: &result, address: &address, signature: account.Signature, signatureType: viewingkey.SignatureType(uint8(account.SignatureType))}
+ }
+ return &result, nil
+ })
+}
diff --git a/tools/walletextension/rpcapi/transaction_api.go b/tools/walletextension/rpcapi/transaction_api.go
new file mode 100644
index 0000000000..537bdbc8f4
--- /dev/null
+++ b/tools/walletextension/rpcapi/transaction_api.go
@@ -0,0 +1,145 @@
+package rpcapi
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "time"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ten-protocol/go-ten/go/common/gethapi"
+ "github.com/ten-protocol/go-ten/go/enclave/rpc"
+ gethrpc "github.com/ten-protocol/go-ten/lib/gethfork/rpc"
+)
+
+type TransactionAPI struct {
+ we *Services
+}
+
+func NewTransactionAPI(we *Services) *TransactionAPI {
+ return &TransactionAPI{we}
+}
+
+func (s *TransactionAPI) GetBlockTransactionCountByNumber(ctx context.Context, blockNr gethrpc.BlockNumber) *hexutil.Uint {
+ count, err := UnauthenticatedTenRPCCall[hexutil.Uint](ctx, s.we, &CacheCfg{TTLCallback: func() time.Duration {
+ return cacheTTLBlockNumber(blockNr)
+ }}, "eth_getBlockTransactionCountByNumber", blockNr)
+ if err != nil {
+ return nil
+ }
+ return count
+}
+
+func (s *TransactionAPI) GetBlockTransactionCountByHash(ctx context.Context, blockHash common.Hash) *hexutil.Uint {
+ count, err := UnauthenticatedTenRPCCall[hexutil.Uint](ctx, s.we, &CacheCfg{TTL: longCacheTTL}, "eth_getBlockTransactionCountByHash", blockHash)
+ if err != nil {
+ return nil
+ }
+ return count
+}
+
+func (s *TransactionAPI) GetTransactionByBlockNumberAndIndex(ctx context.Context, blockNr gethrpc.BlockNumber, index hexutil.Uint) *rpc.RpcTransaction {
+ // not implemented
+ return nil
+}
+
+func (s *TransactionAPI) GetTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) *rpc.RpcTransaction {
+ // not implemented
+ return nil
+}
+
+func (s *TransactionAPI) GetRawTransactionByBlockNumberAndIndex(ctx context.Context, blockNr gethrpc.BlockNumber, index hexutil.Uint) hexutil.Bytes {
+ // not implemented
+ return nil
+}
+
+func (s *TransactionAPI) GetRawTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) hexutil.Bytes {
+ // not implemented
+ return nil
+}
+
+func (s *TransactionAPI) GetTransactionCount(ctx context.Context, address common.Address, blockNrOrHash gethrpc.BlockNumberOrHash) (*hexutil.Uint64, error) {
+ return ExecAuthRPC[hexutil.Uint64](ctx, s.we, &ExecCfg{account: &address}, "eth_getTransactionCount", address, blockNrOrHash)
+}
+
+func (s *TransactionAPI) GetTransactionByHash(ctx context.Context, hash common.Hash) (*rpc.RpcTransaction, error) {
+ return ExecAuthRPC[rpc.RpcTransaction](ctx, s.we, &ExecCfg{tryAll: true}, "eth_getTransactionByHash", hash)
+}
+
+func (s *TransactionAPI) GetRawTransactionByHash(ctx context.Context, hash common.Hash) (hexutil.Bytes, error) {
+ tx, err := ExecAuthRPC[hexutil.Bytes](ctx, s.we, &ExecCfg{tryAll: true}, "eth_getRawTransactionByHash", hash)
+ if tx != nil {
+ return *tx, err
+ }
+ return nil, err
+}
+
+func (s *TransactionAPI) GetTransactionReceipt(ctx context.Context, hash common.Hash) (map[string]interface{}, error) {
+ txRec, err := ExecAuthRPC[map[string]interface{}](ctx, s.we, &ExecCfg{tryUntilAuthorised: true}, "eth_getTransactionReceipt", hash)
+ if err != nil {
+ return nil, err
+ }
+ if txRec == nil {
+ return nil, err
+ }
+ return *txRec, err
+}
+
+func (s *TransactionAPI) SendTransaction(ctx context.Context, args gethapi.TransactionArgs) (common.Hash, error) {
+ txRec, err := ExecAuthRPC[common.Hash](ctx, s.we, &ExecCfg{account: args.From}, "eth_sendTransaction", args)
+ if err != nil {
+ return common.Hash{}, err
+ }
+ userIDBytes, _ := extractUserID(ctx, s.we)
+ if s.we.Config.StoreIncomingTxs && len(userIDBytes) > 10 {
+ tx, err := json.Marshal(args)
+ if err != nil {
+ s.we.Logger().Error("error marshalling transaction: %s", err)
+ return *txRec, nil
+ }
+ err = s.we.Storage.StoreTransaction(string(tx), userIDBytes)
+ if err != nil {
+ s.we.Logger().Error("error storing transaction in the database: %s", err)
+ return *txRec, nil
+ }
+ }
+ return *txRec, err
+}
+
+type SignTransactionResult struct {
+ Raw hexutil.Bytes `json:"raw"`
+ Tx *types.Transaction `json:"tx"`
+}
+
+func (s *TransactionAPI) FillTransaction(ctx context.Context, args gethapi.TransactionArgs) (*SignTransactionResult, error) {
+ return nil, rpcNotImplemented
+}
+
+func (s *TransactionAPI) SendRawTransaction(ctx context.Context, input hexutil.Bytes) (common.Hash, error) {
+ txRec, err := ExecAuthRPC[common.Hash](ctx, s.we, &ExecCfg{tryAll: true}, "eth_sendRawTransaction", input)
+ if err != nil {
+ return common.Hash{}, err
+ }
+ userIDBytes, err := extractUserID(ctx, s.we)
+ if s.we.Config.StoreIncomingTxs && len(userIDBytes) > 10 {
+ err = s.we.Storage.StoreTransaction(input.String(), userIDBytes)
+ if err != nil {
+ s.we.Logger().Error(fmt.Errorf("error storing transaction in the database: %w", err).Error())
+ }
+ }
+ return *txRec, err
+}
+
+func (s *TransactionAPI) PendingTransactions() ([]*rpc.RpcTransaction, error) {
+ return nil, rpcNotImplemented
+}
+
+func (s *TransactionAPI) Resend(ctx context.Context, sendArgs gethapi.TransactionArgs, gasPrice *hexutil.Big, gasLimit *hexutil.Uint64) (common.Hash, error) {
+ txRec, err := ExecAuthRPC[common.Hash](ctx, s.we, &ExecCfg{account: sendArgs.From}, "eth_resend", sendArgs, gasPrice, gasLimit)
+ if txRec != nil {
+ return *txRec, err
+ }
+ return common.Hash{}, err
+}
diff --git a/tools/walletextension/rpcapi/txpool_api.go b/tools/walletextension/rpcapi/txpool_api.go
new file mode 100644
index 0000000000..16ec3f3b76
--- /dev/null
+++ b/tools/walletextension/rpcapi/txpool_api.go
@@ -0,0 +1,35 @@
+package rpcapi
+
+import (
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ rpc2 "github.com/ten-protocol/go-ten/go/enclave/rpc"
+)
+
+type TxPoolAPI struct {
+ we *Services
+}
+
+func NewTxPoolAPI(we *Services) *TxPoolAPI {
+ return &TxPoolAPI{we}
+}
+
+func (s *TxPoolAPI) Content() map[string]map[string]map[string]*rpc2.RpcTransaction {
+ // not implemented
+ return nil
+}
+
+func (s *TxPoolAPI) ContentFrom(_ common.Address) map[string]map[string]*rpc2.RpcTransaction {
+ // not implemented
+ return nil
+}
+
+func (s *TxPoolAPI) Status() map[string]hexutil.Uint {
+ // not implemented
+ return nil
+}
+
+func (s *TxPoolAPI) Inspect() map[string]map[string]map[string]string {
+ // not implemented
+ return nil
+}
diff --git a/tools/walletextension/rpcapi/utils.go b/tools/walletextension/rpcapi/utils.go
new file mode 100644
index 0000000000..a0f24c1c74
--- /dev/null
+++ b/tools/walletextension/rpcapi/utils.go
@@ -0,0 +1,273 @@
+package rpcapi
+
+import (
+ "context"
+ "crypto/sha256"
+ "encoding/json"
+ "fmt"
+ "time"
+
+ gethlog "github.com/ethereum/go-ethereum/log"
+ pool "github.com/jolestar/go-commons-pool/v2"
+ tenrpc "github.com/ten-protocol/go-ten/go/rpc"
+ wecommon "github.com/ten-protocol/go-ten/tools/walletextension/common"
+
+ "github.com/ten-protocol/go-ten/go/common/viewingkey"
+
+ "github.com/ten-protocol/go-ten/lib/gethfork/rpc"
+
+ "github.com/status-im/keycard-go/hexutils"
+
+ "github.com/ten-protocol/go-ten/tools/walletextension/cache"
+
+ "github.com/ethereum/go-ethereum/common"
+)
+
+const (
+ ethCallPaddedArgLen = 64
+ ethCallAddrPadding = "000000000000000000000000"
+
+ notAuthorised = "not authorised"
+
+ longCacheTTL = 5 * time.Hour
+ shortCacheTTL = 100 * time.Millisecond
+)
+
+var rpcNotImplemented = fmt.Errorf("rpc endpoint not implemented")
+
+type ExecCfg struct {
+ account *common.Address
+ computeFromCallback func(user *GWUser) *common.Address
+ tryAll bool
+ tryUntilAuthorised bool
+ adjustArgs func(acct *GWAccount) []any
+ cacheCfg *CacheCfg
+}
+
+type CacheCfg struct {
+ // ResetWhenNewBlock bool todo
+ TTL time.Duration
+ // logic based on block
+ // todo - handle block in the future
+ TTLCallback func() time.Duration
+}
+
+func UnauthenticatedTenRPCCall[R any](ctx context.Context, w *Services, cfg *CacheCfg, method string, args ...any) (*R, error) {
+ audit(w, "RPC start method=%s args=%v", method, args)
+ requestStartTime := time.Now()
+ cacheArgs := []any{method}
+ cacheArgs = append(cacheArgs, args...)
+
+ res, err := withCache(w.Cache, cfg, generateCacheKey(cacheArgs), func() (*R, error) {
+ var resp *R
+ unauthedRPC, err := w.UnauthenticatedClient()
+ if err != nil {
+ return nil, err
+ }
+ if ctx == nil {
+ err = unauthedRPC.Call(&resp, method, args...)
+ } else {
+ err = unauthedRPC.CallContext(ctx, &resp, method, args...)
+ }
+ return resp, err
+ })
+ audit(w, "RPC call. method=%s args=%v result=%s error=%s time=%d", method, args, res, err, time.Since(requestStartTime).Milliseconds())
+ return res, err
+}
+
+func ExecAuthRPC[R any](ctx context.Context, w *Services, cfg *ExecCfg, method string, args ...any) (*R, error) {
+ audit(w, "RPC start method=%s args=%v", method, args)
+ requestStartTime := time.Now()
+ userID, err := extractUserID(ctx, w)
+ if err != nil {
+ return nil, err
+ }
+
+ user, err := getUser(userID, w)
+ if err != nil {
+ return nil, err
+ }
+
+ cacheArgs := []any{userID, method}
+ cacheArgs = append(cacheArgs, args...)
+
+ res, err := withCache(w.Cache, cfg.cacheCfg, generateCacheKey(cacheArgs), func() (*R, error) {
+ // determine candidate "from"
+ candidateAccts, err := getCandidateAccounts(user, w, cfg)
+ if err != nil {
+ return nil, err
+ }
+ if len(candidateAccts) == 0 {
+ return nil, fmt.Errorf("illegal access")
+ }
+
+ var rpcErr error
+ for i := range candidateAccts {
+ acct := candidateAccts[i]
+ result, err := withHTTPRPCConnection(w, acct, func(rpcClient *tenrpc.EncRPCClient) (*R, error) {
+ var result *R
+ adjustedArgs := args
+ if cfg.adjustArgs != nil {
+ adjustedArgs = cfg.adjustArgs(acct)
+ }
+ err := rpcClient.CallContext(ctx, &result, method, adjustedArgs...)
+ return result, err
+ })
+ if err != nil {
+ // for calls where we know the expected error we can return early
+ if cfg.tryUntilAuthorised && err.Error() != notAuthorised {
+ return nil, err
+ }
+ rpcErr = err
+ continue
+ }
+ return result, nil
+ }
+ return nil, rpcErr
+ })
+
+ audit(w, "RPC call. uid=%s, method=%s args=%v result=%s error=%s time=%d", hexutils.BytesToHex(userID), method, args, res, err, time.Since(requestStartTime).Milliseconds())
+ return res, err
+}
+
+func getCandidateAccounts(user *GWUser, _ *Services, cfg *ExecCfg) ([]*GWAccount, error) {
+ candidateAccts := make([]*GWAccount, 0)
+ // for users with multiple accounts try to determine a candidate account based on the available information
+ switch {
+ case cfg.account != nil:
+ acc := user.accounts[*cfg.account]
+ if acc != nil {
+ candidateAccts = append(candidateAccts, acc)
+ return candidateAccts, nil
+ }
+
+ case cfg.computeFromCallback != nil:
+ suggestedAddress := cfg.computeFromCallback(user)
+ if suggestedAddress != nil {
+ acc := user.accounts[*suggestedAddress]
+ if acc != nil {
+ candidateAccts = append(candidateAccts, acc)
+ return candidateAccts, nil
+ }
+ }
+ }
+
+ if cfg.tryAll || cfg.tryUntilAuthorised {
+ for _, acc := range user.accounts {
+ candidateAccts = append(candidateAccts, acc)
+ }
+ }
+
+ return candidateAccts, nil
+}
+
+func extractUserID(ctx context.Context, _ *Services) ([]byte, error) {
+ token, ok := ctx.Value(rpc.GWTokenKey{}).(string)
+ if !ok {
+ return nil, fmt.Errorf("invalid userid: %s", ctx.Value(rpc.GWTokenKey{}))
+ }
+ userID := common.FromHex(token)
+ if len(userID) != viewingkey.UserIDLength {
+ return nil, fmt.Errorf("invalid userid: %s", token)
+ }
+ return userID, nil
+}
+
+// generateCacheKey generates a cache key for the given method, encryptionToken and parameters
+// encryptionToken is used to generate a unique cache key for each user and empty string should be used for public data
+func generateCacheKey(params []any) []byte {
+ // Serialize parameters
+ rawKey, err := json.Marshal(params)
+ if err != nil {
+ return nil
+ }
+
+ // Optional: Apply hashing
+ hasher := sha256.New()
+ hasher.Write(rawKey)
+
+ return hasher.Sum(nil)
+}
+
+func withCache[R any](cache cache.Cache, cfg *CacheCfg, cacheKey []byte, onCacheMiss func() (*R, error)) (*R, error) {
+ if cfg == nil {
+ return onCacheMiss()
+ }
+
+ cacheTTL := cfg.TTL
+ if cfg.TTLCallback != nil {
+ cacheTTL = cfg.TTLCallback()
+ }
+ isCacheable := cacheTTL > 0
+
+ if isCacheable {
+ if cachedValue, ok := cache.Get(cacheKey); ok {
+ // cloning?
+ returnValue, ok := cachedValue.(*R)
+ if !ok {
+ return nil, fmt.Errorf("unexpected error. Invalid format cached. %v", cachedValue)
+ }
+ return returnValue, nil
+ }
+ }
+
+ result, err := onCacheMiss()
+
+ // cache only non-nil values
+ if isCacheable && err == nil && result != nil {
+ cache.Set(cacheKey, result, cacheTTL)
+ }
+
+ return result, err
+}
+
+func audit(services *Services, msg string, params ...any) {
+ if services.Config.VerboseFlag {
+ services.FileLogger.Info(fmt.Sprintf(msg, params...))
+ }
+}
+
+func cacheTTLBlockNumberOrHash(blockNrOrHash rpc.BlockNumberOrHash) time.Duration {
+ if blockNrOrHash.BlockNumber != nil && blockNrOrHash.BlockNumber.Int64() <= 0 {
+ return shortCacheTTL
+ }
+ return longCacheTTL
+}
+
+func cacheTTLBlockNumber(lastBlock rpc.BlockNumber) time.Duration {
+ if lastBlock > 0 {
+ return longCacheTTL
+ }
+ return shortCacheTTL
+}
+
+func connectWS(account *GWAccount, logger gethlog.Logger) (*tenrpc.EncRPCClient, error) {
+ return conn(account.user.services.rpcWSConnPool, account, logger)
+}
+
+func conn(p *pool.ObjectPool, account *GWAccount, logger gethlog.Logger) (*tenrpc.EncRPCClient, error) {
+ connectionObj, err := p.BorrowObject(context.Background())
+ if err != nil {
+ return nil, fmt.Errorf("cannot fetch rpc connection to backend node %w", err)
+ }
+ conn := connectionObj.(*rpc.Client)
+ encClient, err := wecommon.CreateEncClient(conn, account.address.Bytes(), account.user.userKey, account.signature, account.signatureType, logger)
+ if err != nil {
+ return nil, fmt.Errorf("error creating new client, %w", err)
+ }
+ return encClient, nil
+}
+
+func returnConn(p *pool.ObjectPool, conn *tenrpc.EncRPCClient) error {
+ c := conn.Client().(*tenrpc.NetworkClient).RpcClient
+ return p.ReturnObject(context.Background(), c)
+}
+
+func withHTTPRPCConnection[R any](w *Services, acct *GWAccount, execute func(*tenrpc.EncRPCClient) (*R, error)) (*R, error) {
+ rpcClient, err := conn(acct.user.services.rpcHTTPConnPool, acct, w.logger)
+ if err != nil {
+ return nil, fmt.Errorf("could not connect to backed. Cause: %w", err)
+ }
+ defer returnConn(w.rpcHTTPConnPool, rpcClient)
+ return execute(rpcClient)
+}
diff --git a/tools/walletextension/rpcapi/wallet_extension.go b/tools/walletextension/rpcapi/wallet_extension.go
new file mode 100644
index 0000000000..3b27bbe750
--- /dev/null
+++ b/tools/walletextension/rpcapi/wallet_extension.go
@@ -0,0 +1,247 @@
+package rpcapi
+
+import (
+ "bytes"
+ "context"
+ "encoding/hex"
+ "fmt"
+ "time"
+
+ pool "github.com/jolestar/go-commons-pool/v2"
+ gethrpc "github.com/ten-protocol/go-ten/lib/gethfork/rpc"
+
+ "github.com/status-im/keycard-go/hexutils"
+
+ "github.com/ten-protocol/go-ten/tools/walletextension/cache"
+
+ "github.com/ten-protocol/go-ten/go/obsclient"
+
+ gethcommon "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/crypto/ecies"
+ gethlog "github.com/ethereum/go-ethereum/log"
+ "github.com/ten-protocol/go-ten/go/common/stopcontrol"
+ "github.com/ten-protocol/go-ten/go/common/viewingkey"
+ "github.com/ten-protocol/go-ten/go/rpc"
+ "github.com/ten-protocol/go-ten/tools/walletextension/common"
+ "github.com/ten-protocol/go-ten/tools/walletextension/storage"
+)
+
+// Services handles the various business logic for the api endpoints
+type Services struct {
+ HostAddrHTTP string // The HTTP address on which the Ten host can be reached
+ HostAddrWS string // The WS address on which the Ten host can be reached
+ Storage storage.Storage
+ logger gethlog.Logger
+ FileLogger gethlog.Logger
+ stopControl *stopcontrol.StopControl
+ version string
+ tenClient *obsclient.ObsClient
+ Cache cache.Cache
+ // the OG maintains a connection pool of rpc connections to underlying nodes
+ rpcHTTPConnPool *pool.ObjectPool
+ rpcWSConnPool *pool.ObjectPool
+ Config *common.Config
+}
+
+func NewServices(hostAddrHTTP string, hostAddrWS string, storage storage.Storage, stopControl *stopcontrol.StopControl, version string, logger gethlog.Logger, config *common.Config) *Services {
+ rpcClient, err := rpc.NewNetworkClient(hostAddrHTTP)
+ if err != nil {
+ logger.Error(fmt.Errorf("could not create RPC client on %s. Cause: %w", hostAddrHTTP, err).Error())
+ panic(err)
+ }
+ newTenClient := obsclient.NewObsClient(rpcClient)
+ newFileLogger := common.NewFileLogger()
+ newGatewayCache, err := cache.NewCache(logger)
+ if err != nil {
+ logger.Error(fmt.Errorf("could not create cache. Cause: %w", err).Error())
+ panic(err)
+ }
+
+ factoryHTTP := pool.NewPooledObjectFactory(
+ func(context.Context) (interface{}, error) {
+ rpcClient, err := gethrpc.Dial(hostAddrHTTP)
+ if err != nil {
+ return nil, fmt.Errorf("could not create RPC client on %s. Cause: %w", hostAddrHTTP, err)
+ }
+ return rpcClient, nil
+ }, func(ctx context.Context, object *pool.PooledObject) error {
+ client := object.Object.(*gethrpc.Client)
+ client.Close()
+ return nil
+ }, nil, nil, nil)
+
+ factoryWS := pool.NewPooledObjectFactory(
+ func(context.Context) (interface{}, error) {
+ rpcClient, err := gethrpc.Dial(hostAddrWS)
+ if err != nil {
+ return nil, fmt.Errorf("could not create RPC client on %s. Cause: %w", hostAddrWS, err)
+ }
+ return rpcClient, nil
+ }, func(ctx context.Context, object *pool.PooledObject) error {
+ client := object.Object.(*gethrpc.Client)
+ client.Close()
+ return nil
+ }, nil, nil, nil)
+
+ cfg := pool.NewDefaultPoolConfig()
+ cfg.MaxTotal = 100
+ cfg.MaxTotal = 50
+
+ return &Services{
+ HostAddrHTTP: hostAddrHTTP,
+ HostAddrWS: hostAddrWS,
+ Storage: storage,
+ logger: logger,
+ FileLogger: newFileLogger,
+ stopControl: stopControl,
+ version: version,
+ tenClient: newTenClient,
+ Cache: newGatewayCache,
+ rpcHTTPConnPool: pool.NewObjectPool(context.Background(), factoryHTTP, cfg),
+ rpcWSConnPool: pool.NewObjectPool(context.Background(), factoryWS, cfg),
+ Config: config,
+ }
+}
+
+// IsStopping returns whether the WE is stopping
+func (w *Services) IsStopping() bool {
+ return w.stopControl.IsStopping()
+}
+
+// Logger returns the WE set logger
+func (w *Services) Logger() gethlog.Logger {
+ return w.logger
+}
+
+// GenerateAndStoreNewUser generates new key-pair and userID, stores it in the database and returns hex encoded userID and error
+func (w *Services) GenerateAndStoreNewUser() ([]byte, error) {
+ requestStartTime := time.Now()
+ // generate new key-pair
+ viewingKeyPrivate, err := crypto.GenerateKey()
+ viewingPrivateKeyEcies := ecies.ImportECDSA(viewingKeyPrivate)
+ if err != nil {
+ w.Logger().Error(fmt.Sprintf("could not generate new keypair: %s", err))
+ return nil, err
+ }
+
+ // create UserID and store it in the database with the private key
+ userID := viewingkey.CalculateUserID(common.PrivateKeyToCompressedPubKey(viewingPrivateKeyEcies))
+ err = w.Storage.AddUser(userID, crypto.FromECDSA(viewingPrivateKeyEcies.ExportECDSA()))
+ if err != nil {
+ w.Logger().Error(fmt.Sprintf("failed to save user to the database: %s", err))
+ return nil, err
+ }
+
+ requestEndTime := time.Now()
+ duration := requestEndTime.Sub(requestStartTime)
+ audit(w, "Storing new userID: %s, duration: %d ", hexutils.BytesToHex(userID), duration.Milliseconds())
+ return userID, nil
+}
+
+// AddAddressToUser checks if a message is in correct format and if signature is valid. If all checks pass we save address and signature against userID
+func (w *Services) AddAddressToUser(userID []byte, address string, signature []byte, signatureType viewingkey.SignatureType) error {
+ requestStartTime := time.Now()
+ addressFromMessage := gethcommon.HexToAddress(address)
+ // check if a message was signed by the correct address and if the signature is valid
+ recoveredAddress, err := viewingkey.CheckSignature(userID, signature, int64(w.Config.TenChainID), signatureType)
+ if err != nil {
+ return fmt.Errorf("signature is not valid: %w", err)
+ }
+
+ if recoveredAddress.Hex() != addressFromMessage.Hex() {
+ return fmt.Errorf("invalid request. Signature doesn't match address")
+ }
+
+ // register the account for that viewing key
+ err = w.Storage.AddAccount(userID, addressFromMessage.Bytes(), signature, signatureType)
+ if err != nil {
+ w.Logger().Error(fmt.Errorf("error while storing account (%s) for user (%s): %w", addressFromMessage.Hex(), userID, err).Error())
+ return err
+ }
+
+ w.Cache.Remove(userCacheKey(userID))
+ audit(w, "Storing new address for user: %s, address: %s, duration: %d ", hexutils.BytesToHex(userID), address, time.Since(requestStartTime).Milliseconds())
+ return nil
+}
+
+// UserHasAccount checks if provided account exist in the database for given userID
+func (w *Services) UserHasAccount(userID []byte, address string) (bool, error) {
+ audit(w, "Checking if user has account: %s, address: %s", hexutils.BytesToHex(userID), address)
+ addressBytes, err := hex.DecodeString(address[2:]) // remove 0x prefix from address
+ if err != nil {
+ w.Logger().Error(fmt.Errorf("error decoding string (%s), %w", address[2:], err).Error())
+ return false, err
+ }
+
+ // todo - this can be optimised and done in the database if we will have users with large number of accounts
+ // get all the accounts for the selected user
+ accounts, err := w.Storage.GetAccounts(userID)
+ if err != nil {
+ w.Logger().Error(fmt.Errorf("error getting accounts for user (%s), %w", userID, err).Error())
+ return false, err
+ }
+
+ // check if any of the account matches given account
+ found := false
+ for _, account := range accounts {
+ if bytes.Equal(account.AccountAddress, addressBytes) {
+ found = true
+ }
+ }
+ return found, nil
+}
+
+// DeleteUser deletes user and accounts associated with user from the database for given userID
+func (w *Services) DeleteUser(userID []byte) error {
+ audit(w, "Deleting user: %s", hexutils.BytesToHex(userID))
+
+ err := w.Storage.DeleteUser(userID)
+ if err != nil {
+ w.Logger().Error(fmt.Errorf("error deleting user (%s), %w", userID, err).Error())
+ return err
+ }
+ w.Cache.Remove(userCacheKey(userID))
+ return nil
+}
+
+func (w *Services) UserExists(userID []byte) bool {
+ audit(w, "Checking if user exists: %s", userID)
+ // Check if user exists and don't log error if user doesn't exist, because we expect this to happen in case of
+ // user revoking encryption token or using different testnet.
+ // todo add a counter here in the future
+ key, err := w.Storage.GetUserPrivateKey(userID)
+ if err != nil {
+ return false
+ }
+
+ return len(key) > 0
+}
+
+func (w *Services) Version() string {
+ return w.version
+}
+
+func (w *Services) GetTenNodeHealthStatus() (bool, error) {
+ return w.tenClient.Health()
+}
+
+func (w *Services) UnauthenticatedClient() (rpc.Client, error) {
+ return rpc.NewNetworkClient(w.HostAddrHTTP)
+}
+
+func (w *Services) GenerateUserMessageToSign(encryptionToken []byte, formatsSlice []string) (string, error) {
+ // Check if the formats are valid
+ for _, format := range formatsSlice {
+ if _, exists := viewingkey.SignatureTypeMap[format]; !exists {
+ return "", fmt.Errorf("invalid format: %s", format)
+ }
+ }
+
+ messageFormat := viewingkey.GetBestFormat(formatsSlice)
+ message, err := viewingkey.GenerateMessage(encryptionToken, int64(w.Config.TenChainID), viewingkey.PersonalSignVersion, messageFormat)
+ if err != nil {
+ return "", fmt.Errorf("error generating message: %w", err)
+ }
+ return string(message), nil
+}
diff --git a/tools/walletextension/subscriptions/subscriptions.go b/tools/walletextension/subscriptions/subscriptions.go
deleted file mode 100644
index 9405a524ce..0000000000
--- a/tools/walletextension/subscriptions/subscriptions.go
+++ /dev/null
@@ -1,200 +0,0 @@
-package subscriptions
-
-import (
- "context"
- "encoding/json"
- "fmt"
- "sync"
- "time"
-
- "github.com/ethereum/go-ethereum/eth/filters"
-
- "github.com/go-kit/kit/transport/http/jsonrpc"
-
- gethlog "github.com/ethereum/go-ethereum/log"
- "github.com/ten-protocol/go-ten/go/common"
- "github.com/ten-protocol/go-ten/go/common/log"
- "github.com/ten-protocol/go-ten/go/rpc"
- gethrpc "github.com/ten-protocol/go-ten/lib/gethfork/rpc"
- wecommon "github.com/ten-protocol/go-ten/tools/walletextension/common"
- "github.com/ten-protocol/go-ten/tools/walletextension/userconn"
-)
-
-type SubscriptionManager struct {
- subscriptionMappings map[string][]*gethrpc.ClientSubscription
- logger gethlog.Logger
- mu sync.Mutex
-}
-
-func New(logger gethlog.Logger) *SubscriptionManager {
- return &SubscriptionManager{
- subscriptionMappings: make(map[string][]*gethrpc.ClientSubscription),
- logger: logger,
- }
-}
-
-// HandleNewSubscriptions subscribes to an event with all the clients provided.
-// Doing this is necessary because we have relevancy rule, and we want to subscribe sometimes with all clients to get all the events
-func (sm *SubscriptionManager) HandleNewSubscriptions(clients []rpc.Client, criteria filters.FilterCriteria, resp *interface{}, userConn userconn.UserConn) error {
- sm.logger.Info(fmt.Sprintf("Subscribing to event %s with %d clients", criteria, len(clients)))
-
- // create subscriptionID which will enable user to unsubscribe from all subscriptions
- userSubscriptionID := gethrpc.NewID()
-
- // create a common channel for subscriptions from all accounts
- funnelMultipleAccountsChan := make(chan common.IDAndLog)
-
- // read from a multiple accounts channel and write results to userConn
- go readFromChannelAndWriteToUserConn(funnelMultipleAccountsChan, userConn, userSubscriptionID, sm.logger)
-
- // iterate over all clients and subscribe for each of them
- for _, client := range clients {
- subscription, err := client.Subscribe(context.Background(), resp, rpc.SubscribeNamespace, funnelMultipleAccountsChan, rpc.SubscriptionTypeLogs, criteria)
- if err != nil {
- return fmt.Errorf("could not subscrbie for logs with params %v. Cause: %w", criteria, err)
- }
- sm.UpdateSubscriptionMapping(string(userSubscriptionID), subscription)
-
- // We periodically check if the websocket is closed, and terminate the subscription.
- // TODO: Check if it will be much more efficient to create just one go routine for all clients together
- go sm.checkIfUserConnIsClosedAndUnsubscribe(userConn, subscription, string(userSubscriptionID))
- }
-
- // We return subscriptionID with resp interface. We want to use userSubscriptionID to allow unsubscribing
- *resp = userSubscriptionID
- return nil
-}
-
-func readFromChannelAndWriteToUserConn(channel chan common.IDAndLog, userConn userconn.UserConn, userSubscriptionID gethrpc.ID, logger gethlog.Logger) {
- buffer := NewCircularBuffer(wecommon.DeduplicationBufferSize)
- for data := range channel {
- // create unique identifier for current log
- uniqueLogKey := LogKey{
- BlockHash: data.Log.BlockHash,
- TxHash: data.Log.TxHash,
- Index: data.Log.Index,
- }
-
- // check if the current event is a duplicate (and skip it if it is)
- if buffer.Contains(uniqueLogKey) {
- continue
- }
-
- jsonResponse, err := prepareLogResponse(data, userSubscriptionID)
- if err != nil {
- logger.Error("could not marshal log response to JSON on subscription.", log.SubIDKey, data.SubID, log.ErrKey, err)
- continue
- }
-
- // the current log is unique, and we want to add it to our buffer and proceed with forwarding to the user
- buffer.Push(uniqueLogKey)
-
- logger.Trace(fmt.Sprintf("Forwarding log from Obscuro node: %s", jsonResponse), log.SubIDKey, data.SubID)
- err = userConn.WriteResponse(jsonResponse)
- if err != nil {
- logger.Error("could not write the JSON log to the websocket on subscription %", log.SubIDKey, data.SubID, log.ErrKey, err)
- continue
- }
- }
-}
-
-func (sm *SubscriptionManager) unsubscribeAndRemove(userSubscriptionID string, subscription *gethrpc.ClientSubscription) {
- sm.mu.Lock()
- defer sm.mu.Unlock()
-
- subscription.Unsubscribe()
-
- subscriptions, exists := sm.subscriptionMappings[userSubscriptionID]
- if !exists {
- sm.logger.Error("subscription that needs to be removed is not present in subscriptionMappings for userSubscriptionID: %s", userSubscriptionID)
- return
- }
-
- for i, s := range subscriptions {
- if s != subscription {
- continue
- }
-
- // Remove the subscription from the slice
- lastIndex := len(subscriptions) - 1
- subscriptions[i] = subscriptions[lastIndex]
- subscriptions = subscriptions[:lastIndex]
-
- // If the slice is empty, delete the key from the map
- if len(subscriptions) == 0 {
- delete(sm.subscriptionMappings, userSubscriptionID)
- } else {
- sm.subscriptionMappings[userSubscriptionID] = subscriptions
- }
- break
- }
-}
-
-func (sm *SubscriptionManager) checkIfUserConnIsClosedAndUnsubscribe(userConn userconn.UserConn, subscription *gethrpc.ClientSubscription, userSubscriptionID string) {
- for !userConn.IsClosed() {
- time.Sleep(100 * time.Millisecond)
- }
-
- sm.unsubscribeAndRemove(userSubscriptionID, subscription)
-}
-
-func (sm *SubscriptionManager) UpdateSubscriptionMapping(userSubscriptionID string, subscription *gethrpc.ClientSubscription) {
- // Ensure there is no concurrent map writes
- sm.mu.Lock()
- defer sm.mu.Unlock()
-
- // Check if the userSubscriptionID already exists in the map
- subscriptions, exists := sm.subscriptionMappings[userSubscriptionID]
-
- // If it doesn't exist, create a new slice for it
- if !exists {
- subscriptions = []*gethrpc.ClientSubscription{}
- }
-
- // Check if the subscription is already in the slice, if not, add it
- subscriptionExists := false
- for _, sub := range subscriptions {
- if sub == subscription {
- subscriptionExists = true
- break
- }
- }
-
- if !subscriptionExists {
- sm.subscriptionMappings[userSubscriptionID] = append(subscriptions, subscription)
- }
-}
-
-// Formats the log to be sent as an Eth JSON-RPC response.
-func prepareLogResponse(idAndLog common.IDAndLog, userSubscriptionID gethrpc.ID) ([]byte, error) {
- paramsMap := make(map[string]interface{})
- paramsMap[wecommon.JSONKeySubscription] = userSubscriptionID
- paramsMap[wecommon.JSONKeyResult] = idAndLog.Log
-
- respMap := make(map[string]interface{})
- respMap[wecommon.JSONKeyRPCVersion] = jsonrpc.Version
- respMap[wecommon.JSONKeyMethod] = wecommon.MethodEthSubscription
- respMap[wecommon.JSONKeyParams] = paramsMap
-
- jsonResponse, err := json.Marshal(respMap)
- if err != nil {
- return nil, fmt.Errorf("could not marshal log response to JSON. Cause: %w", err)
- }
- return jsonResponse, nil
-}
-
-func (sm *SubscriptionManager) HandleUnsubscribe(userSubscriptionID string, rpcResp *interface{}) {
- subscriptions, exists := sm.subscriptionMappings[userSubscriptionID]
- if !exists {
- *rpcResp = false
- return
- }
-
- sm.mu.Lock()
- defer sm.mu.Unlock()
- for _, sub := range subscriptions {
- sub.Unsubscribe()
- }
- delete(sm.subscriptionMappings, userSubscriptionID)
- *rpcResp = true
-}
diff --git a/tools/walletextension/useraccountmanager/user_account_manager.go b/tools/walletextension/useraccountmanager/user_account_manager.go
deleted file mode 100644
index 664c2cd994..0000000000
--- a/tools/walletextension/useraccountmanager/user_account_manager.go
+++ /dev/null
@@ -1,135 +0,0 @@
-package useraccountmanager
-
-import (
- "encoding/hex"
- "fmt"
- "sync"
-
- "github.com/ten-protocol/go-ten/go/common/viewingkey"
-
- "github.com/ethereum/go-ethereum/common"
- gethlog "github.com/ethereum/go-ethereum/log"
- "github.com/ten-protocol/go-ten/go/rpc"
- "github.com/ten-protocol/go-ten/tools/walletextension/accountmanager"
- wecommon "github.com/ten-protocol/go-ten/tools/walletextension/common"
- "github.com/ten-protocol/go-ten/tools/walletextension/storage"
-)
-
-// UserAccountManager is a struct that stores one account manager per user and other required data
-type UserAccountManager struct {
- userAccountManager map[string]*accountmanager.AccountManager
- unauthenticatedClient rpc.Client
- storage storage.Storage
- hostRPCBinAddrHTTP string
- hostRPCBinAddrWS string
- logger gethlog.Logger
- mu sync.Mutex
-}
-
-func NewUserAccountManager(unauthenticatedClient rpc.Client, logger gethlog.Logger, storage storage.Storage, hostRPCBindAddrHTTP string, hostRPCBindAddrWS string) UserAccountManager {
- return UserAccountManager{
- userAccountManager: make(map[string]*accountmanager.AccountManager),
- unauthenticatedClient: unauthenticatedClient,
- storage: storage,
- hostRPCBinAddrHTTP: hostRPCBindAddrHTTP,
- hostRPCBinAddrWS: hostRPCBindAddrWS,
- logger: logger,
- }
-}
-
-// AddAndReturnAccountManager adds new UserAccountManager if it doesn't exist and returns it, if UserAccountManager already exists for that user just return it
-func (m *UserAccountManager) AddAndReturnAccountManager(userID string) *accountmanager.AccountManager {
- m.mu.Lock()
- defer m.mu.Unlock()
- existingUserAccountManager, exists := m.userAccountManager[userID]
- if exists {
- return existingUserAccountManager
- }
- newAccountManager := accountmanager.NewAccountManager(userID, m.unauthenticatedClient, m.hostRPCBinAddrWS, m.storage, m.logger)
- m.userAccountManager[userID] = newAccountManager
- return newAccountManager
-}
-
-// GetUserAccountManager retrieves the UserAccountManager associated with the given userID.
-// it returns the UserAccountManager and nil error if one exists.
-// before returning it checks the database and creates all missing clients for that userID
-// (we are not loading all of them at startup to limit the number of established connections)
-// If a UserAccountManager does not exist for the userID, it returns nil and an error.
-func (m *UserAccountManager) GetUserAccountManager(userID string) (*accountmanager.AccountManager, error) {
- m.mu.Lock()
- defer m.mu.Unlock()
- userAccManager, exists := m.userAccountManager[userID]
- if !exists {
- return nil, fmt.Errorf("UserAccountManager doesn't exist for user: %s", userID)
- }
-
- // we have userAccountManager as expected.
- // now we need to create all clients that don't exist there yet
- addressesWithClients := userAccManager.GetAllAddressesWithClients()
-
- // get all addresses for current userID
- userIDbytes, err := hex.DecodeString(userID)
- if err != nil {
- return nil, err
- }
-
- // log that we don't have a storage, but still return existing userAccountManager
- // this should never happen, but is useful for tests
- if m.storage == nil {
- m.logger.Error("storage is nil in UserAccountManager")
- return userAccManager, nil
- }
-
- databaseAccounts, err := m.storage.GetAccounts(userIDbytes)
- if err != nil {
- return nil, err
- }
-
- userPrivateKey, err := m.storage.GetUserPrivateKey(userIDbytes)
- if err != nil {
- return nil, err
- }
-
- for _, account := range databaseAccounts {
- addressHexString := common.BytesToAddress(account.AccountAddress).Hex()
- // check if a client for the current address already exists (and skip it if it does)
- if addressAlreadyExists(addressHexString, addressesWithClients) {
- continue
- }
-
- // create a new client
- encClient, err := wecommon.CreateEncClient(m.hostRPCBinAddrWS, account.AccountAddress, userPrivateKey, account.Signature, viewingkey.SignatureType(account.SignatureType), m.logger)
- if err != nil {
- m.logger.Error(fmt.Errorf("error creating new client, %w", err).Error())
- }
-
- // add a client to requested userAccountManager
- userAccManager.AddClient(common.BytesToAddress(account.AccountAddress), encClient)
- addressesWithClients = append(addressesWithClients, addressHexString)
- }
-
- return userAccManager, nil
-}
-
-// DeleteUserAccountManager removes the UserAccountManager associated with the given userID.
-// It returns an error if no UserAccountManager exists for that userID.
-func (m *UserAccountManager) DeleteUserAccountManager(userID string) error {
- m.mu.Lock()
- defer m.mu.Unlock()
- _, exists := m.userAccountManager[userID]
- if !exists {
- return fmt.Errorf("no UserAccountManager exists for userID %s", userID)
- }
- delete(m.userAccountManager, userID)
- return nil
-}
-
-// addressAlreadyExists is a helper function to check if an address is already present in a list of existing addresses
-func addressAlreadyExists(str string, list []string) bool {
- for _, v := range list {
- if v == str {
- return true
- }
- }
- return false
-}
diff --git a/tools/walletextension/useraccountmanager/user_account_manager_test.go b/tools/walletextension/useraccountmanager/user_account_manager_test.go
deleted file mode 100644
index 38c94ed85d..0000000000
--- a/tools/walletextension/useraccountmanager/user_account_manager_test.go
+++ /dev/null
@@ -1,76 +0,0 @@
-package useraccountmanager
-
-import (
- "testing"
-
- "github.com/ethereum/go-ethereum/log"
- "github.com/ten-protocol/go-ten/go/rpc"
-)
-
-func TestAddingAndGettingUserAccountManagers(t *testing.T) {
- unauthedClient, _ := rpc.NewNetworkClient("ws://test")
- userAccountManager := NewUserAccountManager(unauthedClient, log.New(), nil, "http://test", "ws://test")
- userID1 := "4A6F686E20446F65"
- userID2 := "7A65746F65A2676F"
-
- // Test adding and getting account manager for userID1
- userAccountManager.AddAndReturnAccountManager(userID1)
- accManager1, err := userAccountManager.GetUserAccountManager(userID1)
- if err != nil {
- t.Fatal(err)
- }
- // We should get error if we try to get Account manager for User2
- _, err = userAccountManager.GetUserAccountManager(userID2)
- if err == nil {
- t.Fatal("expecting error when trying to get AccountManager for user that doesn't exist.")
- }
-
- // After trying to add new AccountManager for the same user we should get the same instance (not overriding old one)
- userAccountManager.AddAndReturnAccountManager(userID1)
- accManager1New, err := userAccountManager.GetUserAccountManager(userID1)
- if err != nil {
- t.Fatal(err)
- }
-
- if accManager1 != accManager1New {
- t.Fatal("AccountManagers are not the same after adding new account manager for the same userID")
- }
-
- // We get a new instance of AccountManager when we add it for a new user
- userAccountManager.AddAndReturnAccountManager(userID2)
- accManager2, err := userAccountManager.GetUserAccountManager(userID2)
- if err != nil {
- t.Fatal(err)
- }
-
- if accManager1 == accManager2 {
- t.Fatal("AccountManagers are the same for two different users")
- }
-}
-
-func TestDeletingUserAccountManagers(t *testing.T) {
- unauthedClient, _ := rpc.NewNetworkClient("ws://test")
- userAccountManager := NewUserAccountManager(unauthedClient, log.New(), nil, "", "")
- userID := "user1"
-
- // Add an account manager for the user
- userAccountManager.AddAndReturnAccountManager(userID)
-
- // Test deleting user account manager
- err := userAccountManager.DeleteUserAccountManager(userID)
- if err != nil {
- t.Fatal(err)
- }
-
- // After deleting, we should get an error if we try to get the user's account manager
- _, err = userAccountManager.GetUserAccountManager(userID)
- if err == nil {
- t.Fatal("expected an error after trying to get a deleted account manager")
- }
-
- // Trying to delete an account manager that doesn't exist should return an error
- err = userAccountManager.DeleteUserAccountManager("nonexistentUser")
- if err == nil {
- t.Fatal("expected an error after trying to delete an account manager that doesn't exist")
- }
-}
diff --git a/tools/walletextension/userconn/user_conn.go b/tools/walletextension/userconn/user_conn.go
deleted file mode 100644
index 4acb9ebf2f..0000000000
--- a/tools/walletextension/userconn/user_conn.go
+++ /dev/null
@@ -1,147 +0,0 @@
-package userconn
-
-import (
- "fmt"
- "io"
- "net/http"
- "net/url"
- "strings"
- "sync"
-
- "github.com/ten-protocol/go-ten/go/common/log"
-
- gethlog "github.com/ethereum/go-ethereum/log"
-
- "github.com/gorilla/websocket"
-)
-
-var upgrader = websocket.Upgrader{} // Used to upgrade connections to websocket connections.
-
-// UserConn represents a connection to a user.
-type UserConn interface {
- ReadRequest() ([]byte, error)
- ReadRequestParams() map[string]string
- WriteResponse(msg []byte) error
- SupportsSubscriptions() bool
- IsClosed() bool
- GetHTTPRequest() *http.Request
-}
-
-// Represents a user's connection over HTTP.
-type userConnHTTP struct {
- resp http.ResponseWriter
- req *http.Request
- logger gethlog.Logger
-}
-
-// Represents a user's connection websockets.
-type userConnWS struct {
- conn *websocket.Conn
- isClosed bool
- logger gethlog.Logger
- req *http.Request
- mu sync.Mutex
-}
-
-func NewUserConnHTTP(resp http.ResponseWriter, req *http.Request, logger gethlog.Logger) UserConn {
- return &userConnHTTP{resp: resp, req: req, logger: logger}
-}
-
-func NewUserConnWS(resp http.ResponseWriter, req *http.Request, logger gethlog.Logger) (UserConn, error) {
- // We search all the request's headers. If there's a websocket upgrade header, we upgrade to a websocket connection.
- conn, err := upgrader.Upgrade(resp, req, nil)
- if err != nil {
- err = fmt.Errorf("unable to upgrade to websocket connection - %w", err)
- _, _ = resp.Write([]byte(err.Error()))
- logger.Error("unable to upgrade to websocket connection", log.ErrKey, err)
- return nil, err
- }
-
- return &userConnWS{
- conn: conn,
- logger: logger,
- req: req,
- }, nil
-}
-
-func (h *userConnHTTP) ReadRequest() ([]byte, error) {
- body, err := io.ReadAll(h.req.Body)
- if err != nil {
- return nil, fmt.Errorf("could not read request body: %w", err)
- }
- return body, nil
-}
-
-func (h *userConnHTTP) WriteResponse(msg []byte) error {
- _, err := h.resp.Write(msg)
- if err != nil {
- return fmt.Errorf("could not write response: %w", err)
- }
- return nil
-}
-
-func (h *userConnHTTP) SupportsSubscriptions() bool {
- return false
-}
-
-func (h *userConnHTTP) IsClosed() bool {
- return false
-}
-
-func (h *userConnHTTP) ReadRequestParams() map[string]string {
- return getQueryParams(h.req.URL.Query())
-}
-
-func (h *userConnHTTP) GetHTTPRequest() *http.Request {
- return h.req
-}
-
-func (w *userConnWS) ReadRequest() ([]byte, error) {
- _, msg, err := w.conn.ReadMessage()
- if err != nil {
- if websocket.IsCloseError(err) {
- w.isClosed = true
- }
- return nil, fmt.Errorf("could not read request: %w", err)
- }
- return msg, nil
-}
-
-func (w *userConnWS) WriteResponse(msg []byte) error {
- w.mu.Lock()
- defer w.mu.Unlock()
-
- err := w.conn.WriteMessage(websocket.TextMessage, msg)
- if err != nil {
- if websocket.IsCloseError(err) || strings.Contains(string(msg), "EOF") {
- w.isClosed = true
- }
- return fmt.Errorf("could not write response: %w", err)
- }
- return nil
-}
-
-func (w *userConnWS) SupportsSubscriptions() bool {
- return true
-}
-
-func (w *userConnWS) IsClosed() bool {
- return w.isClosed
-}
-
-func (w *userConnWS) ReadRequestParams() map[string]string {
- return getQueryParams(w.req.URL.Query())
-}
-
-func (w *userConnWS) GetHTTPRequest() *http.Request {
- return w.req
-}
-
-func getQueryParams(query url.Values) map[string]string {
- params := make(map[string]string)
- queryParams := query
- for key, value := range queryParams {
- params[key] = value[0]
- }
- return params
-}
diff --git a/tools/walletextension/wallet_extension.go b/tools/walletextension/wallet_extension.go
deleted file mode 100644
index 64ceffe2d7..0000000000
--- a/tools/walletextension/wallet_extension.go
+++ /dev/null
@@ -1,419 +0,0 @@
-package walletextension
-
-import (
- "bytes"
- "encoding/hex"
- "errors"
- "fmt"
- "time"
-
- "github.com/ten-protocol/go-ten/tools/walletextension/cache"
-
- "github.com/ten-protocol/go-ten/tools/walletextension/accountmanager"
-
- "github.com/ten-protocol/go-ten/tools/walletextension/config"
-
- "github.com/ten-protocol/go-ten/go/common/log"
- "github.com/ten-protocol/go-ten/go/obsclient"
-
- "github.com/ten-protocol/go-ten/tools/walletextension/useraccountmanager"
-
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/crypto/ecies"
- "github.com/go-kit/kit/transport/http/jsonrpc"
- "github.com/ten-protocol/go-ten/go/common/stopcontrol"
- "github.com/ten-protocol/go-ten/go/common/viewingkey"
- "github.com/ten-protocol/go-ten/go/rpc"
- "github.com/ten-protocol/go-ten/tools/walletextension/common"
- "github.com/ten-protocol/go-ten/tools/walletextension/storage"
- "github.com/ten-protocol/go-ten/tools/walletextension/userconn"
-
- gethcommon "github.com/ethereum/go-ethereum/common"
- gethlog "github.com/ethereum/go-ethereum/log"
-)
-
-// WalletExtension handles the management of viewing keys and the forwarding of Ethereum JSON-RPC requests.
-type WalletExtension struct {
- hostAddrHTTP string // The HTTP address on which the Ten host can be reached
- hostAddrWS string // The WS address on which the Ten host can be reached
- userAccountManager *useraccountmanager.UserAccountManager
- storage storage.Storage
- logger gethlog.Logger
- fileLogger gethlog.Logger
- stopControl *stopcontrol.StopControl
- version string
- config *config.Config
- tenClient *obsclient.ObsClient
- cache cache.Cache
-}
-
-func New(
- hostAddrHTTP string,
- hostAddrWS string,
- userAccountManager *useraccountmanager.UserAccountManager,
- storage storage.Storage,
- stopControl *stopcontrol.StopControl,
- version string,
- logger gethlog.Logger,
- config *config.Config,
-) *WalletExtension {
- rpcClient, err := rpc.NewNetworkClient(hostAddrHTTP)
- if err != nil {
- logger.Error(fmt.Errorf("could not create RPC client on %s. Cause: %w", hostAddrHTTP, err).Error())
- panic(err)
- }
- newTenClient := obsclient.NewObsClient(rpcClient)
- newFileLogger := common.NewFileLogger()
- newGatewayCache, err := cache.NewCache(logger)
- if err != nil {
- logger.Error(fmt.Errorf("could not create cache. Cause: %w", err).Error())
- panic(err)
- }
-
- return &WalletExtension{
- hostAddrHTTP: hostAddrHTTP,
- hostAddrWS: hostAddrWS,
- userAccountManager: userAccountManager,
- storage: storage,
- logger: logger,
- fileLogger: newFileLogger,
- stopControl: stopControl,
- version: version,
- config: config,
- tenClient: newTenClient,
- cache: newGatewayCache,
- }
-}
-
-// IsStopping returns whether the WE is stopping
-func (w *WalletExtension) IsStopping() bool {
- return w.stopControl.IsStopping()
-}
-
-// Logger returns the WE set logger
-func (w *WalletExtension) Logger() gethlog.Logger {
- return w.logger
-}
-
-// ProxyEthRequest proxys an incoming user request to the enclave
-func (w *WalletExtension) ProxyEthRequest(request *common.RPCRequest, conn userconn.UserConn, hexUserID string) (map[string]interface{}, error) {
- response := map[string]interface{}{}
- // all responses must contain the request id. Both successful and unsuccessful.
- response[common.JSONKeyRPCVersion] = jsonrpc.Version
- response[common.JSONKeyID] = request.ID
-
- // start measuring time for request
- requestStartTime := time.Now()
-
- // Check if the request is in the cache
- isCacheable, key, ttl := cache.IsCacheable(request, hexUserID)
-
- // in case of cache hit return the response from the cache
- if isCacheable {
- if value, ok := w.cache.Get(key); ok {
- // do a shallow copy of the map to avoid concurrent map iteration and map write
- returnValue := make(map[string]interface{})
- for k, v := range value {
- returnValue[k] = v
- }
-
- requestEndTime := time.Now()
- duration := requestEndTime.Sub(requestStartTime)
- // adjust requestID
- returnValue[common.JSONKeyID] = request.ID
- w.fileLogger.Info(fmt.Sprintf("Request method: %s, request params: %s, encryptionToken of sender: %s, response: %s, duration: %d ", request.Method, request.Params, hexUserID, returnValue, duration.Milliseconds()))
- return returnValue, nil
- }
- }
-
- // proxyRequest will find the correct client to proxy the request (or try them all if appropriate)
- var rpcResp interface{}
-
- // wallet extension can override the GetStorageAt to retrieve the current userID
- if request.Method == rpc.GetStorageAt {
- if interceptedResponse := w.getStorageAtInterceptor(request, hexUserID); interceptedResponse != nil {
- w.logger.Info("interception successful for getStorageAt, returning userID response")
- requestEndTime := time.Now()
- duration := requestEndTime.Sub(requestStartTime)
- w.fileLogger.Info(fmt.Sprintf("Request method: %s, request params: %s, encryptionToken of sender: %s, response: %s, duration: %d ", request.Method, request.Params, hexUserID, interceptedResponse, duration.Milliseconds()))
- return interceptedResponse, nil
- }
- }
-
- // check if user is sending a new transaction and if we should store it in the database for debugging purposes
- if request.Method == rpc.SendRawTransaction && w.config.StoreIncomingTxs {
- userIDBytes, err := common.GetUserIDbyte(hexUserID)
- if err != nil {
- w.Logger().Error(fmt.Errorf("error decoding string (%s), %w", hexUserID[2:], err).Error())
- return nil, errors.New("error decoding userID. It should be in hex format")
- }
- err = w.storage.StoreTransaction(request.Params[0].(string), userIDBytes)
- if err != nil {
- w.Logger().Error(fmt.Errorf("error storing transaction in the database: %w", err).Error())
- return nil, err
- }
- }
-
- // get account manager for current user (if there is no users in the query parameters - use defaultUser for WE endpoints)
- selectedAccountManager, err := w.userAccountManager.GetUserAccountManager(hexUserID)
- if err != nil {
- w.Logger().Error(fmt.Errorf("error getting accountManager for user (%s), %w", hexUserID, err).Error())
- return nil, err
- }
-
- err = selectedAccountManager.ProxyRequest(request, &rpcResp, conn)
- if err != nil {
- return nil, err
- }
-
- response[common.JSONKeyResult] = rpcResp
-
- if rpcResp != nil {
- // todo (@ziga) - fix this upstream on the decode
- // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-658.md
- adjustStateRoot(rpcResp, response)
- }
-
- requestEndTime := time.Now()
- duration := requestEndTime.Sub(requestStartTime)
- w.fileLogger.Info(fmt.Sprintf("Request method: %s, request params: %s, encryptionToken of sender: %s, response: %s, duration: %d ", request.Method, request.Params, hexUserID, response, duration.Milliseconds()))
-
- // if the request is cacheable, store the response in the cache
- if isCacheable {
- w.cache.Set(key, response, ttl)
- }
-
- return response, nil
-}
-
-// GenerateAndStoreNewUser generates new key-pair and userID, stores it in the database and returns hex encoded userID and error
-func (w *WalletExtension) GenerateAndStoreNewUser() (string, error) {
- requestStartTime := time.Now()
- // generate new key-pair
- viewingKeyPrivate, err := crypto.GenerateKey()
- viewingPrivateKeyEcies := ecies.ImportECDSA(viewingKeyPrivate)
- if err != nil {
- w.Logger().Error(fmt.Sprintf("could not generate new keypair: %s", err))
- return "", err
- }
-
- // create UserID and store it in the database with the private key
- userID := viewingkey.CalculateUserID(common.PrivateKeyToCompressedPubKey(viewingPrivateKeyEcies))
- err = w.storage.AddUser(userID, crypto.FromECDSA(viewingPrivateKeyEcies.ExportECDSA()))
- if err != nil {
- w.Logger().Error(fmt.Sprintf("failed to save user to the database: %s", err))
- return "", err
- }
-
- hexUserID := hex.EncodeToString(userID)
-
- w.userAccountManager.AddAndReturnAccountManager(hexUserID)
- requestEndTime := time.Now()
- duration := requestEndTime.Sub(requestStartTime)
- w.fileLogger.Info(fmt.Sprintf("Storing new userID: %s, duration: %d ", hexUserID, duration.Milliseconds()))
- return hexUserID, nil
-}
-
-// AddAddressToUser checks if a message is in correct format and if signature is valid. If all checks pass we save address and signature against userID
-func (w *WalletExtension) AddAddressToUser(hexUserID string, address string, signature []byte, signatureType viewingkey.SignatureType) error {
- requestStartTime := time.Now()
- addressFromMessage := gethcommon.HexToAddress(address)
- // check if a message was signed by the correct address and if the signature is valid
- _, err := viewingkey.CheckSignature(hexUserID, signature, int64(w.config.TenChainID), signatureType)
- if err != nil {
- return fmt.Errorf("signature is not valid: %w", err)
- }
-
- // register the account for that viewing key
- userIDBytes, err := common.GetUserIDbyte(hexUserID)
- if err != nil {
- w.Logger().Error(fmt.Errorf("error decoding string (%s), %w", hexUserID[2:], err).Error())
- return errors.New("error decoding userID. It should be in hex format")
- }
- err = w.storage.AddAccount(userIDBytes, addressFromMessage.Bytes(), signature, signatureType)
- if err != nil {
- w.Logger().Error(fmt.Errorf("error while storing account (%s) for user (%s): %w", addressFromMessage.Hex(), hexUserID, err).Error())
- return err
- }
-
- // Get account manager for current userID (and create it if it doesn't exist)
- privateKeyBytes, err := w.storage.GetUserPrivateKey(userIDBytes)
- if err != nil {
- w.Logger().Error(fmt.Errorf("error getting private key for user: (%s), %w", hexUserID, err).Error())
- }
-
- accManager := w.userAccountManager.AddAndReturnAccountManager(hexUserID)
-
- encClient, err := common.CreateEncClient(w.hostAddrHTTP, addressFromMessage.Bytes(), privateKeyBytes, signature, signatureType, w.Logger())
- if err != nil {
- w.Logger().Error(fmt.Errorf("error creating encrypted client for user: (%s), %w", hexUserID, err).Error())
- return fmt.Errorf("error creating encrypted client for user: (%s), %w", hexUserID, err)
- }
-
- accManager.AddClient(addressFromMessage, encClient)
- requestEndTime := time.Now()
- duration := requestEndTime.Sub(requestStartTime)
- w.fileLogger.Info(fmt.Sprintf("Storing new address for user: %s, address: %s, duration: %d ", hexUserID, address, duration.Milliseconds()))
- return nil
-}
-
-// UserHasAccount checks if provided account exist in the database for given userID
-func (w *WalletExtension) UserHasAccount(hexUserID string, address string) (bool, error) {
- w.fileLogger.Info(fmt.Sprintf("Checkinf if user has account: %s, address: %s", hexUserID, address))
- userIDBytes, err := common.GetUserIDbyte(hexUserID)
- if err != nil {
- w.Logger().Error(fmt.Errorf("error decoding string (%s), %w", hexUserID[2:], err).Error())
- return false, err
- }
-
- addressBytes, err := hex.DecodeString(address[2:]) // remove 0x prefix from address
- if err != nil {
- w.Logger().Error(fmt.Errorf("error decoding string (%s), %w", address[2:], err).Error())
- return false, err
- }
-
- // todo - this can be optimised and done in the database if we will have users with large number of accounts
- // get all the accounts for the selected user
- accounts, err := w.storage.GetAccounts(userIDBytes)
- if err != nil {
- w.Logger().Error(fmt.Errorf("error getting accounts for user (%s), %w", hexUserID, err).Error())
- return false, err
- }
-
- // check if any of the account matches given account
- found := false
- for _, account := range accounts {
- if bytes.Equal(account.AccountAddress, addressBytes) {
- found = true
- }
- }
- return found, nil
-}
-
-// DeleteUser deletes user and accounts associated with user from the database for given userID
-func (w *WalletExtension) DeleteUser(hexUserID string) error {
- w.fileLogger.Info(fmt.Sprintf("Deleting user: %s", hexUserID))
- userIDBytes, err := common.GetUserIDbyte(hexUserID)
- if err != nil {
- w.Logger().Error(fmt.Errorf("error decoding string (%s), %w", hexUserID, err).Error())
- return err
- }
-
- err = w.storage.DeleteUser(userIDBytes)
- if err != nil {
- w.Logger().Error(fmt.Errorf("error deleting user (%s), %w", hexUserID, err).Error())
- return err
- }
-
- // Delete UserAccountManager for user that revoked userID
- err = w.userAccountManager.DeleteUserAccountManager(hexUserID)
- if err != nil {
- w.Logger().Error(fmt.Errorf("error deleting UserAccointManager for user (%s), %w", hexUserID, err).Error())
- }
-
- return nil
-}
-
-func (w *WalletExtension) UserExists(hexUserID string) bool {
- w.fileLogger.Info(fmt.Sprintf("Checking if user exists: %s", hexUserID))
- userIDBytes, err := common.GetUserIDbyte(hexUserID)
- if err != nil {
- w.Logger().Error(fmt.Errorf("error decoding string (%s), %w", hexUserID, err).Error())
- return false
- }
-
- // Check if user exists and don't log error if user doesn't exist, because we expect this to happen in case of
- // user revoking encryption token or using different testnet.
- // todo add a counter here in the future
- key, err := w.storage.GetUserPrivateKey(userIDBytes)
- if err != nil {
- return false
- }
-
- return len(key) > 0
-}
-
-func adjustStateRoot(rpcResp interface{}, respMap map[string]interface{}) {
- if resultMap, ok := rpcResp.(map[string]interface{}); ok {
- if val, foundRoot := resultMap[common.JSONKeyRoot]; foundRoot {
- if val == "0x" {
- respMap[common.JSONKeyResult].(map[string]interface{})[common.JSONKeyRoot] = nil
- }
- }
- }
-}
-
-// getStorageAtInterceptor checks if the parameters for getStorageAt are set to values that require interception
-// and return response or nil if the gateway should forward the request to the node.
-func (w *WalletExtension) getStorageAtInterceptor(request *common.RPCRequest, hexUserID string) map[string]interface{} {
- // check if parameters are correct, and we can intercept a request, otherwise return nil
- if w.checkParametersForInterceptedGetStorageAt(request.Params) {
- // check if userID in the parameters is also in our database
- userID, err := common.GetUserIDbyte(hexUserID)
- if err != nil {
- w.logger.Warn("GetStorageAt called with appropriate parameters to return userID, but not found in the database: ", "userId", hexUserID)
- return nil
- }
-
- // check if we have default user (we don't want to send userID of it out)
- if hexUserID == hex.EncodeToString([]byte(common.DefaultUser)) {
- response := map[string]interface{}{}
- response[common.JSONKeyRPCVersion] = jsonrpc.Version
- response[common.JSONKeyID] = request.ID
- response[common.JSONKeyResult] = fmt.Sprintf(accountmanager.ErrNoViewingKey, "eth_getStorageAt")
- return response
- }
-
- _, err = w.storage.GetUserPrivateKey(userID)
- if err != nil {
- w.logger.Info("Trying to get userID, but it is not present in our database: ", log.ErrKey, err)
- return nil
- }
- response := map[string]interface{}{}
- response[common.JSONKeyRPCVersion] = jsonrpc.Version
- response[common.JSONKeyID] = request.ID
- response[common.JSONKeyResult] = hexUserID
- return response
- }
- w.logger.Info(fmt.Sprintf("parameters used in the request do not match requited parameters for interception: %s", request.Params))
-
- return nil
-}
-
-// checkParametersForInterceptedGetStorageAt checks
-// if parameters for getStorageAt are in the correct format to intercept the function
-func (w *WalletExtension) checkParametersForInterceptedGetStorageAt(params []interface{}) bool {
- if len(params) != 3 {
- w.logger.Info(fmt.Sprintf("getStorageAt expects 3 parameters, but %d received", len(params)))
- return false
- }
-
- if methodName, ok := params[0].(string); ok {
- return methodName == common.GetStorageAtUserIDRequestMethodName
- }
- return false
-}
-
-func (w *WalletExtension) Version() string {
- return w.version
-}
-
-func (w *WalletExtension) GetTenNodeHealthStatus() (bool, error) {
- return w.tenClient.Health()
-}
-
-func (w *WalletExtension) GenerateUserMessageToSign(encryptionToken string, formatsSlice []string) (string, error) {
- // Check if the formats are valid
- for _, format := range formatsSlice {
- if _, exists := viewingkey.SignatureTypeMap[format]; !exists {
- return "", fmt.Errorf("invalid format: %s", format)
- }
- }
-
- messageFormat := viewingkey.GetBestFormat(formatsSlice)
- message, err := viewingkey.GenerateMessage(encryptionToken, int64(w.config.TenChainID), viewingkey.PersonalSignVersion, messageFormat)
- if err != nil {
- return "", fmt.Errorf("error generating message: %w", err)
- }
- return string(message), nil
-}
diff --git a/tools/walletextension/walletextension_container.go b/tools/walletextension/walletextension_container.go
new file mode 100644
index 0000000000..505832a98e
--- /dev/null
+++ b/tools/walletextension/walletextension_container.go
@@ -0,0 +1,136 @@
+package walletextension
+
+import (
+ "net/http"
+ "os"
+ "time"
+
+ "github.com/ten-protocol/go-ten/tools/walletextension/api"
+
+ "github.com/ten-protocol/go-ten/tools/walletextension/httpapi"
+
+ "github.com/ten-protocol/go-ten/tools/walletextension/rpcapi"
+
+ "github.com/ten-protocol/go-ten/lib/gethfork/node"
+
+ gethlog "github.com/ethereum/go-ethereum/log"
+ "github.com/ten-protocol/go-ten/go/common/log"
+ "github.com/ten-protocol/go-ten/go/common/stopcontrol"
+ gethrpc "github.com/ten-protocol/go-ten/lib/gethfork/rpc"
+ wecommon "github.com/ten-protocol/go-ten/tools/walletextension/common"
+ "github.com/ten-protocol/go-ten/tools/walletextension/storage"
+)
+
+type Container struct {
+ stopControl *stopcontrol.StopControl
+ logger gethlog.Logger
+ rpcServer node.Server
+}
+
+func NewContainerFromConfig(config wecommon.Config, logger gethlog.Logger) *Container {
+ // create the account manager with a single unauthenticated connection
+ hostRPCBindAddrWS := wecommon.WSProtocol + config.NodeRPCWebsocketAddress
+ hostRPCBindAddrHTTP := wecommon.HTTPProtocol + config.NodeRPCHTTPAddress
+ // start the database
+ databaseStorage, err := storage.New(config.DBType, config.DBConnectionURL, config.DBPathOverride)
+ if err != nil {
+ logger.Crit("unable to create database to store viewing keys ", log.ErrKey, err)
+ os.Exit(1)
+ }
+
+ // captures version in the env vars
+ version := os.Getenv("OBSCURO_GATEWAY_VERSION")
+ if version == "" {
+ version = "dev"
+ }
+
+ stopControl := stopcontrol.New()
+ walletExt := rpcapi.NewServices(hostRPCBindAddrHTTP, hostRPCBindAddrWS, databaseStorage, stopControl, version, logger, &config)
+ cfg := &node.RPCConfig{
+ EnableHTTP: true,
+ HTTPPort: config.WalletExtensionPortHTTP,
+ EnableWs: true,
+ WsPort: config.WalletExtensionPortWS,
+ WsPath: wecommon.APIVersion1 + "/",
+ HTTPPath: wecommon.APIVersion1 + "/",
+ Host: config.WalletExtensionHost,
+ }
+ rpcServer := node.NewServer(cfg, logger)
+
+ rpcServer.RegisterRoutes(httpapi.NewHTTPRoutes(walletExt))
+
+ // register all RPC endpoints exposed by a typical Geth node
+ rpcServer.RegisterAPIs([]gethrpc.API{
+ {
+ Namespace: "eth",
+ Service: rpcapi.NewEthereumAPI(walletExt),
+ }, {
+ Namespace: "eth",
+ Service: rpcapi.NewBlockChainAPI(walletExt),
+ }, {
+ Namespace: "eth",
+ Service: rpcapi.NewTransactionAPI(walletExt),
+ }, {
+ Namespace: "txpool",
+ Service: rpcapi.NewTxPoolAPI(walletExt),
+ }, {
+ Namespace: "debug",
+ Service: rpcapi.NewDebugAPI(walletExt),
+ }, {
+ Namespace: "eth",
+ Service: rpcapi.NewFilterAPI(walletExt),
+ },
+ })
+
+ // register the static files
+ // todo - remove this when the frontend is no longer served from the enclave
+ staticHandler := api.StaticFilesHandler(wecommon.PathStatic)
+ rpcServer.RegisterRoutes([]node.Route{{
+ Name: wecommon.PathStatic,
+ Func: func(resp http.ResponseWriter, req *http.Request) {
+ staticHandler.ServeHTTP(resp, req)
+ },
+ }})
+
+ return NewWalletExtensionContainer(
+ stopControl,
+ rpcServer,
+ logger,
+ )
+}
+
+func NewWalletExtensionContainer(
+ stopControl *stopcontrol.StopControl,
+ rpcServer node.Server,
+ logger gethlog.Logger,
+) *Container {
+ return &Container{
+ stopControl: stopControl,
+ rpcServer: rpcServer,
+ logger: logger,
+ }
+}
+
+// Start starts the wallet extension container
+func (w *Container) Start() error {
+ err := w.rpcServer.Start()
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+func (w *Container) Stop() error {
+ w.stopControl.Stop()
+
+ if w.rpcServer != nil {
+ // rpc server cannot be stopped synchronously as it will kill current request
+ go func() {
+ // make sure it's not killing the connection before returning the response
+ time.Sleep(time.Second) // todo review this sleep
+ w.rpcServer.Stop()
+ }()
+ }
+
+ return nil
+}