chainscript

type Evidence struct {
	// Version of the evidence format.
	Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	// Identifier of the evidence type.
	// For example, in the case of a timestamp on the Bitcoin blockchain,
	// this would be "bitcoin".
	Backend string `protobuf:"bytes,10,opt,name=backend,proto3" json:"backend,omitempty"`
	// Instance of the backend used.
	// For example, in the case of a timestamp on the Bitcoin blockchain,
	// this would be the chain ID (to identify testnet from mainnet).
	Provider string `protobuf:"bytes,11,opt,name=provider,proto3" json:"provider,omitempty"`
	// Data that should be usable offline by any client wishing to validate
	// the evidence.
	// For backwards compatibility, you should update the evidence version
	// when the structure of this proof changes.
	Proof                []byte   `protobuf:"bytes,20,opt,name=proof,proto3" json:"proof,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type Link struct {
	// Version of the link format.
	// You can for example use the git tag of the code used to create the link.
	Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	// Data representing the process' step details.
	// For backwards compatibility, you should update the link version
	// in meta when the structure/encoding of this field changes.
	Data []byte `protobuf:"bytes,10,opt,name=data,proto3" json:"data,omitempty"`
	// Metadata associated to the process' step.
	// Some of this metadata is used to provide filtering options when
	// fetching links.
	Meta *LinkMeta `protobuf:"bytes,11,opt,name=meta,proto3" json:"meta,omitempty"`
	// (Optional) Signatures of configurable parts of the link.
	Signatures           []*Signature `protobuf:"bytes,20,rep,name=signatures,proto3" json:"signatures,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

type LinkHash []byte

type LinkMeta struct {
	// The Client ID should be set by the client code creating the link.
	// Use a unique ID that easily identifies your library, for example the
	// github url of your repository.
	ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"clientId,omitempty"`
	// Hash of the previous link (in the same process).
	PrevLinkHash []byte `protobuf:"bytes,10,opt,name=prev_link_hash,json=prevLinkHash,proto3" json:"prevLinkHash,omitempty"`
	// Priority of the link.
	// Can be used to order and filter search results.
	Priority float64 `protobuf:"fixed64,11,opt,name=priority,proto3" json:"priority,omitempty"`
	// References to related links (potentially in other processes).
	Refs []*LinkReference `protobuf:"bytes,12,rep,name=refs,proto3" json:"refs,omitempty"`
	// Maximum number of children the current link is allowed to have.
	// A reference doesn't count as a child, only usage of prev_link_hash
	// counts as a link child.
	// It is the application's responsibility to comply with this property.
	// If set to -1, the link can have as many children as it wants.
	// If set to 0, the link can't have any children.
	// If set to n > 0, the link can have at most n children.
	OutDegree int32 `protobuf:"varint,13,opt,name=out_degree,json=outDegree,proto3" json:"outDegree,omitempty"`
	// A link is a step in a given process.
	Process *Process `protobuf:"bytes,20,opt,name=process,proto3" json:"process,omitempty"`
	// A link always belongs to a specific map in that process.
	// A map is an instance of a process.
	MapId string `protobuf:"bytes,21,opt,name=map_id,json=mapId,proto3" json:"mapId,omitempty"`
	// (Optional) Action in the process that resulted in the link's creation.
	// Can be used to filter link search results.
	Action string `protobuf:"bytes,30,opt,name=action,proto3" json:"action,omitempty"`
	// (Optional) Step of the process that results from the action.
	// Can be used to help deserialize link data or filter link search results.
	Step string `protobuf:"bytes,31,opt,name=step,proto3" json:"step,omitempty"`
	// (Optional) Tags that can be used to filter link search results.
	Tags []string `protobuf:"bytes,32,rep,name=tags,proto3" json:"tags,omitempty"`
	// (Optional) Additional metadata needed by your business logic.
	// For backwards compatibility, you should update the link version when the
	// structure of this field changes.
	Data                 []byte   `protobuf:"bytes,100,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type LinkReference struct {
	// Hash of the referenced link.
	LinkHash []byte `protobuf:"bytes,1,opt,name=link_hash,json=linkHash,proto3" json:"linkHash,omitempty"`
	// Process containing the referenced link.
	Process              string   `protobuf:"bytes,10,opt,name=process,proto3" json:"process,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type Process struct {
	// The name of the process.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The current state of the process.
	State                string   `protobuf:"bytes,10,opt,name=state,proto3" json:"state,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type Proof interface {
	// Time returns the timestamp (UNIX format) of the proof
	Time() uint64

	// Verify the validity of the proof.
	// For most proof an input is required. For example, a proof containing a
	// merkle path would require the link's hash to verify that it is correctly
	// contained in the merkle path.
	Verify(interface{}) bool
}

type Segment struct {
	// The link is the immutable part of a segment.
	// It contains the details of the step.
	Link *Link `protobuf:"bytes,1,opt,name=link,proto3" json:"link,omitempty"`
	// The link can be enriched with potentially mutable metadata.
	Meta                 *SegmentMeta `protobuf:"bytes,2,opt,name=meta,proto3" json:"meta,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

type SegmentMeta struct {
	// Hash of the segment's link.
	LinkHash []byte `protobuf:"bytes,1,opt,name=link_hash,json=linkHash,proto3" json:"linkHash,omitempty"`
	// Evidences produced for the segment's link.
	Evidences            []*Evidence `protobuf:"bytes,10,rep,name=evidences,proto3" json:"evidences,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

type Signature struct {
	// Version of the signature format.
	Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	// Signature algorithm used (for example, "EdDSA").
	Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
	// A description of the parts of the links that are signed.
	// This should unambiguously let the verifier recompute the signed payload
	// bytes from the link's content.
	PayloadPath string `protobuf:"bytes,10,opt,name=payload_path,json=payloadPath,proto3" json:"payloadPath,omitempty"`
	// Encoded signer's public key.
	// For backwards compatibility, you should update the signature version
	// or the signature type when changing the encoding used.
	PublicKey []byte `protobuf:"bytes,20,opt,name=public_key,json=publicKey,proto3" json:"publicKey,omitempty"`
	// Signature bytes.
	Signature            []byte   `protobuf:"bytes,21,opt,name=signature,proto3" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}