Add Celo CIP-64 acceptance test (sysgo)

op-acceptance-tests/acceptance-tests.yaml

@@ -185,6 +185,12 @@ gates:
       - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/custom_gas_token
         timeout: 10m
 
+  - id: celo
+    description: "Celo-specific tests (CIP-64 fee currencies, etc.)."
+    tests:
+      - package: github.com/ethereum-optimism/optimism/op-acceptance-tests/tests/celo
+        timeout: 10m
+
   - id: supernode
     description: "Supernode tests - tests for the op-supernode multi-chain consensus layer."
     tests:

op-acceptance-tests/justfile

@@ -17,6 +17,9 @@ interop:
 cgt:
     @just acceptance-test "" cgt
 
+celo:
+    @just acceptance-test "" celo
+
 
 # Run acceptance tests with mise-managed binary
 # Usage: just acceptance-test [devnet] [gate]

op-acceptance-tests/tests/celo/cip64_test.go

@@ -0,0 +1,84 @@
+package celo
+
+import (
+	"context"
+	"math/big"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+
+	"github.com/ethereum-optimism/optimism/op-core/predeploys"
+	"github.com/ethereum-optimism/optimism/op-devstack/devtest"
+	"github.com/ethereum-optimism/optimism/op-devstack/presets"
+)
+
+// TestCIP64_PayGasInTestFeeCurrency sends a CeloDynamicFeeTxV2 (CIP-64) with
+// FeeCurrency set to the registered test fee currency. devAccounts[0] is the
+// foundry test mnemonic account that L2Genesis pre-funds with 100k TEST and
+// zero native CELO; the only way the tx can be paid for is via op-geth's
+// fee-currency machinery.
+func TestCIP64_PayGasInTestFeeCurrency(gt *testing.T) {
+	t := devtest.SerialT(gt)
+	sys := presets.NewMinimal(t)
+	ensureCeloFeeCurrencyOrSkip(t, sys)
+
+	priv, err := crypto.HexToECDSA(foundryDevAccount0PrivKeyHex)
+	t.Require().NoError(err, "parse foundry dev priv key")
+	sender := crypto.PubkeyToAddress(priv.PublicKey)
+
+	l2 := sys.L2EL.Escape().L2EthClient()
+	chainID := sys.L2Chain.ChainID().ToBig()
+	recipient := sys.Wallet.NewEOA(sys.L2EL).Address()
+
+	ctx, cancel := context.WithTimeout(t.Ctx(), 60*time.Second)
+	defer cancel()
+
+	nativeBefore, err := l2.BalanceAt(ctx, sender, nil)
+	t.Require().NoError(err, "get native balance")
+	testBefore := erc20BalanceOf(t, sys, predeploys.TestFeeCurrencyAddr, sender)
+	t.Require().Truef(testBefore.Sign() > 0, "sender must have a positive TEST balance, got %s", testBefore)
+
+	nonce, err := l2.PendingNonceAt(ctx, sender)
+	t.Require().NoError(err, "get nonce")
+
+	tx := types.NewTx(&types.CeloDynamicFeeTxV2{
+		ChainID:     chainID,
+		Nonce:       nonce,
+		GasTipCap:   big.NewInt(1_000_000_000),  // 1 gwei
+		GasFeeCap:   big.NewInt(10_000_000_000), // 10 gwei
+		Gas:         200_000,
+		To:          &recipient,
+		Value:       big.NewInt(0),
+		FeeCurrency: &predeploys.TestFeeCurrencyAddr,
+	})
+	signed, err := types.SignTx(tx, types.LatestSignerForChainID(chainID), priv)
+	t.Require().NoError(err, "sign CIP-64 tx")
+	t.Require().NoError(l2.SendTransaction(ctx, signed), "send CIP-64 tx")
+
+	var receipt *types.Receipt
+	t.Require().Eventually(func() bool {
+		r, err := l2.TransactionReceipt(ctx, signed.Hash())
+		if err != nil {
+			return false
+		}
+		receipt = r
+		return true
+	}, sys.L2EL.Escape().TransactionTimeout(), time.Second, "tx receipt")
+
+	t.Require().Equal(uint64(1), receipt.Status, "CIP-64 tx must succeed")
+
+	nativeAfter, err := l2.BalanceAt(ctx, sender, nil)
+	t.Require().NoError(err, "get native balance after")
+	testAfter := erc20BalanceOf(t, sys, predeploys.TestFeeCurrencyAddr, sender)
+
+	// Native balance must not change: gas was paid in TEST, no value transferred.
+	t.Require().Equal(0, nativeBefore.Cmp(nativeAfter),
+		"native balance changed: before=%s after=%s", nativeBefore, nativeAfter)
+
+	// TEST balance must drop — the fee-currency machinery debited gas + intrinsic-gas
+	// surcharge in TEST tokens.
+	t.Require().Truef(testAfter.Cmp(testBefore) < 0,
+		"TEST balance must drop, got before=%s after=%s", testBefore, testAfter)
+}

