isc

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

type AgentID interface {
	Kind() AgentIDKind
	String() string
	Bytes() []byte
	Equals(other AgentID) bool
}

type AgentIDKind uint8

type AgentIDWithL1Address interface {
	AgentID
	Address() iotago.Address
}

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

type Allowance struct {
	Assets *FungibleTokens
	NFTs   []iotago.NFTID
}

type Authorize interface {
	RequireCaller(agentID AgentID)
	RequireCallerAnyOf(agentID []AgentID)
	RequireCallerIsChainOwner()
}

type BLS interface {
	ValidSignature(data []byte, pubKey []byte, signature []byte) bool
	AddressFromPublicKey(pubKey []byte) (iotago.Address, error)
	AggregateBLSSignatures(pubKeysBin [][]byte, sigsBin [][]byte) ([]byte, []byte, error)
}

type Balance interface {
	// BalanceBaseTokens returns number of base tokens in the balance of the smart contract
	BalanceBaseTokens() uint64
	// BalanceNativeToken returns number of native token or nil if it is empty
	BalanceNativeToken(id *iotago.NativeTokenID) *big.Int
	// BalanceFungibleTokens returns all fungible tokens: base tokens and native tokens
	BalanceFungibleTokens() *FungibleTokens
	// OwnedNFTs returns the NFTIDs of NFTs owned by the smart contract
	OwnedNFTs() []iotago.NFTID
	// returns whether a given user owns a given amount of tokens
	HasInAccount(AgentID, *FungibleTokens) bool
}

type CallTarget struct {
	Contract   Hname
	EntryPoint Hname
}

type Calldata interface {
	ID() RequestID
	Params() dict.Dict
	SenderAccount() AgentID
	CallTarget() CallTarget
	TargetAddress() iotago.Address   // TODO implement properly. Target depends on time assumptions and UTXO type
	FungibleTokens() *FungibleTokens // attached assets for the UTXO request, nil for off-ledger. All goes to sender
	NFT() *NFT                       // Not nil if the request is an NFT request
	Allowance() *Allowance           // transfer of assets to the smart contract. Debited from sender account
	GasBudget() (gas uint64, isEVM bool)
}

type ChainID iotago.AliasID

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

type ED25519 interface {
	ValidSignature(data []byte, pubKey []byte, signature []byte) bool
	AddressFromPublicKey(pubKey []byte) (iotago.Address, error)
}

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

type Expiration struct {
	Time          time.Time
	ReturnAddress iotago.Address
}

type Features interface {
	// TimeLock returns the timelock feature, or a zero time if not present
	TimeLock() time.Time
	// Expiry returns the expiry time and sender address, or a zero time if not present
	Expiry() (time.Time, iotago.Address) // return expiry time data and sender address or nil, nil if does not exist
	ReturnAmount() (uint64, bool)
}

type FungibleTokens struct {
	BaseTokens uint64
	Tokens     iotago.NativeTokens
}

type Gas interface {
	Burn(burnCode gas.BurnCode, par ...uint64)
	Budget() uint64
	Burned() uint64
}

type Hashing interface {
	Blake2b(data []byte) hashing.HashValue
	Sha3(data []byte) hashing.HashValue
	Hname(name string) Hname
}

type Helpers interface {
	Requiref(cond bool, format string, args ...interface{})
	RequireNoError(err error, str ...string)
}

type Hname uint32

