deployer.go

package sysgo

import (
	"math/big"
	"path/filepath"
	"slices"
	"time"

	"github.com/ethereum-optimism/optimism/op-chain-ops/devkeys"
	opforks "github.com/ethereum-optimism/optimism/op-core/forks"
	"github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer"
	"github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/artifacts"
	"github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/inspect"
	"github.com/ethereum-optimism/optimism/op-deployer/pkg/deployer/state"
	"github.com/ethereum-optimism/optimism/op-devstack/devtest"
	"github.com/ethereum-optimism/optimism/op-devstack/stack"
	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/intentbuilder"
	"github.com/ethereum-optimism/optimism/op-node/rollup"
	"github.com/ethereum-optimism/optimism/op-service/eth"
	"github.com/ethereum-optimism/optimism/op-service/testreq"
	"github.com/ethereum-optimism/optimism/op-supervisor/supervisor/backend/depset"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core"
	"github.com/ethereum/go-ethereum/log"
	"github.com/ethereum/go-ethereum/params"
	"github.com/ethereum/go-ethereum/params/forks"
	"github.com/holiman/uint256"
)

// funderMnemonicIndex the funding account is not one of the 30 standard account, but still derived from a user-key.
const funderMnemonicIndex = 10_000
const devFeatureBitmapKey = "devFeatureBitmap"

type DeployerOption func(p devtest.T, keys devkeys.Keys, builder intentbuilder.Builder)

func WithForkAtL1Genesis(fork forks.Fork) DeployerOption {
	return func(_ devtest.T, _ devkeys.Keys, builder intentbuilder.Builder) {
		builder.L1().WithL1ForkAtGenesis(fork)
	}
}

func WithForkAtL1Offset(fork forks.Fork, offset uint64) DeployerOption {
	return func(_ devtest.T, _ devkeys.Keys, builder intentbuilder.Builder) {
		builder.L1().WithL1ForkAtOffset(fork, &offset)
	}
}

func WithDefaultBPOBlobSchedule(_ devtest.T, _ devkeys.Keys, builder intentbuilder.Builder) {
	// Once we get the latest changes from op-geth we can change this to
	// params.DefaultBlobSchedule.
	builder.L1().WithL1BlobSchedule(&params.BlobScheduleConfig{
		Cancun: params.DefaultCancunBlobConfig,
		Osaka:  params.DefaultOsakaBlobConfig,
		Prague: params.DefaultPragueBlobConfig,
		BPO1:   params.DefaultBPO1BlobConfig,
		BPO2:   params.DefaultBPO2BlobConfig,
		BPO3:   params.DefaultBPO3BlobConfig,
		BPO4:   params.DefaultBPO4BlobConfig,
	})
}

func WithKarstAtOffset(offset *uint64) DeployerOption {
	return func(p devtest.T, _ devkeys.Keys, builder intentbuilder.Builder) {
		for _, l2Cfg := range builder.L2s() {
			l2Cfg.WithForkAtOffset(opforks.Karst, offset)
		}
	}
}

func WithKarstAtGenesis(p devtest.T, _ devkeys.Keys, builder intentbuilder.Builder) {
	for _, l2Cfg := range builder.L2s() {
		l2Cfg.WithForkAtGenesis(opforks.Karst)
	}
}

func WithJovianAtGenesis(p devtest.T, _ devkeys.Keys, builder intentbuilder.Builder) {
	for _, l2Cfg := range builder.L2s() {
		l2Cfg.WithForkAtGenesis(opforks.Jovian)
	}
}

func WithL2GasLimit(gasLimit uint64) DeployerOption {
	return func(_ devtest.T, _ devkeys.Keys, builder intentbuilder.Builder) {
		for _, l2Cfg := range builder.L2s() {
			l2Cfg.WithGasLimit(gasLimit)
		}
	}
}

func WithEcotoneAtGenesis(p devtest.T, _ devkeys.Keys, builder intentbuilder.Builder) {
	for _, l2Cfg := range builder.L2s() {
		l2Cfg.WithForkAtGenesis(opforks.Ecotone)
	}
}

type DeployerPipelineOption func(wb *worldBuilder, intent *state.Intent, cfg *deployer.ApplyPipelineOpts)

func WithDeployerCacheDir(dirPath string) DeployerPipelineOption {
	return func(_ *worldBuilder, _ *state.Intent, cfg *deployer.ApplyPipelineOpts) {
		cfg.CacheDir = dirPath
	}
}

