environment

type AccountCreator interface {
	CreateAccount(payer runtime.Address) (runtime.Address, error)
}

type AccountFreezer interface {
	// Note that the script variant will return OperationNotSupportedError.
	SetAccountFrozen(address common.Address, frozen bool) error

	FrozenAccounts() []common.Address

	Reset()
}

type AccountInfo interface {
	GetStorageUsed(address common.Address) (uint64, error)
	GetStorageCapacity(address common.Address) (uint64, error)
	GetAccountBalance(address common.Address) (uint64, error)
	GetAccountAvailableBalance(address common.Address) (uint64, error)
	GetAccount(address flow.Address) (*flow.Account, error)
}

type AccountKeyReader interface {
	// GetAccountKey retrieves a public key by index from an existing account.
	//
	// This function returns a nil key with no errors, if a key doesn't exist at
	// the given index. An error is returned if the specified account does not
	// exist, the provided index is not valid, or if the key retrieval fails.
	GetAccountKey(
		address runtime.Address,
		keyIndex int,
	) (
		*runtime.AccountKey,
		error,
	)
	AccountKeysCount(address runtime.Address) (uint64, error)
}

type AccountKeyUpdater interface {
	// AddEncodedAccountKey adds an encoded public key to an existing account.
	//
	// This function returns an error if the specified account does not exist or
	// if the key insertion fails.
	//
	// Note that the script variant will return OperationNotSupportedError.
	AddEncodedAccountKey(address runtime.Address, publicKey []byte) error

	// RevokeEncodedAccountKey revokes a public key by index from an existing
	// account.
	//
	// This function returns an error if the specified account does not exist,
	// the provided key is invalid, or if key revoking fails.
	//
	// Note that the script variant will return OperationNotSupportedError.
	RevokeEncodedAccountKey(
		address runtime.Address,
		index int,
	) (
		[]byte,
		error,
	)

	// AddAccountKey adds a public key to an existing account.
	//
	// This function returns an error if the specified account does not exist or
	// if the key insertion fails.
	//
	// Note that the script variant will return OperationNotSupportedError.
	AddAccountKey(
		address runtime.Address,
		publicKey *runtime.PublicKey,
		hashAlgo runtime.HashAlgorithm,
		weight int,
	) (
		*runtime.AccountKey,
		error,
	)

	// RevokeAccountKey revokes a public key by index from an existing account,
	// and returns the revoked key.
	//
	// This function returns a nil key with no errors, if a key doesn't exist
	// at the given index.  An error is returned if the specified account does
	// not exist, the provided index is not valid, or if the key revoking
	// fails.
	//
	// Note that the script variant will return OperationNotSupportedError.
	RevokeAccountKey(
		address runtime.Address,
		keyIndex int,
	) (
		*runtime.AccountKey,
		error,
	)
}

type AccountStatus [accountStatusSize]byte

type Accounts interface {
	Exists(address flow.Address) (bool, error)
	Get(address flow.Address) (*flow.Account, error)
	GetPublicKeyCount(address flow.Address) (uint64, error)
	AppendPublicKey(address flow.Address, key flow.AccountPublicKey) error
	GetPublicKey(address flow.Address, keyIndex uint64) (flow.AccountPublicKey, error)
	SetPublicKey(address flow.Address, keyIndex uint64, publicKey flow.AccountPublicKey) ([]byte, error)
	GetContractNames(address flow.Address) ([]string, error)
	GetContract(contractName string, address flow.Address) ([]byte, error)
	ContractExists(contractName string, address flow.Address) (bool, error)
	SetContract(contractName string, address flow.Address, contract []byte) error
	DeleteContract(contractName string, address flow.Address) error
	Create(publicKeys []flow.AccountPublicKey, newAddress flow.Address) error
	GetValue(address flow.Address, key string) (flow.RegisterValue, error)
	CheckAccountNotFrozen(address flow.Address) error
	GetStorageUsed(address flow.Address) (uint64, error)
	SetValue(address flow.Address, key string, value flow.RegisterValue) error
	AllocateStorageIndex(address flow.Address) (atree.StorageIndex, error)
	SetAccountFrozen(address flow.Address, frozen bool) error
}

type AddressGenerator interface {
	Bytes() []byte
	NextAddress() (flow.Address, error)
	CurrentAddress() flow.Address
	AddressCount() uint64
}

type BlockInfo interface {
	// GetCurrentBlockHeight returns the current block height.
	GetCurrentBlockHeight() (uint64, error)

	// GetBlockAtHeight returns the block at the given height.
	GetBlockAtHeight(
		height uint64,
	) (
		runtime.Block,
		bool,
		error,
	)
}

