Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

evm

package

Go to main page

Versions in this module

v0

v0.1.0

Apr 17, 2025

v0.0.4

Mar 27, 2025

v0.0.3

Mar 24, 2025

v0.0.2

Mar 24, 2025

Changes in this version

+ const GenesisTestAddr

+ const GenesisTestKey

+ var Codec codec.Manager

+ var EVMInputGas uint64 = (common.AddressLength+wrappers.LongLen+hashing.HashLen+wrappers.LongLen)*TxBytesGas + secp256k1fx.CostPerSignature

+ var EVMOutputGas uint64 = (common.AddressLength + wrappers.LongLen + hashing.HashLen) * TxBytesGas

+ var ErrSnapshotNotSupported = errors.New("snapshot is not supported")

+ var GitCommit string

+ var ID = ids.ID

+ var TxBytesGas uint64 = 1

+ var Version string = "v0.13.6"

+ func CalculateDynamicFee(cost uint64, baseFee *big.Int) (uint64, error)

+ func GetEthAddress(privKey *secp256k1.PrivateKey) common.Address

+ func NewAtomicTxRepository(db *versiondb.Database, codec codec.Manager, lastAcceptedHeight uint64) (*atomicTxRepository, error)

+ func NewSharedMemoryWriter() *sharedMemoryWriter

+ func ParseEthAddress(addrStr string) (common.Address, error)

+ func PublicKeyToEthAddress(pubKey *secp256k1.PublicKey) common.Address

+ func SortEVMInputsAndSigners(inputs []EVMInput, signers [][]*secp256k1.PrivateKey)

+ type Admin struct

+ func NewAdminService(vm *VM, performanceDir string) *Admin

+ func (p *Admin) GetVMConfig(_ *http.Request, _ *struct{}, reply *ConfigReply) error

+ func (p *Admin) LockProfile(_ *http.Request, _ *struct{}, _ *api.EmptyReply) error

+ func (p *Admin) MemoryProfile(_ *http.Request, _ *struct{}, _ *api.EmptyReply) error

+ func (p *Admin) SetLogLevel(_ *http.Request, args *SetLogLevelArgs, reply *api.EmptyReply) error

+ func (p *Admin) StartCPUProfiler(_ *http.Request, _ *struct{}, _ *api.EmptyReply) error

+ func (p *Admin) StopCPUProfiler(r *http.Request, _ *struct{}, _ *api.EmptyReply) error

+ type AtomicBackend interface

+ ApplyToSharedMemory func(lastAcceptedBlock uint64) error

+ AtomicTrie func() AtomicTrie

+ GetVerifiedAtomicState func(blockHash common.Hash) (AtomicState, error)

+ InsertTxs func(blockHash common.Hash, blockHeight uint64, parentHash common.Hash, txs []*Tx) (common.Hash, error)

+ IsBonus func(blockHeight uint64, blockHash common.Hash) bool

+ MarkApplyToSharedMemoryCursor func(previousLastAcceptedHeight uint64) error

+ SetLastAccepted func(lastAcceptedHash common.Hash)

+ Syncer func(client syncclient.LeafClient, targetRoot common.Hash, targetHeight uint64, ...) (Syncer, error)

+ func NewAtomicBackend(db *versiondb.Database, sharedMemory atomic.SharedMemory, ...) (AtomicBackend, error)

+ type AtomicState interface

+ Accept func(commitBatch database.Batch, requests map[ids.ID]*atomic.Requests) error

+ Reject func() error

+ Root func() common.Hash

+ type AtomicTrie interface

+ AcceptTrie func(height uint64, root common.Hash) (bool, error)

+ InsertTrie func(nodes *trienode.NodeSet, root common.Hash) error

+ Iterator func(hash common.Hash, cursor []byte) (AtomicTrieIterator, error)

+ LastAcceptedRoot func() common.Hash

+ LastCommitted func() (common.Hash, uint64)

+ OpenTrie func(hash common.Hash) (*trie.Trie, error)

+ RejectTrie func(root common.Hash) error

+ Root func(height uint64) (common.Hash, error)

