Message Protocol

pub fn decode(core: &Core, max_nesting: usize) -> Result<Operands> {    if max_nesting == 0 {        return Err(BAD);    }    let (family, op) = body(core)?;    match (family, op.opcode) {        (1, Some(6)) | (2, Some(3)) => spend(core, family, op),        (1 | 3, _) => ordinary(core, family, op),        (2, _) => legal(core, op),        (4, _) => read(op, max_nesting),        (5, _) => ack(core, op, max_nesting),        (6, _) => heartbeat(core, op),        (7, _) => governance(core, op),        _ => Err(BAD),    }}

func DecodeOperands(core *wirepb.Core, maxNesting int) (Operands, error) {	if maxNesting < 1 {		return Operands{}, ErrFormat	}	family, op := Body(core)	if op == nil {		return Operands{}, ErrFormat	}	opcode := op.GetOpcode()	typed := Operands{Family: family, Opcode: opcode, Words: slices.Clone(op.Words)}	for _, blob := range op.Blobs {		typed.Blobs = append(typed.Blobs, bytes.Clone(blob))	}	var err error	switch {	case (family == 1 && opcode == 6) || (family == 2 && opcode == 3):		typed.Native, err = spend(core, family, op)	case family == 1 || family == 3:		typed.Native, err = ordinary(core, family, op)	case family == 2:		typed.Native, err = legal(core, op)	case family == 4:		typed.Session, typed.Original, err = decodeRead(op,maxNesting,core.GetAuthorityEpoch(),&typed.TypedIR)	case family == 5:		typed.Original, err = ack(core,op,maxNesting,&typed.TypedIR)	case family == 6:		err = heartbeat(core,op,&typed.TypedIR)	case family == 7:		typed.Session, err = governance(core,op,&typed.TypedIR)	default:		err = ErrFormat	}	if typed.Native != nil {		typed.Session = typed.Native.Session		typed.TypedIR = typed.Native.Summary	}	if err != nil {		return Operands{}, err	}	return typed, nil}

let (authorization, proof) = if family == 2 {    let [_, _, proof] = op.blobs.as_slice() else {        return Err(BAD);    };    if proof.is_empty() {        return Err(BAD);    }    (        Some(EnforcementOrder {            scope,            officer: words.word()?,            jurisdiction: words.word()?,            legal_basis: words.word()?,            assets: words.set()?,            prior_seizure: words.optional_origin()?,            appeal_deadline: deadline(op),        }),        Some(proof.clone()),    )} else {    if op.blobs.len() != 2 || op.appeal_deadline.is_some() {        return Err(BAD);    }    (None, None)};

if family==2 {    if len(op.Blobs)!=3 || len(op.Blobs[2])==0 {return nil,ErrFormat}    var officer,jurisdiction,basis uint64    if err:=w.read(&officer,&jurisdiction,&basis);err!=nil {return nil,err}    assets,err:=w.valueSet();if err!=nil {return nil,err}    prior,err:=w.valueOptional(2);if err!=nil {return nil,err}    authorization=valueSome(valueNode(108,valueScalar(officer),valueScalar(jurisdiction),valueScalar(basis),valueScalars(assets),prior,valueDeadline(op)))    proof=valueSome(valueBytes(op.Blobs[2]))} else if len(op.Blobs)!=2 || op.AppealDeadline!=nil {return nil,ErrFormat}

fn opcode_allowed(family: u64, opcode: u64) -> bool {    [6, 3, 8, 8, 2, 2, 2]        .get((family.saturating_sub(1)) as usize)        .is_some_and(|last| (1..=*last).contains(&opcode))        && family != 0}

primary, scheme, atomicity, priority := core.GetPrimary(), core.GetSignatureScheme(), core.GetAtomicity(), core.GetPriority()last := [...]uint64{6, 3, 8, 8, 2, 2, 2}if primary < 1 || primary > 5 || (scheme != 1 && scheme != 2) || atomicity < 1 || atomicity > 3 ||	priority > 4 || (priority == 0 && atomicity != 3) || op.GetOpcode() < 1 || op.GetOpcode() > last[family-1] {	return nil, ErrFormat}

