Struct farcaster_core::protocol::Parameters

pub struct Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr> {

    pub buy: Pk,
    pub cancel: Pk,
    pub refund: Pk,
    pub punish: Option<Pk>,
    pub adaptor: Pk,
    pub extra_arbitrating_keys: Vec<TaggedElement<u16, Pk>>,
    pub arbitrating_shared_keys: Vec<TaggedElement<SharedKeyId, Rk>>,
    pub spend: Qk,
    pub extra_accordant_keys: Vec<TaggedElement<u16, Qk>>,
    pub accordant_shared_keys: Vec<TaggedElement<SharedKeyId, Sk>>,
    pub proof: Option<Pr>,
    pub destination_address: Addr,
    pub cancel_timelock: Option<Ti>,
    pub punish_timelock: Option<Ti>,
    pub fee_strategy: Option<FeeStrategy<F>>,
}

One has to produce a set of parameters at the start of a swap and receive a mostly equivalent set from counter-party during the reveal procedure. Container for all the parameters a participant needs to execture a swap.

The proof is optional because one receives the proof after receiving the parameters in the receal process, the option allows to create the struct at the first step and add the swap if needed later.

Timelocks and fee strategy are only present in the local set of parameters and not part of the reveal process, thus they are optional too.

Fields

buy: Pk

cancel: Pk

refund: Pk

punish: Option<Pk>

adaptor: Pk

extra_arbitrating_keys: Vec<TaggedElement<u16, Pk>>

arbitrating_shared_keys: Vec<TaggedElement<SharedKeyId, Rk>>

spend: Qk

extra_accordant_keys: Vec<TaggedElement<u16, Qk>>

accordant_shared_keys: Vec<TaggedElement<SharedKeyId, Sk>>

proof: Option<Pr>

destination_address: Addr

cancel_timelock: Option<Ti>

punish_timelock: Option<Ti>

fee_strategy: Option<FeeStrategy<F>>

Implementations

impl<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr> Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>where
    Pk: Clone + CanonicalBytes,
    Qk: CanonicalBytes,
    Rk: CanonicalBytes,
    Sk: CanonicalBytes,

pub fn commit_alice<C: Clone + Eq, U: Into<SwapId>>(
    &self,
    swap_id: U,
    wallet: &impl Commit<C>
) -> CommitAliceParameters<C>

Generates protocol message that commits to Alice’s parameters.

pub fn reveal_alice<U: Into<SwapId>>(
    self,
    swap_id: U
) -> RevealAliceParameters<Pk, Qk, Rk, Sk, Addr, Pr>

Create the reveal protocol message based on the set of parameters.

pub fn commit_bob<C: Clone + Eq, U: Into<SwapId>>(
    &self,
    swap_id: U,
    wallet: &impl Commit<C>
) -> CommitBobParameters<C>

Generates protocol message that commits to Bob’s parameters.

pub fn reveal_bob<U: Into<SwapId>>(
    self,
    swap_id: U
) -> RevealBobParameters<Pk, Qk, Rk, Sk, Addr, Pr>

Create the reveal protocol message based on the set of parameters.

Trait Implementations

impl<Pk: Clone, Qk: Clone, Rk: Clone, Sk: Clone, Addr: Clone, Ti: Clone, F: Clone, Pr: Clone> Clone for Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>

fn clone(&self) -> Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Pk: Debug, Qk: Debug, Rk: Debug, Sk: Debug, Addr: Debug, Ti: Debug, F: Debug, Pr: Debug> Debug for Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>

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

Formats the value using the given formatter.

impl<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr> Decodable for Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>where
    Pk: CanonicalBytes,
    Qk: CanonicalBytes,
    Rk: CanonicalBytes,
    Sk: CanonicalBytes,
    Addr: CanonicalBytes,
    Ti: CanonicalBytes,
    F: CanonicalBytes,
    Pr: CanonicalBytes,

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

Decode an object with a well-defined format

impl<'de, Pk, Qk, Rk, Sk, Addr, Ti, F, Pr> Deserialize<'de> for Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>where
    Pk: Deserialize<'de>,
    Qk: Deserialize<'de>,
    Rk: Deserialize<'de>,
    Sk: Deserialize<'de>,
    Addr: Deserialize<'de>,
    Ti: Deserialize<'de>,
    F: Deserialize<'de>,
    Pr: Deserialize<'de>,

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

Deserialize this value from the given Serde deserializer.

impl<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr> Encodable for Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>where
    Pk: CanonicalBytes,
    Qk: CanonicalBytes,
    Rk: CanonicalBytes,
    Sk: CanonicalBytes,
    Addr: CanonicalBytes,
    Ti: CanonicalBytes,
    F: CanonicalBytes,
    Pr: CanonicalBytes,

fn consensus_encode<W: Write>(&self, writer: &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<Pk: Hash, Qk: Hash, Rk: Hash, Sk: Hash, Addr: Hash, Ti: Hash, F: Hash, Pr: Hash> Hash for Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>

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<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr> Serialize for Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>where
    Pk: Serialize,
    Qk: Serialize,
    Rk: Serialize,
    Sk: Serialize,
    Addr: Serialize,
    Ti: Serialize,
    F: Serialize,
    Pr: Serialize,

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

Serialize this value into the given Serde serializer.

impl<Pk: CanonicalBytes, Qk: CanonicalBytes, Rk: CanonicalBytes, Sk: CanonicalBytes, Addr: CanonicalBytes, Ti: CanonicalBytes, F: CanonicalBytes, Pr: CanonicalBytes> StrictDecode for Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>

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<Pk: CanonicalBytes, Qk: CanonicalBytes, Rk: CanonicalBytes, Sk: CanonicalBytes, Addr: CanonicalBytes, Ti: CanonicalBytes, F: CanonicalBytes, Pr: CanonicalBytes> StrictEncode for Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>

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.