registry

type Asset struct {
	// NetworkID is the Lux network this asset lives on (1 mainnet, 2 testnet, ...).
	NetworkID uint32 `json:"networkID"`
	// ChainID is the SOURCE chain id: the C-Chain id for EVM_NATIVE/ERC20, the
	// UTXO source-chain id (X-Chain) for UTXO.
	ChainID ids.ID `json:"chainID"`
	// Kind is the asset class (EVM_NATIVE | ERC20 | UTXO).
	Kind AssetKind `json:"assetKind"`
	// CanonicalRef is the on-chain reference bytes: the 20-byte ERC-20 address, the
	// 20-byte native marker, or the 32-byte UTXO assetID. Hex-encoded in JSON.
	CanonicalRef Bytes `json:"canonicalRef"`
	// Decimals is the asset's on-chain decimal precision (ERC-20 decimals(),
	// native/UTXO denomination). Verified against chain state for ERC-20.
	Decimals uint8 `json:"decimals"`
	// Symbol/Name are display metadata. They are NOT identity (the AssetID does not
	// hash them) and they are NOT a ticker-id — an asset is keyed by AssetID, never
	// by Symbol. They exist for the UI only.
	Symbol string `json:"symbol"`
	Name   string `json:"name"`
	// Enabled gates whether this asset (and markets over it) may trade. A disabled
	// asset stays registered (auditable) but admits no markets.
	Enabled bool `json:"enabled"`
	// RiskTier is the operator risk classification (caps input, not admissibility).
	RiskTier RiskTier `json:"riskTier"`
}

type AssetKind uint8

type Bytes []byte

type CChainConfirmer interface {
	ConfirmCChain(networkID uint32, evmChainID uint64, cChainID ids.ID) error
}

type ChainVerifier interface {
	// VerifyERC20 confirms a contract exists at addr on the given C-Chain of the
	// given network (code length > 0) and returns its on-chain decimals(). An error
	// means the token is not real there (no code, wrong chain, RPC failure) and the
	// asset MUST be refused.
	VerifyERC20(networkID uint32, cChainID ids.ID, addr []byte) (decimals uint8, err error)
	// VerifyEVMNative confirms the C-Chain itself is the expected native chain for
	// the network (chainID matches) and returns the native decimals.
	VerifyEVMNative(networkID uint32, cChainID ids.ID) (decimals uint8, err error)
	// VerifyUTXOAsset confirms a UTXO assetID exists on the given source chain of
	// the given network and returns its denomination (decimals). An error means the
	// asset does not exist there and MUST be refused.
	VerifyUTXOAsset(networkID uint32, sourceChainID ids.ID, assetID ids.ID) (decimals uint8, err error)
}

type ConsensusMode uint8

type DexAssetPolicy struct {
	// AllowSyntheticAssets, AllowSyntheticMarkets, AllowMockLiquidity default false.
	// On a value-bearing network (mainnet/testnet) any true value fails startup. On
	// a dev network a true value is permitted (developer opt-in) but is still subject
	// to the forbidden-reference scan (Liquidity is never allowed, anywhere).
	AllowSyntheticAssets  bool `json:"dexAllowSyntheticAssets"`
	AllowSyntheticMarkets bool `json:"dexAllowSyntheticMarkets"`
	AllowMockLiquidity    bool `json:"dexAllowMockLiquidity"`
	// AllowedAssetKinds is the active dexAllowedAssetKinds set. Empty is treated as
	// the canonical default {EVM_NATIVE, ERC20, UTXO}; an explicit set may only ever
	// be a SUBSET of those three — any other token is rejected by ParseAssetKind.
	AllowedAssetKinds []AssetKind `json:"dexAllowedAssetKinds"`
}

