she

Fully qualified path: she

Modules


errors	—
utils	—
protocols	—

Modules


errors	—
utils	—
protocols	—

errors

Fully qualified path: she::errors

Enums


Errors	—

Enums


Errors	—

Errors

Fully qualified path: she::errors::Errors

pub enum Errors {
    CurveOrderOverflow,
    PoeError,
    Poe2Error,
    PoeNError,
    ElGamalError,
    SameEncryptionError,
    SameEncryptionSameKeyError,
    SameEnctyptionUnKnownRandomError,
    ProofOfBitError,
    IncompleteRangeProof,
    RangeProofError,
    IncompleteProof,
    NullChallenge,
}

Variants

CurveOrderOverflow

Fully qualified path: she::errors::Errors::CurveOrderOverflow

CurveOrderOverflow

PoeError

Fully qualified path: she::errors::Errors::PoeError

PoeError

Poe2Error

Fully qualified path: she::errors::Errors::Poe2Error

Poe2Error

PoeNError

Fully qualified path: she::errors::Errors::PoeNError

PoeNError

ElGamalError

Fully qualified path: she::errors::Errors::ElGamalError

ElGamalError

SameEncryptionError

Fully qualified path: she::errors::Errors::SameEncryptionError

SameEncryptionError

SameEncryptionSameKeyError

Fully qualified path: she::errors::Errors::SameEncryptionSameKeyError

SameEncryptionSameKeyError

SameEnctyptionUnKnownRandomError

Fully qualified path: she::errors::Errors::SameEnctyptionUnKnownRandomError

SameEnctyptionUnKnownRandomError

ProofOfBitError

Fully qualified path: she::errors::Errors::ProofOfBitError

ProofOfBitError

IncompleteRangeProof

Fully qualified path: she::errors::Errors::IncompleteRangeProof

IncompleteRangeProof

RangeProofError

Fully qualified path: she::errors::Errors::RangeProofError

RangeProofError

IncompleteProof

Fully qualified path: she::errors::Errors::IncompleteProof

IncompleteProof

NullChallenge

Fully qualified path: she::errors::Errors::NullChallenge

NullChallenge

utils

Fully qualified path: she::utils

Free functions


in_curve_order	Asserts that the given number is lower than the curve order.
compute_challenge	—
validate_challenge	—
reduce_modulo_order	This is used to cast a felt252 into the curve order. It is used mainly in challenge computation. We could implement more complex function to avoid non-uniform distribution in…
compute_s	Computes k + x * c mod (CURVE ORDER). The inputs should be in curve order.
subtract_modulo_curve_order	—
to_binary	Computes the binary decomposition of the given number u32 number. The output is and array ordered in big in the end.
generate_random_for_testing	Generates a “random” number in the curve order for testing

Free functions


in_curve_order	Asserts that the given number is lower than the curve order.
compute_challenge	—
validate_challenge	—
reduce_modulo_order	This is used to cast a felt252 into the curve order. It is used mainly in challenge computation. We could implement more complex function to avoid non-uniform distribution in…
compute_s	Computes k + x * c mod (CURVE ORDER). The inputs should be in curve order.
subtract_modulo_curve_order	—
to_binary	Computes the binary decomposition of the given number u32 number. The output is and array ordered in big in the end.
generate_random_for_testing	Generates a “random” number in the curve order for testing

in_curve_order

Asserts that the given number is lower than the curve order.

Fully qualified path: she::utils::in_curve_order

pub fn in_curve_order(number: felt252) -> Result<(), Errors>

compute_challenge

Fully qualified path: she::utils::compute_challenge

pub fn compute_challenge(prefix: felt252, commitments: Array<NonZero<EcPoint>>) -> felt252

validate_challenge

Fully qualified path: she::utils::validate_challenge

pub fn validate_challenge(challenge: felt252) -> Result<(), Errors>

reduce_modulo_order

This is used to cast a felt252 into the curve order. It is used mainly in challenge computation. We could implement more complex function to avoid non-uniform distribution in the challenge space (using hashes for example). The chance of falling in a felt252 that are not in CURVE_ORDER are low.

Note: The diference between a felt252 and CURVE_ORDER is ~ 270. So the chances of hashing anything and not to land inside CURVE_ORDER are ~ 270/2**252.

Fully qualified path: she::utils::reduce_modulo_order

pub fn reduce_modulo_order(number: felt252) -> felt252

compute_s

Computes k + x*c mod (CURVE ORDER). The inputs should be in curve order.

Fully qualified path: she::utils::compute_s

pub fn compute_s(k: felt252, x: felt252, c: felt252) -> felt252

subtract_modulo_curve_order

Fully qualified path: she::utils::subtract_modulo_curve_order

pub fn subtract_modulo_curve_order(lhs: felt252, rhs: felt252) -> felt252

to_binary

Computes the binary decomposition of the given number u32 number. The output is and array ordered in big in the end.

Fully qualified path: she::utils::to_binary

pub fn to_binary(number: u32) -> Array<u8>

generate_random_for_testing

Generates a “random” number in the curve order for testing

Fully qualified path: she::utils::generate_random_for_testing

pub fn generate_random_for_testing(seed: felt252, multiplicity: felt252) -> felt252

protocols

Fully qualified path: she::protocols

Modules


ElGamal	—
SameEncryption	—
SameEncryptionUnknownRandom	—
bit	—
poe	—
poe2	—
poeN	—
range	—

Modules


ElGamal	—
SameEncryption	—
SameEncryptionUnknownRandom	—
bit	—
poe	—
poe2	—
poeN	—
range	—

ElGamal

Fully qualified path: she::protocols::ElGamal

Free functions


verify	Proof that a pair of EC points is a well formed ElGamal encryption of the form `(L, R) = (g1^b g2^r , g1^r)` . The sigma protocol consists of a coupled POE and POE2 and runs as follows:…
verify_with_prefix	—
_verify	Proof that a pair of EC points is a well formed ElGamal encryption of the form `(L, R) = (g1^b g2^r , g1^r)` . The sigma protocol consists of a coupled POE and POE2 and runs as follows:…

