types

type AdaptiveConsensus struct {
	Params         map[int]*ConsensusParams
	Metrics        *StateMetrics
	UpdateInterval time.Duration
	StopChan       chan struct{}
	Mu             sync.RWMutex
}

type AddUTXORequest struct {
	UTXO UTXO
}

type BalanceNotifier interface {
	SendBalanceUpdate(address string) error
	NotifyBalanceUpdate(address string, balance amount.Amount)
}

type BalanceUpdateRequest struct {
	Address string
	Retries int
}

type BeaconChain struct {
	// Blocks specific to the Beacon Chain
	Blocks   []*Block
	Mu       sync.RWMutex
	Database Store // Dedicated DB for beacon chain

}

type Block struct {
	Index              int64            `cbor:"1,keyasint"`
	Timestamp          int64            `cbor:"2,keyasint"`
	PrevHash           hash.Hash        `cbor:"4,keyasint"`
	TransactionsRoot   []byte           `cbor:"4,keyasint"`
	Hash               hash.Hash        `cbor:"5,keyasint,omitempty"`
	Transactions       []*Transaction   `cbor:"6,keyasint"`
	Data               string           `cbor:"7,keyasint,omitempty"`
	ValidatorPublicKey crypto.PublicKey `cbor:"8,keyasint"`
	Signature          crypto.Signature `cbor:"9,keyasint,omitempty"`
	Salt               []byte           `cbor:"10,keyasint"`
	Validator          string           `cbor:"11,keyasint"`
}

type Blockchain struct {
	// Blocks holds the sequence of blocks that constitute the blockchain. Each block contains
	// a set of transactions and is linked to the previous block, forming the chain.
	Blocks []*Block

	// Genesis points to the first block in the blockchain, known as the Genesis block. This block
	// is the foundation of the blockchain, with no preceding block.
	Genesis *Block

	// Adding transactions to the pending transactions pool
	PendingTransactions []*thrylos.Transaction

	// Stakeholders maps validator addresses to their respective stakes in the network. This is
	// used in proof-of-stake (PoS) consensus mechanisms to determine validators' rights to create
	// new blocks based on the size of their stake
	Stakeholders map[string]int64 // Maps validator addresses to their respective stakes

	// UTXOs tracks unspent transaction outputs, which represent the current state of ownership
	// of the blockchain's assets. It is a key component in preventing double spending.
	UTXOs map[string][]*thrylos.UTXO

	// Forks captures any divergences in the blockchain, where two or more blocks are found to
	// have the same predecessor. Forks are resolved through mechanisms that ensure consensus
	// on a single chain.
	Forks []*Fork

	// Mu provides concurrency control to ensure that operations on the blockchain are thread-safe,
	// preventing race conditions and ensuring data integrity.
	Mu sync.RWMutex

	// lastTimestamp records the timestamp of the last added block. This is used to ensure that
	// blocks are added in chronological order, preserving the integrity of the blockchain's timeline.
	LastTimestamp int64

	// Database provides an abstraction over the underlying database technology used to persist
	// blockchain data, facilitating operations like adding blocks and retrieving blockchain state
	Database Store // Updated the type to interface

	PublicKeyMap map[string]*crypto.PublicKey // To store public keys

	GenesisAccount crypto.PrivateKey // Add this to store the genesis account address

	ConsensusManager *ConsensusManager

	ActiveValidators []string

	NextValidatorIndex int

	MinStakeForValidator *big.Int

	OnNewBlock func(*Block) // Callback function for when a new block is added

	ValidatorKeys          ValidatorKeyStore // Changed from *ValidatorKeyStore to ValidatorKeyStore
	TestMode               bool
	OnTransactionProcessed func(*thrylos.Transaction)
	OnBalanceUpdate        func(address string, balance int64)

	StateManager *StateManager

	StateNetwork   NetworkInterface
	StakingService *StakingService

	TransactionPropagator *TransactionPropagator

	LocalShardID ShardID
	ShardStates  map[ShardID]*ChainState

	Beacon           *BeaconChain
	GlobalMessageBus MessageBusInterface
	Libp2pManager    NetworkInterface
	AppConfig        *config.Config
}

type BlockchainConfig struct {
	DataDir           string
	AESKey            []byte
	GenesisAccount    crypto.PrivateKey
	TestMode          bool
	DisableBackground bool
	StateManager      *StateManager
}

type BlockchainInterface interface {
	GetTotalSupply() int64
	IsActiveValidator(address string) bool
	UpdateActiveValidators(count int)
	GetValidatorPublicKey(validator string) (*mldsa44.PublicKey, error)
	RetrievePublicKey(validator string) ([]byte, error)
	GetMinStakeForValidator() *big.Int
	Stakeholders() map[string]int64
	GetActiveValidators() []string // Add this method to the interface

}