type KVDecoder interface {
	kv.KVStoreReader
	GetInt16(key kv.Key, def ...int16) (int16, error)
	MustGetInt16(key kv.Key, def ...int16) int16
	GetUint16(key kv.Key, def ...uint16) (uint16, error)
	MustGetUint16(key kv.Key, def ...uint16) uint16
	GetInt32(key kv.Key, def ...int32) (int32, error)
	MustGetInt32(key kv.Key, def ...int32) int32
	GetUint32(key kv.Key, def ...uint32) (uint32, error)
	MustGetUint32(key kv.Key, def ...uint32) uint32
	GetInt64(key kv.Key, def ...int64) (int64, error)
	MustGetInt64(key kv.Key, def ...int64) int64
	GetUint64(key kv.Key, def ...uint64) (uint64, error)
	MustGetUint64(key kv.Key, def ...uint64) uint64
	GetBool(key kv.Key, def ...bool) (bool, error)
	MustGetBool(key kv.Key, def ...bool) bool
	GetTime(key kv.Key, def ...time.Time) (time.Time, error)
	MustGetTime(key kv.Key, def ...time.Time) time.Time
	GetString(key kv.Key, def ...string) (string, error)
	MustGetString(key kv.Key, def ...string) string
	GetHname(key kv.Key, def ...Hname) (Hname, error)
	MustGetHname(key kv.Key, def ...Hname) Hname
	GetHashValue(key kv.Key, def ...hashing.HashValue) (hashing.HashValue, error)
	MustGetHashValue(key kv.Key, def ...hashing.HashValue) hashing.HashValue
	GetAddress(key kv.Key, def ...iotago.Address) (iotago.Address, error)
	MustGetAddress(key kv.Key, def ...iotago.Address) iotago.Address
	GetRequestID(key kv.Key, def ...RequestID) (RequestID, error)
	MustGetRequestID(key kv.Key, def ...RequestID) RequestID
	GetAgentID(key kv.Key, def ...AgentID) (AgentID, error)
	MustGetAgentID(key kv.Key, def ...AgentID) AgentID
	GetChainID(key kv.Key, def ...*ChainID) (*ChainID, error)
	MustGetChainID(key kv.Key, def ...*ChainID) *ChainID
	GetBytes(key kv.Key, def ...[]byte) ([]byte, error)
	MustGetBytes(key kv.Key, def ...[]byte) []byte
	GetTokenScheme(key kv.Key, def ...iotago.TokenScheme) (iotago.TokenScheme, error)
	MustGetTokenScheme(key kv.Key, def ...iotago.TokenScheme) iotago.TokenScheme
	GetBigInt(key kv.Key, def ...*big.Int) (*big.Int, error)
	MustGetBigInt(key kv.Key, def ...*big.Int) *big.Int
	GetNativeTokenID(key kv.Key, def ...iotago.NativeTokenID) (iotago.NativeTokenID, error)
	MustGetNativeTokenID(key kv.Key, def ...iotago.NativeTokenID) iotago.NativeTokenID
}

type LogInterface interface {
	Infof(format string, param ...interface{})
	Debugf(format string, param ...interface{})
	Panicf(format string, param ...interface{})
}

type NFT struct {
	ID       iotago.NFTID
	Issuer   iotago.Address
	Metadata []byte  // (ImmutableMetadata)
	Owner    AgentID // can be nil
}

type NilAgentID struct{}

type OffLedgerRequest interface {
	Request
	OffLedgerRequestData
	VerifySignature() error
}

type OffLedgerRequestData interface {
	ChainID() *ChainID
	Nonce() uint64
}

type OnLedgerRequest interface {
	Request
	Output() iotago.Output
	IsInternalUTXO(*ChainID) bool
	UTXOInput() iotago.UTXOInput
	Features() Features
}

type Params struct {
	Dict dict.Dict
	KVDecoder
}

type Privileged interface {
	TryLoadContract(programHash hashing.HashValue) error
	CreateNewFoundry(scheme iotago.TokenScheme, metadata []byte) (uint32, uint64)
	DestroyFoundry(uint32) uint64
	ModifyFoundrySupply(serNum uint32, delta *big.Int) int64
	GasBurnEnable(enable bool)
	MustMoveBetweenAccounts(fromAgentID, toAgentID AgentID, fungibleTokens *FungibleTokens, nfts []iotago.NFTID)
	DebitFromAccount(AgentID, *FungibleTokens)
	CreditToAccount(AgentID, *FungibleTokens)

	SubscribeBlockContext(openFunc Hname, closeFunc Hname)
	SetBlockContext(bctx interface{})
	BlockContext() interface{}
	// the amount of tokens available to pay for the gas of the current request
	TotalGasTokens() *FungibleTokens
}

