feat(core): contract root anchoring

gateway-contract/contracts/core_contract/src/errors.rs

@@ -0,0 +1,11 @@
+use soroban_sdk::contracterror;
+
+#[contracterror]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum ContractError {
+    AlreadyInitialized = 1,
+    NotInitialized = 2,
+    RootMismatch = 3,
+    InvalidProof = 4,
+    DuplicateCommitment = 5,
+}

gateway-contract/contracts/core_contract/src/events.rs

@@ -1,3 +1,15 @@
+use soroban_sdk::{contractevent, BytesN};
+
+#[contractevent]
+pub struct UsernameRegistered {
+    pub commitment: BytesN<32>,
+}
+
+#[contractevent]
+pub struct MerkleRootUpdated {
+    pub old_root: BytesN<32>,
+    pub new_root: BytesN<32>,
+}
 #![allow(dead_code)]
 
 use soroban_sdk::{symbol_short, Symbol};

gateway-contract/contracts/core_contract/src/lib.rs

@@ -1,48 +1,86 @@
 #![no_std]
 
-pub mod events;
+mod errors;
+mod events;
+mod storage;
+mod types;
 
-use soroban_sdk::{
-    contract, contracterror, contractimpl, contracttype, panic_with_error, Address, BytesN, Env,
-};
+#[cfg(test)]
+mod test;
+
+use soroban_sdk::{contract, contractclient, contractimpl, panic_with_error, Address, BytesN, Env};
+
+pub use crate::errors::ContractError;
+pub use crate::events::{MerkleRootUpdated, UsernameRegistered};
+pub use crate::types::{Proof, PublicSignals};
 
 #[contract]
-pub struct Contract;
+pub struct CoreContract;
 
-#[contracttype]
-#[derive(Clone)]
-pub enum DataKey {
-    Resolver(BytesN<32>),
+#[contractclient(name = "VerifierContractClient")]
+pub trait VerifierContract {
+    fn verify_proof(env: Env, proof: Proof, public_signals: PublicSignals) -> bool;
 }
 
-#[contracttype]
-#[derive(Clone)]
-pub struct ResolveData {
-    pub wallet: Address,
-    pub memo: Option<u64>,
+fn current_merkle_root(env: &Env) -> BytesN<32> {
+    storage::get_merkle_root(env)
+        .unwrap_or_else(|| panic_with_error!(env, ContractError::NotInitialized))
 }
 
-#[contracterror]
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub enum ResolverError {
-    NotFound = 1,
+fn update_merkle_root(env: &Env, old_root: BytesN<32>, new_root: BytesN<32>) {
+    storage::set_merkle_root(env, &new_root);
+
+    MerkleRootUpdated { old_root, new_root }.publish(env);
 }
 
 #[contractimpl]
-impl Contract {
-    pub fn register_resolver(env: Env, commitment: BytesN<32>, wallet: Address, memo: Option<u64>) {
-        let key = DataKey::Resolver(commitment);
-        let data = ResolveData { wallet, memo };
+impl CoreContract {
+    pub fn init(env: Env, verifier: Address, root: BytesN<32>) {
+        if storage::is_initialized(&env) {
+            panic_with_error!(&env, ContractError::AlreadyInitialized);
+        }
 
-        env.storage().persistent().set(&key, &data);
+        storage::set_verifier(&env, &verifier);
+        storage::set_merkle_root(&env, &root);
     }
 
-    pub fn resolve(env: Env, commitment: BytesN<32>) -> ResolveData {
-        let key = DataKey::Resolver(commitment);
+    pub fn submit_proof(env: Env, proof: Proof, public_signals: PublicSignals) {
+        let current_root = current_merkle_root(&env);
 
-        match env.storage().persistent().get::<DataKey, ResolveData>(&key) {
-            Some(data) => data,
-            None => panic_with_error!(&env, ResolverError::NotFound),
+        if current_root != public_signals.old_root.clone() {
+            panic_with_error!(&env, ContractError::RootMismatch);
         }
+
+        if storage::has_commitment(&env, &public_signals.commitment) {
+            panic_with_error!(&env, ContractError::DuplicateCommitment);
+        }
+
+        let verifier = storage::get_verifier(&env)
+            .unwrap_or_else(|| panic_with_error!(&env, ContractError::NotInitialized));
+        let verifier_client = VerifierContractClient::new(&env, &verifier);
+        let is_valid = verifier_client.verify_proof(&proof, &public_signals);
+        if !is_valid {
+            panic_with_error!(&env, ContractError::InvalidProof);
+        }
+
+        storage::store_commitment(&env, &public_signals.commitment);
+        update_merkle_root(&env, current_root, public_signals.new_root.clone());
+
+        UsernameRegistered {
+            commitment: public_signals.commitment,
+        }
+        .publish(&env);
+    }
+
+    pub fn get_merkle_root(env: Env) -> BytesN<32> {
+        current_merkle_root(&env)
+    }
+
+    pub fn get_verifier(env: Env) -> Option<Address> {
+        storage::get_verifier(&env)
+    }
+
+    pub fn has_commitment(env: Env, commitment: BytesN<32>) -> bool {
+        storage::has_commitment(&env, &commitment)
     }
 }

gateway-contract/contracts/core_contract/src/storage.rs

@@ -0,0 +1,44 @@
+use soroban_sdk::{contracttype, Address, BytesN, Env};
+
+#[contracttype]
+#[derive(Clone)]
+pub enum DataKey {
+    CurrentMerkleRoot,
+    Verifier,
+    Commitment(BytesN<32>),
+}
+
+pub fn is_initialized(env: &Env) -> bool {
+    env.storage().persistent().has(&DataKey::CurrentMerkleRoot)
+        && env.storage().instance().has(&DataKey::Verifier)
+}
+
+pub fn get_merkle_root(env: &Env) -> Option<BytesN<32>> {
+    env.storage().persistent().get(&DataKey::CurrentMerkleRoot)
+}
+
+pub fn set_merkle_root(env: &Env, root: &BytesN<32>) {
+    env.storage()
+        .persistent()
+        .set(&DataKey::CurrentMerkleRoot, root);
+}
+
+pub fn get_verifier(env: &Env) -> Option<Address> {
+    env.storage().instance().get(&DataKey::Verifier)
+}
+
+pub fn set_verifier(env: &Env, verifier: &Address) {
+    env.storage().instance().set(&DataKey::Verifier, verifier);
+}
+
+pub fn has_commitment(env: &Env, commitment: &BytesN<32>) -> bool {
+    env.storage()
+        .persistent()
+        .has(&DataKey::Commitment(commitment.clone()))
+}
+
+pub fn store_commitment(env: &Env, commitment: &BytesN<32>) {
+    env.storage()
+        .persistent()
+        .set(&DataKey::Commitment(commitment.clone()), &true);
+}