test(validator): modify e2e tests related to V2

kroma-chain-ops/genesis/testdata/test-deploy-config-full.json

@@ -71,7 +71,7 @@
  "validatorManagerMaxFinalizations": 10,
  "validatorManagerBaseReward": "0x1",
  "assetManagerKgh": "0xff000000000000000000000000000000000000ff",
- "assetManagerVault": "0x14dC79964da2C08b23698B3D3cc7Ca32193d9955",
+ "assetManagerVault": "0x14dc79964da2c08b23698b3d3cc7ca32193d9955",
  "assetManagerMinDelegationPeriod": 2,
  "assetManagerBondAmount": "0xa",
  "securityCouncilOwners": [

kroma-validator/challenger.go

@@ -191,15 +191,16 @@ func (c *Challenger) InitConfig(ctx context.Context) error {
  if err != nil {
  if errors.Is(err, errors.New("method 'BOND_AMOUNT' not found")) {
  requiredBondAmountV2 = big.NewInt(0)
+ } else {
+ return fmt.Errorf("failed to get required bond amount: %w", err)
  }
- return fmt.Errorf("failed to get required bond amount: %w", err)
  }
  c.requiredBondAmountV2 = requiredBondAmountV2
 
  return nil
  })
  if err != nil {
- return fmt.Errorf("failed to initiate assetMgr config: %w, err")
+ return fmt.Errorf("failed to initiate assetMgr config: %w", err)
  }
 
  return nil

op-e2e/actions/l2_challenger.go

@@ -31,8 +31,8 @@ func (v *L2Validator) ActCreateChallenge(t Testing, outputIndex *big.Int) common
  }, "challenge is already in progress")
 
  canCreateChallenge, err := v.challenger.CanCreateChallenge(t.Ctx(), outputIndex)
- require.NoError(t, err, "unable to check if challenger is in the status that can create challenge")
- require.True(t, canCreateChallenge, "challenger is not in the status that can create challenge")
+ require.NoError(t, err, "unable to check if challenger can create challenge")
+ require.True(t, canCreateChallenge, "challenger cannot create challenge")
 
  tx, err := v.challenger.CreateChallenge(t.Ctx(), outputRange)
  require.NoError(t, err, "unable to create create challenge tx")

op-e2e/actions/l2_challenger_test.go

@@ -82,11 +82,9 @@ func ChallengeBasic(t *testing.T, deltaTimeOffset *hexutil.Uint64, version uint8
  // create challenge
  rt.setupChallenge(rt.challenger1, version)
 
- var beforeAsset *big.Int
- var slashingAmount *big.Int
- var taxAmount *big.Int
+ var beforeAsset, beforeAssetBonded *big.Int
  if version == valhelper.ValidatorV2 {
- beforeAsset, slashingAmount, taxAmount = rt.fetchChallengeAssets(rt.validator.address)
+ _, _, beforeAsset, beforeAssetBonded, _ = rt.fetchValidatorStatus(rt.validator)
  }
 
 interaction:
@@ -143,22 +141,11 @@ interaction:
  require.Equal(rt.t, big.NewInt(2*rt.dp.DeployConfig.ValidatorPoolRequiredBondAmount.ToInt().Int64()), bond.Amount)
  } else if version == valhelper.ValidatorV2 {
  // check asserter has been slashed
- valStatus, err := rt.validator.getValidatorStatus(rt.t)
- require.NoError(rt.t, err)
- require.Equal(rt.t, val.StatusRegistered, valStatus)
-
- afterAsset, err := rt.assetMgrContract.TotalKroAssets(nil, rt.validator.address)
- require.NoError(rt.t, err)
- require.Equal(rt.t, beforeAsset.Uint64()-slashingAmount.Uint64(), afterAsset.Uint64())
-
- inJail, err := rt.validator.isInJail(rt.t)
- require.NoError(rt.t, err)
+ valStatus, inJail, afterAsset, afterAssetBonded, slashingAmount := rt.fetchValidatorStatus(rt.validator)
+ require.Equal(rt.t, val.StatusReady, valStatus)
  require.True(rt.t, inJail)
-
- // check security council has received tax
- bal, err := rt.assetTokenContract.BalanceOf(nil, rt.sd.DeploymentsL1.SecurityCouncilProxy)
- require.NoError(rt.t, err)
- require.Equal(t, taxAmount.Uint64(), bal.Uint64())
+ require.Equal(rt.t, beforeAsset.Uint64()-slashingAmount.Uint64(), afterAsset.Uint64())
+ require.Equal(rt.t, beforeAssetBonded.Uint64()-slashingAmount.Uint64(), afterAssetBonded.Uint64())
  }
 }
 