// WithDAFootprintGasScalar sets the DA footprint gas scalar with which the networks identified by
// l2ChainIDs will be launched. If there are no l2ChainIDs provided, all L2 networks are set with scalar.
func WithDAFootprintGasScalar(scalar uint16, l2ChainIDs ...eth.ChainID) DeployerOption {
	return func(p devtest.T, _ devkeys.Keys, builder intentbuilder.Builder) {
		for _, l2 := range builder.L2s() {
			if len(l2ChainIDs) == 0 || slices.Contains(l2ChainIDs, l2.ChainID()) {
				l2.WithDAFootprintGasScalar(scalar)
			}
		}
	}
}

type L2Deployment struct {
	systemConfigProxyAddr          common.Address
	disputeGameFactoryProxy        common.Address
	l1StandardBridgeProxy          common.Address
	proxyAdmin                     common.Address
	permissionlessDelayedWETHProxy common.Address
}

var _ stack.L2Deployment = &L2Deployment{}

func (d *L2Deployment) SystemConfigProxyAddr() common.Address {
	return d.systemConfigProxyAddr
}

func (d *L2Deployment) DisputeGameFactoryProxyAddr() common.Address {
	return d.disputeGameFactoryProxy
}

func (d *L2Deployment) L1StandardBridgeProxyAddr() common.Address {
	return d.l1StandardBridgeProxy
}

func (d *L2Deployment) ProxyAdminAddr() common.Address {
	return d.proxyAdmin
}

func (d *L2Deployment) PermissionlessDelayedWETHProxyAddr() common.Address {
	return d.permissionlessDelayedWETHProxy
}

type worldBuilder struct {
	p devtest.CommonT

	logger  log.Logger
	require *testreq.Assertions
	keys    devkeys.Keys

	// options
	deployerPipelineOptions []DeployerPipelineOption

	builder intentbuilder.Builder

	output          *state.State
	outL1Genesis    *core.Genesis
	l2Chains        []eth.ChainID
	outL2Genesis    map[eth.ChainID]*core.Genesis
	outL2RollupCfg  map[eth.ChainID]*rollup.Config
	outL2Deployment map[eth.ChainID]*L2Deployment

	outFullCfgSet depset.FullConfigSetMerged

	outSuperchainDeployment *SuperchainDeployment
}

var (
	oneEth     = uint256.NewInt(1e18)
	millionEth = new(uint256.Int).Mul(uint256.NewInt(1e6), oneEth)
)

func WithEmbeddedContractSources() DeployerOption {
	return func(_ devtest.T, _ devkeys.Keys, builder intentbuilder.Builder) {
		setContractLocators(builder, artifacts.EmbeddedLocator)
	}
}

func localContractSourcesLocator(artifactsPath string) (*artifacts.Locator, error) {
	if artifactsPath == "" {
		paths, err := contractPaths()
		if err != nil {
			return nil, err
		}
		artifactsPath = paths.FoundryArtifacts
	}
	absPath, err := filepath.Abs(artifactsPath)
	if err != nil {
		return nil, err
	}
	if err := ensureDir(absPath); err != nil {
		return nil, err
	}
	return artifacts.NewFileLocator(absPath)
}

func setContractLocators(builder intentbuilder.Builder, contractArtifacts *artifacts.Locator) {
	builder.WithL1ContractsLocator(contractArtifacts)
	builder.WithL2ContractsLocator(contractArtifacts)
}

// WithLocalContractSourcesAt configures the deployer to load both L1 and L2
// contract artifacts from the given local contracts-bedrock checkout or
// forge-artifacts directory.
func WithLocalContractSourcesAt(artifactsPath string) DeployerOption {
	return func(p devtest.T, _ devkeys.Keys, builder intentbuilder.Builder) {
		contractArtifacts, err := localContractSourcesLocator(artifactsPath)
		p.Require().NoError(err)
		setContractLocators(builder, contractArtifacts)
	}
}

func WithLocalContractSources() DeployerOption {
	return func(p devtest.T, _ devkeys.Keys, builder intentbuilder.Builder) {
		contractArtifacts, err := localContractSourcesLocator("")
		p.Require().NoError(err)
		setContractLocators(builder, contractArtifacts)
	}
}

