runtime

type AccountKey = stdlib.AccountKey

type Address = common.Address

type ArgumentDecoder interface {
	stdlib.StandardLibraryHandler

	// DecodeArgument decodes a transaction/script argument against the given type.
	DecodeArgument(argument []byte, argumentType cadence.Type) (cadence.Value, error)
}

type ArgumentNotImportableError struct {
	Type interpreter.StaticType
}

type Block = stdlib.Block

type CallStackLimitExceededError struct {
	Limit uint64
}

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

type Config struct {
	Debugger *interpreter.Debugger
	// StackDepthLimit specifies the maximum depth for call stacks
	StackDepthLimit uint64
	// AtreeValidationEnabled configures if atree validation is enabled
	AtreeValidationEnabled bool
	// TracingEnabled configures if tracing is enabled
	TracingEnabled bool
	// ResourceOwnerChangeCallbackEnabled configures if the resource owner change callback is enabled
	ResourceOwnerChangeHandlerEnabled bool
	// CoverageReport enables and collects coverage reporting metrics
	CoverageReport *CoverageReport
	// AttachmentsEnabled specifies if attachments are enabled
	AttachmentsEnabled bool
	// LegacyContractUpgradeEnabled enabled specifies whether to use the old parser when parsing an old contract
	LegacyContractUpgradeEnabled bool
	// ContractUpdateTypeRemovalEnabled specifies if type removal is enabled in contract updates
	ContractUpdateTypeRemovalEnabled bool
}

type Context struct {
	Interface      Interface
	Location       Location
	Environment    Environment
	CoverageReport *CoverageReport
}

type ContractUpdate struct {
	ContractValue *interpreter.CompositeValue
	Key           interpreter.StorageKey
}

type CoverageReport struct {
	// Contains a *LocationCoverage per location.
	Coverage map[common.Location]*LocationCoverage
	// Contains locations whose programs are already inspected.
	Locations map[common.Location]struct{}
	// Contains locations excluded from coverage collection.
	ExcludedLocations map[common.Location]struct{}
	// contains filtered or unexported fields
}

type CoverageReportSummary struct {
	Locations  int    `json:"locations"`
	Statements int    `json:"statements"`
	Hits       int    `json:"hits"`
	Misses     int    `json:"misses"`
	Coverage   string `json:"coverage"`
}

type EmptyRuntimeInterface struct{}

type Environment interface {
	ArgumentDecoder

	SetCompositeValueFunctionsHandler(
		typeID common.TypeID,
		handler stdlib.CompositeValueFunctionsHandler,
	)
	DeclareValue(
		valueDeclaration stdlib.StandardLibraryValue,
		location common.Location,
	)
	DeclareType(
		typeDeclaration stdlib.StandardLibraryType,
		location common.Location,
	)
	Configure(
		runtimeInterface Interface,
		codesAndPrograms CodesAndPrograms,
		storage *Storage,
		coverageReport *CoverageReport,
	)
	ParseAndCheckProgram(
		code []byte,
		location common.Location,
		getAndSetProgram bool,
	) (
		*interpreter.Program,
		error,
	)
	Interpret(
		location common.Location,
		program *interpreter.Program,
		f InterpretFunc,
	) (
		interpreter.Value,
		*interpreter.Interpreter,
		error,
	)
	CommitStorage(inter *interpreter.Interpreter) error
	NewAccountValue(inter *interpreter.Interpreter, address interpreter.AddressValue) interpreter.Value
}

type Error struct {
	Err      error
	Location Location
	Codes    map[Location][]byte
	Programs map[Location]*ast.Program
}

type Executor interface {
	// Preprocess prepares the transaction/script for execution.
	//
	// This function returns an error if the program has errors (e.g., syntax
	// errors, type errors).
	//
	// This method may be called multiple times.  Only the first call will
	// trigger meaningful work; subsequent calls will return the cached return
	// value from the original call (i.e., an Executor implementation must
	// guard this method with sync.Once).
	Preprocess() error

	// Execute executes the transaction/script.
	//
	// This function returns an error if Preprocess failed or if the execution
	// fails.
	//
	// This method may be called multiple times.  Only the first call will
	// trigger meaningful work; subsequent calls will return the cached return
	// value from the original call (i.e., an Executor implementation must
	// guard this method with sync.Once).
	//
	// Note: Execute will invoke Preprocess to ensure Preprocess was called at
	// least once.
	Execute() error

	// Result returns the transaction/scipt's execution result.
	//
	// This function returns an error if Preproces or Execute fails.  The
	// cadence.Value is always nil for transaction.
	//
	// This method may be called multiple times.  Only the first call will
	// trigger meaningful work; subsequent calls will return the cached return
	// value from the original call (i.e., an Executor implementation must
	// guard this method with sync.Once).
	//
	// Note: Result will invoke Execute to ensure Execute was called at least
	// once.
	Result() (cadence.Value, error)
}