type BlockInfoParams struct {
	Blocks      Blocks
	BlockHeader *flow.Header
}

type Blocks interface {
	// ByHeight returns the block at the given height in the chain ending in `header` (or finalized
	// if `header` is nil). This enables querying un-finalized blocks by height with respect to the
	// chain defined by the block we are executing.
	ByHeightFrom(height uint64, header *flow.Header) (*flow.Header, error)
}

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

type BootstrapAccountCreator interface {
	CreateBootstrapAccount(
		publicKeys []flow.AccountPublicKey,
	) (
		flow.Address,
		error,
	)
}

type CadenceEventEncoder struct{}

type ContractFunctionSpec struct {
	AddressFromChain func(flow.Chain) flow.Address
	LocationName     string
	FunctionName     string
	ArgumentTypes    []sema.Type
}

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

type ContractUpdate struct {
	ContractUpdateKey
	Code []byte
}

type ContractUpdateKey struct {
	Address common.Address
	Name    string
}

type ContractUpdater interface {
	// Cadence's runtime API.  Note that the script variant will return
	// OperationNotSupportedError.
	UpdateAccountContractCode(
		address runtime.Address,
		name string,
		code []byte,
	) error

	// Cadence's runtime API.  Note that the script variant will return
	// OperationNotSupportedError.
	RemoveAccountContractCode(address runtime.Address, name string) error

	Commit() ([]ContractUpdateKey, error)

	Reset()
}

type ContractUpdaterImpl struct {
	ContractUpdaterStubs
	// contains filtered or unexported fields
}

type ContractUpdaterParams struct {
	// Depricated: RestrictedDeploymentEnabled is deprecated use
	// SetIsContractDeploymentRestrictedTransaction instead.
	// Can be removed after all networks are migrated to
	// SetIsContractDeploymentRestrictedTransaction
	RestrictContractDeployment bool
	RestrictContractRemoval    bool
}

type ContractUpdaterStubs interface {
	RestrictedDeploymentEnabled() bool
	RestrictedRemovalEnabled() bool

	GetAuthorizedAccounts(path cadence.Path) []common.Address

	UseContractAuditVoucher(address runtime.Address, code []byte) (bool, error)
}

type CryptoLibrary interface {
	Hash(
		data []byte,
		tag string,
		hashAlgorithm runtime.HashAlgorithm,
	) (
		[]byte,
		error,
	)

	VerifySignature(
		signature []byte,
		tag string,
		signedData []byte,
		publicKey []byte,
		signatureAlgorithm runtime.SignatureAlgorithm,
		hashAlgorithm runtime.HashAlgorithm,
	) (
		bool,
		error,
	)

	ValidatePublicKey(pk *runtime.PublicKey) error

	BLSVerifyPOP(
		pk *runtime.PublicKey,
		sig []byte,
	) (
		bool,
		error,
	)

	BLSAggregateSignatures(sigs [][]byte) ([]byte, error)

	BLSAggregatePublicKeys(
		keys []*runtime.PublicKey,
	) (
		*runtime.PublicKey,
		error,
	)
}

type DerivedDataInvalidator struct {
	ContractUpdateKeys []ContractUpdateKey
	FrozenAccounts     []common.Address

	MeterParamOverridesUpdated bool
}

type DerivedTransactionData interface {
	GetProgram(loc common.AddressLocation) (*derived.Program, *state.State, bool)
	SetProgram(loc common.AddressLocation, prog *derived.Program, state *state.State)
}

type Environment interface {
	runtime.Interface

	// Tracer
	StartChildSpan(
		name trace.SpanName,
		options ...otelTrace.SpanStartOption,
	) tracing.TracerSpan

	Meter

	// Runtime
	BorrowCadenceRuntime() *reusableRuntime.ReusableCadenceRuntime
	ReturnCadenceRuntime(*reusableRuntime.ReusableCadenceRuntime)

	TransactionInfo

	// ProgramLogger
	Logger() *zerolog.Logger
	Logs() []string

	// EventEmitter
	Events() []flow.Event
	ServiceEvents() []flow.Event

	// SystemContracts
	AccountsStorageCapacity(
		addresses []common.Address,
		payer common.Address,
		maxTxFees uint64,
	) (
		cadence.Value,
		error,
	)
	CheckPayerBalanceAndGetMaxTxFees(
		payer flow.Address,
		inclusionEffort uint64,
		executionEffort uint64,
	) (
		cadence.Value,
		error,
	)
	DeductTransactionFees(
		payer flow.Address,
		inclusionEffort uint64,
		executionEffort uint64,
	) (
		cadence.Value,
		error,
	)

	// AccountInfo
	GetAccount(address flow.Address) (*flow.Account, error)

	AccountFreezer

	// FlushPendingUpdates flushes pending updates from the stateful environment
	// modules (i.e., ContractUpdater) to the state transaction, and return
	// corresponding modified sets invalidator.
	FlushPendingUpdates() (
		derived.TransactionInvalidator,
		error,
	)

	// Reset resets all stateful environment modules (e.g., ContractUpdater,
	// EventEmitter, AccountFreezer) to initial state.
	Reset()
}

