oplog

type AccessController interface {
	CanAppend(ctx context.Context, entry *Entry) (bool, error)
}

type AppendOptions struct {
	// ReferencesCount is how many entries beyond the heads the new entry
	// refers to, so readers can skip ahead when traversing.
	ReferencesCount int
}

type Clock struct {
	ID   string
	Time int64
}

type Encrypter interface {
	Encrypt(ctx context.Context, plaintext []byte) ([]byte, error)
	Decrypt(ctx context.Context, ciphertext []byte) ([]byte, error)
}

type Encryption struct {
	// Replication encrypts whole entry blocks, so storage and the network
	// only see ciphertext. The stored block is the dag-cbor byte string of
	// the ciphertext.
	Replication Encrypter
	// Data encrypts entry payloads. The payload is encoded as dag-cbor,
	// encrypted, and the ciphertext is what gets signed and stored.
	Data Encrypter
}

type Entry struct {
	// ID is the id of the log the entry belongs to.
	ID string
	// Payload is any value dag-cbor can encode; see package block for the
	// Go types it maps to.
	Payload any
	// Next holds the hashes of the log heads the entry was appended on.
	Next []string
	// Refs holds hashes of older entries, to speed up traversal.
	Refs  []string
	Clock Clock
	V     int64
	// Key is the public key of the writer's identity.
	Key string
	// Identity is the hash of the writer's identity block.
	Identity string
	// Sig is the writer's signature of the entry.
	Sig string
	// Hash is the base58btc CID of the stored entry block. It is set once
	// the entry has been stored or decoded.
	Hash string
	// contains filtered or unexported fields
}

type EntryOptions struct {
	// Clock of the entry. Defaults to time 0 on the identity's public key.
	Clock *Clock
	Next  []string
	Refs  []string
	// EncryptPayload, if set, encrypts the payload (see Encryption.Data).
	EncryptPayload Encrypter
}

type IteratorOptions struct {
	// Amount limits the number of entries. Zero or negative means all.
	Amount int
	// GT and GTE end the iteration at an entry, excluding or including it.
	GT, GTE string
	// LT and LTE start the iteration at an entry, excluding or including
	// it.
	LT, LTE string
}

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

type Options struct {
	// LogID identifies the log; entries of other logs cannot be joined.
	// Defaults to the current Unix time in milliseconds.
	LogID string
	// LogHeads, if set, replaces the persisted heads.
	LogHeads []*Entry
	// AccessController decides who may write. Defaults to AllowAll.
	AccessController AccessController
	// EntryStorage holds entry blocks, IndexStorage records which entries
	// are part of the log and HeadsStorage the current heads. Each
	// defaults to a MemoryStorage.
	EntryStorage storage.Storage
	HeadsStorage storage.Storage
	IndexStorage storage.Storage
	// SortFn orders concurrent entries. Defaults to LastWriteWins.
	SortFn SortFn
	// Encryption turns on entry and/or payload encryption.
	Encryption Encryption
}

type SortFn func(a, b *Entry) int