type HashAlgorithm = sema.HashAlgorithm

type Identifier = ast.Identifier

type ImportResolver = func(location Location) (program *ast.Program, e error)

type Interface interface {
	MeterInterface

	// ResolveLocation resolves an import location.
	ResolveLocation(identifiers []Identifier, location Location) ([]ResolvedLocation, error)
	// GetCode returns the code at a given location
	GetCode(location Location) ([]byte, error)
	// GetOrLoadProgram returns the program for the given location, if available,
	// or sets the program by calling the given load function.
	//
	// For implementations:
	// - Perform a lookup for the location and return the program if it exists.
	// - If the program does not exist, call load, and store the result,
	//   *EVEN IF loading failed* (program is nil / error is non-nil)!
	// - During execution of a high-level program (e.g. script, transaction, etc.),
	//   this function MUST always return the *same* program,
	//   i.e. it may NOT return a different program,
	//   an elaboration in the program that is not annotating the AST in the program;
	//   or a program/elaboration and then nothing in a subsequent call.
	// - This function MUST also return exactly what was previously returned from load,
	//   *EVEN IF loading failed* (program is nil / error is non-nil),
	//   and it may NOT return something different
	// - Do NOT implement this as a cache!
	GetOrLoadProgram(
		location Location,
		load func() (*interpreter.Program, error),
	) (*interpreter.Program, error)
	// SetInterpreterSharedState sets the shared state of all interpreters.
	SetInterpreterSharedState(state *interpreter.SharedState)
	// GetInterpreterSharedState gets the shared state of all interpreters.
	// May return nil if none is available or use is not applicable.
	GetInterpreterSharedState() *interpreter.SharedState
	// GetValue gets a value for the given key in the storage, owned by the given account.
	GetValue(owner, key []byte) (value []byte, err error)
	// SetValue sets a value for the given key in the storage, owned by the given account.
	SetValue(owner, key, value []byte) (err error)
	// ValueExists returns true if the given key exists in the storage, owned by the given account.
	ValueExists(owner, key []byte) (exists bool, err error)
	// AllocateSlabIndex allocates a new slab index under the given account.
	AllocateSlabIndex(owner []byte) (atree.SlabIndex, error)
	// CreateAccount creates a new account.
	CreateAccount(payer Address) (address Address, err error)
	// AddAccountKey appends a key to an account.
	AddAccountKey(address Address, publicKey *PublicKey, hashAlgo HashAlgorithm, weight int) (*AccountKey, error)
	// GetAccountKey retrieves a key from an account by index.
	GetAccountKey(address Address, index uint32) (*AccountKey, error)
	AccountKeysCount(address Address) (uint32, error)
	// RevokeAccountKey removes a key from an account by index.
	RevokeAccountKey(address Address, index uint32) (*AccountKey, error)
	// UpdateAccountContractCode updates the code associated with an account contract.
	UpdateAccountContractCode(location common.AddressLocation, code []byte) (err error)
	// GetAccountContractCode returns the code associated with an account contract.
	GetAccountContractCode(location common.AddressLocation) (code []byte, err error)
	// RemoveAccountContractCode removes the code associated with an account contract.
	RemoveAccountContractCode(location common.AddressLocation) (err error)
	// GetSigningAccounts returns the signing accounts.
	GetSigningAccounts() ([]Address, error)
	// ProgramLog logs program logs.
	ProgramLog(string) error
	// EmitEvent is called when an event is emitted by the runtime.
	EmitEvent(cadence.Event) error
	// GenerateUUID is called to generate a UUID.
	GenerateUUID() (uint64, error)
	// DecodeArgument decodes a transaction/script argument against the given type.
	DecodeArgument(argument []byte, argumentType cadence.Type) (cadence.Value, error)
	// GetCurrentBlockHeight returns the current block height.
	GetCurrentBlockHeight() (uint64, error)
	// GetBlockAtHeight returns the block at the given height.
	GetBlockAtHeight(height uint64) (block Block, exists bool, err error)
	// ReadRandom reads pseudo-random bytes into the input slice, using distributed randomness.
	ReadRandom([]byte) error
	// VerifySignature returns true if the given signature was produced by signing the given tag + data
	// using the given public key, signature algorithm, and hash algorithm.
	VerifySignature(
		signature []byte,
		tag string,
		signedData []byte,
		publicKey []byte,
		signatureAlgorithm SignatureAlgorithm,
		hashAlgorithm HashAlgorithm,
	) (bool, error)
	// Hash returns the digest of hashing the given data with using the given hash algorithm
	Hash(data []byte, tag string, hashAlgorithm HashAlgorithm) ([]byte, error)
	// GetAccountBalance gets accounts default flow token balance.
	GetAccountBalance(address common.Address) (value uint64, err error)
	// GetAccountAvailableBalance gets accounts default flow token balance - balance that is reserved for storage.
	GetAccountAvailableBalance(address common.Address) (value uint64, err error)
	// GetStorageUsed gets storage used in bytes by the address at the moment of the function call.
	GetStorageUsed(address Address) (value uint64, err error)
	// GetStorageCapacity gets storage capacity in bytes on the address.
	GetStorageCapacity(address Address) (value uint64, err error)
	// ImplementationDebugLog logs implementation log statements on a debug-level
	ImplementationDebugLog(message string) error
	// ValidatePublicKey verifies the validity of a public key.
	ValidatePublicKey(key *PublicKey) error
	// GetAccountContractNames returns the names of all contracts deployed in an account.
	GetAccountContractNames(address Address) ([]string, error)
	// RecordTrace records an opentelemetry trace.
	RecordTrace(operation string, location Location, duration time.Duration, attrs []attribute.KeyValue)
	// BLSVerifyPOP verifies a proof of possession (PoP) for the receiver public key.
	BLSVerifyPOP(publicKey *PublicKey, signature []byte) (bool, error)
	// BLSAggregateSignatures aggregate multiple BLS signatures into one.
	BLSAggregateSignatures(signatures [][]byte) ([]byte, error)
	// BLSAggregatePublicKeys aggregate multiple BLS public keys into one.
	BLSAggregatePublicKeys(publicKeys []*PublicKey) (*PublicKey, error)
	// ResourceOwnerChanged gets called when a resource's owner changed (if enabled)
	ResourceOwnerChanged(
		interpreter *interpreter.Interpreter,
		resource *interpreter.CompositeValue,
		oldOwner common.Address,
		newOwner common.Address,
	)
	// GenerateAccountID generates a new, *non-zero*, unique ID for the given account.
	GenerateAccountID(address common.Address) (uint64, error)
	RecoverProgram(program *ast.Program, location common.Location) ([]byte, error)
	ValidateAccountCapabilitiesGet(
		inter *interpreter.Interpreter,
		locationRange interpreter.LocationRange,
		address interpreter.AddressValue,
		path interpreter.PathValue,
		wantedBorrowType *sema.ReferenceType,
		capabilityBorrowType *sema.ReferenceType,
	) (bool, error)
	ValidateAccountCapabilitiesPublish(
		inter *interpreter.Interpreter,
		locationRange interpreter.LocationRange,
		address interpreter.AddressValue,
		path interpreter.PathValue,
		capabilityBorrowType *interpreter.ReferenceStaticType,
	) (bool, error)

	MinimumRequiredVersion() (string, error)
}

