certusone
/
wormhole
mirror of https://github.com/certusone/wormhole.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

node: Bedrock changes

This commit is contained in:
Paul Noel 2023-02-15 17:52:31 +00:00 committed by Evan Gray
parent 6a1271c824
commit ae7de3d575
2 changed files with 57 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
node/cmd/guardiand/node.go
View File

@ -1232,21 +1232,20 @@ func runNode(cmd *cobra.Command, args []string) {
}
}
if shouldStart(optimismRPC) {
if ethWatcher == nil {
log.Fatalf("if optimism is enabled then ethereum must also be enabled.")
}
if !*unsafeDevMode {
if *optimismCtcRpc == "" || *optimismCtcContractAddress == "" {
log.Fatalf("--optimismCtcRpc and --optimismCtcContractAddress both need to be set.")
}
}
logger.Info("Starting Optimism watcher")
readiness.RegisterComponent(common.ReadinessOptimismSyncing)
chainObsvReqC[vaa.ChainIDOptimism] = make(chan *gossipv1.ObservationRequest, observationRequestBufferSize)
optimismWatcher := evm.NewEthWatcher(*optimismRPC, optimismContractAddr, "optimism", common.ReadinessOptimismSyncing, vaa.ChainIDOptimism, chainMsgC[vaa.ChainIDOptimism], nil, chainObsvReqC[vaa.ChainIDOptimism], *unsafeDevMode)
optimismWatcher.SetL1Finalizer(ethWatcher)
if err := optimismWatcher.SetRootChainParams(*optimismCtcRpc, *optimismCtcContractAddress); err != nil {
return err
// If rootChainParams are set, pass them in for pre-Bedrock mode
if *optimismCtcRpc != "" || *optimismCtcContractAddress != "" {
if ethWatcher == nil {
log.Fatalf("if optimism (pre-bedrock) is enabled then ethereum must also be enabled.")
}
optimismWatcher.SetL1Finalizer(ethWatcher)
if err := optimismWatcher.SetRootChainParams(*optimismCtcRpc, *optimismCtcContractAddress); err != nil {
return err
}
}
if err := supervisor.Run(ctx, "optimismwatch", common.WrapWithScissors(optimismWatcher.Run, "optimismwatch")); err != nil {
return err

66
node/pkg/watchers/evm/watcher.go
View File

@ -279,25 +279,53 @@ func (w *Watcher) Run(ctx context.Context) error {
return fmt.Errorf("creating arbitrum connector failed: %w", err)
}
} else if w.chainID == vaa.ChainIDOptimism && !w.unsafeDevMode {
if w.l1Finalizer == nil {
return fmt.Errorf("unable to create optimism watcher because the l1 finalizer is not set")
}
baseConnector, err := connectors.NewEthereumConnector(timeout, w.networkName, w.url, w.contract, logger)
if err != nil {
ethConnectionErrors.WithLabelValues(w.networkName, "dial_error").Inc()
p2p.DefaultRegistry.AddErrorCount(w.chainID, 1)
return fmt.Errorf("dialing eth client failed: %w", err)
}
finalizer, err := finalizers.NewOptimismFinalizer(timeout, logger, w.l1Finalizer, w.rootChainRpc, w.rootChainContract)
if err != nil {
p2p.DefaultRegistry.AddErrorCount(w.chainID, 1)
return fmt.Errorf("creating optimism finalizer failed: %w", err)
}
w.ethConn, err = connectors.NewBlockPollConnector(ctx, baseConnector, finalizer, 250*time.Millisecond, false, false)
if err != nil {
ethConnectionErrors.WithLabelValues(w.networkName, "dial_error").Inc()
p2p.DefaultRegistry.AddErrorCount(w.chainID, 1)
return fmt.Errorf("creating block poll connector failed: %w", err)
if w.rootChainRpc != "" && w.rootChainContract != "" {
// We are in pre-Bedrock mode
if w.l1Finalizer == nil {
return fmt.Errorf("unable to create optimism watcher because the l1 finalizer is not set")
}
baseConnector, err := connectors.NewEthereumConnector(timeout, w.networkName, w.url, w.contract, logger)
if err != nil {
ethConnectionErrors.WithLabelValues(w.networkName, "dial_error").Inc()
p2p.DefaultRegistry.AddErrorCount(w.chainID, 1)
return fmt.Errorf("dialing eth client failed: %w", err)
}
finalizer, err := finalizers.NewOptimismFinalizer(timeout, logger, w.l1Finalizer, w.rootChainRpc, w.rootChainContract)
if err != nil {
p2p.DefaultRegistry.AddErrorCount(w.chainID, 1)
return fmt.Errorf("creating optimism finalizer failed: %w", err)
}
w.ethConn, err = connectors.NewBlockPollConnector(ctx, baseConnector, finalizer, 250*time.Millisecond, false, false)
if err != nil {
ethConnectionErrors.WithLabelValues(w.networkName, "dial_error").Inc()
p2p.DefaultRegistry.AddErrorCount(w.chainID, 1)
return fmt.Errorf("creating block poll connector failed: %w", err)
}
} else {
// We are in Bedrock mode
useFinalizedBlocks = true
safeBlocksSupported := true
logger.Info("using finalized blocks, will publish safe blocks")
baseConnector, err := connectors.NewEthereumConnector(timeout, w.networkName, w.url, w.contract, logger)
if err != nil {
ethConnectionErrors.WithLabelValues(w.networkName, "dial_error").Inc()
p2p.DefaultRegistry.AddErrorCount(w.chainID, 1)
return fmt.Errorf("dialing eth client failed: %w", err)
}
pollConnector, err := connectors.NewBlockPollConnector(ctx, baseConnector, finalizers.NewDefaultFinalizer(), 250*time.Millisecond, useFinalizedBlocks, safeBlocksSupported)
if err != nil {
ethConnectionErrors.WithLabelValues(w.networkName, "dial_error").Inc()
p2p.DefaultRegistry.AddErrorCount(w.chainID, 1)
return fmt.Errorf("creating block poll connector failed: %w", err)
}
// I know this says Arbitrum. That's just what the type is called.
// But we need it the TimeOfBlockByHash() implementation.
w.ethConn, err = connectors.NewArbitrumConnector(ctx, pollConnector)
if err != nil {
ethConnectionErrors.WithLabelValues(w.networkName, "dial_error").Inc()
p2p.DefaultRegistry.AddErrorCount(w.chainID, 1)
return fmt.Errorf("creating optimism connector failed: %w", err)
}
}
} else if w.chainID == vaa.ChainIDPolygon && w.usePolygonCheckpointing() {
baseConnector, err := connectors.NewEthereumConnector(timeout, w.networkName, w.url, w.contract, logger)