@@ -183,11 +170,9 @@ func ChallengeAsserterBisectTimeout(t *testing.T, deltaTimeOffset *hexutil.Uint6
  // create challenge
  rt.setupChallenge(rt.challenger1, version)
 
- var beforeAsset *big.Int
- var slashingAmount *big.Int
- var taxAmount *big.Int
+ var beforeAsset, beforeAssetBonded *big.Int
  if version == valhelper.ValidatorV2 {
- beforeAsset, slashingAmount, taxAmount = rt.fetchChallengeAssets(rt.validator.address)
+ _, _, beforeAsset, beforeAssetBonded, _ = rt.fetchValidatorStatus(rt.validator)
  }
 
 interaction:
@@ -239,22 +224,11 @@ interaction:
  require.Equal(rt.t, big.NewInt(2*rt.dp.DeployConfig.ValidatorPoolRequiredBondAmount.ToInt().Int64()), bond.Amount)
  } else if version == valhelper.ValidatorV2 {
  // check asserter has been slashed
- valStatus, err := rt.validator.getValidatorStatus(rt.t)
- require.NoError(rt.t, err)
- require.Equal(rt.t, val.StatusRegistered, valStatus)
-
- afterAsset, err := rt.assetMgrContract.TotalKroAssets(nil, rt.validator.address)
- require.NoError(rt.t, err)
- require.Equal(rt.t, beforeAsset.Uint64()-slashingAmount.Uint64(), afterAsset.Uint64())
-
- inJail, err := rt.validator.isInJail(rt.t)
- require.NoError(rt.t, err)
+ valStatus, inJail, afterAsset, afterAssetBonded, slashingAmount := rt.fetchValidatorStatus(rt.validator)
+ require.Equal(rt.t, val.StatusReady, valStatus)
  require.True(rt.t, inJail)
-
- // check security council has received tax
- bal, err := rt.assetTokenContract.BalanceOf(nil, rt.sd.DeploymentsL1.SecurityCouncilProxy)
- require.NoError(rt.t, err)
- require.Equal(t, taxAmount.Uint64(), bal.Uint64())
+ require.Equal(rt.t, beforeAsset.Uint64()-slashingAmount.Uint64(), afterAsset.Uint64())
+ require.Equal(rt.t, beforeAssetBonded.Uint64()-slashingAmount.Uint64(), afterAssetBonded.Uint64())
  }
 }
 