type InterpretFunc func(inter *interpreter.Interpreter) (interpreter.Value, error)

type InvalidEntryPointArgumentError struct {
	Err   error
	Index int
}

type InvalidEntryPointParameterCountError struct {
	Expected int
	Actual   int
}

type InvalidScriptReturnTypeError struct {
	Type sema.Type
}

type InvalidTransactionAuthorizerCountError struct {
	Expected int
	Actual   int
}

type InvalidTransactionCountError struct {
	Count int
}

type InvalidValueTypeError struct {
	ExpectedType sema.Type
}

type Location = common.Location

type LocationCoverage struct {
	// Contains hit count for each line on a given location.
	// A hit count of 0 means the line was not covered.
	LineHits map[int]int
	// Total number of statements on a given location.
	Statements int
}

type LocationFilter func(location Location) bool

type MalformedValueError struct {
	ExpectedType sema.Type
}

type MeterInterface interface {
	// MeterMemory gets called when new memory is allocated or used by the interpreter
	MeterMemory(usage common.MemoryUsage) error
	// MeterComputation is a callback method for metering computation, it returns error
	// when computation passes the limit (set by the environment)
	MeterComputation(operationType common.ComputationKind, intensity uint) error
	// ComputationUsed returns the total computation used in the current runtime.
	ComputationUsed() (uint64, error)
	// MemoryUsed returns the total memory (estimate) used in the current runtime.
	MemoryUsed() (uint64, error)
	// InteractionUsed returns the total storage interaction used in the current runtime.
	InteractionUsed() (uint64, error)
}

