stdlib

type Account struct {
	PublicKey *PublicKey
	Address   common.Address
}

type AccountContractAdditionAndNamesHandler interface {
	AccountContractAdditionHandler
	AccountContractNamesProvider
}

type AccountContractAdditionHandler interface {
	EventEmitter
	AccountContractProvider
	ContractAdditionTracker

	ParseAndCheckProgram(
		code []byte,
		location common.Location,
		getAndSetProgram bool,
	) (*interpreter.Program, error)
	// UpdateAccountContractCode updates the code associated with an account contract.
	UpdateAccountContractCode(location common.AddressLocation, code []byte) error
	RecordContractUpdate(
		location common.AddressLocation,
		value *interpreter.CompositeValue,
	)
	ContractUpdateRecorded(location common.AddressLocation) bool
	LoadContractValue(
		location common.AddressLocation,
		program *interpreter.Program,
		name string,
		invocation DeployedContractConstructorInvocation,
	) (
		*interpreter.CompositeValue,
		error,
	)
	TemporarilyRecordCode(location common.AddressLocation, code []byte)
}

type AccountContractNamesProvider interface {
	// GetAccountContractNames returns the names of all contracts deployed in an account.
	GetAccountContractNames(address common.Address) ([]string, error)
}

type AccountContractProvider interface {
	// GetAccountContractCode returns the code associated with an account contract.
	GetAccountContractCode(location common.AddressLocation) ([]byte, error)
}

type AccountContractRemovalHandler interface {
	EventEmitter
	AccountContractProvider
	RemoveAccountContractCode(location common.AddressLocation) error
	RecordContractRemoval(location common.AddressLocation)
}

type AccountContractsHandler interface {
	AccountContractProvider
	AccountContractAdditionAndNamesHandler
	AccountContractRemovalHandler
}

type AccountCreator interface {
	StorageCommitter
	EventEmitter
	AccountHandler
	// CreateAccount creates a new account.
	CreateAccount(payer common.Address) (address common.Address, err error)
}

type AccountHandler interface {
	AccountIDGenerator
	BalanceProvider
	AvailableBalanceProvider
	AccountStorageHandler
	AccountKeysHandler
	AccountContractsHandler
}

type AccountIDGenerator interface {
	// GenerateAccountID generates a new, *non-zero*, unique ID for the given account.
	GenerateAccountID(address common.Address) (uint64, error)
}

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

type AccountKeyAdditionHandler interface {
	EventEmitter
	PublicKeyValidator
	PublicKeySignatureVerifier
	BLSPoPVerifier
	Hasher
	// AddAccountKey appends a key to an account.
	AddAccountKey(address common.Address, key *PublicKey, algo sema.HashAlgorithm, weight int) (*AccountKey, error)
}

type AccountKeyProvider interface {
	PublicKeyValidator
	PublicKeySignatureVerifier
	BLSPoPVerifier
	Hasher
	// GetAccountKey retrieves a key from an account by index.
	GetAccountKey(address common.Address, index uint32) (*AccountKey, error)
	AccountKeysCount(address common.Address) (uint32, error)
}

type AccountKeyRevocationHandler interface {
	EventEmitter
	Hasher
	PublicKeyValidator
	PublicKeySignatureVerifier
	BLSPoPVerifier
	// RevokeAccountKey removes a key from an account by index.
	RevokeAccountKey(address common.Address, index uint32) (*AccountKey, error)
}

type AccountKeysHandler interface {
	AccountKeyProvider
	AccountKeyAdditionHandler
	AccountKeyRevocationHandler
}

type AccountStorageHandler interface {
	StorageUsedProvider
	StorageCapacityProvider
}

type AssertionError struct {
	interpreter.LocationRange
	Message string
}

type AuthorizationMismatchError struct {
	ExpectedAuthorization sema.Access
	FoundAuthorization    sema.Access
	ast.Range
}

type AvailableBalanceProvider interface {
	// GetAccountAvailableBalance gets accounts default flow token balance - balance that is reserved for storage.
	GetAccountAvailableBalance(address common.Address) (uint64, error)
}

type BLSContractHandler interface {
	PublicKeyValidator
	PublicKeySignatureVerifier
	BLSPoPVerifier
	BLSPublicKeyAggregator
	BLSSignatureAggregator
}

