prototree

type ACL interface {
	TypeOf(stateURI string) StateURIType
	MembersOf(stateURI string) (types.Set[types.Address], error)
	HasReadAccess(stateURI string, keypath state.Keypath, addresses types.Set[types.Address]) (bool, error)
}

type AckReceivedCallback func(stateURI string, txID state.Version, peerConn TreePeerConn)

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

type DefaultACL struct {
	ControllerHub tree.ControllerHub
}

type EncryptedTx = protohush.GroupMessage

type FetchHistoryOpts struct {
	FromTxID state.Version
	ToTxID   state.Version
}

type P2PStateURIReceivedCallback func(stateURI string, peerConn TreePeerConn)

type PrivateTxReceivedCallback func(encryptedTx EncryptedTx, peerConn TreePeerConn)

type ReadableSubscription interface {
	Read() (SubscriptionMsg, error)
	Close() error
}

type StateURISubscription interface {
	Read(ctx context.Context) (string, error)
	Close() error
}

type StateURIType int

type Store interface {
	SubscribedStateURIs() types.Set[string]
	AddSubscribedStateURI(stateURI string) error
	RemoveSubscribedStateURI(stateURI string) error
	OnNewSubscribedStateURI(handler func(stateURI string)) (unsubscribe func())

	MaxPeersPerSubscription() uint64
	SetMaxPeersPerSubscription(max uint64) error

	TxSeenByPeer(deviceUniqueID, stateURI string, txID state.Version) bool
	MarkTxSeenByPeer(deviceUniqueID, stateURI string, txID state.Version) error
	PruneTxSeenRecordsOlderThan(threshold time.Duration) error

	EncryptedTx(stateURI string, txID state.Version) (EncryptedTx, error)
	SaveEncryptedTx(stateURI string, txID state.Version, etx EncryptedTx) error

	DebugPrint()
}

type SubscriptionMsg struct {
	StateURI    string          `json:"stateURI"`
	Tx          *tree.Tx        `json:"tx,omitempty"`
	EncryptedTx *EncryptedTx    `json:"encryptedTx,omitempty"`
	State       state.Node      `json:"state,omitempty"`
	Leaves      []state.Version `json:"leaves,omitempty"`
	Error       error           `json:"error,omitempty"`
}

type SubscriptionRequest struct {
	StateURI         string
	Keypath          state.Keypath
	Type             SubscriptionType
	FetchHistoryOpts *FetchHistoryOpts
	Addresses        types.Set[types.Address]
}

type SubscriptionType uint8

type TreePeerConn interface {
	swarm.PeerConn
	Subscribe(ctx context.Context, stateURI string) (ReadableSubscription, error)
	SendTx(ctx context.Context, tx tree.Tx) error
	SendPrivateTx(ctx context.Context, encryptedTx EncryptedTx) (err error)
	Ack(stateURI string, txID state.Version) error
	AnnounceP2PStateURI(ctx context.Context, stateURI string) error
}

type TreeProtocol interface {
	process.Interface
	ProvidersOfStateURI(ctx context.Context, stateURI string) <-chan TreePeerConn
	Subscribe(ctx context.Context, stateURI string) error
	InProcessSubscription(ctx context.Context, stateURI string, subscriptionType SubscriptionType, keypath state.Keypath, fetchHistoryOpts *FetchHistoryOpts) (ReadableSubscription, error)
	Unsubscribe(stateURI string) error
	SubscribeStateURIs() (StateURISubscription, error)
	SendTx(ctx context.Context, tx tree.Tx) error
}

type TreeTransport interface {
	swarm.Transport
	ProvidersOfStateURI(ctx context.Context, stateURI string) (<-chan TreePeerConn, error)
	AnnounceStateURIs(ctx context.Context, stateURIs types.Set[string])
	OnTxReceived(handler TxReceivedCallback)
	OnPrivateTxReceived(handler PrivateTxReceivedCallback)
	OnAckReceived(handler AckReceivedCallback)
	OnWritableSubscriptionOpened(handler WritableSubscriptionOpenedCallback)
	OnP2PStateURIReceived(handler P2PStateURIReceivedCallback)
}

type TxReceivedCallback func(tx tree.Tx, peerConn TreePeerConn)

type WritableSubscription interface {
	process.Interface
	StateURI() string
	Keypath() state.Keypath
	Type() SubscriptionType
	Addresses() types.Set[types.Address]
	EnqueueWrite(msg SubscriptionMsg)
	String() string
}

type WritableSubscriptionImpl interface {
	process.Interface
	Put(ctx context.Context, msg SubscriptionMsg) error
	String() string
}

type WritableSubscriptionImplFactory func() (WritableSubscriptionImpl, error)

type WritableSubscriptionOpenedCallback func(req SubscriptionRequest, writeSubImplFactory WritableSubscriptionImplFactory) (<-chan struct{}, error)