Merge commit 'refs/pull/1793/head' of github.com:OffchainLabs/nitro i…

…nto dataposter-for-validator-contract-wallet

Makefile

@@ -346,10 +346,9 @@ contracts/test/prover/proofs/%.json: $(arbitrator_cases)/%.wasm $(arbitrator_pro
 	test -f target/lib-wasm/libbrotlidec-static.a || ./scripts/build-brotli.sh -w -d
 	@touch $@
 
-.make/wasm-lib: $(DEP_PREDICATE) $(ORDER_ONLY_PREDICATE) .make
+.make/wasm-lib: $(DEP_PREDICATE) arbitrator/wasm-libraries/soft-float/SoftFloat/build/Wasm-Clang/softfloat.a  $(ORDER_ONLY_PREDICATE) .make
 	test -f arbitrator/wasm-libraries/soft-float/bindings32.o || ./scripts/build-brotli.sh -f -d -t .
 	test -f arbitrator/wasm-libraries/soft-float/bindings64.o || ./scripts/build-brotli.sh -f -d -t .
-	test -f arbitrator/wasm-libraries/soft-float/SoftFloat/build/Wasm-Clang/softfloat.a || ./scripts/build-brotli.sh -f -d -t .
 	@touch $@
 
 .make:

arbos/arbosState/arbosstate.go

@@ -303,7 +303,16 @@ func (state *ArbosState) UpgradeArbosVersion(
 					ErrFatalNodeOutOfDate,
 				)
 			}
