Implement across token matching

Author: mpetrun5

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,52 @@
+// 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/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]common.Address
+}
+
+func NewHubPoolContract(
+	client client.Client,
+	address common.Address,
+	l1Tokens map[string]common.Address,
+) *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) {
+	tokenAddress, 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, tokenAddress)
+	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/message/across.go

@@ -31,10 +31,11 @@ import (
 const (
 	AcrossMessage = "AcrossMessage"
 
-	DOMAIN_NAME = "LiquidityPool"
-	VERSION     = "1.0.0"
-	PROTOCOL_ID = 1
-	BLOCK_RANGE = 1000
+	ZERO_ADDRESS = "0000000000000000000000000000000000000000000000000000000000000000"
+	DOMAIN_NAME  = "LiquidityPool"
+	VERSION      = "1.0.0"
+	PROTOCOL_ID  = 1
+	BLOCK_RANGE  = 1000
 
 	TIMEOUT = 10 * time.Minute
 )
@@ -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_ADDRESS {
+		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

chains/evm/message/across_test.go

@@ -33,6 +33,7 @@ type AcrossMessageHandlerTestSuite struct {
 	mockHost          *mock_host.MockHost
 	mockFetcher       *mock_tss.MockSaveDataFetcher
 	mockPricer        *mock_message.MockTokenPricer
+	mockMatcher       *mock_message.MockTokenMatcher
 
 	handler *message.AcrossMessageHandler
 	sigChn  chan interface{}
@@ -60,6 +61,7 @@ func (s *AcrossMessageHandlerTestSuite) SetupTest() {
 	s.mockFetcher.EXPECT().GetKeyshare().AnyTimes().Return(keyshare.ECDSAKeyshare{}, nil)
 
 	s.mockPricer = mock_message.NewMockTokenPricer(ctrl)
+	s.mockMatcher = mock_message.NewMockTokenMatcher(ctrl)
 
 	pools := make(map[uint64]common.Address)
 	pools[2] = common.HexToAddress("0x5c7BCd6E7De5423a257D81B442095A1a6ced35C5")
@@ -74,8 +76,13 @@ func (s *AcrossMessageHandlerTestSuite) SetupTest() {
 		Address:  common.HexToAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
 		Decimals: 18,
 	}
+	tokens["USDC"] = evm.TokenConfig{
+		Address:  common.HexToAddress("0x3355df6d4c9c3035724fd0e3914de96a5a83aaf4"),
+		Decimals: 6,
+	}
 	confirmations := make(map[uint64]uint64)
 	confirmations[1000] = 100
+	confirmations[2000] = 200
 
 	s.handler = message.NewAcrossMessageHandler(
 		1,
@@ -86,6 +93,7 @@ func (s *AcrossMessageHandlerTestSuite) SetupTest() {
 		s.mockCommunication,
 		s.mockFetcher,
 		s.mockPricer,
+		s.mockMatcher,
 		s.sigChn,
 		tokens,
 		confirmations,
@@ -259,3 +267,62 @@ func (s *AcrossMessageHandlerTestSuite) Test_HandleMessage_ValidLog() {
 	err = <-errChn
 	s.Nil(err)
 }
+
+func (s *AcrossMessageHandlerTestSuite) Test_HandleMessage_ZeroOutputToken() {
+	s.mockCommunication.EXPECT().Broadcast(
+		gomock.Any(),
+		gomock.Any(),
+		comm.AcrossMsg,
+		fmt.Sprintf("%d-%s", 1, comm.AcrossSessionID),
+	).Return(nil)
+	p, _ := pstoremem.NewPeerstore()
+	s.mockHost.EXPECT().Peerstore().Return(p)
+
+	s.mockEventFilterer.EXPECT().TransactionReceipt(
+		gomock.Any(),
+		gomock.Any(),
+	).Return(&types.Receipt{}, fmt.Errorf("missing transaction receipt"))
+	s.mockEventFilterer.EXPECT().TransactionReceipt(gomock.Any(), gomock.Any()).Return(&types.Receipt{
+		BlockNumber: big.NewInt(200),
+	}, nil)
+
+	log, _ := hex.DecodeString("0000000000000000000000003355df6d4c9c3035724fd0e3914de96a5a83aaf40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006d7cbe22000000000000000000000000000000000000000000000000000000006d789ac90000000000000000000000000000000000000000000000000000000067ce09230000000000000000000000000000000000000000000000000000000067ce5ea7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000051d55999c7cd91b17af7276cbecd647dbc000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000000")
+	s.mockEventFilterer.EXPECT().LatestBlock().Return(big.NewInt(400), nil).AnyTimes()
+	s.mockEventFilterer.EXPECT().FilterLogs(gomock.Any(), gomock.Any()).Return([]types.Log{
+		{
+			Removed: false,
+			Data:    log,
+			Topics: []common.Hash{
+				{},
+				{},
+				{},
+				{},
+			},
+		},
+	}, nil)
+	s.mockCoordinator.EXPECT().Execute(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
+	s.mockPricer.EXPECT().TokenPrice("USDC").Return(0.99, nil)
+	s.mockMatcher.EXPECT().DestinationToken(gomock.Any(), "USDC").Return(common.Address{}, nil)
+
+	errChn := make(chan error, 1)
+	ad := message.AcrossData{
+		ErrChn:        errChn,
+		DepositId:     big.NewInt(100),
+		Nonce:         big.NewInt(101),
+		LiquidityPool: common.HexToAddress("0xbe526bA5d1ad94cC59D7A79d99A59F607d31A657"),
+		Caller:        common.HexToAddress("0x5ECF7351930e4A251193aA022Ef06249C6cBfa27"),
+	}
+	m := &coreMessage.Message{
+		Data:        ad,
+		Source:      1,
+		Destination: 2,
+	}
+
+	prop, err := s.handler.HandleMessage(m)
+
+	s.Nil(prop)
+	s.Nil(err)
+
+	err = <-errChn
+	s.Nil(err)
+}