Structs


ElGamalInputs	—
ElGamalProof	—
ElGamalProofWithPrefix	—

Free functions


verify	Proof that a pair of EC points is a well formed ElGamal encryption of the form `(L, R) = (g1^b g2^r , g1^r)` . The sigma protocol consists of a coupled POE and POE2 and runs as follows:…
verify_with_prefix	—
_verify	Proof that a pair of EC points is a well formed ElGamal encryption of the form `(L, R) = (g1^b g2^r , g1^r)` . The sigma protocol consists of a coupled POE and POE2 and runs as follows:…

verify

Proof that a pair of EC points is a well formed ElGamal encryption of the form (L, R) = (g1^b g2^r , g1^r). The sigma protocol consists of a coupled POE and POE2 and runs as follows:

    P:  kb,kr <-- R        sends    AL = g1^kb g2^kr, AR=g1^kr
    V:  c <-- R            sends    c
    P:  sb = kb + c*b
    P:  sr = kr + c*r      sends s1, s1

The verifier asserts:

g1^sr == AR * (R^c) [poe]
g1^sb g2^sr == AL * (L^c) [poe2]

notation: (P)rover (V)erifier (R)andom

EC_MUL: 5; EC_ADD: 3

Fully qualified path: she::protocols::ElGamal::verify

pub fn verify(inputs: ElGamalInputs, proof: ElGamalProof) -> Result<(), Errors>

verify_with_prefix

Fully qualified path: she::protocols::ElGamal::verify_with_prefix

pub fn verify_with_prefix(
    inputs: ElGamalInputs, proof: ElGamalProofWithPrefix,
) -> Result<(), Errors>

_verify

Proof that a pair of EC points is a well formed ElGamal encryption of the form (L, R) = (g1^b g2^r , g1^r). The sigma protocol consists of a coupled POE and POE2 and runs as follows:

    P:  kb,kr <-- R        sends    AL = g1^kb g2^kr, AR=g1^kr
    V:  c <-- R            sends    c
    P:  sb = kb + c*b
    P:  sr = kr + c*r      sends s1, s1

The verifier asserts:

g1^sr == AR * (R^c) [poe]
g1^sb g2^sr == AL * (L^c) [poe2]

notation: (P)rover (V)erifier (R)andom

EC_MUL: 5; EC_ADD: 3

Fully qualified path: she::protocols::ElGamal::_verify

pub fn _verify(
    L: NonZero<EcPoint>,
    R: NonZero<EcPoint>,
    g1: NonZero<EcPoint>,
    g2: NonZero<EcPoint>,
    AL: NonZero<EcPoint>,
    AR: NonZero<EcPoint>,
    c: felt252,
    sb: felt252,
    sr: felt252,
) -> Result<(), Errors>

Structs


ElGamalInputs	—
ElGamalProof	—
ElGamalProofWithPrefix	—

ElGamalInputs

Fully qualified path: she::protocols::ElGamal::ElGamalInputs

[derive(Drop)]
pub struct ElGamalInputs {
    pub L: NonZero<EcPoint>,
    pub R: NonZero<EcPoint>,
    pub g1: NonZero<EcPoint>,
    pub g2: NonZero<EcPoint>,
}

Members

L

Fully qualified path: she::protocols::ElGamal::ElGamalInputs::L

pub L: NonZero<EcPoint>

R

Fully qualified path: she::protocols::ElGamal::ElGamalInputs::R

pub R: NonZero<EcPoint>

g1

Fully qualified path: she::protocols::ElGamal::ElGamalInputs::g1

pub g1: NonZero<EcPoint>

g2

Fully qualified path: she::protocols::ElGamal::ElGamalInputs::g2

pub g2: NonZero<EcPoint>

ElGamalProof

Fully qualified path: she::protocols::ElGamal::ElGamalProof

[derive(Drop)]
pub struct ElGamalProof {
    pub AL: NonZero<EcPoint>,
    pub AR: NonZero<EcPoint>,
    pub c: felt252,
    pub sb: felt252,
    pub sr: felt252,
}

Members

AL

Fully qualified path: she::protocols::ElGamal::ElGamalProof::AL

pub AL: NonZero<EcPoint>

AR

Fully qualified path: she::protocols::ElGamal::ElGamalProof::AR

pub AR: NonZero<EcPoint>

c

Fully qualified path: she::protocols::ElGamal::ElGamalProof::c

pub c: felt252

sb

Fully qualified path: she::protocols::ElGamal::ElGamalProof::sb

pub sb: felt252

sr

Fully qualified path: she::protocols::ElGamal::ElGamalProof::sr

pub sr: felt252

ElGamalProofWithPrefix

Fully qualified path: she::protocols::ElGamal::ElGamalProofWithPrefix

[derive(Drop)]
pub struct ElGamalProofWithPrefix {
    pub AL: NonZero<EcPoint>,
    pub AR: NonZero<EcPoint>,
    pub prefix: felt252,
    pub sb: felt252,
    pub sr: felt252,
}

Members

AL

Fully qualified path: she::protocols::ElGamal::ElGamalProofWithPrefix::AL

pub AL: NonZero<EcPoint>

AR

Fully qualified path: she::protocols::ElGamal::ElGamalProofWithPrefix::AR

pub AR: NonZero<EcPoint>

prefix

Fully qualified path: she::protocols::ElGamal::ElGamalProofWithPrefix::prefix

pub prefix: felt252

sb

Fully qualified path: she::protocols::ElGamal::ElGamalProofWithPrefix::sb

pub sb: felt252

sr

Fully qualified path: she::protocols::ElGamal::ElGamalProofWithPrefix::sr

pub sr: felt252

SameEncryption

Fully qualified path: she::protocols::SameEncryption

Free functions


verify	Verifies that two encryptions for two different keys are valid and that they are encrypting the same amount `b` . Note: We assume here that the two randoms `r1` and `r2` are known by the prover….
verify_with_prefix	—
_verify	Verifies that two encryptions for two different keys are valid and that they are encrypting the same amount `b` . Note: We assume here that the two randoms `r1` and `r2` are known by the prover….