op-acceptance-tests/tests/celo/helpers.go

@@ -0,0 +1,64 @@
+package celo
+
+import (
+	"context"
+	"math/big"
+	"time"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/lmittmann/w3"
+
+	"github.com/ethereum-optimism/optimism/op-core/predeploys"
+	"github.com/ethereum-optimism/optimism/op-devstack/devtest"
+	"github.com/ethereum-optimism/optimism/op-devstack/presets"
+)
+
+// Foundry "test test test test test test test test test test test junk" mnemonic,
+// path m/44'/60'/0'/0/0 — same address that L2Genesis.s.sol pre-funds with 100k TEST.
+const foundryDevAccount0PrivKeyHex = "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+
+// ensureCeloFeeCurrencyOrSkip checks that the FeeCurrencyDirectory predeploy is in
+// place and that the test fee currency is registered. Skips the test otherwise so
+// the gate can be run against environments without the Celo predeploys.
+func ensureCeloFeeCurrencyOrSkip(t devtest.T, sys *presets.Minimal) {
+	l2 := sys.L2EL.Escape().L2EthClient()
+
+	ctx, cancel := context.WithTimeout(t.Ctx(), 20*time.Second)
+	defer cancel()
+
+	// Probe the FeeCurrencyDirectory by calling getCurrencyConfig(testFeeCurrency).
+	// On a non-Celo devnet the call has no code to execute and reverts; on a Celo
+	// devnet without the test currency registered, the directory itself reverts
+	// with "currency not registered". Both cases skip.
+	getCurrencyConfig := w3.MustNewFunc(
+		"getCurrencyConfig(address)",
+		"(address oracle, uint256 intrinsicGas)",
+	)
+	data, err := getCurrencyConfig.EncodeArgs(predeploys.TestFeeCurrencyAddr)
+	t.Require().NoError(err, "encode getCurrencyConfig")
+
+	if _, err := l2.Call(ctx, ethereum.CallMsg{To: &predeploys.FeeCurrencyDirectoryAddr, Data: data}, rpc.LatestBlockNumber); err != nil {
+		t.Skip("test fee currency not registered with FeeCurrencyDirectory: " + err.Error())
+	}
+}
+
+// erc20BalanceOf reads the ERC-20 balance of `account` for the token at `token`.
+func erc20BalanceOf(t devtest.T, sys *presets.Minimal, token, account common.Address) *big.Int {
+	l2 := sys.L2EL.Escape().L2EthClient()
+
+	ctx, cancel := context.WithTimeout(t.Ctx(), 20*time.Second)
+	defer cancel()
+
+	balanceOf := w3.MustNewFunc("balanceOf(address)", "uint256")
+	data, err := balanceOf.EncodeArgs(account)
+	t.Require().NoError(err, "encode balanceOf")
+
+	out, err := l2.Call(ctx, ethereum.CallMsg{To: &token, Data: data}, rpc.LatestBlockNumber)
+	t.Require().NoError(err, "call balanceOf")
+
+	var bal *big.Int
+	t.Require().NoError(balanceOf.DecodeReturns(out, &bal), "decode balanceOf")
+	return bal
+}

