runtime

type AccountKey struct {
	KeyIndex  int
	PublicKey *PublicKey
	HashAlgo  HashAlgorithm
	Weight    int
	IsRevoked bool
}

type Address = common.Address

type ArgumentNotImportableError struct {
	Type interpreter.StaticType
}

type Block struct {
	Height    uint64
	View      uint64
	Hash      BlockHash
	Timestamp int64
}

type BlockHash [BlockHashLength]byte

type CallStackLimitExceededError struct {
	Limit uint64
}

type ConformanceMismatchError struct {
	DeclName string
	ast.Range
}

type Context struct {
	Interface         Interface
	Location          Location
	PredeclaredValues []ValueDeclaration
	CheckerOptions    []sema.Option
	// contains filtered or unexported fields
}

type ContractNotFoundError struct {
	ast.Range
}

type ContractRemovalError struct {
	Name string
	interpreter.LocationRange
}

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

type ContractUpdateError struct {
	ContractName string
	Errors       []error
	Location     common.Location
}

type ContractUpdateValidator struct {
	TypeComparator
	// contains filtered or unexported fields
}

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

type EnumCaseMismatchError struct {
	ExpectedName string
	FoundName    string
	ast.Range
}

type Error struct {
	Err      error
	Location common.Location
	Codes    map[common.Location]string
	Programs map[common.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 ExtraneousFieldError struct {
	DeclName  string
	FieldName string
	ast.Range
}

type FieldMismatchError struct {
	DeclName  string
	FieldName string
	Err       error
	ast.Range
}

type HashAlgorithm = sema.HashAlgorithm

type Identifier = ast.Identifier

type ImportResolver = func(location common.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
	// 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)
	// 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 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 a opentelemetry trace.
	RecordTrace(operation string, location common.Location, duration time.Duration, attrs []attribute.KeyValue)
	// BLSVerifyPOP verifies a proof of possession (PoP) for the receiver public key.
	BLSVerifyPOP(pk *PublicKey, s []byte) (bool, error)
	// BLSAggregateSignatures aggregate multiple BLS signatures into one.
	BLSAggregateSignatures(sigs [][]byte) ([]byte, error)
	// BLSAggregatePublicKeys aggregate multiple BLS public keys into one.
	BLSAggregatePublicKeys(keys []*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 InvalidContractDeploymentError struct {
	Err error
	interpreter.LocationRange
}

type InvalidContractDeploymentOriginError struct {
	interpreter.LocationRange
}

type InvalidDeclarationKindChangeError struct {
	Name    string
	OldKind common.DeclarationKind
	NewKind common.DeclarationKind
	ast.Range
}

type InvalidEntryPointArgumentError struct {
	Index int
	Err   error
}

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 common.Location, duration time.Duration)
	ProgramChecked(location common.Location, duration time.Duration)
	ProgramInterpreted(location common.Location, duration time.Duration)
}

type MissingDeclarationError struct {
	Name string
	Kind common.DeclarationKind
	ast.Range
}

type MissingEnumCasesError struct {
	DeclName string
	Expected int
	Found    int
	ast.Range
}

type Option func(Runtime)

type ParsingCheckingError struct {
	Err      error
	Location common.Location
}

type PublicKey struct {
	PublicKey []byte
	SignAlgo  SignatureAlgorithm
}

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)

	// SetCoverageReport activates reporting coverage in the given report.
	// Passing nil disables coverage reporting (default).
	//
	SetCoverageReport(coverageReport *CoverageReport)

	// SetContractUpdateValidationEnabled configures if contract update validation is enabled.
	//
	SetContractUpdateValidationEnabled(enabled bool)

	// SetAtreeValidationEnabled configures if atree validation is enabled.
	SetAtreeValidationEnabled(enabled bool)

	// SetTracingEnabled configures if tracing is enabled.
	SetTracingEnabled(enabled bool)

	// SetInvalidatedResourceValidationEnabled configures
	// if invalidated resource validation is enabled.
	SetInvalidatedResourceValidationEnabled(enabled bool)

	// SetResourceOwnerChangeHandlerEnabled configures if the resource owner change callback is enabled.
	SetResourceOwnerChangeHandlerEnabled(enabled bool)

	// 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)

	// SetDebugger configures interpreters with the given debugger.
	//
	SetDebugger(debugger *interpreter.Debugger)

	// 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)
}

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 TypeComparator struct {
	RootDeclIdentifier *Identifier
}

type TypeMismatchError struct {
	ExpectedType ast.Type
	FoundType    ast.Type
	ast.Range
}

type ValueDeclaration struct {
	Name           string
	Type           sema.Type
	DocString      string
	Kind           common.DeclarationKind
	IsConstant     bool
	ArgumentLabels []string
	Available      func(common.Location) bool
	Value          interpreter.Value
}