driver

type AuditRegistry interface {
	// RegisterAuditInfo binds the passed audit info to the passed identity
	RegisterAuditInfo(identity view.Identity, info []byte) error

	// GetAuditInfo returns the audit info associated to the passed identity, nil if not found
	GetAuditInfo(identity view.Identity) ([]byte, error)
}

type BlockNum = uint64

type ByNum[V comparable] struct {
	TxID    TxID
	Code    V
	Message string
}

type Channel = string

type FinalityEvent[V comparable] struct {
	Ctx               context.Context
	TxID              TxID
	ValidationCode    V
	ValidationMessage string
	Block             BlockNum
	IndexInBlock      TxNum
	Err               error
}

type FinalityListener[V comparable] interface {
	// OnStatus is called when the status of a transaction changes, or it is already valid or invalid
	OnStatus(ctx context.Context, txID TxID, status V, statusMessage string)
}

type GetStateOpt int

type ListenerManager[V comparable] interface {
	AddListener(txID TxID, toAdd FinalityListener[V]) error
	RemoveListener(txID TxID, toRemove FinalityListener[V])
	InvokeListeners(event FinalityEvent[V])
	TxIDs() []TxID
}

type ListenerManagerProvider[V comparable] interface {
	NewManager() ListenerManager[V]
}

type MKey = string

type Metadata = map[MKey][]byte

type NamedDriver[D any] struct {
	Name   PersistenceType
	Driver D
}

type Namespace = string

type Network = string

type PKey = string

type PersistenceType string

type QueryExecutor interface {
	GetState(namespace Namespace, key PKey) (RawValue, error)
	GetStateMetadata(namespace Namespace, key PKey) (Metadata, RawVersion, error)
	GetStateRangeScanIterator(namespace Namespace, startKey PKey, endKey PKey) (VersionedResultsIterator, error)
	Done()
}

type RWSet interface {
	// IsValid returns true if this rwset is valid.
	// A rwset is valid if:
	// 1. It exists in the vault as valid
	// 2. All the read dependencies are satisfied by the vault
	IsValid() error

	IsClosed() bool

	// Clear remove the passed namespace from this rwset
	Clear(ns Namespace) error

	// AddReadAt adds a read dependency for the given namespace and key at the given version
	AddReadAt(ns Namespace, key string, version RawVersion) error

	// SetState sets the given value for the given namespace and key.
	SetState(namespace Namespace, key PKey, value RawValue) error

	GetState(namespace Namespace, key PKey, opts ...GetStateOpt) (RawValue, error)

	// GetDirectState accesses the state using the query executor without looking into the RWSet.
	// This way we can access the query executor while we have a RWSet already open avoiding nested RLocks.
	GetDirectState(namespace Namespace, key PKey) (RawValue, error)

	// DeleteState deletes the given namespace and key
	DeleteState(namespace Namespace, key PKey) error

	GetStateMetadata(namespace Namespace, key PKey, opts ...GetStateOpt) (Metadata, error)

	// SetStateMetadata sets the metadata associated with an existing key-tuple <namespace, key>
	SetStateMetadata(namespace Namespace, key PKey, metadata Metadata) error

	GetReadKeyAt(ns Namespace, i int) (PKey, error)

	// GetReadAt returns the i-th read (key, value) in the namespace ns  of this rwset.
	// The value is loaded from the ledger, if present. If the key's version in the ledger
	// does not match the key's version in the read, then it returns an error.
	GetReadAt(ns Namespace, i int) (PKey, RawValue, error)

	// GetWriteAt returns the i-th write (key, value) in the namespace ns of this rwset.
	GetWriteAt(ns Namespace, i int) (PKey, RawValue, error)

	// NumReads returns the number of reads in the namespace ns  of this rwset.
	NumReads(ns Namespace) int

	// NumWrites returns the number of writes in the namespace ns of this rwset.
	NumWrites(ns Namespace) int

	// Namespaces returns the namespace labels in this rwset.
	Namespaces() []Namespace

	AppendRWSet(raw []byte, nss ...Namespace) error

	Bytes() ([]byte, error)

	Done()

	Equals(rws interface{}, nss ...Namespace) error
}