type PrivilegedView interface {
	GasBurnEnable(enable bool)
}

type Receipt struct {
	Request       []byte             `json:"request"`
	Error         *UnresolvedVMError `json:"error"`
	GasBudget     uint64             `json:"gasBudget"`
	GasBurned     uint64             `json:"gasBurned"`
	GasFeeCharged uint64             `json:"gasFeeCharged"`
	BlockIndex    uint32             `json:"blockIndex"`
	RequestIndex  uint16             `json:"requestIndex"`
	ResolvedError string             `json:"resolvedError"`
	GasBurnLog    *gas.BurnLog       `json:"-"`
}

type Request interface {
	Calldata

	IsOffLedger() bool

	WriteToMarshalUtil(mu *marshalutil.MarshalUtil)

	Bytes() []byte
	String() string
	// contains filtered or unexported methods
}

type RequestID iotago.UTXOInput

type RequestLookupDigest [RequestIDDigestLen + 2]byte

type RequestMetadata struct {
	SenderContract Hname
	// ID of the target smart contract
	TargetContract Hname
	// entry point code
	EntryPoint Hname
	// request arguments
	Params dict.Dict
	// Allowance intended to the target contract to take. Nil means zero allowance
	Allowance *Allowance
	// gas budget
	GasBudget uint64
}

type RequestParameters struct {
	// TargetAddress is the target address. It may represent another chain or L1 address
	TargetAddress iotago.Address
	// FungibleTokens attached to the output, always taken from the caller's account.
	// It expected to contain base tokens at least the amount required for storage deposit
	// It depends on the context how it is handled when base tokens are not enough for storage deposit
	FungibleTokens *FungibleTokens
	// AdjustToMinimumStorageDeposit if true base tokens in attached fungible tokens will be added to meet minimum storage deposit requirements
	AdjustToMinimumStorageDeposit bool
	// Metadata is a request metadata. It may be nil if the output is just sending assets to L1 address
	Metadata *SendMetadata
	// SendOptions includes options of the output, such as time lock or expiry parameters
	Options SendOptions
}

type ReturnAmountOptions interface {
	ReturnTo() iotago.Address
	Amount() uint64
}

type Sandbox interface {
	SandboxBase
	Authorize

	// State k/v store of the current call (in the context of the smart contract)
	State() kv.KVStore
	// Request return the request in the context of which the smart contract is called
	Request() Calldata

	// Call calls the entry point of the contract with parameters and allowance.
	// If the entry point is full entry point, allowance tokens are available to be moved from the caller's
	// accounts (if enough). If the entry point is view, 'allowance' has no effect
	Call(target, entryPoint Hname, params dict.Dict, allowance *Allowance) dict.Dict
	// Caller is the agentID of the caller.
	Caller() AgentID
	// DeployContract deploys contract on the same chain. 'initParams' are passed to the 'init' entry point
	DeployContract(programHash hashing.HashValue, name string, description string, initParams dict.Dict)
	// Event emits an event
	Event(msg string)
	// RegisterError registers an error
	RegisterError(messageFormat string) *VMErrorTemplate
	// GetEntropy 32 random bytes based on the hash of the current state transaction
	GetEntropy() hashing.HashValue
	// AllowanceAvailable specifies max remaining (after transfers) budget of assets the smart contract can take
	// from the caller with TransferAllowedFunds. Nil means no allowance left (zero budget)
	AllowanceAvailable() *Allowance
	// TransferAllowedFunds moves assets from the caller's account to specified account within the budget set by Allowance.
	// Skipping 'assets' means transfer all Allowance().
	// The TransferAllowedFunds call mutates AllowanceAvailable
	// Returns remaining budget
	// TransferAllowedFunds fails if target does not exist
	TransferAllowedFunds(target AgentID, transfer ...*Allowance) *Allowance
	// TransferAllowedFundsForceCreateTarget does not fail when target does not exist.
	// If it is a random target, funds may be inaccessible (less safe)
	TransferAllowedFundsForceCreateTarget(target AgentID, transfer ...*Allowance) *Allowance
	// Send sends an on-ledger request (or a regular transaction to any L1 Address)
	Send(metadata RequestParameters)
	// SendAsNFT sends an on-ledger request as an NFTOutput
	SendAsNFT(metadata RequestParameters, nftID iotago.NFTID)
	// EstimateRequiredStorageDeposit returns the amount of base tokens needed to cover for a given request's storage deposit
	EstimateRequiredStorageDeposit(r RequestParameters) uint64
	// StateAnchor properties of the anchor output
	StateAnchor() *StateAnchor

	// Privileged is a sub-interface of the sandbox which should not be called by VM plugins
	Privileged() Privileged
}

