use crate::poseidon::{
bytes_to_field, field_to_bytes, u128_to_field, u64_to_field, FieldElement, PoseidonHasher,
};
use rand::RngCore;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PrivateAccount {
pub pubkey: [u8; 32],
pub balance: u128,
pub nonce: u64,
pub index: u64,
}
impl PrivateAccount {
pub fn new(hasher: &mut PoseidonHasher, secret: &FieldElement, index: u64) -> Self {
let pubkey_field = hasher.derive_pubkey(secret);
Self {
pubkey: field_to_bytes(&pubkey_field),
balance: 0,
nonce: 0,
index,
}
}
pub fn with_balance(
hasher: &mut PoseidonHasher,
secret: &FieldElement,
index: u64,
balance: u128,
) -> Self {
let pubkey_field = hasher.derive_pubkey(secret);
Self {
pubkey: field_to_bytes(&pubkey_field),
balance,
nonce: 0,
index,
}
}
pub fn pubkey_field(&self) -> FieldElement {
bytes_to_field(&self.pubkey)
}
pub fn balance_field(&self) -> FieldElement {
u128_to_field(self.balance)
}
pub fn nonce_field(&self) -> FieldElement {
u64_to_field(self.nonce)
}
pub fn index_field(&self) -> FieldElement {
u64_to_field(self.index)
}
pub fn compute_leaf(&self, hasher: &mut PoseidonHasher) -> FieldElement {
hasher.compute_leaf(&self.pubkey_field(), &self.balance_field(), &self.nonce_field())
}
pub fn credit(&mut self, amount: u128) {
self.balance = self.balance.saturating_add(amount);
}
pub fn debit(&mut self, amount: u128) -> bool {
if self.balance >= amount {
self.balance -= amount;
self.nonce += 1;
true
} else {
false
}
}
pub fn has_balance(&self, amount: u128) -> bool {
self.balance >= amount
}
}
#[derive(Clone)]
pub struct AccountSecret {
secret: FieldElement,
raw_bytes: [u8; 32],
}
impl AccountSecret {
pub fn from_bytes(bytes: &[u8; 32]) -> Self {
Self {
secret: bytes_to_field(bytes),
raw_bytes: *bytes,
}
}
pub fn generate() -> Self {
let mut rng = rand::thread_rng();
let mut bytes = [0u8; 32];
rng.fill_bytes(&mut bytes);
Self::from_bytes(&bytes)
}
pub fn secret(&self) -> &FieldElement {
&self.secret
}
pub fn as_bytes(&self) -> &[u8; 32] {
&self.raw_bytes
}
pub fn derive_pubkey(&self, hasher: &mut PoseidonHasher) -> FieldElement {
hasher.derive_pubkey(&self.secret)
}
pub fn compute_nullifier(
&self,
hasher: &mut PoseidonHasher,
index: u64,
nonce: u64,
) -> FieldElement {
hasher.compute_nullifier(&self.secret, &u64_to_field(index), &u64_to_field(nonce))
}
pub fn compute_deposit_commitment(
&self,
hasher: &mut PoseidonHasher,
amount: u128,
) -> FieldElement {
hasher.compute_deposit_commitment(&self.secret, &u128_to_field(amount))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_account_creation() {
let mut hasher = PoseidonHasher::new();
let secret = AccountSecret::generate();
let account = PrivateAccount::new(&mut hasher, secret.secret(), 0);
assert_eq!(account.balance, 0);
assert_eq!(account.nonce, 0);
assert_eq!(account.index, 0);
assert_ne!(account.pubkey, [0u8; 32]);
}
#[test]
fn test_credit_debit() {
let mut hasher = PoseidonHasher::new();
let secret = AccountSecret::generate();
let mut account = PrivateAccount::new(&mut hasher, secret.secret(), 0);
account.credit(1_000_000_000_000_000_000); assert_eq!(account.balance, 1_000_000_000_000_000_000);
assert_eq!(account.nonce, 0);
assert!(account.debit(500_000_000_000_000_000)); assert_eq!(account.balance, 500_000_000_000_000_000);
assert_eq!(account.nonce, 1);
assert!(!account.debit(1_000_000_000_000_000_000)); assert_eq!(account.balance, 500_000_000_000_000_000); assert_eq!(account.nonce, 1); }
#[test]
fn test_leaf_computation() {
let mut hasher = PoseidonHasher::new();
let secret = AccountSecret::generate();
let mut account = PrivateAccount::new(&mut hasher, secret.secret(), 0);
let leaf1 = account.compute_leaf(&mut hasher);
account.credit(1_000_000_000_000_000_000);
let leaf2 = account.compute_leaf(&mut hasher);
assert_ne!(leaf1, leaf2); }
#[test]
fn test_nullifier_uniqueness() {
let mut hasher = PoseidonHasher::new();
let secret = AccountSecret::generate();
let null1 = secret.compute_nullifier(&mut hasher, 0, 0);
let null2 = secret.compute_nullifier(&mut hasher, 0, 1);
let null3 = secret.compute_nullifier(&mut hasher, 1, 0);
assert_ne!(null1, null2);
assert_ne!(null1, null3);
assert_ne!(null2, null3);
}
#[test]
fn test_secret_pubkey_consistency() {
let mut hasher = PoseidonHasher::new();
let secret = AccountSecret::generate();
let pubkey1 = secret.derive_pubkey(&mut hasher);
let pubkey2 = secret.derive_pubkey(&mut hasher);
assert_eq!(pubkey1, pubkey2);
let account = PrivateAccount::new(&mut hasher, secret.secret(), 0);
assert_eq!(pubkey1, account.pubkey_field());
}
}