Trait commit_verify::ConvolveCommit

pub trait ConvolveCommit<Msg, Proof, Protocol>
where
    Self: Sized,
    Msg: CommitEncode,
    Proof: ConvolveCommitProof<Msg, Self, Protocol>,
    Protocol: CommitmentProtocol,
{
    type Commitment: Sized + VerifyEq;
    type CommitError: Error;

    // Required method
    fn convolve_commit(
        &self,
        supplement: &Proof::Suppl,
        msg: &Msg
    ) -> Result<(Self::Commitment, Proof), Self::CommitError>;
}

Trait for convolve-commit-verify scheme, where some data structure (named container) may commit to existing message using supplement and producing final commitment value. The commitment can’t be used to restore original message, however the fact of the commitment may be deterministically verified when the message and the supplement (now acting as a proof) proof are revealed.

In other words, convolve-commit takes an object (self), a supplement, convolves them in certain way together and than uses the result to produce a commitment to a message and a proof:

• self + supplement -> internal_repr;
• internal_repr + msg -> (commitment, proof). Later on, a verifier presented with a message and the proof may do the commitment verification in the following way: msg, proof, commitment -> bool.

To use convolve-commit-verify scheme one needs to implement this trait for a data structure acting as a container for a specific commitment under certain protocol, specified as generic parameters. The container type must specify commitment types as associated type Self::Commitment. The commitment type in certain cases may be equal to the original container type; when the commitment represents internally modified container.

The difference between convolve-commit-verify and embed-commit-verify schemes is in the fact that unlike embed-commit, convolve-commit does not produce a proof external to the commitment, but instead requires additional immutable supplement information which is not a part of the container converted into the commitment. As an example one may consider procedures of homomorphic public key tweaking with the hash of the message, which is a case of embed-commit procedure, producing original public key as a proof and tweaked public key as a commitment – and procedure of pay-to-contract commitment in scriptPubkey of a transaction output, which requires additional information about the public key or scripts present in the scriptPubkey only in hashed form (this is supplement), and producing just a modified version of the scriptPubkey (commitment) without any additional proof data.

Operations with convolve-commit-verify scheme may be represented in form of ConvolveCommit: (Container, Supplement, Message) -> Commitment (see Self::convolve_commit and Verify: (Container', Supplement, Message) -> bool (see ConvolveCommitProof::verify).

This trait is heavily used in deterministic bitcoin commitments.

Protocol definition

Generic parameter Protocol provides context & configuration for commitment scheme protocol used for this container type.

Introduction of this generic allows to:

• implement trait for foreign data types;
• add multiple implementations under different commitment protocols to the combination of the same message and container type (each of each will have its own Proof type defined as an associated generic).

Usually represents an uninstantiable type, but may be a structure containing commitment protocol configuration or context objects.

// Uninstantiable type
pub enum Lnpbp6 {}

impl CommitmentProtocol for Lnpbp6 {}

// Protocol definition
pub enum Lnpbp1 {}
// ...

Required Associated Types

type Commitment: Sized + VerifyEq

Commitment type produced as a result of Self::convolve_commit procedure.

type CommitError: Error

Error type that may be reported during Self::convolve_commit procedure. It may also be returned from ConvolveCommitProof::verify in case the proof data are invalid and the commitment can’t be re-created.

Required Methods

fn convolve_commit( &self, supplement: &Proof::Suppl, msg: &Msg ) -> Result<(Self::Commitment, Proof), Self::CommitError>

Takes the supplement to unparse the content of this container (self) (“convolves” these two data together) and uses them to produce a final Self::Commitment to the message msg.

Implementations must error with a dedicated error type enumerating commitment procedure mistakes.

Object Safety

This trait is not object safe.

Implementors