migrate proof data types

Author: samkim-crypto

zk-sdk-pod/src/lib.rs

@@ -1,6 +1,8 @@
 pub mod encryption;
 pub mod errors;
 pub mod macros;
+pub mod num;
+pub mod proof_data;
 pub mod range_proof;
 pub mod sigma_proofs;
 

zk-sdk-pod/src/num.rs

@@ -0,0 +1,29 @@
+use bytemuck_derive::{Pod, Zeroable};
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Pod, Zeroable)]
+#[repr(transparent)]
+pub struct PodU16([u8; 2]);
+impl From<u16> for PodU16 {
+    fn from(n: u16) -> Self {
+        Self(n.to_le_bytes())
+    }
+}
+impl From<PodU16> for u16 {
+    fn from(pod: PodU16) -> Self {
+        Self::from_le_bytes(pod.0)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Pod, Zeroable)]
+#[repr(transparent)]
+pub struct PodU64([u8; 8]);
+impl From<u64> for PodU64 {
+    fn from(n: u64) -> Self {
+        Self(n.to_le_bytes())
+    }
+}
+impl From<PodU64> for u64 {
+    fn from(pod: PodU64) -> Self {
+        Self::from_le_bytes(pod.0)
+    }
+}

zk-sdk-pod/src/proof_data/batched_grouped_ciphertext_validity/handles_2.rs

@@ -0,0 +1,34 @@
+use {
+    crate::{
+        encryption::{
+            elgamal::PodElGamalPubkey, grouped_elgamal::PodGroupedElGamalCiphertext2Handles,
+        },
+        sigma_proofs::PodBatchedGroupedCiphertext2HandlesValidityProof,
+    },
+    bytemuck_derive::{Pod, Zeroable},
+};
+
+/// The instruction data that is needed for the
+/// `ProofInstruction::VerifyBatchedGroupedCiphertextValidity` instruction.
+///
+/// It includes the cryptographic proof as well as the context data information needed to verify
+/// the proof.
+#[derive(Clone, Copy, Pod, Zeroable)]
+#[repr(C)]
+pub struct BatchedGroupedCiphertext2HandlesValidityProofData {
+    pub context: BatchedGroupedCiphertext2HandlesValidityProofContext,
+
+    pub proof: PodBatchedGroupedCiphertext2HandlesValidityProof,
+}
+
+#[derive(Clone, Copy, Pod, Zeroable)]
+#[repr(C)]
+pub struct BatchedGroupedCiphertext2HandlesValidityProofContext {
+    pub first_pubkey: PodElGamalPubkey, // 32 bytes
+
+    pub second_pubkey: PodElGamalPubkey, // 32 bytes
+
+    pub grouped_ciphertext_lo: PodGroupedElGamalCiphertext2Handles, // 96 bytes
+
+    pub grouped_ciphertext_hi: PodGroupedElGamalCiphertext2Handles, // 96 bytes
+}

zk-sdk-pod/src/proof_data/batched_grouped_ciphertext_validity/handles_3.rs

@@ -0,0 +1,36 @@
+use {
+    crate::{
+        encryption::{
+            elgamal::PodElGamalPubkey, grouped_elgamal::PodGroupedElGamalCiphertext3Handles,
+        },
+        sigma_proofs::PodBatchedGroupedCiphertext3HandlesValidityProof,
+    },
+    bytemuck_derive::{Pod, Zeroable},
+};
+
+/// The instruction data that is needed for the
+/// `ProofInstruction::VerifyBatchedGroupedCiphertext3HandlesValidity` instruction.
+///
+/// It includes the cryptographic proof as well as the context data information needed to verify
+/// the proof.
+#[derive(Clone, Copy, Pod, Zeroable)]
+#[repr(C)]
+pub struct BatchedGroupedCiphertext3HandlesValidityProofData {
+    pub context: BatchedGroupedCiphertext3HandlesValidityProofContext,
+
+    pub proof: PodBatchedGroupedCiphertext3HandlesValidityProof,
+}
+
+#[derive(Clone, Copy, Pod, Zeroable)]
+#[repr(C)]
+pub struct BatchedGroupedCiphertext3HandlesValidityProofContext {
+    pub first_pubkey: PodElGamalPubkey, // 32 bytes
+
+    pub second_pubkey: PodElGamalPubkey, // 32 bytes
+
+    pub third_pubkey: PodElGamalPubkey, // 32 bytes
+
+    pub grouped_ciphertext_lo: PodGroupedElGamalCiphertext3Handles, // 128 bytes
+
+    pub grouped_ciphertext_hi: PodGroupedElGamalCiphertext3Handles, // 128 bytes
+}

zk-sdk-pod/src/proof_data/batched_grouped_ciphertext_validity/mod.rs

@@ -0,0 +1,13 @@
+mod handles_2;
+mod handles_3;
+
+pub use {
+    handles_2::{
+        BatchedGroupedCiphertext2HandlesValidityProofContext,
+        BatchedGroupedCiphertext2HandlesValidityProofData,
+    },
+    handles_3::{
+        BatchedGroupedCiphertext3HandlesValidityProofContext,
+        BatchedGroupedCiphertext3HandlesValidityProofData,
+    },
+};

zk-sdk-pod/src/proof_data/batched_range_proof/batched_range_proof_u128.rs