type BLSPoPVerifier interface {
	// BLSVerifyPOP verifies a proof of possession (PoP) for the receiver public key.
	BLSVerifyPOP(publicKey *PublicKey, signature []byte) (bool, error)
}

type BLSPublicKeyAggregator interface {
	PublicKeySignatureVerifier
	BLSPoPVerifier
	// BLSAggregatePublicKeys aggregate multiple BLS public keys into one.
	BLSAggregatePublicKeys(publicKeys []*PublicKey) (*PublicKey, error)
}

type BLSSignatureAggregator interface {
	// BLSAggregateSignatures aggregate multiple BLS signatures into one.
	BLSAggregateSignatures(signatures [][]byte) ([]byte, error)
}

type BalanceProvider interface {
	// GetAccountBalance gets accounts default flow token balance.
	GetAccountBalance(address common.Address) (uint64, error)
}

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

type BlockAtHeightProvider interface {
	// GetBlockAtHeight returns the block at the given height.
	GetBlockAtHeight(height uint64) (block Block, exists bool, err error)
}

type BlockHash [BlockHashLength]byte

type Blockchain interface {
	RunScript(
		context TestFrameworkScriptExecutionContext,
		code string, arguments []interpreter.Value,
	) *ScriptResult

	CreateAccount() (*Account, error)

	GetAccount(interpreter.AddressValue) (*Account, error)

	AddTransaction(
		context TestFrameworkAddTransactionContext,
		code string,
		authorizers []common.Address,
		signers []*Account,
		arguments []interpreter.Value,
	) error

	ExecuteNextTransaction() *TransactionResult

	CommitBlock() error

	DeployContract(
		context TestFrameworkContractDeploymentContext,
		name string,
		path string,
		arguments []interpreter.Value,
	) error

	Logs() []string

	ServiceAccount() (*Account, error)

	Events(
		context TestFrameworkEventsContext,
		eventType interpreter.StaticType,
	) interpreter.Value

	Reset(uint64)

	MoveTime(int64)

	CreateSnapshot(string) error

	LoadSnapshot(string) error
}

type CadenceV042ToV1ContractUpdateValidator struct {
	*TypeComparator
	// contains filtered or unexported fields
}

type CapabilityControllerHandler interface {
	EventEmitter
}

type CapabilityControllerIssueHandler interface {
	EventEmitter
	AccountIDGenerator
}

type CapabilityControllersMutatedDuringIterationError struct {
	interpreter.LocationRange
}

type CompositeValueFunctionsHandler func(
	inter *interpreter.Interpreter,
	compositeValue *interpreter.CompositeValue,
) *interpreter.FunctionOrderedMap

type CompositeValueFunctionsHandlers map[common.TypeID]CompositeValueFunctionsHandler

type ConformanceMismatchError struct {
	DeclName           string
	MissingConformance string
	ast.Range
}

type ContractAdditionTracker interface {
	// StartContractAddition starts adding a contract.
	StartContractAddition(location common.AddressLocation)

	// EndContractAddition ends adding the contract
	EndContractAddition(location common.AddressLocation)

	// IsContractBeingAdded checks whether a contract is being added in the current execution.
	IsContractBeingAdded(location common.AddressLocation) bool
}

type ContractNotFoundError struct {
	ast.Range
}

type ContractRemovalError struct {
	interpreter.LocationRange
	Name string
}

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

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

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

type DeployedContractConstructorInvocation struct {
	ContractType         *sema.CompositeType
	ConstructorArguments []interpreter.Value
	Address              common.Address
}

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

type EventEmitter interface {
	EmitEvent(
		context interpreter.ValueExportContext,
		eventType *sema.CompositeType,
		eventFields []interpreter.Value,
	)
}

type ExtraneousFieldError struct {
	DeclName  string
	FieldName string
	ast.Range
}

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

type FlowLocation struct{}

type FunctionLogger func(message string) error

type Hasher interface {
	// Hash returns the digest of hashing the given data with using the given hash algorithm
	Hash(data []byte, tag string, algorithm sema.HashAlgorithm) ([]byte, error)
}

type InvalidContractArgumentError struct {
	ExpectedType sema.Type
	ActualType   sema.Type
	Index        int
}

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 InvalidTypeRemovalPragmaError struct {
	Expression ast.Expression
	ast.Range
}

