archive expired retryables

arbos/arbosState/arbosstate.go

@@ -73,7 +73,7 @@ func OpenArbosState(stateDB vm.StateDB, burner burn.Burner) (*ArbosState, error)
 		backingStorage.OpenStorageBackedAddress(uint64(networkFeeAccountOffset)),
 		l1pricing.OpenL1PricingState(backingStorage.OpenSubStorage(l1PricingSubspace)),
 		l2pricing.OpenL2PricingState(backingStorage.OpenSubStorage(l2PricingSubspace)),
-		retryables.OpenRetryableState(backingStorage.OpenSubStorage(retryablesSubspace), stateDB),
+		retryables.OpenRetryableState(backingStorage.OpenSubStorage(retryablesSubspace)),
 		addressTable.Open(backingStorage.OpenSubStorage(addressTableSubspace)),
 		addressSet.OpenAddressSet(backingStorage.OpenSubStorage(chainOwnerSubspace)),
 		merkleAccumulator.OpenMerkleAccumulator(backingStorage.OpenSubStorage(sendMerkleSubspace)),

arbos/block_processor.go

@@ -36,10 +36,16 @@ var ArbSysAddress common.Address
 var InternalTxStartBlockMethodID [4]byte
 var InternalTxBatchPostingReportMethodID [4]byte
 var RedeemScheduledEventID common.Hash
+var ExpiredMerkleUpdateEventID common.Hash
+var ExpiredMerkleRootSnapshotEventID common.Hash
+var RetryableExpiredEventID common.Hash
 var L2ToL1TransactionEventID common.Hash
 var L2ToL1TxEventID common.Hash
 var EmitReedeemScheduledEvent func(*vm.EVM, uint64, uint64, [32]byte, [32]byte, common.Address, *big.Int, *big.Int) error
 var EmitTicketCreatedEvent func(*vm.EVM, [32]byte) error
