Merge pull request #206 from renproject/release/0.4.6

Release v0.4.6

.github/workflows/go.yml

@@ -4,8 +4,8 @@ jobs:
   test:
     runs-on: ubuntu-latest
     env:
-      FILECOIN_FFI_COMMIT: a62d00da59d1b0fb35f3a4ae854efa9441af892d
-      SOLANA_FFI_COMMIT: f6521b8a1af44f4d468bc8e7e67ba3766a5602ef 
+      FILECOIN_FFI_COMMIT: 8b97bd8230b77bd32f4f27e4766a6d8a03b4e801
+      SOLANA_FFI_COMMIT: 1428533377eb4ce00e81d04a53bad92f5339db00
     services:
       solana:
         image: renbot/ren-solana:latest
@@ -50,7 +50,7 @@ jobs:
         run: |
           sudo apt-get update
           sudo apt-get install -y build-essential
-          sudo apt-get install -y jq mesa-opencl-icd ocl-icd-opencl-dev pkg-config libudev-dev
+          sudo apt-get install -y jq mesa-opencl-icd ocl-icd-opencl-dev pkg-config libudev-dev hwloc libhwloc-dev
       - name: Install dependencies (Filecoin FFI)
         if: steps.cache-extern.outputs.cache-hit != 'true'
         run: |

CHANGELOG.md

@@ -1,6 +1,23 @@
+## 0.4.6
+
+- Update Multichain to v0.3.21
+- Update Solana recipient encoding
+- Add support for Goerli
+- Fix gateway querying for Filecoin
+
+## 0.4.5
+
+- Add support for Arbitrum
+- Update Multichain to v0.3.18
+- Update compatibility layer for v0 burns
+- Use connection pool for Redis interaction
+- Fetch public key and max confirmations from Darknode when booting
+- Fix incorrect `amount` field for v0 mints
+
 ## 0.4.4
 
 - Partial transaction persistence for gateway recovery
+- Compatibility updates for empty gpubkey
 
 ## 0.4.3
 

cacher/cacher.go

