Merge remote-tracking branch 'origin/aylin' into sync-upstream-v0.6.2

chain.json

@@ -7,8 +7,7 @@
   "priority-regossip-txs-per-address": 200,
   "priority-regossip-addresses": ["0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", "0x70997970C51812dc3A010C7d01b50e0d17dc79C8", "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC", "0x8db97C7cEcE249c2b98bDC0226Cc4C2A57BF52FC"],
   "validator-private-key-file": "/tmp/validator.pk",
-  "is-validator": true,
-  "trading-api-enabled": true,
+  "node-type": "kitkat_berghain",
   "testing-api-enabled": true,
   "load-from-snapshot-enabled": true,
   "snapshot-file-path": "/tmp/snapshot",

go.mod

@@ -16,7 +16,7 @@ require (
 	github.com/gballet/go-libpcsclite v0.0.0-20191108122812-4678299bea08
 	github.com/go-cmd/cmd v1.4.1
 	github.com/golang/mock v1.6.0
-	github.com/google/uuid v1.6.0
+	github.com/google/uuid v1.3.0
 	github.com/gorilla/rpc v1.2.0
 	github.com/gorilla/websocket v1.4.2
 	github.com/hashicorp/go-bexpr v0.1.10
@@ -75,6 +75,7 @@ require (
 	github.com/go-stack/stack v1.8.1 // indirect
 	github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/golang-jwt/jwt/v4 v4.3.0 // indirect
 	github.com/golang/protobuf v1.5.3 // indirect
 	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect
 	github.com/google/btree v1.1.2 // indirect

network-configs/aylin/chain_tresor.json

@@ -0,0 +1,5 @@
+{
+    "state-sync-enabled": true,
+    "feeRecipient": "0xB3D25D47291D7F8b97FE3884A924541cDDcbB8Be",
+    "node-type": "tresor"
+}

plugin/evm/config.go

@@ -61,8 +61,7 @@ const (
 	defaultStateSyncMinBlocks   = 300_000
 	defaultStateSyncRequestSize = 1024 // the number of key/values to ask peers for per request
 
-	defaultIsValidator             = false
-	defaultTradingAPIEnabled       = false
+	defaultNodeType                = "tresor"
 	defaultLoadFromSnapshotEnabled = true
 	defaultSnapshotFilePath        = "/tmp/snapshot"
 	defaultMakerbookDatabasePath   = "/tmp/makerbook"
@@ -236,11 +235,9 @@ type Config struct {
 
 	// Testing apis enabled
 	TestingApiEnabled bool `json:"testing-api-enabled"`
-	// IsValidator is true if this node is a validator
-	IsValidator bool `json:"is-validator"`
 
-	// TradingAPI is for the sdk
-	TradingAPIEnabled bool `json:"trading-api-enabled"`
+	// NodeType is the type of node among the following: "tresor", "kitkat", "berghain", meaning validator only, matching engine, rpc node respectively
+	NodeType string `json:"node-type"`
 
 	// LoadFromSnapshotEnabled = true if the node should load the memory db from a snapshot
 	LoadFromSnapshotEnabled bool `json:"load-from-snapshot-enabled"`
@@ -311,8 +308,7 @@ func (c *Config) SetDefaults() {
 	c.AcceptedCacheSize = defaultAcceptedCacheSize
 	c.ValidatorPrivateKeyFile = defaultValidatorPrivateKeyFile
 	c.TestingApiEnabled = defaultTestingApiEnabled
-	c.IsValidator = defaultIsValidator
-	c.TradingAPIEnabled = defaultTradingAPIEnabled
+	c.NodeType = defaultNodeType
 	c.LoadFromSnapshotEnabled = defaultLoadFromSnapshotEnabled
 	c.SnapshotFilePath = defaultSnapshotFilePath
 	c.MakerbookDatabasePath = defaultMakerbookDatabasePath

plugin/evm/gossiper_orders.go

@@ -122,8 +122,7 @@ func (n *legacyPushGossiper) sendSignedOrders(orders []*hu.SignedOrder) error {
 	return n.client.LegacyGossip(msgBytes)
 }
 
-//   #### HANDLER ####
-
+// #### HANDLER ####
 func (h *LegacyGossipHandler) HandleSignedOrders(nodeID ids.NodeID, msg message.SignedOrdersGossip) error {
 	h.mu.Lock()
 	defer h.mu.Unlock()
@@ -158,10 +157,14 @@ func (h *LegacyGossipHandler) HandleSignedOrders(nodeID ids.NodeID, msg message.
 	// re-gossip orders, but not when we already knew the orders
 	ordersToGossip := make([]*hu.SignedOrder, 0)
 	for _, order := range orders {
-		_, err := tradingAPI.PlaceOrder(order)
+		_, shouldTriggerMatching, err := tradingAPI.PlaceOrder(order)
 		if err == nil {
 			h.stats.IncSignedOrdersGossipReceivedNew()
 			ordersToGossip = append(ordersToGossip, order)
+			if shouldTriggerMatching {
+				log.Info("received new match-able signed order, triggering matching pipeline...")
+				h.vm.limitOrderProcesser.RunMatchingPipeline()
+			}
 		} else if err == hu.ErrOrderAlreadyExists {
 			h.stats.IncSignedOrdersGossipReceivedKnown()
 		} else {

plugin/evm/limit_order.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"runtime"
 	"runtime/debug"
+	"strings"
 	"sync"
 	"time"
 
@@ -32,11 +33,23 @@ const (
 	snapshotInterval    uint64 = 10 // save snapshot every 1000 blocks
 )
 
+type NodeType string
+
+const (
+	Tresor          NodeType = "tresor"          // vanilla validator
+	Kitkat          NodeType = "kitkat"          // validator + matching engine
+	Berghain        NodeType = "berghain"        // rpc node
+	Kitkat_Berghain NodeType = "kitkat_berghain" // validator + matching engine + rpc node
+)
+
 type LimitOrderProcesser interface {
 	ListenAndProcessTransactions(blockBuilder *blockBuilder)
 	GetOrderBookAPI() *orderbook.OrderBookAPI
 	GetTestingAPI() *orderbook.TestingAPI
 	GetTradingAPI() *orderbook.TradingAPI
+	RunMatchingPipeline()
+	GetNodeType() NodeType
+	isMatcherNode() bool
 }
 
 type limitOrderProcesser struct {
@@ -55,24 +68,42 @@ type limitOrderProcesser struct {
 	hubbleDB                 database.Database
 	configService            orderbook.IConfigService
 	blockBuilder             *blockBuilder
-	isValidator              bool
 	tradingAPIEnabled        bool
+	nodeType                 NodeType
 	loadFromSnapshotEnabled  bool
 	snapshotSavedBlockNumber uint64
 	snapshotFilePath         string
 	tradingAPI               *orderbook.TradingAPI
 }
 
-func NewLimitOrderProcesser(ctx *snow.Context, txPool *txpool.TxPool, shutdownChan <-chan struct{}, shutdownWg *sync.WaitGroup, backend *eth.EthAPIBackend, blockChain *core.BlockChain, hubbleDB database.Database, validatorPrivateKey string, config Config) LimitOrderProcesser {
+func NewLimitOrderProcesser(ctx *snow.Context, txPool *txpool.TxPool, shutdownChan <-chan struct{}, shutdownWg *sync.WaitGroup, backend *eth.EthAPIBackend, blockChain *core.BlockChain, hubbleDB database.Database, config Config) (LimitOrderProcesser, error) {
 	log.Info("**** NewLimitOrderProcesser")
+
 	configService := orderbook.NewConfigService(blockChain)
 	memoryDb := orderbook.NewInMemoryDatabase(configService)
+
+	nodeType, err := stringToNodeType(config.NodeType)
+	if err != nil {
+		return nil, err
+	}
+	var validatorPrivateKey string
+	if nodeType == Kitkat || nodeType == Kitkat_Berghain {
+		validatorPrivateKey, err = loadPrivateKeyFromFile(config.ValidatorPrivateKeyFile)
+		if err != nil {
+			panic(fmt.Sprint("please specify correct path for validator-private-key-file in chain.json ", err))
+		}
+		if validatorPrivateKey == "" {
+			panic("validator private key is empty")
+		}
+	}
 	lotp := orderbook.NewLimitOrderTxProcessor(txPool, memoryDb, backend, validatorPrivateKey)
+
 	signedObAddy := configService.GetSignedOrderbookContract()
 	contractEventProcessor := orderbook.NewContractEventsProcessor(memoryDb, signedObAddy)
 
 	matchingPipeline := orderbook.NewMatchingPipeline(memoryDb, lotp, configService)
-	// if any of the following values are changed, the nodes will need to be restarted
+	// if any of the following values are changed, the nodes will need to be restarted.
+	// This is also true for local testing. once contracts are deployed it's mandatory to restart the nodes
 	hState := &hu.HubbleState{
 		Assets:             matchingPipeline.GetCollaterals(),
 		ActiveMarkets:      matchingPipeline.GetActiveMarkets(),
@@ -108,14 +139,40 @@ func NewLimitOrderProcesser(ctx *snow.Context, txPool *txpool.TxPool, shutdownCh
 		matchingPipeline:        matchingPipeline,
 		filterAPI:               filterAPI,
 		configService:           configService,
-		isValidator:             config.IsValidator,
-		tradingAPIEnabled:       config.TradingAPIEnabled,
+		nodeType:                nodeType,
 		loadFromSnapshotEnabled: config.LoadFromSnapshotEnabled,
 		snapshotFilePath:        config.SnapshotFilePath,
+	}, nil
+}
+
+func loadPrivateKeyFromFile(keyFile string) (string, error) {
+	key, err := os.ReadFile(keyFile)
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSuffix(string(key), "\n"), nil
+}
+
+func stringToNodeType(nodeTypeString string) (NodeType, error) {
+	switch nodeTypeString {
+	case string(Tresor):
+		return Tresor, nil
+	case string(Kitkat):
+		return Kitkat, nil
+	case string(Berghain):
+		return Berghain, nil
+	case string(Kitkat_Berghain):
+		return Kitkat_Berghain, nil
+	default:
+		return "", fmt.Errorf("unknown NodeType: %s", nodeTypeString)
 	}
 }
 
 func (lop *limitOrderProcesser) ListenAndProcessTransactions(blockBuilder *blockBuilder) {
+	if lop.nodeType == Tresor {
+		return
+	}
+
 	lop.mu.Lock()
 
 	lastAccepted := lop.blockChain.LastAcceptedBlock()
@@ -172,7 +229,7 @@ func (lop *limitOrderProcesser) ListenAndProcessTransactions(blockBuilder *block
 }
 
 func (lop *limitOrderProcesser) RunMatchingPipeline() {
-	if !lop.isValidator {
+	if !lop.isMatcherNode() {
 		return
 	}
 	executeFuncAndRecoverPanic(func() {
@@ -204,6 +261,14 @@ func (lop *limitOrderProcesser) GetTestingAPI() *orderbook.TestingAPI {
 	return orderbook.NewTestingAPI(lop.memoryDb, lop.backend, lop.configService, lop.hubbleDB)
 }
 
+func (lop *limitOrderProcesser) GetNodeType() NodeType {
+	return lop.nodeType
+}
+
+func (lop *limitOrderProcesser) isMatcherNode() bool {
+	return lop.nodeType == Kitkat || lop.nodeType == Kitkat_Berghain
+}
+
 func (lop *limitOrderProcesser) listenAndStoreLimitOrderTransactions() {
 	logsCh := make(chan []*types.Log)
 	logsSubscription := lop.backend.SubscribeHubbleLogsEvent(logsCh)
@@ -347,6 +412,7 @@ func (lop *limitOrderProcesser) runMatchingTimer() {
 
 			case <-lop.shutdownChan:
 				lop.matchingPipeline.MatchingTicker.Stop()
+				lop.matchingPipeline.SanitaryTicker.Stop()
 				return
 			}
 		}

plugin/evm/order_api.go

@@ -60,7 +60,8 @@ func (api *OrderAPI) PlaceSignedOrders(ctx context.Context, input string) (Place
 			continue
 		}
 
-		orderId, err := api.tradingAPI.PlaceOrder(order)
+		// we ignore the 2nd argument shouldTriggerMatching. since PlaceSignedOrders is only called in API nodes, we do not trigger matching in them
+		orderId, _, err := api.tradingAPI.PlaceOrder(order)
 		orderResponse.OrderId = orderId.String()
 		if err != nil {
 			orderResponse.Error = err.Error()

plugin/evm/orderbook/matching_pipeline.go

@@ -97,7 +97,7 @@ func (pipeline *MatchingPipeline) Run(blockNumber *big.Int) bool {
 	}
 
 	orderBookTxsCount := pipeline.lotp.GetOrderBookTxsCount()
-	log.Info("MatchingPipeline:Run", "orderBookTxsCount", orderBookTxsCount)
+	log.Info("MatchingPipeline:Complete", "orderBookTxsCount", orderBookTxsCount)
 	if orderBookTxsCount > 0 {
 		pipeline.lotp.SetOrderBookTxsBlockNumber(blockNumber.Uint64())
 		return true