Structs


SameEncryptionInputs	—
SameEncryptionProof	—
SameEncryptionProofWithPrefix	—

Free functions


verify	Verifies that two encryptions for two different keys are valid and that they are encrypting the same amount `b` . Note: We assume here that the two randoms `r1` and `r2` are known by the prover….
verify_with_prefix	—
_verify	Verifies that two encryptions for two different keys are valid and that they are encrypting the same amount `b` . Note: We assume here that the two randoms `r1` and `r2` are known by the prover….

verify

Verifies that two encryptions for two different keys are valid and that they are encrypting the same amount b. Note: We assume here that the two randoms r1 and r2 are known by the prover. This proof is just two proof of ElGamal encryption which both use the same value sb. (L1, R1) = (g^b y1^r1, g^r1), (L2, R2) = (g^b y2^r2, g^r2). The protocol runs as follows

    P:  kb, kr1, kr2 <-- R      sends    AL1=g^kb y1^kr1, AR1=g^kb, AL2=g^kb y2^kr2, AR2=g^kr2
    V:          c  <-- R        sends    c
    P:  sb  = kb  + c*b         sends    sb
    P:  sr1 = kr1 + c*r1        sends    sr1
    P:  sr2 = kr2 + c*r2        sends    sr2

The verifier asserts:

The correct encryption of (L1,R1)
The correct encryption of (L2,R2)

notation: (P)rover (V)erifier (R)andom

EC_MUL: 10; EC_ADD: 6

Fully qualified path: she::protocols::SameEncryption::verify

pub fn verify(inputs: SameEncryptionInputs, proof: SameEncryptionProof) -> Result<(), Errors>

verify_with_prefix

Fully qualified path: she::protocols::SameEncryption::verify_with_prefix

pub fn verify_with_prefix(
    inputs: SameEncryptionInputs, proof: SameEncryptionProofWithPrefix,
) -> Result<(), Errors>

_verify

    P:  kb, kr1, kr2 <-- R      sends    AL1=g^kb y1^kr1, AR1=g^kb, AL2=g^kb y2^kr2, AR2=g^kr2
    V:          c  <-- R        sends    c
    P:  sb  = kb  + c*b         sends    sb
    P:  sr1 = kr1 + c*r1        sends    sr1
    P:  sr2 = kr2 + c*r2        sends    sr2

The verifier asserts:

The correct encryption of (L1,R1)
The correct encryption of (L2,R2)

notation: (P)rover (V)erifier (R)andom

EC_MUL: 10; EC_ADD: 6

Fully qualified path: she::protocols::SameEncryption::_verify

pub fn _verify(
    L1: NonZero<EcPoint>,
    R1: NonZero<EcPoint>,
    L2: NonZero<EcPoint>,
    R2: NonZero<EcPoint>,
    g: NonZero<EcPoint>,
    y1: NonZero<EcPoint>,
    y2: NonZero<EcPoint>,
    AL1: NonZero<EcPoint>,
    AR1: NonZero<EcPoint>,
    AL2: NonZero<EcPoint>,
    AR2: NonZero<EcPoint>,
    c: felt252,
    sb: felt252,
    sr1: felt252,
    sr2: felt252,
) -> Result<(), Errors>

Structs


SameEncryptionInputs	—
SameEncryptionProof	—
SameEncryptionProofWithPrefix	—

SameEncryptionInputs

Fully qualified path: she::protocols::SameEncryption::SameEncryptionInputs

[derive(Drop)]
pub struct SameEncryptionInputs {
    pub L1: NonZero<EcPoint>,
    pub R1: NonZero<EcPoint>,
    pub L2: NonZero<EcPoint>,
    pub R2: NonZero<EcPoint>,
    pub g: NonZero<EcPoint>,
    pub y1: NonZero<EcPoint>,
    pub y2: NonZero<EcPoint>,
}

Members

L1

Fully qualified path: she::protocols::SameEncryption::SameEncryptionInputs::L1

pub L1: NonZero<EcPoint>

R1

Fully qualified path: she::protocols::SameEncryption::SameEncryptionInputs::R1

pub R1: NonZero<EcPoint>

L2

Fully qualified path: she::protocols::SameEncryption::SameEncryptionInputs::L2

pub L2: NonZero<EcPoint>

R2

Fully qualified path: she::protocols::SameEncryption::SameEncryptionInputs::R2

pub R2: NonZero<EcPoint>

g

Fully qualified path: she::protocols::SameEncryption::SameEncryptionInputs::g

pub g: NonZero<EcPoint>

y1

Fully qualified path: she::protocols::SameEncryption::SameEncryptionInputs::y1

pub y1: NonZero<EcPoint>

y2

Fully qualified path: she::protocols::SameEncryption::SameEncryptionInputs::y2

pub y2: NonZero<EcPoint>

SameEncryptionProof

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProof

[derive(Drop)]
pub struct SameEncryptionProof {
    pub AL1: NonZero<EcPoint>,
    pub AR1: NonZero<EcPoint>,
    pub AL2: NonZero<EcPoint>,
    pub AR2: NonZero<EcPoint>,
    pub c: felt252,
    pub sb: felt252,
    pub sr1: felt252,
    pub sr2: felt252,
}

Members

AL1

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProof::AL1

pub AL1: NonZero<EcPoint>

AR1

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProof::AR1

pub AR1: NonZero<EcPoint>

AL2

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProof::AL2

pub AL2: NonZero<EcPoint>

AR2

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProof::AR2

pub AR2: NonZero<EcPoint>

c

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProof::c

pub c: felt252

sb

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProof::sb

pub sb: felt252

sr1

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProof::sr1

pub sr1: felt252

sr2

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProof::sr2

pub sr2: felt252

SameEncryptionProofWithPrefix

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProofWithPrefix

[derive(Drop)]
pub struct SameEncryptionProofWithPrefix {
    pub AL1: NonZero<EcPoint>,
    pub AR1: NonZero<EcPoint>,
    pub AL2: NonZero<EcPoint>,
    pub AR2: NonZero<EcPoint>,
    pub prefix: felt252,
    pub sb: felt252,
    pub sr1: felt252,
    pub sr2: felt252,
}

