api

type AggregatedFirmware struct {
	Index uint64
	Good  bool
}

type ConsistencyProof struct {
	Proof [][]byte
}

type DeviceReleaseLog struct {
	DeviceID  string
	Revisions []uint64
}

type FirmwareID struct {
	LogIndex            uint64
	FirmwareImageSHA512 []byte
}

type FirmwareMetadata struct {

	// DeviceID specifies the target device for this firmware.
	DeviceID string

	// FirmwareRevision specifies which version of firmware this is.
	// TODO(al): consider whether to use a string
	FirmwareRevision uint64

	// FirmwareImageSHA512 is the SHA512 hash over the firmware image as it will
	// be delivered.
	FirmwareImageSHA512 []byte

	// ExpectedFirmwareMeasurement represents the expected measured state of the
	// device once the firmware is installed.
	ExpectedFirmwareMeasurement []byte

	// BuildTimestamp is the time at which this build was published in RFC3339 format.
	// e.g. "1985-04-12T23:20:50.52Z"
	BuildTimestamp string
}

type GetConsistencyRequest struct {
	From uint64
	To   uint64
}

type GetFirmwareManifestRequest struct {
	Index    uint64
	TreeSize uint64
}

type InclusionProof struct {
	Value     []byte
	LeafIndex uint64
	Proof     [][]byte
}

type LogCheckpoint struct {
	log.Checkpoint
	// The number of nanoseconds since the Unix epoch.
	TimestampNanos uint64

	// If set, Envelope contains the envelope from which this Checkpoint was parsed.
	Envelope []byte
}

type MalwareStatement struct {
	// FirmwareID is the SignedStatement in the log being annotated.
	FirmwareID FirmwareID

	// Good is a crude signal of goodness.
	// TODO(mhutchinson): Add more fields as needed for the demo (e.g. Timestamp).
	Good bool
}

type MapCheckpoint struct {
	// LogCheckpoint is the json encoded api.LogCheckpoint.
	LogCheckpoint []byte
	LogSize       uint64
	RootHash      []byte
	Revision      uint64
}

type MapInclusionProof struct {
	Key   []byte
	Value []byte
	// Proof is all of the sibling hashes down the path, keyed by the bit length of the parent node ID.
	// A nil entry means that this branch is empty.
	// The parent node ID is used because the root does not have a sibling.
	Proof [][]byte
}

type MapTile struct {
	// The path from the root of the map to the root of this tile.
	Path []byte
	// All non-empty leaves in this tile, sorted left-to-right.
	Leaves []MapTileLeaf
}

type MapTileLeaf struct {
	// The path from the root of the container MapTile to this leaf.
	Path []byte
	// The hash value being committed to.
	Hash []byte
}

type ProofBundle struct {
	// ManifestStatement is the json representation of an `api.SignedStatement` struct.
	ManifestStatement []byte
	// Checkpoint must represent a tree which includes the ManifestStatement.
	Checkpoint []byte
	// InclusionProof is a proof to Checkpoint for ManifestStatement.
	InclusionProof InclusionProof
}

type RevocationStatement struct {
	// FirmwareID is the SignedStatement in the log being annotated.
	FirmwareID FirmwareID
}

type SignedStatement struct {
	// Type is one of the statement types from above, and indicates what
	// Statement should be interpreted as.
	Type StatementType
	// The serialised Claim in json form.
	// This is one of MalwareStatement or BuildStatement.
	Statement []byte

	// Signature is the bytestream of the signature over (Type || Statement).
	Signature []byte
}

type StatementType byte

type UpdatePackage struct {
	// FirmwareImage is the actual firmware image itself.
	FirmwareImage []byte
	// ProofBundle holds the various artifacts required to validate the firmware image.
	// It should be a serialised JSON form of the ProofBundle structure.
	ProofBundle []byte
}