config

type AirdropConfig struct {
	Enabled         bool
	SnapshotDate    string
	ConversionRatio float64 // Legacy token to LUX conversion ratio
	VestingPeriod   uint64  // in seconds
	ClaimPeriod     uint64  // in seconds
}

type ChainConfig struct {
	Name    string          // Chain name (e.g., "zoo", "mychain")
	Genesis json.RawMessage // Genesis JSON
	Config  json.RawMessage // Chain config JSON (eth APIs, etc.)
	Upgrade json.RawMessage // Upgrade config JSON
}

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

type ChainStakeRequirement struct {
	ChainID               string
	MinimumStake          uint64
	RequiresSpecialAccess bool   // e.g., B-chain bridge validators
	AccessRequirements    string // Description of special requirements
}

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

type GPUConfig struct {
	// Enabled controls whether GPU acceleration is used
	Enabled bool

	// Backend specifies which GPU backend to use: "auto", "metal", "cuda", "cpu"
	Backend string

	// DeviceIndex specifies which GPU device to use when multiple are available
	DeviceIndex int

	// LogLevel sets the GPU subsystem log level: "debug", "info", "warn", "error"
	LogLevel string
}

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

type LoaderOption func(*Loader)

type LogConfig struct {
	// Level is the minimum log level to output
	Level string `json:"level" yaml:"level" mapstructure:"level"`

	// Format is the log output format (terminal, json, plain)
	Format string `json:"format" yaml:"format" mapstructure:"format"`

	// Directory is where log files are written
	Directory string `json:"directory" yaml:"directory" mapstructure:"directory"`

	// MaxSize is the maximum size in megabytes before log rotation
	MaxSize int `json:"max-size" yaml:"max-size" mapstructure:"max-size"`

	// MaxFiles is the maximum number of old log files to retain
	MaxFiles int `json:"max-files" yaml:"max-files" mapstructure:"max-files"`

	// MaxAge is the maximum number of days to retain old log files
	MaxAge int `json:"max-age" yaml:"max-age" mapstructure:"max-age"`

	// Compress enables compression of rotated log files
	Compress bool `json:"compress" yaml:"compress" mapstructure:"compress"`

	// ShowCaller shows caller information in log entries
	ShowCaller bool `json:"show-caller" yaml:"show-caller" mapstructure:"show-caller"`

	// ShowColors enables colored output for terminal format
	ShowColors bool `json:"show-colors" yaml:"show-colors" mapstructure:"show-colors"`
}

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

type LogFormat string

type LogLevel string

type LoggerAdapter struct {
	*zap.Logger
	// contains filtered or unexported fields
}

type LuxConfig struct {
	// DataDir is the base directory for all Lux data
	DataDir string `json:"data-dir" yaml:"data-dir" mapstructure:"data-dir"`

	// PluginDir is the directory for VM plugins
	PluginDir string `json:"plugin-dir" yaml:"plugin-dir" mapstructure:"plugin-dir"`

	// Log contains logging configuration
	Log LogConfig `json:"log" yaml:"log" mapstructure:"log"`

	// Network contains network-related configuration
	Network NetworkConfig `json:"network" yaml:"network" mapstructure:"network"`

	// Node contains node-specific configuration
	Node NodeConfig `json:"node" yaml:"node" mapstructure:"node"`
}

type NFTTier struct {
	Name              string
	RequiredLUX       uint64 // Base LUX requirement with NFT
	StakingMultiplier uint32 // Reward multiplier percentage
	MaxValidators     uint32 // Max validators in this tier
}

type NetworkConfig struct {
	// ID is the network ID
	ID uint32 `json:"id" yaml:"id" mapstructure:"id"`

	// Name is the network name (mainnet, testnet, local)
	Name string `json:"name" yaml:"name" mapstructure:"name"`

	// APIEndpoint is the primary API endpoint
	APIEndpoint string `json:"api-endpoint" yaml:"api-endpoint" mapstructure:"api-endpoint"`
}