Members

AL1

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProofWithPrefix::AL1

pub AL1: NonZero<EcPoint>

AR1

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProofWithPrefix::AR1

pub AR1: NonZero<EcPoint>

AL2

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProofWithPrefix::AL2

pub AL2: NonZero<EcPoint>

AR2

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProofWithPrefix::AR2

pub AR2: NonZero<EcPoint>

prefix

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProofWithPrefix::prefix

pub prefix: felt252

sb

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProofWithPrefix::sb

pub sb: felt252

sr1

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProofWithPrefix::sr1

pub sr1: felt252

sr2

Fully qualified path: she::protocols::SameEncryption::SameEncryptionProofWithPrefix::sr2

pub sr2: felt252

SameEncryptionUnknownRandom

Fully qualified path: she::protocols::SameEncryptionUnknownRandom

Free functions


verify	Verifies that two encryptions for two keys are valid and that they are encrypting the same amount `b` . For this proof, the prover knows only one of the randoms values and knows the secret…
verify_with_prefix	—
_verify	Verifies that two encryptions for two keys are valid and that they are encrypting the same amount `b` . For this proof, the prover knows only one of the randoms values and knows the secret…

Structs


SameEncryptionUnknownRandomInputs	—
SameEncryptionUnknownRandomProof	—
SameEncryptionUnknownRandomProofWithPrefix	—

Free functions


verify	Verifies that two encryptions for two keys are valid and that they are encrypting the same amount `b` . For this proof, the prover knows only one of the randoms values and knows the secret…
verify_with_prefix	—
_verify	Verifies that two encryptions for two keys are valid and that they are encrypting the same amount `b` . For this proof, the prover knows only one of the randoms values and knows the secret…

verify

Verifies that two encryptions for two keys are valid and that they are encrypting the same amount b. For this proof, the prover knows only one of the randoms values and knows the secret of the public key that does not know the random for. Let (L1, R1) = (g^b y^_r, g^_r), _r is unknown to the prover. The prover can decrypt b with the knowledge of x. By showing that L1 = g^b R^x whe can prove that the ElGamal encryption indeed encrypts b. The protocol runs as follows

    P:  kx, kb, kr <-- R     sends    Ax=g^kx, AL1 = g^kb R^kx, AL2 = g^kb y2^kr, AR2 = g^kr
    V:  c <-- R              sends    c
    P:  sx = k + c*x         sends    s
    P:  sb = kb + c*b        sends    sb
    P:  sr = kr + c*r        sends    sr

The verifier asserts:

g^sx == Ax * (y^c) [poe]
g^sb R1^sx == AL1 * (L1^c) [poe2]
verifyElGamal for (L2,R2)

notation: (P)rover (V)erifier (R)andom

EC_MUL: 10; EC_ADD: 6

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::verify

pub fn verify(
    inputs: SameEncryptionUnknownRandomInputs, proof: SameEncryptionUnknownRandomProof,
) -> Result<(), Errors>

verify_with_prefix

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::verify_with_prefix

pub fn verify_with_prefix(
    inputs: SameEncryptionUnknownRandomInputs, proof: SameEncryptionUnknownRandomProofWithPrefix,
) -> Result<(), Errors>

_verify

    P:  kx, kb, kr <-- R     sends    Ax=g^kx, AL1 = g^kb R^kx, AL2 = g^kb y2^kr, AR2 = g^kr
    V:  c <-- R              sends    c
    P:  sx = k + c*x         sends    s
    P:  sb = kb + c*b        sends    sb
    P:  sr = kr + c*r        sends    sr

The verifier asserts:

g^sx == Ax * (y^c) [poe]
g^sb R1^sx == AL1 * (L1^c) [poe2]
verifyElGamal for (L2,R2)

notation: (P)rover (V)erifier (R)andom

EC_MUL: 10; EC_ADD: 6

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::_verify

pub fn _verify(
    L1: NonZero<EcPoint>,
    R1: NonZero<EcPoint>,
    L2: NonZero<EcPoint>,
    R2: NonZero<EcPoint>,
    g: NonZero<EcPoint>,
    y1: NonZero<EcPoint>,
    y2: NonZero<EcPoint>,
    Ax: NonZero<EcPoint>,
    AL1: NonZero<EcPoint>,
    AL2: NonZero<EcPoint>,
    AR2: NonZero<EcPoint>,
    c: felt252,
    sb: felt252,
    sx: felt252,
    sr2: felt252,
) -> Result<(), Errors>

Structs


SameEncryptionUnknownRandomInputs	—
SameEncryptionUnknownRandomProof	—
SameEncryptionUnknownRandomProofWithPrefix	—

SameEncryptionUnknownRandomInputs

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomInputs

[derive(Drop)]
pub struct SameEncryptionUnknownRandomInputs {
    pub L1: NonZero<EcPoint>,
    pub R1: NonZero<EcPoint>,
    pub L2: NonZero<EcPoint>,
    pub R2: NonZero<EcPoint>,
    pub g: NonZero<EcPoint>,
    pub y1: NonZero<EcPoint>,
    pub y2: NonZero<EcPoint>,
}

Members

L1

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomInputs::L1

pub L1: NonZero<EcPoint>

R1

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomInputs::R1

pub R1: NonZero<EcPoint>

L2

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomInputs::L2

pub L2: NonZero<EcPoint>

R2

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomInputs::R2

pub R2: NonZero<EcPoint>

g

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomInputs::g

pub g: NonZero<EcPoint>

y1

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomInputs::y1

pub y1: NonZero<EcPoint>

y2

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomInputs::y2

pub y2: NonZero<EcPoint>

SameEncryptionUnknownRandomProof

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProof

[derive(Drop)]
pub struct SameEncryptionUnknownRandomProof {
    pub Ax: NonZero<EcPoint>,
    pub AL1: NonZero<EcPoint>,
    pub AL2: NonZero<EcPoint>,
    pub AR2: NonZero<EcPoint>,
    pub c: felt252,
    pub sb: felt252,
    pub sx: felt252,
    pub sr2: felt252,
}