type SandboxBase interface {
	Helpers
	Balance
	// Params returns the parameters of the current call
	Params() *Params
	// ChainID returns the chain ID
	ChainID() *ChainID
	// ChainOwnerID returns the AgentID of the current owner of the chain
	ChainOwnerID() AgentID
	// Contract returns the Hname of the current contract in the context
	Contract() Hname
	// AccountID returns the agentID of the current contract (i.e. chainID + contract hname)
	AccountID() AgentID
	// Timestamp returns the Unix timestamp of the current state in seconds
	Timestamp() time.Time
	// Log returns a logger that outputs on the local machine. It includes Panicf method
	Log() LogInterface
	// Utils provides access to common necessary functionality
	Utils() Utils
	// Gas returns sub-interface for gas related functions. It is stateful but does not modify chain's state
	Gas() Gas
	// GetNFTInfo returns information about a NFTID (issuer and metadata)
	GetNFTData(nftID iotago.NFTID) NFT
	// CallView calls another contract. Only calls view entry points
	CallView(contractHname Hname, entryPoint Hname, params dict.Dict) dict.Dict
	// StateR returns the immutable k/v store of the current call (in the context of the smart contract)
	StateR() kv.KVStoreReader
}

type SandboxView interface {
	SandboxBase

	// Privileged is a sub-interface of the sandbox that should never be called by VM plugins
	Privileged() PrivilegedView
}

type SendMetadata struct {
	TargetContract Hname
	EntryPoint     Hname
	Params         dict.Dict
	Allowance      *Allowance
	GasBudget      uint64
}

type SendOptions struct {
	Timelock   time.Time
	Expiration *Expiration
}

type StateAnchor struct {
	ChainID              ChainID
	Sender               iotago.Address
	OutputID             iotago.OutputID
	IsOrigin             bool
	StateController      iotago.Address
	GovernanceController iotago.Address
	StateIndex           uint32
	StateData            []byte
	Deposit              uint64
	NativeTokens         iotago.NativeTokens
}

type UnresolvedVMError struct {
	ErrorCode VMErrorCode   `json:"code"`
	Params    []interface{} `json:"params"`
	Hash      uint32        `json:"hash"`
}

type UnsignedOffLedgerRequest interface {
	WithNonce(nonce uint64) UnsignedOffLedgerRequest
	WithGasBudget(gasBudget uint64) UnsignedOffLedgerRequest
	WithAllowance(allowance *Allowance) UnsignedOffLedgerRequest
	Sign(key *cryptolib.KeyPair) OffLedgerRequest
}

type Utils interface {
	Hashing() Hashing
	ED25519() ED25519
	BLS() BLS
}

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

type VMErrorBase interface {
	error
	Code() VMErrorCode
}

type VMErrorCode struct {
	ContractID Hname
	ID         uint16
}

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

type VMProcessor interface {
	GetEntryPoint(code Hname) (VMProcessorEntryPoint, bool)
	GetDescription() string
}

type VMProcessorEntryPoint interface {
	Call(ctx interface{}) dict.Dict
	IsView() bool
}