protocol

type AnchorDocument struct {
	ID   string
	Desc string
	Type AnchorDocumentType
}

type AnchorDocumentType string

type AnchoringInfo struct {
	AnchorString         string
	Artifacts            []*AnchorDocument
	OperationReferences  []*operation.Reference
	AdditionalOperations []*operation.QueuedOperation
	ExpiredOperations    []*operation.QueuedOperation
}

type Client interface {
	// Current returns latest version of protocol.
	Current() (Version, error)

	// Get returns the version at the given transaction time.
	Get(transactionTime uint64) (Version, error)
}

type ClientProvider interface {
	ForNamespace(namespace string) (Client, error)
}

type DocumentComposer interface {
	ApplyPatches(doc document.Document, patches []patch.Patch) (document.Document, error)
}

type DocumentTransformer interface {
	TransformDocument(rm *ResolutionModel, info TransformationInfo) (*document.ResolutionResult, error)
}

type DocumentValidator interface {
	IsValidOriginalDocument(payload []byte) error
	IsValidPayload(payload []byte) error
}

type OperationApplier interface {
	Apply(op *operation.AnchoredOperation, rm *ResolutionModel) (*ResolutionModel, error)
}

type OperationHandler interface {
	// PrepareTxnFiles operations will create relevant batch files, store them in CAS and return anchor string.
	PrepareTxnFiles(ops []*operation.QueuedOperation) (*AnchoringInfo, error)
}

type OperationParser interface {
	Parse(namespace string, operation []byte) (*operation.Operation, error)
	ParseDID(namespace, shortOrLongFormDID string) (string, []byte, error)
	GetRevealValue(operation []byte) (string, error)
	GetCommitment(operation []byte) (string, error)
}

type OperationProvider interface {
	GetTxnOperations(sidetreeTxn *txn.SidetreeTxn) ([]*operation.AnchoredOperation, error)
}

type Protocol struct {
	// GenesisTime is inclusive starting logical anchoring time that this protocol applies to.
	// (e.g. block number in a blockchain)
	GenesisTime uint64 `json:"genesisTime"`

	// MultihashAlgorithms are supported multihash algorithm codes
	MultihashAlgorithms []uint `json:"multihashAlgorithms"`

	// MaxOperationCount defines maximum number of operations per batch.
	MaxOperationCount uint `json:"maxOperationCount"`

	// MaxOperationSize is maximum operation size in bytes (used to reject operations before parsing them)
	// It has to be greater than max delta size (big) + max proof size (medium) + other small values (operation type, suffix-data)
	MaxOperationSize uint `json:"maxOperationSize"`

	// MaxOperationHashLength is maximum operation hash length
	MaxOperationHashLength uint `json:"maxOperationHashLength"`

	// MaxDeltaSize is maximum size of operation's delta property.
	MaxDeltaSize uint `json:"maxDeltaSize"`

	// MaxCasUriLength is maximum length of CAS URI in batch files.
	MaxCasURILength uint `json:"maxCasUriLength"`

	// CompressionAlgorithm is file compression algorithm.
	CompressionAlgorithm string `json:"compressionAlgorithm"`

	// MaxCoreIndexFileSize is maximum allowed size (in bytes) of core index file stored in CAS.
	MaxCoreIndexFileSize uint `json:"maxCoreIndexFileSize"`

	// MaxProofFileSize is maximum allowed size (in bytes) of proof files stored in CAS.
	MaxProofFileSize uint `json:"maxProofFileSize"`

	// MaxProvisionalIndexFileSize is maximum allowed size (in bytes) of provisional index file stored in CAS.
	MaxProvisionalIndexFileSize uint `json:"maxProvisionalIndexFileSize"`

	// MaxChunkFileSize is maximum allowed size (in bytes) of chunk file stored in CAS.
	MaxChunkFileSize uint `json:"maxChunkFileSize"`

	// Patches contains the list of allowed patches.
	Patches []string `json:"patches"`

	// SignatureAlgorithms contain supported signature algorithms for signed operations (e.g. EdDSA, ES256, ES384, ES512, ES256K).
	SignatureAlgorithms []string `json:"signatureAlgorithms"`

	// KeyAlgorithms contain supported key algorithms for signed operations (e.g. secp256k1, P-256, P-384, P-512, Ed25519).
	KeyAlgorithms []string `json:"keyAlgorithms"`

	// MaxOperationTimeDelta is maximum time that operation should be valid before it expires; used with anchor from time
	MaxOperationTimeDelta uint64 `json:"maxOperationTimeDelta"`

	// NonceSize is the number of bytes in nonce values
	NonceSize uint64 `json:"nonceSize"`

	// MaxMemoryDecompressionFactor is maximum file size after decompression (e.g. 3 times maximum file size)
	MaxMemoryDecompressionFactor uint `json:"maxMemoryDecompressionFactor"`
}

type ResolutionModel struct {
	Doc                            document.Document
	CreatedTime                    uint64
	UpdatedTime                    uint64
	LastOperationTransactionTime   uint64
	LastOperationTransactionNumber uint64
	LastOperationProtocolVersion   uint64
	UpdateCommitment               string
	RecoveryCommitment             string
	Deactivated                    bool
	AnchorOrigin                   interface{}
	EquivalentReferences           []string
	CanonicalReference             string
	VersionID                      string
	PublishedOperations            []*operation.AnchoredOperation
	UnpublishedOperations          []*operation.AnchoredOperation
}

type TransformationInfo map[string]interface{}

type TxnProcessor interface {
	Process(sidetreeTxn txn.SidetreeTxn, suffixes ...string) (numProcessed int, err error)
}

type Version interface {
	Version() string
	Protocol() Protocol
	TransactionProcessor() TxnProcessor
	OperationParser() OperationParser
	OperationApplier() OperationApplier
	OperationHandler() OperationHandler
	OperationProvider() OperationProvider
	DocumentComposer() DocumentComposer
	DocumentValidator() DocumentValidator
	DocumentTransformer() DocumentTransformer
}