@@ -278,11 +252,9 @@ func ChallengeChallengerBisectTimeout(t *testing.T, deltaTimeOffset *hexutil.Uin
  // create challenge
  rt.setupChallenge(rt.challenger1, version)
 
- var beforeAsset *big.Int
- var slashingAmount *big.Int
- var taxAmount *big.Int
+ var beforeAsset, beforeAssetBonded *big.Int
  if version == valhelper.ValidatorV2 {
- beforeAsset, slashingAmount, taxAmount = rt.fetchChallengeAssets(rt.challenger1.address)
+ _, _, beforeAsset, beforeAssetBonded, _ = rt.fetchValidatorStatus(rt.challenger1)
  }
 
 interaction:
@@ -333,22 +305,11 @@ interaction:
  require.Equal(rt.t, big.NewInt(2*rt.dp.DeployConfig.ValidatorPoolRequiredBondAmount.ToInt().Int64()), bond.Amount)
  } else if version == valhelper.ValidatorV2 {
  // check challenger has been slashed
- valStatus, err := rt.challenger1.getValidatorStatus(rt.t)
- require.NoError(rt.t, err)
- require.Equal(rt.t, val.StatusRegistered, valStatus)
-
- afterAsset, err := rt.assetMgrContract.TotalKroAssets(nil, rt.challenger1.address)
- require.NoError(rt.t, err)
- require.Equal(rt.t, beforeAsset.Uint64()-slashingAmount.Uint64(), afterAsset.Uint64())
-
- inJail, err := rt.challenger1.isInJail(rt.t)
- require.NoError(rt.t, err)
+ valStatus, inJail, afterAsset, afterAssetBonded, slashingAmount := rt.fetchValidatorStatus(rt.challenger1)
+ require.Equal(rt.t, val.StatusReady, valStatus)
  require.True(rt.t, inJail)
-
- // check security council has received tax
- bal, err := rt.assetTokenContract.BalanceOf(nil, rt.sd.DeploymentsL1.SecurityCouncilProxy)
- require.NoError(rt.t, err)
- require.Equal(t, taxAmount.Uint64(), bal.Uint64())
+ require.Equal(rt.t, beforeAsset.Uint64()-slashingAmount.Uint64(), afterAsset.Uint64())
+ require.Equal(rt.t, beforeAssetBonded.Uint64()-slashingAmount.Uint64(), afterAssetBonded.Uint64())
  }
 }
 
@@ -372,11 +333,9 @@ func ChallengeChallengerProvingTimeout(t *testing.T, deltaTimeOffset *hexutil.Ui
  // create challenge
  rt.setupChallenge(rt.challenger1, version)
 
- var beforeAsset *big.Int
- var slashingAmount *big.Int
- var taxAmount *big.Int
+ var beforeAsset, beforeAssetBonded *big.Int
  if version == valhelper.ValidatorV2 {
- beforeAsset, slashingAmount, taxAmount = rt.fetchChallengeAssets(rt.challenger1.address)
+ _, _, beforeAsset, beforeAssetBonded, _ = rt.fetchValidatorStatus(rt.challenger1)
  }
 
 interaction:
@@ -431,22 +390,11 @@ interaction:
  require.Equal(rt.t, big.NewInt(2*rt.dp.DeployConfig.ValidatorPoolRequiredBondAmount.ToInt().Int64()), bond.Amount)
  } else if version == valhelper.ValidatorV2 {
  // check challenger has been slashed
- valStatus, err := rt.challenger1.getValidatorStatus(rt.t)
- require.NoError(rt.t, err)
- require.Equal(rt.t, val.StatusRegistered, valStatus)
-
- afterAsset, err := rt.assetMgrContract.TotalKroAssets(nil, rt.challenger1.address)
- require.NoError(rt.t, err)
- require.Equal(rt.t, beforeAsset.Uint64()-slashingAmount.Uint64(), afterAsset.Uint64())
-
- inJail, err := rt.challenger1.isInJail(rt.t)
- require.NoError(rt.t, err)
+ valStatus, inJail, afterAsset, afterAssetBonded, slashingAmount := rt.fetchValidatorStatus(rt.challenger1)
+ require.Equal(rt.t, val.StatusReady, valStatus)
  require.True(rt.t, inJail)
-
- // check security council has received tax
- bal, err := rt.assetTokenContract.BalanceOf(nil, rt.sd.DeploymentsL1.SecurityCouncilProxy)
- require.NoError(rt.t, err)
- require.Equal(t, taxAmount.Uint64(), bal.Uint64())
+ require.Equal(rt.t, beforeAsset.Uint64()-slashingAmount.Uint64(), afterAsset.Uint64())
+ require.Equal(rt.t, beforeAssetBonded.Uint64()-slashingAmount.Uint64(), afterAssetBonded.Uint64())
  }
 }
 
