driver

type AccessControl = interface{}

type BlockNum = uint64

type ByNum struct {
	Txid string
	Code ValidationCode
}

type Committer interface {
	Start(context context.Context) error

	// AddTransactionFilter adds a new transaction filter to this commit pipeline.
	// The transaction filter is used to check if an unknown transaction needs to be processed anyway
	AddTransactionFilter(tf TransactionFilter) error

	// AddFinalityListener registers a listener for transaction status for the passed transaction id.
	// If the status is already valid or invalid, the listener is called immediately.
	// When the listener is invoked, then it is also removed.
	// The transaction id must not be empty.
	AddFinalityListener(txID string, listener FinalityListener) error

	// RemoveFinalityListener unregisters the passed listener.
	RemoveFinalityListener(txID string, listener FinalityListener) error
}

type DataRead struct {
	Key string
}

type DataTx interface {
	Put(db string, key string, bytes []byte, a AccessControl) error
	Get(db string, key string) ([]byte, error)
	Commit(sync bool) (string, error)
	Delete(db string, key string) error
	SignAndClose() ([]byte, error)
	AddMustSignUser(userID string)
}

type DataWrite struct {
	Key   string
	Value []byte
	Acl   interface{}
}

type DeliveryService interface {
	// StartDelivery starts the delivery
	StartDelivery(context.Context) error
	// Stop stops delivery
	Stop()
}

type Envelope interface {
	TxID() string
	Nonce() []byte
	Creator() []byte
	Results() []byte
	Bytes() ([]byte, error)
	FromBytes(raw []byte) error
	String() string
}

type EnvelopeService interface {
	Exists(txid string) bool
	StoreEnvelope(txid string, env interface{}) error
	LoadEnvelope(txid string) ([]byte, error)
}

type Finality interface {
	// IsFinal takes in input a transaction id and waits for its confirmation.
	// with the respect to the passed context that can be used to set a deadline
	// for the waiting time.
	IsFinal(ctx context.Context, txID string) error
}

type FinalityListener = driver.FinalityListener[ValidationCode]

type Flag = int32

type GetStateOpt = driver.GetStateOpt

type Identity struct {
	Name string
	Cert string
	Key  string
}

type IdentityManager interface {
	Me() string
	Identity(id string) *Identity
}

type Ledger interface {
	GetTransactionReceipt(txId string) (Flag, error)
}

type ListenerManager driver.ListenerManager[ValidationCode]

type ListenerManagerProvider driver.ListenerManagerProvider[ValidationCode]

type LoadedDataTx interface {
	ID() string
	Commit() error
	CoSignAndClose() ([]byte, error)
	Reads() map[string][]*DataRead
	Writes() map[string][]*DataWrite
	MustSignUsers() []string
	SignedUsers() []string
}

type MetadataService interface {
	Exists(txid string) bool
	StoreTransient(txid string, transientMap TransientMap) error
	LoadTransient(txid string) (TransientMap, error)
}

type NetworkConfig interface {
	FinalityEventQueueWorkers() int
	FinalityNumRetries() int
	FinalitySleepTime() time.Duration
	PollingTimeout() time.Duration
}

type NetworkConfigProvider interface {
	GetNetworkConfig(network string) (NetworkConfig, error)
}

type OrionNetworkService interface {
	Name() string
	IdentityManager() IdentityManager
	SessionManager() SessionManager
	TransactionManager() TransactionManager
	TransactionService() TransactionService
	MetadataService() MetadataService
	Vault() Vault
	EnvelopeService() EnvelopeService
	ProcessorManager() ProcessorManager
	Finality() Finality
	Committer() Committer
	DeliveryService() DeliveryService
}

type OrionNetworkServiceProvider interface {
	Names() []string
	DefaultName() string
	// OrionNetworkService returns a OrionNetworkService instance for the passed parameters
	OrionNetworkService(id string) (OrionNetworkService, error)
}

type ProcessTransaction interface {
	Network() string
	ID() string
	FunctionAndParameters() (string, []string)
}

type Processor interface {
	Process(req Request, tx ProcessTransaction, rws RWSet, ns string) error
}

type ProcessorManager interface {
	AddProcessor(ns string, processor Processor) error
	SetDefaultProcessor(processor Processor) error
	ProcessByID(txid string) error
}

type Query interface {
	// GetDataByRange executes a range query on a given database. The startKey is
	// inclusive but endKey is not. When the startKey is an empty string, it denotes
	// `fetch keys from the beginning` while an empty endKey denotes `fetch keys till the
	// the end`. The limit denotes the number of records to be fetched in total. However,
	// when the limit is set to 0, it denotes no limit. The iterator returned by
	// GetDataByRange is used to retrieve the records.
	GetDataByRange(dbName, startKey, endKey string, limit uint64) (QueryIterator, error)
}

type QueryExecutor = vault.QueryExecutor

type QueryIterator interface {
	// Next returns the next record. If there is no more records, it would return a nil value
	// and a false value.
	Next() (string, []byte, uint64, uint64, bool, error)
}

type RWSExtractor interface {
	Extract(tx []byte) (ProcessTransaction, RWSet, error)
}

type RWSet = driver.RWSet

type Request interface {
	ID() string
}

type SeekEnd struct{}

type SeekPos struct {
	Txid string
}

type SeekStart struct{}

type Session interface {
	// DataTx returns a data transaction for the passed id
	DataTx(txID string) (DataTx, error)
	LoadDataTx(env interface{}) (LoadedDataTx, error)
	Ledger() (Ledger, error)
	Query() (Query, error)
}

type SessionManager interface {
	// NewSession creates a new session to orion using the passed identity
	NewSession(id string) (Session, error)
}

type StatusReporter interface {
	Status(txID string) (ValidationCode, string, []string, error)
}

type TXIDStore interface {
	GetLastTxID() (string, error)
	Iterator(pos interface{}) (TxidIterator, error)
}

type TransactionFilter = driver.TransactionFilter

type TransactionManager interface {
	ComputeTxID(id *TxID) string
	NewEnvelope() Envelope
	CommitEnvelope(session Session, envelope Envelope) error
}

type TransactionService interface {
	Exists(txid string) bool
	StoreTransaction(txid string, raw []byte) error
	LoadTransaction(txid string) ([]byte, error)
}

type TransactionStatusChanged struct {
	ThisTopic         string
	TxID              string
	VC                ValidationCode
	ValidationMessage string
}

type TransientMap map[string][]byte

type TxID struct {
	Nonce   []byte
	Creator []byte
}

type TxNum = uint64

type TxValidationStatus = driver2.TxValidationStatus[ValidationCode]

type TxidIterator = collections.Iterator[*ByNum]

type ValidationCode = int

type ValidationCodeProvider struct{}

type Vault interface {
	driver2.Vault[ValidationCode]
	GetLastTxID() (string, error)
}