Data Model

#[derive(    Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, serde::Serialize, serde::Deserialize,)]pub struct TransportKey {    deployment: u64,    source: u64,    principal: u64,    uuid: [u8; 16],}impl TransportKey {    pub fn for_core(core: &Core) -> Result<Self> {        let bad = WireError::InvalidFormat;        Ok(Self {            deployment: core.deployment.ok_or(bad)?,            source: core.source_domain.ok_or(bad)?,            principal: core.principal.ok_or(bad)?,            uuid: core                .uuid                .as_deref()                .ok_or(bad)?                .try_into()                .map_err(|_| bad)?,        })    }}

type TransportKey struct {	Deployment, Source, Principal uint64	UUID                          [16]byte}func Key(core *wirepb.Core) (TransportKey, error) {	if core.Deployment == nil || core.SourceDomain == nil || core.Principal == nil || len(core.Uuid) != 16 {		return TransportKey{}, ErrFormat	}	return TransportKey{Deployment: core.GetDeployment(), Source: core.GetSourceDomain(), Principal: core.GetPrincipal(), UUID: [16]byte(core.Uuid)}, nil}

// An operation carries positional operands. The family of the enclosing body// member and the opcode fix the meaning and order of every entry in words and// blobs. The field-meaning table spec/operations.json lists, for each family// and opcode, the positions, enumerations and whether the reference// configuration accepts the operation.message Operation {  optional uint64 opcode = 1;  repeated fixed64 words = 2 [packed = false];  repeated bytes blobs = 3;  // The appeal deadline of a regulatory action (family 2). Operations of  // other families reject both members. In this version an absent member and  // appeal_deadline_indefinite both mean that no appeal deadline applies.  oneof appeal_deadline {    // Only the value true is canonical.    bool appeal_deadline_indefinite = 4;    // Unix time in UTC seconds.    fixed64 appeal_deadline_utc_seconds = 5;  }}

#[derive(Clone, PartialEq, ::prost::Message)]pub struct Operation {    #[prost(uint64, optional, tag = "1")]    pub opcode: Option<u64>,    #[prost(fixed64, repeated, packed = "false", tag = "2")]    pub words: Vec<u64>,    #[prost(bytes = "vec", repeated, tag = "3")]    pub blobs: Vec<Vec<u8>>,    #[prost(oneof = "operation::AppealDeadline", tags = "4, 5")]    pub appeal_deadline: Option<operation::AppealDeadline>,}pub mod operation {    #[derive(Clone, PartialEq, ::prost::Oneof)]    pub enum AppealDeadline {        #[prost(bool, tag = "4")]        AppealDeadlineIndefinite(bool),        #[prost(fixed64, tag = "5")]        AppealDeadlineUtcSeconds(u64),    }}

// An operation carries positional operands. The family of the enclosing body// member and the opcode fix the meaning and order of every entry in words and// blobs. The field-meaning table spec/operations.json lists, for each family// and opcode, the positions, enumerations and whether the reference// configuration accepts the operation.type Operation struct {	state  protoimpl.MessageState `protogen:"open.v1"`	Opcode *uint64                `protobuf:"varint,1,opt,name=opcode" json:"opcode,omitempty"`	Words  []uint64               `protobuf:"fixed64,2,rep,name=words" json:"words,omitempty"`	Blobs  [][]byte               `protobuf:"bytes,3,rep,name=blobs" json:"blobs,omitempty"`	// The appeal deadline of a regulatory action (family 2). Operations of	// other families reject both members. In this version an absent member and	// appeal_deadline_indefinite both mean that no appeal deadline applies.	//	// Types that are valid to be assigned to AppealDeadline:	//	//	*Operation_AppealDeadlineIndefinite	//	*Operation_AppealDeadlineUtcSeconds	AppealDeadline isOperation_AppealDeadline `protobuf_oneof:"appeal_deadline"`	unknownFields  protoimpl.UnknownFields	sizeCache      protoimpl.SizeCache}

fn present(&mut self) -> Result<bool> {    match self.word()? {        0 => Ok(false),        1 => Ok(true),        _ => Err(BAD),    }}fn optional_origin(&mut self) -> Result<Option<OriginKey>> {    if self.present()? {        Ok(Some(self.origin()?))    } else {        Ok(None)    }}fn optional_word(&mut self) -> Result<Option<u64>> {    if self.present()? {        Ok(Some(self.word()?))    } else {        Ok(None)    }}fn take(&mut self, count: usize) -> Result<&[u64]> {    let (items, remaining) = self.0.split_at_checked(count).ok_or(BAD)?;    self.0 = remaining;    Ok(items)}fn set(&mut self) -> Result<BTreeSet<u64>> {    let count = self.size()?;    let items = self.take(count)?;    if items.windows(2).any(|pair| pair[0] >= pair[1]) {        return Err(BAD);    }    Ok(items.iter().copied().collect())}fn end(&self) -> Result<()> {    if self.0.is_empty() { Ok(()) } else { Err(BAD) }}