@@ -471,11 +419,10 @@ func ChallengeInvalidProofFail(t *testing.T, deltaTimeOffset *hexutil.Uint64, ve
  // create challenge
  rt.setupChallenge(rt.challenger1, version)
 
- var taxAmount *big.Int
+ var beforeAssetChal, beforeAssetVal, beforeAssetBondedChal, beforeAssetBondedVal *big.Int
  if version == valhelper.ValidatorV2 {
- // if the challenger proves fault with invalid proof, asserter will be slashed
- // after security council dismisses the challenge, the slashed asset should be handled manually
- _, _, taxAmount = rt.fetchChallengeAssets(rt.validator.address)
+ _, _, beforeAssetChal, beforeAssetBondedChal, _ = rt.fetchValidatorStatus(rt.challenger1)
+ _, _, beforeAssetVal, beforeAssetBondedVal, _ = rt.fetchValidatorStatus(rt.validator)
  }
 
 interaction:
@@ -551,15 +498,19 @@ interaction:
  require.NoError(rt.t, err)
  require.Equal(rt.t, big.NewInt(2*rt.dp.DeployConfig.ValidatorPoolRequiredBondAmount.ToInt().Int64()), bond.Amount)
  } else if version == valhelper.ValidatorV2 {
- // check asserter has been unjailed by guardian
- inJail, err := rt.validator.isInJail(rt.t)
- require.NoError(rt.t, err)
- require.False(rt.t, inJail)
+ // check challenger has been slashed
+ valStatus, inJail, afterAsset, afterAssetBonded, slashingAmount := rt.fetchValidatorStatus(rt.challenger1)
+ require.Equal(rt.t, val.StatusReady, valStatus)
+ require.True(rt.t, inJail)
+ require.Equal(rt.t, beforeAssetChal.Uint64()-slashingAmount.Uint64(), afterAsset.Uint64())
+ require.Equal(rt.t, beforeAssetBondedChal.Uint64()-slashingAmount.Uint64(), afterAssetBonded.Uint64())
 
- // check security council has received tax
- bal, err := rt.assetTokenContract.BalanceOf(nil, rt.sd.DeploymentsL1.SecurityCouncilProxy)
- require.NoError(rt.t, err)
- require.Equal(t, taxAmount.Uint64(), bal.Uint64())
+ // check asserter has been reverted slash by guardian
+ valStatus, inJail, afterAsset, afterAssetBonded, slashingAmount = rt.fetchValidatorStatus(rt.validator)
+ require.Equal(rt.t, val.StatusActive, valStatus)
+ require.False(rt.t, inJail)
+ require.Equal(rt.t, beforeAssetVal.Uint64(), afterAsset.Uint64())
+ require.Equal(rt.t, beforeAssetBondedVal.Uint64(), afterAssetBonded.Uint64())
  }
 }
 
