feat(rfq-guard): v2 guard logic [SLT-387]

services/rfq/guard/guardconfig/config.go

@@ -34,8 +34,10 @@ type Config struct {
 
 // ChainConfig represents the configuration for a chain.
 type ChainConfig struct {
-	// Bridge is the rfq bridge contract address.
-	RFQAddress string `yaml:"rfq_address"`
+	// RFQAddressV1 is the rfq bridge contract address.
+	RFQAddressV1 *string `yaml:"rfq_address_v1"`
+	// RFQAddressV2 is the rfq bridge contract address.
+	RFQAddressV2 string `yaml:"rfq_address_v2"`
 	// Confirmations is the number of required confirmations.
 	Confirmations uint64 `yaml:"confirmations"`
 }
@@ -66,12 +68,19 @@ func LoadConfig(path string) (config Config, err error) {
 // Validate validates the config.
 func (c Config) Validate() (err error) {
 	for chainID := range c.Chains {
-		addr, err := c.GetRFQAddress(chainID)
+		addrV1, err := c.GetRFQAddressV1(chainID)
 		if err != nil {
 			return fmt.Errorf("could not get rfq address: %w", err)
 		}
-		if !common.IsHexAddress(addr) {
-			return fmt.Errorf("invalid rfq address: %s", addr)
+		if addrV1 != nil && !common.IsHexAddress(*addrV1) {
+			return fmt.Errorf("invalid rfq address: %s", *addrV1)
+		}
+		addrV2, err := c.GetRFQAddressV2(chainID)
+		if err != nil {
+			return fmt.Errorf("could not get rfq address: %w", err)
+		}
+		if !common.IsHexAddress(addrV2) {
+			return fmt.Errorf("invalid rfq address: %s", addrV2)
 		}
 	}
 
@@ -83,13 +92,22 @@ func (c Config) GetChains() map[int]ChainConfig {
 	return c.Chains
 }
 
-// GetRFQAddress returns the RFQ address for the given chain.
-func (c Config) GetRFQAddress(chainID int) (string, error) {
+// GetRFQAddressV1 returns the RFQ address for the given chain.
+func (c Config) GetRFQAddressV1(chainID int) (*string, error) {
+	chainCfg, ok := c.Chains[chainID]
+	if !ok {
+		return nil, fmt.Errorf("chain config not found for chain %d", chainID)
+	}
+	return chainCfg.RFQAddressV1, nil
+}
+
+// GetRFQAddressV2 returns the RFQ address for the given chain.
+func (c Config) GetRFQAddressV2(chainID int) (string, error) {
 	chainCfg, ok := c.Chains[chainID]
 	if !ok {
 		return "", fmt.Errorf("chain config not found for chain %d", chainID)
 	}
-	return chainCfg.RFQAddress, nil
+	return chainCfg.RFQAddressV2, nil
 }
 
 const defaultDBSelectorIntervalSeconds = 1
@@ -115,7 +133,8 @@ func NewGuardConfigFromRelayer(relayerCfg relconfig.Config) Config {
 	}
 	for chainID, chainCfg := range relayerCfg.GetChains() {
 		cfg.Chains[chainID] = ChainConfig{
-			RFQAddress:    chainCfg.RFQAddress,
+			RFQAddressV1:  chainCfg.RFQAddressV1,
+			RFQAddressV2:  chainCfg.RFQAddress,
 			Confirmations: chainCfg.FinalityConfirmations,
 		}
 	}

services/rfq/guard/guarddb/base/model.go

@@ -36,6 +36,8 @@ type PendingProvenModel struct {
 	Origin uint32
 	// RelayerAddress is the address of the relayer that called prove()
 	RelayerAddress string
+	// FastBridgeAddress is the address of the fast bridge contract
+	FastBridgeAddress string
 	// TransactionID is the transaction id of the event
 	TransactionID string `gorm:"column:transaction_id;primaryKey"`
 	// TxHash is the hash of the relay transaction on destination
@@ -49,12 +51,13 @@ type PendingProvenModel struct {
 // FromPendingProven converts a quote request to an object that can be stored in the db.
 func FromPendingProven(proven guarddb.PendingProven) PendingProvenModel {
 	return PendingProvenModel{
-		Origin:         proven.Origin,
-		RelayerAddress: proven.RelayerAddress.Hex(),
-		TransactionID:  hexutil.Encode(proven.TransactionID[:]),
-		TxHash:         proven.TxHash.Hex(),
-		Status:         proven.Status,
-		BlockNumber:    proven.BlockNumber,
+		Origin:            proven.Origin,
+		RelayerAddress:    proven.RelayerAddress.Hex(),
+		FastBridgeAddress: proven.FastBridgeAddress.Hex(),
+		TransactionID:     hexutil.Encode(proven.TransactionID[:]),
+		TxHash:            proven.TxHash.Hex(),
+		Status:            proven.Status,
+		BlockNumber:       proven.BlockNumber,
 	}
 }
 

services/rfq/guard/guarddb/db.go

@@ -59,12 +59,13 @@ type BridgeRequest struct {
 
 // PendingProven is the pending proven object.
 type PendingProven struct {
-	Origin         uint32
-	RelayerAddress common.Address
-	TransactionID  [32]byte
-	TxHash         common.Hash
-	Status         PendingProvenStatus
-	BlockNumber    uint64
+	Origin            uint32
+	RelayerAddress    common.Address
+	FastBridgeAddress common.Address
+	TransactionID     [32]byte
+	TxHash            common.Hash
+	Status            PendingProvenStatus
+	BlockNumber       uint64
 }
 
 // PendingProvenStatus is the status of a quote request in the db.

services/rfq/guard/service/guard.go

@@ -17,6 +17,7 @@
 	"github.com/synapsecns/sanguine/ethergo/submitter"
 	omniClient "github.com/synapsecns/sanguine/services/omnirpc/client"
 	"github.com/synapsecns/sanguine/services/rfq/contracts/fastbridge"
+	"github.com/synapsecns/sanguine/services/rfq/contracts/fastbridgev2"
 	"github.com/synapsecns/sanguine/services/rfq/guard/guardconfig"
 	"github.com/synapsecns/sanguine/services/rfq/guard/guarddb"
 	"github.com/synapsecns/sanguine/services/rfq/guard/guarddb/connect"
@@ -29,22 +30,23 @@
 
 // Guard monitors calls to prove() and verifies them.
 type Guard struct {
-	cfg            guardconfig.Config
-	metrics        metrics.Handler
-	db             guarddb.Service
-	client         omniClient.RPCClient
-	chainListeners map[int]listener.ContractListener
-	contracts      map[int]*fastbridge.FastBridgeRef
-	txSubmitter    submitter.TransactionSubmitter
-	otelRecorder   iOtelRecorder
+	cfg          guardconfig.Config
+	metrics      metrics.Handler
+	db           guarddb.Service
+	client       omniClient.RPCClient
+	contractsV1  map[int]*fastbridge.FastBridgeRef
+	contractsV2  map[int]*fastbridgev2.FastBridgeV2Ref
+	listenersV1  map[int]listener.ContractListener
+	listenersV2  map[int]listener.ContractListener
+	txSubmitter  submitter.TransactionSubmitter
+	otelRecorder iOtelRecorder
 }
 
 // NewGuard creates a new Guard.
 //
 //nolint:cyclop
 func NewGuard(ctx context.Context, metricHandler metrics.Handler, cfg guardconfig.Config, txSubmitter submitter.TransactionSubmitter) (*Guard, error) {
 	omniClient := omniClient.NewOmnirpcClient(cfg.OmniRPCURL, metricHandler, omniClient.WithCaptureReqRes())
-	chainListeners := make(map[int]listener.ContractListener)
 
 	dbType, err := dbcommon.DBTypeFromString(cfg.Database.Type)
 	if err != nil {
@@ -55,37 +57,62 @@
 		return nil, fmt.Errorf("could not make db: %w", err)
 	}
 
+	contractsV1 := make(map[int]*fastbridge.FastBridgeRef)
+	contractsV2 := make(map[int]*fastbridgev2.FastBridgeV2Ref)
+	listenersV1 := make(map[int]listener.ContractListener)
+	listenersV2 := make(map[int]listener.ContractListener)
+
 	// setup chain listeners
-	contracts := make(map[int]*fastbridge.FastBridgeRef)
 	for chainID := range cfg.GetChains() {
-		rfqAddr, err := cfg.GetRFQAddress(chainID)
+		// setup v1
+		rfqAddrV1, err := cfg.GetRFQAddressV1(chainID)
+		if err != nil {
+			return nil, fmt.Errorf("could not get rfq address: %w", err)
+		}
+		if rfqAddrV1 != nil {
+			chainClient, err := omniClient.GetChainClient(ctx, chainID)
+			if err != nil {
+				return nil, fmt.Errorf("could not get chain client: %w", err)
+			}
+			contract, err := fastbridge.NewFastBridgeRef(common.HexToAddress(*rfqAddrV1), chainClient)
+			if err != nil {
+				return nil, fmt.Errorf("could not create fast bridge contract: %w", err)
+			}
+			startBlock, err := contract.DeployBlock(&bind.CallOpts{Context: ctx})
+			if err != nil {
+				return nil, fmt.Errorf("could not get deploy block: %w", err)
+			}
+			chainListener, err := listener.NewChainListener(chainClient, store, common.HexToAddress(*rfqAddrV1), uint64(startBlock.Int64()), metricHandler, listener.WithName("guard"))
+			if err != nil {
+				return nil, fmt.Errorf("could not get chain listener: %w", err)
+			}
+			listenersV1[chainID] = chainListener
+			contractsV1[chainID] = contract
+		}
+
+		// setup v2
+		rfqAddrV2, err := cfg.GetRFQAddressV2(chainID)
 		if err != nil {
 			return nil, fmt.Errorf("could not get rfq address: %w", err)
 		}
 		chainClient, err := omniClient.GetChainClient(ctx, chainID)
 		if err != nil {
 			return nil, fmt.Errorf("could not get chain client: %w", err)
 		}
-
-		contract, err := fastbridge.NewFastBridgeRef(common.HexToAddress(rfqAddr), chainClient)
+		contract, err := fastbridgev2.NewFastBridgeV2Ref(common.HexToAddress(rfqAddrV2), chainClient)
 		if err != nil {
 			return nil, fmt.Errorf("could not create fast bridge contract: %w", err)
 		}
 		startBlock, err := contract.DeployBlock(&bind.CallOpts{Context: ctx})
 		if err != nil {
 			return nil, fmt.Errorf("could not get deploy block: %w", err)
 		}
-		chainListener, err := listener.NewChainListener(chainClient, store, common.HexToAddress(rfqAddr), uint64(startBlock.Int64()), metricHandler, listener.WithName("guard"))
+		chainListener, err := listener.NewChainListener(chainClient, store, common.HexToAddress(rfqAddrV2), uint64(startBlock.Int64()), metricHandler, listener.WithName("guard"))
 		if err != nil {
 			return nil, fmt.Errorf("could not get chain listener: %w", err)
 		}
-		chainListeners[chainID] = chainListener
-
-		// setup FastBridge contract on this chain
-		contracts[chainID], err = fastbridge.NewFastBridgeRef(common.HexToAddress(rfqAddr), chainClient)
-		if err != nil {
-			return nil, fmt.Errorf("could not create bridge contract: %w", err)
-		}
+		listenersV2[chainID] = chainListener
+		contractsV2[chainID] = contract
 	}
 
 	// build submitter from config if one is not supplied
@@ -103,14 +130,16 @@
 	}
 
 	return &Guard{
-		cfg:            cfg,
-		metrics:        metricHandler,
-		db:             store,
-		client:         omniClient,
-		chainListeners: chainListeners,
-		contracts:      contracts,
-		txSubmitter:    txSubmitter,
-		otelRecorder:   otelRecorder,
+		cfg:          cfg,
+		metrics:      metricHandler,
+		db:           store,
+		client:       omniClient,
+		contractsV1:  contractsV1,
+		contractsV2:  contractsV2,
+		listenersV1:  listenersV1,
+		listenersV2:  listenersV2,
+		txSubmitter:  txSubmitter,
+		otelRecorder: otelRecorder,
 	}, nil
 }
 
@@ -173,10 +202,26 @@
 	for chainID := range g.cfg.GetChains() {
 		//nolint: copyloopvar
 		chainID := chainID // capture loop variable
+
+		// only run v1 if it is set
+		v1Addr, err := g.cfg.GetRFQAddressV1(chainID)
+		if err != nil {
+			return fmt.Errorf("could not get rfq address v1: %w", err)
+		}
+		if v1Addr != nil {
+			group.Go(func() error {
+				err := g.runChainIndexerV1(ctx, chainID)
+				if err != nil {
+					return fmt.Errorf("could not runChainIndexer chain indexer for chain %d [v1]: %w", chainID, err)
+				}
+				return nil
+			})
+		}
+
 		group.Go(func() error {
-			err := g.runChainIndexer(ctx, chainID)
+			err := g.runChainIndexerV2(ctx, chainID)
 			if err != nil {
-				return fmt.Errorf("could not runChainIndexer chain indexer for chain %d: %w", chainID, err)
+				return fmt.Errorf("could not runChainIndexer chain indexer for chain %d [v2]: %w", chainID, err)
 			}
 			return nil
 		})
@@ -191,8 +236,8 @@
 }
 
 //nolint:cyclop
-func (g Guard) runChainIndexer(ctx context.Context, chainID int) (err error) {
-	chainListener := g.chainListeners[chainID]
+func (g Guard) runChainIndexerV1(ctx context.Context, chainID int) (err error) {
+	chainListener := g.listenersV1[chainID]
 
 	parser, err := fastbridge.NewParser(chainListener.Address())
 	if err != nil {
@@ -247,6 +292,75 @@
 	return nil
 }
 
+//nolint:cyclop
+func (g Guard) runChainIndexerV2(ctx context.Context, chainID int) (err error) {
+	chainListener := g.listenersV2[chainID]
+
+	parser, err := fastbridgev2.NewParser(chainListener.Address())
+	if err != nil {
+		return fmt.Errorf("could not parse: %w", err)
+	}
+
+	err = chainListener.Listen(ctx, func(parentCtx context.Context, log types.Log) (err error) {
+		et, parsedEvent, ok := parser.ParseEvent(log)
+		// handle unknown event
+		if !ok {
+			if len(log.Topics) != 0 {
+				logger.Warnf("unknown event %s", log.Topics[0])
+			}
+			return nil
+		}
+
+		ctx, span := g.metrics.Tracer().Start(parentCtx, fmt.Sprintf("handleLog-%s", et), trace.WithAttributes(
+			attribute.String(metrics.TxHash, log.TxHash.String()),
+			attribute.Int(metrics.Origin, chainID),
+			attribute.String(metrics.Contract, log.Address.String()),
+			attribute.String("block_hash", log.BlockHash.String()),
+			attribute.Int64("block_number", int64(log.BlockNumber)),
+		))
+
+		defer func() {
+			metrics.EndSpanWithErr(span, err)
+		}()
+
+		switch event := parsedEvent.(type) {
+		case *fastbridgev2.FastBridgeV2BridgeRequested:
+			v1Event := &fastbridge.FastBridgeBridgeRequested{
+				TransactionId: event.TransactionId,
+				Sender:        event.Sender,
+				Request:       event.Request,
+				DestChainId:   event.DestChainId,
+				OriginToken:   event.OriginToken,
+				DestToken:     event.DestToken,
+				DestAmount:    event.DestAmount,
+				SendChainGas:  event.SendChainGas,
+				Raw:           event.Raw,
+			}
+			err = g.handleBridgeRequestedLog(ctx, v1Event, chainID)
+			if err != nil {
+				return fmt.Errorf("could not handle request: %w", err)
+			}
+		// following events match ABIs exactly, so no need to differentiate
+		case *fastbridge.FastBridgeBridgeProofProvided:
+			err = g.handleProofProvidedLog(ctx, event, chainID)
+			if err != nil {
+				return fmt.Errorf("could not handle request: %w", err)
+			}
+		case *fastbridge.FastBridgeBridgeProofDisputed:
+			err = g.handleProofDisputedLog(ctx, event)
+			if err != nil {
+				return fmt.Errorf("could not handle request: %w", err)
+			}
+		}
+
+		return nil
+	})
+	if err != nil {
+		return fmt.Errorf("listener failed: %w", err)
+	}
+	return nil
+}
+
 func (g *Guard) processDB(ctx context.Context) (err error) {
 	provens, err := g.db.GetPendingProvensByStatus(ctx, guarddb.ProveCalled)
 	if err != nil {
@@ -262,3 +376,11 @@
 
 	return nil
 }
+
+func (g *Guard) isV2Address(chainID int, addr common.Address) bool {
+	rfqAddr, err := g.cfg.GetRFQAddressV2(chainID)
+	if err != nil {
+		return false
+	}
+	return addr == common.HexToAddress(rfqAddr)
+}