Struct farcaster_core::protocol::Bob

pub struct Bob<Addr, Ar, Ac> {
    pub arbitrating: Ar,
    pub accordant: Ac,
    pub refund_address: Addr,
    pub fee_politic: FeePriority,
}

Bob, a SwapRole, starts with arbitrating blockchain assets and exchange them for accordant blockchain assets.

Fields

arbitrating: Ar

The arbitrating blockchain to use during the swap

accordant: Ac

The accordant blockchain to use during the swap

refund_address: Addr

An arbitrating address where, if unsuccessfully executed, the funds exchanged will be sent back to

fee_politic: FeePriority

The fee politic to apply during the swap fee calculation

Implementations

impl<Addr, Ar, Ac> Bob<Addr, Ar, Ac>

pub fn new(
    arbitrating: Ar,
    accordant: Ac,
    refund_address: Addr,
    fee_politic: FeePriority
) -> Self

Create a new Bob role with the local parameters.

impl<Addr, Ar, Ac> Bob<Addr, Ar, Ac>where
    Addr: Clone,

pub fn generate_parameters<Amt, Bmt, Pk, Qk, Rk, Sk, Ti, F, Pr, Kg>(
    &self,
    key_gen: &mut Kg,
    deal: &Deal<Amt, Bmt, Ti, F>
) -> Res<Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>>where
    Ar: DeriveKeys<PublicKey = Pk, PrivateKey = Rk>,
    Ac: DeriveKeys<PublicKey = Qk, PrivateKey = Sk>,
    Ti: Copy,
    F: Clone,
    Kg: KeyGenerator<Pk, Qk, Rk, Sk, Pr>,

Generate Bob’s parameters for the protocol execution based on a key generator.

Safety

All the data passed to the function are considered trusted and does not require extra validation. The deal is assumend to be validated by user upfront.

pub fn core_arbitrating_transactions<Amt, Tx, Px, Pk, Qk, Rk, Sk, Ti, F, Pr, Out>(
    &self,
    alice_parameters: &Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>,
    bob_parameters: &Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>,
    funding: impl Fundable<Tx, Out, Addr, Pk>,
    arb_params: ArbitratingParameters<Amt, Ti, F>
) -> Res<CoreArbitratingTransactions<Px>>where
    Ar: Transactions<Addr = Addr, Amt = Amt, Tx = Tx, Out = Out, Ti = Ti, Pk = Pk, Px = Px>,
    Px: Fee<FeeUnit = F>,
    Out: Eq,
    Pk: Copy,
    Amt: Copy,
    Ti: Copy,

Initialize the core arbitrating transactions composed of: Lockable, Cancelable, and Refundable transactions.

Safety

Alice’s Parameters (i.e. counter-party parameters) are created and validated with the protocol messages that commit and reveal the values.

This function assumes that the commit/reveal scheme has been validated and assumes that all cryptographic proof needed for securing the system have passed the validation.

Previously verified data:

• alice_parameters: Alice’s parameters
• arb_params: The core arbitrating parameter used in verification

Trusted data:

• bob_parameters: Bob’s own parameters
• funding: Bob’s own funding transaction

Execution

The parameters to create the three transactions are:

• Alice’s public keys present in Alice’s Parameters
• Bob’s public keys present in Bob’s Parameters
• The Fundable transaction
• The FeeStrategy and the FeePriority

The lock transaction is initialized by passing the DataLock structure, then the cancel transaction is initialized based on the lock transaction with the DataPunishableLock structure, then the punish is initialized based on the cancel transaction.

Transaction Fee

The fee on each transactions are set according to the FeeStrategy specified in the deal and the FeePriority in self.

pub fn cosign_arbitrating_cancel<S, Px, Si, Pk, Ms>(
    &self,
    wallet: &mut S,
    core: &CoreArbitratingTransactions<Px>
) -> Res<Si>where
    S: Sign<Pk, Ms, Si>,
    Ar: Transactions<Addr = Addr, Ms = Ms, Pk = Pk, Si = Si, Px = Px>,
    Px: Clone,

Co-sign the arbitrating Cancelable transaction.

Safety

All the data passed to cosign_arbitrating_cancel are considered trusted.

The signature is created by Bob and does not require any extra validation.

Execution

• Parse the Cancelable partial transaction in CoreArbitratingTransactions
• Retreive the cancel public key from the paramters
• Generate the witness data and sign it

Returns the signature.

pub fn validate_adaptor_refund<Amt, Px, Pk, Qk, Rk, Sk, Ti, F, Pr, S, Ms, Si, EncSig>(
    &self,
    wallet: &mut S,
    alice_parameters: &Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>,
    bob_parameters: &Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>,
    core: &CoreArbitratingTransactions<Px>,
    refund_adaptor_sig: &EncSig
) -> Res<()>where
    S: EncSign<Pk, Ms, Si, EncSig>,
    Ar: Transactions<Addr = Addr, Amt = Amt, Ti = Ti, Ms = Ms, Pk = Pk, Si = Si, Px = Px>,
    Px: Clone,

Validates the adaptor refund witness based on the parameters and the core arbitrating transactions.

Safety

Alice’s Parameters (i.e. counter-party parameters) are created and validated with the protocol messages that commit and reveal the values.

This function assumes that the commit/reveal scheme has been validated and assumes that all cryptographic proof needed for securing the system have passed the validation.

CoreArbitratingTransactions protocol message is created by Bob and does not require any extra validation.

Previously verified data:

• alice_parameters: Alice’s parameters

Trusted data:

• bob_parameters: Bob’s own parameters
• core: Core arbitrating transactions

Verified data:

• refund_adaptor_sig: The adaptor witness to verify

Execution

