ai

type Agent[T ConsensusData] struct {
	// contains filtered or unexported fields
}

type AnyDecision struct {
	Type      string      `json:"type"`
	Decision  interface{} `json:"decision"`
	Timestamp time.Time   `json:"timestamp"`
}

type BasicModel interface {
	// Decide takes context and returns a decision
	Decide(ctx context.Context, question string, data map[string]interface{}) (*SimpleDecision, error)
}

type BlockAgent struct {
	*Agent[BlockData]
}

type BlockData struct {
	Height       uint64    `json:"height"`
	Hash         string    `json:"hash"`
	Transactions []string  `json:"transactions"`
	Timestamp    time.Time `json:"timestamp"`
	Validator    string    `json:"validator"`
}

type BlockFeatureExtractor struct{}

type BridgeChain struct {
	ChainID   string    `json:"chain_id"`
	Name      string    `json:"name"`
	RPC       string    `json:"rpc"`
	Contract  string    `json:"contract"`
	Currency  string    `json:"currency"`
	Decimals  int       `json:"decimals"`
	LastBlock uint64    `json:"last_block"`
	LastSync  time.Time `json:"last_sync"`
	Active    bool      `json:"active"`
}

type BridgeTransaction struct {
	ID            string    `json:"id"`
	FromChain     string    `json:"from_chain"`
	ToChain       string    `json:"to_chain"`
	Amount        *big.Int  `json:"amount"`
	Sender        string    `json:"sender"`
	Recipient     string    `json:"recipient"`
	SourceTxHash  string    `json:"source_tx_hash"`
	TargetTxHash  string    `json:"target_tx_hash"`
	Status        TxStatus  `json:"status"`
	CreatedAt     time.Time `json:"created_at"`
	CompletedAt   time.Time `json:"completed_at,omitempty"`
	Confirmations int       `json:"confirmations"`
}

type Builder interface {
	// Fluent interface for composition
	WithInference(moduleID string, config interface{}) Builder
	WithDecision(moduleID string, config interface{}) Builder
	WithLearning(moduleID string, config interface{}) Builder
	WithCoordination(moduleID string, config interface{}) Builder

	// Build the final engine
	Build() (Engine, error)
}

type ChainConfig struct {
	ChainID        string   `json:"chain_id"`
	Name           string   `json:"name"`
	NativeCurrency string   `json:"native_currency"`
	BridgeContract string   `json:"bridge_contract"`
	MinPayment     *big.Int `json:"min_payment"`
	GasMultiplier  float64  `json:"gas_multiplier"`
	Enabled        bool     `json:"enabled"`
}

type ChainState struct {
	Height      uint64                 `json:"height"`
	Hash        string                 `json:"hash"`
	Validators  []string               `json:"validators"`
	Performance *Performance           `json:"performance"`
	Issues      []string               `json:"issues"`
	LastSeen    time.Time              `json:"last_seen"`
	Metadata    map[string]interface{} `json:"metadata"`
}

type ComputeJob struct {
	ID            string                 `json:"id"`
	SourceChain   string                 `json:"source_chain"`
	Requester     string                 `json:"requester"`
	JobType       string                 `json:"job_type"` // "inference", "training", "consensus"
	Data          map[string]interface{} `json:"data"`
	ComputeUnits  *big.Int               `json:"compute_units"`
	PaymentAmount *big.Int               `json:"payment_amount"`
	PaymentTxHash string                 `json:"payment_tx_hash"`
	Status        JobStatus              `json:"status"`
	CreatedAt     time.Time              `json:"created_at"`
	StartedAt     time.Time              `json:"started_at,omitempty"`
	CompletedAt   time.Time              `json:"completed_at,omitempty"`
	Result        []byte                 `json:"result,omitempty"`
	ErrorMessage  string                 `json:"error_message,omitempty"`
}

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

type ComputeRequest struct {
	SourceChain string                 `json:"source_chain"`
	Requester   string                 `json:"requester"`
	JobType     string                 `json:"job_type"`
	Data        map[string]interface{} `json:"data"`
	MaxPayment  *big.Int               `json:"max_payment"`
}

type Config struct {
	// Module-specific config
	Modules map[string]interface{} `json:"modules"`

	// Global settings
	Global map[string]interface{} `json:"global"`
}

type ConsensusData interface {
	BlockData | TransactionData | UpgradeData | SecurityData | DisputeData
}

type ConsensusPhase string

type ConsensusState[T ConsensusData] struct {
	Round       uint64                        `json:"round"`
	Phase       ConsensusPhase                `json:"phase"`
	Proposals   map[string]*Proposal[T]       `json:"proposals"`
	Votes       map[string]map[string]float64 `json:"votes"` // proposal -> node -> weight
	Finalized   *Decision[T]                  `json:"finalized,omitempty"`
	StartedAt   time.Time                     `json:"started_at"`
	FinalizedAt time.Time                     `json:"finalized_at,omitempty"`
}