+ TrieDB func() *trie.Database

+ UpdateTrie func(tr *trie.Trie, height uint64, atomicOps map[ids.ID]*atomic.Requests) error

+ type AtomicTrieIterator interface

+ AtomicOps func() *atomic.Requests

+ BlockNumber func() uint64

+ BlockchainID func() ids.ID

+ Error func() error

+ Key func() []byte

+ Next func() bool

+ Value func() []byte

+ func NewAtomicTrieIterator(trieIterator *trie.Iterator, codec codec.Manager) AtomicTrieIterator

+ type AtomicTxRepository interface

+ Codec func() codec.Manager

+ GetByHeight func(height uint64) ([]*Tx, error)

+ GetByTxID func(txID ids.ID) (*Tx, uint64, error)

+ GetIndexHeight func() (uint64, error)

+ IterateByHeight func(start uint64) database.Iterator

+ Write func(height uint64, txs []*Tx) error

+ WriteBonus func(height uint64, txs []*Tx) error

+ type Batch struct

+ func (batch Batch) Replay(w ethdb.KeyValueWriter) error

+ func (batch Batch) ValueSize() int

+ type Block struct

+ func (b *Block) Accept(context.Context) error

+ func (b *Block) Bytes() []byte

+ func (b *Block) Height() uint64

+ func (b *Block) ID() ids.ID

+ func (b *Block) Parent() ids.ID

+ func (b *Block) Reject(context.Context) error

+ func (b *Block) SetStatus(status choices.Status)

+ func (b *Block) ShouldVerifyWithContext(context.Context) (bool, error)

+ func (b *Block) Status() choices.Status

+ func (b *Block) String() string

+ func (b *Block) Timestamp() time.Time

+ func (b *Block) Verify(context.Context) error

+ func (b *Block) VerifyWithContext(ctx context.Context, proposerVMBlockCtx *block.Context) error

+ type BlockValidator interface

+ SyntacticVerify func(b *Block, rules params.Rules) error

+ func NewBlockValidator(extDataHashes map[common.Hash]common.Hash) BlockValidator

+ type BuildGenesisReply struct

+ Bytes string

+ Encoding formatting.Encoding

+ type Client interface

+ Export func(ctx context.Context, userPass api.UserPass, amount uint64, to ids.ShortID, ...) (ids.ID, error)

+ ExportKey func(ctx context.Context, userPass api.UserPass, addr common.Address, ...) (*secp256k1.PrivateKey, string, error)

+ ExportLUX func(ctx context.Context, userPass api.UserPass, amount uint64, to ids.ShortID, ...) (ids.ID, error)

+ GetAtomicTx func(ctx context.Context, txID ids.ID, options ...rpc.Option) ([]byte, error)

+ GetAtomicTxStatus func(ctx context.Context, txID ids.ID, options ...rpc.Option) (Status, error)

+ GetAtomicUTXOs func(ctx context.Context, addrs []ids.ShortID, sourceChain string, limit uint32, ...) ([][]byte, ids.ShortID, ids.ID, error)

+ GetVMConfig func(ctx context.Context, options ...rpc.Option) (*Config, error)

+ Import func(ctx context.Context, userPass api.UserPass, to common.Address, ...) (ids.ID, error)

+ ImportKey func(ctx context.Context, userPass api.UserPass, privateKey *secp256k1.PrivateKey, ...) (common.Address, error)

+ IssueTx func(ctx context.Context, txBytes []byte, options ...rpc.Option) (ids.ID, error)

+ LockProfile func(ctx context.Context, options ...rpc.Option) error

+ MemoryProfile func(ctx context.Context, options ...rpc.Option) error

+ SetLogLevel func(ctx context.Context, level slog.Level, options ...rpc.Option) error

+ StartCPUProfiler func(ctx context.Context, options ...rpc.Option) error

+ StopCPUProfiler func(ctx context.Context, options ...rpc.Option) error

+ func NewCChainClient(uri string) Client

+ func NewClient(uri, chain string) Client

+ type Config struct

+ APIMaxDuration Duration

+ AcceptedCacheSize int

