feat: lifi escrow message handler

.github/workflows/mocks.yml

@@ -3,16 +3,21 @@
 
 on: [pull_request]
 name: Mocks check
+
 env:
   GO111MODULE: on
   GOPRIVATE: github.com/sprintertech
+  TOKEN: ${{ secrets.REPO_ACCESS_TOKEN }}
 
 jobs:
   mocks-check:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
 
+      - name: setup git access to private repos
+        run: git config --global url."https://${TOKEN}:[email protected]/sprintertech/".insteadOf "https://github.com/sprintertech/"
+
       - uses: actions/setup-go@v2
         with:
           go-version: "^1.23"

Makefile

@@ -37,9 +37,11 @@ genmocks:
 	mockgen -destination=./comm/p2p/mock/stream/stream.go github.com/libp2p/go-libp2p/core/network Stream,Conn
 	mockgen -source=./chains/evm/message/across.go -destination=./chains/evm/message/mock/across.go
 	mockgen -source=./chains/evm/message/rhinestone.go -destination=./chains/evm/message/mock/rhinestone.go
+	mockgen -source=./chains/evm/message/lifiEscrow.go -destination=./chains/evm/message/mock/lifiEscrow.go
 	mockgen -source=./chains/evm/message/mayan.go -destination=./chains/evm/message/mock/mayan.go
 	mockgen -source=./chains/evm/message/confirmations.go -destination=./chains/evm/message/mock/confirmations.go
 	mockgen -source=./api/handlers/signing.go -destination=./api/handlers/mock/signing.go
+	mockgen -package mock_message -destination=./chains/evm/message/mock/pricing.go github.com/sprintertech/lifi-solver/pkg/pricing OrderPricer
 
 
 

api/handlers/signing.go

@@ -20,6 +20,7 @@ const (
 	AcrossProtocol     ProtocolType = "across"
 	MayanProtocol      ProtocolType = "mayan"
 	RhinestoneProtocol ProtocolType = "rhinestone"
+	LifiEscrow         ProtocolType = "lifi-escrow"
 	LifiProtocol       ProtocolType = "lifi"
 )
 
@@ -112,6 +113,19 @@ func (h *SigningHandler) HandleSigning(w http.ResponseWriter, r *http.Request) {
 				BorrowAmount:  b.BorrowAmount.Int,
 			})
 		}
+	case LifiEscrow:
+		{
+			m = evmMessage.NewLifiEscrowData(0, b.ChainId, &evmMessage.LifiEscrowData{
+				OrderID:       b.DepositId,
+				Nonce:         b.Nonce.Int,
+				LiquidityPool: common.HexToAddress(b.LiquidityPool),
+				Caller:        common.HexToAddress(b.Caller),
+				ErrChn:        errChn,
+				Source:        0,
+				Destination:   b.ChainId,
+				BorrowAmount:  b.BorrowAmount.Int,
+			})
+		}
 	default:
 		JSONError(w, fmt.Errorf("invalid protocol %s", b.Protocol), http.StatusBadRequest)
 		return

api/handlers/signing_test.go

@@ -360,6 +360,40 @@ func (s *SigningHandlerTestSuite) Test_HandleSigning_RhinestoneSuccess() {
 	s.Equal(http.StatusAccepted, recorder.Code)
 }
 
