diff --git a/zk-sdk/src/lib.rs b/zk-sdk/src/lib.rs
index 5510fcb0..6464cec9 100644
--- a/zk-sdk/src/lib.rs
+++ b/zk-sdk/src/lib.rs
@@ -29,6 +29,12 @@ mod sigma_proofs;
 pub mod transcript;
 pub mod zk_elgamal_proof_program;
 
+/// Global transcript domain separator.
+///
+/// This string MUST be changed for any fork or separate deployment to prevent
+/// cross-chain proof replay attacks.
+pub const TRANSCRIPT_DOMAIN: &[u8] = b"solana-zk-elgamal-proof-program-v1";
+
 /// Byte length of a compressed Ristretto point or scalar in Curve255519
 const UNIT_LEN: usize = 32;
 /// Byte length of a compressed Ristretto point in Curve25519
diff --git a/zk-sdk/src/range_proof/inner_product.rs b/zk-sdk/src/range_proof/inner_product.rs
index 66e6fbc5..734e9c6d 100644
--- a/zk-sdk/src/range_proof/inner_product.rs
+++ b/zk-sdk/src/range_proof/inner_product.rs
@@ -503,8 +503,8 @@ mod tests {
             G.iter().chain(H.iter()).chain(iter::once(&Q)),
         );
 