+ AcceptorQueueLimit int

+ AdminAPIDir string

+ AdminAPIEnabled bool

+ AllowMissingTries bool

+ AllowUnfinalizedQueries bool

+ AllowUnprotectedTxHashes []common.Hash

+ AllowUnprotectedTxs bool

+ CommitInterval uint64

+ ContinuousProfilerDir string

+ ContinuousProfilerFrequency Duration

+ ContinuousProfilerMaxFiles int

+ CorethAdminAPIDir string

+ CorethAdminAPIEnabled bool

+ EnabledEthAPIs []string

+ InspectDatabase bool

+ KeystoreDirectory string

+ KeystoreExternalSigner string

+ KeystoreInsecureUnlockAllowed bool

+ LocalTxsEnabled bool

+ LogJSONFormat bool

+ LogLevel string

+ MaxBlocksPerRequest int64

+ MaxOutboundActiveCrossChainRequests int64

+ MaxOutboundActiveRequests int64

+ MetricsExpensiveEnabled bool

+ OfflinePruning bool

+ OfflinePruningBloomFilterSize uint64

+ OfflinePruningDataDirectory string

+ PopulateMissingTries *uint64

+ PopulateMissingTriesParallelism int

+ Preimages bool

+ PruneWarpDB bool

+ Pruning bool

+ PullGossipFrequency Duration

+ PushGossipFrequency Duration

+ PushGossipNumPeers int

+ PushGossipNumValidators int

+ PushGossipPercentStake float64

+ PushRegossipNumPeers int

+ PushRegossipNumValidators int

+ RPCGasCap uint64

+ RPCTxFeeCap float64

+ RegossipFrequency Duration

+ SkipTxIndexing bool

+ SkipUpgradeCheck bool

+ SnapshotCache int

+ SnapshotVerify bool

+ SnapshotWait bool

+ SnowmanAPIEnabled bool

+ StateSyncCommitInterval uint64

+ StateSyncEnabled *bool

+ StateSyncIDs string

+ StateSyncMinBlocks uint64

+ StateSyncRequestSize uint16

+ StateSyncServerTrieCache int

+ StateSyncSkipResume bool

+ TransactionHistory uint64

+ TrieCleanCache int

+ TrieDirtyCache int

+ TrieDirtyCommitTarget int

+ TriePrefetcherParallelism int

+ TxLookupLimit uint64

+ TxPoolAccountQueue uint64

+ TxPoolAccountSlots uint64

+ TxPoolGlobalQueue uint64

+ TxPoolGlobalSlots uint64

+ TxPoolLifetime Duration

+ TxPoolPriceBump uint64

+ TxPoolPriceLimit uint64

+ TxRegossipFrequency Duration

+ WSCPUMaxStored Duration

+ WSCPURefillRate Duration

+ WarpAPIEnabled bool

+ WarpOffChainMessages []hexutil.Bytes

+ func (c *Config) Deprecate() string

+ func (c *Config) SetDefaults()

+ func (c *Config) Validate() error

+ func (c Config) EthAPIs() []string

+ func (c Config) EthBackendSettings() eth.Settings

+ type ConfigReply struct

+ Config *Config

+ type CorethLogger struct

+ func InitLogger(alias string, level string, jsonFormat bool, writer io.Writer) (CorethLogger, error)

+ func (c *CorethLogger) SetLogLevel(level string) error

+ type Database struct

+ func (db Database) NewBatch() ethdb.Batch

+ func (db Database) NewBatchWithSize(size int) ethdb.Batch

+ func (db Database) NewIterator(prefix []byte, start []byte) ethdb.Iterator

+ func (db Database) NewIteratorWithStart(start []byte) ethdb.Iterator

+ func (db Database) NewSnapshot() (ethdb.Snapshot, error)

+ func (db Database) Stat(string) (string, error)

+ type Duration struct

+ func (d *Duration) UnmarshalJSON(data []byte) (err error)

+ func (d Duration) MarshalJSON() ([]byte, error)

+ func (d Duration) String() string

+ type EVMInput struct

+ Address common.Address

+ Amount uint64