Members

Ax

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProof::Ax

pub Ax: NonZero<EcPoint>

AL1

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProof::AL1

pub AL1: NonZero<EcPoint>

AL2

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProof::AL2

pub AL2: NonZero<EcPoint>

AR2

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProof::AR2

pub AR2: NonZero<EcPoint>

c

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProof::c

pub c: felt252

sb

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProof::sb

pub sb: felt252

sx

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProof::sx

pub sx: felt252

sr2

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProof::sr2

pub sr2: felt252

SameEncryptionUnknownRandomProofWithPrefix

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProofWithPrefix

[derive(Drop)]
pub struct SameEncryptionUnknownRandomProofWithPrefix {
    pub Ax: NonZero<EcPoint>,
    pub AL1: NonZero<EcPoint>,
    pub AL2: NonZero<EcPoint>,
    pub AR2: NonZero<EcPoint>,
    pub prefix: felt252,
    pub sb: felt252,
    pub sx: felt252,
    pub sr2: felt252,
}

Members

Ax

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProofWithPrefix::Ax

pub Ax: NonZero<EcPoint>

AL1

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProofWithPrefix::AL1

pub AL1: NonZero<EcPoint>

AL2

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProofWithPrefix::AL2

pub AL2: NonZero<EcPoint>

AR2

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProofWithPrefix::AR2

pub AR2: NonZero<EcPoint>

prefix

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProofWithPrefix::prefix

pub prefix: felt252

sb

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProofWithPrefix::sb

pub sb: felt252

sx

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProofWithPrefix::sx

pub sx: felt252

sr2

Fully qualified path: she::protocols::SameEncryptionUnknownRandom::SameEncryptionUnknownRandomProofWithPrefix::sr2

pub sr2: felt252

bit

Fully qualified path: she::protocols::bit

Free functions


verify	Proof of Bit: verifies that a commited `V = g^b h^r` is the ciphertext of either `b=0 OR b=1` . If `b=0` then `V = h^r` and a proof of exponet for `r` is enough. If `b=1` then `V/g = h^r`…
verify_with_prefix	—
_verify	Proof of Bit: verifies that a commited `V = g^b h^r` is the ciphertext of either `b=0 OR b=1` . If `b=0` then `V = h^r` and a proof of exponet for `r` is enough. If `b=1` then `V/g = h^r`…
prover_for_testing	—

Structs


BitInputs	—
BitProof	—
BitProofWithPrefix	—

Free functions


verify	Proof of Bit: verifies that a commited `V = g^b h^r` is the ciphertext of either `b=0 OR b=1` . If `b=0` then `V = h^r` and a proof of exponet for `r` is enough. If `b=1` then `V/g = h^r`…
verify_with_prefix	—
_verify	Proof of Bit: verifies that a commited `V = g^b h^r` is the ciphertext of either `b=0 OR b=1` . If `b=0` then `V = h^r` and a proof of exponet for `r` is enough. If `b=1` then `V/g = h^r`…
prover_for_testing	—

verify

Proof of Bit: verifies that a commited V = g^b h^r is the ciphertext of either b=0 OR b=1. If b=0 then V = h^r and a proof of exponet for r is enough. If b=1 then V/g = h^r can be also proven with a POE. This is combined in a OR statement and the protocol can validate that one of the cases is valid without leaking which one is the valid one.

EC_MUL: 4; EC_ADD: 3

Fully qualified path: she::protocols::bit::verify

pub fn verify(inputs: BitInputs, proof: BitProof) -> Result<(), Errors>

verify_with_prefix

Fully qualified path: she::protocols::bit::verify_with_prefix

pub fn verify_with_prefix(inputs: BitInputs, proof: BitProofWithPrefix) -> Result<(), Errors>

_verify

EC_MUL: 4; EC_ADD: 3

Fully qualified path: she::protocols::bit::_verify

pub fn _verify(
    V: NonZero<EcPoint>,
    g1: NonZero<EcPoint>,
    g2: NonZero<EcPoint>,
    A0: NonZero<EcPoint>,
    A1: NonZero<EcPoint>,
    c: felt252,
    c0: felt252,
    s0: felt252,
    s1: felt252,
) -> Result<(), Errors>

prover_for_testing

Fully qualified path: she::protocols::bit::prover_for_testing

pub fn prover_for_testing(
    b: u8, r: felt252, g1: NonZero<EcPoint>, g2: NonZero<EcPoint>, prefix: felt252,
) -> (BitInputs, BitProofWithPrefix)

Structs


BitInputs	—
BitProof	—
BitProofWithPrefix	—

BitInputs

Fully qualified path: she::protocols::bit::BitInputs

[derive(Drop, Copy)]
pub struct BitInputs {
    pub V: NonZero<EcPoint>,
    pub g1: NonZero<EcPoint>,
    pub g2: NonZero<EcPoint>,
}

Members

V

Fully qualified path: she::protocols::bit::BitInputs::V

pub V: NonZero<EcPoint>

g1

Fully qualified path: she::protocols::bit::BitInputs::g1

pub g1: NonZero<EcPoint>

g2

Fully qualified path: she::protocols::bit::BitInputs::g2

pub g2: NonZero<EcPoint>

BitProof

Fully qualified path: she::protocols::bit::BitProof

[derive(Drop, Copy)]
pub struct BitProof {
    pub A0: NonZero<EcPoint>,
    pub A1: NonZero<EcPoint>,
    pub c: felt252,
    pub c0: felt252,
    pub s0: felt252,
    pub s1: felt252,
}

Members

A0

Fully qualified path: she::protocols::bit::BitProof::A0

pub A0: NonZero<EcPoint>

A1

Fully qualified path: she::protocols::bit::BitProof::A1

pub A1: NonZero<EcPoint>

c

Fully qualified path: she::protocols::bit::BitProof::c

pub c: felt252

c0

Fully qualified path: she::protocols::bit::BitProof::c0