func WithCommons(l1ChainID eth.ChainID) DeployerOption {
	return func(p devtest.T, keys devkeys.Keys, builder intentbuilder.Builder) {
		_, l1Config := builder.WithL1(l1ChainID)

		l1StartTimestamp := uint64(time.Now().Unix()) + 1
		l1Config.WithTimestamp(l1StartTimestamp)

		l1Config.WithL1ForkAtGenesis(forks.Prague) // activate pectra on L1

		faucetFunderAddr, err := keys.Address(devkeys.UserKey(funderMnemonicIndex))
		p.Require().NoError(err, "need funder addr")
		l1Config.WithPrefundedAccount(faucetFunderAddr, *eth.BillionEther.ToU256())

		// We use the L1 chain ID to identify the superchain-wide roles.
		addrFor := intentbuilder.RoleToAddrProvider(p, keys, l1ChainID)
		_, superCfg := builder.WithSuperchain()
		intentbuilder.WithDevkeySuperRoles(p, keys, l1ChainID, superCfg)
		l1Config.WithPrefundedAccount(addrFor(devkeys.SuperchainProxyAdminOwner), *millionEth)
		l1Config.WithPrefundedAccount(addrFor(devkeys.SuperchainProtocolVersionsOwner), *millionEth)
		l1Config.WithPrefundedAccount(addrFor(devkeys.SuperchainConfigGuardianKey), *millionEth)
		l1Config.WithPrefundedAccount(addrFor(devkeys.L1ProxyAdminOwnerRole), *millionEth)
	}
}

func WithGuardianMatchL1PAO() DeployerOption {
	return func(p devtest.T, keys devkeys.Keys, builder intentbuilder.Builder) {
		_, superCfg := builder.WithSuperchain()
		intentbuilder.WithOverrideGuardianToL1PAO(p, keys, superCfg.L1ChainID(), superCfg)
	}
}

func WithPrefundedL2(l1ChainID, l2ChainID eth.ChainID) DeployerOption {
	return func(p devtest.T, keys devkeys.Keys, builder intentbuilder.Builder) {
		_, l2Config := builder.WithL2(l2ChainID)
		intentbuilder.WithDevkeyVaults(p, keys, l2Config)
		intentbuilder.WithDevkeyL2Roles(p, keys, l2Config)
		// l2configurator L1ProxyAdminOwner must be also populated
		intentbuilder.WithDevkeyL1Roles(p, keys, l2Config, l1ChainID)
		{
			faucetFunderAddr, err := keys.Address(devkeys.UserKey(funderMnemonicIndex))
			p.Require().NoError(err, "need funder addr")
			l2Config.WithPrefundedAccount(faucetFunderAddr, *eth.BillionEther.ToU256())
		}
		{
			addrFor := intentbuilder.RoleToAddrProvider(p, keys, l2ChainID)
			l1Config := l2Config.L1Config()
			l1Config.WithPrefundedAccount(addrFor(devkeys.BatcherRole), *millionEth)
			l1Config.WithPrefundedAccount(addrFor(devkeys.ProposerRole), *millionEth)
			l1Config.WithPrefundedAccount(addrFor(devkeys.ChallengerRole), *millionEth)
			l1Config.WithPrefundedAccount(addrFor(devkeys.SystemConfigOwner), *millionEth)
		}
	}
}

// WithDevFeatureEnabled adds a feature as enabled in the dev feature bitmap
func WithDevFeatureEnabled(flag common.Hash) DeployerOption {
	return func(p devtest.T, keys devkeys.Keys, builder intentbuilder.Builder) {
		currentValue := builder.GlobalOverride(devFeatureBitmapKey)
		var bitmap common.Hash
		if currentValue != nil {
			bitmap = currentValue.(common.Hash)
		}
		builder.WithGlobalOverride(devFeatureBitmapKey, deployer.EnableDevFeature(bitmap, flag))
		if flag == deployer.OptimismPortalInteropDevFlag {
			builder.WithUseInterop(true)
		}
	}
}

// WithInteropAtGenesis activates interop at genesis for all known L2s
func WithInteropAtGenesis() DeployerOption {
	return func(p devtest.T, keys devkeys.Keys, builder intentbuilder.Builder) {
		for _, l2Cfg := range builder.L2s() {
			l2Cfg.WithForkAtGenesis(opforks.Interop)
		}
	}
}

