fhevm

type Contract interface {
	Address() common.Address
}

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

type EVMEnvironment interface {
	// StateDB related functions
	GetState(common.Address, common.Hash) common.Hash
	SetState(common.Address, common.Hash, common.Hash)
	GetNonce(common.Address) uint64
	AddBalance(common.Address, *big.Int)
	GetBalance(common.Address) *big.Int

	Suicide(common.Address) bool

	// EVM call stack depth
	GetDepth() int

	// EVM Logger
	GetLogger() Logger

	// TODO: clarify meaning of the following
	IsCommitting() bool
	IsEthCall() bool
	IsReadOnly() bool

	CreateContract(caller common.Address, code []byte, gas uint64, value *big.Int, address common.Address) ([]byte, common.Address, uint64, error)
	CreateContract2(caller common.Address, code []byte, codeHash common.Hash, gas uint64, value *big.Int, address common.Address) ([]byte, common.Address, uint64, error)

	FhevmData() *FhevmData
	FhevmParams() *FhevmParams

	// This should return the context used for OpenTelemetry in the current EVM.
	// It should be considered the root context for every op that runs in the EVM, and all spans created from this context
	// would be child spans for what has been already created using the context.
	// Implementations returning nil would disable OpenTelemetry on the fhEVM
	OtelContext() context.Context
}

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

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

type FhevmParams struct {
	GasCosts                        GasCosts
	DisableDecryptionsInTransaction bool
}

type GasCosts struct {
	FheCast           uint64
	FhePubKey         uint64
	FheAddSub         map[tfhe.FheUintType]uint64
	FheDecrypt        map[tfhe.FheUintType]uint64
	FheBitwiseOp      map[tfhe.FheUintType]uint64
	FheMul            map[tfhe.FheUintType]uint64
	FheScalarMul      map[tfhe.FheUintType]uint64
	FheScalarDiv      map[tfhe.FheUintType]uint64
	FheScalarRem      map[tfhe.FheUintType]uint64
	FheShift          map[tfhe.FheUintType]uint64
	FheScalarShift    map[tfhe.FheUintType]uint64
	FheEq             map[tfhe.FheUintType]uint64
	FheLe             map[tfhe.FheUintType]uint64
	FheMinMax         map[tfhe.FheUintType]uint64
	FheScalarMinMax   map[tfhe.FheUintType]uint64
	FheNot            map[tfhe.FheUintType]uint64
	FheNeg            map[tfhe.FheUintType]uint64
	FheReencrypt      map[tfhe.FheUintType]uint64
	FheTrivialEncrypt map[tfhe.FheUintType]uint64
	FheRand           map[tfhe.FheUintType]uint64
	FheIfThenElse     map[tfhe.FheUintType]uint64
	FheVerify         map[tfhe.FheUintType]uint64
	FheGetCiphertext  map[tfhe.FheUintType]uint64
}

type Logger interface {
	Debug(msg string, keyvals ...interface{})
	Info(msg string, keyvals ...interface{})
	Error(msg string, keyvals ...interface{})
}

type Memory interface {
	Set(offset, size uint64, value []byte)
	Set32(offset uint64, val *uint256.Int)
	Resize(size uint64)
	GetCopy(offset, size int64) (cpy []byte)
	GetPtr(offset, size int64) []byte
	Len() int
	Data() []byte
}

type PrivilegedMemory struct {
	// A map from a ciphertext hash to itself and stack depths at which it is verified
	VerifiedCiphertexts map[common.Hash]*verifiedCiphertext
}

type ScopeContext interface {
	GetMemory() Memory
	GetStack() Stack
	GetContract() Contract
}

type Stack interface {
	Pop() uint256.Int
	Peek() *uint256.Int
}