type NodeConfig struct {
	// HTTPPort is the HTTP API port
	HTTPPort int `json:"http-port" yaml:"http-port" mapstructure:"http-port"`

	// StakingPort is the staking/P2P port
	StakingPort int `json:"staking-port" yaml:"staking-port" mapstructure:"staking-port"`

	// DBType is the database backend type
	DBType string `json:"db-type" yaml:"db-type" mapstructure:"db-type"`
}

type Paths struct {
	// BaseDir is the root data directory (default: ~/.lux)
	BaseDir string
}

type PluginInfo struct {
	// VMID is the VM identifier (hash)
	VMID string `json:"vm_id"`

	// Name is the human-readable name
	Name string `json:"name"`

	// Version is the plugin version
	Version string `json:"version"`

	// Path is the full path to the plugin binary
	Path string `json:"path"`

	// Description is an optional description
	Description string `json:"description"`

	// Installed indicates if the plugin is installed
	Installed bool `json:"installed"`

	// Size is the file size in bytes
	Size int64 `json:"size"`

	// ModTime is the last modification time
	ModTime time.Time `json:"mod_time"`
}

type PluginManager interface {
	// GetPluginDir returns the resolved plugin directory
	GetPluginDir() string

	// List returns all installed plugins
	List(ctx context.Context) ([]PluginInfo, error)

	// Get returns info about a specific plugin
	Get(ctx context.Context, vmID string) (*PluginInfo, error)

	// Install installs a plugin from a source path
	Install(ctx context.Context, source string, vmID string) error

	// Uninstall removes a plugin
	Uninstall(ctx context.Context, vmID string) error

	// GetPath returns the full path for a plugin binary
	GetPath(vmID string) string

	// Exists checks if a plugin is installed
	Exists(vmID string) bool

	// EnsureDir ensures the plugin directory exists
	EnsureDir() error
}

type PluginManifest struct {
	// Name is the package name (e.g., "evm")
	Name string `json:"name"`

	// Org is the organization/username (e.g., "luxfi")
	Org string `json:"org"`

	// Version is the semantic version (e.g., "v1.0.0")
	Version string `json:"version"`

	// VMID is the computed VM identifier hash
	VMID string `json:"vmid"`

	// VMName is the canonical VM name used to compute VMID
	VMName string `json:"vm_name,omitempty"`

	// Aliases are alternative names for this VM
	Aliases []string `json:"aliases,omitempty"`

	// Binary is the executable filename
	Binary string `json:"binary"`

	// Description is a human-readable description
	Description string `json:"description,omitempty"`

	// Repository is the source repository URL
	Repository string `json:"repository,omitempty"`

	// InstalledAt is when the plugin was installed
	InstalledAt time.Time `json:"installed_at"`

	// Size is the binary size in bytes
	Size int64 `json:"size,omitempty"`
}

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

type PluginRegistry struct {
	// Plugins maps "org/name" to list of installed versions
	Plugins map[string][]string `json:"plugins"`

	// Active maps VMID to active package reference
	Active map[string]string `json:"active"`

	// UpdatedAt is when the registry was last modified
	UpdatedAt time.Time `json:"updated_at"`
}

type StakingConfig struct {
	// Minimum stake: 1M LUX for validators
	MinimumValidatorStake uint64

	// NFT staking tiers
	NFTStakingEnabled bool
	NFTTiers          []NFTTier

	// Delegation parameters
	MinimumDelegatorStake uint64
	MaxDelegationRatio    uint32

	// Chain-specific validator requirements
	ChainValidatorRequirements map[string]ChainStakeRequirement

	// Combined staking (NFT + delegation + staked) to reach minimum
	AllowCombinedStaking bool
}

type TokenomicsConfig struct {
	// Total supply: 2T tokens
	TotalSupply uint64

	// Airdrop configuration for legacy token holders
	AirdropConfig AirdropConfig

	// Staking requirements
	StakingConfig StakingConfig

	// Chain-specific allocations
	ChainAllocations map[string]uint64
}