op-deployer: Add support for dumping calldata (#13680)

* op-deployer: Add support for dumping calldata

* Update state.go

Author: mslipper

op-deployer/pkg/deployer/apply.go

@@ -32,10 +32,11 @@ import (
 )
 
 type ApplyConfig struct {
-	L1RPCUrl   string
-	Workdir    string
-	PrivateKey string
-	Logger     log.Logger
+	L1RPCUrl         string
+	Workdir          string
+	PrivateKey       string
+	DeploymentTarget DeploymentTarget
+	Logger           log.Logger
 
 	privateKeyECDSA *ecdsa.PrivateKey
 }
@@ -57,16 +58,14 @@ func (a *ApplyConfig) Check() error {
 		return fmt.Errorf("logger must be specified")
 	}
 
-	return nil
-}
-
-func (a *ApplyConfig) CheckLive() error {
-	if a.privateKeyECDSA == nil {
-		return fmt.Errorf("private key must be specified")
-	}
+	if a.DeploymentTarget == DeploymentTargetLive {
+		if a.L1RPCUrl == "" {
+			return fmt.Errorf("l1 RPC URL must be specified for live deployment")
+		}
 
-	if a.L1RPCUrl == "" {
-		return fmt.Errorf("l1RPCUrl must be specified")
+		if a.privateKeyECDSA == nil {
+			return fmt.Errorf("private key must be specified for live deployment")
+		}
 	}
 
 	return nil
@@ -81,14 +80,19 @@ func ApplyCLI() func(cliCtx *cli.Context) error {
 		l1RPCUrl := cliCtx.String(L1RPCURLFlagName)
 		workdir := cliCtx.String(WorkdirFlagName)
 		privateKey := cliCtx.String(PrivateKeyFlagName)
+		depTarget, err := NewDeploymentTarget(cliCtx.String(DeploymentTargetFlag.Name))
+		if err != nil {
+			return fmt.Errorf("failed to parse deployment target: %w", err)
+		}
 
 		ctx := ctxinterrupt.WithCancelOnInterrupt(cliCtx.Context)
 
 		return Apply(ctx, ApplyConfig{
-			L1RPCUrl:   l1RPCUrl,
-			Workdir:    workdir,
-			PrivateKey: privateKey,
-			Logger:     l,
+			L1RPCUrl:         l1RPCUrl,
+			Workdir:          workdir,
+			PrivateKey:       privateKey,
+			DeploymentTarget: depTarget,
+			Logger:           l,
 		})
 	}
 }
@@ -110,6 +114,7 @@ func Apply(ctx context.Context, cfg ApplyConfig) error {
 
 	if err := ApplyPipeline(ctx, ApplyPipelineOpts{
 		L1RPCUrl:           cfg.L1RPCUrl,
+		DeploymentTarget:   cfg.DeploymentTarget,
 		DeployerPrivateKey: cfg.privateKeyECDSA,
 		Intent:             intent,
 		State:              st,
@@ -129,6 +134,7 @@ type pipelineStage struct {
 
 type ApplyPipelineOpts struct {
 	L1RPCUrl           string
+	DeploymentTarget   DeploymentTarget
 	DeployerPrivateKey *ecdsa.PrivateKey
 	Intent             *state.Intent
 	State              *state.State
@@ -187,34 +193,11 @@ func ApplyPipeline(
 	}
 
 	var bcaster broadcaster.Broadcaster
+	var l1RPC *rpc.Client
 	var l1Client *ethclient.Client
 	var l1Host *script.Host
-	if intent.DeploymentStrategy == state.DeploymentStrategyLive {
-		l1RPC, err := rpc.Dial(opts.L1RPCUrl)
-		if err != nil {
-			return fmt.Errorf("failed to connect to L1 RPC: %w", err)
-		}
-
-		l1Client = ethclient.NewClient(l1RPC)
-
-		chainID, err := l1Client.ChainID(ctx)
-		if err != nil {
-			return fmt.Errorf("failed to get chain ID: %w", err)
-		}
-
-		signer := opcrypto.SignerFnFromBind(opcrypto.PrivateKeySignerFn(opts.DeployerPrivateKey, chainID))
-
-		bcaster, err = broadcaster.NewKeyedBroadcaster(broadcaster.KeyedBroadcasterOpts{
-			Logger:  opts.Logger,
-			ChainID: new(big.Int).SetUint64(intent.L1ChainID),
-			Client:  l1Client,
-			Signer:  signer,
-			From:    deployer,
-		})
-		if err != nil {
-			return fmt.Errorf("failed to create broadcaster: %w", err)
-		}
 
+	initForkHost := func() error {
 		l1Host, err = env.DefaultScriptHost(
 			bcaster,
 			opts.Logger,
@@ -243,7 +226,54 @@ func ApplyPipeline(
 		); err != nil {
 			return fmt.Errorf("failed to select fork: %w", err)
 		}
-	} else {
+
+		return nil
+	}
+
+	switch opts.DeploymentTarget {
+	case DeploymentTargetLive:
+		l1RPC, err = rpc.Dial(opts.L1RPCUrl)
+		if err != nil {
+			return fmt.Errorf("failed to connect to L1 RPC: %w", err)
+		}
+
+		l1Client = ethclient.NewClient(l1RPC)
+
+		chainID, err := l1Client.ChainID(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to get chain ID: %w", err)
+		}
+
+		signer := opcrypto.SignerFnFromBind(opcrypto.PrivateKeySignerFn(opts.DeployerPrivateKey, chainID))
+
+		bcaster, err = broadcaster.NewKeyedBroadcaster(broadcaster.KeyedBroadcasterOpts{
+			Logger:  opts.Logger,
+			ChainID: new(big.Int).SetUint64(intent.L1ChainID),
+			Client:  l1Client,
+			Signer:  signer,
+			From:    deployer,
+		})
+		if err != nil {
+			return fmt.Errorf("failed to create broadcaster: %w", err)
+		}
+
+		if err := initForkHost(); err != nil {
+			return fmt.Errorf("failed to initialize L1 host: %w", err)
+		}
+	case DeploymentTargetCalldata, DeploymentTargetNoop:
+		l1RPC, err = rpc.Dial(opts.L1RPCUrl)
+		if err != nil {
+			return fmt.Errorf("failed to connect to L1 RPC: %w", err)
+		}
+
+		l1Client = ethclient.NewClient(l1RPC)
+
+		bcaster = new(broadcaster.CalldataBroadcaster)
+
+		if err := initForkHost(); err != nil {
+			return fmt.Errorf("failed to initialize L1 host: %w", err)
+		}
+	case DeploymentTargetGenesis:
 		bcaster = broadcaster.NoopBroadcaster()
 		l1Host, err = env.DefaultScriptHost(
 			bcaster,
@@ -254,6 +284,8 @@ func ApplyPipeline(
 		if err != nil {
 			return fmt.Errorf("failed to create L1 script host: %w", err)
 		}
+	default:
+		return fmt.Errorf("invalid deployment target: '%s'", opts.DeploymentTarget)
 	}
 
 	pEnv := &pipeline.Env{
@@ -267,11 +299,10 @@ func ApplyPipeline(
 
 	pline := []pipelineStage{
 		{"init", func() error {
-			if intent.DeploymentStrategy == state.DeploymentStrategyLive {
-				return pipeline.InitLiveStrategy(ctx, pEnv, intent, st)
-			} else {
+			if opts.DeploymentTarget == DeploymentTargetGenesis {
 				return pipeline.InitGenesisStrategy(pEnv, intent, st)
 			}
+			return pipeline.InitLiveStrategy(ctx, pEnv, intent, st)
 		}},
 		{"deploy-superchain", func() error {
 			return pipeline.DeploySuperchain(pEnv, intent, st)
@@ -314,23 +345,22 @@ func ApplyPipeline(
 		pline = append(pline, pipelineStage{
 			fmt.Sprintf("set-start-block-%s", chainID.Hex()),
 			func() error {
-				if intent.DeploymentStrategy == state.DeploymentStrategyLive {
-					return pipeline.SetStartBlockLiveStrategy(ctx, pEnv, st, chainID)
-				} else {
+				if opts.DeploymentTarget == DeploymentTargetGenesis {
 					return pipeline.SetStartBlockGenesisStrategy(pEnv, st, chainID)
 				}
+				return pipeline.SetStartBlockLiveStrategy(ctx, pEnv, st, chainID)
 			},
 		})
 	}
 
-	// Run through the pipeline. The state dump is captured between
-	// every step.
+	// Run through the pipeline.
 	for _, stage := range pline {
 		if err := stage.apply(); err != nil {
 			return fmt.Errorf("error in pipeline stage apply: %w", err)
 		}
 
-		if intent.DeploymentStrategy == state.DeploymentStrategyGenesis {
+		// Some steps use the L1StateDump, so we need to apply it to state after every step.
+		if opts.DeploymentTarget == DeploymentTargetGenesis {
 			dump, err := pEnv.L1ScriptHost.StateDump()
 			if err != nil {
 				return fmt.Errorf("failed to dump state: %w", err)
@@ -348,6 +378,14 @@ func ApplyPipeline(
 		}
 	}
 
+	if opts.DeploymentTarget == DeploymentTargetCalldata {
+		cdCaster := pEnv.Broadcaster.(*broadcaster.CalldataBroadcaster)
+		st.DeploymentCalldata, err = cdCaster.Dump()
+		if err != nil {
+			return fmt.Errorf("failed to dump calldata: %w", err)
+		}
+	}
+
 	st.AppliedIntent = intent
 	if err := pEnv.StateWriter.WriteState(st); err != nil {
 		return fmt.Errorf("failed to write state: %w", err)

op-deployer/pkg/deployer/broadcaster/calldata.go

@@ -0,0 +1,52 @@
+package broadcaster
+
+import (
+	"context"
+	"sync"
+
+	"github.com/ethereum-optimism/optimism/op-chain-ops/script"
+	"github.com/ethereum-optimism/optimism/op-service/txmgr"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+const defaultGasLimit = 30_000_000
+
+type CalldataDump struct {
+	To    *common.Address
+	Data  hexutil.Bytes
+	Value *hexutil.Big
+}
+
+type CalldataBroadcaster struct {
+	txs []txmgr.TxCandidate
+	mtx sync.Mutex
+}
+
+func (d *CalldataBroadcaster) Broadcast(ctx context.Context) ([]BroadcastResult, error) {
+	return nil, nil
+}
+
+func (d *CalldataBroadcaster) Hook(bcast script.Broadcast) {
+	candidate := asTxCandidate(bcast, defaultGasLimit)
+
+	d.mtx.Lock()
+	d.txs = append(d.txs, candidate)
+	d.mtx.Unlock()
+}
+
+func (d *CalldataBroadcaster) Dump() ([]CalldataDump, error) {
+	d.mtx.Lock()
+	defer d.mtx.Unlock()
+
+	var out []CalldataDump
+	for _, tx := range d.txs {
+		out = append(out, CalldataDump{
+			To:    tx.To,
+			Value: (*hexutil.Big)(tx.Value),
+			Data:  tx.TxData,
+		})
+	}
+	d.txs = nil
+	return out, nil
+}

op-deployer/pkg/deployer/broadcaster/calldata_test.go

@@ -0,0 +1,59 @@
+package broadcaster
+
+import (
+	"context"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-chain-ops/script"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/holiman/uint256"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCalldataBroadcaster(t *testing.T) {
+	bcast := new(CalldataBroadcaster)
+
+	bcasts := []script.Broadcast{
+		{
+			Type:  script.BroadcastCall,
+			To:    common.Address{'1'},
+			Input: []byte{'D', '1'},
+			Value: (*hexutil.U256)(new(uint256.Int).SetUint64(123)),
+		},
+		{
+			Type:  script.BroadcastCreate,
+			Input: []byte{'D', '2'},
+		},
+	}
+	for _, b := range bcasts {
+		bcast.Hook(b)
+	}
+
+	res, err := bcast.Broadcast(context.Background())
+	require.NoError(t, err)
+	require.Nil(t, res)
+
+	dump, err := bcast.Dump()
+	require.NoError(t, err)
+
+	expValues := make([]CalldataDump, len(bcasts))
+	for i, b := range bcasts {
+		var to *common.Address
+		if b.To != (common.Address{}) {
+			to = &b.To
+		}
+
+		var value *hexutil.Big
+		if b.Value != nil {
+			value = (*hexutil.Big)((*uint256.Int)(b.Value).ToBig())
+		}
+
+		expValues[i] = CalldataDump{
+			To:    to,
+			Value: value,
+			Data:  b.Input,
+		}
+	}
+	require.EqualValues(t, expValues, dump)
+}

op-deployer/pkg/deployer/broadcaster/keyed.go

@@ -7,6 +7,8 @@ import (
 	"sync"
 	"time"
 
+	"github.com/holiman/uint256"
+
 	"github.com/ethereum-optimism/optimism/op-service/eth"
 
 	"github.com/ethereum-optimism/optimism/op-chain-ops/script"
@@ -18,7 +20,6 @@ import (
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/hashicorp/go-multierror"
-	"github.com/holiman/uint256"
 )
 
 const (
@@ -184,6 +185,12 @@ func (t *KeyedBroadcaster) broadcast(ctx context.Context, bcast script.Broadcast
 	ch := make(chan txmgr.SendResponse, 1)
 
 	id := bcast.ID()
+	candidate := asTxCandidate(bcast, blockGasLimit)
+	t.mgr.SendAsync(ctx, candidate, ch)
+	return ch, id
+}
+
+func asTxCandidate(bcast script.Broadcast, blockGasLimit uint64) txmgr.TxCandidate {
 	value := ((*uint256.Int)(bcast.Value)).ToBig()
 	var candidate txmgr.TxCandidate
 	switch bcast.Type {
@@ -212,10 +219,10 @@ func (t *KeyedBroadcaster) broadcast(ctx context.Context, bcast script.Broadcast
 			Value:    value,
 			GasLimit: padGasLimit(bcast.Input, bcast.GasUsed, true, blockGasLimit),
 		}
+	default:
+		panic(fmt.Sprintf("unrecognized broadcast type: '%s'", bcast.Type))
 	}
-
-	t.mgr.SendAsync(ctx, candidate, ch)
-	return ch, id
+	return candidate
 }
 
 // padGasLimit calculates the gas limit for a transaction based on the intrinsic gas and the gas used by