2021-10-05 09:05:02 -07:00
|
|
|
pub use bytemuck::{Pod, Zeroable};
|
2023-03-15 15:35:20 -07:00
|
|
|
use {
|
|
|
|
crate::zk_token_proof_instruction::ProofType,
|
2023-05-11 11:34:58 -07:00
|
|
|
base64::{prelude::BASE64_STANDARD, Engine},
|
2023-03-15 15:35:20 -07:00
|
|
|
num_traits::{FromPrimitive, ToPrimitive},
|
|
|
|
solana_program::instruction::InstructionError,
|
|
|
|
std::fmt,
|
|
|
|
};
|
2021-09-30 10:25:36 -07:00
|
|
|
|
2022-05-22 18:00:42 -07:00
|
|
|
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Pod, Zeroable)]
|
2022-02-08 09:09:50 -08:00
|
|
|
#[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)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-22 18:00:42 -07:00
|
|
|
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Pod, Zeroable)]
|
2022-02-08 09:09:50 -08:00
|
|
|
#[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)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-03-15 15:35:20 -07:00
|
|
|
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Pod, Zeroable)]
|
|
|
|
#[repr(transparent)]
|
|
|
|
pub struct PodProofType(u8);
|
|
|
|
impl From<ProofType> for PodProofType {
|
|
|
|
fn from(proof_type: ProofType) -> Self {
|
|
|
|
Self(ToPrimitive::to_u8(&proof_type).unwrap())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl TryFrom<PodProofType> for ProofType {
|
|
|
|
type Error = InstructionError;
|
|
|
|
|
|
|
|
fn try_from(pod: PodProofType) -> Result<Self, Self::Error> {
|
|
|
|
FromPrimitive::from_u8(pod.0).ok_or(Self::Error::InvalidAccountData)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-22 18:00:42 -07:00
|
|
|
#[derive(Clone, Copy, Pod, Zeroable, PartialEq, Eq)]
|
2021-09-30 10:25:36 -07:00
|
|
|
#[repr(transparent)]
|
|
|
|
pub struct CompressedRistretto(pub [u8; 32]);
|
|
|
|
|
2022-05-22 18:00:42 -07:00
|
|
|
#[derive(Clone, Copy, Pod, Zeroable, PartialEq, Eq)]
|
2021-09-30 10:25:36 -07:00
|
|
|
#[repr(transparent)]
|
2021-09-30 11:11:53 -07:00
|
|
|
pub struct ElGamalCiphertext(pub [u8; 64]);
|
2021-09-30 10:25:36 -07:00
|
|
|
|
2021-10-05 09:05:02 -07:00
|
|
|
impl fmt::Debug for ElGamalCiphertext {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
|
|
write!(f, "{:?}", self.0)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-25 20:09:41 -07:00
|
|
|
impl fmt::Display for ElGamalCiphertext {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
2023-05-11 11:34:58 -07:00
|
|
|
write!(f, "{}", BASE64_STANDARD.encode(self.0))
|
2022-07-25 20:09:41 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-21 11:52:36 -08:00
|
|
|
impl Default for ElGamalCiphertext {
|
|
|
|
fn default() -> Self {
|
|
|
|
Self::zeroed()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-22 18:00:42 -07:00
|
|
|
#[derive(Clone, Copy, Default, Pod, Zeroable, PartialEq, Eq)]
|
2021-09-30 10:25:36 -07:00
|
|
|
#[repr(transparent)]
|
2021-09-30 11:11:53 -07:00
|
|
|
pub struct ElGamalPubkey(pub [u8; 32]);
|
2021-09-30 10:25:36 -07:00
|
|
|
|
2021-10-05 09:05:02 -07:00
|
|
|
impl fmt::Debug for ElGamalPubkey {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
|
|
write!(f, "{:?}", self.0)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-25 20:09:41 -07:00
|
|
|
impl fmt::Display for ElGamalPubkey {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
2023-05-11 11:34:58 -07:00
|
|
|
write!(f, "{}", BASE64_STANDARD.encode(self.0))
|
2022-07-25 20:09:41 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-22 18:00:42 -07:00
|
|
|
#[derive(Clone, Copy, Default, Pod, Zeroable, PartialEq, Eq)]
|
2021-09-30 10:25:36 -07:00
|
|
|
#[repr(transparent)]
|
2021-10-05 06:02:52 -07:00
|
|
|
pub struct PedersenCommitment(pub [u8; 32]);
|
2021-09-30 10:25:36 -07:00
|
|
|
|
2021-10-05 09:05:02 -07:00
|
|
|
impl fmt::Debug for PedersenCommitment {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
|
|
write!(f, "{:?}", self.0)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-22 18:00:42 -07:00
|
|
|
#[derive(Clone, Copy, Default, Pod, Zeroable, PartialEq, Eq)]
|
2021-09-30 10:25:36 -07:00
|
|
|
#[repr(transparent)]
|
2022-01-21 17:56:27 -08:00
|
|
|
pub struct DecryptHandle(pub [u8; 32]);
|
2021-09-30 10:25:36 -07:00
|
|
|
|
2022-01-21 17:56:27 -08:00
|
|
|
impl fmt::Debug for DecryptHandle {
|
2021-10-05 09:05:02 -07:00
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
|
|
write!(f, "{:?}", self.0)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-02-17 09:45:07 -08:00
|
|
|
/// Serialization of `CtxtCommEqualityProof`
|
2021-12-07 07:34:47 -08:00
|
|
|
#[derive(Clone, Copy)]
|
|
|
|
#[repr(transparent)]
|
2022-02-17 09:45:07 -08:00
|
|
|
pub struct CtxtCommEqualityProof(pub [u8; 192]);
|
2021-12-07 07:34:47 -08:00
|
|
|
|
2022-02-17 09:45:07 -08:00
|
|
|
// `CtxtCommEqualityProof` is a Pod and Zeroable.
|
2021-12-07 07:34:47 -08:00
|
|
|
// Add the marker traits manually because `bytemuck` only adds them for some `u8` arrays
|
2022-02-17 09:45:07 -08:00
|
|
|
unsafe impl Zeroable for CtxtCommEqualityProof {}
|
|
|
|
unsafe impl Pod for CtxtCommEqualityProof {}
|
|
|
|
|
|
|
|
/// Serialization of `CtxtCtxtEqualityProof`
|
|
|
|
#[derive(Clone, Copy)]
|
|
|
|
#[repr(transparent)]
|
|
|
|
pub struct CtxtCtxtEqualityProof(pub [u8; 224]);
|
|
|
|
|
|
|
|
// `CtxtCtxtEqualityProof` is a Pod and Zeroable.
|
|
|
|
// Add the marker traits manually because `bytemuck` only adds them for some `u8` arrays
|
|
|
|
unsafe impl Zeroable for CtxtCtxtEqualityProof {}
|
|
|
|
unsafe impl Pod for CtxtCtxtEqualityProof {}
|
2021-12-07 07:34:47 -08:00
|
|
|
|
2021-12-12 07:23:10 -08:00
|
|
|
/// Serialization of validity proofs
|
|
|
|
#[derive(Clone, Copy)]
|
|
|
|
#[repr(transparent)]
|
|
|
|
pub struct ValidityProof(pub [u8; 160]);
|
|
|
|
|
|
|
|
// `ValidityProof` is a Pod and Zeroable.
|
|
|
|
// Add the marker traits manually because `bytemuck` only adds them for some `u8` arrays
|
|
|
|
unsafe impl Zeroable for ValidityProof {}
|
|
|
|
unsafe impl Pod for ValidityProof {}
|
|
|
|
|
2022-01-27 16:53:15 -08:00
|
|
|
/// Serialization of aggregated validity proofs
|
|
|
|
#[derive(Clone, Copy)]
|
|
|
|
#[repr(transparent)]
|
|
|
|
pub struct AggregatedValidityProof(pub [u8; 160]);
|
|
|
|
|
|
|
|
// `AggregatedValidityProof` is a Pod and Zeroable.
|
|
|
|
// Add the marker traits manually because `bytemuck` only adds them for some `u8` arrays
|
|
|
|
unsafe impl Zeroable for AggregatedValidityProof {}
|
|
|
|
unsafe impl Pod for AggregatedValidityProof {}
|
|
|
|
|
2021-12-16 06:15:29 -08:00
|
|
|
/// Serialization of zero balance proofs
|
|
|
|
#[derive(Clone, Copy)]
|
|
|
|
#[repr(transparent)]
|
2021-12-16 06:26:39 -08:00
|
|
|
pub struct ZeroBalanceProof(pub [u8; 96]);
|
2021-12-16 06:15:29 -08:00
|
|
|
|
|
|
|
// `ZeroBalanceProof` is a Pod and Zeroable.
|
|
|
|
// Add the marker traits manually because `bytemuck` only adds them for some `u8` arrays
|
|
|
|
unsafe impl Zeroable for ZeroBalanceProof {}
|
|
|
|
unsafe impl Pod for ZeroBalanceProof {}
|
|
|
|
|
2022-02-01 11:11:28 -08:00
|
|
|
/// Serialization of fee sigma proof
|
|
|
|
#[derive(Clone, Copy, Pod, Zeroable)]
|
|
|
|
#[repr(transparent)]
|
|
|
|
pub struct FeeSigmaProof(pub [u8; 256]);
|
|
|
|
|
2022-10-14 04:15:20 -07:00
|
|
|
/// Serialization of public-key sigma proof
|
|
|
|
#[derive(Clone, Copy, Pod, Zeroable)]
|
|
|
|
#[repr(transparent)]
|
|
|
|
pub struct PubkeySigmaProof(pub [u8; 64]);
|
|
|
|
|
2021-09-30 10:25:36 -07:00
|
|
|
/// Serialization of range proofs for 64-bit numbers (for `Withdraw` instruction)
|
|
|
|
#[derive(Clone, Copy)]
|
|
|
|
#[repr(transparent)]
|
|
|
|
pub struct RangeProof64(pub [u8; 672]);
|
|
|
|
|
|
|
|
// `PodRangeProof64` is a Pod and Zeroable.
|
|
|
|
// Add the marker traits manually because `bytemuck` only adds them for some `u8` arrays
|
|
|
|
unsafe impl Zeroable for RangeProof64 {}
|
|
|
|
unsafe impl Pod for RangeProof64 {}
|
|
|
|
|
|
|
|
/// Serialization of range proofs for 128-bit numbers (for `TransferRangeProof` instruction)
|
|
|
|
#[derive(Clone, Copy)]
|
|
|
|
#[repr(transparent)]
|
|
|
|
pub struct RangeProof128(pub [u8; 736]);
|
|
|
|
|
|
|
|
// `PodRangeProof128` is a Pod and Zeroable.
|
|
|
|
// Add the marker traits manually because `bytemuck` only adds them for some `u8` arrays
|
|
|
|
unsafe impl Zeroable for RangeProof128 {}
|
|
|
|
unsafe impl Pod for RangeProof128 {}
|
2021-10-11 12:28:21 -07:00
|
|
|
|
2022-02-01 11:11:28 -08:00
|
|
|
/// Serialization of range proofs for 128-bit numbers (for `TransferRangeProof` instruction)
|
|
|
|
#[derive(Clone, Copy)]
|
|
|
|
#[repr(transparent)]
|
|
|
|
pub struct RangeProof256(pub [u8; 800]);
|
|
|
|
|
|
|
|
// `PodRangeProof256` is a Pod and Zeroable.
|
|
|
|
// Add the marker traits manually because `bytemuck` only adds them for some `u8` arrays
|
|
|
|
unsafe impl Zeroable for RangeProof256 {}
|
|
|
|
unsafe impl Pod for RangeProof256 {}
|
|
|
|
|
2021-12-13 07:56:49 -08:00
|
|
|
/// Serialization for AeCiphertext
|
2022-05-22 18:00:42 -07:00
|
|
|
#[derive(Clone, Copy, PartialEq, Eq)]
|
2021-10-11 12:28:21 -07:00
|
|
|
#[repr(transparent)]
|
2021-12-13 07:56:49 -08:00
|
|
|
pub struct AeCiphertext(pub [u8; 36]);
|
2021-10-17 08:45:41 -07:00
|
|
|
|
2021-12-13 07:56:49 -08:00
|
|
|
// `AeCiphertext` is a Pod and Zeroable.
|
2021-10-17 08:45:41 -07:00
|
|
|
// Add the marker traits manually because `bytemuck` only adds them for some `u8` arrays
|
2021-12-13 07:56:49 -08:00
|
|
|
unsafe impl Zeroable for AeCiphertext {}
|
|
|
|
unsafe impl Pod for AeCiphertext {}
|
2021-10-11 12:28:21 -07:00
|
|
|
|
2021-12-13 07:56:49 -08:00
|
|
|
impl fmt::Debug for AeCiphertext {
|
2021-10-11 12:28:21 -07:00
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
|
|
write!(f, "{:?}", self.0)
|
|
|
|
}
|
|
|
|
}
|
2022-01-20 13:27:31 -08:00
|
|
|
|
2022-07-25 20:09:41 -07:00
|
|
|
impl fmt::Display for AeCiphertext {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
2023-05-11 11:34:58 -07:00
|
|
|
write!(f, "{}", BASE64_STANDARD.encode(self.0))
|
2022-07-25 20:09:41 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-20 13:27:31 -08:00
|
|
|
impl Default for AeCiphertext {
|
|
|
|
fn default() -> Self {
|
|
|
|
Self::zeroed()
|
|
|
|
}
|
|
|
|
}
|
2022-02-01 11:11:28 -08:00
|
|
|
|
|
|
|
// TODO: refactor this code into the instruction module
|
2022-02-08 09:09:50 -08:00
|
|
|
#[derive(Clone, Copy, Pod, Zeroable)]
|
|
|
|
#[repr(C)]
|
|
|
|
pub struct TransferPubkeys {
|
2022-03-03 12:07:27 -08:00
|
|
|
pub source_pubkey: ElGamalPubkey,
|
|
|
|
pub destination_pubkey: ElGamalPubkey,
|
|
|
|
pub auditor_pubkey: ElGamalPubkey,
|
2022-02-08 09:09:50 -08:00
|
|
|
}
|
2022-02-01 11:11:28 -08:00
|
|
|
|
|
|
|
#[derive(Clone, Copy, Pod, Zeroable)]
|
2022-02-08 09:09:50 -08:00
|
|
|
#[repr(C)]
|
|
|
|
pub struct TransferWithFeePubkeys {
|
2022-03-03 12:07:27 -08:00
|
|
|
pub source_pubkey: ElGamalPubkey,
|
|
|
|
pub destination_pubkey: ElGamalPubkey,
|
|
|
|
pub auditor_pubkey: ElGamalPubkey,
|
|
|
|
pub withdraw_withheld_authority_pubkey: ElGamalPubkey,
|
2022-02-08 09:09:50 -08:00
|
|
|
}
|
2022-02-01 11:11:28 -08:00
|
|
|
|
2022-02-08 09:09:50 -08:00
|
|
|
#[derive(Clone, Copy, Pod, Zeroable)]
|
|
|
|
#[repr(C)]
|
|
|
|
pub struct TransferAmountEncryption {
|
|
|
|
pub commitment: PedersenCommitment,
|
2022-03-03 12:07:27 -08:00
|
|
|
pub source_handle: DecryptHandle,
|
|
|
|
pub destination_handle: DecryptHandle,
|
|
|
|
pub auditor_handle: DecryptHandle,
|
2022-02-08 09:09:50 -08:00
|
|
|
}
|
2022-02-01 11:11:28 -08:00
|
|
|
|
2022-02-08 09:09:50 -08:00
|
|
|
#[derive(Clone, Copy, Pod, Zeroable)]
|
|
|
|
#[repr(C)]
|
|
|
|
pub struct FeeEncryption {
|
|
|
|
pub commitment: PedersenCommitment,
|
2022-03-03 12:07:27 -08:00
|
|
|
pub destination_handle: DecryptHandle,
|
|
|
|
pub withdraw_withheld_authority_handle: DecryptHandle,
|
2022-02-08 09:09:50 -08:00
|
|
|
}
|
2022-02-01 11:11:28 -08:00
|
|
|
|
2022-02-08 09:09:50 -08:00
|
|
|
#[derive(Clone, Copy, Pod, Zeroable)]
|
|
|
|
#[repr(C)]
|
|
|
|
pub struct FeeParameters {
|
|
|
|
/// Fee rate expressed as basis points of the transfer amount, i.e. increments of 0.01%
|
|
|
|
pub fee_rate_basis_points: PodU16,
|
|
|
|
/// Maximum fee assessed on transfers, expressed as an amount of tokens
|
|
|
|
pub maximum_fee: PodU64,
|
|
|
|
}
|