use starknet::core::utils::get_storage_var_address;
use starknet_crypto::pedersen_hash;
use starknet_types_core::felt::Felt;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct EncPrivateKeySlots {
pub auditor_public_key: Felt,
pub ephemeral_pubkey: Felt,
pub enc_private_key: Felt,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct EncChannelInfoSlots {
pub ephemeral_pubkey: Felt,
pub enc_channel_key: Felt,
pub enc_sender_addr: Felt,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct EncSubchannelInfoSlots {
pub salt: Felt,
pub enc_token: Felt,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct EncOutgoingChannelInfoSlots {
pub salt: Felt,
pub enc_recipient_addr: Felt,
}
impl EncPrivateKeySlots {
pub fn to_vec(self) -> Vec<Felt> {
vec![
self.auditor_public_key,
self.ephemeral_pubkey,
self.enc_private_key,
]
}
}
impl EncChannelInfoSlots {
pub fn to_vec(self) -> Vec<Felt> {
vec![
self.ephemeral_pubkey,
self.enc_channel_key,
self.enc_sender_addr,
]
}
}
impl EncSubchannelInfoSlots {
pub fn to_vec(self) -> Vec<Felt> {
vec![self.salt, self.enc_token]
}
}
impl EncOutgoingChannelInfoSlots {
pub fn to_vec(self) -> Vec<Felt> {
vec![self.salt, self.enc_recipient_addr]
}
}
fn slot(name: &str, keys: &[Felt]) -> Felt {
get_storage_var_address(name, keys).expect("storage var name exceeds 31 chars")
}
pub fn auditor_public_key() -> Felt {
slot("auditor_public_key", &[])
}
pub fn public_key(user_address: Felt) -> Felt {
slot("public_key", &[user_address])
}
pub fn enc_private_key(user_address: Felt) -> EncPrivateKeySlots {
let base = slot("enc_private_key", &[user_address]);
EncPrivateKeySlots {
auditor_public_key: base,
ephemeral_pubkey: base + Felt::ONE,
enc_private_key: base + Felt::TWO,
}
}
pub fn channel_exists(channel_marker: Felt) -> Felt {
slot("channel_exists", &[channel_marker])
}
pub fn recipient_channels_base(recipient_address: Felt) -> Felt {
slot("recipient_channels", &[recipient_address])
}
pub fn recipient_channels_element(recipient_address: Felt, index: u64) -> EncChannelInfoSlots {
let base = recipient_channels_base(recipient_address);
let element_base = pedersen_hash(&base, &Felt::from(index));
EncChannelInfoSlots {
ephemeral_pubkey: element_base,
enc_channel_key: element_base + Felt::ONE,
enc_sender_addr: element_base + Felt::TWO,
}
}
pub fn subchannel_exists(subchannel_marker: Felt) -> Felt {
slot("subchannel_exists", &[subchannel_marker])
}
pub fn subchannel_tokens(subchannel_id: Felt) -> EncSubchannelInfoSlots {
let base = slot("subchannel_tokens", &[subchannel_id]);
EncSubchannelInfoSlots {
salt: base,
enc_token: base + Felt::ONE,
}
}
pub fn outgoing_channels(outgoing_channel_id: Felt) -> EncOutgoingChannelInfoSlots {
let base = slot("outgoing_channels", &[outgoing_channel_id]);
EncOutgoingChannelInfoSlots {
salt: base,
enc_recipient_addr: base + Felt::ONE,
}
}
pub fn notes(note_id: Felt) -> Felt {
slot("notes", &[note_id])
}
pub fn nullifiers(nullifier: Felt) -> Felt {
slot("nullifiers", &[nullifier])
}
#[cfg(test)]
mod live_probes {
use super::*;
#[test]
#[ignore]
fn slot_print_auditor_public_key() {
eprintln!("auditor_public_key slot = {:#x}", auditor_public_key());
}
#[test]
#[ignore]
fn slot_print_notes() {
let hex = std::env::var("NOTE_ID").expect("NOTE_ID env var required (hex felt)");
let note_id = Felt::from_hex(&hex).expect("NOTE_ID must be hex felt");
eprintln!("notes({:#x}) slot = {:#x}", note_id, notes(note_id));
}
}