type ChainState struct {
	ShardID        ShardID // Identifier for this shard
	TotalNumShards int     // NEW: Total number of shards in the network
	Blocks         []*Block
	Genesis        *Block

	// PendingTransactions: Will be moved to a shard-specific TxPool.
	PendingTransactions    []*thrylos.Transaction
	Stakeholders           map[string]int64
	UTXOs                  map[string][]*thrylos.UTXO // Still uses *thrylos.UTXO internally
	Forks                  []*Fork                    // Forks within this specific shard chain
	Mu                     sync.RWMutex               // This mutex protects only THIS shard's state
	LastTimestamp          int64
	Database               Store // Store interface, but implementation will be shard-aware
	PublicKeyMap           map[string]*crypto.PublicKey
	GenesisAccount         crypto.PrivateKey
	ConsensusManager       *ConsensusManager
	ActiveValidators       []string
	NextValidatorIndex     int
	MinStakeForValidator   *big.Int
	OnNewBlock             func(*Block)
	ValidatorKeys          ValidatorKeyStore
	TestMode               bool
	OnTransactionProcessed func(*thrylos.Transaction)
	OnBalanceUpdate        func(address string, balance int64)
	StateManager           *StateManager
	StateNetwork           NetworkInterface
	StakingService         *StakingService
	TransactionPropagator  *TransactionPropagator
}

type ConnectionStatus struct {
	Address         string    `json:"address"`
	Connected       bool      `json:"connected"`
	LastConnected   time.Time `json:"lastConnected"`
	ReconnectCount  int       `json:"reconnectCount"`
	QueueSize       int       `json:"queueSize"`
	IsReconnecting  bool      `json:"isReconnecting"`
	LastMessageSent time.Time `json:"lastMessageSent"`
}

type ConsensusManager struct {
	Blockchain       BlockchainInterface
	CurrentBlockTime time.Duration
	PredictionModel  *PredictionModel
	// contains filtered or unexported fields
}

type ConsensusParams struct {
	BlockSize        int
	ConfirmationTime time.Duration
	MinValidators    int
	Threshold        float64
}

type DAGTipsResponse struct {
	Tips  []string
	Error error
}

type Fork struct {
	Index  int
	Blocks []*Block
}

type FundAddressRequest struct {
	Address string
	Amount  amount.Amount // Change from int64 to amount.Amount
}

type IsCounterNodeResponse struct {
	IsCounter bool
	Error     error
}

type Message struct {
	Type       MessageType
	Data       interface{}
	ResponseCh chan Response
}

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

type MessageBusInterface interface {
	Subscribe(msgType MessageType, ch chan Message) // Use chan Message directly
	Unsubscribe(msgType MessageType, ch chan Message)
	Publish(msg Message)
	Close()
}

type MessageChannel = chan Message // Using type alias for clarity

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

type MessageType string

type NetworkInterface interface {
	SendMessage(nodeAddress string, message []byte) error
	BroadcastMessage(message []byte) error
	GetPeerAddresses() []string
	IsConnected(nodeAddress string) bool
	AddPeer(address string)
	RemovePeer(address string)
}

type NetworkMessage struct {
	Type      string      `json:"type"`
	Data      interface{} `json:"data"`
	Timestamp time.Time   `json:"timestamp"`
}

type PendingBalanceUpdate struct {
	Address   string
	Balance   int64
	Timestamp time.Time
}

type PendingTransactionBatchRequest struct {
	BatchSize int
}

type PendingTransactionBatchResponse struct {
	Transactions []*Transaction
	Error        error
}

type PendingTransactionCountResponse struct {
	Count int
	Error error
}

type PredictionModel struct {
	ExpectedTransactionVolume int
	ExpectedNodeCount         int
}

type RelocationCandidate struct {
	Address     string
	AccessCount int64
	FromShard   int
	ToShard     int
}

type Response struct {
	Data  interface{}
	Error error
}

type ShardID int

type ShardMetrics struct {
	AccessCount int64
	ModifyCount int64
	LoadFactor  float64
	Latency     time.Duration
	LastUpdated time.Time
	Mu          sync.RWMutex // Export the mutex
}

type ShardScaling struct {
	LoadThresholds struct {
		Split float64 // When to split a shard
		Merge float64 // When to consider merging shards
	}
	Limits struct {
		MinShards int
		MaxShards int
	}
	CooldownPeriod time.Duration // Now exported with capital C
	// contains filtered or unexported fields
}

