mirror of
https://github.com/luxfi/node.git
synced 2026-10-30 15:24:05 +00:00
zeekay
7cf87b230b
The module already called itself github.com/luxfi/node while containing no node in Go: cmd/luxd was twenty-one lines that printed the size of a few types, and the Go column of the matrix measured a VM plugin. A repo that fetches the thing it claims to be has not replaced it, so the Go sources move in — 1515 files, the daemon and everything under it — and the build reaches outside this module for nothing. Rust and C++ sit beside it unchanged and are still measured against it by the differential. That is the point of one repo: the reference implementation and the two ports are the same checkout, so parity is a thing you can run rather than a thing you assert. Verified: builds, and the closure carries no lux-private — checked at build time rather than believed. The daemon starts twelve chains on a local network (P X C Q Z A B G K M F, plus D through its plugin) and reports healthy.
121 lines
2.5 KiB
Go
121 lines
2.5 KiB
Go
// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved.
|
|
// See the file LICENSE for licensing terms.
|
|
|
|
package chain
|
|
|
|
import (
|
|
enginechain "github.com/luxfi/consensus/engine/chain"
|
|
"github.com/luxfi/database"
|
|
"github.com/luxfi/ids"
|
|
"github.com/luxfi/node/vms/example/xsvm/state"
|
|
"github.com/luxfi/runtime"
|
|
|
|
xsblock "github.com/luxfi/node/vms/example/xsvm/block"
|
|
)
|
|
|
|
var _ Chain = (*chain)(nil)
|
|
|
|
type Chain interface {
|
|
LastAccepted() ids.ID
|
|
SetChainState(state enginechain.Engine)
|
|
GetBlock(blkID ids.ID) (Block, error)
|
|
|
|
// Creates a fully verifiable and executable block, which can be processed
|
|
// by the consensus engine, from a stateless block.
|
|
NewBlock(blk *xsblock.Stateless) (Block, error)
|
|
}
|
|
|
|
type chain struct {
|
|
chainRuntime *runtime.Runtime
|
|
acceptedState database.Database
|
|
|
|
// chain state as driven by the consensus engine
|
|
chainState enginechain.Engine
|
|
|
|
lastAcceptedID ids.ID
|
|
verifiedBlocks map[ids.ID]*block
|
|
}
|
|
|
|
func New(rt *runtime.Runtime, db database.Database) (Chain, error) {
|
|
// Load the last accepted block data. For a newly created VM, this will be
|
|
// the genesis. It is assumed the genesis was processed and stored
|
|
// previously during VM initialization.
|
|
lastAcceptedID, err := state.GetLastAccepted(db)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
c := &chain{
|
|
chainRuntime: rt,
|
|
acceptedState: db,
|
|
lastAcceptedID: lastAcceptedID,
|
|
}
|
|
|
|
lastAccepted, err := c.getBlock(lastAcceptedID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
c.verifiedBlocks = map[ids.ID]*block{
|
|
lastAcceptedID: lastAccepted,
|
|
}
|
|
return c, err
|
|
}
|
|
|
|
func (c *chain) LastAccepted() ids.ID {
|
|
return c.lastAcceptedID
|
|
}
|
|
|
|
func (c *chain) SetChainState(state enginechain.Engine) {
|
|
c.chainState = state
|
|
}
|
|
|
|
func (c *chain) GetBlock(blkID ids.ID) (Block, error) {
|
|
return c.getBlock(blkID)
|
|
}
|
|
|
|
func (c *chain) NewBlock(blk *xsblock.Stateless) (Block, error) {
|
|
blkID, err := blk.ID()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if blk, exists := c.verifiedBlocks[blkID]; exists {
|
|
return blk, nil
|
|
}
|
|
|
|
blkBytes, err := blk.Marshal()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &block{
|
|
Stateless: blk,
|
|
chain: c,
|
|
id: blkID,
|
|
bytes: blkBytes,
|
|
}, nil
|
|
}
|
|
|
|
func (c *chain) getBlock(blkID ids.ID) (*block, error) {
|
|
if blk, exists := c.verifiedBlocks[blkID]; exists {
|
|
return blk, nil
|
|
}
|
|
|
|
blkBytes, err := state.GetBlock(c.acceptedState, blkID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
stateless, err := xsblock.Parse(blkBytes)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &block{
|
|
Stateless: stateless,
|
|
chain: c,
|
|
id: blkID,
|
|
bytes: blkBytes,
|
|
}, nil
|
|
}
|