pub c0: felt252

s0

Fully qualified path: she::protocols::bit::BitProof::s0

pub s0: felt252

s1

Fully qualified path: she::protocols::bit::BitProof::s1

pub s1: felt252

BitProofWithPrefix

Fully qualified path: she::protocols::bit::BitProofWithPrefix

[derive(Drop, Copy)]
pub struct BitProofWithPrefix {
    pub A0: NonZero<EcPoint>,
    pub A1: NonZero<EcPoint>,
    pub prefix: felt252,
    pub c0: felt252,
    pub s0: felt252,
    pub s1: felt252,
}

Members

A0

Fully qualified path: she::protocols::bit::BitProofWithPrefix::A0

pub A0: NonZero<EcPoint>

A1

Fully qualified path: she::protocols::bit::BitProofWithPrefix::A1

pub A1: NonZero<EcPoint>

prefix

Fully qualified path: she::protocols::bit::BitProofWithPrefix::prefix

pub prefix: felt252

c0

Fully qualified path: she::protocols::bit::BitProofWithPrefix::c0

pub c0: felt252

s0

Fully qualified path: she::protocols::bit::BitProofWithPrefix::s0

pub s0: felt252

s1

Fully qualified path: she::protocols::bit::BitProofWithPrefix::s1

pub s1: felt252

poe

Fully qualified path: she::protocols::poe

Free functions


verify	Proof of Exponent: validate a proof of knowledge of the exponent `y = g ^ x` . The sigma protocol runs as follow:…
verify_with_prefix	—
_verify	Proof of Exponent: validate a proof of knowledge of the exponent `y = g ^ x` . The sigma protocol runs as follow:…
simulate_poe_for_testing	—

Structs


PoeInputs	—
PoeProof	—
PoeProofWithPrefix	—

Free functions


verify	Proof of Exponent: validate a proof of knowledge of the exponent `y = g ^ x` . The sigma protocol runs as follow:…
verify_with_prefix	—
_verify	Proof of Exponent: validate a proof of knowledge of the exponent `y = g ^ x` . The sigma protocol runs as follow:…
simulate_poe_for_testing	—

verify

Proof of Exponent: validate a proof of knowledge of the exponent y = g ^ x. The sigma protocol runs as follow:

    P:  k <-- R        sends    A = g ^ k
    V:  c <-- R        sends    c
    P:  s = k + c*x    sends    s

The verifier asserts:

g^s == A * (y^c)

notation: (P)rover (V)erifier (R)andom

EC_MUL: 2; EC_ADD: 1

Fully qualified path: she::protocols::poe::verify

pub fn verify(inputs: PoeInputs, proof: PoeProof) -> Result<(), Errors>

verify_with_prefix

Fully qualified path: she::protocols::poe::verify_with_prefix

pub fn verify_with_prefix(inputs: PoeInputs, proof: PoeProofWithPrefix) -> Result<(), Errors>

_verify

Proof of Exponent: validate a proof of knowledge of the exponent y = g ^ x. The sigma protocol runs as follow:

    P:  k <-- R        sends    A = g ^ k
    V:  c <-- R        sends    c
    P:  s = k + c*x    sends    s

The verifier asserts:

g^s == A * (y^c)

notation: (P)rover (V)erifier (R)andom

EC_MUL: 2; EC_ADD: 1

Fully qualified path: she::protocols::poe::_verify

pub fn _verify(
    y: NonZero<EcPoint>, g: NonZero<EcPoint>, A: NonZero<EcPoint>, c: felt252, s: felt252,
) -> Result<(), Errors>

simulate_poe_for_testing

Fully qualified path: she::protocols::poe::simulate_poe_for_testing

pub fn simulate_poe_for_testing(
    y: NonZero<EcPoint>, g: NonZero<EcPoint>, seed: felt252,
) -> (NonZero<EcPoint>, felt252, felt252)

Structs


PoeInputs	—
PoeProof	—
PoeProofWithPrefix	—

PoeInputs

Fully qualified path: she::protocols::poe::PoeInputs

[derive(Drop)]
pub struct PoeInputs {
    pub y: NonZero<EcPoint>,
    pub g: NonZero<EcPoint>,
}

Members

y

Fully qualified path: she::protocols::poe::PoeInputs::y

pub y: NonZero<EcPoint>

g

Fully qualified path: she::protocols::poe::PoeInputs::g

pub g: NonZero<EcPoint>

PoeProof

Fully qualified path: she::protocols::poe::PoeProof

[derive(Drop)]
pub struct PoeProof {
    pub A: NonZero<EcPoint>,
    pub c: felt252,
    pub s: felt252,
}

Members

A

Fully qualified path: she::protocols::poe::PoeProof::A

pub A: NonZero<EcPoint>

c

Fully qualified path: she::protocols::poe::PoeProof::c

pub c: felt252

s

Fully qualified path: she::protocols::poe::PoeProof::s

pub s: felt252

PoeProofWithPrefix

Fully qualified path: she::protocols::poe::PoeProofWithPrefix

[derive(Drop)]
pub struct PoeProofWithPrefix {
    pub A: NonZero<EcPoint>,
    pub prefix: felt252,
    pub s: felt252,
}

Members

A

Fully qualified path: she::protocols::poe::PoeProofWithPrefix::A

pub A: NonZero<EcPoint>

prefix

Fully qualified path: she::protocols::poe::PoeProofWithPrefix::prefix

pub prefix: felt252

s

Fully qualified path: she::protocols::poe::PoeProofWithPrefix::s

pub s: felt252

poe2

Fully qualified path: she::protocols::poe2

Free functions


verify	Proof of Exponent 2: validate a proof of knowledge of the exponent `y = g1^x1 g2^x2` . The sigma protocol runs as follows:…
verify_with_prefix	—
_verify	Proof of Exponent 2: validate a proof of knowledge of the exponent `y = g1^x1 g2^x2` . The sigma protocol runs as follows:…

Structs


Poe2Inputs	—
Poe2Proof	—
Poe2ProofWithPrefix	—

Free functions