• Parse the Refundable partial transaction in CoreArbitratingTransactions
• Verify the adaptor witness with the public keys from the parameters

Return Ok(()) if all tests succeed.

pub fn sign_adaptor_buy<Amt, Px, Pk, Qk, Rk, Sk, Ti, F, Pr, S, Ms, Si, EncSig, U>(
    &self,
    swap_id: U,
    wallet: &mut S,
    alice_parameters: &Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>,
    bob_parameters: &Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>,
    core: &CoreArbitratingTransactions<Px>,
    arb_params: ArbitratingParameters<Amt, Ti, F>
) -> Res<BuyProcedureSignature<Px, EncSig>>where
    S: EncSign<Pk, Ms, Si, EncSig>,
    Ar: Transactions<Addr = Addr, Amt = Amt, Ti = Ti, Ms = Ms, Pk = Pk, Si = Si, Px = Px>,
    Px: Clone + Fee<FeeUnit = F>,
    Pk: Copy,
    Ti: Copy,
    U: Into<SwapId>,

Creates the Buyable transaction and generate the adaptor witness

Safety

This function MUST NOT be run if validate_adaptor_refund is not successful.

This function MUST NOT be run if the accordant assets are not confirmed on-chain.

Alice’s Parameters (i.e. counter-party parameters) are created and validated with the protocol messages that commit and reveal the values.

This function assumes that the commit/reveal scheme has been validated and assumes that all cryptographic proof needed for securing the system have passed the validation.

CoreArbitratingTransactions protocol message is created by Bob and does not require any extra validation.

Previously verified data:

• alice_parameters: Alice’s parameters
• arb_params: The parameters used to verify core

Trusted data:

• wallet: Bob’s own wallet, used to perform cryptographic operations
• bob_parameters: Bob’s own parameters
• core: Core arbitrating transactions

Execution

• Parse the Lockable partial transaction in CoreArbitratingTransactions
• Generate the DataLock structure from Alice and Bob parameters and the deal
• Retrieve Alice’s adaptor public key from Alice’s Parameters
• Retreive the buy public key from the paramters
• Generate the adaptor witness data and sign it

Returns the partial transaction and the signature inside the BuyProcedureSignature protocol message.

pub fn sign_arbitrating_lock<S, Px, Si, Pk, Ms>(
    &self,
    wallet: &mut S,
    core: &CoreArbitratingTransactions<Px>
) -> Res<Si>where
    S: Sign<Pk, Ms, Si>,
    Ar: Transactions<Addr = Addr, Ms = Ms, Pk = Pk, Si = Si, Px = Px>,
    Px: Clone,

Sign the arbitrating Lockable transaction and return the signature.

Safety

This function MUST NOT be run if validate_adaptor_refund is not successful.

All the data passed to sign_arbitrating_lock are considered trusted.

CoreArbitratingTransactions protocol message is created by Bob and does not require any extra validation.

Execution

• Parse the Lockable partial transaction in CoreArbitratingTransactions
• Retreive the funding public key from the paramters
• Generate the witness data and sign it

Returns the signature.

pub fn fully_sign_refund<S, Px, Si, Pk, Ms, EncSig>(
    &self,
    wallet: &mut S,
    core: &CoreArbitratingTransactions<Px>,
    signed_adaptor_refund: &EncSig
) -> Res<TxSignatures<Si>>where
    S: Sign<Pk, Ms, Si> + EncSign<Pk, Ms, Si, EncSig>,
    Ar: Transactions<Addr = Addr, Ms = Ms, Pk = Pk, Si = Si, Px = Px>,
    EncSig: Clone,
    Px: Clone,

Sign the arbitrating Refundable transaction and adapt the counter-party adaptor witness with the private adaptor key.

Safety

This function MUST NOT be run if validate_adaptor_refund is not successful.

The encrypted signature is created by Alice and must be verified to be a valid.

This function assumes that the adaptor signature has been validated and assumes that all cryptographic proof needed for securing the system have passed the validation.

CoreArbitratingTransactions protocol message is created by Bob and does not require any extra validation.

Execution

• Parse the Refundable partial transaction in CoreArbitratingTransactions
• Retreive the refund public key from the paramters
• Generate the refund witness data
• Retreive the adaptor public key from the pamaters
• Adapt the signature

Returns the signatures inside a TxSignatures structure.

pub fn recover_accordant_key<S, Tx, Px, Si, Pk, Qk, Rk, Sk, Ti, F, Pr, EncSig>(
    &self,
    wallet: &mut S,
    alice_parameters: &Parameters<Pk, Qk, Rk, Sk, Addr, Ti, F, Pr>,
    buy_adaptor_sig: EncSig,
    buy_tx: Tx
) -> Rkwhere
    S: RecoverSecret<Pk, Rk, Si, EncSig>,
    Ar: Transactions<Addr = Addr, Tx = Tx, Px = Px, Pk = Pk, Si = Si>,

This function allows to recover the secret key used to encrypt the buy signature, allowing Bob to recover Alice’s secret and transfer ownership of funds.

Trait Implementations

impl<Addr: Clone, Ar: Clone, Ac: Clone> Clone for Bob<Addr, Ar, Ac>

fn clone(&self) -> Bob<Addr, Ar, Ac>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Addr: Debug, Ar: Debug, Ac: Debug> Debug for Bob<Addr, Ar, Ac>

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

Formats the value using the given formatter.

impl<Addr, Ar, Ac> Decodable for Bob<Addr, Ar, Ac>where
    Ar: Decodable,
    Ac: Decodable,
    Addr: CanonicalBytes,

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

Decode an object with a well-defined format

impl<Addr, Ar, Ac> Encodable for Bob<Addr, Ar, Ac>where
    Ar: Encodable,
    Ac: Encodable,
    Addr: 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.