type Metrics interface {
	ProgramParsed(location Location, duration time.Duration)
	ProgramChecked(location Location, duration time.Duration)
	ProgramInterpreted(location Location, duration time.Duration)
}

type ParsingCheckingError struct {
	Err      error
	Location Location
}

type PublicKey = stdlib.PublicKey

type REPL struct {
	OnError          func(err error, location Location, codes map[Location][]byte)
	OnExpressionType func(sema.Type)
	OnResult         func(interpreter.Value)
	// contains filtered or unexported fields
}

type REPLSuggestion struct {
	Name, Description string
}

type ResolvedLocation = sema.ResolvedLocation

type Runtime interface {
	// Config returns the runtime.Config this Runtime was instantiated with.
	Config() Config

	// NewScriptExecutor returns an executor which executes the given script.
	NewScriptExecutor(Script, Context) Executor

	// ExecuteScript executes the given script.
	//
	// This function returns an error if the program has errors (e.g syntax errors, type errors),
	// or if the execution fails.
	ExecuteScript(Script, Context) (cadence.Value, error)

	// NewTransactionExecutor returns an executor which executes the given
	// transaction.
	NewTransactionExecutor(Script, Context) Executor

	// ExecuteTransaction executes the given transaction.
	//
	// This function returns an error if the program has errors (e.g syntax errors, type errors),
	// or if the execution fails.
	ExecuteTransaction(Script, Context) error

	// NewContractFunctionExecutor returns an executor which invokes a contract
	// function with the given arguments.
	NewContractFunctionExecutor(
		contractLocation common.AddressLocation,
		functionName string,
		arguments []cadence.Value,
		argumentTypes []sema.Type,
		context Context,
	) Executor

	// InvokeContractFunction invokes a contract function with the given arguments.
	//
	// This function returns an error if the execution fails.
	// If the contract function accepts an &Account as a parameter,
	// the corresponding argument can be an interpreter.Address.
	// Returns a cadence.Value
	InvokeContractFunction(
		contractLocation common.AddressLocation,
		functionName string,
		arguments []cadence.Value,
		argumentTypes []sema.Type,
		context Context,
	) (cadence.Value, error)

	// ParseAndCheckProgram parses and checks the given code without executing the program.
	//
	// This function returns an error if the program contains any syntax or semantic errors.
	ParseAndCheckProgram(source []byte, context Context) (*interpreter.Program, error)

	// ReadStored reads the value stored at the given path
	//
	ReadStored(address common.Address, path cadence.Path, context Context) (cadence.Value, error)

	// Storage returns the storage system and an interpreter which can be used for
	// accessing values in storage.
	//
	// NOTE: only use the interpreter for storage operations,
	// do *NOT* use the interpreter for any other purposes,
	// such as executing a program.
	//
	Storage(context Context) (*Storage, *interpreter.Interpreter, error)

	SetDebugger(debugger *interpreter.Debugger)
}

type Script struct {
	Source    []byte
	Arguments [][]byte
}

type ScriptParameterTypeNotImportableError struct {
	Type sema.Type
}

type ScriptParameterTypeNotStorableError struct {
	Type sema.Type
}

type SignatureAlgorithm = sema.SignatureAlgorithm

type Storage struct {
	*atree.PersistentSlabStorage
	NewStorageMaps *orderedmap.OrderedMap[interpreter.StorageKey, atree.SlabIndex]

	Ledger atree.Ledger
	// contains filtered or unexported fields
}

type UnreferencedRootSlabsError struct {
	UnreferencedRootSlabIDs []atree.SlabID
}

type ValueNotExportableError struct {
	Type interpreter.StaticType
}