Struct SURB 

pub struct SURB<S: SphinxSuite, H: SphinxHeaderSpec> {
    pub first_relayer: H::KeyId,
    pub alpha: GenericArray<u8, <S::G as GroupElement<S::E>>::AlphaLen>,
    pub header: RoutingInfo<H>,
    pub sender_key: SecretKey16,
    pub additional_data_receiver: H::SurbReceiverData,
}

Single Use Reply Block

This is delivered to the recipient, so they are able to send reply messages back anonymously (via the return path inside that SURB).

SURB is always created in a pair with ReplyOpener, so that the sending party knows how to decrypt the data.

The SURB sent to the receiving party must be accompanied by a Pseudonym, and once the receiving party uses that SURB to send a reply, it must be accompanied by the same Pseudonym. Upon receiving such a reply, the reply recipient (= sender of the SURB) uses the Pseudonym to find the ReplyOpener created with the SURB to read the reply.

Always use create_surb to create the SURB and ReplyOpener pair.

Fields

first_relayer: H::KeyId

ID of the first relayer.

alpha: GenericArray<u8, <S::G as GroupElement<S::E>>::AlphaLen>

Alpha value for the header.

header: RoutingInfo<H>

Sphinx routing header.

sender_key: SecretKey16

Encryption key to use to encrypt the data for the SURB’s creator.

additional_data_receiver: H::SurbReceiverData

Additional data for the SURB receiver.

Implementations

impl<S: SphinxSuite, H: SphinxHeaderSpec> SURB<S, H>

pub const SIZE: usize

Size of the SURB in bytes.

pub fn into_boxed(self) -> Box<[u8]>

Serializes SURB into wire format.

pub fn get_hash(&self, context: &[u8]) -> Hash

Computes Keccak256 hash of the SURB.

The given context is appended to the input.

Trait Implementations

impl<S: SphinxSuite, H: SphinxHeaderSpec> Clone for SURB<S, H>

where H::KeyId: Clone, H::SurbReceiverData: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: SphinxSuite, H: SphinxHeaderSpec> Debug for SURB<S, H>

where H::KeyId: Debug, H::SurbReceiverData: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, S: SphinxSuite, H> Deserialize<'de> for SURB<S, H>

where H: Deserialize<'de> + SphinxHeaderSpec, H::KeyId: Deserialize<'de>, H::SurbReceiverData: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S: SphinxSuite, H: SphinxHeaderSpec> PartialEq for SURB<S, H>

where H::KeyId: PartialEq, H::SurbReceiverData: PartialEq,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S: SphinxSuite, H> Serialize for SURB<S, H>

where H: Serialize + SphinxHeaderSpec, H::KeyId: Serialize, H::SurbReceiverData: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, S: SphinxSuite, H: SphinxHeaderSpec> TryFrom<&'a [u8]> for SURB<S, H>

type Error = GeneralError

The type returned in the event of a conversion error.

fn try_from(value: &'a [u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl<S: SphinxSuite, H: SphinxHeaderSpec> Eq for SURB<S, H>

where H::KeyId: Eq, H::SurbReceiverData: Eq,