type Stake struct {
	UserAddress            string  `json:"userAddress"`
	Amount                 int64   `json:"amount"`
	StartTime              int64   `json:"startTime"`
	LastStakeUpdateTime    int64   `json:"lastStakeUpdateTime"` // Last time stake was updated
	StakeTimeSum           float64 `json:"stakeTimeSum"`        // Accumulated stake-time (stake * duration)
	StakeTimeAverage       float64 `json:"stakeTimeAverage"`    // Moving average of stake-time
	TotalStakeRewards      float64 `json:"totalStakeRewards"`
	TotalDelegationRewards float64 `json:"totalDelegationRewards"`
	IsActive               bool    `json:"isActive"`
	ValidatorRole          bool    `json:"validatorRole"`
}

type Stakeholder struct {
	Address string
	Stake   int
}

type StakingManager interface {
	GetPoolStats() map[string]interface{}
	CreateStake(userAddress string, amount int64) (*Stake, error)
	UnstakeTokens(userAddress string, amount int64) error
	DelegateToPool(delegator string, amount int64) error
	UndelegateFromPool(delegator string, amount int64) error
	DistributeRewards() error
	GetTotalStaked() int64
	GetEffectiveInflationRate() float64
}

type StakingPool struct {
	MinStakeAmount    int64 `json:"minStakeAmount"`
	MinDelegation     int64 `json:"minDelegation"`     // Added for pool delegations
	FixedYearlyReward int64 `json:"fixedYearlyReward"` // Always 4.8M
	TotalStaked       int64 `json:"totalStaked"`       // Track total stake for monitoring
	TotalDelegated    int64 `json:"totalDelegated"`    // Added for pool delegations
	LastRewardTime    int64 `json:"lastRewardTime"`    // Last reward distribution time (in seconds)
}

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

type StateManager struct {
	Scaling *ShardScaling // Add this field (using capital S for public access)
	// contains filtered or unexported fields
}

type StateMetrics struct {
	ShardMetrics map[int]*ShardMetrics
	Mu           sync.RWMutex
}

type StateMetricsInterface interface {
	NewStateMetrics(numShards int) *StateMetrics
}

type StatePartition struct {
	ID           int
	StartAddress string
	EndAddress   string
	Balances     map[string]int64
	UTXOs        map[string]*UTXO
	LastUpdated  int64
	// contains filtered or unexported fields
}

type Store interface {
	//UTOX
	GetUTXO(addr address.Address) ([]*UTXO, error)
	AddUTXO(utxo UTXO) error
	GetAllUTXOs() (map[string][]UTXO, error)
	AddNewUTXO(ctx TransactionContext, utxo UTXO, totalNumShards int) error
	CreateAndStoreUTXO(id, txID string, index int, owner string, amount float64) error
	CreateUTXO(id, txID string, index int, address string, amount float64) (UTXO, error)
	UpdateUTXOs(inputs []UTXO, outputs []UTXO) error
	GetUTXOsForUser(address string) ([]UTXO, error)
	GetUTXOsForAddress(address string, totalNumShards int) ([]UTXO, error)
	MarkUTXOAsSpent(ctx TransactionContext, utxo UTXO, totalNumShards int) error

	RetrieveTransaction(txn *badger.Txn, transactionID string, shardID ShardID) (*Transaction, error)
	SendTransaction(fromAddress, toAddress string, amount int, privKey crypto.PrivateKey, totalNumShards int) (bool, error) // MODIFIED
	SaveTransaction(ctx TransactionContext, tx *Transaction, totalNumShards int) error                                      // MODIFIED (added ctx to align with common usage)
	GetTransaction(id string, shardID ShardID) (*Transaction, error)                                                        // MODIFIED
	ProcessTransaction(tx *Transaction, totalNumShards int) error                                                           // MODIFIED (assuming it orchestrates other sharded ops)
	AddTransaction(tx *thrylos.Transaction, shardID ShardID) error                                                          // MODIFIED (if thrylos.Transaction is stored directly per-shard)
	TransactionExists(ctx TransactionContext, txID string, shardID ShardID) (bool, error)                                   // MODIFIED
	SetTransaction(txn TransactionContext, key []byte, value []byte) error

	CommitTransaction(ctx TransactionContext) error
	BeginTransaction() (TransactionContext, error)
	RollbackTransaction(txn TransactionContext) error

	//Block
	GetLastBlock() (*Block, error)
	GetLastBlockNumber() (int, error)
	GetBlock(blockNumber uint32) (*Block, error)
	RetrieveBlock(shardID ShardID, blockNumber int) ([]byte, error) // MODIFIED: Added shardID

	GetLastBlockData(shardID ShardID) ([]byte, error)
	StoreBlock(blockData []byte, blockNumber int) error
	GetLastBlockIndex(shardID ShardID) (int, error)
	SaveBlock(blk *Block) error                                    // For Genesis
	SaveBlockWithContext(ctx TransactionContext, blk *Block) error // For AddBlockToChain
	AddToBalance(ctx TransactionContext, address string, amount int64, totalNumShards int) error
	SpendUTXO(ctx TransactionContext, utxoKey string, ownerAddress string, totalNumShards int) (amount int64, err error)

	//PublicKey
	GetPublicKey(addr address.Address) (crypto.PublicKey, error)
	SavePublicKey(pubKey crypto.PublicKey) error

	//Balance
	GetBalance(address string, utxos map[string][]UTXO) (amount.Amount, error)
	UpdateBalance(address string, balance int64) error

	// Close
	Close() error
	GetDataDir() string
	GetLockFilePath() string
}

