ledger

type ACLFunc func(topic string, authorPubKey []byte, record Record) error

type BlobStore interface {
	Put(data []byte) (cid string, err error)
	Get(cid string) ([]byte, error)
	Has(cid string) (bool, error)
	Delete(cid string) error
	Size() (count int, bytes int64, err error)
}

type BlobStoreAdapter struct {
	Inner BlobStore
}

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

type CausalWatermark map[Topic]uint64

type CompactionPolicy struct {
	MaxTombstoneAge time.Duration // prune tombstones older than this (0 = keep all)
	MaxVersions     int           // keep last N versions per key (0 = unlimited)
	MaxRecords      int           // hard cap per topic (0 = unlimited)
}

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

type ConflictRecord struct {
	Topic     Topic
	Key       string
	Winner    Record
	Loser     Record
	Timestamp time.Time
	MergeFunc string // name of merge function that resolved it
}

type ContentHash [ContentHashLen]byte

type ContextBlobStore interface {
	Put(ctx context.Context, data []byte) (cid string, err error)
	Get(ctx context.Context, cid string) ([]byte, error)
	Has(ctx context.Context, cid string) (bool, error)
	Delete(ctx context.Context, cid string) error
	Size(ctx context.Context) (int64, error)
}

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

type ExpirySource interface {
	PruneExpired() (removed int, err error)
}

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

type HandlerMetadata struct {
	Name           string   `json:"name"`
	RequiresAuth   bool     `json:"requiresAuth"`
	RequiredScopes []string `json:"requiredScopes,omitempty"`
	TimeoutMs      int      `json:"timeoutMs"`
}

type IdentityView struct {
	NodeID      string
	Topic       string
	ContentHash ContentHash
	HLC         uint64
	UpdatedAt   int64 // unix nano; consumers convert to time.Time as needed
}

type IndexFunc func(Record) []string

type KeyFunc func(Record) string

type LatencyRecord struct {
	FromNode     string    `json:"fromNode"`
	ToNode       string    `json:"toNode"`
	RTTMs        int64     `json:"rttMs"`                  // Application RTT (gossip/data exchange latency)
	InitialRTTMs int64     `json:"initialRttMs,omitempty"` // Network RTT (connection setup latency)
	Transport    string    `json:"transport,omitempty"`    // "noise-udp" or "gossip-tls"
	MeasuredAt   time.Time `json:"measuredAt"`
	ExpiresAt    time.Time `json:"expiresAt"`
}

type Ledger interface {
	Head(ctx context.Context) (CausalWatermark, error)
	Append(ctx context.Context, rec Record) error
	BatchAppend(ctx context.Context, records []Record) error
	Stream(ctx context.Context, from CausalWatermark, topics []Topic) (<-chan Record, error)
	Snapshot(ctx context.Context) (io.ReadCloser, error)
}

type MemberRecord struct {
	TenantID  string            `json:"tenant"`
	NodeID    string            `json:"nodeId"`
	PubKey    []byte            `json:"pubkey"`
	CreatedAt time.Time         `json:"createdAt"`
	ExpiresAt time.Time         `json:"expiresAt,omitempty"`
	Attrs     map[string]string `json:"attrs,omitempty"`
	Handlers  []HandlerMetadata `json:"handlers,omitempty"` // Handler security metadata
}

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

type MergeFunc func(existing, incoming Record) (Record, error)

type MetricsRecorder interface {
	RecordApplied(topic string, merged bool)
	RecordExpired(topic string)
	MergeConflict(topic string, winner string)
	TopicSize(topic string, count int, bytes int64)
	GossipExchange(topic string, sent, received int)
}

type NoopMetricsRecorder struct{}

type QueryFilter struct {
	NodeID    string    // filter by node (empty = all)
	KeyPrefix string    // filter by key prefix (empty = all)
	Since     time.Time // records after this time (zero = all)
	Limit     int       // max results (0 = unlimited)
}

type ReachAddress struct {
	Host  string `json:"ip"`
	Port  int    `json:"port"`
	Proto string `json:"proto"`
	Scope string `json:"scope"` // public|lan|rfc1918
}