fn supported_frame(core: &Core) -> bool {    match core.body.as_ref() {        Some(Body::StateSync(op)) => matches!(op.opcode, Some(1..=6)),        Some(Body::RegulatoryAction(op)) => matches!(op.opcode, Some(1..=3)),        Some(Body::Ack(op)) => op.opcode == Some(1),        Some(Body::Query(op)) => matches!(op.opcode, Some(1..=8)),        Some(Body::LockManagement(op)) => matches!(op.opcode, Some(1..=6)),        Some(Body::Governance(op)) => op.opcode == Some(1),        _ => false,    }}

// ReferenceAccepts reports whether the reference configuration executes the// operation of a decoded Core. It accepts 25 of the 31 operations of version// 6 and refuses Write, Timeout, CorrelatedResponse, Capabilities, Liveness// and InstallEpoch.func ReferenceAccepts(core *wirepb.Core) bool {	family, op := Body(core)	opcode := op.GetOpcode()	switch family {	case 1, 3:		return opcode >= 1 && opcode <= 6	case 2:		return opcode >= 1 && opcode <= 3	case 4:		return opcode >= 1 && opcode <= 8	case 5, 7:		return opcode == 1	default:		return false	}}

let frame_limit = product.security.frame_limit(channel);if bytes.len() > frame_limit {    return Err(WireError::InvalidFormat);}let input = match channel.profile().version {    6 => {        check_declared_version(bytes, frame_limit)?;        Input::Modern(Box::new(decode_packet(bytes, frame_limit)?))    }    5 if product.security.legacy_configured(channel) => Input::Legacy {        bytes,        core: Box::new(legacy::decode_shape(bytes, frame_limit)?),    },    _ => return Err(WireError::UnsupportedVersion),};check_operation(product.security.as_ref(), channel, input.core())?;if !product.security.matches_signed_packet(bytes, credentials.signature) {    return Err(WireError::InvalidSignature);}let core = input.core();let boundary = boundary_for(product.security.as_ref(), channel, core, deployment, cut)?;if bytes.len() > boundary.max_frame {    return Err(WireError::InvalidFormat);}gate_delivery(delivery, boundary.now, ordered.is_none())?;if ordered.is_none() && product.security.delivery_cancelled(core) {    return Err(WireError::Cancelled);}let legacy = input.verify(channel, &boundary)?;check_delivery_ttl(product.security.as_ref(), channel, core)?;let operands = decode(core, boundary.max_nesting)?;

// ReceiveAccepting is Receive with the operation check that a configuration// runs in front of the admission gate. An operation that accepts refuses// receives ErrVersion before any signature or source check. A nil accepts// admits every operation.func (store *TransportBindings) ReceiveAccepting(raw []byte, profile Profile, boundary Boundary,	accepts func(*wirepb.Core) bool, attest func(*wirepb.Core) bool) (Arrival, *CanonicalPacket, error) {	if profile.Version != 6 {		return First, nil, ErrVersion	}	if err := CheckDeclaredVersion(raw, boundary.MaxFrame); err != nil {		return First, nil, err	}	packet, err := DecodePacket(raw, boundary.MaxFrame)	if err != nil {		return First, nil, err	}	// Decode and bind the signed Core without exposing it to either callback.	signedCore := packet.Core()	if accepts != nil && !accepts(packet.Core()) {		return First, nil, ErrVersion	}	if err = AdmitPacket(packet, profile, boundary); err != nil {		return First, nil, err	}	if !attest(packet.Core()) {		return First, nil, ErrSource	}	decodedOperands, err := DecodeOperands(signedCore, boundary.MaxNesting)	if err != nil {		return First, nil, err	}

if nested.version != core.version    || nested.deployment != core.deployment    || nested.principal != Some(id.namespace)    || nested.source_domain != core.target_domain    || nested.target_domain != core.source_domain{    return Err(WireError::InvalidSource);}let matches_debit_revision =    |revision| commit.is_none_or(|reference| reference.position == revision);match decoded {    Operands::Ordinary { id: nested, payload, .. } => {        if nested != id || (matches!(payload.command, Command::Debit { .. })            && !matches_debit_revision(payload.cut.revision))        {            return Err(BAD);        }    }    Operands::Legal { id: nested, .. }    | Operands::Spend { id: nested, .. }        if nested != id =>    {        return Err(BAD);    }    Operands::Receipt { original, .. } => {        if !same_original(&nested, &original) {            return Err(WireError::InvalidSource);        }        let (family, operation) = body(&original)?;        let (nested_id, payload, _) = native(&original, operation)?;        if nested_id != id || (family == 1 && operation.opcode == Some(1)            && !matches_debit_revision(payload.cut.revision))        {            return Err(BAD);        }    }    Operands::Response { .. } => return Err(BAD),    _ => (),}