+ AssetID ids.ID

+ Nonce uint64

+ func (i EVMInput) Compare(other EVMInput) int

+ func (in *EVMInput) Verify() error

+ type EVMOutput struct

+ Address common.Address

+ Amount uint64

+ AssetID ids.ID

+ func (o EVMOutput) Compare(other EVMOutput) int

+ func (out *EVMOutput) Verify() error

+ type EthPushGossiper struct

+ func (e *EthPushGossiper) Add(tx *types.Transaction)

+ type ExportArgs struct

+ AssetID string

+ type ExportKeyArgs struct

+ Address string

+ type ExportKeyReply struct

+ PrivateKey *secp256k1.PrivateKey

+ PrivateKeyHex string

+ type ExportLUXArgs struct

+ Amount json.Uint64

+ BaseFee *hexutil.Big

+ TargetChain string

+ To string

+ type Factory struct

+ func (*Factory) New(logging.Logger) (interface{}, error)

+ type FormattedTx struct

+ BlockHeight *json.Uint64

+ type GetAcceptedFrontReply struct

+ Hash common.Hash

+ Number *big.Int

+ type GetAtomicTxStatusReply struct

+ BlockHeight *json.Uint64

+ Status Status

+ type GossipAtomicTx struct

+ Tx *Tx

+ func (tx *GossipAtomicTx) GossipID() ids.ID

+ type GossipAtomicTxMarshaller struct

+ func (g GossipAtomicTxMarshaller) MarshalGossip(tx *GossipAtomicTx) ([]byte, error)

+ func (g GossipAtomicTxMarshaller) UnmarshalGossip(bytes []byte) (*GossipAtomicTx, error)

+ type GossipEthTx struct

+ Tx *types.Transaction

+ func (tx *GossipEthTx) GossipID() ids.ID

+ type GossipEthTxMarshaller struct

+ func (g GossipEthTxMarshaller) MarshalGossip(tx *GossipEthTx) ([]byte, error)

+ func (g GossipEthTxMarshaller) UnmarshalGossip(bytes []byte) (*GossipEthTx, error)

+ type GossipEthTxPool struct

+ func NewGossipEthTxPool(mempool *txpool.TxPool, registerer prometheus.Registerer) (*GossipEthTxPool, error)

+ func (g *GossipEthTxPool) Add(tx *GossipEthTx) error

+ func (g *GossipEthTxPool) GetFilter() ([]byte, []byte)

+ func (g *GossipEthTxPool) Has(txID ids.ID) bool

+ func (g *GossipEthTxPool) IsSubscribed() bool

+ func (g *GossipEthTxPool) Iterate(f func(tx *GossipEthTx) bool)

+ func (g *GossipEthTxPool) Subscribe(ctx context.Context)

+ type GossipHandler struct

+ func NewGossipHandler(vm *VM, stats GossipReceivedStats) *GossipHandler

+ func (h *GossipHandler) HandleAtomicTx(nodeID ids.NodeID, msg message.AtomicTxGossip) error

+ func (h *GossipHandler) HandleEthTxs(nodeID ids.NodeID, msg message.EthTxsGossip) error

+ type GossipStats interface

+ IncAtomicGossipReceived func()

+ IncAtomicGossipReceivedDropped func()

+ IncAtomicGossipReceivedError func()

+ IncAtomicGossipReceivedKnown func()

+ IncAtomicGossipReceivedNew func()

+ IncEthTxsGossipReceived func()

+ IncEthTxsGossipReceivedError func()

+ IncEthTxsGossipReceivedKnown func()

+ IncEthTxsGossipReceivedNew func()

+ func NewGossipStats() GossipStats

+ type Gossiper interface

+ GossipAtomicTxs func(txs []*Tx) error

+ GossipEthTxs func(txs []*types.Transaction) error

+ type ImportArgs struct

+ BaseFee *hexutil.Big

+ SourceChain string

+ To common.Address

+ type ImportKeyArgs struct

+ PrivateKey *secp256k1.PrivateKey

+ type LuxAPI struct

+ func (service *LuxAPI) Export(_ *http.Request, args *ExportArgs, response *api.JSONTxID) error