type ReachQuery struct {
	NodeID   string  // Filter by specific node ID (optional)
	Role     string  // Filter by role (optional)
	MinScore float64 // Minimum availability score (optional, 0.0-1.0)
	Limit    int     // Maximum number of results (optional)
}

type ReachRecord struct {
	TenantID      string         `json:"tenant"`
	NodeID        string         `json:"nodeId"`
	Seq           uint64         `json:"seq"`
	Addresses     []ReachAddress `json:"addrs"`
	Region        string         `json:"region"` // Hosting region (e.g., "iad", "us-east-1")
	NATType       string         `json:"natType"`
	NATObserved   string         `json:"natObserved"`
	LatencyMillis int64          `json:"latencyMs"`
	Availability  float64        `json:"availability"`
	LoadFactor    float64        `json:"loadFactor"` // 0.0 (idle) to 1.0 (overloaded)
	ExpiresAt     time.Time      `json:"expiresAt"`
	UpdatedAt     time.Time      `json:"ts"`

	// SchemaVersion lets the cache detect delta-encoded bodies (bit 15
	// set) and skip applying them — deltas are an address-change
	// optimisation at the reach layer and would otherwise clobber the
	// last signed full snapshot (wiping Metadata/Addresses/Region).
	// Full snapshots are re-emitted on a cadence, so Metadata stays
	// fresh regardless.
	SchemaVersion uint16 `json:"v,omitempty"`

	// Metadata is consumer-defined identity payload carried alongside
	// reachability. Examples: {"service_name":"devices.orbtr.io",
	// "roles":"anchor","region":"iad","fly_machine":"abc"} for mesh
	// nodes, or {"hostname":"alice-laptop","device_id":"dev-abc"} for
	// agents. The ledger cache derives MemberRecord views from this
	// map on read (see DirectoryCache.Members), so consumers don't need
	// a parallel Member publish path — a single signed ReachRecord is
	// the source of truth for both "how to reach me" and "who I am".
	Metadata map[string]string `json:"meta,omitempty"`
}

type Record struct {
	Topic           Topic           `json:"topic"`
	Seq             uint64          `json:"seq"`
	TenantID        string          `json:"tenantId"`
	NodeID          string          `json:"nodeId"`
	Body            json.RawMessage `json:"body"`
	Signature       []byte          `json:"sig"`
	Timestamp       time.Time       `json:"ts"`
	LamportClock    uint64          `json:"lc,omitempty"`        // causal ordering
	HLCTimestamp    uint64          `json:"hlc,omitempty"`       // hybrid logical clock (0 = unused)
	Tombstone       bool            `json:"tombstone,omitempty"` // true = deletion marker
	DeletedAt       time.Time       `json:"deletedAt,omitempty"`
	TombstoneReason string          `json:"tombstoneReason,omitempty"` // "explicit", "cap"
	ExpiresAt       time.Time       `json:"expiresAt,omitempty"`       // TTL expiration (zero = never)
	AuthorPubKey    []byte          `json:"authorPubkey,omitempty"`    // Ed25519 public key of record author
	BlobCID         string          `json:"blobCid,omitempty"`         // content-addressed blob reference
}

type RoleRecord struct {
	TenantID string            `json:"tenant"`
	NodeID   string            `json:"nodeId"`
	Roles    []string          `json:"roles"`
	Handlers []HandlerMetadata `json:"handlers,omitempty"` // Handler security metadata
	MaxGrade int               `json:"maxGrade,omitempty"` // Highest grade this node can support (0-4)
	Updated  time.Time         `json:"ts"`
}

type Topic string

type TopicConfig struct {
	Merge            MergeFunc                                    // conflict resolution (nil = OverwriteMerge)
	Key              KeyFunc                                      // key derivation (nil = NodeIDKey)
	ExpiryEnabled    bool                                         // enable TTL expiration
	RequireSignature bool                                         // reject unsigned records
	VerifyFunc       func(pubkey, signature, content []byte) bool // custom signature verifier (nil = Ed25519)
	SignFunc         func(content []byte) (pubkey, sig []byte)    // for local writes
}