if original.GetVersion() != core.GetVersion() || original.GetDeployment() != core.GetDeployment() ||	original.GetPrincipal() != namespace || original.GetSourceDomain() != core.GetTargetDomain() ||	original.GetTargetDomain() != core.GetSourceDomain() {	return nil, ErrSource}// A committed Debit response names the revision that the Debit names.debitAt := func(family, opcode, revision uint64) bool {	return family != 1 || opcode != 1 || !committed || position == revision}switch {case nested.Family == 5 && nested.Opcode == 2:	return nil, ErrFormatcase nested.Native != nil:	if nested.Native.Sequence != sequence || !debitAt(nested.Family, nested.Opcode, nested.Native.Revision) {		return nil, ErrFormat	}case nested.Family == 4 && nested.Opcode == 8:	// A receipt request answers for the original call that it carries.	inner := nested.Original	if !sameOriginal(original, inner) {		return nil, ErrSource	}	family, innerOp := Body(inner)	if innerOp == nil {		return nil, ErrFormat	}	call, _, err := native(inner,innerOp)	if err != nil {		return nil, err	}	if inner.GetPrincipal() != namespace || call.Sequence != sequence ||		!debitAt(family, innerOp.GetOpcode(), call.Revision) {		return nil, ErrFormat	}}

fn append_set(out: &mut Vec<u8>, set: &BTreeSet<u64>) {    out.extend((set.len() as u64).to_be_bytes());    for value in set {        out.extend(value.to_be_bytes());    }}pub fn offer_bytes(offer: &Offer) -> Vec<u8> {    let mut out = b"OIP\0HEARTBEAT-OFFER\0".to_vec();    for value in [        offer.deployment,        offer.sender,        offer.receiver,        offer.challenge,        offer.expires,    ] {        out.extend(value.to_be_bytes());    }    for set in [        &offer.versions,        &offer.families,        &offer.atomicities,        &offer.schemes,    ] {        append_set(&mut out, set);    }    out}pub fn confirmation_bytes(local: &Offer, remote: &Offer, profile: &Profile) -> Vec<u8> {    let mut out = b"OIP\0HEARTBEAT-PROFILE\0".to_vec();    for offer in [local, remote] {        let bytes = offer_bytes(offer);        out.extend((bytes.len() as u64).to_be_bytes());        out.extend(bytes);    }    out.extend(profile.version.to_be_bytes());    for set in [&profile.families, &profile.atomicities, &profile.schemes] {        append_set(&mut out, set);    }    out}

func appendSet(out []byte, values []uint64) []byte {	out = binary.BigEndian.AppendUint64(out, uint64(len(values)))	for _, v := range values {		out = binary.BigEndian.AppendUint64(out, v)	}	return out}func OfferBytes(offer Offer) []byte {	out := []byte("OIP\x00HEARTBEAT-OFFER\x00")	for _, v := range []uint64{offer.Deployment, offer.Sender, offer.Receiver, offer.Challenge, offer.Expires} {		out = binary.BigEndian.AppendUint64(out, v)	}	for _, set := range [][]uint64{offer.Versions, offer.Families, offer.Atomicities, offer.Schemes} {		out = appendSet(out, set)	}	return out}func ConfirmationBytes(local, remote Offer, profile Profile) []byte {	out := []byte("OIP\x00HEARTBEAT-PROFILE\x00")	for _, offer := range []Offer{local, remote} {		bytes := OfferBytes(offer)		out = binary.BigEndian.AppendUint64(out, uint64(len(bytes)))		out = append(out, bytes...)	}	out = binary.BigEndian.AppendUint64(out, profile.Version)	for _, set := range [][]uint64{profile.Families, profile.Atomicities, profile.Schemes} {		out = appendSet(out, set)	}	return out}

