runtime

type Address = common.Address

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

type BlockHash [BlockHashLength]byte

type Cache map[StorageKey]CacheEntry

type CacheEntry struct {
	// true indicates that the value definitely must be written, independent of the value.
	// false indicates that the value may has to be written if the value is modified.
	MustWrite bool
	Value     interpreter.Value
}

type ComputationLimitExceededError struct {
	Limit uint64
}

type ConformanceCountMismatchError struct {
	ast.Range
	// contains filtered or unexported fields
}

type ConformanceMismatchError struct {
	ast.Range
	// contains filtered or unexported fields
}

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

type ContractNotFoundError struct {
	ast.Range
}

type ContractUpdate struct {
	Contract         interpreter.Value
	ExportedContract cadence.Value
}

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

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

type ContractUpdates map[StorageKey]ContractUpdate

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

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

type ExtraneousFieldError struct {
	ast.Range
	// contains filtered or unexported fields
}

type FieldMismatchError struct {
	ast.Range
	// contains filtered or unexported fields
}

type HighLevelStorage interface {
	Interface

	// HighLevelStorageEnabled should return true
	// if the functions of HighLevelStorage should be called,
	// e.g. SetCadenceValue
	HighLevelStorageEnabled() bool

	// SetCadenceValue sets a value for the given key in the storage, owned by the given account.
	SetCadenceValue(owner Address, key string, value cadence.Value) (err error)
}

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 attempts gets the program for the given location, if available.
	//
	// NOTE: 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 (!) after SetProgram was called.
	//
	// This is not a caching function!
	//
	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)
	// CreateAccount creates a new account.
	CreateAccount(payer Address) (address Address, err error)
	// AddAccountKey appends a key to an account.
	AddAccountKey(address Address, publicKey []byte) error
	// RemoveAccountKey removes a key from an account by index.
	RemoveAccountKey(address Address, index int) (publicKey []byte, err 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
	// ValueExists returns true if the given key exists in the storage, owned by the given account.
	ValueExists(owner, key []byte) (exists bool, err error)
	// GenerateUUID is called to generate a UUID.
	GenerateUUID() (uint64, error)
	// GetComputationLimit returns the computation limit. A value <= 0 means there is no limit
	GetComputationLimit() uint64
	// SetComputationUsed reports the amount of computation used.
	SetComputationUsed(used uint64) 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 string,
		hashAlgorithm string,
	) (bool, error)
	// Hash returns the digest of hashing the given data with using the given hash algorithm
	Hash(data []byte, hashAlgorithm string) ([]byte, 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
}

type InvalidContractDeploymentError struct {
	Err error
	interpreter.LocationRange
}

type InvalidContractDeploymentOriginError struct {
	interpreter.LocationRange
}

type InvalidDeclarationKindChangeError struct {
	ast.Range
	// contains filtered or unexported fields
}

type InvalidEntryPointArgumentError struct {
	Index int
	Err   error
}

type InvalidEntryPointParameterCountError struct {
	Expected int
	Actual   int
}

type InvalidNonStorableTypeUsageError struct {
	ast.Range
	// contains filtered or unexported fields
}

type InvalidScriptReturnTypeError struct {
	Type sema.Type
}

type InvalidTransactionAuthorizerCountError struct {
	Expected int
	Actual   int
}

type InvalidTransactionCountError struct {
	Count int
}

type InvalidTypeAssignmentError struct {
	Value interpreter.Value
	Type  sema.Type
	Err   error
}

type Location = common.Location

type LocationCoverage struct {
	LineHits map[int]int `json:"line_hits"`
}

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

type Option func(Runtime)

type ParsingCheckingError struct {
	Err      error
	Location common.Location
}

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

type REPLSuggestion struct {
	Name, Description string
}

type ResolvedLocation = sema.ResolvedLocation

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

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

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

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

type ScriptParameterTypeNotStorableError struct {
	Type sema.Type
}

type StorageKey struct {
	Address common.Address
	Key     string
}

type TypeMismatchError struct {
	ast.Range
	// contains filtered or unexported fields
}

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