type LaunchAssertions struct {
	// CapsOn asserts per-asset / per-market notional caps are enforced (bounding the
	// blast radius of a crash-fault or operator error during the CFT launch window).
	CapsOn bool
	// RealAssetsOnly asserts the asset registry admits only EVM_NATIVE|ERC20|UTXO and
	// no synthetic asset/market/liquidity is enabled (the property this whole package
	// enforces).
	RealAssetsOnly bool
	// HaltReady asserts the halt control is wired and reachable, so the chain can be
	// stopped fast if the honest-validator assumption is violated.
	HaltReady bool
}

type Manifest struct {
	// Network is the canonical network name this manifest applies to. It must match
	// the deploy target; a mismatch is a hard error (you cannot ship the testnet
	// manifest to mainnet).
	Network string `json:"network"`
	// NetworkID is the Lux networkID (1 mainnet, 2 testnet, ...) every asset/market
	// in this manifest must declare. A per-entry networkID that disagrees is rejected.
	NetworkID uint32 `json:"networkID"`
	// EVMChainID is the C-Chain's EVM chainID (eth_chainId): 96369 mainnet, 96368
	// testnet, 96370 devnet, 1337 localnet. It is the AUTHORITATIVE, RPC-checkable
	// identity of the C-Chain — the CI validator confirms the target RPC's
	// eth_chainId equals this before admitting any ERC-20/native entry, so a manifest
	// can never be validated against the wrong chain.
	EVMChainID uint64 `json:"evmChainID"`
	// CChainID is the canonical C-Chain CONSENSUS id (the P-Chain blockchain id, an
	// ids.ID) used in the AssetID preimage so a derived AssetID lives in the same
	// identity space as the on-chain atomic objects. It is network-specific and is
	// confirmed by the CI validator against the live P-Chain (platform.getBlockchains)
	// — the validator REFUSES to proceed if the manifest's CChainID is not the C-Chain
	// the target net actually runs. EVM_NATIVE/ERC20 entries are rooted here; an entry
	// whose chainID disagrees is rejected (so a manifest cannot point an "ERC20" at a
	// non-C chain).
	CChainID ids.ID `json:"cChainID"`
	// ChainLabels maps a source chain id (hex) to its human label, consumed by the
	// forbidden-reference deny-scan (so the off-network-universe check has labels to
	// test). Optional; an unlabeled chain simply has no white-label name to match.
	ChainLabels map[string]string `json:"chainLabels,omitempty"`
	// Assets and Markets are the declared real entries.
	Assets  []Asset  `json:"assets"`
	Markets []Market `json:"markets"`
}

type Market struct {
	// NetworkID must match both assets' networks (a market does not span networks).
	NetworkID uint32 `json:"networkID"`
	// BaseAssetID / QuoteAssetID are canonical AssetIDs of registered assets.
	BaseAssetID  ids.ID `json:"baseAssetID"`
	QuoteAssetID ids.ID `json:"quoteAssetID"`
	// VenueConfig is the canonical serialization of the venue parameters (tick, lot,
	// fee tier) that distinguish two venues on the same pair. Hex in JSON.
	VenueConfig Bytes `json:"venueConfig"`
	// Enabled gates whether the market trades. A disabled market is still pinned to
	// real assets; it simply admits no orders.
	Enabled bool `json:"enabled"`
}

type NetworkClass uint8

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

type RiskTier uint8

type RuntimeVerifier struct {
	// NetworkID is the node's running network id (runtime.Runtime.NetworkID).
	NetworkID uint32
	// CChainID is the node's running C-Chain consensus id (runtime.Runtime.CChainID).
	// EVM_NATIVE / ERC20 assets must be rooted here.
	CChainID ids.ID
	// XChainID is the node's running X-Chain id (runtime.Runtime.XChainID). UTXO assets
	// are accepted only from a UTXO source chain the node actually runs; when XChainID
	// is set, a UTXO asset rooted off it is refused.
	XChainID ids.ID
	// contains filtered or unexported fields
}

type ValueModeStatus struct {
	Mode   ConsensusMode
	Status string // NoByzantineFinalityClaim for HONEST_VALIDATOR_LABELED, "" for QUORUM_FINALITY
}