op-acceptance-tests/tests/celo/init_test.go

@@ -0,0 +1,18 @@
+package celo
+
+import (
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-devstack/presets"
+	"github.com/ethereum-optimism/optimism/op-devstack/stack"
+	"github.com/ethereum-optimism/optimism/op-devstack/sysgo"
+)
+
+func TestMain(m *testing.M) {
+	presets.DoMain(m,
+		presets.WithMinimal(),
+		stack.MakeCommon(sysgo.WithDeployerOptions(
+			sysgo.WithCelo(),
+		)),
+	)
+}

op-core/predeploys/addresses.go

@@ -57,6 +57,14 @@ const (
 	SortedOracles                     = "0xefb84935239dacdecf7c5ba76d8de40b077b7b33"
 	AddressSortedLinkedListWithMedian = "0xED477A99035d0c1e11369F1D7A4e587893cc002B"
 	FeeCurrency                       = "0x4200000000000000000000000000000000001022"
+	// FeeCurrencyDirectory matches the celo-mainnet address that op-geth's
+	// addresses.MainnetAddresses defaults to when no chain-specific entry exists.
+	FeeCurrencyDirectory = "0x15F344b9E6c3Cb6F0376A36A64928b13F62C6276"
+	// TestFeeCurrency is a non-production fee currency installed by L2Genesis when
+	// deployCeloContracts is set, registered with the FeeCurrencyDirectory so CIP-64
+	// transactions can pay gas in it. The address is the celo-mainnet cUSD address
+	// (kept for a deterministic predeploy slot).
+	TestFeeCurrency = "0x765DE816845861e75A25fCA122bb6898B8B1282a"
 )
 
 var (
@@ -114,6 +122,8 @@ var (
 	SortedOraclesAddr                     = common.HexToAddress(SortedOracles)
 	AddressSortedLinkedListWithMedianAddr = common.HexToAddress(AddressSortedLinkedListWithMedian)
 	FeeCurrencyAddr                       = common.HexToAddress(FeeCurrency)
+	FeeCurrencyDirectoryAddr              = common.HexToAddress(FeeCurrencyDirectory)
+	TestFeeCurrencyAddr                   = common.HexToAddress(TestFeeCurrency)
 
 	CeloPredeploys = make(map[string]*Predeploy)
 )
@@ -213,6 +223,8 @@ func init() {
 	CeloPredeploys["SortedOracles"] = &Predeploy{Address: SortedOraclesAddr}
 	CeloPredeploys["AddressSortedLinkedListWithMedian"] = &Predeploy{Address: AddressSortedLinkedListWithMedianAddr}
 	CeloPredeploys["FeeCurrency"] = &Predeploy{Address: FeeCurrencyAddr}
+	CeloPredeploys["FeeCurrencyDirectory"] = &Predeploy{Address: FeeCurrencyDirectoryAddr}
+	CeloPredeploys["TestFeeCurrency"] = &Predeploy{Address: TestFeeCurrencyAddr}
 	for key, predeploy := range CeloPredeploys {
 		Predeploys[key] = predeploy
 	}

op-deployer/pkg/deployer/integration_test/apply_test.go

@@ -535,6 +535,40 @@ func TestApplyGenesisStrategy(t *testing.T) {
 	})
 }
 
