daemon

type AnnounceBlocksMessage struct {
	MaxBkSeq uint64
	// contains filtered or unexported fields
}

type AnnounceTxnsMessage struct {
	Txns []cipher.SHA256
	// contains filtered or unexported fields
}

type AsyncMessage interface {
	Process(d *Daemon)
}

type BlockchainProgress struct {
	// Our current blockchain length
	Current uint64 `json:"current"`
	// Our best guess at true blockchain length
	Highest uint64 `json:"highest"`
	Peers   []struct {
		Address string `json:"address"`
		Height  uint64 `json:"height"`
	} `json:"peers"`
}

type Config struct {
	Daemon   DaemonConfig
	Messages MessagesConfig
	Pool     PoolConfig
	Pex      pex.Config
	Gateway  GatewayConfig
	Visor    VisorConfig
}

type ConnectEvent struct {
	Addr      string
	Solicited bool
}

type Connection struct {
	ID           int    `json:"id"`
	Addr         string `json:"address"`
	LastSent     int64  `json:"last_sent"`
	LastReceived int64  `json:"last_received"`
	// Whether the connection is from us to them (true, outgoing),
	// or from them to us (false, incoming)
	Outgoing bool `json:"outgoing"`
	// Whether the client has identified their version, mirror etc
	Introduced bool   `json:"introduced"`
	Mirror     uint32 `json:"mirror"`
	ListenPort uint16 `json:"listen_port"`
}

type ConnectionError struct {
	Addr  string
	Error error
}

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

type Connections struct {
	Connections []*Connection `json:"connections"`
}

type CullMatchFunc func(addr string, t time.Time) (bool, error)

type Daemon struct {
	// Daemon configuration
	Config DaemonConfig

	// Components
	Messages *Messages
	Pool     *Pool
	Pex      *pex.Pex
	Gateway  *Gateway
	Visor    *Visor

	DefaultConnections []string

	// log buffer
	LogBuff bytes.Buffer
	// contains filtered or unexported fields
}

type DaemonConfig struct {
	// Application version. TODO -- manage version better
	Version int32
	// IP Address to serve on. Leave empty for automatic assignment
	Address string
	// TCP/UDP port for connections
	Port int
	// Directory where application data is stored
	DataDirectory string
	// How often to check and initiate an outgoing connection if needed
	OutgoingRate time.Duration
	// How often to re-attempt to fill any missing private (aka required)
	// connections
	PrivateRate time.Duration
	// Number of outgoing connections to maintain
	OutgoingMax int
	// Maximum number of connections to try at once
	PendingMax int
	// How long to wait for a version packet
	IntroductionWait time.Duration
	// How often to check for peers that have decided to stop communicating
	CullInvalidRate time.Duration
	// How many connections are allowed from the same base IP
	IPCountsMax int
	// Disable all networking activity
	DisableNetworking bool
	// Don't make outgoing connections
	DisableOutgoingConnections bool
	// Don't allow incoming connections
	DisableIncomingConnections bool
	// Run on localhost and only connect to localhost peers
	LocalhostOnly bool
	// Log ping and pong messages
	LogPings bool
}

type DisconnectEvent struct {
	Addr   string
	Reason gnet.DisconnectReason
}

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

type Gateway struct {
	Config GatewayConfig
	// contains filtered or unexported fields
}

type GatewayConfig struct {
	BufferSize      int
	EnableWalletAPI bool
}

type GetBlocksMessage struct {
	LastBlock       uint64
	RequestedBlocks uint64
	// contains filtered or unexported fields
}

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

type GetTxnsMessage struct {
	Txns []cipher.SHA256
	// contains filtered or unexported fields
}

type GiveBlocksMessage struct {
	Blocks []coin.SignedBlock
	// contains filtered or unexported fields
}

type GivePeersMessage struct {
	Peers []IPAddr
	// contains filtered or unexported fields
}

type GiveTxnsMessage struct {
	Txns coin.Transactions
	// contains filtered or unexported fields
}

type Health struct {
	BlockchainMetadata *visor.BlockchainMetadata
	Version            visor.BuildInfo
	OpenConnections    int
	Uptime             time.Duration
}

type IPAddr struct {
	IP   uint32
	Port uint16
}

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

type IntroductionMessage struct {
	// Mirror is a random value generated on client startup that is used
	// to identify self-connections
	Mirror uint32
	// Port is the port that this client is listening on
	Port uint16
	// Our client version
	Version int32
	// contains filtered or unexported fields
}

type MessageConfig struct {
	Prefix  gnet.MessagePrefix
	Message interface{}
}

type MessageEvent struct {
	Message AsyncMessage
	Context *gnet.MessageContext
}

type Messages struct {
	Config MessagesConfig
	// Magic value for detecting self-connection
	Mirror uint32
}

type MessagesConfig struct {
	// Message ID prefices
	Messages []MessageConfig
}

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

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

type OutputsFilter func(outputs coin.UxArray) coin.UxArray

type PeerBlockchainHeight struct {
	Address string
	Height  uint64
}

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

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

type PongMessage struct {
}

type Pool struct {
	Config PoolConfig
	Pool   *gnet.ConnectionPool
}

type PoolConfig struct {
	// Timeout when trying to connect to new peers through the pool
	DialTimeout time.Duration
	// How often to process message buffers and generate events
	MessageHandlingRate time.Duration
	// How long to wait before sending another ping
	PingRate time.Duration
	// How long a connection can idle before considered stale
	IdleLimit time.Duration
	// How often to check for needed pings
	IdleCheckRate time.Duration
	// How often to check for stale connections
	ClearStaleRate time.Duration
	// Buffer size for gnet.ConnectionPool's network Read events
	EventChannelSize int
	// contains filtered or unexported fields
}

type RPC struct{}

type ResendResult struct {
	Txids []string `json:"txids"` // transaction id
}

type SendingTxnsMessage interface {
	GetTxns() []cipher.SHA256
}

type Visor struct {
	Config VisorConfig
	// contains filtered or unexported fields
}

type VisorConfig struct {
	Config visor.Config
	// Disable visor networking
	DisableNetworking bool
	// How often to request blocks from peers
	BlocksRequestRate time.Duration
	// How often to announce our blocks to peers
	BlocksAnnounceRate time.Duration
	// How many blocks to respond with to a GetBlocksMessage
	BlocksResponseCount uint64
	// How long between saving copies of the blockchain
	BlockchainBackupRate time.Duration
	// Max announce txns hash number
	MaxTxnAnnounceNum int
	// How often to announce our unconfirmed txns to peers
	TxnsAnnounceRate time.Duration
	// How long to wait for Visor request to process
	RequestDeadline time.Duration
	// Internal request buffer size
	RequestBufferSize int
}