Implement calculation of the unlock hash that matches on-chain implementation

mpetrun5 · mpetrun5 · commit 54b76d6cbbef · 2025-02-18T17:07:04.000+01:00
diff --git a/chains/evm/calls/consts/across.go b/chains/evm/calls/consts/across.go
@@ -0,0 +1,91 @@
+package consts
+
+const SpokePoolABI = `
+[
+  {
+    "inputs": [
+      {
+        "components": [
+          {
+            "internalType": "bytes32",
+            "name": "depositor",
+            "type": "bytes32"
+          },
+          {
+            "internalType": "bytes32",
+            "name": "recipient",
+            "type": "bytes32"
+          },
+          {
+            "internalType": "bytes32",
+            "name": "exclusiveRelayer",
+            "type": "bytes32"
+          },
+          {
+            "internalType": "bytes32",
+            "name": "inputToken",
+            "type": "bytes32"
+          },
+          {
+            "internalType": "bytes32",
+            "name": "outputToken",
+            "type": "bytes32"
+          },
+          {
+            "internalType": "uint256",
+            "name": "inputAmount",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "outputAmount",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "originChainId",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "depositId",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint32",
+            "name": "fillDeadline",
+            "type": "uint32"
+          },
+          {
+            "internalType": "uint32",
+            "name": "exclusivityDeadline",
+            "type": "uint32"
+          },
+          {
+            "internalType": "bytes",
+            "name": "message",
+            "type": "bytes"
+          }
+        ],
+        "internalType": "struct V3SpokePoolInterface.V3RelayData",
+        "name": "relayData",
+        "type": "tuple"
+      },
+      {
+        "internalType": "uint256",
+        "name": "repaymentChainId",
+        "type": "uint256"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "repaymentAddress",
+        "type": "bytes32"
+      }
+    ],
+    "name": "fillRelay",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]
+`
diff --git a/chains/evm/calls/events/events.go b/chains/evm/calls/events/events.go
@@ -5,9 +5,12 @@ package events
 
 import (
 	"math/big"
+	"strings"
 
+	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/sprintertech/sprinter-signing/chains/evm/calls/consts"
 )
 
 type EventSig string
@@ -34,14 +37,54 @@ type AcrossDeposit struct {
 	OutputToken         [32]byte
 	InputAmount         *big.Int
 	OutputAmount        *big.Int
-	RepaymentChainId    *big.Int
-	OriginChainId       *big.Int
+	DestinationChainId  *big.Int
 	DepositId           *big.Int
 	QuoteTimestamp      uint32
-	FillDeadline        uint32
 	ExclusivityDeadline uint32
+	FillDeadline        uint32
+	Depositor           [32]byte
+	Recipient           [32]byte
+	ExclusiveRelayer    [32]byte
+	Message             []byte
+}
+
+func (a *AcrossDeposit) ToV3RelayData(originChainID *big.Int) *AcrossV3RelayData {
+	return &AcrossV3RelayData{
+		Depositor:           a.Depositor,
+		Recipient:           a.Recipient,
+		ExclusiveRelayer:    a.ExclusiveRelayer,
+		InputToken:          a.InputToken,
+		OutputToken:         a.OutputToken,
+		InputAmount:         a.InputAmount,
+		OutputAmount:        a.OutputAmount,
+		OriginChainId:       originChainID,
+		DepositId:           a.DepositId,
+		FillDeadline:        a.FillDeadline,
+		ExclusivityDeadline: a.ExclusivityDeadline,
+		Message:             a.Message,
+	}
+}
+
+type AcrossV3RelayData struct {
 	Depositor           [32]byte
 	Recipient           [32]byte
-	ExclusiveRelayer    common.Address
+	ExclusiveRelayer    [32]byte
+	InputToken          [32]byte
+	OutputToken         [32]byte
+	InputAmount         *big.Int
+	OutputAmount        *big.Int
+	OriginChainId       *big.Int
+	DepositId           *big.Int
+	FillDeadline        uint32
+	ExclusivityDeadline uint32
 	Message             []byte
 }