type Decision[T ConsensusData] struct {
	ID           string                 `json:"id"`
	Action       string                 `json:"action"`
	Data         T                      `json:"data"`
	Confidence   float64                `json:"confidence"`
	Reasoning    string                 `json:"reasoning"`
	Alternatives []string               `json:"alternatives,omitempty"`
	Context      map[string]interface{} `json:"context"`
	Timestamp    time.Time              `json:"timestamp"`

	// Consensus metadata
	ProposerID    string  `json:"proposer_id"`
	VoteCount     int     `json:"vote_count"`
	WeightedVotes float64 `json:"weighted_votes"`
}

type Dispute struct {
	ID         string    `json:"id"`
	Type       string    `json:"type"` // "fork", "validator", "upgrade", "security"
	ChainID    string    `json:"chain_id"`
	Parties    []string  `json:"parties"`
	Evidence   []string  `json:"evidence"`
	Status     string    `json:"status"` // "open", "resolved", "escalated"
	Resolution string    `json:"resolution,omitempty"`
	CreatedAt  time.Time `json:"created_at"`
	ResolvedAt time.Time `json:"resolved_at,omitempty"`
}

type DisputeAgent struct {
	*Agent[DisputeData]
}

type DisputeData struct {
	Type      string    `json:"type"`
	Parties   []string  `json:"parties"`
	Evidence  []string  `json:"evidence"`
	ChainID   string    `json:"chain_id"`
	Timestamp time.Time `json:"timestamp"`
}

type DisputeFeatureExtractor struct{}

type Engine interface {
	// Module management - exactly one way
	AddModule(module Module) error
	RemoveModule(id string) error
	GetModule(id string) Module
	ListModules() []Module

	// Processing pipeline - exactly one way
	Process(ctx context.Context, input Input) (Output, error)

	// Configuration - exactly one way
	Configure(config Config) error
}

type Evidence[T ConsensusData] struct {
	Data      T         `json:"data"`
	NodeID    string    `json:"node_id"`
	Weight    float64   `json:"weight"`
	Timestamp time.Time `json:"timestamp"`
}

type FeatureExtractor[T ConsensusData] interface {
	Extract(data T) map[string]float64
	Names() []string
}

type Hallucination[T ConsensusData] struct {
	ID         string                 `json:"id"`
	ModelID    string                 `json:"model_id"`
	State      map[string]interface{} `json:"state"`
	Confidence float64                `json:"confidence"`
	NodeVotes  map[string]float64     `json:"node_votes"`
	UsageCount int64                  `json:"usage_count"`
	CreatedAt  time.Time              `json:"created_at"`
	UpdatedAt  time.Time              `json:"updated_at"`
	Evidence   []Evidence[T]          `json:"evidence"`
}

type Input struct {
	Type    InputType              `json:"type"`
	Data    map[string]interface{} `json:"data"`
	Context map[string]interface{} `json:"context,omitempty"`
}

type InputType string

type IntegrationConfig struct {
	NodeID       string            `json:"node_id"`
	Enabled      bool              `json:"enabled"`
	ModelPaths   map[string]string `json:"model_paths"`
	SyncInterval time.Duration     `json:"sync_interval"`
	LogLevel     string            `json:"log_level"`

	// Cross-chain marketplace config
	EnableMarketplace bool           `json:"enable_marketplace"`
	SupportedChains   []*ChainConfig `json:"supported_chains"`
	PricePerUnit      int64          `json:"price_per_unit"`
	MaxComputeUnits   int64          `json:"max_compute_units"`
}

type JobStatus string

type Logger interface {
	Info(msg string, fields ...interface{})
	Warn(msg string, fields ...interface{})
	Error(msg string, fields ...interface{})
}

type Model[T ConsensusData] interface {
	// Core decision making
	Decide(ctx context.Context, input T, context map[string]interface{}) (*Decision[T], error)

	// Training and adaptation
	Learn(examples []TrainingExample[T]) error
	UpdateWeights(gradients []float64) error
	GetState() map[string]interface{}
	LoadState(state map[string]interface{}) error

	// Consensus integration
	ProposeDecision(ctx context.Context, input T) (*Proposal[T], error)
	ValidateProposal(proposal *Proposal[T]) (float64, error) // returns confidence
}

type Module interface {
	// Identity
	ID() string
	Type() ModuleType

	// Lifecycle - exactly one way to manage state
	Initialize(ctx context.Context, config Config) error
	Start(ctx context.Context) error
	Stop(ctx context.Context) error

	// Processing - exactly one way to process data
	Process(ctx context.Context, input Input) (Output, error)
}

type ModuleType string

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