type RawValue = []byte

type RawVersion = []byte

type SeekEnd struct{}

type SeekPos struct {
	Txid TxID
}

type SeekSet struct {
	TxIDs []TxID
}

type SeekStart struct{}

type SigDeserializer interface {
	DeserializeVerifier(raw []byte) (Verifier, error)
	DeserializeSigner(raw []byte) (Signer, error)
	Info(raw []byte, auditInfo []byte) (string, error)
}

type SigRegistry interface {
	// RegisterSigner binds the passed identity to the passed signer and verifier
	RegisterSigner(identity view.Identity, signer Signer, verifier Verifier) error

	// RegisterVerifier binds the passed identity to the passed verifier
	RegisterVerifier(identity view.Identity, verifier Verifier) error
}

type SigService interface {
	// GetSigner returns the signer bound to the passed identity
	GetSigner(identity view.Identity) (Signer, error)

	// GetVerifier returns the verifier bound to the passed identity
	GetVerifier(identity view.Identity) (Verifier, error)

	// GetSigningIdentity returns the signer identity bound to the passed identity
	GetSigningIdentity(identity view.Identity) (SigningIdentity, error)

	// IsMe returns true if a signer was ever registered for the passed identity
	IsMe(identity view.Identity) bool
}

type Signer interface {
	// Sign signs message bytes and returns the signature or an error on failure.
	Sign(message []byte) ([]byte, error)
}

type SigningIdentity interface {
	VerifyingIdentity

	// Sign signs message bytes and returns the signature or an error on failure.
	Sign(message []byte) ([]byte, error)

	GetPublicVersion() VerifyingIdentity
}

type TransactionFilter interface {
	Accept(txID TxID, env []byte) (bool, error)
}

type TxID = string

type TxNum = uint64

type TxValidationStatus[V comparable] struct {
	TxID           TxID
	ValidationCode V
	Message        string
}

type ValidationCode interface {
	comparable
}

type ValidationCodeProvider[V ValidationCode] interface {
	ToInt32(V) int32
	FromInt32(int32) V
	Unknown() V
	Busy() V
	Valid() V
	Invalid() V
	NotFound() V
}

type Vault[V comparable] interface {
	// NewQueryExecutor gives handle to a query executor.
	// A client can obtain more than one 'QueryExecutor's for parallel execution.
	// Any synchronization should be performed at the implementation level if required
	NewQueryExecutor() (QueryExecutor, error)

	// NewRWSet returns a RWSet for this ledger.
	// A client may obtain more than one such simulator; they are made unique
	// by way of the supplied txid
	NewRWSet(txID TxID) (RWSet, error)

	// GetRWSet returns a RWSet for this ledger whose content is unmarshalled
	// from the passed bytes.
	// A client may obtain more than one such simulator; they are made unique
	// by way of the supplied txid
	GetRWSet(txID TxID, rwset []byte) (RWSet, error)

	SetDiscarded(txID TxID, message string) error

	Status(txID TxID) (V, string, error)

	Statuses(txIDs ...TxID) ([]TxValidationStatus[V], error)

	// DiscardTx discards the transaction with the given transaction id.
	// If no error occurs, invoking Status on the same transaction id will return the Invalid flag.
	DiscardTx(txID TxID, message string) error

	CommitTX(ctx context.Context, txID TxID, block BlockNum, index TxNum) error
}

type Verifier interface {
	// Verify verifies the signature over the passed message.
	Verify(message, sigma []byte) error
}

type VerifyingIdentity interface {
	// Serialize returns the byte representation of this identity
	Serialize() ([]byte, error)

	// Verify verifies the signature over the passed message.
	Verify(message []byte, signature []byte) error
}

type VersionedMetadataValue struct {
	Version  RawVersion
	Metadata Metadata
}

type VersionedRead struct {
	Key     PKey
	Raw     RawValue
	Version RawVersion
}

type VersionedResultsIterator = collections.Iterator[*VersionedRead]

type VersionedValue struct {
	Raw     RawValue
	Version RawVersion
}