verify	Proof of Exponent 2: validate a proof of knowledge of the exponent `y = g1^x1 g2^x2` . The sigma protocol runs as follows:…
verify_with_prefix	—
_verify	Proof of Exponent 2: validate a proof of knowledge of the exponent `y = g1^x1 g2^x2` . The sigma protocol runs as follows:…

verify

Proof of Exponent 2: validate a proof of knowledge of the exponent y = g1^x1 g2^x2. The sigma protocol runs as follows:

    P:  k1,k2 <-- R        sends    A = g1^k1 g2^k2
    V:  c <-- R            sends    c
    P:  s1 = k1 + c*x1
    P:  s2 = k2 + c*x2     sends    s1, s2

The verifier asserts:

g1^s1 g2^s2 == A * (y^c)

notation: (P)rover (V)erifier (R)andom

EC_MUL: 3; EC_ADD: 2

Fully qualified path: she::protocols::poe2::verify

pub fn verify(inputs: Poe2Inputs, proof: Poe2Proof) -> Result<(), Errors>

verify_with_prefix

Fully qualified path: she::protocols::poe2::verify_with_prefix

pub fn verify_with_prefix(inputs: Poe2Inputs, proof: Poe2ProofWithPrefix) -> Result<(), Errors>

_verify

Proof of Exponent 2: validate a proof of knowledge of the exponent y = g1^x1 g2^x2. The sigma protocol runs as follows:

    P:  k1,k2 <-- R        sends    A = g1^k1 g2^k2
    V:  c <-- R            sends    c
    P:  s1 = k1 + c*x1
    P:  s2 = k2 + c*x2     sends    s1, s2

The verifier asserts:

g1^s1 g2^s2 == A * (y^c)

notation: (P)rover (V)erifier (R)andom

EC_MUL: 3; EC_ADD: 2

Fully qualified path: she::protocols::poe2::_verify

pub fn _verify(
    y: NonZero<EcPoint>,
    g1: NonZero<EcPoint>,
    g2: NonZero<EcPoint>,
    A: NonZero<EcPoint>,
    c: felt252,
    s1: felt252,
    s2: felt252,
) -> Result<(), Errors>

Structs


Poe2Inputs	—
Poe2Proof	—
Poe2ProofWithPrefix	—

Poe2Inputs

Fully qualified path: she::protocols::poe2::Poe2Inputs

[derive(Drop)]
pub struct Poe2Inputs {
    pub y: NonZero<EcPoint>,
    pub g1: NonZero<EcPoint>,
    pub g2: NonZero<EcPoint>,
}

Members

y

Fully qualified path: she::protocols::poe2::Poe2Inputs::y

pub y: NonZero<EcPoint>

g1

Fully qualified path: she::protocols::poe2::Poe2Inputs::g1

pub g1: NonZero<EcPoint>

g2

Fully qualified path: she::protocols::poe2::Poe2Inputs::g2

pub g2: NonZero<EcPoint>

Poe2Proof

Fully qualified path: she::protocols::poe2::Poe2Proof

[derive(Drop)]
pub struct Poe2Proof {
    pub A: NonZero<EcPoint>,
    pub c: felt252,
    pub s1: felt252,
    pub s2: felt252,
}

Members

A

Fully qualified path: she::protocols::poe2::Poe2Proof::A

pub A: NonZero<EcPoint>

c

Fully qualified path: she::protocols::poe2::Poe2Proof::c

pub c: felt252

s1

Fully qualified path: she::protocols::poe2::Poe2Proof::s1

pub s1: felt252

s2

Fully qualified path: she::protocols::poe2::Poe2Proof::s2

pub s2: felt252

Poe2ProofWithPrefix

Fully qualified path: she::protocols::poe2::Poe2ProofWithPrefix

[derive(Drop)]
pub struct Poe2ProofWithPrefix {
    pub A: NonZero<EcPoint>,
    pub prefix: felt252,
    pub s1: felt252,
    pub s2: felt252,
}

Members

A

Fully qualified path: she::protocols::poe2::Poe2ProofWithPrefix::A

pub A: NonZero<EcPoint>

prefix

Fully qualified path: she::protocols::poe2::Poe2ProofWithPrefix::prefix

pub prefix: felt252

s1

Fully qualified path: she::protocols::poe2::Poe2ProofWithPrefix::s1

pub s1: felt252

s2

Fully qualified path: she::protocols::poe2::Poe2ProofWithPrefix::s2

pub s2: felt252

poeN

Fully qualified path: she::protocols::poeN

Free functions


verify	Proof of Exponents: validate a proof of knowledge of the exponents `y = g_1^x_1 g_2^x_2 ... g_N^x_N` . The sigma protocol runs as follows:…
verify_with_prefix	—
_verify	Proof of Exponents: validate a proof of knowledge of the exponents `y = g_1^x_1 g_2^x_2 ... g_N^x_N` . The sigma protocol runs as follows:…

Structs


PoeNInputs	—
PoeNProof	—
PoeNProofWithPrefix	—

Free functions


verify	Proof of Exponents: validate a proof of knowledge of the exponents `y = g_1^x_1 g_2^x_2 ... g_N^x_N` . The sigma protocol runs as follows:…
verify_with_prefix	—
_verify	Proof of Exponents: validate a proof of knowledge of the exponents `y = g_1^x_1 g_2^x_2 ... g_N^x_N` . The sigma protocol runs as follows:…

verify

Proof of Exponents: validate a proof of knowledge of the exponents y = g_1^x_1 g_2^x_2 ... g_N^x_N. The sigma protocol runs as follows:

    P:  k_i <-- R          sends    A = g_1^k_1... g_i^k_i ... g_N^k_N
    V:  c <-- R            sends    c
    P:  s_i = k_i + c*x_i  sends    s_i
    The verifier asserts:
    - g_1^s_1...g_i^s_i... g_N^s_N == A * (y^c)

notation: (P)rover (V)erifier (R)andom

EC_MUL: N+1; EC_ADD: N

Fully qualified path: she::protocols::poeN::verify

pub fn verify(inputs: PoeNInputs, proof: PoeNProof) -> Result<(), Errors>