// WithHardforkSequentialActivation configures a deployment such that L2 chains
// activate hardforks sequentially, starting from startFork and continuing
// until (including) endFork. Each successive fork is scheduled at
// an increasing offset.
func WithHardforkSequentialActivation(startFork, endFork opforks.Name, delta *uint64) DeployerOption {
	return func(p devtest.T, keys devkeys.Keys, builder intentbuilder.Builder) {
		for _, l2Cfg := range builder.L2s() {
			l2Cfg.WithForkAtGenesis(startFork)
			activateWithOffset := false
			deactivate := false
			for idx, refFork := range opforks.All {
				if deactivate {
					l2Cfg.WithForkAtOffset(refFork, nil)
					deactivate = true
					continue
				}
				if activateWithOffset {
					offset := *delta * uint64(idx)
					l2Cfg.WithForkAtOffset(refFork, &offset)
				}
				if startFork == refFork {
					activateWithOffset = true
				}
				if endFork == refFork {
					deactivate = true
				}
			}
		}
	}
}

// WithSequencingWindow overrides the number of L1 blocks in a sequencing window, applied to all L2s.
func WithSequencingWindow(n uint64) DeployerOption {
	return func(p devtest.T, keys devkeys.Keys, builder intentbuilder.Builder) {
		builder.WithGlobalOverride("sequencerWindowSize", uint64(n))
	}
}

func WithDeployerMatchL1PAO() DeployerPipelineOption {
	return func(wb *worldBuilder, intent *state.Intent, cfg *deployer.ApplyPipelineOpts) {
		l1ChainID := new(big.Int).SetUint64(intent.L1ChainID)
		deployerKey, err := wb.keys.Secret(devkeys.L1ProxyAdminOwnerRole.Key(l1ChainID))
		wb.require.NoError(err)
		cfg.DeployerPrivateKey = deployerKey
	}
}

// WithL2BlockTimes sets per-chain L2 block times. The map keys are L2 chain
// IDs and values are the desired block time in seconds for that chain.
func WithL2BlockTimes(blockTimes map[eth.ChainID]uint64) DeployerOption {
	return func(_ devtest.T, _ devkeys.Keys, builder intentbuilder.Builder) {
		for _, l2Cfg := range builder.L2s() {
			if bt, ok := blockTimes[l2Cfg.ChainID()]; ok {
				l2Cfg.WithBlockTime(bt)
			}
		}
	}
}

// WithFinalizationPeriodSeconds overrides the number of L1 blocks in a sequencing window, applied to all L2s.
func WithFinalizationPeriodSeconds(n uint64) DeployerOption {
	return func(p devtest.T, keys devkeys.Keys, builder intentbuilder.Builder) {
		for _, l2Cfg := range builder.L2s() {
			l2Cfg.WithFinalizationPeriodSeconds(n)
		}
	}
}

func WithProofMaturityDelaySeconds(n uint64) DeployerOption {
	return func(p devtest.T, keys devkeys.Keys, builder intentbuilder.Builder) {
		builder.WithGlobalOverride("proofMaturityDelaySeconds", uint64(n))
	}
}

func WithDisputeGameFinalityDelaySeconds(seconds uint64) DeployerOption {
	return func(p devtest.T, keys devkeys.Keys, builder intentbuilder.Builder) {
		builder.WithGlobalOverride("disputeGameFinalityDelaySeconds", seconds)
	}
}

func WithCustomGasToken(name, symbol string, initialLiquidity *big.Int, liquidityControllerOwner common.Address) DeployerOption {
	return func(p devtest.T, keys devkeys.Keys, builder intentbuilder.Builder) {
		for _, l2Cfg := range builder.L2s() {
			l2Cfg.WithCustomGasToken(name, symbol, initialLiquidity, liquidityControllerOwner)
		}
	}
}

func (wb *worldBuilder) buildL1Genesis() {
	wb.require.NotNil(wb.output.L1DevGenesis, "must have L1 genesis outer config")
	wb.require.NotNil(wb.output.L1StateDump, "must have L1 genesis alloc")

	genesisOuter := wb.output.L1DevGenesis
	genesisAlloc := wb.output.L1StateDump.Data.Accounts
	genesisCfg := *genesisOuter
	genesisCfg.StateHash = nil
	genesisCfg.Alloc = genesisAlloc

	wb.outL1Genesis = &genesisCfg
}

