Struct farcaster_core::protocol::message::CommitAliceParameters

pub struct CommitAliceParameters<C> {
    pub swap_id: SwapId,
    pub buy: C,
    pub cancel: C,
    pub refund: C,
    pub punish: C,
    pub adaptor: C,
    pub extra_arbitrating_keys: Vec<TaggedElement<u16, C>>,
    pub arbitrating_shared_keys: Vec<TaggedElement<SharedKeyId, C>>,
    pub spend: C,
    pub extra_accordant_keys: Vec<TaggedElement<u16, C>>,
    pub accordant_shared_keys: Vec<TaggedElement<SharedKeyId, C>>,
}

Forces Alice to commit to the result of her cryptographic setup before receiving Bob’s setup. This is done to remove adaptive behavior in the cryptographic parameters.

Fields

swap_id: SwapId

The swap identifier related to this message.

buy: C

Commitment to the buy public key.

cancel: C

Commitment to the cancel public key.

refund: C

Commitment to the refund public key.

punish: C

Commitment to the punish public key.

adaptor: C

Commitment to the adaptor public key.

extra_arbitrating_keys: Vec<TaggedElement<u16, C>>

Commitments to the extra arbitrating public keys.

arbitrating_shared_keys: Vec<TaggedElement<SharedKeyId, C>>

Commitments to the arbitrating shared keys.

spend: C

Commitment to the spend public key.

extra_accordant_keys: Vec<TaggedElement<u16, C>>

Commitments to the extra accordant public keys.

accordant_shared_keys: Vec<TaggedElement<SharedKeyId, C>>

Commitments to the accordant shared keys.

Implementations

impl<C> CommitAliceParameters<C>where
    C: Eq + Clone + CanonicalBytes,

pub fn verify_with_reveal<Pk, Qk, Rk, Sk, Addr, Pr>(
    &self,
    wallet: &impl Commit<C>,
    reveal: RevealAliceParameters<Pk, Qk, Rk, Sk, Addr, Pr>
) -> Result<(), Error>where
    Pk: CanonicalBytes,
    Qk: CanonicalBytes,
    Rk: CanonicalBytes,
    Sk: CanonicalBytes,

Trait Implementations

impl<C: Clone> Clone for CommitAliceParameters<C>

fn clone(&self) -> CommitAliceParameters<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Debug> Debug for CommitAliceParameters<C>

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

Formats the value using the given formatter.

impl<C> Decodable for CommitAliceParameters<C>where
    C: CanonicalBytes,

fn consensus_decode<D: Read>(d: &mut D) -> Result<Self, Error>

Decode an object with a well-defined format

impl<'de, C> Deserialize<'de> for CommitAliceParameters<C>where
    C: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C> Display for CommitAliceParameters<C>where
    C: Debug,

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

Formats the value using the given formatter.

impl<C> Encodable for CommitAliceParameters<C>where
    C: CanonicalBytes,

fn consensus_encode<W: Write>(&self, s: &mut W) -> Result<usize, Error>

Encode an object with a well-defined format, should only ever error if the underlying encoder errors. If successful, returns size of the encoded object in bytes.

impl<C: Hash> Hash for CommitAliceParameters<C>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<C: PartialEq> PartialEq<CommitAliceParameters<C>> for CommitAliceParameters<C>

fn eq(&self, other: &CommitAliceParameters<C>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<C> Serialize for CommitAliceParameters<C>where
    C: Serialize,

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

Serialize this value into the given Serde serializer.

impl<C: CanonicalBytes> StrictDecode for CommitAliceParameters<C>

fn strict_decode<D: Read>(d: D) -> Result<Self, Error>

Decode with the given std::io::Read instance; must either construct an instance or return implementation-specific error type.

fn strict_deserialize(data: impl AsRef<[u8]>) -> Result<Self, Error>

Tries to deserialize byte array into the current type using StrictDecode::strict_decode. If there are some data remains in the buffer once deserialization is completed, fails with Error::DataNotEntirelyConsumed. Use io::Cursor over the buffer and StrictDecode::strict_decode to avoid such failures.

fn strict_file_load(path: impl AsRef<Path>) -> Result<Self, Error>

Reads data from file at path and reconstructs object from it. Fails with Error::DataNotEntirelyConsumed if file contains remaining data after the object reconstruction.

impl<C: CanonicalBytes> StrictEncode for CommitAliceParameters<C>

fn strict_encode<E: Write>(&self, e: E) -> Result<usize, Error>

Encode with the given std::io::Write instance; must return result with either amount of bytes encoded – or implementation-specific error type.

fn strict_serialize(&self) -> Result<Vec<u8, Global>, Error>

Serializes data as a byte array using StrictEncode::strict_encode function

fn strict_file_save(&self, path: impl AsRef<Path>) -> Result<usize, Error>

Saves data to a file at a given path. If the file does not exists, attempts to create the file. If the file already exists, it gets truncated.

impl<C: Eq> Eq for CommitAliceParameters<C>

impl<C> StructuralEq for CommitAliceParameters<C>

impl<C> StructuralPartialEq for CommitAliceParameters<C>