@@ -0,0 +1,21 @@
+use {
+    crate::{
+        proof_data::batched_range_proof::BatchedRangeProofContext, range_proof::PodRangeProofU128,
+    },
+    bytemuck_derive::{Pod, Zeroable},
+};
+
+/// The instruction data that is needed for the
+/// `ProofInstruction::VerifyBatchedRangeProofU128` instruction.
+///
+/// It includes the cryptographic proof as well as the context data information needed to verify
+/// the proof.
+#[derive(Clone, Copy, Pod, Zeroable)]
+#[repr(C)]
+pub struct BatchedRangeProofU128Data {
+    /// The context data for a batched range proof
+    pub context: BatchedRangeProofContext,
+
+    /// The batched range proof
+    pub proof: PodRangeProofU128,
+}

zk-sdk-pod/src/proof_data/batched_range_proof/batched_range_proof_u256.rs

@@ -0,0 +1,21 @@
+use {
+    crate::{
+        proof_data::batched_range_proof::BatchedRangeProofContext, range_proof::PodRangeProofU256,
+    },
+    bytemuck_derive::{Pod, Zeroable},
+};
+
+/// The instruction data that is needed for the
+/// `ProofInstruction::BatchedRangeProofU256Data` instruction.
+///
+/// It includes the cryptographic proof as well as the context data information needed to verify
+/// the proof.
+#[derive(Clone, Copy, Pod, Zeroable)]
+#[repr(C)]
+pub struct BatchedRangeProofU256Data {
+    /// The context data for a batched range proof
+    pub context: BatchedRangeProofContext,
+
+    /// The batched range proof
+    pub proof: PodRangeProofU256,
+}

zk-sdk-pod/src/proof_data/batched_range_proof/batched_range_proof_u64.rs

@@ -0,0 +1,21 @@
+use {
+    crate::{
+        proof_data::batched_range_proof::BatchedRangeProofContext, range_proof::PodRangeProofU64,
+    },
+    bytemuck_derive::{Pod, Zeroable},
+};
+
+/// The instruction data that is needed for the
+/// `ProofInstruction::VerifyBatchedRangeProofU64` instruction.
+///
+/// It includes the cryptographic proof as well as the context data information needed to verify
+/// the proof.
+#[derive(Clone, Copy, Pod, Zeroable)]
+#[repr(C)]
+pub struct BatchedRangeProofU64Data {
+    /// The context data for a batched range proof
+    pub context: BatchedRangeProofContext,
+
+    /// The batched range proof
+    pub proof: PodRangeProofU64,
+}

zk-sdk-pod/src/proof_data/batched_range_proof/mod.rs

@@ -0,0 +1,29 @@
+use {
+    crate::encryption::pedersen::PodPedersenCommitment,
+    bytemuck_derive::{Pod, Zeroable},
+};
+
+pub mod batched_range_proof_u128;
+pub mod batched_range_proof_u256;
+pub mod batched_range_proof_u64;
+
+pub use {
+    batched_range_proof_u128::BatchedRangeProofU128Data,
+    batched_range_proof_u256::BatchedRangeProofU256Data,
+    batched_range_proof_u64::BatchedRangeProofU64Data,
+};
+
+/// The maximum number of Pedersen commitments that can be processed in a single batched range proof.
+const MAX_COMMITMENTS: usize = 8;
+
+/// The context data needed to verify a range-proof for a Pedersen committed value.
+///
+/// This struct holds the public information that a batched range proof certifies. It includes the
+/// Pedersen commitments and their corresponding bit lengths. This context is shared by all
+/// `VerifyBatchedRangeProof{N}` instructions.
+#[derive(Clone, Copy, Pod, Zeroable)]
+#[repr(C)]
+pub struct BatchedRangeProofContext {
+    pub commitments: [PodPedersenCommitment; MAX_COMMITMENTS],
+    pub bit_lengths: [u8; MAX_COMMITMENTS],
+}

zk-sdk-pod/src/proof_data/ciphertext_ciphertext_equality.rs

@@ -0,0 +1,33 @@
+use {
+    crate::{
+        encryption::elgamal::{PodElGamalCiphertext, PodElGamalPubkey},
+        sigma_proofs::PodCiphertextCiphertextEqualityProof,
+    },
+    bytemuck_derive::{Pod, Zeroable},
+};
+
+/// The instruction data that is needed for the
+/// `ProofInstruction::VerifyCiphertextCiphertextEquality` instruction.
+///
+/// It includes the cryptographic proof as well as the context data information needed to verify
+/// the proof.
+#[derive(Clone, Copy, Pod, Zeroable)]
+#[repr(C)]
+pub struct CiphertextCiphertextEqualityProofData {
+    pub context: CiphertextCiphertextEqualityProofContext,
+
+    pub proof: PodCiphertextCiphertextEqualityProof,
+}
+
+/// The context data needed to verify a ciphertext-ciphertext equality proof.
+#[derive(Clone, Copy, Pod, Zeroable)]
+#[repr(C)]
+pub struct CiphertextCiphertextEqualityProofContext {
+    pub first_pubkey: PodElGamalPubkey, // 32 bytes
+
+    pub second_pubkey: PodElGamalPubkey, // 32 bytes
+
+    pub first_ciphertext: PodElGamalCiphertext, // 64 bytes
+
+    pub second_ciphertext: PodElGamalCiphertext, // 64 bytes
+}