@@ -584,11 +535,9 @@ func ChallengeForceDeleteOutputBySecurityCouncil(t *testing.T, deltaTimeOffset *
  // create challenge
  rt.setupChallenge(rt.challenger1, version)
 
- var beforeAsset *big.Int
- var slashingAmount *big.Int
- var taxAmount *big.Int
+ var beforeAsset, beforeAssetBonded *big.Int
  if version == valhelper.ValidatorV2 {
- beforeAsset, slashingAmount, taxAmount = rt.fetchChallengeAssets(rt.validator.address)
+ _, _, beforeAsset, beforeAssetBonded, _ = rt.fetchValidatorStatus(rt.validator)
  }
 
 interaction:
@@ -651,22 +600,11 @@ interaction:
  require.Equal(rt.t, big.NewInt(2*rt.dp.DeployConfig.ValidatorPoolRequiredBondAmount.ToInt().Int64()), bond.Amount)
  } else if version == valhelper.ValidatorV2 {
  // check asserter has been slashed
- valStatus, err := rt.validator.getValidatorStatus(rt.t)
- require.NoError(rt.t, err)
- require.Equal(rt.t, val.StatusRegistered, valStatus)
-
- inJail, err := rt.validator.isInJail(rt.t)
- require.NoError(rt.t, err)
+ valStatus, inJail, afterAsset, afterAssetBonded, slashingAmount := rt.fetchValidatorStatus(rt.validator)
+ require.Equal(rt.t, val.StatusReady, valStatus)
  require.True(rt.t, inJail)
-
- afterAsset, err := rt.assetMgrContract.TotalKroAssets(nil, rt.validator.address)
- require.NoError(rt.t, err)
  require.Equal(rt.t, beforeAsset.Uint64()-slashingAmount.Uint64(), afterAsset.Uint64())
-
- // check security council has received tax (in this case, tax is double: challenger timeout and force delete output)
- bal, err := rt.assetTokenContract.BalanceOf(nil, rt.sd.DeploymentsL1.SecurityCouncilProxy)
- require.NoError(rt.t, err)
- require.Equal(t, taxAmount.Uint64()*2, bal.Uint64())
+ require.Equal(rt.t, beforeAssetBonded.Uint64()-slashingAmount.Uint64(), afterAssetBonded.Uint64())
  }
 }
 
@@ -741,6 +679,10 @@ interaction1:
  balance, err := rt.valPoolContract.BalanceOf(nil, rt.challenger2.address)
  require.NoError(rt.t, err)
  require.Equal(rt.t, balance.Int64(), defaultDepositAmount-rt.dp.DeployConfig.ValidatorPoolRequiredBondAmount.ToInt().Int64())
+ } else if version == valhelper.ValidatorV2 {
+ // check bond amount before challenge is canceled
+ _, _, _, bond, slashingAmount := rt.fetchValidatorStatus(rt.challenger2)
+ require.Equal(t, slashingAmount.Uint64(), bond.Uint64())
  }
 
  // progress challenge by challenger 2
@@ -777,5 +719,9 @@ interaction2:
  balance, err := rt.valPoolContract.BalanceOf(nil, rt.challenger2.address)
  require.NoError(rt.t, err)
  require.Equal(rt.t, balance.Int64(), int64(defaultDepositAmount))
+ } else if version == valhelper.ValidatorV2 {
+ // check bond amount released after challenge canceled
+ _, _, _, bond, _ := rt.fetchValidatorStatus(rt.challenger2)
+ require.Equal(t, uint64(0), bond.Uint64())
  }
 }

op-e2e/actions/l2_runtime.go

@@ -11,7 +11,6 @@ import (
  "github.com/ethereum-optimism/optimism/op-service/testlog"
  "github.com/ethereum/go-ethereum/common"
  "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
  "github.com/ethereum/go-ethereum/core/types"
  "github.com/ethereum/go-ethereum/log"
  "github.com/stretchr/testify/require"
@@ -260,6 +259,11 @@ func (rt *Runtime) setupChallenge(challenger *L2Validator, version uint8) {
  require.Equal(rt.t, rt.dp.DeployConfig.ValidatorPoolRequiredBondAmount.ToInt(), bond.Amount)
  } else if version == valhelper.ValidatorV2 {
  rt.registerToValMgr(challenger)
+
+ // check bond amount before create challenge
+ bond, err := rt.assetMgrContract.TotalValidatorKroBonded(nil, challenger.address)
+ require.NoError(rt.t, err)
+ require.Equal(rt.t, uint64(0), bond.Uint64())
  }
 
  // submit create challenge tx
@@ -288,6 +292,11 @@ func (rt *Runtime) setupChallenge(challenger *L2Validator, version uint8) {
  cBal, err := rt.valPoolContract.BalanceOf(nil, challenger.address)
  require.NoError(rt.t, err)
  require.Equal(rt.t, new(big.Int).Sub(new(big.Int).SetInt64(defaultDepositAmount), rt.dp.DeployConfig.ValidatorPoolRequiredBondAmount.ToInt()), cBal)
+ } else if version == valhelper.ValidatorV2 {
+ // check bond amount after create challenge
+ bond, err := rt.assetMgrContract.TotalValidatorKroBonded(nil, challenger.address)
+ require.NoError(rt.t, err)
+ require.Equal(rt.t, rt.dp.DeployConfig.AssetManagerBondAmount.ToInt().Uint64(), bond.Uint64())
  }
 }
 