type Subscription struct {
	Type      string                 `json:"type"`
	Addresses []string               `json:"addresses,omitempty"`
	Options   map[string]interface{} `json:"options,omitempty"`
}

type Transaction struct {
	ID               string           `cbor:"1,keyasint"`
	Timestamp        int64            `cbor:"2,keyasint"`
	Inputs           []UTXO           `cbor:"3,keyasint"`
	Outputs          []UTXO           `cbor:"4,keyasint"`
	EncryptedInputs  []byte           `cbor:"5,keyasint,omitempty"`
	EncryptedOutputs []byte           `cbor:"6,keyasint,omitempty"`
	EncryptedAESKey  []byte           `cbor:"7,keyasint"`
	PreviousTxIds    []string         `cbor:"8,keyasint"`
	SenderAddress    address.Address  `cbor:"9,keyasint"`
	SenderPublicKey  crypto.PublicKey `cbor:"10,keyasint"`
	Signature        crypto.Signature `cbor:"11,keyasint,omitempty"`
	GasFee           int              `cbor:"12,keyasint"`
	BlockHash        string           `cbor:"13,keyasint,omitempty"`
	Salt             []byte           `cbor:"14,keyasint,omitempty"`
	Status           string           `cbor:"15,keyasint,omitempty"`
}

type TransactionContext interface {
	GetUTXOs() map[string][]UTXO
	SetUTXOs(utxos map[string][]UTXO)
	IsModified(key string) bool
	SetModified(key string)
	GetTransaction() *Transaction
	Commit() error
	Rollback() error
	GetBadgerTxn() *badger.Txn // Add this new method
}

type TransactionPropagator struct {
	Blockchain BlockchainInterface
	Mu         sync.RWMutex
}

type TxPool interface {
	AddTransaction(tx *Transaction) error
	RemoveTransaction(tx *Transaction) error
	GetTransaction(txID string) (*Transaction, error)
	RemoveTransactions(txs []*Transaction) error
	GetFirstTransaction() (*Transaction, error)
	GetAllTransactions() ([]*Transaction, error)
	BroadcastTransaction(tx *Transaction) error
	GetActiveValidators(tx *Transaction) error
	Size() int
}

type UTXO struct {
	ID            string        `cbor:"1,keyasint,omitempty"`
	Index         int           `cbor:"2,keyasint"`
	TransactionID string        `cbor:"3,keyasint"`
	OwnerAddress  string        `cbor:"4,keyasint"`
	Amount        amount.Amount `cbor:"5,keyasint"`
	IsSpent       bool          `cbor:"6,keyasint"`
}

type UTXORequest struct {
	Address string
}

type UTXOResponse struct {
	UTXOs []UTXO
	Error error
}

type UpdateDAGStateRequest struct {
	TransactionID string
	State         string
}

type UpdateProcessorStateRequest struct {
	TransactionID string
	State         string
}

type UpdateStateRequest struct {
	Address string
	Balance int64
}

type UpdateTransactionStateRequest struct {
	TransactionID string
	State         string
}

type Validator interface {
	Index() int32
	PrivateKey() *crypto.PrivateKey
	PublicKey() *crypto.PublicKey
	Address() *address.Address
	Stake() amount.Amount
	Marshal() ([]byte, error)
	Unmarshal(data []byte) error
}

type ValidatorKeyStore interface {
	StoreKey(address string, key *crypto.PrivateKey) error
	GetKey(address string) (*crypto.PrivateKey, bool)
	RemoveKey(address string) error
	HasKey(address string) bool
	GetAllAddresses() []string
}

type Vote struct {
	ValidatorID    string    `json:"validator_id"`
	BlockNumber    int32     `json:"block_number"`
	BlockHash      string    `json:"block_hash,omitempty"`
	ValidationPass bool      `json:"validation_pass,omitempty"`
	Timestamp      time.Time `json:"timestamp"`
	VoterNode      string    `json:"voter_node"`
}