+func (s *SigningHandlerTestSuite) Test_HandleSigning_LifiSuccess() {
+	msgChn := make(chan []*message.Message)
+	handler := handlers.NewSigningHandler(msgChn, s.chains)
+
+	input := handlers.SigningBody{
+		DepositId:     "depositID",
+		Protocol:      "lifi-escrow",
+		LiquidityPool: "0xbe526bA5d1ad94cC59D7A79d99A59F607d31A657",
+		Caller:        "0xbe526bA5d1ad94cC59D7A79d99A59F607d31A657",
+		Calldata:      "0xbe5",
+		Nonce:         &handlers.BigInt{big.NewInt(1001)},
+		BorrowAmount:  &handlers.BigInt{big.NewInt(1000)},
+	}
+	body, _ := json.Marshal(input)
+
+	req := httptest.NewRequest(http.MethodPost, "/v1/chains/1/signatures", bytes.NewReader(body))
+	req = mux.SetURLVars(req, map[string]string{
+		"chainId": "1",
+	})
+	req.Header.Set("Content-Type", "application/json")
+
+	recorder := httptest.NewRecorder()
+
+	go func() {
+		msg := <-msgChn
+		ad := msg[0].Data.(*across.LifiEscrowData)
+		ad.ErrChn <- nil
+	}()
+
+	handler.HandleSigning(recorder, req)
+
+	s.Equal(http.StatusAccepted, recorder.Code)
+}
+
 type StatusHandlerTestSuite struct {
 	suite.Suite
 

app/app.go

@@ -18,6 +18,11 @@ import (
 	"github.com/libp2p/go-libp2p/core/crypto"
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/viper"
+	"github.com/sprintertech/lifi-solver/pkg/pricing"
+	lifiTypes "github.com/sprintertech/lifi-solver/pkg/protocols/lifi"
+	"github.com/sprintertech/lifi-solver/pkg/protocols/lifi/validation"
+	"github.com/sprintertech/lifi-solver/pkg/token"
+	"github.com/sprintertech/lifi-solver/pkg/tokenpricing/pyth"
 	solverConfig "github.com/sprintertech/solver-config/go/config"
 	"github.com/sprintertech/sprinter-signing/api"
 	"github.com/sprintertech/sprinter-signing/api/handlers"
@@ -36,6 +41,7 @@ import (
 	"github.com/sprintertech/sprinter-signing/metrics"
 	"github.com/sprintertech/sprinter-signing/price"
 	"github.com/sprintertech/sprinter-signing/protocol/across"
+	"github.com/sprintertech/sprinter-signing/protocol/lifi"
 	"github.com/sprintertech/sprinter-signing/protocol/mayan"
 	"github.com/sprintertech/sprinter-signing/topology"
 	"github.com/sprintertech/sprinter-signing/tss"
@@ -153,6 +159,7 @@ func Run() error {
 	var hubPoolContract across.TokenMatcher
 	acrossPools := make(map[uint64]common.Address)
 	mayanPools := make(map[uint64]common.Address)
+	lifiOutputSettlers := make(map[uint64]common.Address)
 	repayerAddresses := make(map[uint64]common.Address)
 	tokens := make(map[uint64]map[string]config.TokenConfig)
 	for _, chainConfig := range configuration.ChainConfigs {
@@ -175,6 +182,11 @@ func Run() error {
 					mayanPools[*c.GeneralChainConfig.Id] = poolAddress
 				}
 
+				if c.LifiOutputSettler != "" {
+					settlerAddress := common.HexToAddress(c.LifiOutputSettler)
+					lifiOutputSettlers[*c.GeneralChainConfig.Id] = settlerAddress
+				}
+
 				if c.AcrossHubPool != "" {
 					hubPoolAddress := common.HexToAddress(c.AcrossHubPool)
 					hubPoolContract = contracts.NewHubPoolContract(client, hubPoolAddress, c.Tokens)
@@ -269,6 +281,32 @@ func Run() error {
 					confirmationsPerChain[*c.GeneralChainConfig.Id] = c.ConfirmationsByValue
 				}
 
+				if c.LifiOutputSettler != "" {
+					usdPricer := pyth.NewClient(ctx)
+					resolver := token.NewTokenResolver(solverConfig, usdPricer)
+					orderPricer := pricing.NewStandardPricer(resolver)
+					lifiApi := lifi.NewLifiAPI()
+					lifiValidator := validation.NewLifiEscrowOrderValidator[lifiTypes.LifiOrder](solverConfig, orderPricer)
+
+					lifiMh := evmMessage.NewLifiEscrowMessageHandler(
+						*c.GeneralChainConfig.Id,
+						lifiOutputSettlers,
+						coordinator,
+						host,
+						communication,
+						keyshareStore,
+						watcher,
+						tokenStore,
+						lifiApi,
+						orderPricer,
+						lifiValidator,
+						sigChn,
+					)
+					mh.RegisterMessageHandler(evmMessage.LifiEscrowMessage, lifiMh)
+					supportedChains[*c.GeneralChainConfig.Id] = struct{}{}
+					confirmationsPerChain[*c.GeneralChainConfig.Id] = c.ConfirmationsByValue
+				}
+
 				lifiUnlockMh := evmMessage.NewLifiUnlockHandler(
 					*c.GeneralChainConfig.Id,
 					repayerAddresses,

chains/evm/calls/consts/lifi.go

@@ -0,0 +1,33 @@
+package consts
+
+import (
+	"strings"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+)
+
+var LifiABI, _ = abi.JSON(strings.NewReader(`[{
+  "name": "fillOrderOutputs",
+  "type": "function",
+  "stateMutability": "nonpayable",
+  "inputs": [
+    {"name": "fillDeadline", "type": "uint32"},
+    {"name": "orderId", "type": "bytes32"},
+    {
+      "name": "outputs",
+      "type": "tuple[]",
+      "components": [
+        {"name": "oracle", "type": "bytes32"},
+        {"name": "settler", "type": "bytes32"},
+        {"name": "chainId", "type": "uint256"},
+        {"name": "token", "type": "bytes32"},
+        {"name": "amount", "type": "uint256"},
+        {"name": "recipient", "type": "bytes32"},
+        {"name": "call", "type": "bytes"},
+        {"name": "context", "type": "bytes"}
+      ]
+    },
+    {"name": "proposedSolver", "type": "bytes32"}
+  ],
+  "outputs": []
+}]`))

chains/evm/config.go

@@ -21,10 +21,11 @@ type EVMConfig struct {
 	GeneralChainConfig chain.GeneralChainConfig
 	Admin              string
 
-	AcrossPool    string
-	AcrossHubPool string
-	MayanSwift    string
-	Repayer       string
+	AcrossPool        string
+	AcrossHubPool     string
+	MayanSwift        string
+	LifiOutputSettler string
+	Repayer           string
 
 	Tokens map[string]config.TokenConfig
 	// usd bucket -> confirmations
@@ -102,6 +103,8 @@ func NewEVMConfig(chainConfig map[string]interface{}, solverConfig solverConfig.
 
 		MayanSwift: solverConfig.ProtocolsMetadata.Mayan.SwiftContracts[id],
 
+		LifiOutputSettler: solverConfig.ProtocolsMetadata.Lifi.OutputSettler,
+
 		// nolint:gosec
 		BlockRetryInterval: time.Duration(c.BlockRetryInterval) * time.Second,
 		BlockInterval:      big.NewInt(c.BlockInterval),

chains/evm/config_test.go

@@ -107,6 +107,9 @@ func (s *NewEVMConfigTestSuite) Test_ValidConfig() {
 					"eip155:1": "repayer",
 				},
 			},
+			Lifi: &solverConfig.LifiMetadata{
+				OutputSettler: "settler",
+			},
 		},
 	})
 
@@ -128,6 +131,7 @@ func (s *NewEVMConfigTestSuite) Test_ValidConfig() {
 		AcrossPool:           "acrossPool",
 		AcrossHubPool:        "acrossHubPool",
 		MayanSwift:           "mayanSwift",
+		LifiOutputSettler:    "settler",
 		ConfirmationsByValue: make(map[uint64]uint64),
 		Tokens:               make(map[string]config.TokenConfig),
 	})
@@ -215,6 +219,9 @@ func (s *NewEVMConfigTestSuite) Test_ValidConfigWithCustomTxParams() {
 					"eip155:1": "repayer",
 				},
 			},
+			Lifi: &solverConfig.LifiMetadata{
+				OutputSettler: "settler",
+			},
 		},
 	})
 