type Logger interface {
	// ProgramLog logs program logs.
	ProgramLog(message string) error
}

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

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

type NameMismatchError struct {
	OldName string
	NewName string
	ast.Range
}

type OldProgramError struct {
	Err      error
	Location common.Location
}

type PanicError struct {
	interpreter.LocationRange
	Message string
}

type PublicKey struct {
	PublicKey []byte
	SignAlgo  sema.SignatureAlgorithm
}

type PublicKeyFunctionsHandler interface {
	PublicKeySignatureVerifier
	BLSPoPVerifier
}

type PublicKeySignatureVerifier interface {
	// 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 sema.SignatureAlgorithm,
		hashAlgorithm sema.HashAlgorithm,
	) (bool, error)
}

type PublicKeyValidator interface {
	// ValidatePublicKey verifies the validity of a public key.
	ValidatePublicKey(key *PublicKey) error
}

type RLPDecodeListError struct {
	interpreter.LocationRange
	Msg string
}

type RLPDecodeStringError struct {
	interpreter.LocationRange
	Msg string
}

type RandomGenerator interface {
	// ReadRandom reads pseudo-random bytes into the input slice, using distributed randomness.
	// The number of bytes read is equal to the length of input slice.
	ReadRandom([]byte) error
}

type ScriptResult struct {
	Value interpreter.Value
	Error error
}

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

type StandardLibraryHandler interface {
	Logger
	RandomGenerator
	BlockAtHeightProvider
	CurrentBlockProvider
	AccountCreator
	PublicKeyValidator
	PublicKeySignatureVerifier
	BLSPoPVerifier
	BLSPublicKeyAggregator
	BLSSignatureAggregator
	Hasher
}

type StandardLibraryType struct {
	Type sema.Type
	Name string
	Kind common.DeclarationKind
}

type StandardLibraryValue struct {
	Type           sema.Type
	Value          interpreter.Value
	Position       *ast.Position
	Name           string
	DocString      string
	ArgumentLabels []string
	Kind           common.DeclarationKind
}

type StorageCapacityProvider interface {
	StorageCommitter
	// GetStorageCapacity gets storage capacity in bytes on the address.
	GetStorageCapacity(address common.Address) (uint64, error)
}

type StorageCommitter interface {
	CommitStorageTemporarily(context interpreter.ValueTransferContext) error
}

type StorageUsedProvider interface {
	StorageCommitter
	// GetStorageUsed gets storage used in bytes by the address at the moment of the function call.
	GetStorageUsed(address common.Address) (uint64, error)
}

type TestContractType struct {
	Checker          *sema.Checker
	CompositeType    *sema.CompositeType
	InitializerTypes []sema.Type
	// contains filtered or unexported fields
}

type TestFailedError struct {
	Err error
}

type TestFramework interface {
	EmulatorBackend() Blockchain

	ReadFile(string) (string, error)
}

type TestFrameworkAddTransactionContext interface {
	interpreter.ValueExportContext
}

type TestFrameworkContractDeploymentContext interface {
	interpreter.ValueExportContext
}

type TestFrameworkEventsContext interface {
	common.MemoryGauge
	interpreter.ArrayCreationContext
	interpreter.ArrayCreationContext
	interpreter.MemberAccessibleContext
}

type TestFrameworkScriptExecutionContext interface {
	interpreter.ValueExportContext
}

type TransactionResult struct {
	Error error
}

type TypeComparator struct {
	RootDeclIdentifier *ast.Identifier
	// contains filtered or unexported fields
}

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

type TypeRemovalPragmaRemovalError struct {
	RemovedType string
}

type UnrepresentableEntitlementsUpgrade struct {
	Type                 sema.Type
	InvalidAuthorization sema.Access
	ast.Range
}

type UpdateValidator interface {
	ast.TypeEqualityChecker

	Validate() error

	Location() common.Location
	// contains filtered or unexported methods
}

type UseOfRemovedTypeError struct {
	Declaration ast.Declaration
	ast.Range
}

type VMFunction struct {
	BaseType      sema.Type
	FunctionValue *vm.NativeFunctionValue
}

type VMValue struct {
	Name  string
	Value vm.Value
}