+ func (service *LuxAPI) ExportKey(r *http.Request, args *ExportKeyArgs, reply *ExportKeyReply) error

+ func (service *LuxAPI) ExportLUX(_ *http.Request, args *ExportLUXArgs, response *api.JSONTxID) error

+ func (service *LuxAPI) GetAtomicTx(r *http.Request, args *api.GetTxArgs, reply *FormattedTx) error

+ func (service *LuxAPI) GetAtomicTxStatus(r *http.Request, args *api.JSONTxID, reply *GetAtomicTxStatusReply) error

+ func (service *LuxAPI) GetUTXOs(r *http.Request, args *api.GetUTXOsArgs, reply *api.GetUTXOsReply) error

+ func (service *LuxAPI) Import(_ *http.Request, args *ImportArgs, response *api.JSONTxID) error

+ func (service *LuxAPI) ImportKey(r *http.Request, args *ImportKeyArgs, reply *api.JSONAddress) error

+ func (service *LuxAPI) ImportLUX(_ *http.Request, args *ImportArgs, response *api.JSONTxID) error

+ func (service *LuxAPI) IssueTx(r *http.Request, args *api.FormattedTx, response *api.JSONTxID) error

+ func (service *LuxAPI) Version(r *http.Request, _ *struct{}, reply *VersionReply) error

+ type Mempool struct

+ Pending chan struct{}

+ func NewMempool(ctx *snow.Context, registerer prometheus.Registerer, maxSize int, ...) (*Mempool, error)

+ func (m *Mempool) Add(tx *GossipAtomicTx) error

+ func (m *Mempool) AddLocalTx(tx *Tx) error

+ func (m *Mempool) AddTx(tx *Tx) error

+ func (m *Mempool) CancelCurrentTx(txID ids.ID)

+ func (m *Mempool) CancelCurrentTxs()

+ func (m *Mempool) DiscardCurrentTx(txID ids.ID)

+ func (m *Mempool) DiscardCurrentTxs()

+ func (m *Mempool) ForceAddTx(tx *Tx) error

+ func (m *Mempool) GetFilter() ([]byte, []byte)

+ func (m *Mempool) GetPendingTx(txID ids.ID) (*Tx, bool)

+ func (m *Mempool) GetTx(txID ids.ID) (*Tx, bool, bool)

+ func (m *Mempool) Has(txID ids.ID) bool

+ func (m *Mempool) IssueCurrentTxs()

+ func (m *Mempool) Iterate(f func(tx *GossipAtomicTx) bool)

+ func (m *Mempool) Len() int

+ func (m *Mempool) NextTx() (*Tx, bool)

+ func (m *Mempool) RemoveTx(tx *Tx)

+ type Metadata struct

+ func (md *Metadata) Bytes() []byte

+ func (md *Metadata) ID() ids.ID

+ func (md *Metadata) Initialize(unsignedBytes, bytes []byte)

+ func (md *Metadata) SignedBytes() []byte

+ type SetLogLevelArgs struct

+ Level string

+ type SnowmanAPI struct

+ func (api *SnowmanAPI) GetAcceptedFront(ctx context.Context) (*GetAcceptedFrontReply, error)

+ func (api *SnowmanAPI) IssueBlock(ctx context.Context) error

+ type StateSyncClient interface

+ ClearOngoingSummary func() error

+ Error func() error

+ GetOngoingSyncStateSummary func(context.Context) (block.StateSummary, error)

+ ParseStateSummary func(ctx context.Context, summaryBytes []byte) (block.StateSummary, error)

+ Shutdown func() error

+ StateSyncEnabled func(context.Context) (bool, error)

+ func NewStateSyncClient(config *stateSyncClientConfig) StateSyncClient

+ type StateSyncServer interface

+ GetLastStateSummary func(context.Context) (block.StateSummary, error)

+ GetStateSummary func(context.Context, uint64) (block.StateSummary, error)

+ func NewStateSyncServer(config *stateSyncServerConfig) StateSyncServer

+ type StaticService struct