-			// no state changes needed
+			// Update the PerBatchGasCost to a more accurate value compared to the old v6 default.
+			ensure(state.l1PricingState.SetPerBatchGasCost(l1pricing.InitialPerBatchGasCostV12))
+
+			// We had mistakenly initialized AmortizedCostCapBips to math.MaxUint64 in older versions,
+			// but the correct value to disable the amortization cap is 0.
+			oldAmortizationCap, err := state.l1PricingState.AmortizedCostCapBips()
+			ensure(err)
+			if oldAmortizationCap == math.MaxUint64 {
+				ensure(state.l1PricingState.SetAmortizedCostCapBips(0))
+			}
 		default:
 			return fmt.Errorf(
 				"the chain is upgrading to unsupported ArbOS version %v, %w",
@@ -315,7 +324,9 @@ func (state *ArbosState) UpgradeArbosVersion(
 	}
 
 	if firstTime && upgradeTo >= 6 {
-		state.Restrict(state.l1PricingState.SetPerBatchGasCost(l1pricing.InitialPerBatchGasCostV6))
+		if upgradeTo < 11 {
+			state.Restrict(state.l1PricingState.SetPerBatchGasCost(l1pricing.InitialPerBatchGasCostV6))
+		}
 		state.Restrict(state.l1PricingState.SetEquilibrationUnits(l1pricing.InitialEquilibrationUnitsV6))
 		state.Restrict(state.l2PricingState.SetSpeedLimitPerSecond(l2pricing.InitialSpeedLimitPerSecondV6))
 		state.Restrict(state.l2PricingState.SetMaxPerBlockGasLimit(l2pricing.InitialPerBlockGasLimitV6))

arbos/l1pricing/l1pricing.go

@@ -72,9 +72,10 @@ const (
 )
 
 const (
-	InitialInertia           = 10
-	InitialPerUnitReward     = 10
-	InitialPerBatchGasCostV6 = 100000
+	InitialInertia            = 10
+	InitialPerUnitReward      = 10
+	InitialPerBatchGasCostV6  = 100_000
+	InitialPerBatchGasCostV12 = 210_000 // overriden as part of the upgrade
 )
 
 // one minute at 100000 bytes / sec

arbos/tx_processor.go

@@ -385,7 +385,10 @@ func (p *TxProcessor) GasChargingHook(gasRemaining *uint64) (common.Address, err
 		poster = p.evm.Context.Coinbase
 	}
 
-	if basefee.Sign() > 0 {
+	if p.msg.TxRunMode == core.MessageCommitMode {
+		p.msg.SkipL1Charging = false
+	}
+	if basefee.Sign() > 0 && !p.msg.SkipL1Charging {
 		// Since tips go to the network, and not to the poster, we use the basefee.
 		// Note, this only determines the amount of gas bought, not the price per gas.
 

go.mod

@@ -113,7 +113,6 @@ require (
 	github.com/hannahhoward/go-pubsub v0.0.0-20200423002714-8d62886cc36e // indirect
 	github.com/hashicorp/errwrap v1.1.0 // indirect
 	github.com/hashicorp/go-multierror v1.1.1 // indirect
-	github.com/holiman/big v0.0.0-20221017200358-a027dc42d04e // indirect
 	github.com/ipfs/bbloom v0.0.4 // indirect
 	github.com/ipfs/go-bitfield v1.1.0 // indirect
 	github.com/ipfs/go-block-format v0.1.1 // indirect

go.sum

@@ -600,8 +600,6 @@ github.com/hashicorp/vault/api v1.0.4/go.mod h1:gDcqh3WGcR1cpF5AJz/B1UFheUEneMoI
 github.com/hashicorp/vault/sdk v0.1.13/go.mod h1:B+hVj7TpuQY1Y/GPbCpffmgd+tSEwvhkWnjtSYCaS2M=
 github.com/hashicorp/yamux v0.0.0-20180604194846-3520598351bb/go.mod h1:+NfK9FKeTrX5uv1uIXGdwYDTeHna2qgaIlx54MXqjAM=
 github.com/hashicorp/yamux v0.0.0-20181012175058-2f1d1f20f75d/go.mod h1:+NfK9FKeTrX5uv1uIXGdwYDTeHna2qgaIlx54MXqjAM=
-github.com/holiman/big v0.0.0-20221017200358-a027dc42d04e h1:pIYdhNkDh+YENVNi3gto8n9hAmRxKxoar0iE6BLucjw=
-github.com/holiman/big v0.0.0-20221017200358-a027dc42d04e/go.mod h1:j9cQbcqHQujT0oKJ38PylVfqohClLr3CvDC+Qcg+lhU=
 github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao=
 github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA=
 github.com/holiman/uint256 v1.2.0 h1:gpSYcPLWGv4sG43I2mVLiDZCNDh/EpGjSk8tmtxitHM=

precompiles/ArbOwner_test.go

@@ -9,20 +9,17 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/offchainlabs/nitro/arbos/l1pricing"
-
-	"github.com/ethereum/go-ethereum/common/math"
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/params"
 
 	"github.com/offchainlabs/nitro/arbos/arbosState"
 	"github.com/offchainlabs/nitro/arbos/burn"
-	"github.com/offchainlabs/nitro/util/testhelpers"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/offchainlabs/nitro/arbos/l1pricing"
 	"github.com/offchainlabs/nitro/arbos/util"
+	"github.com/offchainlabs/nitro/util/testhelpers"
 )
 
 func TestArbOwner(t *testing.T) {
@@ -99,7 +96,7 @@ func TestArbOwner(t *testing.T) {
 
 	costCap, err := gasInfo.GetAmortizedCostCapBips(callCtx, evm)
 	Require(t, err)
-	if costCap != math.MaxUint64 {
+	if costCap != 0 {
 		Fail(t, costCap)
 	}
 	newCostCap := uint64(77734)

system_tests/estimation_test.go

@@ -218,3 +218,36 @@ func TestComponentEstimate(t *testing.T) {
 		Fatal(t, l2Estimate, l2Used)
 	}
 }
+
+func TestDisableL1Charging(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	_, node, client := CreateTestL2(t, ctx)
+	defer node.StopAndWait()
+	addr := common.HexToAddress("0x12345678")
+
+	gasWithL1Charging, err := client.EstimateGas(ctx, ethereum.CallMsg{To: &addr})
+	Require(t, err)
+
+	gasWithoutL1Charging, err := client.EstimateGas(ctx, ethereum.CallMsg{To: &addr, SkipL1Charging: true})
+	Require(t, err)
+
+	if gasWithL1Charging <= gasWithoutL1Charging {
+		Fatal(t, "SkipL1Charging didn't disable L1 charging")
+	}
+	if gasWithoutL1Charging != params.TxGas {
+		Fatal(t, "Incorrect gas estimate with disabled L1 charging")
+	}
+
+	_, err = client.CallContract(ctx, ethereum.CallMsg{To: &addr, Gas: gasWithL1Charging}, nil)
+	Require(t, err)
+
+	_, err = client.CallContract(ctx, ethereum.CallMsg{To: &addr, Gas: gasWithoutL1Charging}, nil)
+	if err == nil {
+		Fatal(t, "CallContract passed with insufficient gas")
+	}
+
+	_, err = client.CallContract(ctx, ethereum.CallMsg{To: &addr, Gas: gasWithoutL1Charging, SkipL1Charging: true}, nil)
+	Require(t, err)
+}

system_tests/staker_test.go

@@ -42,7 +42,7 @@ import (
 	"github.com/offchainlabs/nitro/validator/valnode"
 )
 
-func makeBackgroundTxs(ctx context.Context, l2info *BlockchainTestInfo, l2clientA arbutil.L1Interface, l2clientB arbutil.L1Interface, faultyStaker bool) error {
+func makeBackgroundTxs(ctx context.Context, l2info *BlockchainTestInfo, l2clientA arbutil.L1Interface) error {
 	for i := uint64(0); ctx.Err() == nil; i++ {
 		l2info.Accounts["BackgroundUser"].Nonce = i
 		tx := l2info.PrepareTx("BackgroundUser", "BackgroundUser", l2info.TransferGas, common.Big0, nil)
@@ -54,19 +54,6 @@ func makeBackgroundTxs(ctx context.Context, l2info *BlockchainTestInfo, l2client
 		if err != nil {
 			return err
 		}
-		if faultyStaker {
-			// Create a different transaction for the second node
-			l2info.Accounts["BackgroundUser"].Nonce = i
-			tx = l2info.PrepareTx("BackgroundUser", "BackgroundUser", l2info.TransferGas, common.Big1, nil)
-			err = l2clientB.SendTransaction(ctx, tx)
-			if err != nil {
-				return err
-			}
-			_, err = EnsureTxSucceeded(ctx, l2clientB, tx)
-			if err != nil {
-				return err
-			}
-		}
 	}
 	return nil
 }
@@ -112,7 +99,11 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 	if faultyStaker {
 		l2info.GenerateGenesisAccount("FaultyAddr", common.Big1)
 	}
-	l2clientB, l2nodeB := Create2ndNodeWithConfig(t, ctx, l2nodeA, l1stack, l1info, &l2info.ArbInitData, arbnode.ConfigDefaultL1Test(), nil)
+	config := arbnode.ConfigDefaultL1Test()
+	config.Sequencer.Enable = false
+	config.DelayedSequencer.Enable = false
+	config.BatchPoster.Enable = false
+	_, l2nodeB := Create2ndNodeWithConfig(t, ctx, l2nodeA, l1stack, l1info, &l2info.ArbInitData, config, nil)
 	defer l2nodeB.StopAndWait()
 
 	nodeAGenesis := l2nodeA.Execution.Backend.APIBackend().CurrentHeader().Hash()
@@ -162,6 +153,9 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 	_, err = EnsureTxSucceeded(ctx, l1client, tx)
 	Require(t, err)
 
+	validatorUtils, err := rollupgen.NewValidatorUtils(l2nodeA.DeployInfo.ValidatorUtils, l1client)
+	Require(t, err)
+
 	valConfig := staker.L1ValidatorConfig{}
 
 	dpA, err := validatorDataposter(rawdb.NewTable(l2nodeB.ArbDB, storage.BlockValidatorPrefix), l2nodeA.L1Reader, &l1authA, NewFetcherFromConfig(arbnode.ConfigDefaultL1NonSequencerTest()), nil)
@@ -280,12 +274,6 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 	Require(t, err)
 	_, err = EnsureTxSucceeded(ctx, l2clientA, tx)
 	Require(t, err)
-	if faultyStaker {
-		err = l2clientB.SendTransaction(ctx, tx)
-		Require(t, err)
-		_, err = EnsureTxSucceeded(ctx, l2clientB, tx)
-		Require(t, err)
-	}
 
 	// Continually make L2 transactions in a background thread
 	backgroundTxsCtx, cancelBackgroundTxs := context.WithCancel(ctx)
@@ -296,7 +284,7 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 	})()
 	go (func() {
 		defer close(backgroundTxsShutdownChan)
-		err := makeBackgroundTxs(backgroundTxsCtx, l2info, l2clientA, l2clientB, faultyStaker)
+		err := makeBackgroundTxs(backgroundTxsCtx, l2info, l2clientA)
 		if !errors.Is(err, context.Canceled) {
 			log.Warn("error making background txs", "err", err)
 		}
@@ -339,8 +327,11 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 				if !challengeMangerTimedOut {
 					// Upgrade the ChallengeManager contract to an implementation which says challenges are always timed out
 
-					mockImpl, _, _, err := mocksgen.DeployTimedOutChallengeManager(&deployAuth, l1client)
+					mockImpl, tx, _, err := mocksgen.DeployTimedOutChallengeManager(&deployAuth, l1client)
 					Require(t, err)
+					_, err = EnsureTxSucceeded(ctx, l1client, tx)
+					Require(t, err)
+
 					managerAddr := valWalletA.ChallengeManagerAddress()
 					// 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103
 					proxyAdminSlot := common.BigToHash(arbmath.BigSub(crypto.Keccak256Hash([]byte("eip1967.proxy.admin")).Big(), common.Big1))
@@ -353,7 +344,7 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 
 					proxyAdmin, err := mocksgen.NewProxyAdminForBinding(proxyAdminAddr, l1client)
 					Require(t, err)
-					tx, err := proxyAdmin.Upgrade(&deployAuth, managerAddr, mockImpl)
+					tx, err = proxyAdmin.Upgrade(&deployAuth, managerAddr, mockImpl)
 					Require(t, err)
 					_, err = EnsureTxSucceeded(ctx, l1client, tx)
 					Require(t, err)
@@ -379,9 +370,9 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 			Require(t, err, "EnsureTxSucceeded failed for staker", stakerName, "tx")
 		}
 		if faultyStaker {
-			challengeAddr, err := rollup.CurrentChallenge(&bind.CallOpts{}, valWalletAddrA)
+			conflictInfo, err := validatorUtils.FindStakerConflict(&bind.CallOpts{}, l2nodeA.DeployInfo.Rollup, l1authA.From, l1authB.From, big.NewInt(1024))
 			Require(t, err)
-			if challengeAddr != 0 {
+			if staker.ConflictType(conflictInfo.Ty) == staker.CONFLICT_TYPE_FOUND {
 				cancelBackgroundTxs()
 			}
 		}
@@ -394,6 +385,7 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 		if isHonestZombie {
 			Fatal(t, "staker A became a zombie")
 		}
+		fmt.Printf("watchtower staker acting:\n")
 		watchTx, err := stakerC.Act(ctx)
 		if err != nil && !strings.Contains(err.Error(), "catch up") {
 			Require(t, err, "watchtower staker failed to act")