verify_with_prefix

Fully qualified path: she::protocols::poeN::verify_with_prefix

pub fn verify_with_prefix(inputs: PoeNInputs, proof: PoeNProofWithPrefix) -> Result<(), Errors>

_verify

Proof of Exponents: validate a proof of knowledge of the exponents y = g_1^x_1 g_2^x_2 ... g_N^x_N. The sigma protocol runs as follows:

    P:  k_i <-- R          sends    A = g_1^k_1... g_i^k_i ... g_N^k_N
    V:  c <-- R            sends    c
    P:  s_i = k_i + c*x_i  sends    s_i
    The verifier asserts:
    - g_1^s_1...g_i^s_i... g_N^s_N == A * (y^c)

notation: (P)rover (V)erifier (R)andom

EC_MUL: N+1; EC_ADD: N

Fully qualified path: she::protocols::poeN::_verify

pub fn _verify(
    y: NonZero<EcPoint>,
    generators: Array<NonZero<EcPoint>>,
    A: NonZero<EcPoint>,
    c: felt252,
    ss: Array<felt252>,
) -> Result<(), Errors>

Structs


PoeNInputs	—
PoeNProof	—
PoeNProofWithPrefix	—

PoeNInputs

Fully qualified path: she::protocols::poeN::PoeNInputs

[derive(Drop)]
pub struct PoeNInputs {
    pub y: NonZero<EcPoint>,
    pub generators: Array<NonZero<EcPoint>>,
}

Members

y

Fully qualified path: she::protocols::poeN::PoeNInputs::y

pub y: NonZero<EcPoint>

generators

Fully qualified path: she::protocols::poeN::PoeNInputs::generators

pub generators: Array<NonZero<EcPoint>>

PoeNProof

Fully qualified path: she::protocols::poeN::PoeNProof

[derive(Drop)]
pub struct PoeNProof {
    pub A: NonZero<EcPoint>,
    pub c: felt252,
    pub ss: Array<felt252>,
}

Members

A

Fully qualified path: she::protocols::poeN::PoeNProof::A

pub A: NonZero<EcPoint>

c

Fully qualified path: she::protocols::poeN::PoeNProof::c

pub c: felt252

ss

Fully qualified path: she::protocols::poeN::PoeNProof::ss

pub ss: Array<felt252>

PoeNProofWithPrefix

Fully qualified path: she::protocols::poeN::PoeNProofWithPrefix

[derive(Drop)]
pub struct PoeNProofWithPrefix {
    pub A: NonZero<EcPoint>,
    pub prefix: felt252,
    pub ss: Array<felt252>,
}

Members

A

Fully qualified path: she::protocols::poeN::PoeNProofWithPrefix::A

pub A: NonZero<EcPoint>

prefix

Fully qualified path: she::protocols::poeN::PoeNProofWithPrefix::prefix

pub prefix: felt252

ss

Fully qualified path: she::protocols::poeN::PoeNProofWithPrefix::ss

pub ss: Array<felt252>

range

Fully qualified path: she::protocols::range

Free functions


verify	Verify that a span of `V_i = g^b_i h^r_i` are encoding either `b=1` or `b=0` and that those `b_i` are indeed the binary decomposition `b = sum_i b_i 2^i` . With the `b` that is encoded in…
pregenerate_random_for_testing	—
prover_for_testing	—

Structs


RangeInputs	—
RangeProof	—

Free functions


verify	Verify that a span of `V_i = g^b_i h^r_i` are encoding either `b=1` or `b=0` and that those `b_i` are indeed the binary decomposition `b = sum_i b_i 2^i` . With the `b` that is encoded in…
pregenerate_random_for_testing	—
prover_for_testing	—

verify

Verify that a span of V_i = g^b_i h^r_i are encoding either b=1 or b=0 and that those b_i are indeed the binary decomposition b = sum_i b_i 2^i. With the b that is encoded in V = g^b h^r. (Note that r = sum_i r_i 2^i)

EC_MUL: bit_size * ( 4 + 1 ) (160 for u32); EC_ADD: bit_size * ( 3 + 1 ) (128 for u32)

Fully qualified path: she::protocols::range::verify

pub fn verify(inputs: RangeInputs, proof: RangeProof) -> Result<NonZero<EcPoint>, Errors>

pregenerate_random_for_testing

Fully qualified path: she::protocols::range::pregenerate_random_for_testing

pub fn pregenerate_random_for_testing(bit_size: u32, seed: felt252) -> (Array<felt252>, felt252)

prover_for_testing

Fully qualified path: she::protocols::range::prover_for_testing

pub fn prover_for_testing(
    amount: u32,
    g1: NonZero<EcPoint>,
    g2: NonZero<EcPoint>,
    bit_size: u32,
    randomness: Array<felt252>,
    initial_prefix: felt252,
    seed: felt252,
) -> (RangeInputs, RangeProof, felt252)

Structs


RangeInputs	—
RangeProof	—

RangeInputs

Fully qualified path: she::protocols::range::RangeInputs

[derive(Drop)]
pub struct RangeInputs {
    pub g1: NonZero<EcPoint>,
    pub g2: NonZero<EcPoint>,
    pub bit_size: u32,
    pub commitments: Span<NonZero<EcPoint>>,
}

Members

g1

Fully qualified path: she::protocols::range::RangeInputs::g1

pub g1: NonZero<EcPoint>

g2

Fully qualified path: she::protocols::range::RangeInputs::g2

pub g2: NonZero<EcPoint>

bit_size

Fully qualified path: she::protocols::range::RangeInputs::bit_size

pub bit_size: u32

commitments

Fully qualified path: she::protocols::range::RangeInputs::commitments

pub commitments: Span<NonZero<EcPoint>>

RangeProof

Fully qualified path: she::protocols::range::RangeProof

[derive(Drop)]
pub struct RangeProof {
    pub proofs: Span<BitProofWithPrefix>,
}

Members

proofs

Fully qualified path: she::protocols::range::RangeProof::proofs

pub proofs: Span<BitProofWithPrefix>

Keyboard shortcuts

she - Cairo