func (wb *worldBuilder) buildL2Genesis() {
	wb.outL2Genesis = make(map[eth.ChainID]*core.Genesis)
	wb.outL2RollupCfg = make(map[eth.ChainID]*rollup.Config)
	for _, ch := range wb.output.Chains {
		l2Genesis, l2RollupCfg, err := inspect.GenesisAndRollup(wb.output, ch.ID)
		wb.require.NoError(err, "need L2 genesis and rollup")
		id := eth.ChainIDFromBytes32(ch.ID)
		wb.outL2Genesis[id] = l2Genesis
		wb.outL2RollupCfg[id] = l2RollupCfg
	}
}

func (wb *worldBuilder) buildL2DeploymentOutputs() {
	wb.outL2Deployment = make(map[eth.ChainID]*L2Deployment)
	for _, ch := range wb.output.Chains {
		chainID := eth.ChainIDFromBytes32(ch.ID)
		wb.outL2Deployment[chainID] = &L2Deployment{
			systemConfigProxyAddr:          ch.SystemConfigProxy,
			disputeGameFactoryProxy:        ch.DisputeGameFactoryProxy,
			l1StandardBridgeProxy:          ch.L1StandardBridgeProxy,
			proxyAdmin:                     ch.OpChainProxyAdminImpl,
			permissionlessDelayedWETHProxy: ch.DelayedWethPermissionlessGameProxy,
		}
	}
	wb.outSuperchainDeployment = &SuperchainDeployment{
		protocolVersionsAddr: wb.output.SuperchainDeployment.ProtocolVersionsProxy,
		superchainConfigAddr: wb.output.SuperchainDeployment.SuperchainConfigProxy,
	}
}

func WithRevenueShare(enabled bool, chainFeesRecipient common.Address) DeployerOption {
	return func(p devtest.T, keys devkeys.Keys, builder intentbuilder.Builder) {
		for _, l2Cfg := range builder.L2s() {
			l2Cfg.WithRevenueShare(enabled, chainFeesRecipient)
		}
	}
}

func (wb *worldBuilder) buildFullConfigSet() {
	// If no chain has interop active, the dep set will be nil here,
	// so we should skip building the full config set.
	if wb.output.InteropDepSet == nil {
		return
	}

	rollupConfigSet := depset.StaticRollupConfigSetFromRollupConfigMap(wb.outL2RollupCfg,
		depset.StaticTimestamp(wb.outL1Genesis.Timestamp))
	fullCfgSet, err := depset.NewFullConfigSetMerged(rollupConfigSet, wb.output.InteropDepSet)
	wb.require.NoError(err)
	wb.outFullCfgSet = fullCfgSet
}

func (wb *worldBuilder) Build() {
	st := &state.State{
		Version: 1,
	}

	// Work-around of op-deployer design issue.
	// We use the same deployer key for all L1 and L2 chains we deploy here.
	deployerKey, err := wb.keys.Secret(devkeys.DeployerRole.Key(big.NewInt(0)))
	wb.require.NoError(err, "need deployer key")

	intent, err := wb.builder.Build()
	wb.require.NoError(err)

	pipelineOpts := deployer.ApplyPipelineOpts{
		DeploymentTarget:   deployer.DeploymentTargetGenesis,
		L1RPCUrl:           "",
		DeployerPrivateKey: deployerKey,
		Intent:             intent,
		State:              st,
		Logger:             wb.logger,
		StateWriter:        wb, // direct output back here
	}
	for _, opt := range wb.deployerPipelineOptions {
		opt(wb, intent, &pipelineOpts)
	}

	err = deployer.ApplyPipeline(wb.p.Ctx(), pipelineOpts)
	wb.require.NoError(err)

	wb.require.NotNil(wb.output, "expected state-write to output")

	for _, id := range wb.output.Chains {
		chainID := eth.ChainIDFromBytes32(id.ID)
		wb.l2Chains = append(wb.l2Chains, chainID)
	}

	wb.buildL1Genesis()
	wb.buildL2Genesis()
	wb.buildL2DeploymentOutputs()
	wb.buildFullConfigSet()
}

// WriteState is a callback used by deployer.ApplyPipeline to write the output
func (wb *worldBuilder) WriteState(st *state.State) error {
	wb.output = st
	return nil
}