Struct IncomingContract

pub struct IncomingContract {
    pub hash: Hash,
    pub encrypted_preimage: EncryptedPreimage,
    pub decrypted_preimage: DecryptedPreimage,
    pub gateway_key: PublicKey,
}

Specialized smart contract for incoming payments

A user generates a private/public keypair that can later be used to claim the incoming funds. The public key is defined as the preimage of a payment hash and threshold-encrypted to the federation’s public key. They then put up the encrypted preimage for sale by creating an IncomingContractOffer.

A lightning gateway wanting to claim an incoming HTLC can now use the offer to buy the preimage by transferring funds into the corresponding contract. This activates the threshold decryption process inside the federation. Since the user could have threshold-encrypted useless data there are two possible outcomes:

1. The decryption results in a valid preimage which is given to the lightning gateway. The user can in return claim the funds from the contract. For this they need to be able to sign with the private key corresponding to the public key which they used as preimage.
2. The decryption results in an invalid preimage, the gateway can claim back the money. For this to work securely they have to specify a public key when creating the actual contract.

Fields

hash: Hash

Payment hash which’s corresponding preimage is being sold

encrypted_preimage: EncryptedPreimage

Encrypted preimage as specified in offer

decrypted_preimage: DecryptedPreimage

Status of preimage decryption, will either end in failure or contain the preimage eventually. In case decryption was successful the preimage is also the public key locking the contract, allowing the offer creator to redeem their money.

gateway_key: PublicKey

Key that can unlock contract in case the decrypted preimage was invalid

Trait Implementations

impl Clone for IncomingContract

fn clone(&self) -> IncomingContract

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for IncomingContract

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

Formats the value using the given formatter.

impl Decodable for IncomingContract

fn consensus_decode_from_finite_reader<D: Read>( d: &mut D, modules: &ModuleDecoderRegistry, ) -> Result<Self, DecodeError>

Decode Self from a size-limited reader.

fn consensus_decode<R>( r: &mut R, modules: &ModuleRegistry<Decoder, DecodingMode>, ) -> Result<Self, DecodeError>

where R: Read,

Decode an object with a well-defined format.

fn consensus_decode_hex( hex: &str, modules: &ModuleRegistry<Decoder, DecodingMode>, ) -> Result<Self, DecodeError>

Decode an object from hex

fn consensus_decode_vec( bytes: Vec<u8>, modules: &ModuleRegistry<Decoder, DecodingMode>, ) -> Result<Self, DecodeError>

impl<'de> Deserialize<'de> for IncomingContract

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodable for IncomingContract

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

Encode an object with a well-defined format. Returns the number of bytes written on success.

fn consensus_encode_to_vec(&self) -> Vec<u8>

Self::consensus_encode to newly allocated Vec<u8>

fn consensus_encode_to_hex(&self) -> String

Encode and convert to hex string representation

fn consensus_encode_to_len(&self) -> usize

Encode without storing the encoding, return the size

fn consensus_hash<H>(&self) -> H

where H: Hash, <H as Hash>::Engine: Write,

Generate a SHA256 hash of the consensus encoding using the default hash engine for H.

impl Hash for IncomingContract

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 IdentifiableContract for IncomingContract

fn contract_id(&self) -> ContractId

impl PartialEq for IncomingContract

fn eq(&self, other: &IncomingContract) -> 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 Serialize for IncomingContract

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for IncomingContract

impl StructuralPartialEq for IncomingContract