Implement GraphQL API

.gitattributes

@@ -1,4 +1,4 @@
 # Automatically collapse generated files in GitHub.
 ethereum/wrappers/*.go  linguist-generated=true
-docs/json-rpc-clients/typescript/*.md  linguist-generated=true
+docs/graphql-clients/typescript/*.md  linguist-generated=true
 

.graphqlconfig

@@ -0,0 +1,3 @@
+{
+    "schemaPath": "graphql/schema.graphql"
+}

Makefile

@@ -1,5 +1,5 @@
 .PHONY: deps
-deps: deps-ts wasmbrowsertest
+deps: deps-ts wasmbrowsertest gqlgen
 
 
 .PHONY: deps-ts
@@ -13,6 +13,13 @@ gobin:
 	GO111MODULE=off go get -u github.com/myitcv/gobin
 
 
+# gqlgen is a tool for embedding files so that they are included in binaries.
+# This installs the CLI for go-bindata.
+.PHONY: gqlgen
+gqlgen: gobin
+	gobin github.com/99designs/gqlgen@v0.11.3
+
+
 # wasmbrowsertest is required for running WebAssembly tests in the browser.
 .PHONY: wasmbrowsertest
 wasmbrowsertest: gobin
@@ -21,7 +28,7 @@ wasmbrowsertest: gobin
 
 # Installs dependencies without updating Gopkg.lock or yarn.lock
 .PHONY: deps-no-lockfile
-deps-no-lockfile: deps-ts-no-lockfile wasmbrowsertest
+deps-no-lockfile: deps-ts-no-lockfile wasmbrowsertest gqlgen
 
 
 .PHONY: deps-ts-no-lockfile
@@ -34,7 +41,7 @@ test-all: test-go test-wasm-browser test-ts test-browser-conversion test-browser
 
 
 .PHONY: test-go
-test-go: test-go-parallel test-go-serial
+test-go: generate test-go-parallel test-go-serial
 
 
 .PHONY: test-go-parallel
@@ -84,8 +91,14 @@ lint-ts:
 lint-prettier:
 	yarn prettier:ci
 
+
+.PHONY: generate
+generate:
+	go generate ./...
+
+
 .PHONY: mesh
-mesh:
+mesh: generate
 	go install ./cmd/mesh
 
 
@@ -105,7 +118,7 @@ db-integrity-check:
 
 
 .PHONY: cut-release
-cut-release:
+cut-release: generate
 	go run ./cmd/cut-release/main.go
 
 
@@ -117,7 +130,7 @@ all: mesh mesh-keygen mesh-bootstrap db-integrity-check
 
 
 .PHONY: docker-mesh
-docker-mesh:
+docker-mesh: generate
 	docker build . -t 0xorg/mesh -f ./dockerfiles/mesh/Dockerfile
 
 
@@ -132,5 +145,6 @@ docker-mesh-fluent-bit:
 
 
 .PHONY: docker-mesh-bridge
-docker-mesh-bridge:
-	docker build . -t 0xorg/mesh-bridge -f ./dockerfiles/mesh-bridge/Dockerfile
+docker-mesh-bridge: generate
+	@echo 'WARN: mesh-bridge is currently disabled since it has not been updated to use the new GraphQL API' 
+	# docker build . -t 0xorg/mesh-bridge -f ./dockerfiles/mesh-bridge/Dockerfile

README.md

@@ -39,12 +39,12 @@ in the network and begin receiving orders from and sending orders to them. You
 do not need to know the identities (e.g., IP address or domain name) of any
 peers in the network ahead of time and they do not need to know about you.
 
-Developers can use the JSON-RPC API to interact with a Mesh node that they
-control. The API allows you to send orders into the network, receive any new
-orders, and get notified when the status of an existing order changes (e.g. when
-it is filled, canceled, or expired). Under the hood, Mesh performs efficient
-order validation and order book pruning, which takes out a lot of the hard work
-for developers.
+Developers can use the GraphQL API to interact with a Mesh node that they
+control. The API allows you to send orders into the network, query for existing
+orders, and get notified when an order is added or the status of an existing
+order changes (e.g. when it is filled, canceled, or expired). Under the hood,
+Mesh performs efficient order validation and order book pruning, which takes out
+a lot of the hard work for developers.
 
 ## Documentation
 

cmd/cut-release/main.go

@@ -98,8 +98,8 @@ func updateHardCodedVersions(version string) {
 	newBrowserLiteDependencyString := fmt.Sprintf(`"@0x/mesh-browser-lite": "^%s"`, version)
 	newBrowserDependencyString := fmt.Sprintf(`"@0x/mesh-browser": "^%s"`, version)
 
-	// Update `packages/mesh-rpc-client/package.json`
-	tsClientPackageJSONPath := "packages/mesh-rpc-client/package.json"
+	// Update `packages/mesh-graphql-client/package.json`
+	tsClientPackageJSONPath := "packages/mesh-graphql-client/package.json"
 	regex := `"version": "(.*)"`
 	updateFileWithRegex(tsClientPackageJSONPath, regex, newVersionString)
 
@@ -156,7 +156,7 @@ func updateHardCodedVersions(version string) {
 	updateFileWithRegex(changelog, regex, newChangelogSection)
 
 	// Update badge in README.md
-	pathToMDFilesWithBadges := []string{"README.md", "docs/rpc_api.md", "docs/deployment.md", "docs/deployment_with_telemetry.md"}
+	pathToMDFilesWithBadges := []string{"README.md", "docs/graphql_api.md", "docs/deployment.md", "docs/deployment_with_telemetry.md"}
 	doubleDashVersion := strings.Replace(version, "-", "--", -1)
 	newSvgName := fmt.Sprintf("version-%s-orange.svg", doubleDashVersion)
 	regex = `version-(.*)-orange.svg`

cmd/mesh-bridge/main.go

@@ -5,120 +5,123 @@
 //to flow to another
 package main
 
-import (
-	"context"
-	"time"
+// Note(albrow): If we want to use mesh-bridge in the future we will need to update it to
+// use the new GraphQL API. Considered low-priority as of the time of writing this comment.
 
-	"github.com/0xProject/0x-mesh/rpc"
-	"github.com/0xProject/0x-mesh/zeroex"
-	ethrpc "github.com/ethereum/go-ethereum/rpc"
-	"github.com/plaid/go-envvar/envvar"
-	log "github.com/sirupsen/logrus"
-)
+// import (
+// 	"context"
+// 	"time"
 
-const (
-	firstWSRPCAddressLabel  = "FirstWSRPCAddress"
-	secondWSRPCAddressLabel = "SecondWSRPCAddress"
-	maxReceiveBatch         = 100
-	receiveTimeout          = 2 * time.Second
-	tenThousand             = 10000
-)
+// 	"github.com/0xProject/0x-mesh/rpc"
+// 	"github.com/0xProject/0x-mesh/zeroex"
+// 	ethrpc "github.com/ethereum/go-ethereum/rpc"
+// 	"github.com/plaid/go-envvar/envvar"
+// 	log "github.com/sirupsen/logrus"
+// )
 
-type clientEnvVars struct {
-	FirstWSRPCAddress  string `envvar:"FIRST_WS_RPC_ADDRESS"`
-	SecondWSRPCAddress string `envvar:"SECOND_WS_RPC_ADDRESS"`
-	Verbosity          int    `envvar:"VERBOSITY"`
-}
+// const (
+// 	firstWSRPCAddressLabel  = "FirstWSRPCAddress"
+// 	secondWSRPCAddressLabel = "SecondWSRPCAddress"
+// 	maxReceiveBatch         = 100
+// 	receiveTimeout          = 2 * time.Second
+// 	tenThousand             = 10000
+// )
+
+// type clientEnvVars struct {
+// 	FirstWSRPCAddress  string `envvar:"FIRST_WS_RPC_ADDRESS"`
+// 	SecondWSRPCAddress string `envvar:"SECOND_WS_RPC_ADDRESS"`
+// 	Verbosity          int    `envvar:"VERBOSITY"`
+// }
 
 func main() {
-	env := clientEnvVars{}
-	if err := envvar.Parse(&env); err != nil {
-		panic(err)
-	}
+	// 	env := clientEnvVars{}
+	// 	if err := envvar.Parse(&env); err != nil {
+	// 		panic(err)
+	// 	}
 
-	log.SetLevel(log.Level(env.Verbosity))
+	// 	log.SetLevel(log.Level(env.Verbosity))
 
-	firstClient, err := rpc.NewClient(env.FirstWSRPCAddress)
-	if err != nil {
-		log.WithError(err).Fatal("could not create client")
-	}
-	stats, err := firstClient.GetStats()
-	if err != nil {
-		log.Fatal(err)
-	}
-	log.WithField("stats", stats).Info("Spun up first client")
+	// 	firstClient, err := rpc.NewClient(env.FirstWSRPCAddress)
+	// 	if err != nil {
+	// 		log.WithError(err).Fatal("could not create client")
+	// 	}
+	// 	stats, err := firstClient.GetStats()
+	// 	if err != nil {
+	// 		log.Fatal(err)
+	// 	}
+	// 	log.WithField("stats", stats).Info("Spun up first client")
 
-	secondClient, err := rpc.NewClient(env.SecondWSRPCAddress)
-	if err != nil {
-		log.WithError(err).Fatal("could not create client")
-	}
-	stats, err = secondClient.GetStats()
-	if err != nil {
-		log.Fatal(err)
-	}
-	log.WithField("stats", stats).Info("Spun up second client")
+	// 	secondClient, err := rpc.NewClient(env.SecondWSRPCAddress)
+	// 	if err != nil {
+	// 		log.WithError(err).Fatal("could not create client")
+	// 	}
+	// 	stats, err = secondClient.GetStats()
+	// 	if err != nil {
+	// 		log.Fatal(err)
+	// 	}
+	// 	log.WithField("stats", stats).Info("Spun up second client")
 
-	go func() {
-		pipeOrders(secondClient, firstClient, secondWSRPCAddressLabel, firstWSRPCAddressLabel)
-	}()
-	pipeOrders(firstClient, secondClient, firstWSRPCAddressLabel, secondWSRPCAddressLabel)
+	// 	go func() {
+	// 		pipeOrders(secondClient, firstClient, secondWSRPCAddressLabel, firstWSRPCAddressLabel)
+	// 	}()
+	// 	pipeOrders(firstClient, secondClient, firstWSRPCAddressLabel, secondWSRPCAddressLabel)
 }
 
-func pipeOrders(inClient, outClient *rpc.Client, inLabel, outLabel string) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	orderEventsChan := make(chan []*zeroex.OrderEvent, tenThousand)
-	clientSubscription, err := inClient.SubscribeToOrders(ctx, orderEventsChan)
-	if err != nil {
-		log.WithError(err).Fatal("Couldn't set up OrderStream subscription")
-	}
-	defer clientSubscription.Unsubscribe()
-	for {
-		incomingSignedOrders, err := receiveBatch(orderEventsChan, clientSubscription, inLabel, outLabel)
-		if err != nil {
-			log.Fatal(err)
-		}
-		if len(incomingSignedOrders) == 0 {
-			continue
-		}
-		validationResults, err := outClient.AddOrders(incomingSignedOrders)
-		if err != nil {
-			log.Fatal(err)
-		}
-		log.WithFields(log.Fields{
-			"from":        inLabel,
-			"to":          outLabel,
-			"numSent":     len(incomingSignedOrders),
-			"numAccepted": len(validationResults.Accepted),
-			"numRejected": len(validationResults.Rejected),
-		}).Info("Finished bridging orders")
-	}
-}
+// func pipeOrders(inClient, outClient *rpc.Client, inLabel, outLabel string) {
+// 	ctx, cancel := context.WithCancel(context.Background())
+// 	defer cancel()
+// 	orderEventsChan := make(chan []*zeroex.OrderEvent, tenThousand)
+// 	clientSubscription, err := inClient.SubscribeToOrders(ctx, orderEventsChan)
+// 	if err != nil {
+// 		log.WithError(err).Fatal("Couldn't set up OrderStream subscription")
+// 	}
+// 	defer clientSubscription.Unsubscribe()
+// 	for {
+// 		incomingSignedOrders, err := receiveBatch(orderEventsChan, clientSubscription, inLabel, outLabel)
+// 		if err != nil {
+// 			log.Fatal(err)
+// 		}
+// 		if len(incomingSignedOrders) == 0 {
+// 			continue
+// 		}
+// 		validationResults, err := outClient.AddOrders(incomingSignedOrders)
+// 		if err != nil {
+// 			log.Fatal(err)
+// 		}
+// 		log.WithFields(log.Fields{
+// 			"from":        inLabel,
+// 			"to":          outLabel,
+// 			"numSent":     len(incomingSignedOrders),
+// 			"numAccepted": len(validationResults.Accepted),
+// 			"numRejected": len(validationResults.Rejected),
+// 		}).Info("Finished bridging orders")
+// 	}
+// }
 
-func receiveBatch(inChan chan []*zeroex.OrderEvent, subscription *ethrpc.ClientSubscription, inLabel, outLabel string) ([]*zeroex.SignedOrder, error) {
-	signedOrders := []*zeroex.SignedOrder{}
-	timeoutChan := time.After(receiveTimeout)
-	for {
-		if len(signedOrders) >= maxReceiveBatch {
-			return signedOrders, nil
-		}
-		select {
-		case <-timeoutChan:
-			return signedOrders, nil
-		case orderEvents := <-inChan:
-			for _, orderEvent := range orderEvents {
-				if orderEvent.EndState != zeroex.ESOrderAdded {
-					continue
-				}
-				log.WithFields(log.Fields{
-					"from":      inLabel,
-					"to":        outLabel,
-					"orderHash": orderEvent.OrderHash.Hex(),
-				}).Info("Found new order over bridge")
-				signedOrders = append(signedOrders, orderEvent.SignedOrder)
-			}
-		case err := <-subscription.Err():
-			log.Fatal(err)
-		}
-	}
-}
+// func receiveBatch(inChan chan []*zeroex.OrderEvent, subscription *ethrpc.ClientSubscription, inLabel, outLabel string) ([]*zeroex.SignedOrder, error) {
+// 	signedOrders := []*zeroex.SignedOrder{}
+// 	timeoutChan := time.After(receiveTimeout)
+// 	for {
+// 		if len(signedOrders) >= maxReceiveBatch {
+// 			return signedOrders, nil
+// 		}
+// 		select {
+// 		case <-timeoutChan:
+// 			return signedOrders, nil
+// 		case orderEvents := <-inChan:
+// 			for _, orderEvent := range orderEvents {
+// 				if orderEvent.EndState != zeroex.ESOrderAdded {
+// 					continue
+// 				}
+// 				log.WithFields(log.Fields{
+// 					"from":      inLabel,
+// 					"to":        outLabel,
+// 					"orderHash": orderEvent.OrderHash.Hex(),
+// 				}).Info("Found new order over bridge")
+// 				signedOrders = append(signedOrders, orderEvent.SignedOrder)
+// 			}
+// 		case err := <-subscription.Err():
+// 			log.Fatal(err)
+// 		}
+// 	}
+// }