Virtual Machines

type ChainVM interface {
    common.VM

    // Block building
    BuildBlock(ctx context.Context) (snowman.Block, error)

    // Block retrieval
    GetBlock(ctx context.Context, blkID ids.ID) (snowman.Block, error)
    ParseBlock(ctx context.Context, blockBytes []byte) (snowman.Block, error)

    // Consensus integration
    SetPreference(ctx context.Context, blkID ids.ID) error
    LastAccepted(ctx context.Context) (ids.ID, error)

    // Optional: height-indexed access
    GetBlockIDAtHeight(ctx context.Context, height uint64) (ids.ID, error)
}

type VM interface {
    common.AppHandler          // AppRequest/AppResponse/AppGossip hooks
    health.Checker             // Exposed via /ext/health
    validators.Connector       // Called on peer connect/disconnect

    // Lifecycle
    Initialize(ctx context.Context, chainCtx *snow.Context,
        db database.Database, genesisBytes []byte,
        upgradeBytes []byte, configBytes []byte,
        fxs []*common.Fx, appSender common.AppSender) error
    SetState(ctx context.Context, state snow.State) error
    Shutdown(ctx context.Context) error

    // Info
    Version(ctx context.Context) (string, error)

    // APIs
    CreateHandlers(ctx context.Context) (map[string]http.Handler, error)
    NewHTTPHandler(ctx context.Context) (http.Handler, error)

    // Engine notifications (PendingTxs, etc.)
    WaitForEvent(ctx context.Context) (common.Message, error)
}

type Block interface {
    // ID(), Accept(), Reject(), Status() come from snow.Decidable
    snow.Decidable

    // Identity
    Parent() ids.ID
    Height() uint64
    Timestamp() time.Time
    Bytes() []byte

    // Validation
    Verify(context.Context) error
}

type Status int

const (
    Unknown Status = iota
    Processing
    Rejected
    Accepted
)

type VM struct {
    // State management
    state        state.State
    atomicUTXOs  atomic.SharedMemory

    // Block building
    Builder      blockbuilder.Builder
    Network      network.Network

    // Validators
    Validators   validators.Manager
}

type VM struct {
    // Asset management
    fxs     []*Fx
    state   state.State

    // UTXO handling
    utxoSet atomic.SharedMemory
}

type VM struct {
    // Wrapped VM
    ChainVM block.ChainVM

    // Proposer selection
    windower proposer.Windower

    // Block timing
    MinBlockDelay time.Duration
}

type MyVM struct {
    db      database.Database
    state   *MyState
    builder *BlockBuilder
    pending <-chan struct{}
}

func (vm *MyVM) Initialize(ctx context.Context, ...) error {
    // Set up database and state
    vm.db = db
    vm.state = NewState(db)
    vm.pending = vm.builder.Subscribe() // emits when there are pending txs
    return nil
}

func (vm *MyVM) WaitForEvent(ctx context.Context) (common.Message, error) {
    select {
    case <-ctx.Done():
        return 0, ctx.Err()
    case <-vm.pending:
        return common.PendingTxs, nil
    }
}

func (vm *MyVM) BuildBlock(ctx context.Context) (snowman.Block, error) {
    // Collect pending transactions
    txs := vm.builder.GetPendingTxs()
    // Create new block
    return NewBlock(vm.state.LastAccepted(), txs), nil
}

// gRPC service definition
service VM {
    rpc Initialize(InitializeRequest) returns (InitializeResponse);
    rpc BuildBlock(BuildBlockRequest) returns (BuildBlockResponse);
    rpc ParseBlock(ParseBlockRequest) returns (ParseBlockResponse);
    rpc GetBlock(GetBlockRequest) returns (GetBlockResponse);
    // ... more methods
}

func (n *Node) initVMs() error {
    // Built-in VMs
    n.VMManager.RegisterFactory(ctx, constants.PlatformVMID,
        &platformvm.Factory{})
    n.VMManager.RegisterFactory(ctx, constants.AVMID,
        &avm.Factory{})
    n.VMManager.RegisterFactory(ctx, constants.EVMID,
        &coreth.Factory{})

    // Plugin VMs are discovered from the plugins directory
    // (default: ~/.avalanchego/plugins/)
}

{
  "pruning-enabled": true,
  "state-sync-enabled": true,
  "eth-apis": ["eth", "eth-filter", "net", "web3"]
}

// Use versioned database for atomic commits
func (vm *VM) Accept(ctx context.Context, blk *Block) error {
    batch := vm.db.NewBatch()
    defer batch.Reset()

    // Apply state changes
    for _, tx := range blk.Txs {
        if err := vm.state.Apply(batch, tx); err != nil {
            return err
        }
    }

    // Commit atomically
    return batch.Write()
}

// Drive block production: return PendingTxs when mempool has work
func (vm *VM) WaitForEvent(ctx context.Context) (common.Message, error) {
    select {
    case <-ctx.Done():
        return 0, ctx.Err()
    case <-vm.pending:
        return common.PendingTxs, nil
    }
}

func (vm *VM) CreateHandlers(ctx context.Context) (map[string]http.Handler, error) {
    return map[string]http.Handler{
        "/rpc":    vm.newJSONRPCHandler(),
        "/ws":     vm.newWebSocketHandler(),
        "/health": vm.newHealthHandler(),
    }, nil
}