+ func (*StaticService) BuildGenesis(_ context.Context, args *core.Genesis) (*BuildGenesisReply, error)

+ type Status uint32

+ const Accepted

+ const Dropped

+ const Processing

+ const Unknown

+ func (s *Status) UnmarshalJSON(b []byte) error

+ func (s Status) MarshalJSON() ([]byte, error)

+ func (s Status) String() string

+ func (s Status) Valid() error

+ type Syncer interface

+ Done func() <-chan error

+ Start func(ctx context.Context) error

+ type TestUnsignedTx struct

+ AcceptRequestsBlockchainIDV ids.ID

+ AcceptRequestsV *atomic.Requests

+ BurnedV uint64

+ EVMStateTransferV error

+ GasUsedV uint64

+ IDV ids.ID

+ InputUTXOsV set.Set[ids.ID]

+ SemanticVerifyV error

+ SignedBytesV []byte

+ UnsignedBytesV []byte

+ VerifyV error

+ func (t *TestUnsignedTx) AtomicOps() (ids.ID, *atomic.Requests, error)

+ func (t *TestUnsignedTx) Burned(assetID ids.ID) (uint64, error)

+ func (t *TestUnsignedTx) Bytes() []byte

+ func (t *TestUnsignedTx) EVMStateTransfer(ctx *snow.Context, state *state.StateDB) error

+ func (t *TestUnsignedTx) GasUsed(fixedFee bool) (uint64, error)

+ func (t *TestUnsignedTx) ID() ids.ID

+ func (t *TestUnsignedTx) Initialize(unsignedBytes, signedBytes []byte)

+ func (t *TestUnsignedTx) InputUTXOs() set.Set[ids.ID]

+ func (t *TestUnsignedTx) SemanticVerify(vm *VM, stx *Tx, parent *Block, baseFee *big.Int, rules params.Rules) error

+ func (t *TestUnsignedTx) SignedBytes() []byte

+ func (t *TestUnsignedTx) Verify(ctx *snow.Context, rules params.Rules) error

+ type Tx struct

+ Creds []verify.Verifiable

+ func ExtractAtomicTx(atomicTxBytes []byte, codec codec.Manager) (*Tx, error)

+ func ExtractAtomicTxs(atomicTxBytes []byte, batch bool, codec codec.Manager) ([]*Tx, error)

+ func ExtractAtomicTxsBatch(atomicTxBytes []byte, codec codec.Manager) ([]*Tx, error)

+ func (tx *Tx) BlockFeeContribution(fixedFee bool, luxAssetID ids.ID, baseFee *big.Int) (*big.Int, *big.Int, error)

+ func (tx *Tx) Compare(other *Tx) int

+ func (tx *Tx) Sign(c codec.Manager, signers [][]*secp256k1.PrivateKey) error

+ type UnsignedAtomicTx interface

+ AtomicOps func() (ids.ID, *atomic.Requests, error)

+ EVMStateTransfer func(ctx *snow.Context, state *state.StateDB) error

+ InputUTXOs func() set.Set[ids.ID]

+ SemanticVerify func(vm *VM, stx *Tx, parent *Block, baseFee *big.Int, rules params.Rules) error

+ Verify func(ctx *snow.Context, rules params.Rules) error

+ type UnsignedExportTx struct

+ BlockchainID ids.ID

+ DestinationChain ids.ID

+ ExportedOutputs []*lux.TransferableOutput

+ Ins []EVMInput

+ NetworkID uint32

+ func (utx *UnsignedExportTx) AtomicOps() (ids.ID, *atomic.Requests, error)

+ func (utx *UnsignedExportTx) Burned(assetID ids.ID) (uint64, error)

+ func (utx *UnsignedExportTx) EVMStateTransfer(ctx *snow.Context, state *state.StateDB) error

+ func (utx *UnsignedExportTx) GasUsed(fixedFee bool) (uint64, error)

+ func (utx *UnsignedExportTx) InputUTXOs() set.Set[ids.ID]

+ func (utx *UnsignedExportTx) SemanticVerify(vm *VM, stx *Tx, _ *Block, baseFee *big.Int, rules params.Rules) error