type EnvironmentParams struct {
	Chain flow.Chain

	// NOTE: The ServiceAccountEnabled option is used by the playground
	// https://github.com/onflow/flow-playground-api/blob/1ad967055f31db8f1ce88e008960e5fc14a9fbd1/compute/computer.go#L76
	ServiceAccountEnabled bool

	RuntimeParams

	ProgramLoggerParams

	EventEmitterParams

	BlockInfoParams
	TransactionInfoParams

	ContractUpdaterParams
}

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

type EventEmitter interface {
	// Cadence's runtime API.  Note that the script variant will return
	// OperationNotSupportedError.
	EmitEvent(event cadence.Event) error

	Events() []flow.Event
	ServiceEvents() []flow.Event

	Reset()
}

type EventEmitterParams struct {
	ServiceEventCollectionEnabled bool
	EventCollectionByteSizeLimit  uint64
	EventEncoder                  EventEncoder
}

type EventEncoder interface {
	Encode(event cadence.Event) ([]byte, error)
}

type Meter interface {
	MeterComputation(common.ComputationKind, uint) error
	ComputationUsed() uint64
	ComputationIntensities() meter.MeteredComputationIntensities

	MeterMemory(usage common.MemoryUsage) error
	MemoryEstimate() uint64

	MeterEmittedEvent(byteSize uint64) error
	TotalEmittedEventBytes() uint64
}

type MeterParamOverridesInvalidator struct {
	DerivedDataInvalidator
}

type MetricsReporter interface {
	RuntimeTransactionParsed(time.Duration)
	RuntimeTransactionChecked(time.Duration)
	RuntimeTransactionInterpreted(time.Duration)
	RuntimeSetNumberOfAccounts(count uint64)
}

type NoAccountCreator struct {
}

type NoAccountFreezer struct{}

type NoAccountKeyUpdater struct{}

type NoContractUpdater struct{}

type NoEventEmitter struct{}

type NoTransactionInfo struct {
}

type NoopBlockFinder struct{}

type NoopMetricsReporter struct{}

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

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

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

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

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

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

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

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

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

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

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

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

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

type ProgramInvalidator struct {
	DerivedDataInvalidator
}

type ProgramLogger struct {
	ProgramLoggerParams
	// contains filtered or unexported fields
}

type ProgramLoggerParams struct {
	zerolog.Logger

	CadenceLoggingEnabled bool

	MetricsReporter
}

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

type Runtime struct {
	RuntimeParams
	// contains filtered or unexported fields
}

type RuntimeParams struct {
	runtime.ReusableCadenceRuntimePool
}

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

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

type TransactionInfo interface {
	TxIndex() uint32
	TxID() flow.Identifier

	TransactionFeesEnabled() bool
	LimitAccountStorage() bool

	SigningAccounts() []runtime.Address

	IsServiceAccountAuthorizer() bool

	// Cadence's runtime API.  Note that the script variant will return
	// OperationNotSupportedError.
	GetSigningAccounts() ([]runtime.Address, error)
}

type TransactionInfoParams struct {
	TxIndex uint32
	TxId    flow.Identifier
	TxBody  *flow.TransactionBody

	TransactionFeesEnabled bool
	LimitAccountStorage    bool
}

type UUIDGenerator interface {
	GenerateUUID() (uint64, error)
}

type UnsafeRandomGenerator interface {
	// UnsafeRandom returns a random uint64, where the process of random number
	// derivation is not cryptographically secure.
	UnsafeRandom() (uint64, error)
}

type ValueStore interface {
	GetValue(owner []byte, key []byte) ([]byte, error)

	SetValue(owner, key, value []byte) error

	ValueExists(owner []byte, key []byte) (bool, error)

	AllocateStorageIndex(owner []byte) (atree.StorageIndex, error)
}