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 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
	// CoverageReportingEnabled configures if coverage reporting is enabled
	CoverageReportingEnabled bool
	// AccountLinkingEnabled specifies if account linking is enabled
	AccountLinkingEnabled bool
}

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

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

type CoverageReport struct {
	Coverage map[common.Location]*LocationCoverage `json:"-"`
}

type Environment interface {
	ArgumentDecoder

	Declare(valueDeclaration stdlib.StandardLibraryValue)
	Configure(
		runtimeInterface Interface,
		codesAndPrograms codesAndPrograms,
		storage *Storage,
		coverageReport *CoverageReport,
	)
	ParseAndCheckProgram(
		code []byte,
		location common.Location,
		storeProgram bool,
	) (
		*interpreter.Program,
		error,
	)
	Interpret(
		location common.Location,
		program *interpreter.Program,
		f InterpretFunc,
	) (
		interpreter.Value,
		*interpreter.Interpreter,
		error,
	)
	CommitStorage(inter *interpreter.Interpreter) error
	NewAuthAccountValue(address interpreter.AddressValue) interpreter.Value
	NewPublicAccountValue(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 {
	// 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)
	// GetProgram returns the program for the given location, if available.
	//
	// NOTE:
	//
	// For implementations:
	// - During execution, 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 what was set using SetProgram,
	//   it may NOT return something different or nothing/nil (!) after SetProgram was called.
	//   Do NOT implement this as a cache!
	//
	// For uses:
	// - ONLY call this function when a program must be parsed and checked,
	//   as an optimization to reuse the result of a potential previous parse and check.
	// - If GetProgram returns nil, Cadence MUST call SetProgram:
	//   There's an informal contract between Cadence and the implementer:
	//   Cadence calls GetProgram to potentially avoid having to parse and check a program.
	//   If the implementer returns nil from GetProgram,
	//   it expects that Cadence sets the resulting parsed and checked program with SetProgram.
	// - The behaviour after GetProgram returning nil or a program must be always deterministic:
	//   As SetProgram is called when GetProgram is nil, then SetProgram MUST also be called when
	//   GetProgram returns a program. This prevents nondeterministic behaviour
	//
	// Deprecated: This function should be refactored to ensure that SetProgram is always called
	//
	GetProgram(Location) (*interpreter.Program, error)
	// SetProgram sets the program for the given location.
	SetProgram(Location, *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)
	// AllocateStorageIndex allocates a new storage index under the given account.
	AllocateStorageIndex(owner []byte) (atree.StorageIndex, error)
	// CreateAccount creates a new account.
	CreateAccount(payer Address) (address Address, err error)
	// AddEncodedAccountKey appends an encoded key to an account.
	AddEncodedAccountKey(address Address, publicKey []byte) error
	// RevokeEncodedAccountKey removes a key from an account by index, add returns the encoded key.
	RevokeEncodedAccountKey(address Address, index int) (publicKey []byte, 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 int) (*AccountKey, error)
	AccountKeysCount(address Address) (uint64, error)
	// RevokeAccountKey removes a key from an account by index.
	RevokeAccountKey(address Address, index int) (*AccountKey, error)
	// UpdateAccountContractCode updates the code associated with an account contract.
	UpdateAccountContractCode(address Address, name string, code []byte) (err error)
	// GetAccountContractCode returns the code associated with an account contract.
	GetAccountContractCode(address Address, name string) (code []byte, err error)
	// RemoveAccountContractCode removes the code associated with an account contract.
	RemoveAccountContractCode(address Address, name string) (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)
	// 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
	// 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)
	// UnsafeRandom returns a random uint64, where the process of random number derivation is not cryptographically
	// secure.
	UnsafeRandom() (uint64, 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,
	)
	// MeterMemory gets called when new memory is allocated or used by the interpreter
	MeterMemory(usage common.MemoryUsage) 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 {
	LineHits map[int]int `json:"line_hits"`
}

type MalformedValueError struct {
	ExpectedType sema.Type
}

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 {
	// contains filtered or unexported fields
}

type REPLSuggestion struct {
	Name, Description string
}

type ResolvedLocation = sema.ResolvedLocation

type Runtime interface {
	// 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 AuthAccount 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)

	// ReadLinked dereferences the path and returns the value stored at the target
	//
	ReadLinked(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

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

type ValueNotExportableError struct {
	Type interpreter.StaticType
}