@@ -7,7 +7,7 @@ import (
 	"github.com/renproject/darknode/engine"
 	"github.com/renproject/darknode/jsonrpc"
 	"github.com/renproject/kv"
-	v1 "github.com/renproject/lightnode/compat/v1"
+	"github.com/renproject/lightnode/compat/v1"
 	"github.com/renproject/lightnode/db"
 	"github.com/renproject/lightnode/http"
 	"github.com/renproject/pack"

cacher/cacher_test.go

@@ -32,7 +32,7 @@ var _ = Describe("Cacher", func() {
 		sqlDB, err := sql.Open("sqlite3", "./test.db")
 		Expect(err).NotTo(HaveOccurred())
 
-		database := db.New(sqlDB)
+		database := db.New(sqlDB, 100)
 		Expect(database.Init()).Should(Succeed())
 
 		cacher := New(inspector, logrus.New(), ttl, phi.Options{Cap: 10}, database)

cmd/lightnode/lightnode.go

@@ -15,21 +15,23 @@ import (
 
 	_ "github.com/lib/pq"
 	_ "github.com/mattn/go-sqlite3"
-	"golang.org/x/time/rate"
 
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/evalphobia/logrus_sentry"
 	"github.com/go-redis/redis/v7"
 	"github.com/renproject/aw/wire"
 	"github.com/renproject/darknode/binding"
+	"github.com/renproject/darknode/engine"
 	"github.com/renproject/darknode/jsonrpc"
 	"github.com/renproject/darknode/tx"
 	"github.com/renproject/id"
 	"github.com/renproject/lightnode"
 	"github.com/renproject/lightnode/http"
 	"github.com/renproject/multichain"
 	"github.com/renproject/pack"
+	"github.com/renproject/surge"
 	"github.com/sirupsen/logrus"
+	"golang.org/x/time/rate"
 )
 
 func main() {
@@ -56,19 +58,42 @@ func main() {
 
 	ctx := context.Background()
 
-	// Fetch and apply the first successfull exposed config from bootstrap nodes
+	// Fetch and apply the first successfully exposed config from bootstrap nodes
 	conf, err := getConfigFromBootstrap(ctx, logger, options.BootstrapAddrs)
 	if err != nil {
 		logger.Fatalf("failed to fetch config from any bootstrap node")
 	}
 
 	options.Whitelist = conf.Whitelist
 
+	// Replace Darknode whitelist with a custom one if it is set.
+	if os.Getenv("WHITELIST") != "" {
+		options = options.WithWhitelist(
+			parseWhitelist("WHITELIST"),
+		)
+	}
+
 	for chain, chainOpt := range options.Chains {
 		chainOpt.Confirmations = conf.Confirmations[chain]
+		if conf.MaxConfirmations[chain] != 0 {
+			chainOpt.MaxConfirmations = conf.MaxConfirmations[chain]
+		} else {
+			chainOpt.MaxConfirmations = pack.MaxU64
+		}
 		options.Chains[chain] = chainOpt
 	}
 
+	// Fetch block state from first bootstrap node and use the public key
+	state, err := fetchBlockState(context.Background(), addrToUrl(options.BootstrapAddrs[0], logger), logger, time.Minute)
+	if err != nil {
+		logger.Fatalf("failed to fetch block state from bootstrap node")
+	}
+	pub, err := parsePubkey(state)
+	if err != nil {
+		logger.Fatalf("failed to parse public key from block state")
+	}
+	options = options.WithDistPubKey(&pub)
+
 	// Run Lightnode.
 	node := lightnode.New(options, ctx, logger, sqlDB, client)
 	node.Run(ctx)
@@ -85,7 +110,7 @@ func getConfigFromBootstrap(ctx context.Context, logger logrus.FieldLogger, addr
 			return conf, nil
 		}
 	}
-	return jsonrpc.ResponseQueryConfig{}, fmt.Errorf("Could not load config from darknodes")
+	return jsonrpc.ResponseQueryConfig{}, fmt.Errorf("could not load config from darknodes")
 }
 
 func addrToUrl(addr wire.Address, logger logrus.FieldLogger) string {
@@ -106,7 +131,7 @@ func fetchConfig(ctx context.Context, url string, logger logrus.FieldLogger, tim
 	var resp jsonrpc.ResponseQueryConfig
 	params, err := json.Marshal(jsonrpc.ParamsQueryConfig{})
 	if err != nil {
-		logger.Errorf("[config] cannot marshal query peers params: %v", err)
+		logger.Errorf("[config] cannot marshal query config params: %v", err)
 		return resp, err
 	}
 	client := http.NewClient(timeout)
@@ -138,6 +163,63 @@ func fetchConfig(ctx context.Context, url string, logger logrus.FieldLogger, tim
 	return resp, nil
 }
 
+func fetchBlockState(ctx context.Context, url string, logger logrus.FieldLogger, timeout time.Duration) (jsonrpc.ResponseQueryBlockState, error) {
+	var resp jsonrpc.ResponseQueryBlockState
+	params, err := json.Marshal(jsonrpc.ParamsQueryBlockState{})
+	if err != nil {
+		logger.Errorf("[config] cannot marshal query block state params: %v", err)
+		return resp, err
+	}
+	client := http.NewClient(timeout)
+
+	request := jsonrpc.Request{
+		Version: "2.0",
+		ID:      rand.Int31(),
+		Method:  jsonrpc.MethodQueryBlockState,
+		Params:  params,
+	}
+
+	response, err := client.SendRequest(ctx, url, request, nil)
+	if err != nil {
+		logger.Errorf("[config] error calling queryConfig: %v", err)
+		return resp, err
+	}
+
+	raw, err := json.Marshal(response.Result)
+	if err != nil {
+		logger.Errorf("[config] error marshaling queryConfig result: %v", err)
+		return resp, err
+	}
+
+	if err := json.Unmarshal(raw, &resp); err != nil {
+		logger.Warnf("[config] cannot unmarshal queryConfig result from %v: %v", url, err)
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+func parsePubkey(response jsonrpc.ResponseQueryBlockState) (id.PubKey, error) {
+	systemContract := response.State.Get("System")
+	if systemContract == nil {
+		return id.PubKey{}, fmt.Errorf("system contract is nil")
+	}
+
+	var state engine.SystemState
+	if err := pack.Decode(&state, systemContract); err != nil {
+		return id.PubKey{}, err
+	}
+	if len(state.Shards.Primary) < 1 {
+		return id.PubKey{}, fmt.Errorf("nil primary shard")
+	}
+	shard := state.Shards.Primary[0]
+	var pub id.PubKey
+	if err := surge.FromBinary(&pub, shard.PubKey); err != nil {
+		return id.PubKey{}, err
+	}
+	return pub, nil
+}
+
 func initLogger(name string, network multichain.Network) logrus.FieldLogger {
 	logger := logrus.New()
 	sentryURL := os.Getenv("SENTRY_URL")
@@ -168,16 +250,17 @@ func initRedis() *redis.Client {
 	}
 	redisPassword, _ := redisURL.User.Password()
 	return redis.NewClient(&redis.Options{
-		Addr:     redisURL.Host,
-		Password: redisPassword,
-		DB:       0, // Use default DB.
+		Addr:       redisURL.Host,
+		Password:   redisPassword,
+		DB:         0, // Use default DB.
+		MaxRetries: 5,
+		PoolSize:   15,
 	})
 }
 
 func parseOptions() lightnode.Options {
 	options := lightnode.DefaultOptions().
-		WithNetwork(parseNetwork("HEROKU_APP_NAME")).
-		WithDistPubKey(parsePubKey("PUB_KEY"))
+		WithNetwork(parseNetwork("HEROKU_APP_NAME"))
 
 	// We only want to override the default options if the environment variable
 	// has been specified.
@@ -193,6 +276,9 @@ func parseOptions() lightnode.Options {
 	if os.Getenv("MAX_PAGE_SIZE") != "" {
 		options = options.WithMaxBatchSize(parseInt("MAX_PAGE_SIZE"))
 	}
+	if os.Getenv("MAX_GATEWAY_COUNT") != "" {
+		options = options.WithMaxGatewayCount(parseInt("MAX_GATEWAY_COUNT"))
+	}
 	if os.Getenv("SERVER_TIMEOUT") != "" {
 		options = options.WithServerTimeout(parseTime("SERVER_TIMEOUT"))
 	}
@@ -235,6 +321,12 @@ func parseOptions() lightnode.Options {
 	}
 
 	chains := map[multichain.Chain]binding.ChainOptions{}
+	if os.Getenv("RPC_ARBITRUM") != "" {
+		chains[multichain.Arbitrum] = binding.ChainOptions{
+			RPC:      pack.String(os.Getenv("RPC_ARBITRUM")),
+			Protocol: pack.String(os.Getenv("GATEWAY_ARBITRUM")),
+		}
+	}
 	if os.Getenv("RPC_AVALANCHE") != "" {
 		chains[multichain.Avalanche] = binding.ChainOptions{
 			RPC:      pack.String(os.Getenv("RPC_AVALANCHE")),
@@ -287,6 +379,12 @@ func parseOptions() lightnode.Options {
 			},
 		}
 	}
+	if os.Getenv("RPC_GOERLI") != "" {
+		chains[multichain.Goerli] = binding.ChainOptions{
+			RPC:      pack.String(os.Getenv("RPC_GOERLI")),
+			Protocol: pack.String(os.Getenv("GATEWAY_GOERLI")),
+		}
+	}
 	if os.Getenv("RPC_POLYGON") != "" {
 		chains[multichain.Polygon] = binding.ChainOptions{
 			RPC:      pack.String(os.Getenv("RPC_POLYGON")),

cmd/localnet/localnet.go

@@ -32,7 +32,7 @@ func main() {
 
 	flag.Parse()
 
-	if *flagPort == ""{
+	if *flagPort == "" {
 		panic("Please provide the port number using --port")
 	}
 	var config darknode.Options
@@ -72,25 +72,25 @@ func main() {
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
-		<- ctx.Done()
+		<-ctx.Done()
 		db.Close()
 	}()
 
 	redisClient, redisServer := initRedis()
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
-		<- ctx.Done()
+		<-ctx.Done()
 		redisServer.Close()
 	}()
 
 	node := lightnode.New(options, ctx, logrus.New(), db, redisClient)
 	go node.Run(ctx)
-	<- ctx.Done()
+	<-ctx.Done()
 	wg.Wait()
 }
 
-func initSQLITE(dir string ) *sql.DB {
+func initSQLITE(dir string) *sql.DB {
 	if err := os.MkdirAll(dir, 0766); err != nil {
 		panic(err)
 	}