+func TestApplyDeployCeloContracts(t *testing.T) {
+	op_e2e.InitParallel(t)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	opts, intent, st := setupGenesisChain(t, devnet.DefaultChainID)
+	intent.Chains[0].DeployCeloContracts = true
+
+	require.NoError(t, deployer.ApplyPipeline(ctx, opts))
+
+	allocs := st.Chains[0].Allocs.Data.Accounts
+
+	// Predeploys (proxies — code is the EIP-1967 Proxy bytecode at these addresses).
+	proxied := []common.Address{
+		predeploys.CeloRegistryAddr,
+		predeploys.GoldTokenAddr,
+		predeploys.FeeHandlerAddr,
+		predeploys.SortedOraclesAddr,
+		predeploys.FeeCurrencyDirectoryAddr,
+		predeploys.TestFeeCurrencyAddr, // StableTokenV2 instance registered as a fee currency
+	}
+	for _, addr := range proxied {
+		acc, ok := allocs[addr]
+		require.Truef(t, ok, "no account at %s", addr)
+		require.NotEmpty(t, acc.Code, "no code at %s", addr)
+	}
+
+	// Library — etched directly, not proxied.
+	acc, ok := allocs[predeploys.AddressSortedLinkedListWithMedianAddr]
+	require.True(t, ok, "no account at AddressSortedLinkedListWithMedian")
+	require.NotEmpty(t, acc.Code)
+}
+
 func TestProofParamOverrides(t *testing.T) {
 	op_e2e.InitParallel(t)
 

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

@@ -40,6 +40,7 @@ type L2GenesisInput struct {
 	NativeAssetLiquidityAmount               *big.Int
 	LiquidityControllerOwner                 common.Address
 	UseL2CM                                  bool
+	DeployCeloContracts                      bool
 }
 
 type L2GenesisScript script.DeployScriptWithoutOutput[L2GenesisInput]

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

@@ -47,6 +47,8 @@ type DeployOPChainInput struct {
 	SuperchainConfig    common.Address
 
 	UseCustomGasToken bool
+
+	DeployCeloContracts bool
 }
 
 type DeployOPChainOutput struct {

op-deployer/pkg/deployer/pipeline/l2genesis.go

@@ -127,6 +127,7 @@ func GenerateL2Genesis(pEnv *Env, intent *state.Intent, bundle ArtifactsBundle,
 		NativeAssetLiquidityAmount: cgt.NativeAssetLiquidityAmount,
 		LiquidityControllerOwner:   cgt.LiquidityControllerOwner,
 		UseL2CM:                    useL2CM,
+		DeployCeloContracts:        thisIntent.DeployCeloContracts,
 	}); err != nil {
 		return fmt.Errorf("failed to call L2Genesis script: %w", err)
 	}

op-deployer/pkg/deployer/pipeline/opchain.go

@@ -151,8 +151,8 @@ func makeDCI(intent *state.Intent, thisIntent *state.ChainIntent, chainID common
 		UnsafeBlockSigner:            thisIntent.Roles.UnsafeBlockSigner,
 		Proposer:                     thisIntent.Roles.Proposer,
 		Challenger:                   thisIntent.Roles.Challenger,
-		BasefeeScalar:                standard.BasefeeScalar,
-		BlobBaseFeeScalar:            standard.BlobBaseFeeScalar,
+		BasefeeScalar:                celoOrDefaultScalar(thisIntent.DeployCeloContracts, standard.BasefeeScalar),
+		BlobBaseFeeScalar:            celoOrDefaultScalar(thisIntent.DeployCeloContracts, standard.BlobBaseFeeScalar),
 		L2ChainId:                    chainID.Big(),
 		Opcm:                         opcmAddr,
 		SaltMixer:                    st.Create2Salt.String(), // passing through salt generated at state initialization
@@ -168,9 +168,19 @@ func makeDCI(intent *state.Intent, thisIntent *state.ChainIntent, chainID common
 		OperatorFeeConstant:          thisIntent.OperatorFeeConstant,
 		SuperchainConfig:             st.SuperchainDeployment.SuperchainConfigProxy,
 		UseCustomGasToken:            thisIntent.IsCustomGasTokenEnabled(),
+		DeployCeloContracts:          thisIntent.DeployCeloContracts,
 	}, nil
 }
 
+// celoOrDefaultScalar returns 0 when Celo contracts are deployed (so the chain operator
+// pays all L1 DA cost on behalf of users) and the standard default otherwise.
+func celoOrDefaultScalar(celo bool, def uint32) uint32 {
+	if celo {
+		return 0
+	}
+	return def
+}
+
 func makeChainState(chainID common.Hash, impls opcm.ReadImplementationAddressesOutput, dco opcm.DeployOPChainOutput) *state.ChainState {
 	opChainContracts := addresses.OpChainContracts{}
 	opChainContracts.OpChainProxyAdminImpl = dco.OpChainProxyAdmin

op-deployer/pkg/deployer/state/chain_intent.go

@@ -83,6 +83,7 @@ type ChainIntent struct {
 	MinBaseFee                 uint64                    `json:"minBaseFee,omitempty" toml:"minBaseFee,omitempty"`
 	DAFootprintGasScalar       uint16                    `json:"daFootprintGasScalar,omitempty" toml:"daFootprintGasScalar,omitempty"`
 	CustomGasToken             CustomGasToken            `json:"customGasToken" toml:"customGasToken"`
+	DeployCeloContracts        bool                      `json:"deployCeloContracts,omitempty" toml:"deployCeloContracts,omitempty"`
 
 	// Optional. For development purposes only. Only enabled if the operation mode targets a genesis-file output.
 	L2DevGenesisParams *L2DevGenesisParams `json:"l2DevGenesisParams,omitempty" toml:"l2DevGenesisParams,omitempty"`

op-deployer/pkg/deployer/state/deploy_config.go

@@ -62,8 +62,8 @@ func CombineDeployConfig(intent *Intent, chainIntent *ChainIntent, state *State,
 				GovernanceTokenOwner:  standard.GovernanceTokenOwner,
 			},
 			GasPriceOracleDeployConfig: genesis.GasPriceOracleDeployConfig{
-				GasPriceOracleBaseFeeScalar:       standard.BasefeeScalar,
-				GasPriceOracleBlobBaseFeeScalar:   standard.BlobBaseFeeScalar,
+				GasPriceOracleBaseFeeScalar:       celoOrDefaultScalar(chainIntent.DeployCeloContracts, standard.BasefeeScalar),
+				GasPriceOracleBlobBaseFeeScalar:   celoOrDefaultScalar(chainIntent.DeployCeloContracts, standard.BlobBaseFeeScalar),
 				GasPriceOracleOperatorFeeScalar:   chainIntent.OperatorFeeScalar,
 				GasPriceOracleOperatorFeeConstant: chainIntent.OperatorFeeConstant,
 			},
@@ -184,3 +184,12 @@ func calculateBatchInboxAddr(chainID common.Hash) common.Address {
 	copy(out[1:], crypto.Keccak256(chainID[:])[:19])
 	return out
 }
+
+// celoOrDefaultScalar returns 0 when Celo contracts are deployed (so the chain operator
+// pays all L1 DA cost on behalf of users) and the standard default otherwise.
+func celoOrDefaultScalar(celo bool, def uint32) uint32 {
+	if celo {
+		return 0
+	}
+	return def
+}

op-devstack/sysgo/deployer.go

@@ -406,6 +406,17 @@ func WithCustomGasToken(name, symbol string, initialLiquidity *big.Int, liquidit
 	}
 }
 
+// WithCelo enables Celo predeploys (CeloRegistry, FeeCurrencyDirectory, cUSD, ...) in the
+// L2 genesis allocs. cUSD is registered as a fee currency so CIP-64 (CeloDynamicFeeTxV2)
+// transactions can be paid in cUSD. devAccounts[0] is funded with 100k cUSD.
+func WithCelo() DeployerOption {
+	return func(p devtest.P, keys devkeys.Keys, builder intentbuilder.Builder) {
+		for _, l2Cfg := range builder.L2s() {
+			l2Cfg.WithDeployCeloContracts()
+		}
+	}
+}
+
 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")