create ElGamal registry program

Author: samkim-crypto

Cargo.toml

@@ -75,6 +75,7 @@ members = [
   "token/confidential-transfer/proof-extraction",
   "token/confidential-transfer/proof-generation",
   "token/confidential-transfer/proof-tests",
+  "token/confidential-transfer/elgamal-registry",
   "token/client",
   "utils/cgen",
   "utils/test-client",

token/confidential-transfer/elgamal-registry/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "spl-elgamal-registry"
+version = "0.1.0"
+description = "Solana ElGamal Registry"
+authors = ["Solana Labs Maintainers <[email protected]>"]
+repository = "https://github.com/solana-labs/solana-program-library"
+license = "Apache-2.0"
+edition = "2021"
+
+[features]
+no-entrypoint = []
+test-sbf = []
+
+[dependencies]
+bytemuck = { version = "1.18.0", features = ["derive"] }
+solana-program = "2.0.3"
+solana-zk-sdk = "2.0.3"
+spl-pod = { version = "0.4.0", path = "../../../libraries/pod" }
+spl-token-confidential-transfer-proof-extraction = { version = "0.1.0", path = "../proof-extraction" }
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

token/confidential-transfer/elgamal-registry/src/entrypoint.rs

@@ -0,0 +1,14 @@
+//! Program entrypoint
+
+#![cfg(all(target_os = "solana", not(feature = "no-entrypoint")))]
+
+use solana_program::{account_info::AccountInfo, entrypoint::ProgramResult, pubkey::Pubkey};
+
+solana_program::entrypoint!(process_instruction);
+fn process_instruction(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> ProgramResult {
+    crate::processor::process_instruction(program_id, accounts, instruction_data)
+}

token/confidential-transfer/elgamal-registry/src/instruction.rs

@@ -0,0 +1,196 @@
+use {
+    crate::{get_elgamal_registry_address, id},
+    solana_program::{
+        instruction::{AccountMeta, Instruction},
+        program_error::ProgramError,
+        pubkey::Pubkey,
+        system_program, sysvar,
+    },
+    solana_zk_sdk::zk_elgamal_proof_program::{
+        instruction::ProofInstruction, proof_data::PubkeyValidityProofData,
+    },
+    spl_token_confidential_transfer_proof_extraction::{ProofData, ProofLocation},
+};
+
+#[derive(Clone, Debug, PartialEq)]
+#[repr(u8)]
+pub enum RegistryInstruction {
+    /// Initialize an ElGamal public key registry.
+    ///
+    /// 0. `[writeable, signer]` The funding account (must be a system account)
+    /// 1. `[writable]` The account to be created
+    /// 2. `[]` The wallet address (will also be the owner address for the
+    ///    registry account)
+    /// 3. `[]` System program
+    /// 4. `[]` Instructions sysvar if `VerifyPubkeyValidity` is included in the
+    ///    same transaction or context state account if `VerifyPubkeyValidity`
+    ///    is pre-verified into a context state account.
+    /// 5. `[]` (Optional) Record account if the accompanying proof is to be
+    ///    read from a record account.
+    CreateRegistry {
+        /// Relative location of the `ProofInstruction::PubkeyValidityProof`
+        /// instruction to the `CreateElGamalRegistry` instruction in the
+        /// transaction. If the offset is `0`, then use a context state account
+        /// for the proof.
+        proof_instruction_offset: i8,
+    },
+    /// Update an ElGamal public key registry with a new ElGamal public key.
+    ///
+    /// 0. `[writable]` The ElGamal registry account
+    /// 1. `[]` Instructions sysvar if `VerifyPubkeyValidity` is included in the
+    ///    same transaction or context state account if `VerifyPubkeyValidity`
+    ///    is pre-verified into a context state account.
+    /// 2. `[]` (Optional) Record account if the accompanying proof is to be
+    ///    read from a record account.
+    /// 3. `[signer]` The owner of the ElGamal public key registry
+    UpdateRegistry {
+        /// Relative location of the `ProofInstruction::PubkeyValidityProof`
+        /// instruction to the `UpdateElGamalRegistry` instruction in the
+        /// transaction. If the offset is `0`, then use a context state account
+        /// for the proof.
+        proof_instruction_offset: i8,
+    },
+}
+
+impl RegistryInstruction {
+    /// Unpacks a byte buffer into a `RegistryInstruction`
+    pub fn unpack(input: &[u8]) -> Result<Self, ProgramError> {
+        let (&tag, rest) = input
+            .split_first()
+            .ok_or(ProgramError::InvalidInstructionData)?;
+
+        Ok(match tag {
+            0 => {
+                let proof_instruction_offset =
+                    *rest.first().ok_or(ProgramError::InvalidInstructionData)?;
+                Self::CreateRegistry {
+                    proof_instruction_offset: proof_instruction_offset as i8,
+                }
+            }
+            1 => {
+                let proof_instruction_offset =
+                    *rest.first().ok_or(ProgramError::InvalidInstructionData)?;
+                Self::UpdateRegistry {
+                    proof_instruction_offset: proof_instruction_offset as i8,
+                }
+            }
+            _ => return Err(ProgramError::InvalidInstructionData),
+        })
+    }
+
+    /// Packs a `RegistryInstruction` into a byte buffer.
+    pub fn pack(&self) -> Vec<u8> {
+        let mut buf = vec![];
+        match self {
+            Self::CreateRegistry {
+                proof_instruction_offset,
+            } => {
+                buf.push(0);
+                buf.extend_from_slice(&proof_instruction_offset.to_le_bytes());
+            }
+            Self::UpdateRegistry {
+                proof_instruction_offset,
+            } => {
+                buf.push(1);
+                buf.extend_from_slice(&proof_instruction_offset.to_le_bytes());
+            }
+        };
+        buf
+    }
+}
+
+/// Create a `RegistryInstruction::CreateRegistry` instruction
+pub fn create_registry(
+    funding_address: &Pubkey,
+    owner_address: &Pubkey,
+    proof_location: ProofLocation<PubkeyValidityProofData>,
+) -> Result<Vec<Instruction>, ProgramError> {
+    let elgamal_registry_address = get_elgamal_registry_address(owner_address, &id());
+
+    let mut accounts = vec![
+        AccountMeta::new(*funding_address, true),
+        AccountMeta::new(elgamal_registry_address, false),
+        AccountMeta::new_readonly(*owner_address, false),
+        AccountMeta::new_readonly(system_program::id(), false),
+    ];
+    let proof_instruction_offset = proof_instruction_offset(&mut accounts, proof_location);
+
+    let registry_instruction = Instruction {
+        program_id: id(),
+        accounts,
+        data: RegistryInstruction::CreateRegistry {
+            proof_instruction_offset,
+        }
+        .pack(),
+    };
+    append_zk_elgamal_proof(registry_instruction, proof_location)
+}
+
+/// Create a `RegistryInstruction::UpdateRegistry` instruction
+pub fn update_registry(
+    registry_account: &Pubkey,
+    owner: &Pubkey,
+    proof_location: ProofLocation<PubkeyValidityProofData>,
+) -> Result<Vec<Instruction>, ProgramError> {
+    let mut accounts = vec![AccountMeta::new(*registry_account, false)];
+    let proof_instruction_offset = proof_instruction_offset(&mut accounts, proof_location);
+    accounts.push(AccountMeta::new_readonly(*owner, true));
+
+    let registry_instruction = Instruction {
+        program_id: id(),
+        accounts,
+        data: RegistryInstruction::UpdateRegistry {
+            proof_instruction_offset,
+        }
+        .pack(),
+    };
+    append_zk_elgamal_proof(registry_instruction, proof_location)
+}
+
+/// Takes a `ProofLocation`, updates the list of accounts, and returns a
+/// suitable proof location
+fn proof_instruction_offset(
+    accounts: &mut Vec<AccountMeta>,
+    proof_location: ProofLocation<PubkeyValidityProofData>,
+) -> i8 {
+    match proof_location {
+        ProofLocation::InstructionOffset(proof_instruction_offset, proof_data) => {
+            accounts.push(AccountMeta::new_readonly(sysvar::instructions::id(), false));
+            if let ProofData::RecordAccount(record_address, _) = proof_data {
+                accounts.push(AccountMeta::new_readonly(*record_address, false));
+            }
+            proof_instruction_offset.into()
+        }
+        ProofLocation::ContextStateAccount(context_state_account) => {
+            accounts.push(AccountMeta::new_readonly(*context_state_account, false));
+            0
+        }
+    }
+}
+
+/// Takes a `RegistryInstruction` and appends the pubkey validity proof
+/// instruction
+fn append_zk_elgamal_proof(
+    registry_instruction: Instruction,
+    proof_data_location: ProofLocation<PubkeyValidityProofData>,
+) -> Result<Vec<Instruction>, ProgramError> {
+    let mut instructions = vec![registry_instruction];
+
+    if let ProofLocation::InstructionOffset(proof_instruction_offset, proof_data) =
+        proof_data_location
+    {
+        let proof_instruction_offset: i8 = proof_instruction_offset.into();
+        if proof_instruction_offset != 1 {
+            return Err(ProgramError::InvalidArgument);
+        }
+        match proof_data {
+            ProofData::InstructionData(data) => instructions
+                .push(ProofInstruction::VerifyPubkeyValidity.encode_verify_proof(None, data)),
+            ProofData::RecordAccount(address, offset) => instructions.push(
+                ProofInstruction::VerifyPubkeyValidity
+                    .encode_verify_proof_from_account(None, address, offset),
+            ),
+        }
+    }
+    Ok(instructions)
+}

token/confidential-transfer/elgamal-registry/src/lib.rs

@@ -0,0 +1,28 @@
+mod entrypoint;
+pub mod instruction;
+pub mod processor;
+pub mod state;
+
+use solana_program::pubkey::Pubkey;
+
+/// Seed for the ElGamal registry program-derived address
+pub const REGISTRY_ADDRESS_SEED: &[u8] = "elgamal-registry".as_bytes();
+
+/// Derives the ElGamal registry account address and seed for the given wallet
+/// address
+pub fn get_elgamal_registry_address_and_bump_seed(
+    wallet_address: &Pubkey,
+    program_id: &Pubkey,
+) -> (Pubkey, u8) {
+    Pubkey::find_program_address(
+        &[REGISTRY_ADDRESS_SEED, &wallet_address.to_bytes()],
+        program_id,
+    )
+}
+
+/// Derives the ElGamal registry account address for the given wallet address
+pub fn get_elgamal_registry_address(wallet_address: &Pubkey, program_id: &Pubkey) -> Pubkey {
+    get_elgamal_registry_address_and_bump_seed(wallet_address, program_id).0
+}
+
+solana_program::declare_id!("regVYJW7tcT8zipN5YiBvHsvR5jXW1uLFxaHSbugABg");