dag

type Addressable interface {
	// PAL contains the encrypted addresses of the participants
	PAL() [][]byte
}

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

type EncryptedPAL [][]byte

type Event struct {
	// Type of event, can be used to filter
	Type string `json:"type,omitempty"`
	// Hash is the ID of the Event, usually the same as the dag.Transaction.Ref()
	Hash hash.SHA256Hash `json:"Hash"`
	// Retries is the current number of retries
	Retries int `json:"retries"`
	// Latest records the timestamp of the last notification attempt. It is not used in the backoff calculation.
	Latest *time.Time `json:"latest,omitempty"`
	// Transaction that was added to the DAG or for which the Payload was written. Mandatory.
	Transaction Transaction `json:"transaction"`
	// Payload that was written to the PayloadStore, optional (private TXs).
	Payload []byte `json:"payload,omitempty"`
	// Error contains the error of the last try if any.
	Error string `json:"error,omitempty"`
}

type EventFatal struct {
	Err error
}

type LabelStyle int

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

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

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

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

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

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

type NetworkHeader interface {
	// Previous returns the references of the previous transactions this transaction points to.
	Previous() []hash.SHA256Hash
	// Version returns the version number of the distributed transaction format.
	Version() Version
}

type NotificationFilter func(event Event) bool

type Notifier interface {
	// Name returns the name of the notifier
	Name() string
	// Save an event that needs to be retried even after a crash.
	// It will not yet be sent, use Notify to notify the receiver.
	// The event may be ignored due to configured filters.
	// Returns nil if event already exists.
	// An error is returned if there's a problem with the underlying storage.
	Save(tx stoabs.WriteTx, event Event) error
	// Notify the receiver, if an error occurs it'll be retried later.
	// This does not store the event in the DB, use Save for that.
	Notify(event Event)
	// Finished marks the job as finished and removes it from the scheduler
	// An error is returned if there's a problem with the underlying storage.
	Finished(hash hash.SHA256Hash) error
	// Run retries all existing events.
	Run() error
	// GetFailedEvents retrieves the hashes of failed events.
	// If the notifier is not persistent it'll always return 0.
	GetFailedEvents() ([]Event, error)
	// Close cancels all running events. It does not remove them from the DB
	Close() error
}

type NotifierOption func(notifier *notifier)

type PAL []did.DID

type PayloadReferencer interface {
	// PayloadHash returns the hash of the payload of the transaction.
	PayloadHash() hash.SHA256Hash

	// PayloadType returns the MIME-formatted type of the payload. It must contain the context and specific type of the
	// payload, e.g. 'registry/endpoint'.
	PayloadType() string
}

type PayloadStore interface {
	// contains filtered or unexported methods
}

type ReceiverFn func(event Event) (bool, error)

type Referencable interface {
	// Ref returns a unique sha256 hash of the implementing object.
	Ref() hash.SHA256Hash
}

type Signable interface {
	// SigningKey returns the key that was used to sign the transaction as JWK.
	// If this field is not set SigningKeyID must be used to resolve the signing key.
	SigningKey() jwk.Key
	// SigningKeyID returns the ID of the key that was used to sign the transaction. It can be used to look up the key.
	SigningKeyID() string
	// SigningTime returns the time that the transaction was signed.
	SigningTime() time.Time
	// SigningAlgorithm returns the name of the JOSE signing algorithm that was used to sign the transaction.
	SigningAlgorithm() string
}

type SourceTXKeyResolver struct {
	Resolver resolver.DIDResolver
}

