state

type ExecutionParameters struct {
	meter.MeterParameters
}

type ExecutionState struct {
	// contains filtered or unexported fields
}

type Meter interface {
	// MeterComputation captures computation usage.
	//
	// Expected error returns during normal operation:
	//   - errors.LimitExceededError with errors.LimitKindComputation if the
	//     computation limit is exceeded
	MeterComputation(usage common.ComputationUsage) error
	ComputationRemaining(kind common.ComputationKind) uint64
	ComputationIntensities() meter.MeteredComputationIntensities
	TotalComputationLimit() uint64
	TotalComputationUsed() uint64

	// MeterMemory captures memory usage.
	//
	// Expected error returns during normal operation:
	//   - errors.LimitExceededError with errors.LimitKindMemory if the memory
	//     limit is exceeded
	MeterMemory(usage common.MemoryUsage) error
	MemoryAmounts() meter.MeteredMemoryAmounts
	TotalMemoryEstimate() uint64

	InteractionUsed() uint64

	// MeterEmittedEvent captures the byte size of an emitted event.
	//
	// Expected error returns during normal operation:
	//   - errors.LimitExceededError with errors.LimitKindEvent if the event
	//     byte size limit is exceeded
	MeterEmittedEvent(byteSize uint64) error

	// RunWithMeteringDisabled runs f with metering disabled.
	// While metering is disabled, usage of all metered quantities - computation,
	// memory, emitted events, and ledger interaction - is neither accumulated
	// toward the totals nor subject to its limit.
	// This function can be used to run a function that fits one of these cases:
	// - the function should not fail due to metering limits
	// - the function is not invokable by the user and has a constant execution time (e.g. fee deduction)
	// - the function is metered once before calling `RunWithMeteringDisabled` with a special weight (e.g. create account)
	// 		and doesn't need additional metering inside the function
	RunWithMeteringDisabled(f func())
}

type NestedTransactionId struct {
	// contains filtered or unexported fields
}

type NestedTransactionPreparer interface {
	Meter

	// ExecutionParameters returns the execution parameters
	ExecutionParameters() ExecutionParameters

	// NumNestedTransactions returns the number of uncommitted nested
	// transactions.  Note that the main transaction is not considered a
	// nested transaction.
	NumNestedTransactions() int

	// IsParseRestricted returns true if the current nested transaction is in
	// parse resticted access mode.
	IsParseRestricted() bool

	MainTransactionId() NestedTransactionId

	// IsCurrent returns true if the provide id refers to the current (nested)
	// transaction.
	IsCurrent(id NestedTransactionId) bool

	// InterimReadSet returns the current read set aggregated from all
	// outstanding nested transactions.
	InterimReadSet() map[flow.RegisterID]struct{}

	// FinalizeMainTransaction finalizes the main transaction and returns
	// its execution snapshot.  The finalized main transaction will not accept
	// any new commits after this point.  This returns an error if there are
	// outstanding nested transactions.
	FinalizeMainTransaction() (*snapshot.ExecutionSnapshot, error)

	// BeginNestedTransaction creates a unrestricted nested transaction within
	// the current unrestricted (nested) transaction.  The meter parameters are
	// inherited from the current transaction.  This returns error if the
	// current nested transaction is program restricted.
	BeginNestedTransaction() (
		NestedTransactionId,
		error,
	)

	// BeginNestedTransactionForDerivedData creates a unrestricted nested
	// transaction for computing a derived data value (e.g. loading a program
	// into the programs cache). Its state meters unconditionally, so the
	// cached snapshot's meter is deterministic regardless of the caller's
	// metering scope; see ExecutionState.NewChildForDerivedData (internal
	// issue #7126). This returns error if the current nested transaction is
	// program restricted.
	BeginNestedTransactionForDerivedData() (
		NestedTransactionId,
		error,
	)

	// BeginNestedTransactionWithMeterParams creates a unrestricted nested
	// transaction within the current unrestricted (nested) transaction, using
	// the provided meter parameters. This returns error if the current nested
	// transaction is program restricted.
	BeginNestedTransactionWithMeterParams(
		params ExecutionParameters,
	) (
		NestedTransactionId,
		error,
	)

	// BeginParseRestrictedNestedTransaction creates a restricted nested
	// transaction within the current (nested) transaction.  The meter
	// parameters are inherited from the current transaction.
	BeginParseRestrictedNestedTransaction(
		location common.AddressLocation,
	) (
		NestedTransactionId,
		error,
	)

	// CommitNestedTransaction commits the changes in the current unrestricted
	// nested transaction to the parent (nested) transaction.  This returns
	// error if the expectedId does not match the current nested transaction.
	// This returns the committed execution snapshot otherwise.
	//
	// Note: The returned committed execution snapshot may be reused by another
	// transaction via AttachAndCommitNestedTransaction to update the
	// transaction bookkeeping, but the caller must manually invalidate the
	// state.
	// USE WITH EXTREME CAUTION.
	CommitNestedTransaction(
		expectedId NestedTransactionId,
	) (
		*snapshot.ExecutionSnapshot,
		error,
	)

	// CommitParseRestrictedNestedTransaction commits the changes in the
	// current restricted nested transaction to the parent (nested)
	// transaction.  This returns error if the specified location does not
	// match the tracked location. This returns the committed execution
	// snapshot otherwise.
	//
	// Note: The returned committed execution snapshot may be reused by another
	// transaction via AttachAndCommitNestedTransaction to update the
	// transaction bookkeeping, but the caller must manually invalidate the
	// state.
	// USE WITH EXTREME CAUTION.
	CommitParseRestrictedNestedTransaction(
		location common.AddressLocation,
	) (
		*snapshot.ExecutionSnapshot,
		error,
	)

	// AttachAndCommitNestedTransaction commits the changes from the cached
	// nested transaction execution snapshot to the current (nested)
	// transaction.
	AttachAndCommitNestedTransaction(
		cachedSnapshot *snapshot.ExecutionSnapshot,
	) error

	// RestartNestedTransaction merges all changes that belongs to the nested
	// transaction about to be restart (for spock/meter bookkeeping), then
	// wipes its view changes.
	RestartNestedTransaction(
		id NestedTransactionId,
	) error

	// Get returns a register value from the current (nested) transaction's
	// view. Limits are only enforced when metering is enabled.
	//
	// Expected error returns during normal operation:
	//   - errors.StateKeySizeLimitError if the key exceeds the key size limit
	//   - errors.LimitExceededError with errors.LimitKindLedgerInteraction if
	//     the storage interaction limit is exceeded
	//
	// All other errors are exceptions (e.g. ledger failures).
	Get(id flow.RegisterID) (flow.RegisterValue, error)

	// Set updates a register value in the current (nested) transaction's
	// view. Limits are only enforced when metering is enabled.
	//
	// Expected error returns during normal operation:
	//   - errors.StateKeySizeLimitError or errors.StateValueSizeLimitError if
	//     the key or value exceeds its size limit
	//   - errors.LimitExceededError with errors.LimitKindLedgerInteraction if
	//     the storage interaction limit is exceeded
	//
	// All other errors are exceptions (e.g. ledger failures).
	Set(id flow.RegisterID, value flow.RegisterValue) error

	// BaseStorageSnapshot gives access to the storage snapshot as it was without changes
	// WARNING: this should not be read mid-transaction as reads to it are not recorded in the spocks
	BaseStorageSnapshot() snapshot.StorageSnapshot
}

type StateParameters struct {
	meter.MeterParameters
	// contains filtered or unexported fields
}