type Output struct {
	Type     OutputType             `json:"type"`
	Data     map[string]interface{} `json:"data"`
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type OutputType string

type PaymentProof struct {
	TxHash      string    `json:"tx_hash"`
	Amount      *big.Int  `json:"amount"`
	FromChain   string    `json:"from_chain"`
	ToChain     string    `json:"to_chain"`
	Sender      string    `json:"sender"`
	Recipient   string    `json:"recipient"`
	BlockHeight uint64    `json:"block_height"`
	Timestamp   time.Time `json:"timestamp"`
	Verified    bool      `json:"verified"`
}

type Performance struct {
	TPS           float64 `json:"tps"`
	Latency       int64   `json:"latency_ms"`
	FaultRate     float64 `json:"fault_rate"`
	UpgradeNeeded bool    `json:"upgrade_needed"`
}

type Proposal[T ConsensusData] struct {
	ID         string        `json:"id"`
	NodeID     string        `json:"node_id"`
	Decision   *Decision[T]  `json:"decision"`
	Evidence   []Evidence[T] `json:"evidence"`
	Weight     float64       `json:"weight"`
	Confidence float64       `json:"confidence"`
	Timestamp  time.Time     `json:"timestamp"`
}

type SecurityAgent struct {
	*Agent[SecurityData]
}

type SecurityData struct {
	ThreatLevel string    `json:"threat_level"`
	Threats     []string  `json:"threats"`
	NodeID      string    `json:"node_id"`
	Evidence    []string  `json:"evidence"`
	Timestamp   time.Time `json:"timestamp"`
}

type SecurityFeatureExtractor struct{}

type SecurityState struct {
	ThreatLevel   string            `json:"threat_level"` // "low", "medium", "high", "critical"
	ActiveThreats []string          `json:"active_threats"`
	Mitigations   map[string]string `json:"mitigations"`
	LastScan      time.Time         `json:"last_scan"`
}

type SharedMemory[T ConsensusData] struct {
	// contains filtered or unexported fields
}

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

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

type SimpleDecision struct {
	Action     string                 `json:"action"`
	Confidence float64                `json:"confidence"`
	Reasoning  string                 `json:"reasoning"`
	Data       map[string]interface{} `json:"data,omitempty"`
	Timestamp  time.Time              `json:"timestamp"`
}

type SimpleLogger struct{}

type SimpleModel[T ConsensusData] struct {
	// contains filtered or unexported fields
}

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

type TrainingExample[T ConsensusData] struct {
	Input    T                      `json:"input"`
	Output   Decision[T]            `json:"output"`
	Feedback float64                `json:"feedback"` // -1 to +1
	NodeID   string                 `json:"node_id"`
	Weight   float64                `json:"weight"`
	Context  map[string]interface{} `json:"context"`
}

type TransactionData struct {
	Hash      string                 `json:"hash"`
	From      string                 `json:"from"`
	To        string                 `json:"to"`
	Amount    uint64                 `json:"amount"`
	Fee       uint64                 `json:"fee"`
	Data      map[string]interface{} `json:"data"`
	Timestamp time.Time              `json:"timestamp"`
}

type TransactionFeatureExtractor struct{}

type TxStatus string

type Upgrade struct {
	ID          string                 `json:"id"`
	Type        string                 `json:"type"` // "protocol", "vm", "consensus", "security"
	ChainID     string                 `json:"chain_id"`
	Version     string                 `json:"version"`
	Changes     []string               `json:"changes"`
	Risk        string                 `json:"risk"`   // "low", "medium", "high", "critical"
	Status      string                 `json:"status"` // "proposed", "testing", "approved", "deployed"
	TestResults map[string]interface{} `json:"test_results,omitempty"`
	CreatedAt   time.Time              `json:"created_at"`
	DeployedAt  time.Time              `json:"deployed_at,omitempty"`
}

type UpgradeAgent struct {
	*Agent[UpgradeData]
}

type UpgradeData struct {
	Version     string    `json:"version"`
	Changes     []string  `json:"changes"`
	Risk        string    `json:"risk"`
	TestResults []string  `json:"test_results"`
	Timestamp   time.Time `json:"timestamp"`
}

type UpgradeFeatureExtractor struct{}

type XChainBridge interface {
	// Transfer funds from source chain to pay for compute
	TransferPayment(ctx context.Context, sourceChain, targetChain string, amount *big.Int, recipient string) error

	// Verify payment was received
	VerifyPayment(ctx context.Context, txHash string, expectedAmount *big.Int) (*PaymentProof, error)

	// Get exchange rate between chains
	GetExchangeRate(ctx context.Context, fromChain, toChain string) (*big.Int, error)

	// Submit computation result back to requesting chain
	SubmitResult(ctx context.Context, targetChain string, jobID string, result []byte) error
}