op-deployer: Support output files in bootstrap (#13302)

* op-deployer: Support output files in bootstrap

* lint

op-deployer/pkg/deployer/bootstrap/asterisc.go

@@ -73,6 +73,7 @@ func AsteriscCLI(cliCtx *cli.Context) error {
 	l := oplog.NewLogger(oplog.AppOut(cliCtx), logCfg)
 	oplog.SetGlobalLogHandler(l.Handler())
 
+	outfile := cliCtx.String(OutfileFlagName)
 	l1RPCUrl := cliCtx.String(deployer.L1RPCURLFlagName)
 	privateKey := cliCtx.String(deployer.PrivateKeyFlagName)
 	artifactsURLStr := cliCtx.String(ArtifactsLocatorFlagName)
@@ -85,18 +86,27 @@ func AsteriscCLI(cliCtx *cli.Context) error {
 
 	ctx := ctxinterrupt.WithCancelOnInterrupt(cliCtx.Context)
 
-	return Asterisc(ctx, AsteriscConfig{
+	dao, err := Asterisc(ctx, AsteriscConfig{
 		L1RPCUrl:         l1RPCUrl,
 		PrivateKey:       privateKey,
 		Logger:           l,
 		ArtifactsLocator: artifactsLocator,
 		PreimageOracle:   preimageOracle,
 	})
+	if err != nil {
+		return fmt.Errorf("failed to deploy Asterisc: %w", err)
+	}
+
+	if err := jsonutil.WriteJSON(dao, ioutil.ToStdOutOrFileOrNoop(outfile, 0o755)); err != nil {
+		return fmt.Errorf("failed to write output: %w", err)
+	}
+	return nil
 }
 
-func Asterisc(ctx context.Context, cfg AsteriscConfig) error {
+func Asterisc(ctx context.Context, cfg AsteriscConfig) (opcm.DeployAsteriscOutput, error) {
+	var dao opcm.DeployAsteriscOutput
 	if err := cfg.Check(); err != nil {
-		return fmt.Errorf("invalid config for Asterisc: %w", err)
+		return dao, fmt.Errorf("invalid config for Asterisc: %w", err)
 	}
 
 	lgr := cfg.Logger
@@ -106,7 +116,7 @@ func Asterisc(ctx context.Context, cfg AsteriscConfig) error {
 
 	artifactsFS, cleanup, err := artifacts.Download(ctx, cfg.ArtifactsLocator, progressor)
 	if err != nil {
-		return fmt.Errorf("failed to download artifacts: %w", err)
+		return dao, fmt.Errorf("failed to download artifacts: %w", err)
 	}
 	defer func() {
 		if err := cleanup(); err != nil {
@@ -116,12 +126,12 @@ func Asterisc(ctx context.Context, cfg AsteriscConfig) error {
 
 	l1Client, err := ethclient.Dial(cfg.L1RPCUrl)
 	if err != nil {
-		return fmt.Errorf("failed to connect to L1 RPC: %w", err)
+		return dao, fmt.Errorf("failed to connect to L1 RPC: %w", err)
 	}
 
 	chainID, err := l1Client.ChainID(ctx)
 	if err != nil {
-		return fmt.Errorf("failed to get chain ID: %w", err)
+		return dao, fmt.Errorf("failed to get chain ID: %w", err)
 	}
 
 	signer := opcrypto.SignerFnFromBind(opcrypto.PrivateKeySignerFn(cfg.privateKeyECDSA, chainID))
@@ -135,12 +145,12 @@ func Asterisc(ctx context.Context, cfg AsteriscConfig) error {
 		From:    chainDeployer,
 	})
 	if err != nil {
-		return fmt.Errorf("failed to create broadcaster: %w", err)
+		return dao, fmt.Errorf("failed to create broadcaster: %w", err)
 	}
 
 	l1RPC, err := rpc.Dial(cfg.L1RPCUrl)
 	if err != nil {
-		return fmt.Errorf("failed to connect to L1 RPC: %w", err)
+		return dao, fmt.Errorf("failed to connect to L1 RPC: %w", err)
 	}
 
 	l1Host, err := env.DefaultForkedScriptHost(
@@ -152,27 +162,23 @@ func Asterisc(ctx context.Context, cfg AsteriscConfig) error {
 		l1RPC,
 	)
 	if err != nil {
-		return fmt.Errorf("failed to create script host: %w", err)
+		return dao, fmt.Errorf("failed to create script host: %w", err)
 	}
 
-	dgo, err := opcm.DeployAsterisc(
+	dao, err = opcm.DeployAsterisc(
 		l1Host,
 		opcm.DeployAsteriscInput{
 			PreimageOracle: cfg.PreimageOracle,
 		},
 	)
 	if err != nil {
-		return fmt.Errorf("error deploying asterisc VM: %w", err)
+		return dao, fmt.Errorf("error deploying asterisc VM: %w", err)
 	}
 
 	if _, err := bcaster.Broadcast(ctx); err != nil {
-		return fmt.Errorf("failed to broadcast: %w", err)
+		return dao, fmt.Errorf("failed to broadcast: %w", err)
 	}
 
 	lgr.Info("deployed asterisc VM")
-
-	if err := jsonutil.WriteJSON(dgo, ioutil.ToStdOut()); err != nil {
-		return fmt.Errorf("failed to write output: %w", err)
-	}
-	return nil
+	return dao, nil
 }

op-deployer/pkg/deployer/bootstrap/delayed_weth.go

@@ -71,6 +71,7 @@ func DelayedWETHCLI(cliCtx *cli.Context) error {
 	l := oplog.NewLogger(oplog.AppOut(cliCtx), logCfg)
 	oplog.SetGlobalLogHandler(l.Handler())
 
+	outfile := cliCtx.String(OutfileFlagName)
 	config, err := NewDelayedWETHConfigFromClI(cliCtx, l)
 	if err != nil {
 		return err
@@ -78,7 +79,15 @@ func DelayedWETHCLI(cliCtx *cli.Context) error {
 
 	ctx := ctxinterrupt.WithCancelOnInterrupt(cliCtx.Context)
 
-	return DelayedWETH(ctx, config)
+	dwo, err := DelayedWETH(ctx, config)
+	if err != nil {
+		return fmt.Errorf("failed to deploy DelayedWETH: %w", err)
+	}
+
+	if err := jsonutil.WriteJSON(dwo, ioutil.ToStdOutOrFileOrNoop(outfile, 0o755)); err != nil {
+		return fmt.Errorf("failed to write output: %w", err)
+	}
+	return nil
 }
 
 func NewDelayedWETHConfigFromClI(cliCtx *cli.Context, l log.Logger) (DelayedWETHConfig, error) {
@@ -100,9 +109,10 @@ func NewDelayedWETHConfigFromClI(cliCtx *cli.Context, l log.Logger) (DelayedWETH
 	return config, nil
 }
 
-func DelayedWETH(ctx context.Context, cfg DelayedWETHConfig) error {
+func DelayedWETH(ctx context.Context, cfg DelayedWETHConfig) (opcm.DeployDelayedWETHOutput, error) {
+	var dwo opcm.DeployDelayedWETHOutput
 	if err := cfg.Check(); err != nil {
-		return fmt.Errorf("invalid config for DelayedWETH: %w", err)
+		return dwo, fmt.Errorf("invalid config for DelayedWETH: %w", err)
 	}
 
 	lgr := cfg.Logger
@@ -112,7 +122,7 @@ func DelayedWETH(ctx context.Context, cfg DelayedWETHConfig) error {
 
 	artifactsFS, cleanup, err := artifacts2.Download(ctx, cfg.ArtifactsLocator, progressor)
 	if err != nil {
-		return fmt.Errorf("failed to download artifacts: %w", err)
+		return dwo, fmt.Errorf("failed to download artifacts: %w", err)
 	}
 	defer func() {
 		if err := cleanup(); err != nil {
@@ -122,26 +132,26 @@ func DelayedWETH(ctx context.Context, cfg DelayedWETHConfig) error {
 
 	l1Client, err := ethclient.Dial(cfg.L1RPCUrl)
 	if err != nil {
-		return fmt.Errorf("failed to connect to L1 RPC: %w", err)
+		return dwo, fmt.Errorf("failed to connect to L1 RPC: %w", err)
 	}
 
 	chainID, err := l1Client.ChainID(ctx)
 	if err != nil {
-		return fmt.Errorf("failed to get chain ID: %w", err)
+		return dwo, fmt.Errorf("failed to get chain ID: %w", err)
 	}
 	chainIDU64 := chainID.Uint64()
 
 	superCfg, err := standard.SuperchainFor(chainIDU64)
 	if err != nil {
-		return fmt.Errorf("error getting superchain config: %w", err)
+		return dwo, fmt.Errorf("error getting superchain config: %w", err)
 	}
 	proxyAdmin, err := standard.ManagerOwnerAddrFor(chainIDU64)
 	if err != nil {
-		return fmt.Errorf("error getting superchain proxy admin: %w", err)
+		return dwo, fmt.Errorf("error getting superchain proxy admin: %w", err)
 	}
 	delayedWethOwner, err := standard.SystemOwnerAddrFor(chainIDU64)
 	if err != nil {
-		return fmt.Errorf("error getting superchain system owner: %w", err)
+		return dwo, fmt.Errorf("error getting superchain system owner: %w", err)
 	}
 
 	signer := opcrypto.SignerFnFromBind(opcrypto.PrivateKeySignerFn(cfg.privateKeyECDSA, chainID))
@@ -155,12 +165,12 @@ func DelayedWETH(ctx context.Context, cfg DelayedWETHConfig) error {
 		From:    chainDeployer,
 	})
 	if err != nil {
-		return fmt.Errorf("failed to create broadcaster: %w", err)
+		return dwo, fmt.Errorf("failed to create broadcaster: %w", err)
 	}
 
 	l1RPC, err := rpc.Dial(cfg.L1RPCUrl)
 	if err != nil {
-		return fmt.Errorf("failed to connect to L1 RPC: %w", err)
+		return dwo, fmt.Errorf("failed to connect to L1 RPC: %w", err)
 	}
 
 	host, err := env.DefaultForkedScriptHost(
@@ -172,7 +182,7 @@ func DelayedWETH(ctx context.Context, cfg DelayedWETHConfig) error {
 		l1RPC,
 	)
 	if err != nil {
-		return fmt.Errorf("failed to create script host: %w", err)
+		return dwo, fmt.Errorf("failed to create script host: %w", err)
 	}
 
 	var release string
@@ -186,7 +196,7 @@ func DelayedWETH(ctx context.Context, cfg DelayedWETHConfig) error {
 
 	superchainConfigAddr := common.Address(*superCfg.Config.SuperchainConfigAddr)
 
-	dwo, err := opcm.DeployDelayedWETH(
+	dwo, err = opcm.DeployDelayedWETH(
 		host,
 		opcm.DeployDelayedWETHInput{
 			Release:               release,
@@ -198,17 +208,13 @@ func DelayedWETH(ctx context.Context, cfg DelayedWETHConfig) error {
 		},
 	)
 	if err != nil {
-		return fmt.Errorf("error deploying DelayedWETH: %w", err)
+		return dwo, fmt.Errorf("error deploying DelayedWETH: %w", err)
 	}
 
 	if _, err := bcaster.Broadcast(ctx); err != nil {
-		return fmt.Errorf("failed to broadcast: %w", err)
+		return dwo, fmt.Errorf("failed to broadcast: %w", err)
 	}
 
 	lgr.Info("deployed DelayedWETH")
-
-	if err := jsonutil.WriteJSON(dwo, ioutil.ToStdOut()); err != nil {
-		return fmt.Errorf("failed to write output: %w", err)
-	}
-	return nil
+	return dwo, nil
 }

op-deployer/pkg/deployer/bootstrap/dispute_game.go

@@ -83,12 +83,22 @@ func DisputeGameCLI(cliCtx *cli.Context) error {
 	l := oplog.NewLogger(oplog.AppOut(cliCtx), logCfg)
 	oplog.SetGlobalLogHandler(l.Handler())
 
+	outfile := cliCtx.String(OutfileFlagName)
 	cfg, err := NewDisputeGameConfigFromCLI(cliCtx, l)
 	if err != nil {
 		return err
 	}
 	ctx := ctxinterrupt.WithCancelOnInterrupt(cliCtx.Context)
-	return DisputeGame(ctx, cfg)
+	dgo, err := DisputeGame(ctx, cfg)
+	if err != nil {
+		return fmt.Errorf("failed to deploy dispute game: %w", err)
+	}
+
+	if err := jsonutil.WriteJSON(dgo, ioutil.ToStdOutOrFileOrNoop(outfile, 0o755)); err != nil {
+		return fmt.Errorf("failed to write output: %w", err)
+	}
+
+	return nil
 }
 
 func NewDisputeGameConfigFromCLI(cliCtx *cli.Context, l log.Logger) (DisputeGameConfig, error) {
@@ -123,9 +133,10 @@ func NewDisputeGameConfigFromCLI(cliCtx *cli.Context, l log.Logger) (DisputeGame
 	return cfg, nil
 }
 
-func DisputeGame(ctx context.Context, cfg DisputeGameConfig) error {
+func DisputeGame(ctx context.Context, cfg DisputeGameConfig) (opcm.DeployDisputeGameOutput, error) {
+	var dgo opcm.DeployDisputeGameOutput
 	if err := cfg.Check(); err != nil {
-		return fmt.Errorf("invalid config for DisputeGame: %w", err)
+		return dgo, fmt.Errorf("invalid config for DisputeGame: %w", err)
 	}
 
 	lgr := cfg.Logger
@@ -135,7 +146,7 @@ func DisputeGame(ctx context.Context, cfg DisputeGameConfig) error {
 
 	artifactsFS, cleanup, err := artifacts2.Download(ctx, cfg.ArtifactsLocator, progressor)
 	if err != nil {
-		return fmt.Errorf("failed to download artifacts: %w", err)
+		return dgo, fmt.Errorf("failed to download artifacts: %w", err)
 	}
 	defer func() {
 		if err := cleanup(); err != nil {
@@ -145,22 +156,22 @@ func DisputeGame(ctx context.Context, cfg DisputeGameConfig) error {
 
 	l1Client, err := ethclient.Dial(cfg.L1RPCUrl)
 	if err != nil {
-		return fmt.Errorf("failed to connect to L1 RPC: %w", err)
+		return dgo, fmt.Errorf("failed to connect to L1 RPC: %w", err)
 	}
 	l1Rpc, err := rpc.Dial(cfg.L1RPCUrl)
 	if err != nil {
-		return fmt.Errorf("failed to connect to L1 RPC: %w", err)
+		return dgo, fmt.Errorf("failed to connect to L1 RPC: %w", err)
 	}
 
 	chainID, err := l1Client.ChainID(ctx)
 	if err != nil {
-		return fmt.Errorf("failed to get chain ID: %w", err)
+		return dgo, fmt.Errorf("failed to get chain ID: %w", err)
 	}
 	chainIDU64 := chainID.Uint64()
 
 	standardVersionsTOML, err := standard.L1VersionsDataFor(chainIDU64)
 	if err != nil {
-		return fmt.Errorf("error getting standard versions TOML: %w", err)
+		return dgo, fmt.Errorf("error getting standard versions TOML: %w", err)
 	}
 
 	signer := opcrypto.SignerFnFromBind(opcrypto.PrivateKeySignerFn(cfg.privateKeyECDSA, chainID))
@@ -174,7 +185,7 @@ func DisputeGame(ctx context.Context, cfg DisputeGameConfig) error {
 		From:    chainDeployer,
 	})
 	if err != nil {
-		return fmt.Errorf("failed to create broadcaster: %w", err)
+		return dgo, fmt.Errorf("failed to create broadcaster: %w", err)
 	}
 
 	host, err := env.DefaultForkedScriptHost(
@@ -186,7 +197,7 @@ func DisputeGame(ctx context.Context, cfg DisputeGameConfig) error {
 		l1Rpc,
 	)
 	if err != nil {
-		return fmt.Errorf("failed to create L1 script host: %w", err)
+		return dgo, fmt.Errorf("failed to create L1 script host: %w", err)
 	}
 
 	var release string
@@ -197,7 +208,8 @@ func DisputeGame(ctx context.Context, cfg DisputeGameConfig) error {
 	}
 
 	lgr.Info("deploying dispute game", "release", release)
-	dgo, err := opcm.DeployDisputeGame(
+
+	dgo, err = opcm.DeployDisputeGame(
 		host,
 		opcm.DeployDisputeGameInput{
 			Release:                  release,
@@ -218,17 +230,13 @@ func DisputeGame(ctx context.Context, cfg DisputeGameConfig) error {
 		},
 	)
 	if err != nil {
-		return fmt.Errorf("error deploying dispute game: %w", err)
+		return dgo, fmt.Errorf("error deploying dispute game: %w", err)
 	}
 
 	if _, err := bcaster.Broadcast(ctx); err != nil {
-		return fmt.Errorf("failed to broadcast: %w", err)
+		return dgo, fmt.Errorf("failed to broadcast: %w", err)
 	}
 
 	lgr.Info("deployed dispute game")
-
-	if err := jsonutil.WriteJSON(dgo, ioutil.ToStdOut()); err != nil {
-		return fmt.Errorf("failed to write output: %w", err)
-	}
-	return nil
+	return dgo, nil
 }

op-deployer/pkg/deployer/bootstrap/flags.go

@@ -11,6 +11,7 @@ import (
 )
 
 const (
+	OutfileFlagName                         = "outfile"
 	ArtifactsLocatorFlagName                = "artifacts-locator"
 	WithdrawalDelaySecondsFlagName          = "withdrawal-delay-seconds"
 	MinProposalSizeBytesFlagName            = "min-proposal-size-bytes"
@@ -44,6 +45,12 @@ const (
 )
 
 var (
+	OutfileFlag = &cli.StringFlag{
+		Name:    OutfileFlagName,
+		Usage:   "Output file. Use - for stdout.",
+		EnvVars: deployer.PrefixEnvVar("OUTFILE"),
+		Value:   "-",
+	}
 	ArtifactsLocatorFlag = &cli.StringFlag{
 		Name:    ArtifactsLocatorFlagName,
 		Usage:   "Locator for artifacts.",
@@ -221,6 +228,7 @@ var OPCMFlags = []cli.Flag{
 	deployer.L1RPCURLFlag,
 	deployer.PrivateKeyFlag,
 	ReleaseFlag,
+	OutfileFlag,
 }
 
 var ImplementationsFlags = []cli.Flag{
@@ -235,6 +243,7 @@ var ImplementationsFlags = []cli.Flag{
 var DelayedWETHFlags = []cli.Flag{
 	deployer.L1RPCURLFlag,
 	deployer.PrivateKeyFlag,
+	OutfileFlag,
 	ArtifactsLocatorFlag,
 	DelayedWethImplFlag,
 }
@@ -242,6 +251,7 @@ var DelayedWETHFlags = []cli.Flag{
 var DisputeGameFlags = []cli.Flag{
 	deployer.L1RPCURLFlag,
 	deployer.PrivateKeyFlag,
+	OutfileFlag,
 	ArtifactsLocatorFlag,
 	MinProposalSizeBytesFlag,
 	ChallengePeriodSecondsFlag,
@@ -263,6 +273,7 @@ var DisputeGameFlags = []cli.Flag{
 var BaseFPVMFlags = []cli.Flag{
 	deployer.L1RPCURLFlag,
 	deployer.PrivateKeyFlag,
+	OutfileFlag,
 	ArtifactsLocatorFlag,
 	PreimageOracleFlag,
 }
@@ -274,6 +285,7 @@ var AsteriscFlags = BaseFPVMFlags
 var ProxyFlags = []cli.Flag{
 	deployer.L1RPCURLFlag,
 	deployer.PrivateKeyFlag,
+	OutfileFlag,
 	ArtifactsLocatorFlag,
 	ProxyOwnerFlag,
 }
@@ -281,6 +293,7 @@ var ProxyFlags = []cli.Flag{
 var SuperchainFlags = []cli.Flag{
 	deployer.L1RPCURLFlag,
 	deployer.PrivateKeyFlag,
+	OutfileFlag,
 	ArtifactsLocatorFlag,
 	SuperchainProxyAdminOwnerFlag,
 	ProtocolVersionsOwnerFlag,

op-deployer/pkg/deployer/bootstrap/mips.go

@@ -84,6 +84,7 @@ func MIPSCLI(cliCtx *cli.Context) error {
 
 	l1RPCUrl := cliCtx.String(deployer.L1RPCURLFlagName)
 	privateKey := cliCtx.String(deployer.PrivateKeyFlagName)
+	outfile := cliCtx.String(OutfileFlagName)
 	artifactsURLStr := cliCtx.String(ArtifactsLocatorFlagName)
 	artifactsLocator := new(artifacts2.Locator)
 	if err := artifactsLocator.UnmarshalText([]byte(artifactsURLStr)); err != nil {
@@ -95,7 +96,7 @@ func MIPSCLI(cliCtx *cli.Context) error {
 
 	ctx := ctxinterrupt.WithCancelOnInterrupt(cliCtx.Context)
 
-	return MIPS(ctx, MIPSConfig{
+	dmo, err := MIPS(ctx, MIPSConfig{
 		L1RPCUrl:         l1RPCUrl,
 		PrivateKey:       privateKey,
 		Logger:           l,
@@ -103,11 +104,20 @@ func MIPSCLI(cliCtx *cli.Context) error {
 		MipsVersion:      mipsVersion,
 		PreimageOracle:   preimageOracle,
 	})
+	if err != nil {
+		return fmt.Errorf("failed to deploy MIPS: %w", err)
+	}
+
+	if err := jsonutil.WriteJSON(dmo, ioutil.ToStdOutOrFileOrNoop(outfile, 0o755)); err != nil {
+		return fmt.Errorf("failed to write output: %w", err)
+	}
+	return nil
 }
 
-func MIPS(ctx context.Context, cfg MIPSConfig) error {
+func MIPS(ctx context.Context, cfg MIPSConfig) (opcm.DeployMIPSOutput, error) {
+	var dmo opcm.DeployMIPSOutput
 	if err := cfg.Check(); err != nil {
-		return fmt.Errorf("invalid config for MIPS: %w", err)
+		return dmo, fmt.Errorf("invalid config for MIPS: %w", err)
 	}
 
 	lgr := cfg.Logger
@@ -117,7 +127,7 @@ func MIPS(ctx context.Context, cfg MIPSConfig) error {
 
 	artifactsFS, cleanup, err := artifacts2.Download(ctx, cfg.ArtifactsLocator, progressor)
 	if err != nil {
-		return fmt.Errorf("failed to download artifacts: %w", err)
+		return dmo, fmt.Errorf("failed to download artifacts: %w", err)
 	}
 	defer func() {
 		if err := cleanup(); err != nil {
@@ -127,14 +137,14 @@ func MIPS(ctx context.Context, cfg MIPSConfig) error {
 
 	l1RPC, err := rpc.Dial(cfg.L1RPCUrl)
 	if err != nil {
-		return fmt.Errorf("failed to connect to L1 RPC: %w", err)
+		return dmo, 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)
+		return dmo, fmt.Errorf("failed to get chain ID: %w", err)
 	}
 
 	signer := opcrypto.SignerFnFromBind(opcrypto.PrivateKeySignerFn(cfg.privateKeyECDSA, chainID))
@@ -148,7 +158,7 @@ func MIPS(ctx context.Context, cfg MIPSConfig) error {
 		From:    chainDeployer,
 	})
 	if err != nil {
-		return fmt.Errorf("failed to create broadcaster: %w", err)
+		return dmo, fmt.Errorf("failed to create broadcaster: %w", err)
 	}
 
 	host, err := env.DefaultForkedScriptHost(
@@ -160,7 +170,7 @@ func MIPS(ctx context.Context, cfg MIPSConfig) error {
 		l1RPC,
 	)
 	if err != nil {
-		return fmt.Errorf("failed to create script host: %w", err)
+		return dmo, fmt.Errorf("failed to create script host: %w", err)
 	}
 
 	var release string
@@ -172,7 +182,7 @@ func MIPS(ctx context.Context, cfg MIPSConfig) error {
 
 	lgr.Info("deploying dispute game", "release", release)
 
-	dgo, err := opcm.DeployMIPS(
+	dmo, err = opcm.DeployMIPS(
 		host,
 		opcm.DeployMIPSInput{
 			MipsVersion:    cfg.MipsVersion,
@@ -180,17 +190,14 @@ func MIPS(ctx context.Context, cfg MIPSConfig) error {
 		},
 	)
 	if err != nil {
-		return fmt.Errorf("error deploying dispute game: %w", err)
+		return dmo, fmt.Errorf("error deploying dispute game: %w", err)
 	}
 
 	if _, err := bcaster.Broadcast(ctx); err != nil {
-		return fmt.Errorf("failed to broadcast: %w", err)
+		return dmo, fmt.Errorf("failed to broadcast: %w", err)
 	}
 
 	lgr.Info("deployed dispute game")
 
-	if err := jsonutil.WriteJSON(dgo, ioutil.ToStdOut()); err != nil {
-		return fmt.Errorf("failed to write output: %w", err)
-	}
-	return nil
+	return dmo, nil
 }

op-deployer/pkg/deployer/bootstrap/opcm.go

@@ -73,6 +73,7 @@ func OPCMCLI(cliCtx *cli.Context) error {
 
 	l1RPCUrl := cliCtx.String(deployer.L1RPCURLFlagName)
 	privateKey := cliCtx.String(deployer.PrivateKeyFlagName)
+	outfile := cliCtx.String(OutfileFlagName)
 	release := cliCtx.String(ReleaseFlagName)
 
 	ctx := ctxinterrupt.WithCancelOnInterrupt(cliCtx.Context)
@@ -87,7 +88,7 @@ func OPCMCLI(cliCtx *cli.Context) error {
 		return fmt.Errorf("failed to deploy OPCM: %w", err)
 	}
 
-	if err := jsonutil.WriteJSON(out, ioutil.ToStdOut()); err != nil {
+	if err := jsonutil.WriteJSON(out, ioutil.ToStdOutOrFileOrNoop(outfile, 0o755)); err != nil {
 		return fmt.Errorf("failed to write output: %w", err)
 	}
 	return nil

op-deployer/pkg/deployer/bootstrap/proxy.go

@@ -75,6 +75,7 @@ func ProxyCLI(cliCtx *cli.Context) error {
 
 	l1RPCUrl := cliCtx.String(deployer.L1RPCURLFlagName)
 	privateKey := cliCtx.String(deployer.PrivateKeyFlagName)
+	outfile := cliCtx.String(OutfileFlagName)
 	artifactsURLStr := cliCtx.String(ArtifactsLocatorFlagName)
 	artifactsLocator := new(artifacts.Locator)
 	if err := artifactsLocator.UnmarshalText([]byte(artifactsURLStr)); err != nil {
@@ -85,18 +86,27 @@ func ProxyCLI(cliCtx *cli.Context) error {
 
 	ctx := ctxinterrupt.WithCancelOnInterrupt(cliCtx.Context)
 
-	return Proxy(ctx, ProxyConfig{
+	dpo, err := Proxy(ctx, ProxyConfig{
 		L1RPCUrl:         l1RPCUrl,
 		PrivateKey:       privateKey,
 		Logger:           l,
 		ArtifactsLocator: artifactsLocator,
 		Owner:            owner,
 	})
+	if err != nil {
+		return fmt.Errorf("failed to deploy Proxy: %w", err)
+	}
+
+	if err := jsonutil.WriteJSON(dpo, ioutil.ToStdOutOrFileOrNoop(outfile, 0o755)); err != nil {
+		return fmt.Errorf("failed to write output: %w", err)
+	}
+	return nil
 }
 
-func Proxy(ctx context.Context, cfg ProxyConfig) error {
+func Proxy(ctx context.Context, cfg ProxyConfig) (opcm.DeployProxyOutput, error) {
+	var dpo opcm.DeployProxyOutput
 	if err := cfg.Check(); err != nil {
-		return fmt.Errorf("invalid config for Proxy: %w", err)
+		return dpo, fmt.Errorf("invalid config for Proxy: %w", err)
 	}
 
 	lgr := cfg.Logger
@@ -106,7 +116,7 @@ func Proxy(ctx context.Context, cfg ProxyConfig) error {
 
 	artifactsFS, cleanup, err := artifacts.Download(ctx, cfg.ArtifactsLocator, progressor)
 	if err != nil {
-		return fmt.Errorf("failed to download artifacts: %w", err)
+		return dpo, fmt.Errorf("failed to download artifacts: %w", err)
 	}
 	defer func() {
 		if err := cleanup(); err != nil {
@@ -116,12 +126,12 @@ func Proxy(ctx context.Context, cfg ProxyConfig) error {
 
 	l1Client, err := ethclient.Dial(cfg.L1RPCUrl)
 	if err != nil {
-		return fmt.Errorf("failed to connect to L1 RPC: %w", err)
+		return dpo, fmt.Errorf("failed to connect to L1 RPC: %w", err)
 	}
 
 	chainID, err := l1Client.ChainID(ctx)
 	if err != nil {
-		return fmt.Errorf("failed to get chain ID: %w", err)
+		return dpo, fmt.Errorf("failed to get chain ID: %w", err)
 	}
 
 	signer := opcrypto.SignerFnFromBind(opcrypto.PrivateKeySignerFn(cfg.privateKeyECDSA, chainID))
@@ -135,12 +145,12 @@ func Proxy(ctx context.Context, cfg ProxyConfig) error {
 		From:    chainDeployer,
 	})
 	if err != nil {
-		return fmt.Errorf("failed to create broadcaster: %w", err)
+		return dpo, fmt.Errorf("failed to create broadcaster: %w", err)
 	}
 
 	l1RPC, err := rpc.Dial(cfg.L1RPCUrl)
 	if err != nil {
-		return fmt.Errorf("failed to connect to L1 RPC: %w", err)
+		return dpo, fmt.Errorf("failed to connect to L1 RPC: %w", err)
 	}
 
 	l1Host, err := env.DefaultForkedScriptHost(
@@ -152,27 +162,23 @@ func Proxy(ctx context.Context, cfg ProxyConfig) error {
 		l1RPC,
 	)
 	if err != nil {
-		return fmt.Errorf("failed to create script host: %w", err)
+		return dpo, fmt.Errorf("failed to create script host: %w", err)
 	}
 
-	dgo, err := opcm.DeployProxy(
+	dpo, err = opcm.DeployProxy(
 		l1Host,
 		opcm.DeployProxyInput{
 			Owner: cfg.Owner,
 		},
 	)
 	if err != nil {
-		return fmt.Errorf("error deploying proxy: %w", err)
+		return dpo, fmt.Errorf("error deploying proxy: %w", err)
 	}
 
 	if _, err := bcaster.Broadcast(ctx); err != nil {
-		return fmt.Errorf("failed to broadcast: %w", err)
+		return dpo, fmt.Errorf("failed to broadcast: %w", err)
 	}
 
 	lgr.Info("deployed new ERC-1967 proxy")
-
-	if err := jsonutil.WriteJSON(dgo, ioutil.ToStdOut()); err != nil {
-		return fmt.Errorf("failed to write output: %w", err)
-	}
-	return nil
+	return dpo, nil
 }

op-deployer/pkg/deployer/bootstrap/superchain.go

@@ -98,6 +98,7 @@ func SuperchainCLI(cliCtx *cli.Context) error {
 	paused := cliCtx.Bool(PausedFlagName)
 	requiredVersionStr := cliCtx.String(RequiredProtocolVersionFlagName)
 	recommendedVersionStr := cliCtx.String(RecommendedProtocolVersionFlagName)
+	outfile := cliCtx.String(OutfileFlagName)
 
 	cfg := SuperchainConfig{
 		L1RPCUrl:                  l1RPCUrl,
@@ -124,7 +125,7 @@ func SuperchainCLI(cliCtx *cli.Context) error {
 		return fmt.Errorf("failed to deploy superchain: %w", err)
 	}
 
-	if err := jsonutil.WriteJSON(dso, ioutil.ToStdOut()); err != nil {
+	if err := jsonutil.WriteJSON(dso, ioutil.ToStdOutOrFileOrNoop(outfile, 0o755)); err != nil {
 		return fmt.Errorf("failed to write output: %w", err)
 	}
 	return nil