+var EmitExpiredMerkleUpdateEvent func(*vm.EVM, [32]byte, *big.Int) error
+var EmitExpiredMerkleRootSnapshotEvent func(*vm.EVM, [32]byte, uint64) error
+var EmitRetryableExpiredEvent func(*vm.EVM, [32]byte, *big.Int, [32]byte, uint64) error
 var gasUsedSinceStartupCounter = metrics.NewRegisteredCounter("arb/gas_used", nil)
 
 type L1Info struct {
@@ -230,7 +236,7 @@ func ProduceBlockAdvanced(
 			}
 			retryable, _ := state.RetryableState().OpenRetryable(retry.TicketId, time)
 			if retryable == nil {
-				// retryable was already deleted
+				// retryable expired or was canceled
 				continue
 			}
 		} else {

arbos/internal_tx.go

@@ -9,6 +9,7 @@ import (
 	"math/big"
 
 	"github.com/offchainlabs/nitro/util/arbmath"
+	"github.com/offchainlabs/nitro/util/merkletree"
 
 	"github.com/ethereum/go-ethereum/log"
 
@@ -82,9 +83,43 @@ func ApplyInternalTxUpdate(tx *types.ArbitrumInternalTx, state *arbosState.Arbos
 
 		currentTime := evm.Context.Time
 
-		// Try to reap 2 retryables
-		_ = state.RetryableState().TryToReapOneRetryable(currentTime, evm, util.TracingDuringEVM)
-		_ = state.RetryableState().TryToReapOneRetryable(currentTime, evm, util.TracingDuringEVM)
+		// Try to reap 2 retryables, revert the state on failure
+		snapshot := evm.StateDB.Snapshot()
+	reapingLoop:
+		for i := 0; i < 2; i++ {
+			merkleUpdateEvents, leaf, err := state.RetryableState().TryToReapOneRetryable(currentTime, evm, util.TracingDuringEVM)
+			if err != nil {
+				log.Error("Failed to try reaping one retryable", "err", err)
+				break
+			}
+			if leaf != nil {
+				position := merkletree.LevelAndLeaf{Level: 0, Leaf: leaf.Index}
+				if err = EmitRetryableExpiredEvent(evm, leaf.Hash, position.ToBigInt(), leaf.TicketId, leaf.NumTries); err != nil {
+					log.Error("Failed to emit RetryableExpired event", "err", err)
+					break
+				}
+			}
+			for _, event := range merkleUpdateEvents {
+				position := merkletree.LevelAndLeaf{Level: event.Level, Leaf: event.NumLeaves}
+				if err = EmitExpiredMerkleUpdateEvent(evm, event.Hash, position.ToBigInt()); err != nil {
+					log.Error("Failed to emit ExpiredMerkleUpdate event", "err", err)
+					break reapingLoop
+				}
+			}
+			// we succeeded reaping, so take new snapshot
+			snapshot = evm.StateDB.Snapshot()
+		}
+		if err == nil {
+			err := state.RetryableState().TryRotatingExpiredRootSnapshots(currentTime)
+			if err != nil {
+				log.Error("Failed to try rotating expired root snapshots", "err", err)
+			}
+		}
+
+		if err != nil {
+			evm.StateDB.RevertToSnapshot(snapshot)
+			log.Warn("Reverting ticket handling because of an error (fully or partially)")
+		}
 
 		state.L2PricingState().UpdatePricingModel(l2BaseFee, timePassed, false)
 

arbos/l1pricing_test.go

@@ -229,7 +229,7 @@ func TestUpdateTimeUpgradeBehavior(t *testing.T) {
 	if !ok {
 		panic("not a statedb")
 	}
-	stateCheck(t, statedb, false, "uh oh, nothing should have happened", func() {
+	stateCheck(t, statedb, statedb, false, "uh oh, nothing should have happened", func() {
 		Require(t, l1p.UpdateForBatchPosterSpending(
 			evm.StateDB, evm, 1, 1, 1, poster, common.Big1, amount, util.TracingDuringEVM,
 		))

arbos/merkleAccumulator/merkleAccumulator.go

@@ -121,10 +121,10 @@ func (acc *MerkleAccumulator) setPartial(level uint64, val *common.Hash) error {
 }
 
 // Note: itemHash is hashed before being included in the tree, to prevent confusing leafs with branches.
-func (acc *MerkleAccumulator) Append(itemHash common.Hash) ([]MerkleTreeNodeEvent, error) {
+func (acc *MerkleAccumulator) Append(itemHash common.Hash) ([]MerkleTreeNodeEvent, uint64, error) {
 	size, err := acc.size.Increment()
 	if err != nil {
-		return nil, err
+		return nil, 0, err
 	}
 	events := []MerkleTreeNodeEvent{}
 
@@ -134,25 +134,25 @@ func (acc *MerkleAccumulator) Append(itemHash common.Hash) ([]MerkleTreeNodeEven
 		if level == CalcNumPartials(size-1) { // -1 to counteract the acc.size++ at top of this function
 			h := common.BytesToHash(soFar)
 			err := acc.setPartial(level, &h)
-			return events, err
+			return events, size, err
 		}
 		thisLevel, err := acc.getPartial(level)
 		if err != nil {
-			return nil, err
+			return nil, size, err
 		}
 		if *thisLevel == (common.Hash{}) {
 			h := common.BytesToHash(soFar)
 			err := acc.setPartial(level, &h)
-			return events, err
+			return events, size, err
 		}
 		soFar, err = acc.Keccak(thisLevel.Bytes(), soFar)
 		if err != nil {
-			return nil, err
+			return nil, size, err
 		}
 		h := common.Hash{}
 		err = acc.setPartial(level, &h)
 		if err != nil {
-			return nil, err
+			return nil, size, err
 		}
 		level += 1
 		events = append(events, MerkleTreeNodeEvent{level, size - 1, common.BytesToHash(soFar)})