func (w *words) present() (bool, error) {	value, err := w.word()	if err != nil || value > 1 {		return false, ErrFormat	}	return value == 1, nil}func (w *words) set() error {	count, err := w.word()	if err != nil {		return err	}	values, err := w.take(count)	if err != nil || !strictlySorted(values) {		return ErrFormat	}	return nil}func (w *words) optional(count uint64) error {	present, err := w.present()	if err == nil && present {		_, err = w.take(count)	}	return err}func (w *words) end() error {	if len(w.items) != 0 {		return ErrFormat	}	return nil}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]pub struct Unsigned256(pub [u8; 32]);impl Unsigned256 {    pub fn from_bytes(bytes: &[u8]) -> Result<Self> {        Ok(Self(bytes.try_into().map_err(|_| BAD)?))    }    pub fn product_amount(self) -> Result<u64> {        if self.0[..24].iter().any(|&byte| byte != 0) {            return Err(BAD);        }        Ok(u64::from_be_bytes(self.0[24..].try_into().unwrap()))    }}

type Unsigned256 [32]bytefunc DecodeAmount(raw []byte) (Unsigned256, error) {	if len(raw) != 32 {		return Unsigned256{}, ErrFormat	}	return Unsigned256(raw), nil}func (amount Unsigned256) ProductAmount() (uint64, error) {	for _, byte := range amount[:24] {		if byte != 0 {			return 0, ErrFormat		}	}	return binary.BigEndian.Uint64(amount[24:]), nil}

#[derive(Clone, Copy, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]pub struct Binding {    pub origin: OriginKey,    pub asset: AssetId,    pub owner: Principal,    pub destination: EndpointId,    pub recipient: Principal,    pub amount: u64,}impl Binding {    pub fn source(self) -> Account {        Account {            endpoint: self.origin.domain,            owner: self.owner,            asset: self.asset,        }    }    pub fn destination(self) -> Account {        Account {            endpoint: self.destination,            owner: self.recipient,            asset: self.asset,        }    }}#[derive(Clone, Copy, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]pub struct Credential {    pub asset: AssetId,    pub origin: OriginKey,    pub holder: Principal,    pub generation: u64,    pub epoch: u64,}

type Origin struct{ Domain, Event uint64 }type Binding struct {	Origin                                       Origin	Asset, Owner, Destination, Recipient, Amount uint64}type Credential struct {	Asset                     uint64	Origin                    Origin	Holder, Generation, Epoch uint64}

fn native<'a>(core: &Core, op: &'a Operation) -> Result<(CallId, CallPayload, Words<'a>)> {    let mut words = Words(&op.words);    let message_id = words.word()?;    let caller = core.principal.ok_or(BAD)?;    let id = CallId {        namespace: caller,        sequence: words.word()?,    };    let session = words.word()?;    let cut = CommitCut {        authority_epoch: core.authority_epoch.ok_or(BAD)?,        revision: words.size()?,    };    let origin_epoch = words.word()?;    let binding = Binding {        origin: words.origin()?,        asset: words.word()?,        owner: words.word()?,        destination: words.word()?,        recipient: words.word()?,        amount: amount(op.blobs.first().ok_or(BAD)?)?,    };    Ok((        id,        CallPayload {            message_id,            origin_epoch,            endpoint: core.target_domain.ok_or(BAD)?,            caller,            session,            cut,            binding,            credential: None,            versions: Vec::new(),            command: Command::PublishPrimary,        },        words,    ))}

// native reads the call prefix that ordinary, legal and spend operations// share: the words in order, then the amount in the first blob.func native(core *wirepb.Core, op *wirepb.Operation) (*Native, words, error) {	w := words{items: op.Words}	n := &Native{Namespace:core.GetPrincipal(),Endpoint:core.GetTargetDomain(),Caller:core.GetPrincipal()}	b := &n.Binding	if err := w.read(&n.Reference, &n.Sequence, &n.Session, &n.Revision, &n.OriginEpoch,		&b.Origin.Domain, &b.Origin.Event, &b.Asset, &b.Owner, &b.Destination, &b.Recipient); err != nil {		return nil, w, err	}	if len(op.Blobs) == 0 {		return nil, w, ErrFormat	}	value, err := amount(op.Blobs[0])	if err != nil {		return nil, w, err	}	b.Amount = value	return n, w, nil}