-        let mut prover_transcript = Transcript::new(b"innerproducttest");
-        let mut verifier_transcript = Transcript::new(b"innerproducttest");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"innerproducttest");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"innerproducttest");
 
         let proof = InnerProductProof::new(
             &Q,
@@ -532,7 +532,7 @@ mod tests {
             .is_ok());
 
         let proof = InnerProductProof::from_bytes(proof.to_bytes().as_slice()).unwrap();
-        let mut verifier_transcript = Transcript::new(b"innerproducttest");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"innerproducttest");
         assert!(proof
             .verify(
                 n,
diff --git a/zk-sdk/src/range_proof/mod.rs b/zk-sdk/src/range_proof/mod.rs
index 0c00cb1b..9c53e628 100644
--- a/zk-sdk/src/range_proof/mod.rs
+++ b/zk-sdk/src/range_proof/mod.rs
@@ -529,8 +529,8 @@ mod tests {
     fn test_single_rangeproof() {
         let (comm, open) = Pedersen::new(55_u64);
 
-        let mut transcript_create = Transcript::new(b"Test");
-        let mut transcript_verify = Transcript::new(b"Test");
+        let mut transcript_create = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut transcript_verify = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof =
             RangeProof::new(vec![55], vec![32], vec![&open], &mut transcript_create).unwrap();
@@ -551,8 +551,8 @@ mod tests {
         let (comm_2, open_2) = Pedersen::new(77_u64);
         let (comm_3, open_3) = Pedersen::new(99_u64);
 
-        let mut transcript_create = Transcript::new(b"Test");
-        let mut transcript_verify = Transcript::new(b"Test");
+        let mut transcript_create = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut transcript_verify = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = RangeProof::new(
             vec![55, 77, 99],
@@ -580,8 +580,8 @@ mod tests {
     fn range_proof_bytes_roundtrip() {
         let (comm, open) = Pedersen::new(42_u64);
 
-        let mut transcript_create = Transcript::new(b"Test");
-        let mut transcript_verify = Transcript::new(b"Test");
+        let mut transcript_create = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut transcript_verify = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let bits: usize = 8;
 
@@ -602,23 +602,23 @@ mod tests {
 
     #[test]
     fn test_range_proof_string() {
-        let commitment_1_str = "dDaa/MTEDlyI0Nxx+iu1tOteZsTWmPXAfn9QI0W9mSc=";
+        let commitment_1_str = "qtkYT/O6bSJ9y7mtqxjZ7dOqloJwLGTcTaeG+5GlBWo=";
         let pod_commitment_1 = PodPedersenCommitment::from_str(commitment_1_str).unwrap();
         let commitment_1: PedersenCommitment = pod_commitment_1.try_into().unwrap();
 
-        let commitment_2_str = "tnRILjKpogi2sXxLgZzMqlqPMLnCJmrSjZ5SPQYhtgg=";
+        let commitment_2_str = "pCdHYFSN7yMEK9Li01M1w1OeRzbaVgQ8xYHlxPTUtF0=";
         let pod_commitment_2 = PodPedersenCommitment::from_str(commitment_2_str).unwrap();
         let commitment_2: PedersenCommitment = pod_commitment_2.try_into().unwrap();
 
-        let commitment_3_str = "ZAC5ZLXotsMOVExtrr56D/EZNeyo9iWepNbeH22EuRo=";
+        let commitment_3_str = "gqs3gA6CqT3Uvpb2eCW/lo6m/A2RxHSSopObQkv3DCU=";
         let pod_commitment_3 = PodPedersenCommitment::from_str(commitment_3_str).unwrap();
         let commitment_3: PedersenCommitment = pod_commitment_3.try_into().unwrap();
 
-        let proof_str = "AvvBQL63pXMXsmuvuNbs/CqXdzeyrMpEIO2O/cI6/SyqU4N+7HUU3LmXai9st+DxqTnuKsm0SgnADfpLpQCEbDDupMb09NY8oHT8Bx8WQhv9eyoBlrPRd7DVhOUsio02gBshe3p2Wj7+yDCpFaZ7/PMypFBX6+E+EqCiPI6yUk4ztslWY0Ksac41eJgcPzXyIx2kvmSTsVBKLb7U01PWBC+AUyUmK3/IdvmJ4DnlS3xFrdg/mxSsYJFd3OZA3cwDb0jePQf/P43/2VVqPRixMVO7+VGoMKPoRTEEVbClsAlW6stGTFPcrimu3c+geASgvwElkIKNGtYcjoj3SS+/VeqIG9Ei1j+TJtPhOE9SG4KNw9xBGwecpliDbQhKjO950EVcnOts+a525/frZV1jHJmOOrZtKRV4pvk37dtQkx4sv+pxRmfVrjwOcKQeg+BzcuF0vaQbqa4SUbzbO9z3RwIMlYIBaz0bqZgJmtPOFuFmNyCJaeB29vlcEAfYbn5gdlgtWP50tKmhoskndulziKZjz4qHSA9rbG2ZtoMHoCsAobHKu2H9OxcaK4Scj1QGwst+zXBEY8uePNbxvU5DMJLVFORtLUXkVdPCmCSsm1Bz4TRbnls8LOVW6wqTgShQMhjNM3RtwdHXENPn5uDnhyvfduAcL+DtI8AIJyRneROefk7i7gjal8dLdMM/QnXT7ctpMQU6uNlpsNzq65xlOQKXO71vQ3c2mE/DmxVJi6BTS5WCzavvhiqdhQyRL61ESCALQpaP0/d0DLwLikVH3ypuDLEnVXe9Pmkxdd0xCzO6QcfyK50CPnV/dVgHeLg8EVag2O83+/7Ys5oLxrDad9TJTDcrT2xsRqECFnSA+z9uZtDPujhQL0ogS5RH4agnQN4mVGTwOLV8OKpn+AvWq6+j1/9EXFkLPBTU5wT0FQuT2VZ8xp5GeqdI13Zey1uPrxc6CZZ407y9OINED4IdBQ==";
+        let proof_str = "lLDpeo97bHU8A34ruX/wKUY4SJgCKLZf7HiBy6Tz5R8EGdLQuqleOmGWWt+tWO9XMqww1vBNDSADFTMONLWsNLrsArLR2ALxpqUSo/Kw9LG3gH+YApSZksWrYuk7RG1K0JtVnt6j9hYSoLiuinkIm3iWTyfrVZooiX1FMoRAnD5SyPYNJxV4e4POb6WpJvkgXVZuNUC5DF0SK2yVihGmBu05fpG8eHhMcekSPUfIVjNfSQImJ09YvVUgVJvGAcAKBIbB/L2bOfUcmRcrun/F8cOnV5MuSJ0IzYcl9SkEPgEKiC5qv4oep2fWg4Ch0RUM9uWBxI+FXbM/xesdvTzfC3bIhntvws8f5BON6hm/6reWR/7J+z+8rSM0pbpFDalaWLXYxM7uSm4sHzvZtU+Z6/eDvpmNJyVCfFbkcETQsQ/OMzavDAbhpbsvcOPHIgTiesOtgDFBYWarJSrWSmckcaqQ1bEftaSkB+Kbs6zvfc0Pl0LfOy5zt3a3Nqh0a5BwgFEerolBgu/ZX5sptjTnu2psvgBPDzOsUYtRKhY1sXPyg2t9KhFVJ/Riw1+AlnQuAL0GJYCFPUVSkJX2dRVzHQ41kdti6pMsTh/ifBLLlSf5AYk9jiYeHk1HCokBITcwXL36nI3B1HQl6g3/nsx//Jd7w17hJuuIYkOhNuz7iTtisvnCNZdiDkFcTky8ya8oJBM1kJrdakdesStWTXzJOvKfs5jUrl5yVksq+E/jM/oU09cYSoesUQMxAgHqJmkvipRlx71+/YgL1349W4wJ3oPd6kkYx0YVwEHjqiZTvnJEVyUvQxc6X0ddUpNBrjfRxKJ5OV+axOaz76S22PokJh6LNbwa7EUVEwVW0BIABytN9fOe7y+2w4+k73Q8LuFE5QIaqcWX/9IRHey5wEbKtF4ARD6pot92nqXZLxUP1whvrMYNlbFeYLGBX6T6J5+7j3c3fHgCZAhMWSU+MNuGBQ==";
         let pod_proof = PodRangeProofU128::from_str(proof_str).unwrap();
         let proof: RangeProof = pod_proof.try_into().unwrap();
 
-        let mut transcript_verify = Transcript::new(b"Test");
+        let mut transcript_verify = Transcript::new_zk_elgamal_transcript(b"Test");
 
         proof
             .verify(
diff --git a/zk-sdk/src/sigma_proofs/batched_grouped_ciphertext_validity/handles_2.rs b/zk-sdk/src/sigma_proofs/batched_grouped_ciphertext_validity/handles_2.rs
index 07b22b6d..f9c36e31 100644
--- a/zk-sdk/src/sigma_proofs/batched_grouped_ciphertext_validity/handles_2.rs
+++ b/zk-sdk/src/sigma_proofs/batched_grouped_ciphertext_validity/handles_2.rs
@@ -221,8 +221,8 @@ mod test {
             handles: [first_handle_hi, second_handle_hi],
         };
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = BatchedGroupedCiphertext2HandlesValidityProof::new(
             first_pubkey,
@@ -254,32 +254,32 @@ mod test {
 
     #[test]
     fn test_batched_grouped_ciphertext_2_handles_validity_proof_string() {
-        let first_pubkey_str = "wiRFV9DBwFjq0VAhE0nIqReYYUp8ONNL8o2btZ7vMyA=";
+        let first_pubkey_str = "cvkvHnlr6h8V9V1Q2mGj5+XH6SBvJRR3dMdDYtgnpwk=";
         let pod_first_pubkey = PodElGamalPubkey::from_str(first_pubkey_str).unwrap();
         let first_pubkey: ElGamalPubkey = pod_first_pubkey.try_into().unwrap();
 
-        let second_pubkey_str = "4NXmE874oiZ5ZnId2pjT3G4PpIiZ+XXQ/S6CN7X3L0k=";
+        let second_pubkey_str = "evcjLw8+v2mcWRisCCKXbjWVNRsC0JufOoSV5cR9ixg=";
         let pod_second_pubkey = PodElGamalPubkey::from_str(second_pubkey_str).unwrap();
         let second_pubkey: ElGamalPubkey = pod_second_pubkey.try_into().unwrap();
 
-        let grouped_ciphertext_lo_str = "znf5HkMod0lFyQIXs/vEh5y/XupcB0BFWpifP3r9ty/yKqpQckmCu346CR0mz6c8UsCno340HpNHnXWgEu2BFuKo/7SDXpRBPwexGl1p2XWr4gzRA2mq02w7lGyKmXBD";
+        let grouped_ciphertext_lo_str = "MsnlU3s9YjWFaC3IjIKS52yl41X1xH+mre0BbAwE2j3E28wjWQPZn4B4nM+eV0zgihHq7uUSY57a4l42HJRULIBlCR/8G2Wfuq63WVbBroxmRbbJzZFGgdpGVLoFA8Aw";
         let pod_grouped_ciphertext_lo =
             PodGroupedElGamalCiphertext2Handles::from_str(grouped_ciphertext_lo_str).unwrap();
         let grouped_ciphertext_lo: GroupedElGamalCiphertext<2> =
             pod_grouped_ciphertext_lo.try_into().unwrap();
 
-        let grouped_ciphertext_hi_str = "8K38lmBNf4fym6a5VXtimvCeOl7+WnRy0flw4c8bEnOQkH+KjCuq49eoBFLWYj1qBl3z4T1oX0jqVMUV7Q56TSChJHie1HFJ/2JA0lNNLAGHFN2wWvi/oIsydgkHofov";
+        let grouped_ciphertext_hi_str = "2kpzTKaOoiNM/zZimt9g5uX60GFCes355lM4S2QvWx46YMpuGWoU5gG5G9hoCuY5T9PwGTiIQashf6mUFuulPWr0EYKatR7Q8dfyeFpJl2pdZ2Imwmf5LDqDUXSt9Zg3";
         let pod_grouped_ciphertext_hi =
             PodGroupedElGamalCiphertext2Handles::from_str(grouped_ciphertext_hi_str).unwrap();
         let grouped_ciphertext_hi: GroupedElGamalCiphertext<2> =
             pod_grouped_ciphertext_hi.try_into().unwrap();
 
-        let proof_str = "/nHixPF/ne2Wo67Ga4Jk/H1BkD0Erf/aqKqiUSjb71liado8WGgY0He29iKYeDUoq5NMASG/Qd9YGNg4IDr+ZLL4uTGGv4+Gdu2oXsTDgVM1rfu8K27vb5k7crDw7DN15CHXR+vjrVR0VxajwlBNWQAFWB8rEkSIDZUoJOU28gGjWK3TpJ3mBwY2YgntcHT1+GgeRmdnSrieU6wo45oHAw==";
+        let proof_str = "GqVxS3sISd9hw3r0jDx3qwNFArLpiXMcySvtQqu5PSGoZDTtRgXMDiSEPSRoTER7/pjI/z2G8yNWYBMS6E28U8rnVCAS6k1K8anbrTF4n7TRmAac4CdpKCh8AZPzvi40kpWskl20Fogq8WPVf1r2i6nesQGTrMsKXH5j7ShC8QZbPtTn878eTdB7K9DNWFxGshxL8KzMh0dLMlj7IAJnAg==";
         let pod_proof =
             PodBatchedGroupedCiphertext2HandlesValidityProof::from_str(proof_str).unwrap();
         let proof: BatchedGroupedCiphertext2HandlesValidityProof = pod_proof.try_into().unwrap();
 
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         proof
             .verify(
diff --git a/zk-sdk/src/sigma_proofs/batched_grouped_ciphertext_validity/handles_3.rs b/zk-sdk/src/sigma_proofs/batched_grouped_ciphertext_validity/handles_3.rs
index b440fce6..7e154b8d 100644
--- a/zk-sdk/src/sigma_proofs/batched_grouped_ciphertext_validity/handles_3.rs
+++ b/zk-sdk/src/sigma_proofs/batched_grouped_ciphertext_validity/handles_3.rs
@@ -245,8 +245,8 @@ mod test {
             handles: [first_handle_hi, second_handle_hi, third_handle_hi],
         };
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = BatchedGroupedCiphertext3HandlesValidityProof::new(
             first_pubkey,
@@ -280,36 +280,36 @@ mod test {
 
     #[test]
     fn test_batched_grouped_ciphertext_3_handles_validity_proof_string() {
-        let first_pubkey_str = "wHNY5XvUo78IXLa1cUlUihKFtGc4MBYNa2owsDMUeGY=";
+        let first_pubkey_str = "mv/4oSby3PfTEG9gG4SDDlkN3b0YTpuyjdX9+40FKQY=";
         let pod_first_pubkey = PodElGamalPubkey::from_str(first_pubkey_str).unwrap();
         let first_pubkey: ElGamalPubkey = pod_first_pubkey.try_into().unwrap();
 
-        let second_pubkey_str = "gFcPVz9K6hrmZaIIxZCzUReAaslmoeG+iYgqgAjYIik=";
+        let second_pubkey_str = "hPehNW3wI5YdK5b4yeIM+t9zS5oBtGILLiltFUui1UA=";
         let pod_second_pubkey = PodElGamalPubkey::from_str(second_pubkey_str).unwrap();
         let second_pubkey: ElGamalPubkey = pod_second_pubkey.try_into().unwrap();
 
-        let third_pubkey_str = "BDq8H0zNhWN4a33SbBS9VeKkaPHH+XpEuOtQKmVoHhY=";
+        let third_pubkey_str = "hlACCsmVJVIZxa25qpKbjBO11wg/Tdtcz954OtHOWVw=";
         let pod_third_pubkey = PodElGamalPubkey::from_str(third_pubkey_str).unwrap();
         let third_pubkey: ElGamalPubkey = pod_third_pubkey.try_into().unwrap();
 
-        let grouped_ciphertext_lo_str = "iKQ6Z39F6m4aax7LZT6fOSj4zCVRtymxFoUHnZ5y3ypWwQDK5BwI0tB+T/D+GKe9xL2RLLCp3a0DFh6Wa3HUMQ5TGnwZSqpqvx4+G9LUVYhLsIJgkm9+ugn8W2xI7IsgtKVtI25e728L3RuNlVuPTFpo6JBpeQu6JVKLFlND+Cg=";
+        let grouped_ciphertext_lo_str = "ksKg6KXMBA9iFSh/PMqV9k03AGz5eigsm2+TT6RZplg2HCExsRJJQCpHbCu+ab7aj5hMEWhNLokKB2S2uEsnEF7w6HriN99/+vKbkGg7613d2+TzX8gxjeC6boZWtGFCqH00JXSvbZIjbvOPffhGy/Y7u/zh1r+aeDmuQRd7vmM=";
         let pod_grouped_ciphertext_lo =
             PodGroupedElGamalCiphertext3Handles::from_str(grouped_ciphertext_lo_str).unwrap();
         let grouped_ciphertext_lo: GroupedElGamalCiphertext<3> =
             pod_grouped_ciphertext_lo.try_into().unwrap();
 
-        let grouped_ciphertext_hi_str = "XIMFG7lp3lvF/6AhQPdnKiNITBBZFC18ldeZ8WcH9Hvan3Af1pmZKpCGYNmVq6o08rdp/GVLsousKle927xgJORqagQIJJRI9m3ycxsNnVNQp3xH6j2fFCTMGV1WRP4XJuS9DLkByIqDaKZzAJX1NiHCoQr32W9Pn+aHVo5d+Co=";
+        let grouped_ciphertext_hi_str = "DMNBOrDAamfntobNpK1EXJ/dSA44Qmhc5EeVcZTz/gQOnxO4GYRSpeiu7IwujAPPalnuaWkQYlzfS8b79OfNJRganJZYVQg4aU2Ul+OjKrETKdhCo7K3qFhMoJiZGJFKnHLFCGyDsCPyvc2FQopxjbaDjrVsmDTMEJPStpZZAH8=";
         let pod_grouped_ciphertext_hi =
             PodGroupedElGamalCiphertext3Handles::from_str(grouped_ciphertext_hi_str).unwrap();
         let grouped_ciphertext_hi: GroupedElGamalCiphertext<3> =
             pod_grouped_ciphertext_hi.try_into().unwrap();
 
-        let proof_str = "Xuc6mdJ9uwShYmmxOti6mkyYsL7sbvoAQGCZabm6e2wGeIPORDtsQt1s4lnEtPodoFGBOjw/GH7qNtwcTBewWnrvfRA7ZzYbb1kTO7NfCthxunu7YQ9S3kemdIJlYKM3aoYkJp7/vLm7FE6Tuhr128I9nYIUcrYoRIuDVSMeTHpMBaLkfKHJGI95IPiCBHWtE0KeNKZLWUpM/CFdELJECNDJ68dG169GKLANMQh8rxMIgHyasVuG/bP11JAvgAwF";
+        let proof_str = "tA4eOWOFFKF50h5vEGUdh7znZDV2KY/PJN8aFsqtyVuOvHoJQTyxMA8f1PTYa39rTkiVEYz3r2eV4Es8gvDMXCZdQoSc/mHE5QsPLT02ArpTSsFoZ1z4E9DZOxIuoqQ5EBc4Zy/brk2NWbpJua4FtPQB7fLHWIS/YgK7v6/cKlKhz64iyKeZxmNFKi12awd5s9vRGDGZvv0inoF+QoqgBB5PRTCR933/r4+Alkx340oFTQnZG7HABG4ora3i0KwK";
         let pod_proof =
             PodBatchedGroupedCiphertext3HandlesValidityProof::from_str(proof_str).unwrap();
         let proof: BatchedGroupedCiphertext3HandlesValidityProof = pod_proof.try_into().unwrap();
 
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         proof
             .verify(
diff --git a/zk-sdk/src/sigma_proofs/ciphertext_ciphertext_equality.rs b/zk-sdk/src/sigma_proofs/ciphertext_ciphertext_equality.rs
index 961bf87d..839fd2d8 100644
--- a/zk-sdk/src/sigma_proofs/ciphertext_ciphertext_equality.rs
+++ b/zk-sdk/src/sigma_proofs/ciphertext_ciphertext_equality.rs
@@ -325,8 +325,8 @@ mod test {
             .pubkey()
             .encrypt_with(message, &second_opening);
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = CiphertextCiphertextEqualityProof::new(
             &first_keypair,
@@ -359,8 +359,8 @@ mod test {
             .pubkey()
             .encrypt_with(second_message, &second_opening);
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = CiphertextCiphertextEqualityProof::new(
             &first_keypair,
@@ -390,27 +390,27 @@ mod test {
 
     #[test]
     fn test_ciphertext_ciphertext_equality_proof_string() {
-        let first_pubkey_str = "XKhsxbC3XUsUTSUHeGYtPhT1pKzh+6d+Pg0uZdR3Ywo=";
+        let first_pubkey_str = "GIKnIiKI6A6BbzxToDRqzotS8CyzKZbQzvYMkk1WQjs=";
         let pod_first_pubkey = PodElGamalPubkey::from_str(first_pubkey_str).unwrap();
         let first_pubkey: ElGamalPubkey = pod_first_pubkey.try_into().unwrap();
 
-        let second_pubkey_str = "+pWhNz5/aD4ilMW51l/+pRky8quQp3LOwLidNG0sbw0=";
+        let second_pubkey_str = "Iph2rhdueZ+zu80qqol50HpCDSZUi8Dsnj5HgG1SLxo=";
         let pod_second_pubkey = PodElGamalPubkey::from_str(second_pubkey_str).unwrap();
         let second_pubkey: ElGamalPubkey = pod_second_pubkey.try_into().unwrap();
 
-        let first_ciphertext_str = "rFxGWbBfME9OPMbbM0+Rva6fHR36QSk7HBpaRigT/y+wQiuDcdvox90nDXBB6JItVzCz+1CcOJS8yGL0LEiuIg==";
+        let first_ciphertext_str = "JN53y4eNNDlLVT9/K1RaEmduNZGes/8tJYN9IxI6519cyvae5bOZEEGWeHmxaTRwV/84/yw54AdezYWIl1KDeg==";
         let pod_first_ciphertext = PodElGamalCiphertext::from_str(first_ciphertext_str).unwrap();
         let first_ciphertext: ElGamalCiphertext = pod_first_ciphertext.try_into().unwrap();
 
-        let second_ciphertext_str = "ZCfDdEUJpdGkoDKL6ykMAhR42HZldHXHs7CFS4mBiRFc4vGZr2I833MqKA+QBmoD/A+qZEQn/E7oTcHhUtywXA==";
+        let second_ciphertext_str = "Vl51YOwSgLntr5MKMV9pTeRYzfnaCinVc/P7MSzggGRO7kkmtm3mmwG+aRrb2jSrCrW/570S/5euiEVV7Lg0dQ==";
         let pod_second_ciphertext = PodElGamalCiphertext::from_str(second_ciphertext_str).unwrap();
         let second_ciphertext: ElGamalCiphertext = pod_second_ciphertext.try_into().unwrap();
 
-        let proof_str = "vGlON1XF9o0HGm6RKTiwzdcqv+Z9TloHeJdFHZfC7EZkk4b+BuoLckiYmKN8AirgrO3Lq2fStuXToPW1l9PbMB71G61bA2lM1jI2NdBc3N2cHgjPhsZh6Z2sUH9vg1cbtIquvawYevRFb4+cssT3HmNRW3bc2Tfrf0DpPIM/1g87+QrwziKG3OUqDVw+GK/p/SncS7b4aLOXMPVBhP5CCO3R/KVaeTzNz0WHljfUp7LPial2zTpRbic2dbUC1PgPAsqvnZzSEQQ3NM3IVCt5cEIF5xq/S4aDrolvKAjCZwM=";
+        let proof_str = "ij/fhClZeoguA0RvwPqbzU0Df3lqWwZgQdOLCiRmq2KA79t4/EOaHeWlXNugCRDC/SMdbVLt1k32Ko3P3BjNA7zXoI19g4ex61/UGL4+ScL9xpcsJRVheqFENxhbZjZ7CLRWXkYAl+UvVcvHjSuO2bVHPpuHBoBONlUt5rP5K2cxrg1sgH7wXvrV2cMEtZOqA9MQ0WYemEb2N9c77BycArJgGc/wlRu58VygHmbEuwbmWsrfc1xdpjb5LFSBuaoEeCvywXJmR7iL9JgfkIhvv//jvDCeK6BkqsfStocFrQQ=";
         let pod_proof = PodCiphertextCiphertextEqualityProof::from_str(proof_str).unwrap();
         let proof: CiphertextCiphertextEqualityProof = pod_proof.try_into().unwrap();
 
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         proof
             .verify(
diff --git a/zk-sdk/src/sigma_proofs/ciphertext_commitment_equality.rs b/zk-sdk/src/sigma_proofs/ciphertext_commitment_equality.rs
index a8154fd7..4fa3a145 100644
--- a/zk-sdk/src/sigma_proofs/ciphertext_commitment_equality.rs
+++ b/zk-sdk/src/sigma_proofs/ciphertext_commitment_equality.rs
@@ -288,8 +288,8 @@ mod test {
         let ciphertext = keypair.pubkey().encrypt(message);
         let (commitment, opening) = Pedersen::new(message);
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = CiphertextCommitmentEqualityProof::new(
             &keypair,
@@ -317,8 +317,8 @@ mod test {
         let ciphertext = keypair.pubkey().encrypt(encrypted_message);
         let (commitment, opening) = Pedersen::new(committed_message);
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = CiphertextCommitmentEqualityProof::new(
             &keypair,
@@ -356,8 +356,8 @@ mod test {
         let ciphertext = elgamal_keypair.pubkey().encrypt(message);
         let (commitment, opening) = Pedersen::new(message);
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = CiphertextCommitmentEqualityProof::new(
             &elgamal_keypair,
@@ -386,8 +386,8 @@ mod test {
         let commitment = PedersenCommitment::from_bytes(&[0u8; 32]).unwrap();
         let opening = PedersenOpening::from_bytes(&[0u8; 32]).unwrap();
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = CiphertextCommitmentEqualityProof::new(
             &elgamal_keypair,
@@ -416,8 +416,8 @@ mod test {
         let commitment = PedersenCommitment::from_bytes(&[0u8; 32]).unwrap();
         let opening = PedersenOpening::from_bytes(&[0u8; 32]).unwrap();
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = CiphertextCommitmentEqualityProof::new(
             &elgamal_keypair,
@@ -445,8 +445,8 @@ mod test {
         let ciphertext = ElGamalCiphertext::from_bytes(&[0u8; 64]).unwrap();
         let (commitment, opening) = Pedersen::new(message);
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = CiphertextCommitmentEqualityProof::new(
             &elgamal_keypair,
@@ -469,23 +469,23 @@ mod test {
 
     #[test]
     fn test_ciphertext_commitment_equality_proof_string() {
-        let pubkey_str = "GjhkgCwnACDgcXgg84ftN6D/qTXklqGHXV6bpS6Gxng=";
+        let pubkey_str = "uO3j5FuK4OGJD8ain+4MXLU84ixomYnBI5s0pQ3X0Cs=";
         let pod_pubkey = PodElGamalPubkey::from_str(pubkey_str).unwrap();
         let pubkey: ElGamalPubkey = pod_pubkey.try_into().unwrap();
 
-        let ciphertext_str = "tFwKgb/c+ur8umDgAS0KgZLonGmasp3Q+2ZsmLm2U22wPiAKj38zY36XtXYvoFfz9uQPYhw6yQipmtMa+UQDHA==";
+        let ciphertext_str = "PsM4qA4ImFKGui57JZKzIFl1RO30GG+saCMmI9gAAENu82mvud6uhZ6YLJoLcq5hLSLPY48R8p//H24gNjxoBg==";
         let pod_ciphertext = PodElGamalCiphertext::from_str(ciphertext_str).unwrap();
         let ciphertext: ElGamalCiphertext = pod_ciphertext.try_into().unwrap();
 
-        let commitment_str = "QqbD5LkfgnlpIYnJyyC24R32FarXXYWUJBgK/IDGwBc=";
+        let commitment_str = "RNst9nTGL7PkluExuhmD1kJNM86ZZH6OE8R4P1pPFHQ=";
         let pod_commitment = PodPedersenCommitment::from_str(commitment_str).unwrap();
         let commitment: PedersenCommitment = pod_commitment.try_into().unwrap();
 
-        let proof_str = "wrCo38Ny+SoLGdSDQ/UuE2JnjQslz7rofz386C5VRjRUBaZ1Y7oeT4WVOonW+W1c0uFUCg0zhs/8FmsVORBfXV43lnRkwuPUPKPDDUXWciZoVtWrVOSakutDYLI62CIsIXCx6IzcfEXHYPYpXQGqc/Cf9LdEiVAgFV8BDVe3GQZV9V6HwQWyadTx0R/cAb4vrCqe9h5cudM5Qwj45wAzDmiXUkbLb53Y1nvC3qf7Pq7b94eAClSSzhDr3VbO9k8L";
+        let proof_str = "ELyazp4KuO/vLn91GiiEBgwYlMvisVisVRf8DWRjE1KoFGV2mxRX370N/roHFXArVXGTzL1e0C8UAPHHVYI5M+rE7mXhpGJ1rpMuGduCavOb7WIvzYE0xO6gQmPMeow08x5O/e4SlyGfA2s1S/Z8J+t9yxqbfqTugn9TNjFBFAcM3WOOFGk0dQdi7V3YGpNQMz3P9oWE7d1SsVohUDYEAvyaqXYWc0+YSJEdC7BaRdTqXp4ft8ybAjNB6SmCeisO";
         let pod_proof = PodCiphertextCommitmentEqualityProof::from_str(proof_str).unwrap();
         let proof: CiphertextCommitmentEqualityProof = pod_proof.try_into().unwrap();
 
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         proof
             .verify(&pubkey, &ciphertext, &commitment, &mut verifier_transcript)
diff --git a/zk-sdk/src/sigma_proofs/grouped_ciphertext_validity/handles_2.rs b/zk-sdk/src/sigma_proofs/grouped_ciphertext_validity/handles_2.rs
index e3f1e248..39887387 100644
--- a/zk-sdk/src/sigma_proofs/grouped_ciphertext_validity/handles_2.rs
+++ b/zk-sdk/src/sigma_proofs/grouped_ciphertext_validity/handles_2.rs
@@ -319,8 +319,8 @@ mod test {
             handles: [first_handle, second_handle],
         };
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = GroupedCiphertext2HandlesValidityProof::new(
             first_pubkey,
@@ -360,8 +360,8 @@ mod test {
             handles: [first_handle, second_handle],
         };
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = GroupedCiphertext2HandlesValidityProof::new(
             &first_pubkey,
@@ -400,8 +400,8 @@ mod test {
             handles: [first_handle, second_handle],
         };
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = GroupedCiphertext2HandlesValidityProof::new(
             first_pubkey,
@@ -439,8 +439,8 @@ mod test {
             handles: [first_handle, second_handle],
         };
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = GroupedCiphertext2HandlesValidityProof::new(
             first_pubkey,
@@ -468,25 +468,25 @@ mod test {
 
     #[test]
     fn test_grouped_ciphertext_validity_proof_string() {
-        let first_pubkey_str = "/AAGWq6R6Q+WTAAVKPWfprjJyxEZJTSfc7d86p4NoQY=";
+        let first_pubkey_str = "gtNxEo4FPZgflFBNJP5bH5j8lNIKy2tSdMc2NgH9/GE=";
         let pod_first_pubkey = PodElGamalPubkey::from_str(first_pubkey_str).unwrap();
         let first_pubkey: ElGamalPubkey = pod_first_pubkey.try_into().unwrap();
 
-        let second_pubkey_str = "SH4Fx8z2WPPw1RFtpNHJqpmWZ4caT4DJrAZeB0Uejg4=";
+        let second_pubkey_str = "2n1QN21P9Sct2VLIPZPnMrKaaOk32HgJswBSrnS//2c=";
         let pod_second_pubkey = PodElGamalPubkey::from_str(second_pubkey_str).unwrap();
         let second_pubkey: ElGamalPubkey = pod_second_pubkey.try_into().unwrap();
 
-        let grouped_ciphertext_str = "TvcjS9N355ALEoD1XmUmr9wJbTJtbatTO08vrGP72n8+7LjGEkJtz98qwx0EXFGUWOgIfLTX9nIb/9T8uIE4a6ggg0i5ymLFP/7nIQFbTAKbCR6ZaMAzJ7ifFjUsS60E";
+        let grouped_ciphertext_str = "ZBw1CGUSTw+HUMOz5kZfudrvpA06RRXZ3r1Fbbl9W2NgowjM+0pXGDX3o+15YjMOdYLMpATyRVOAn/tvViyndEZy4BYO6P9gK3snCDVBqVLWe3NhpYqZODiy0KycRLo1";
         let pod_grouped_ciphertext =
             PodGroupedElGamalCiphertext2Handles::from_str(grouped_ciphertext_str).unwrap();
         let grouped_ciphertext: GroupedElGamalCiphertext<2> =
             pod_grouped_ciphertext.try_into().unwrap();
 
-        let proof_str = "yrq38Wvs11QWFGVCw4nNOYdS5cEdSYWhCOnxRFfucmDsOv7If1hAOO+c634+r5gQn5Xz6pOTzMmbLGY5dlhvW1QaYNtcOcA93w21DfTLKb7OuOqBP6AV/XjhuQzOKkg+plDrzdHLGdxwMpFTpvzrCgCiJZc7z2j7okCBuh4INwZ+k28TF1l6dGg4dhnoWNW8+R/yMq7WmfJ4b84fUdMDBA==";
+        let proof_str = "0KudqgloR0IekkFmhDTz63kwtqecTVEMZtmb1qruARuqqki5AjgZoyHy6qJG3AugO4Ur8AP6/4RbH+EJExAzNKJincDYZUxe1VFZRgmD4pRnfYz2NEqZ3YizYC3NQ051ii91O1FxQzYfXOjsnQl4qvtkZqM6c6gZMxWtVmlMJAuu3buONyUOsyDHEx0gXBWTN5hv/CvSZij7owfPnZ36CA==";
         let pod_proof = PodGroupedCiphertext2HandlesValidityProof::from_str(proof_str).unwrap();
         let proof: GroupedCiphertext2HandlesValidityProof = pod_proof.try_into().unwrap();
 
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         proof
             .verify(
diff --git a/zk-sdk/src/sigma_proofs/grouped_ciphertext_validity/handles_3.rs b/zk-sdk/src/sigma_proofs/grouped_ciphertext_validity/handles_3.rs
index 110d3b70..25595ad7 100644
--- a/zk-sdk/src/sigma_proofs/grouped_ciphertext_validity/handles_3.rs
+++ b/zk-sdk/src/sigma_proofs/grouped_ciphertext_validity/handles_3.rs
@@ -373,8 +373,8 @@ mod test {
             handles: [first_handle, second_handle, third_handle],
         };
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = GroupedCiphertext3HandlesValidityProof::new(
             first_pubkey,
@@ -418,8 +418,8 @@ mod test {
             handles: [first_handle, second_handle, third_handle],
         };
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = GroupedCiphertext3HandlesValidityProof::new(
             &first_pubkey,
@@ -464,8 +464,8 @@ mod test {
             handles: [first_handle, second_handle, third_handle],
         };
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = GroupedCiphertext3HandlesValidityProof::new(
             first_pubkey,
@@ -511,8 +511,8 @@ mod test {
             handles: [first_handle, second_handle, third_handle],
         };
 
-        let mut prover_transcript = Transcript::new(b"Test");
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         let proof = GroupedCiphertext3HandlesValidityProof::new(
             first_pubkey,
@@ -542,29 +542,29 @@ mod test {
 
     #[test]
     fn test_grouped_ciphertext_3_handles_validity_proof_string() {
-        let first_pubkey_str = "ZFS3qCHSduL3Ec05YRo2YWPxRxybflL0Gt1isV8RZX4=";
+        let first_pubkey_str = "EAbHeljb89aEvbxaq2i3T8e7kEh1iZa55G67S4aPN2U=";
         let pod_first_pubkey = PodElGamalPubkey::from_str(first_pubkey_str).unwrap();
         let first_pubkey: ElGamalPubkey = pod_first_pubkey.try_into().unwrap();
 
-        let second_pubkey_str = "qMK9fLd04eXzFZxpSsFqNkOzv8+9EPsVgWZ7AiJRol0=";
+        let second_pubkey_str = "lH291F1FwDQEFq3kyCEQ7ANACAoS+tthsCLBRMMKvCo=";
         let pod_second_pubkey = PodElGamalPubkey::from_str(second_pubkey_str).unwrap();
         let second_pubkey: ElGamalPubkey = pod_second_pubkey.try_into().unwrap();
 
-        let third_pubkey_str = "7O10JYXXxLdxns7KQQl375Cmka27/kcT2Fvg/wUFpFA=";
+        let third_pubkey_str = "EuaVaP3a6YvTokc8dq6kKTnn9cz8A92nMISmDzWElGo=";
         let pod_third_pubkey = PodElGamalPubkey::from_str(third_pubkey_str).unwrap();
         let third_pubkey: ElGamalPubkey = pod_third_pubkey.try_into().unwrap();
 
-        let grouped_ciphertext_str = "eBidpsDaf5HlsgHorK/Tevqckk5S3u2GUSl1n4ruqhZ2Cos1br6FttkrDKj3to1XCQ2Gyh8mFclskivxVWrGHa4NZGozBndinSrhPWSSMyVydeX2veMn6yUhGLtZkcFgeEq+j4FKrgeBIvXksHZsf8A+gEo+C/HspWSB5viDPBs=";
+        let grouped_ciphertext_str = "BpvM2hRQg9xKqEC68Zjc7jtVKyfZ5hiF+BgF0+Pnz1CI+/lX8i7xgBejr9O+hrrKWAomNC6Zv5M8B+MUokxAClLrs+zhcm5TdpLbvtUsM/PTKVNKh30PRGSKr12e65EJ5EgyNO2FjjLL4o2jSJepbrOohkUVWojqTGQ4nZAhtVI=";
         let pod_grouped_ciphertext =
             PodGroupedElGamalCiphertext3Handles::from_str(grouped_ciphertext_str).unwrap();
         let grouped_ciphertext: GroupedElGamalCiphertext<3> =
             pod_grouped_ciphertext.try_into().unwrap();
 
-        let proof_str = "BiHICmQCsllZqb/4prAlQbxJy0nC7/7zvfp295vw3HGyyytGcXgQMOtWJrLsJBrMe4Qs0YCwI7R3igIV52bPH0aHtWSY5LdDnNNZRdKJIxmtMRGfOuD6fF/c8XejIt5JlgSozH+paMJb7/AE6ZtcpOSvSVsItudbOw0B8rc7ZX/HtkrCx1gm5uLK45JaDr/osnij3fjXGUw9lfC1odBfDu/9Co/FHlZz+7NU4gQ4Uf0iMtPutw31b6mSVNrvE6gN";
+        let proof_str = "yAJhtqJPhXdUN24lYeD7J+n7/6F+aV+H0rBSseHvD1dEr2FWy9bl20Qf5E3CHA8IlvOzQQpMJiZ8B9sxhqGdDgwVNbhPhMaKksRqMyKrHq2Vpi3Uz8LB6/uCQNcYyLBMlCjgVpscvudqpLuIpk3PRVhC5igNBV9GSL6iXKAuhkWc2ubCdlZKXJM1xFAnTbn5RSoRmSonESBr4NBwjHyaCHMwX7W8+jjxBc3hDSJOqKNkZgym0gmWv64cc32wKVEA";
         let pod_proof = PodGroupedCiphertext3HandlesValidityProof::from_str(proof_str).unwrap();
         let proof: GroupedCiphertext3HandlesValidityProof = pod_proof.try_into().unwrap();
 
-        let mut verifier_transcript = Transcript::new(b"Test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"Test");
 
         proof
             .verify(
diff --git a/zk-sdk/src/sigma_proofs/percentage_with_cap.rs b/zk-sdk/src/sigma_proofs/percentage_with_cap.rs
index 46454502..01e30f2d 100644
--- a/zk-sdk/src/sigma_proofs/percentage_with_cap.rs
+++ b/zk-sdk/src/sigma_proofs/percentage_with_cap.rs
@@ -680,8 +680,8 @@ mod test {
 
         let (claimed_commitment, _claimed_opening) = Pedersen::new(0_u64);
 
-        let mut prover_transcript = Transcript::new(b"test");
-        let mut verifier_transcript = Transcript::new(b"test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"test");
 
         prover_transcript
             .append_message(b"percentage-commitment", &percentage_commitment.to_bytes());
@@ -727,8 +727,8 @@ mod test {
 
         let (claimed_commitment, claimed_opening) = Pedersen::new(delta_amount);
 
-        let mut prover_transcript = Transcript::new(b"test");
-        let mut verifier_transcript = Transcript::new(b"test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"test");
 
         prover_transcript
             .append_message(b"percentage-commitment", &percentage_commitment.to_bytes());
@@ -781,8 +781,8 @@ mod test {
 
         let (claimed_commitment, claimed_opening) = Pedersen::new(0_u64);
 
-        let mut prover_transcript = Transcript::new(b"test");
-        let mut verifier_transcript = Transcript::new(b"test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"test");
 
         let proof = PercentageWithCapProof::new(
             &percentage_commitment,
@@ -838,8 +838,8 @@ mod test {
             claimed_commitment.get_point() - claimed_opening.get_scalar() * &(*H)
         );
 
-        let mut prover_transcript = Transcript::new(b"test");
-        let mut verifier_transcript = Transcript::new(b"test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"test");
 
         let proof = PercentageWithCapProof::new(
             &percentage_commitment,
@@ -885,8 +885,8 @@ mod test {
 
         let (claimed_commitment, claimed_opening) = Pedersen::new(delta);
 
-        let mut prover_transcript = Transcript::new(b"test");
-        let mut verifier_transcript = Transcript::new(b"test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"test");
 
         let proof = PercentageWithCapProof::new(
             &percentage_commitment,
@@ -916,26 +916,26 @@ mod test {
     fn test_percentage_with_cap_proof_string() {
         let max_value: u64 = 3;
 
-        let percentage_commitment_str = "0E3JSrvPEjVf2QST6m8tJ9huEwRSbb8D/phD4UG8cnU=";
+        let percentage_commitment_str = "OBDhFPvEfM1g2lR5dF0eH2pFGJC+MSW+B71WrUz8bkk=";
         let pod_percentage_commitment =
             PodPedersenCommitment::from_str(percentage_commitment_str).unwrap();
         let percentage_commitment: PedersenCommitment =
             pod_percentage_commitment.try_into().unwrap();
 
-        let delta_commitment_str = "nHYaTODvZ1gSz6l6X1/Sr8zdgMx4jsVaG2D/bN6HvA4=";
+        let delta_commitment_str = "DGcxgwh381H/WiDlptyk3o2Q+eyDIEmIVY6JsdUI3GA=";
         let pod_delta_commitment = PodPedersenCommitment::from_str(delta_commitment_str).unwrap();
         let delta_commitment: PedersenCommitment = pod_delta_commitment.try_into().unwrap();
 
-        let claimed_commitment_str = "JpWpWZXGgQ6KU2n0HXYkc4bQIirq82OKAPQx+lN5B0Q=";
+        let claimed_commitment_str = "PCUoVQfHE0ZV/ZrV5ECyqTzcZpSa3Hs9rkgoCTPsoxI=";
         let pod_claimed_commitment =
             PodPedersenCommitment::from_str(claimed_commitment_str).unwrap();
         let claimed_commitment: PedersenCommitment = pod_claimed_commitment.try_into().unwrap();
 
-        let proof_str = "FFlTOVj/0m96Bh27AVGay+EQiKLkPJTwLpVCYV7JCAGUMa8+gvW9Q5tiSbOldI7pNKLEDXINDGGsNhqm02NDDpuyV+ub5G0A8tMcSTHc3IdmI6sSMO/ThgdXtuFP0LcHpmQzXFM/jLRTR2Ey0s30fJ5u+uWLG8ntyQDHQ9PHc0qOULenzw2ibTSi9BpAw+mieyp+lTQ+JEK9wgDbZyI+EgC7x8s6Ff1vnR4GTS8FoQeGieAb8k/Zp1xttxhRk/sEshiG106FkFOQOjWr+fjYDyMyL1H+TAFxp8dGcuovCArmIP84n67PENWSeN81M90llIuV2OsdCK2eCvSYPJVcDA==";
+        let proof_str = "NPcjkaOzpPNz7uNZXMry5MsiVyqbSnThXioe+Ulw606XDZl2dpKcQ+wYhQqC+XH4aXCgbNB2mClYNZcR0pt7CFh64cJdNGkNuzVAjQBfeq0G+UM7ciF31UcT+1gvjcsIXA2RX9dpiXZWNqCBYbV4nwAV94RFi+ro4HNDBLnmQ3+C2xtal1Qob2tqurvUTYnUdaQDEpDdVhGhvOh8Y/jvTr4h2aQeDSBCi03qN9L4y8jAUXR4UcqwPWBJo7hp2gsF+qmg3iawG/d9taaOssRny6OVWwhuBU1P7pMKZeh1xAo/HCbAYY+CEz9SyMnUPPuZq+38npHiy6icqQoItwfRDg==";
         let pod_proof = PodPercentageWithCapProof::from_str(proof_str).unwrap();
         let proof: PercentageWithCapProof = pod_proof.try_into().unwrap();
 
-        let mut verifier_transcript = Transcript::new(b"test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"test");
 
         proof
             .verify(
diff --git a/zk-sdk/src/sigma_proofs/pubkey_validity.rs b/zk-sdk/src/sigma_proofs/pubkey_validity.rs
index 9c543450..0316d76b 100644
--- a/zk-sdk/src/sigma_proofs/pubkey_validity.rs
+++ b/zk-sdk/src/sigma_proofs/pubkey_validity.rs
@@ -164,8 +164,8 @@ mod test {
         // random ElGamal keypair
         let keypair = ElGamalKeypair::new_rand();
 
-        let mut prover_transcript = Transcript::new(b"test");
-        let mut verifier_transcript = Transcript::new(b"test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"test");
 
         let proof = PubkeyValidityProof::new(&keypair, &mut prover_transcript);
         proof
@@ -176,8 +176,8 @@ mod test {
         let keypair =
             ElGamalKeypair::new_from_signer(&Keypair::new(), Pubkey::default().as_ref()).unwrap();
 
-        let mut prover_transcript = Transcript::new(b"test");
-        let mut verifier_transcript = Transcript::new(b"test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"test");
 
         let proof = PubkeyValidityProof::new(&keypair, &mut prover_transcript);
         proof
@@ -192,15 +192,15 @@ mod test {
 
     #[test]
     fn test_pubkey_proof_str() {
-        let pubkey_str = "1KM0Ld9q6NU69bINtfUCujhlNbzrhLumxLMfRVKMvFg=";
+        let pubkey_str = "lhKgvZ+xRsKTR7wfKNlpltvPZk0Pc5MfpyVlqRmDcAk=";
         let pod_pubkey = PodElGamalPubkey::from_str(pubkey_str).unwrap();
         let pubkey: ElGamalPubkey = pod_pubkey.try_into().unwrap();
 
-        let proof_str = "QKtYgQdnHJF/qwlynbdkS1veGp+hK3VTUh0bNJaHPTLslNRBX5eDo7z2N+wS9+yJwHHiOh47QmbgYwOJ/hZYDA==";
+        let proof_str = "utgoLBANuVRtvN7YyZrUwz0dZL+ObsDlRpJdb6erXiQZWCtkvRbSJ8mSBKPvkahHunah80JooQWqhFQXkOCWBw==";
         let pod_proof = PodPubkeyValidityProof::from_str(proof_str).unwrap();
         let proof: PubkeyValidityProof = pod_proof.try_into().unwrap();
 
-        let mut verifier_transcript = Transcript::new(b"test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"test");
 
         proof.verify(&pubkey, &mut verifier_transcript).unwrap();
     }
@@ -216,7 +216,7 @@ mod test {
             z: Scalar::ZERO,
         };
 
-        let mut verifier_transcript = Transcript::new(b"test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"test");
         let err = proof
             .verify(&identity_pubkey, &mut verifier_transcript)
             .unwrap_err();
diff --git a/zk-sdk/src/sigma_proofs/zero_ciphertext.rs b/zk-sdk/src/sigma_proofs/zero_ciphertext.rs
index 55c5ac06..c79e4575 100644
--- a/zk-sdk/src/sigma_proofs/zero_ciphertext.rs
+++ b/zk-sdk/src/sigma_proofs/zero_ciphertext.rs
@@ -203,8 +203,8 @@ mod test {
     fn test_zero_ciphertext_proof_correctness() {
         let keypair = ElGamalKeypair::new_rand();
 
-        let mut prover_transcript = Transcript::new(b"test");
-        let mut verifier_transcript = Transcript::new(b"test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"test");
 
         // general case: encryption of 0
         let elgamal_ciphertext = keypair.pubkey().encrypt(0_u64);
@@ -238,8 +238,8 @@ mod test {
     fn test_zero_ciphertext_proof_edge_cases() {
         let keypair = ElGamalKeypair::new_rand();
 
-        let mut prover_transcript = Transcript::new(b"test");
-        let mut verifier_transcript = Transcript::new(b"test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"test");
 
         // all zero ciphertext should always be a valid encryption of 0
         let ciphertext = ElGamalCiphertext::from_bytes(&[0u8; 64]).unwrap();
@@ -252,8 +252,8 @@ mod test {
 
         // if only either commitment or handle is zero, the ciphertext is always invalid and proof
         // verification should always reject
-        let mut prover_transcript = Transcript::new(b"test");
-        let mut verifier_transcript = Transcript::new(b"test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"test");
 
         let zeroed_commitment = PedersenCommitment::from_bytes(&[0u8; 32]).unwrap();
         let handle = keypair
@@ -271,8 +271,8 @@ mod test {
             .verify(keypair.pubkey(), &ciphertext, &mut verifier_transcript)
             .is_err());
 
-        let mut prover_transcript = Transcript::new(b"test");
-        let mut verifier_transcript = Transcript::new(b"test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"test");
 
         let (zeroed_commitment, _) = Pedersen::new(0_u64);
         let ciphertext = ElGamalCiphertext {
@@ -287,8 +287,8 @@ mod test {
             .is_err());
 
         // if public key is always zero, then the proof should always reject
-        let mut prover_transcript = Transcript::new(b"test");
-        let mut verifier_transcript = Transcript::new(b"test");
+        let mut prover_transcript = Transcript::new_zk_elgamal_transcript(b"test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"test");
 
         let public = ElGamalPubkey::try_from([0u8; 32].as_slice()).unwrap();
         let ciphertext = public.encrypt(0_u64);
@@ -302,19 +302,19 @@ mod test {
 
     #[test]
     fn test_zero_ciphertext_proof_string() {
-        let pubkey_str = "ghXlevXjXYxZ5EfCUA/GkuXutYszDIhR4HQQQtQZrUM=";
+        let pubkey_str = "iKeujRa2kL82Az2fl7MXHYVMc0XJFoGZckD7LvPtSU8=";
         let pod_pubkey = PodElGamalPubkey::from_str(pubkey_str).unwrap();
         let pubkey: ElGamalPubkey = pod_pubkey.try_into().unwrap();
 
-        let ciphertext_str = "BuN6mUznNwepi3DLPpmwAUl2JsnUO7KG6vsqfHjvxnOcB+lk/z6uod6VJdwjfb59g0+1ZdGErttsUHn0nU1qPQ==";
+        let ciphertext_str = "crvDqbMD4OVe4mkuzqUJrhyblxTAu3vaUqMvfYuAHybADkpXli9m1zXHrvdpO1PfDQ6U/RHxLgr3XUvDg2sLBA==";
         let pod_ciphertext = PodElGamalCiphertext::from_str(ciphertext_str).unwrap();
         let ciphertext: ElGamalCiphertext = pod_ciphertext.try_into().unwrap();
 
-        let proof_str = "WgkuFTQDH9aQkdk76xAK9YpfxZmqWS56jBN/ic73yhv6YMS3+bz8HrO4G7DangnI8D0sFL2LPBC5ocwycbQvLAUZ671RZsTXGLzCyytpbdLFTL8d+Y2xkibnJ9AA6MkM";
+        let proof_str = "fMibXtwhpBMr5FWg9CrBqlCrLq/cC2RmiwMpToMHxSyCI5AT+Ns4orbzcbqTiOJzF+tCgaJj+XCLXHk/YQLcQ4G+g3bppv3RDOLmGnVuyepMsSCVI4CGykTBqXb+ReQJ";
         let pod_proof = PodZeroCiphertextProof::from_str(proof_str).unwrap();
         let proof: ZeroCiphertextProof = pod_proof.try_into().unwrap();
 
-        let mut verifier_transcript = Transcript::new(b"test");
+        let mut verifier_transcript = Transcript::new_zk_elgamal_transcript(b"test");
 
         proof
             .verify(&pubkey, &ciphertext, &mut verifier_transcript)
diff --git a/zk-sdk/src/transcript.rs b/zk-sdk/src/transcript.rs
index 7355d3da..de456dbb 100644
--- a/zk-sdk/src/transcript.rs
+++ b/zk-sdk/src/transcript.rs
@@ -1,10 +1,13 @@
 use {
-    crate::errors::TranscriptError,
+    crate::{errors::TranscriptError, TRANSCRIPT_DOMAIN},
     curve25519_dalek::{ristretto::CompressedRistretto, scalar::Scalar, traits::IsIdentity},
     merlin::Transcript,
 };
 
 pub trait TranscriptProtocol {
+    /// Create a new transcript with the global domain separator and a specific label.
+    fn new_zk_elgamal_transcript(label: &'static [u8]) -> Transcript;
+
     /// Append a `scalar` with the given `label`.
     fn append_scalar(&mut self, label: &'static [u8], scalar: &Scalar);
 
@@ -51,6 +54,12 @@ pub trait TranscriptProtocol {
 }
 
 impl TranscriptProtocol for Transcript {
+    fn new_zk_elgamal_transcript(label: &'static [u8]) -> Transcript {
+        let mut transcript = Transcript::new(TRANSCRIPT_DOMAIN);
+        transcript.append_message(b"dom-sep", label);
+        transcript
+    }
+
     fn append_scalar(&mut self, label: &'static [u8], scalar: &Scalar) {
         self.append_message(label, scalar.as_bytes());
     }
diff --git a/zk-sdk/src/zk_elgamal_proof_program/proof_data/batched_grouped_ciphertext_validity/handles_2.rs b/zk-sdk/src/zk_elgamal_proof_program/proof_data/batched_grouped_ciphertext_validity/handles_2.rs
index da10526a..9e2f5cf4 100644
--- a/zk-sdk/src/zk_elgamal_proof_program/proof_data/batched_grouped_ciphertext_validity/handles_2.rs
+++ b/zk-sdk/src/zk_elgamal_proof_program/proof_data/batched_grouped_ciphertext_validity/handles_2.rs
@@ -23,6 +23,7 @@ use {
             pedersen::PedersenOpening,
         },
         sigma_proofs::batched_grouped_ciphertext_validity::BatchedGroupedCiphertext2HandlesValidityProof,
+        transcript::TranscriptProtocol,
         zk_elgamal_proof_program::errors::{ProofGenerationError, ProofVerificationError},
     },
     merlin::Transcript,
@@ -78,8 +79,9 @@ impl BatchedGroupedCiphertext2HandlesValidityProofData {
             grouped_ciphertext_hi: pod_grouped_ciphertext_hi,
         };
 
-        let mut transcript =
-            Transcript::new(b"batched-grouped-ciphertext-validity-2-handles-instruction");
+        let mut transcript = Transcript::new_zk_elgamal_transcript(
+            b"batched-grouped-ciphertext-validity-2-handles-instruction",
+        );
 
         let proof = BatchedGroupedCiphertext2HandlesValidityProof::new(
             first_pubkey,
@@ -109,8 +111,9 @@ impl ZkProofData<BatchedGroupedCiphertext2HandlesValidityProofContext>
 
     #[cfg(not(target_os = "solana"))]
     fn verify_proof(&self) -> Result<(), ProofVerificationError> {
-        let mut transcript =
-            Transcript::new(b"batched-grouped-ciphertext-validity-2-handles-instruction");
+        let mut transcript = Transcript::new_zk_elgamal_transcript(
+            b"batched-grouped-ciphertext-validity-2-handles-instruction",
+        );
 
         let first_pubkey = self.context.first_pubkey.try_into()?;
         let second_pubkey = self.context.second_pubkey.try_into()?;
diff --git a/zk-sdk/src/zk_elgamal_proof_program/proof_data/batched_grouped_ciphertext_validity/handles_3.rs b/zk-sdk/src/zk_elgamal_proof_program/proof_data/batched_grouped_ciphertext_validity/handles_3.rs
index 455ce4ba..7f72e77e 100644
--- a/zk-sdk/src/zk_elgamal_proof_program/proof_data/batched_grouped_ciphertext_validity/handles_3.rs
+++ b/zk-sdk/src/zk_elgamal_proof_program/proof_data/batched_grouped_ciphertext_validity/handles_3.rs
@@ -23,6 +23,7 @@ use {
             pedersen::PedersenOpening,
         },
         sigma_proofs::batched_grouped_ciphertext_validity::BatchedGroupedCiphertext3HandlesValidityProof,
+        transcript::TranscriptProtocol,
         zk_elgamal_proof_program::errors::{ProofGenerationError, ProofVerificationError},
     },
     merlin::Transcript,
@@ -83,8 +84,9 @@ impl BatchedGroupedCiphertext3HandlesValidityProofData {
             grouped_ciphertext_hi: pod_grouped_ciphertext_hi,
         };
 
-        let mut transcript =
-            Transcript::new(b"batched-grouped-ciphertext-validity-3-handles-instruction");
+        let mut transcript = Transcript::new_zk_elgamal_transcript(
+            b"batched-grouped-ciphertext-validity-3-handles-instruction",
+        );
 
         let proof = BatchedGroupedCiphertext3HandlesValidityProof::new(
             first_pubkey,
@@ -115,8 +117,9 @@ impl ZkProofData<BatchedGroupedCiphertext3HandlesValidityProofContext>
 
     #[cfg(not(target_os = "solana"))]
     fn verify_proof(&self) -> Result<(), ProofVerificationError> {
-        let mut transcript =
-            Transcript::new(b"batched-grouped-ciphertext-validity-3-handles-instruction");
+        let mut transcript = Transcript::new_zk_elgamal_transcript(
+            b"batched-grouped-ciphertext-validity-3-handles-instruction",
+        );
 
         let first_pubkey = self.context.first_pubkey.try_into()?;
         let second_pubkey = self.context.second_pubkey.try_into()?;
diff --git a/zk-sdk/src/zk_elgamal_proof_program/proof_data/batched_range_proof/mod.rs b/zk-sdk/src/zk_elgamal_proof_program/proof_data/batched_range_proof/mod.rs
index a003a214..2273416b 100644
--- a/zk-sdk/src/zk_elgamal_proof_program/proof_data/batched_range_proof/mod.rs
+++ b/zk-sdk/src/zk_elgamal_proof_program/proof_data/batched_range_proof/mod.rs
@@ -26,6 +26,7 @@ use crate::encryption::pod::pedersen::PodPedersenCommitment;
 use {
     crate::{
         encryption::pedersen::{PedersenCommitment, PedersenOpening},
+        transcript::TranscriptProtocol,
         zk_elgamal_proof_program::errors::{ProofGenerationError, ProofVerificationError},
     },
     bytemuck::{bytes_of, Zeroable},
@@ -60,7 +61,8 @@ pub struct BatchedRangeProofContext {
 #[cfg(not(target_os = "solana"))]
 impl BatchedRangeProofContext {
     fn new_transcript(&self) -> Transcript {
-        let mut transcript = Transcript::new(b"batched-range-proof-instruction");
+        let mut transcript =
+            Transcript::new_zk_elgamal_transcript(b"batched-range-proof-instruction");
         transcript.append_message(b"commitments", bytes_of(&self.commitments));
         transcript.append_message(b"bit-lengths", bytes_of(&self.bit_lengths));
         transcript
diff --git a/zk-sdk/src/zk_elgamal_proof_program/proof_data/ciphertext_ciphertext_equality.rs b/zk-sdk/src/zk_elgamal_proof_program/proof_data/ciphertext_ciphertext_equality.rs
index cf2db4b1..b9e5484f 100644
--- a/zk-sdk/src/zk_elgamal_proof_program/proof_data/ciphertext_ciphertext_equality.rs
+++ b/zk-sdk/src/zk_elgamal_proof_program/proof_data/ciphertext_ciphertext_equality.rs
@@ -21,6 +21,7 @@ use {
             pedersen::PedersenOpening,
         },
         sigma_proofs::ciphertext_ciphertext_equality::CiphertextCiphertextEqualityProof,
+        transcript::TranscriptProtocol,
         zk_elgamal_proof_program::errors::{ProofGenerationError, ProofVerificationError},
     },
     merlin::Transcript,
@@ -75,7 +76,8 @@ impl CiphertextCiphertextEqualityProofData {
             second_ciphertext: pod_second_ciphertext,
         };
 
-        let mut transcript = Transcript::new(b"ciphertext-ciphertext-equality-instruction");
+        let mut transcript =
+            Transcript::new_zk_elgamal_transcript(b"ciphertext-ciphertext-equality-instruction");
 
         let proof = CiphertextCiphertextEqualityProof::new(
             first_keypair,
@@ -103,7 +105,8 @@ impl ZkProofData<CiphertextCiphertextEqualityProofContext>
 
     #[cfg(not(target_os = "solana"))]
     fn verify_proof(&self) -> Result<(), ProofVerificationError> {
-        let mut transcript = Transcript::new(b"ciphertext-ciphertext-equality-instruction");
+        let mut transcript =
+            Transcript::new_zk_elgamal_transcript(b"ciphertext-ciphertext-equality-instruction");
 
         let first_pubkey = self.context.first_pubkey.try_into()?;
         let second_pubkey = self.context.second_pubkey.try_into()?;
diff --git a/zk-sdk/src/zk_elgamal_proof_program/proof_data/ciphertext_commitment_equality.rs b/zk-sdk/src/zk_elgamal_proof_program/proof_data/ciphertext_commitment_equality.rs
index 30925c3d..c02fce6a 100644
--- a/zk-sdk/src/zk_elgamal_proof_program/proof_data/ciphertext_commitment_equality.rs
+++ b/zk-sdk/src/zk_elgamal_proof_program/proof_data/ciphertext_commitment_equality.rs
@@ -24,6 +24,7 @@ use {
             pedersen::{PedersenCommitment, PedersenOpening},
         },
         sigma_proofs::ciphertext_commitment_equality::CiphertextCommitmentEqualityProof,
+        transcript::TranscriptProtocol,
         zk_elgamal_proof_program::errors::{ProofGenerationError, ProofVerificationError},
     },
     merlin::Transcript,
@@ -69,7 +70,8 @@ impl CiphertextCommitmentEqualityProofData {
             ciphertext: PodElGamalCiphertext(ciphertext.to_bytes()),
             commitment: PodPedersenCommitment(commitment.to_bytes()),
         };
-        let mut transcript = Transcript::new(b"ciphertext-commitment-equality-instruction");
+        let mut transcript =
+            Transcript::new_zk_elgamal_transcript(b"ciphertext-commitment-equality-instruction");
         let proof = CiphertextCommitmentEqualityProof::new(
             keypair,
             ciphertext,
@@ -96,7 +98,8 @@ impl ZkProofData<CiphertextCommitmentEqualityProofContext>
 
     #[cfg(not(target_os = "solana"))]
     fn verify_proof(&self) -> Result<(), ProofVerificationError> {
-        let mut transcript = Transcript::new(b"ciphertext-commitment-equality-instruction");
+        let mut transcript =
+            Transcript::new_zk_elgamal_transcript(b"ciphertext-commitment-equality-instruction");
 
         let pubkey = self.context.pubkey.try_into()?;
         let ciphertext = self.context.ciphertext.try_into()?;
diff --git a/zk-sdk/src/zk_elgamal_proof_program/proof_data/grouped_ciphertext_validity/handles_2.rs b/zk-sdk/src/zk_elgamal_proof_program/proof_data/grouped_ciphertext_validity/handles_2.rs
index c4fb40df..bfbc3b8f 100644
--- a/zk-sdk/src/zk_elgamal_proof_program/proof_data/grouped_ciphertext_validity/handles_2.rs
+++ b/zk-sdk/src/zk_elgamal_proof_program/proof_data/grouped_ciphertext_validity/handles_2.rs
@@ -23,6 +23,7 @@ use {
             pedersen::PedersenOpening,
         },
         sigma_proofs::grouped_ciphertext_validity::GroupedCiphertext2HandlesValidityProof,
+        transcript::TranscriptProtocol,
         zk_elgamal_proof_program::errors::{ProofGenerationError, ProofVerificationError},
     },
     merlin::Transcript,
@@ -70,7 +71,9 @@ impl GroupedCiphertext2HandlesValidityProofData {
             grouped_ciphertext: pod_grouped_ciphertext,
         };
 
-        let mut transcript = Transcript::new(b"grouped-ciphertext-validity-2-handles-instruction");
+        let mut transcript = Transcript::new_zk_elgamal_transcript(
+            b"grouped-ciphertext-validity-2-handles-instruction",
+        );
 
         let proof = GroupedCiphertext2HandlesValidityProof::new(
             first_pubkey,
@@ -97,7 +100,9 @@ impl ZkProofData<GroupedCiphertext2HandlesValidityProofContext>
 
     #[cfg(not(target_os = "solana"))]
     fn verify_proof(&self) -> Result<(), ProofVerificationError> {
-        let mut transcript = Transcript::new(b"grouped-ciphertext-validity-2-handles-instruction");
+        let mut transcript = Transcript::new_zk_elgamal_transcript(
+            b"grouped-ciphertext-validity-2-handles-instruction",
+        );
 
         let first_pubkey = self.context.first_pubkey.try_into()?;
         let second_pubkey = self.context.second_pubkey.try_into()?;
diff --git a/zk-sdk/src/zk_elgamal_proof_program/proof_data/grouped_ciphertext_validity/handles_3.rs b/zk-sdk/src/zk_elgamal_proof_program/proof_data/grouped_ciphertext_validity/handles_3.rs
index bf2c9bb8..17ffaba1 100644
--- a/zk-sdk/src/zk_elgamal_proof_program/proof_data/grouped_ciphertext_validity/handles_3.rs
+++ b/zk-sdk/src/zk_elgamal_proof_program/proof_data/grouped_ciphertext_validity/handles_3.rs
@@ -23,6 +23,7 @@ use {
             pedersen::PedersenOpening,
         },
         sigma_proofs::grouped_ciphertext_validity::GroupedCiphertext3HandlesValidityProof,
+        transcript::TranscriptProtocol,
         zk_elgamal_proof_program::errors::{ProofGenerationError, ProofVerificationError},
     },
     merlin::Transcript,
@@ -75,7 +76,9 @@ impl GroupedCiphertext3HandlesValidityProofData {
             grouped_ciphertext: pod_grouped_ciphertext,
         };
 
-        let mut transcript = Transcript::new(b"grouped-ciphertext-validity-3-handles-instruction");
+        let mut transcript = Transcript::new_zk_elgamal_transcript(
+            b"grouped-ciphertext-validity-3-handles-instruction",
+        );
 
         let proof = GroupedCiphertext3HandlesValidityProof::new(
             first_pubkey,
@@ -103,7 +106,9 @@ impl ZkProofData<GroupedCiphertext3HandlesValidityProofContext>
 
     #[cfg(not(target_os = "solana"))]
     fn verify_proof(&self) -> Result<(), ProofVerificationError> {
-        let mut transcript = Transcript::new(b"grouped-ciphertext-validity-3-handles-instruction");
+        let mut transcript = Transcript::new_zk_elgamal_transcript(
+            b"grouped-ciphertext-validity-3-handles-instruction",
+        );
 
         let first_pubkey = self.context.first_pubkey.try_into()?;
         let second_pubkey = self.context.second_pubkey.try_into()?;
diff --git a/zk-sdk/src/zk_elgamal_proof_program/proof_data/percentage_with_cap.rs b/zk-sdk/src/zk_elgamal_proof_program/proof_data/percentage_with_cap.rs
index 8a5053ee..fb3760ce 100644
--- a/zk-sdk/src/zk_elgamal_proof_program/proof_data/percentage_with_cap.rs
+++ b/zk-sdk/src/zk_elgamal_proof_program/proof_data/percentage_with_cap.rs
@@ -11,6 +11,7 @@ use {
     crate::{
         encryption::pedersen::{PedersenCommitment, PedersenOpening},
         sigma_proofs::percentage_with_cap::PercentageWithCapProof,
+        transcript::TranscriptProtocol,
         zk_elgamal_proof_program::errors::{ProofGenerationError, ProofVerificationError},
     },
     merlin::Transcript,
@@ -87,7 +88,8 @@ impl PercentageWithCapProofData {
             max_value: pod_max_value,
         };
 
-        let mut transcript = Transcript::new(b"percentage-with-cap-instruction");
+        let mut transcript =
+            Transcript::new_zk_elgamal_transcript(b"percentage-with-cap-instruction");
 
         let proof = PercentageWithCapProof::new(
             percentage_commitment,
@@ -116,7 +118,8 @@ impl ZkProofData<PercentageWithCapProofContext> for PercentageWithCapProofData {
 
     #[cfg(not(target_os = "solana"))]
     fn verify_proof(&self) -> Result<(), ProofVerificationError> {
-        let mut transcript = Transcript::new(b"percentage-with-cap-instruction");
+        let mut transcript =
+            Transcript::new_zk_elgamal_transcript(b"percentage-with-cap-instruction");
 
         let percentage_commitment = self.context.percentage_commitment.try_into()?;
         let delta_commitment = self.context.delta_commitment.try_into()?;
diff --git a/zk-sdk/src/zk_elgamal_proof_program/proof_data/pubkey_validity.rs b/zk-sdk/src/zk_elgamal_proof_program/proof_data/pubkey_validity.rs
index d09a75de..ac2b8e31 100644
--- a/zk-sdk/src/zk_elgamal_proof_program/proof_data/pubkey_validity.rs
+++ b/zk-sdk/src/zk_elgamal_proof_program/proof_data/pubkey_validity.rs
@@ -10,6 +10,7 @@ use {
     crate::{
         encryption::elgamal::ElGamalKeypair,
         sigma_proofs::pubkey_validity::PubkeyValidityProof,
+        transcript::TranscriptProtocol,
         zk_elgamal_proof_program::errors::{ProofGenerationError, ProofVerificationError},
     },
     merlin::Transcript,
@@ -54,7 +55,7 @@ impl PubkeyValidityProofData {
 
         let context = PubkeyValidityProofContext { pubkey: pod_pubkey };
 
-        let mut transcript = Transcript::new(b"pubkey-validity-instruction");
+        let mut transcript = Transcript::new_zk_elgamal_transcript(b"pubkey-validity-instruction");
         let proof = PubkeyValidityProof::new(keypair, &mut transcript).into();
 
         Ok(PubkeyValidityProofData { context, proof })
@@ -70,7 +71,7 @@ impl ZkProofData<PubkeyValidityProofContext> for PubkeyValidityProofData {
 
     #[cfg(not(target_os = "solana"))]
     fn verify_proof(&self) -> Result<(), ProofVerificationError> {
-        let mut transcript = Transcript::new(b"pubkey-validity-instruction");
+        let mut transcript = Transcript::new_zk_elgamal_transcript(b"pubkey-validity-instruction");
         let pubkey = self.context.pubkey.try_into()?;
         let proof: PubkeyValidityProof = self.proof.try_into()?;
         proof.verify(&pubkey, &mut transcript).map_err(|e| e.into())
diff --git a/zk-sdk/src/zk_elgamal_proof_program/proof_data/zero_ciphertext.rs b/zk-sdk/src/zk_elgamal_proof_program/proof_data/zero_ciphertext.rs
index d7063ce6..253623c0 100644
--- a/zk-sdk/src/zk_elgamal_proof_program/proof_data/zero_ciphertext.rs
+++ b/zk-sdk/src/zk_elgamal_proof_program/proof_data/zero_ciphertext.rs
@@ -9,6 +9,7 @@ use {
     crate::{
         encryption::elgamal::{ElGamalCiphertext, ElGamalKeypair},
         sigma_proofs::zero_ciphertext::ZeroCiphertextProof,
+        transcript::TranscriptProtocol,
         zk_elgamal_proof_program::errors::{ProofGenerationError, ProofVerificationError},
     },
     merlin::Transcript,
@@ -62,7 +63,7 @@ impl ZeroCiphertextProofData {
             ciphertext: pod_ciphertext,
         };
 
-        let mut transcript = Transcript::new(b"zero-ciphertext-instruction");
+        let mut transcript = Transcript::new_zk_elgamal_transcript(b"zero-ciphertext-instruction");
         let proof = ZeroCiphertextProof::new(keypair, ciphertext, &mut transcript).into();
 
         Ok(ZeroCiphertextProofData { context, proof })
@@ -78,7 +79,7 @@ impl ZkProofData<ZeroCiphertextProofContext> for ZeroCiphertextProofData {
 
     #[cfg(not(target_os = "solana"))]
     fn verify_proof(&self) -> Result<(), ProofVerificationError> {
-        let mut transcript = Transcript::new(b"zero-ciphertext-instruction");
+        let mut transcript = Transcript::new_zk_elgamal_transcript(b"zero-ciphertext-instruction");
         let pubkey = self.context.pubkey.try_into()?;
         let ciphertext = self.context.ciphertext.try_into()?;
         let proof: ZeroCiphertextProof = self.proof.try_into()?;