feat: match across zero address output tokens (#29)

* Implement across token matching

* Add hub pool address to config

* Gnerate a keypair to allow for read only calls

* Update ci lint configuration to v2

* Lint

* Rename zero address to zero hash

Author: mpetrun5

.golangci.yml

@@ -1,22 +1,8 @@
-# Refer to golangci-lint's example config file for more options and information:
-# https://github.com/golangci/golangci-lint/blob/master/.golangci.reference.yml
-
+version: "2"
 run:
-  timeout: 5m
   modules-download-mode: readonly
-  exclude-dirs:
-    - vendor
-    - third_party
-
 linters:
   enable:
-    - errcheck
-    - gosimple
-    - goimports
-    - govet
-    - staticcheck
-    - unused
-    - ineffassign
     - bodyclose
     - gocognit
     - godox
@@ -26,7 +12,26 @@ linters:
     - reassign
     - wastedassign
     - whitespace
-
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
+    paths:
+      - third_party$
+      - builtin$
+      - examples$
 issues:
   max-issues-per-linter: 0
-  max-same-issues: 0
+  max-same-issues: 0
+formatters:
+  enable:
+    - goimports
+  exclusions:
+    generated: lax
+    paths:
+      - third_party$
+      - builtin$
+      - examples$

api/handlers/util.go

@@ -18,7 +18,7 @@ func (b *BigInt) UnmarshalJSON(data []byte) error {
 	}
 
 	s := strings.Trim(string(data), "\"")
-	_, ok := b.Int.SetString(s, 10)
+	_, ok := b.SetString(s, 10)
 	if !ok {
 		return fmt.Errorf("failed to parse big.Int from %s", s)
 	}

app/app.go

@@ -22,6 +22,7 @@ import (
 	"github.com/sprintertech/sprinter-signing/api/handlers"
 	"github.com/sprintertech/sprinter-signing/cache"
 	"github.com/sprintertech/sprinter-signing/chains/evm"
+	"github.com/sprintertech/sprinter-signing/chains/evm/calls/contracts"
 	"github.com/sprintertech/sprinter-signing/chains/evm/calls/events"
 	evmListener "github.com/sprintertech/sprinter-signing/chains/evm/listener"
 	evmMessage "github.com/sprintertech/sprinter-signing/chains/evm/message"
@@ -38,6 +39,7 @@ import (
 	coreEvm "github.com/sygmaprotocol/sygma-core/chains/evm"
 	evmClient "github.com/sygmaprotocol/sygma-core/chains/evm/client"
 	coreListener "github.com/sygmaprotocol/sygma-core/chains/evm/listener"
+	"github.com/sygmaprotocol/sygma-core/crypto/secp256k1"
 
 	"github.com/sygmaprotocol/sygma-core/observability"
 	"github.com/sygmaprotocol/sygma-core/relayer"
@@ -139,6 +141,7 @@ func Run() error {
 	confirmationsPerChain := make(map[uint64]map[uint64]uint64)
 	domains := make(map[uint64]relayer.RelayedChain)
 
+	var hubPoolContract evmMessage.TokenMatcher
 	acrossPools := make(map[uint64]common.Address)
 	for _, chainConfig := range configuration.ChainConfigs {
 		switch chainConfig["type"] {
@@ -151,6 +154,15 @@ func Run() error {
 					poolAddress := common.HexToAddress(config.AcrossPool)
 					acrossPools[*config.GeneralChainConfig.Id] = poolAddress
 				}
+
+				if config.HubPool != "" {
+					kp, _ := secp256k1.GenerateKeypair()
+					client, err := evmClient.NewEVMClient(config.GeneralChainConfig.Endpoint, kp)
+					panicOnError(err)
+
+					hubPoolAddress := common.HexToAddress(config.HubPool)
+					hubPoolContract = contracts.NewHubPoolContract(client, hubPoolAddress, config.Tokens)
+				}
 			}
 		default:
 			panic(fmt.Errorf("type '%s' not recognized", chainConfig["type"]))
@@ -182,6 +194,7 @@ func Run() error {
 						communication,
 						keyshareStore,
 						priceAPI,
+						hubPoolContract,
 						sigChn,
 						config.Tokens,
 						config.ConfirmationsByValue,

chains/evm/calls/consts/across.go

@@ -6,6 +6,35 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/abi"
 )
 
+var HubPoolABI, _ = abi.JSON(strings.NewReader(`
+[
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "destinationChainId",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "l1Token",
+        "type": "address"
+      }
+    ],
+    "name": "poolRebalanceRoute",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "destinationToken",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]
+`))
+
 var SpokePoolABI, _ = abi.JSON(strings.NewReader(`
 [
   {

chains/evm/calls/contracts/hubPool.go

@@ -0,0 +1,53 @@
+// The Licensed Work is (c) 2022 Sygma
+// SPDX-License-Identifier: LGPL-3.0-only
+
+package contracts
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/sprintertech/sprinter-signing/chains/evm"
+	"github.com/sprintertech/sprinter-signing/chains/evm/calls/consts"
+	"github.com/sygmaprotocol/sygma-core/chains/evm/client"
+	"github.com/sygmaprotocol/sygma-core/chains/evm/contracts"
+)
+
+type HubPoolContract struct {
+	contracts.Contract
+	client client.Client
+	tokens map[string]evm.TokenConfig
+}
+
+func NewHubPoolContract(
+	client client.Client,
+	address common.Address,
+	l1Tokens map[string]evm.TokenConfig,
+) *HubPoolContract {
+	return &HubPoolContract{
+		Contract: contracts.NewContract(address, consts.HubPoolABI, nil, client, nil),
+		client:   client,
+		tokens:   l1Tokens,
+	}
+}
+
+func (c *HubPoolContract) DestinationToken(destinationChainId *big.Int, symbol string) (common.Address, error) {
+	tokenConfig, ok := c.tokens[symbol]
+	if !ok {
+		return common.Address{}, fmt.Errorf("no hub pool token configured for symbol %s", symbol)
+	}
+
+	res, err := c.CallContract("poolRebalanceRoute", destinationChainId, tokenConfig.Address)
+	if err != nil {
+		return common.Address{}, err
+	}
+
+	out := *abi.ConvertType(res[0], new(common.Address)).(*common.Address)
+	if out.Hex() == (common.Address{}).Hex() {
+		return common.Address{}, fmt.Errorf("rebalance route not configured for %s", symbol)
+	}
+
+	return out, nil
+}

chains/evm/config.go

@@ -25,6 +25,7 @@ type EVMConfig struct {
 	GeneralChainConfig chain.GeneralChainConfig
 	Admin              string
 	AcrossPool         string
+	HubPool            string
 	LiqudityPool       string
 	Tokens             map[string]TokenConfig
 	// usd bucket -> confirmations
@@ -38,6 +39,7 @@ type RawEVMConfig struct {
 	Admin                    string                 `mapstructure:"admin"`
 	LiqudityPool             string                 `mapstructure:"liquidityPool"`
 	AcrossPool               string                 `mapstructure:"acrossPool"`
+	HubPool                  string                 `mapstructure:"hubPool"`
 	Tokens                   map[string]interface{} `mapstructure:"tokens"`
 	ConfirmationsByValue     map[string]interface{} `mapstructure:"confirmationsByValue"`
 	BlockInterval            int64                  `mapstructure:"blockInterval" default:"5"`
@@ -105,12 +107,13 @@ func NewEVMConfig(chainConfig map[string]interface{}) (*EVMConfig, error) {
 		confirmations[usd] = confirmation
 	}
 
-	c.GeneralChainConfig.ParseFlags()
+	c.ParseFlags()
 	config := &EVMConfig{
 		GeneralChainConfig: c.GeneralChainConfig,
 		Admin:              c.Admin,
 		LiqudityPool:       c.LiqudityPool,
 		AcrossPool:         c.AcrossPool,
+		HubPool:            c.HubPool,
 		// nolint:gosec
 		BlockRetryInterval: time.Duration(c.BlockRetryInterval) * time.Second,
 		BlockInterval:      big.NewInt(c.BlockInterval),

chains/evm/config_test.go

@@ -109,6 +109,7 @@ func (s *NewEVMConfigTestSuite) Test_ValidConfigWithCustomTxParams() {
 		"admin":                 "adminAddress",
 		"liquidityPool":         "pool",
 		"acrossPool":            "acrossPool",
+		"hubPool":               "hubPool",
 		"maxGasPrice":           1000,
 		"gasMultiplier":         1000,
 		"gasIncreasePercentage": 20,
@@ -158,6 +159,7 @@ func (s *NewEVMConfigTestSuite) Test_ValidConfigWithCustomTxParams() {
 		Admin:                "adminAddress",
 		LiqudityPool:         "pool",
 		AcrossPool:           "acrossPool",
+		HubPool:              "hubPool",
 		ConfirmationsByValue: expectedBlockConfirmations,
 		Tokens:               expectedTokens,
 	})

chains/evm/message/across.go

@@ -31,6 +31,7 @@ import (
 const (
 	AcrossMessage = "AcrossMessage"
 
+	ZERO_HASH   = "0000000000000000000000000000000000000000000000000000000000000000"
 	DOMAIN_NAME = "LiquidityPool"
 	VERSION     = "1.0.0"
 	PROTOCOL_ID = 1
@@ -72,13 +73,18 @@ type TokenPricer interface {
 	TokenPrice(symbol string) (float64, error)
 }
 
+type TokenMatcher interface {
+	DestinationToken(destinationChainId *big.Int, symbol string) (common.Address, error)
+}
+
 type AcrossMessageHandler struct {
 	client  EventFilterer
 	chainID uint64
 
 	tokens        map[string]evm.TokenConfig
 	confirmations map[uint64]uint64
 	blocktime     time.Duration
+	tokenMatcher  TokenMatcher
 	tokenPricer   TokenPricer
 	pools         map[uint64]common.Address
 
@@ -87,7 +93,7 @@ type AcrossMessageHandler struct {
 	comm        comm.Communication
 	fetcher     signing.SaveDataFetcher
 
-	sigChn chan interface{}
+	sigChn chan any
 }
 
 func NewAcrossMessageHandler(
@@ -99,7 +105,8 @@ func NewAcrossMessageHandler(
 	comm comm.Communication,
 	fetcher signing.SaveDataFetcher,
 	tokenPricer TokenPricer,
-	sigChn chan interface{},
+	tokenMatcher TokenMatcher,
+	sigChn chan any,
 	tokens map[string]evm.TokenConfig,
 	confirmations map[uint64]uint64,
 	blocktime time.Duration,
@@ -117,6 +124,7 @@ func NewAcrossMessageHandler(
 		confirmations: confirmations,
 		blocktime:     blocktime,
 		tokenPricer:   tokenPricer,
+		tokenMatcher:  tokenMatcher,
 	}
 }
 
@@ -237,6 +245,15 @@ func (h *AcrossMessageHandler) minimalConfirmations(d *events.AcrossDeposit) (ui
 		return 0, err
 	}
 
+	if common.Bytes2Hex(d.OutputToken[:]) == ZERO_HASH {
+		address, err := h.tokenMatcher.DestinationToken(d.DestinationChainId, symbol)
+		if err != nil {
+			return 0, err
+		}
+
+		d.OutputToken = common.BytesToHash(address.Bytes())
+	}
+
 	price, err := h.tokenPricer.TokenPrice(symbol)
 	if err != nil {
 		return 0, err