@@ -235,6 +242,7 @@ func (s *NewEVMConfigTestSuite) Test_ValidConfigWithCustomTxParams() {
 		AcrossPool:           "acrossPool",
 		AcrossHubPool:        "acrossHubPool",
 		MayanSwift:           "mayanSwift",
+		LifiOutputSettler:    "settler",
 		Repayer:              "repayer",
 		ConfirmationsByValue: expectedBlockConfirmations,
 		Tokens:               expectedTokens,

chains/evm/message/across.go

@@ -36,12 +36,17 @@ type Coordinator interface {
 }
 
 type ConfirmationWatcher interface {
-	WaitForConfirmations(
+	WaitForTokenConfirmations(
 		ctx context.Context,
 		chainID uint64,
 		txHash common.Hash,
 		token common.Address,
 		amount *big.Int) error
+	WaitForOrderConfirmations(
+		ctx context.Context,
+		chainID uint64,
+		txHash common.Hash,
+		orderValue float64) error
 }
 
 type DepositFetcher interface {
@@ -117,7 +122,7 @@ func (h *AcrossMessageHandler) HandleMessage(m *message.Message) (*proposal.Prop
 		return nil, err
 	}
 
-	err = h.confirmationWatcher.WaitForConfirmations(
+	err = h.confirmationWatcher.WaitForTokenConfirmations(
 		context.Background(),
 		h.chainID,
 		data.DepositTxHash,
@@ -136,7 +141,7 @@ func (h *AcrossMessageHandler) HandleMessage(m *message.Message) (*proposal.Prop
 		return nil, err
 	}
 
-	unlockHash, err := unlockHash(
+	unlockHash, err := borrowUnlockHash(
 		calldata,
 		d.OutputAmount,
 		common.BytesToAddress(d.OutputToken[12:]),

chains/evm/message/across_test.go

@@ -187,7 +187,7 @@ func (s *AcrossMessageHandlerTestSuite) Test_HandleMessage_ValidDeposit() {
 	}
 	s.mockDepositFetcher.EXPECT().Deposit(gomock.Any(), gomock.Any(), gomock.Any()).Return(deposit, nil)
 
-	s.mockWatcher.EXPECT().WaitForConfirmations(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
+	s.mockWatcher.EXPECT().WaitForTokenConfirmations(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
 	s.mockCoordinator.EXPECT().Execute(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
 
 	errChn := make(chan error, 1)