pub fn select_profile(    local: &Offer,    remote: &Offer,    floor: u64,    legacy_allowed: bool,) -> Result<Profile> {    let version = [6, 5]        .into_iter()        .find(|&version| {            version >= floor                && (version != 5 || legacy_allowed)                && local.versions.contains(&version)                && remote.versions.contains(&version)        })        .ok_or(WireError::UnsupportedVersion)?;    Ok(Profile {        version,        families: local            .families            .intersection(&remote.families)            .copied()            .filter(|family| version != 5 || matches!(family, 4 | 6))            .collect(),        atomicities: local            .atomicities            .intersection(&remote.atomicities)            .copied()            .collect(),        schemes: local            .schemes            .intersection(&remote.schemes)            .copied()            .filter(|scheme| version != 5 || *scheme == 1)            .collect(),    })}

func SelectProfile(local, remote Offer, floor uint64, legacyAllowed bool) (Profile, error) {	for _, s := range [][]uint64{local.Versions, local.Families, local.Atomicities, local.Schemes,		remote.Versions, remote.Families, remote.Atomicities, remote.Schemes} {		if !strictlySorted(s) {			return Profile{}, ErrFormat		}	}	for _, v := range []uint64{6, 5} {		if v >= floor && (v != 5 || legacyAllowed) && slices.Contains(local.Versions, v) && slices.Contains(remote.Versions, v) {			families := intersect(local.Families, remote.Families)			schemes := intersect(local.Schemes, remote.Schemes)			if v == 5 {				families = intersect(families, []uint64{4, 6})				schemes = intersect(schemes, []uint64{1})			}			return Profile{Version: v, Families: families, Atomicities: intersect(local.Atomicities, remote.Atomicities), Schemes: schemes}, nil		}	}	return Profile{}, ErrVersion}

pub fn negotiate(context: &Negotiation, signed: SignedOffers<'_>) -> Result<Channel> {    let local = signed.local;    let remote = signed.remote;    if local.deployment != context.deployment        || remote.deployment != context.deployment        || local.sender != context.local        || local.receiver != context.remote        || remote.sender != context.remote        || remote.receiver != context.local        || local.challenge != context.challenge        || remote.challenge != context.challenge        || local.expires < context.now        || remote.expires < context.now    {        return Err(WireError::InvalidSource);    }    if !verify(        &context.local_key,        &offer_bytes(local),        signed.local_signature,    ) || !verify(        &context.remote_key,        &offer_bytes(remote),        signed.remote_signature,    ) {        return Err(WireError::InvalidSignature);    }    let profile = select_profile(local, remote, context.floor, context.legacy_allowed)?;    if !verify(        &context.remote_key,        &confirmation_bytes(local, remote, &profile),        signed.confirmation,    ) {        return Err(WireError::InvalidSignature);    }    Ok(Channel {        profile,        deployment: context.deployment,        local: context.local,        remote: context.remote,        expires: local.expires.min(remote.expires),        challenge: context.challenge,        peer_keys: [context.local_key, context.remote_key],    })}

func Negotiate(context Negotiation, signed SignedOffers) (Channel, error) {	l, r := signed.Local, signed.Remote	if l.Deployment != context.Deployment || r.Deployment != context.Deployment ||		l.Sender != context.Local || l.Receiver != context.Remote || r.Sender != context.Remote || r.Receiver != context.Local ||		l.Challenge != context.Challenge || r.Challenge != context.Challenge || l.Expires < context.Now || r.Expires < context.Now {		return Channel{}, ErrSource	}	if !verify(context.LocalKey, OfferBytes(l), signed.LocalSignature) ||		!verify(context.RemoteKey, OfferBytes(r), signed.RemoteSignature) {		return Channel{}, ErrSignature	}	profile, err := SelectProfile(l, r, context.Floor, context.LegacyAllowed)	if err != nil {		return Channel{}, err	}	if !verify(context.RemoteKey, ConfirmationBytes(l, r, profile), signed.Confirmation) {		return Channel{}, ErrSignature	}	return Channel{profile: profile, deployment: context.Deployment, local: context.Local, remote: context.Remote,		challenge: context.Challenge, expires: min(l.Expires, r.Expires), keys: [2][32]byte{context.LocalKey, context.RemoteKey}}, nil}