Merge #4082 #4089 #4096

4082: Update fvm test to use vm.RunV2 r=pattyshack a=pattyshack



4089: Move logical time into a separate package r=pattyshack a=pattyshack

To be reuse for the generalized transactional manager.

4096: Fix error predicate typo r=pattyshack a=pattyshack



Co-authored-by: Patrick Lee <[email protected]>

Author: bors[bot]

fvm/bootstrap.go

@@ -13,6 +13,7 @@ import (
 	"github.com/onflow/flow-go/fvm/errors"
 	"github.com/onflow/flow-go/fvm/meter"
 	"github.com/onflow/flow-go/fvm/storage"
+	"github.com/onflow/flow-go/fvm/storage/logical"
 	"github.com/onflow/flow-go/model/flow"
 	"github.com/onflow/flow-go/module/epochs"
 )
@@ -259,7 +260,7 @@ func (BootstrapProcedure) Type() ProcedureType {
 	return BootstrapProcedureType
 }
 
-func (proc *BootstrapProcedure) ExecutionTime() derived.LogicalTime {
+func (proc *BootstrapProcedure) ExecutionTime() logical.Time {
 	return 0
 }
 

fvm/derived/derived_block_data.go

@@ -7,6 +7,7 @@ import (
 	"github.com/onflow/cadence/runtime/interpreter"
 
 	"github.com/onflow/flow-go/fvm/state"
+	"github.com/onflow/flow-go/fvm/storage/logical"
 )
 
 type DerivedTransaction interface {
@@ -101,8 +102,8 @@ func (block *DerivedBlockData) NewChildDerivedBlockData() *DerivedBlockData {
 }
 
 func (block *DerivedBlockData) NewSnapshotReadDerivedTransactionData(
-	snapshotTime LogicalTime,
-	executionTime LogicalTime,
+	snapshotTime logical.Time,
+	executionTime logical.Time,
 ) (
 	DerivedTransactionCommitter,
 	error,
@@ -128,8 +129,8 @@ func (block *DerivedBlockData) NewSnapshotReadDerivedTransactionData(
 }
 
 func (block *DerivedBlockData) NewDerivedTransactionData(
-	snapshotTime LogicalTime,
-	executionTime LogicalTime,
+	snapshotTime logical.Time,
+	executionTime logical.Time,
 ) (
 	DerivedTransactionCommitter,
 	error,

fvm/derived/table.go

@@ -7,8 +7,12 @@ import (
 	"github.com/hashicorp/go-multierror"
 
 	"github.com/onflow/flow-go/fvm/state"
+	"github.com/onflow/flow-go/fvm/storage/logical"
 )
 
+// TODO(patrick): rm once emulator is updated
+const EndOfBlockExecutionTime = logical.EndOfBlockExecutionTime
+
 // ValueComputer is used by DerivedDataTable's GetOrCompute to compute the
 // derived value when the value is not in DerivedDataTable (i.e., "cache miss").
 type ValueComputer[TKey any, TVal any] interface {
@@ -43,7 +47,7 @@ type DerivedDataTable[TKey comparable, TVal any] struct {
 	lock  sync.RWMutex
 	items map[TKey]*invalidatableEntry[TVal]
 
-	latestCommitExecutionTime LogicalTime
+	latestCommitExecutionTime logical.Time
 
 	invalidators chainedTableInvalidators[TKey, TVal] // Guarded by lock.
 }
@@ -53,10 +57,10 @@ type TableTransaction[TKey comparable, TVal any] struct {
 
 	// The start time when the snapshot first becomes readable (i.e., the
 	// "snapshotTime - 1"'s transaction committed the snapshot view).
-	snapshotTime LogicalTime
+	snapshotTime logical.Time
 
 	// The transaction (or script)'s execution start time (aka TxIndex).
-	executionTime LogicalTime
+	executionTime logical.Time
 
 	// toValidateTime is used to amortize cost of repeated Validate calls.
 	// Each Validate call will only validate the time range
@@ -66,7 +70,7 @@ type TableTransaction[TKey comparable, TVal any] struct {
 	// Note that since newly derived values are computed based on snapshotTime's
 	// view, each time a newly derived value is added to the transaction,
 	// toValidateTime is reset back to snapshotTime.
-	toValidateTime LogicalTime
+	toValidateTime logical.Time
 
 	readSet  map[TKey]*invalidatableEntry[TVal]
 	writeSet map[TKey]*invalidatableEntry[TVal]
@@ -77,7 +81,7 @@ type TableTransaction[TKey comparable, TVal any] struct {
 }
 
 func newEmptyTable[TKey comparable, TVal any](
-	latestCommit LogicalTime,
+	latestCommit logical.Time,
 ) *DerivedDataTable[TKey, TVal] {
 	return &DerivedDataTable[TKey, TVal]{
 		items:                     map[TKey]*invalidatableEntry[TVal]{},
@@ -87,7 +91,7 @@ func newEmptyTable[TKey comparable, TVal any](
 }
 
 func NewEmptyTable[TKey comparable, TVal any]() *DerivedDataTable[TKey, TVal] {
-	return newEmptyTable[TKey, TVal](ParentBlockTime)
+	return newEmptyTable[TKey, TVal](logical.ParentBlockTime)
 }
 
 // This variant is needed by the chunk verifier, which does not start at the
@@ -98,7 +102,7 @@ func NewEmptyTableWithOffset[
 ](
 	offset uint32,
 ) *DerivedDataTable[TKey, TVal] {
-	return newEmptyTable[TKey, TVal](LogicalTime(offset) - 1)
+	return newEmptyTable[TKey, TVal](logical.Time(offset) - 1)
 }
 
 func (table *DerivedDataTable[TKey, TVal]) NewChildTable() *DerivedDataTable[TKey, TVal] {
@@ -122,7 +126,7 @@ func (table *DerivedDataTable[TKey, TVal]) NewChildTable() *DerivedDataTable[TKe
 
 	return &DerivedDataTable[TKey, TVal]{
 		items:                     items,
-		latestCommitExecutionTime: ParentBlockTime,
+		latestCommitExecutionTime: logical.ParentBlockTime,
 		invalidators:              nil,
 	}
 }
@@ -131,7 +135,7 @@ func (table *DerivedDataTable[TKey, TVal]) NextTxIndexForTestingOnly() uint32 {
 	return uint32(table.LatestCommitExecutionTimeForTestingOnly()) + 1
 }
 
-func (table *DerivedDataTable[TKey, TVal]) LatestCommitExecutionTimeForTestingOnly() LogicalTime {
+func (table *DerivedDataTable[TKey, TVal]) LatestCommitExecutionTimeForTestingOnly() logical.Time {
 	table.lock.RLock()
 	defer table.lock.RUnlock()
 
@@ -235,7 +239,7 @@ func (table *DerivedDataTable[TKey, TVal]) commit(
 
 	if table.latestCommitExecutionTime+1 < txn.snapshotTime &&
 		(!txn.isSnapshotReadTransaction ||
-			txn.snapshotTime != EndOfBlockExecutionTime) {
+			txn.snapshotTime != logical.EndOfBlockExecutionTime) {
 
 		return newNotRetryableError(
 			"invalid TableTransaction: missing commit range [%v, %v)",
@@ -290,9 +294,9 @@ func (table *DerivedDataTable[TKey, TVal]) commit(
 }
 
 func (table *DerivedDataTable[TKey, TVal]) newTableTransaction(
-	upperBoundExecutionTime LogicalTime,
-	snapshotTime LogicalTime,
-	executionTime LogicalTime,
+	upperBoundExecutionTime logical.Time,
+	snapshotTime logical.Time,
+	executionTime logical.Time,
 	isSnapshotReadTransaction bool,
 ) (
 	*TableTransaction[TKey, TVal],
@@ -323,28 +327,28 @@ func (table *DerivedDataTable[TKey, TVal]) newTableTransaction(
 }
 
 func (table *DerivedDataTable[TKey, TVal]) NewSnapshotReadTableTransaction(
-	snapshotTime LogicalTime,
-	executionTime LogicalTime,
+	snapshotTime logical.Time,
+	executionTime logical.Time,
 ) (
 	*TableTransaction[TKey, TVal],
 	error,
 ) {
 	return table.newTableTransaction(
-		LargestSnapshotReadTransactionExecutionTime,
+		logical.LargestSnapshotReadTransactionExecutionTime,
 		snapshotTime,
 		executionTime,
 		true)
 }
 
 func (table *DerivedDataTable[TKey, TVal]) NewTableTransaction(
-	snapshotTime LogicalTime,
-	executionTime LogicalTime,
+	snapshotTime logical.Time,
+	executionTime logical.Time,
 ) (
 	*TableTransaction[TKey, TVal],
 	error,
 ) {
 	return table.newTableTransaction(
-		LargestNormalTransactionExecutionTime,
+		logical.LargestNormalTransactionExecutionTime,
 		snapshotTime,
 		executionTime,
 		false)
@@ -485,6 +489,6 @@ func (txn *TableTransaction[TKey, TVal]) Commit() RetryableError {
 	return txn.table.commit(txn)
 }
 
-func (txn *TableTransaction[TKey, TVal]) ToValidateTimeForTestingOnly() LogicalTime {
+func (txn *TableTransaction[TKey, TVal]) ToValidateTimeForTestingOnly() logical.Time {
 	return txn.toValidateTime
 }

fvm/derived/table_invalidator.go

@@ -2,6 +2,7 @@ package derived
 
 import (
 	"github.com/onflow/flow-go/fvm/state"
+	"github.com/onflow/flow-go/fvm/storage/logical"
 )
 
 type TableInvalidator[TKey comparable, TVal any] interface {
@@ -15,15 +16,15 @@ type TableInvalidator[TKey comparable, TVal any] interface {
 type tableInvalidatorAtTime[TKey comparable, TVal any] struct {
 	TableInvalidator[TKey, TVal]
 
-	executionTime LogicalTime
+	executionTime logical.Time
 }
 
 // NOTE: chainedInvalidator assumes that the entries are order by non-decreasing
 // execution time.
 type chainedTableInvalidators[TKey comparable, TVal any] []tableInvalidatorAtTime[TKey, TVal]
 
 func (chained chainedTableInvalidators[TKey, TVal]) ApplicableInvalidators(
-	toValidateTime LogicalTime,
+	toValidateTime logical.Time,
 ) chainedTableInvalidators[TKey, TVal] {
 	// NOTE: switch to bisection search (or reverse iteration) if the list
 	// is long.