@@ -304,6 +313,7 @@ func (rt *Runtime) depositToValPool(validator *L2Validator) {
 
 func (rt *Runtime) registerToValMgr(validator *L2Validator) {
  minActivateAmount := rt.dp.DeployConfig.ValidatorManagerMinActivateAmount.ToInt()
+ minActivateAmount = new(big.Int).Mul(minActivateAmount, common.Big256)
 
  // approve governance token
  validator.ActApprove(rt.t, minActivateAmount)
@@ -314,8 +324,7 @@ func (rt *Runtime) registerToValMgr(validator *L2Validator) {
  rt.includeL1BlockBySender(validator.address)
 
  // check validator status is active
- status, err := validator.getValidatorStatus(rt.t)
- require.NoError(rt.t, err)
+ status := validator.getValidatorStatus(rt.t)
  require.Equal(rt.t, val.StatusActive, status)
 }
 
@@ -354,25 +363,17 @@ func (rt *Runtime) submitL2Output() {
  require.Equal(rt.t, types.ReceiptStatusSuccessful, receipt.Status, "submission failed")
 }
 
-func (rt *Runtime) fetchChallengeAssets(loser common.Address) (*big.Int, *big.Int, *big.Int) {
- slashingRate, err := rt.assetMgrContract.SLASHINGRATE(nil)
- require.NoError(rt.t, err)
- slashingRateDenom, err := rt.assetMgrContract.SLASHINGRATEDENOM(nil)
- require.NoError(rt.t, err)
- taxRate, err := rt.assetMgrContract.TAXNUMERATOR(nil)
+func (rt *Runtime) fetchValidatorStatus(validator *L2Validator) (uint8, bool, *big.Int, *big.Int, *big.Int) {
+ valStatus := validator.getValidatorStatus(rt.t)
+ inJail := validator.isInJail(rt.t)
+ slashingAmount, err := rt.assetMgrContract.BONDAMOUNT(nil)
  require.NoError(rt.t, err)
- taxDenom, err := rt.assetMgrContract.TAXDENOMINATOR(nil)
+ validatorAsset, err := rt.assetMgrContract.TotalValidatorKro(nil, validator.address)
  require.NoError(rt.t, err)
- minSlashingAmount, err := rt.assetMgrContract.MINSLASHINGAMOUNT(nil)
+ validatorAssetBonded, err := rt.assetMgrContract.TotalValidatorKroBonded(nil, validator.address)
  require.NoError(rt.t, err)
- totalAsset, err := rt.assetMgrContract.TotalKroAssets(nil, loser)
- require.NoError(rt.t, err)
-
- slashingAmount := new(big.Int).Div(new(big.Int).Mul(totalAsset, slashingRate), slashingRateDenom)
- slashingAmount = math.BigMax(slashingAmount, minSlashingAmount)
- taxAmount := new(big.Int).Div(new(big.Int).Mul(slashingAmount, taxRate), taxDenom)
 
- return totalAsset, slashingAmount, taxAmount
+ return valStatus, inJail, validatorAsset, validatorAssetBonded, slashingAmount
 }
 
 func (rt *Runtime) includeL1BlockBySender(from common.Address) {