+
+func (a *AcrossV3RelayData) Calldata() ([]byte, error) {
+	abi, _ := abi.JSON(strings.NewReader(consts.SpokePoolABI))
+	input, err := abi.Pack("fillRelay", a)
+	if err != nil {
+		return []byte{}, err
+	}
+	return input, nil
+}
diff --git a/chains/evm/config.go b/chains/evm/config.go
@@ -22,6 +22,7 @@ type HandlerConfig struct {
 type EVMConfig struct {
 	GeneralChainConfig chain.GeneralChainConfig
 	Admin              string
+	LiqudityPool       string
 	BlockConfirmations *big.Int
 	BlockInterval      *big.Int
 	BlockRetryInterval time.Duration
@@ -30,6 +31,7 @@ type EVMConfig struct {
 type RawEVMConfig struct {
 	chain.GeneralChainConfig `mapstructure:",squash"`
 	Admin                    string `mapstructure:"admin"`
+	LiqudityPool             string `mapstructure:"liquidityPool"`
 	BlockConfirmations       int64  `mapstructure:"blockConfirmations" default:"10"`
 	BlockInterval            int64  `mapstructure:"blockInterval" default:"5"`
 	BlockRetryInterval       uint64 `mapstructure:"blockRetryInterval" default:"5"`
@@ -71,6 +73,7 @@ func NewEVMConfig(chainConfig map[string]interface{}) (*EVMConfig, error) {
 	config := &EVMConfig{
 		GeneralChainConfig: c.GeneralChainConfig,
 		Admin:              c.Admin,
+		LiqudityPool:       c.LiqudityPool,
 		BlockRetryInterval: time.Duration(c.BlockRetryInterval) * time.Second,
 		BlockConfirmations: big.NewInt(c.BlockConfirmations),
 		BlockInterval:      big.NewInt(c.BlockInterval),
diff --git a/chains/evm/config_test.go b/chains/evm/config_test.go
@@ -91,14 +91,15 @@ func (s *NewEVMConfigTestSuite) Test_ValidConfig() {
 
 func (s *NewEVMConfigTestSuite) Test_ValidConfigWithCustomTxParams() {
 	rawConfig := map[string]interface{}{
-		"id":          1,
-		"endpoint":    "ws://domain.com",
-		"name":        "evm1",
-		"from":        "address",
-		"bridge":      "bridgeAddress",
-		"admin":       "adminAddress",
-		"retry":       "retryAddress",
-		"frostKeygen": "frostKeygen",
+		"id":            1,
+		"endpoint":      "ws://domain.com",
+		"name":          "evm1",
+		"from":          "address",
+		"bridge":        "bridgeAddress",
+		"admin":         "adminAddress",
+		"liquidityPool": "pool",
+		"retry":         "retryAddress",
+		"frostKeygen":   "frostKeygen",
 		"handlers": []evm.HandlerConfig{
 			{
 				Type:    "erc20",
@@ -135,5 +136,6 @@ func (s *NewEVMConfigTestSuite) Test_ValidConfigWithCustomTxParams() {
 		BlockInterval:      big.NewInt(2),
 		BlockRetryInterval: time.Duration(10) * time.Second,
 		Admin:              "adminAddress",
+		LiqudityPool:       "pool",
 	})
 }
diff --git a/chains/evm/message/across.go b/chains/evm/message/across.go
@@ -9,7 +9,10 @@ import (
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/signer/core/apitypes"
 	"github.com/libp2p/go-libp2p/core/host"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/rs/zerolog/log"
@@ -24,6 +27,11 @@ import (
 
 const (
 	AcrossMessage = "AcrossMessage"
+
+	DOMAIN_NAME     = ""
+	VERSION         = "v1.0.0"
+	BORROW_TYPEHASH = "Borrow(address borrowToken,uint256 amount,address target,bytes targetCallData,uint256 nonce,uint256 deadline)"
+	PROTOCOL_ID     = 1
 )
 
 type EventFilterer interface {
@@ -45,10 +53,16 @@ func NewAcrossMessage(source uint8, destination uint8, acrossData AcrossData) *m
 	}
 }
 
+type Coordinator interface {
+	Execute(ctx context.Context, tssProcesses []tss.TssProcess, resultChn chan interface{}, coordinator peer.ID) error
+}
+
 type AcrossMessageHandler struct {
-	client EventFilterer
+	client        EventFilterer
+	sourceChainID *big.Int
 
 	across common.Address
+	pools  map[uint64]common.Address
 	abi    abi.ABI
 
 	coordinator *tss.Coordinator
@@ -106,8 +120,13 @@ func (h *AcrossMessageHandler) HandleMessage(m *message.Message) (*proposal.Prop
 		return nil, err
 	}
 
+	unlockHash, err := h.unlockHash(d)
+	if err != nil {
+		return nil, err
+	}
+
 	signing, err := signing.NewSigning(
-		d.DepositId,
+		new(big.Int).SetBytes(unlockHash),
 		data.depositId.Text(16),
 		data.depositId.Text(16),
 		h.host,
@@ -161,3 +180,62 @@ func (h *AcrossMessageHandler) parseDeposit(l types.Log) (*events.AcrossDeposit,
 	err := h.abi.UnpackIntoInterface(&d, "V3FundsDeposited", l.Data)
 	return d, err
 }
+
+func (h *AcrossMessageHandler) unlockHash(deposit *events.AcrossDeposit) ([]byte, error) {
+	calldata, err := deposit.ToV3RelayData(h.sourceChainID).Calldata()
+	if err != nil {
+		return []byte{}, nil
+	}
+
+	encodedData := crypto.Keccak256(
+		crypto.Keccak256(
+			[]byte(
+				"Borrow(address borrowToken,uint256 amount,address target,bytes targetCallData,uint256 nonce,uint256 deadline)",
+			),
+		),
+		deposit.OutputToken[12:],
+		deposit.OutputAmount.Bytes(),
+		deposit.Recipient[12:],
+		calldata,
+		common.LeftPadBytes(h.nonce(deposit).Bytes(), 32),
+		new(big.Int).SetUint64(uint64(deposit.FillDeadline)).Bytes(),
+	)
+
+	poolAddress := h.pools[h.sourceChainID.Uint64()]
+	typedData := apitypes.TypedData{
+		Domain: apitypes.TypedDataDomain{
+			Name:              DOMAIN_NAME,
+			ChainId:           math.NewHexOrDecimal256(deposit.DestinationChainId.Int64()),
+			Version:           VERSION,
+			VerifyingContract: poolAddress.Hex(),
+		},
+	}
+	domainSeparator, err := typedData.HashStruct("EIP712Domain", typedData.Domain.Map())
+	if err != nil {
+		return []byte{}, err
+	}
+
+	rawData := []byte(fmt.Sprintf("\x19\x01%s%s", string(domainSeparator), string(encodedData)))
+	return crypto.Keccak256(rawData), nil
+}
+
+// nonce creates a unique ID from the across deposit id, origin chain id and protocol id.
+// Resulting id has this format: [originChainID (8 bits)][protocolID (8 bits)][nonce (240 bits)].
+func (h *AcrossMessageHandler) nonce(deposit *events.AcrossDeposit) *big.Int {
+	// Create a new big.Int
+	nonce := new(big.Int)
+
+	// Set originChainID (64 bits)
+	nonce.SetInt64(h.sourceChainID.Int64())
+	nonce.Lsh(nonce, 256) // Shift left by 320 bits (248 + 8)
+
+	// Add protocolID in the middle (shifted left by 248 bits)
+	protocolInt := big.NewInt(PROTOCOL_ID)
+	protocolInt.Lsh(protocolInt, 248)
+	nonce.Or(nonce, protocolInt)
+
+	// Add nonce at the end
+	nonce.Or(nonce, deposit.DepositId)
+
+	return nonce
+}