type State interface {
	core.Diagnosable
	core.Migratable
	core.Configurable

	// WritePayload writes contents for the specified payload, identified by the given hash.
	// It also calls observers and therefore requires the transaction.
	WritePayload(ctx context.Context, transaction Transaction, payloadHash hash.SHA256Hash, data []byte) error
	// IsPayloadPresent checks whether the contents for the given transaction are present.
	IsPayloadPresent(ctx context.Context, payloadHash hash.SHA256Hash) (bool, error)
	// ReadPayload reads the contents for the specified payload, identified by the given hash. If contents can't be found,
	// ErrPayloadNotFound is returned. If something (else) goes wrong an error is returned.
	ReadPayload(ctx context.Context, payloadHash hash.SHA256Hash) ([]byte, error)
	// Add a transaction to the DAG. If it can't be added an error is returned.
	// If the transaction already exists, nothing is added and no observers are notified.
	// The payload may be passed as well. Allowing for better notification of observers
	Add(ctx context.Context, transactions Transaction, payload []byte) error
	// FindBetweenLC finds all transactions which lamport clock value lies between startInclusive and endExclusive.
	// They are returned in order: first sorted on lamport clock value, then on transaction reference (byte order).
	FindBetweenLC(ctx context.Context, startInclusive uint32, endExclusive uint32) ([]Transaction, error)
	// GetTransaction returns the transaction from local storage.
	// If contents can't be found, ErrTransactionNotFound is returned.
	GetTransaction(ctx context.Context, hash hash.SHA256Hash) (Transaction, error)
	// IsPresent returns true if a transaction is present in the DAG
	IsPresent(context.Context, hash.SHA256Hash) (bool, error)
	// Notifier creates a new Notifier.
	// It lets another part of the application receive events on new transactions. When a new transaction is received
	// the `receiver` function is called. Notifiers can be persistent and will survive restarts.
	// The name is used to keep different notifiers apart.
	// Filters can be used to receive specific transactions. Filters are added via the WithSelectionFilter() option.
	// A Notifier should only be created during `configuration` step since the `start` step will redeliver all events that have not been delivered yet.
	// Returns an error when the Notifier already exists
	Notifier(name string, receiver ReceiverFn, filters ...NotifierOption) (Notifier, error)
	// Notifiers returns all registered notifiers
	Notifiers() []Notifier
	// Head returns the reference to a transactions that has not been referenced in the prevs of other transactions.
	// Returns hash.EmptyHash when no head is stored.
	Head(ctx context.Context) (hash.SHA256Hash, error)
	// Shutdown the DB
	Shutdown() error
	// Start the publisher and verifier
	Start() error
	// Verify checks the integrity of the DAG. Should be called when it's loaded, e.g. from disk.
	Verify(ctx context.Context) error
	// XOR returns the xor of all transaction references between the DAG root and the clock closest to the requested clock value.
	// This closest clock value is also returned, and is defined as the lowest of:
	//	- upper-limit of the page that contains the requested clock
	//	- highest lamport clock in the DAG
	// A requested clock of math.MaxUint32 will return the xor of the entire DAG
	XOR(reqClock uint32) (hash.SHA256Hash, uint32)
	// IBLT returns the iblt of all transaction references between the DAG root and the clock closest to the requested clock value.
	// This closest clock value is also returned, and is defined as the lowest of:
	//	- upper-limit of the page that contains the requested clock
	//	- highest lamport clock in the DAG
	// A requested clock of math.MaxUint32 will return the iblt of the entire DAG
	IBLT(reqClock uint32) (tree.Iblt, uint32)

	// IncorrectStateDetected is called when the xor and LC value from a gossip message do NOT match the local state.
	IncorrectStateDetected()
	// CorrectStateDetected is called when the xor and LC value from a gossip message match the local state.
	CorrectStateDetected()
}

type Statistics struct {
	// NumberOfTransactions contains the number of transactions on the DAG
	NumberOfTransactions uint
	// DataSize contains the size of the DAG in bytes
	DataSize int64
}

type Transaction interface {
	UnsignedTransaction
	Signable
	Referencable
	Addressable
	json.Marshaler
	// Data returns the byte representation of this transaction which can be used for transport.
	Data() []byte
}

type TransactionSigner interface {
	// Sign signs the unsigned transaction, including the signingTime parameter as header.
	Sign(ctx context.Context, input UnsignedTransaction, signingTime time.Time) (Transaction, error)
}

type UnsignedTransaction interface {
	NetworkHeader
	Addressable
	PayloadReferencer

	// Clock returns the Lamport clock value
	Clock() uint32
}

type Verifier func(tx stoabs.ReadTx, transaction Transaction) error

type Version int

type Visitor func(transaction Transaction) bool