+ func (utx *UnsignedExportTx) Verify(ctx *snow.Context, rules params.Rules) error

+ type UnsignedImportTx struct

+ BlockchainID ids.ID

+ ImportedInputs []*lux.TransferableInput

+ NetworkID uint32

+ Outs []EVMOutput

+ SourceChain ids.ID

+ func (utx *UnsignedImportTx) AtomicOps() (ids.ID, *atomic.Requests, error)

+ func (utx *UnsignedImportTx) Burned(assetID ids.ID) (uint64, error)

+ func (utx *UnsignedImportTx) EVMStateTransfer(ctx *snow.Context, state *state.StateDB) error

+ func (utx *UnsignedImportTx) GasUsed(fixedFee bool) (uint64, error)

+ func (utx *UnsignedImportTx) InputUTXOs() set.Set[ids.ID]

+ func (utx *UnsignedImportTx) SemanticVerify(vm *VM, stx *Tx, parent *Block, baseFee *big.Int, rules params.Rules) error

+ func (utx *UnsignedImportTx) Verify(ctx *snow.Context, rules params.Rules) error

+ type UnsignedTx interface

+ Burned func(assetID ids.ID) (uint64, error)

+ Bytes func() []byte

+ GasUsed func(fixedFee bool) (uint64, error)

+ ID func() ids.ID

+ Initialize func(unsignedBytes, signedBytes []byte)

+ SignedBytes func() []byte

+ type VM struct

+ IsPlugin bool

+ func (vm *VM) Clock() *mockable.Clock

+ func (vm *VM) CodecRegistry() codec.Registry

+ func (vm *VM) CreateHandlers(context.Context) (map[string]http.Handler, error)

+ func (vm *VM) CreateStaticHandlers(context.Context) (map[string]http.Handler, error)

+ func (vm *VM) FormatAddress(chainID ids.ID, addr ids.ShortID) (string, error)

+ func (vm *VM) FormatLocalAddress(addr ids.ShortID) (string, error)

+ func (vm *VM) GetActivationTime() time.Time

+ func (vm *VM) GetAtomicUTXOs(chainID ids.ID, addrs set.Set[ids.ShortID], startAddr ids.ShortID, ...) ([]*lux.UTXO, ids.ShortID, ids.ID, error)

+ func (vm *VM) GetBlockIDAtHeight(_ context.Context, height uint64) (ids.ID, error)

+ func (vm *VM) GetCurrentNonce(address common.Address) (uint64, error)

+ func (vm *VM) GetSpendableFunds(keys []*secp256k1.PrivateKey, assetID ids.ID, amount uint64) ([]EVMInput, [][]*secp256k1.PrivateKey, error)

+ func (vm *VM) GetSpendableLUXWithFee(keys []*secp256k1.PrivateKey, amount uint64, cost uint64, baseFee *big.Int) ([]EVMInput, [][]*secp256k1.PrivateKey, error)

+ func (vm *VM) HealthCheck(context.Context) (interface{}, error)

+ func (vm *VM) Initialize(_ context.Context, chainCtx *snow.Context, db database.Database, ...) error

+ func (vm *VM) Logger() logging.Logger

+ func (vm *VM) NewBlockBuilder(notifyBuildBlockChan chan<- commonEng.Message) *blockBuilder

+ func (vm *VM) ParseAddress(addrStr string) (ids.ID, ids.ShortID, error)

+ func (vm *VM) ParseEthBlock(b []byte) (*types.Block, error)

+ func (vm *VM) ParseLocalAddress(addrStr string) (ids.ShortID, error)

+ func (vm *VM) ParseServiceAddress(addrStr string) (ids.ShortID, error)

+ func (vm *VM) SetPreference(ctx context.Context, blkID ids.ID) error

+ func (vm *VM) SetState(_ context.Context, state snow.State) error

+ func (vm *VM) Shutdown(context.Context) error

+ func (vm *VM) VerifyHeightIndex(context.Context) error

+ func (vm *VM) Version(context.Context) (string, error)

+ type VersionReply struct

+ Version string