Implement submit_proof endpoint

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,9 @@
+use soroban_sdk::{contractevent, BytesN};
+
+#[contractevent]
+pub struct UsernameRegistered {
+    pub commitment: BytesN<32>,
+}
 #![allow(dead_code)]
 
 use soroban_sdk::{symbol_short, Symbol};

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

@@ -1,5 +1,9 @@
 #![no_std]
 
+mod errors;
+mod events;
+mod storage;
+mod types;
 pub mod events;
 pub mod types;
 
@@ -8,30 +12,56 @@ use soroban_sdk::{
 };
 use types::ResolveData;
 
-#[contract]
-pub struct Contract;
+#[cfg(test)]
+mod test;
 
-#[contracttype]
-#[derive(Clone)]
-pub enum DataKey {
-    Resolver(BytesN<32>),
-}
+use soroban_sdk::{contract, contractclient, contractimpl, panic_with_error, Address, BytesN, Env};
+
+pub use crate::errors::ContractError;
+pub use crate::events::UsernameRegistered;
+pub use crate::types::{Proof, PublicSignals};
+
+#[contract]
+pub struct CoreContract;
 
+#[contractclient(name = "VerifierContractClient")]
+pub trait VerifierContract {
+    fn verify_proof(env: Env, proof: Proof, public_signals: PublicSignals) -> bool;
 #[contracterror]
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum ResolverError {
     NotFound = 1,
 }
 
 #[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_root(&env, &root);
     }
 
+    pub fn submit_proof(env: Env, proof: Proof, public_signals: PublicSignals) {
+        let current_root = storage::get_root(&env)
+            .unwrap_or_else(|| panic_with_error!(&env, ContractError::NotInitialized));
+
+        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);
     pub fn set_memo(env: Env, commitment: BytesN<32>, memo_id: u64) {
         let key = DataKey::Resolver(commitment);
         let mut data = env
@@ -51,6 +81,26 @@ impl Contract {
             Some(data) => (data.wallet, data.memo),
             None => panic_with_error!(&env, ResolverError::NotFound),
         }
+
+        storage::store_commitment(&env, &public_signals.commitment);
+        storage::set_root(&env, &public_signals.new_root);
+
+        UsernameRegistered {
+            commitment: public_signals.commitment,
+        }
+        .publish(&env);
+    }
+
+    pub fn get_root(env: Env) -> Option<BytesN<32>> {
+        storage::get_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,41 @@
+use soroban_sdk::{contracttype, Address, BytesN, Env};
+
+#[contracttype]
+#[derive(Clone)]
+pub enum DataKey {
+    Root,
+    Verifier,
+    Commitment(BytesN<32>),
+}
+
+pub fn is_initialized(env: &Env) -> bool {
+    env.storage().instance().has(&DataKey::Root) && env.storage().instance().has(&DataKey::Verifier)
+}
+
+pub fn get_root(env: &Env) -> Option<BytesN<32>> {
+    env.storage().instance().get(&DataKey::Root)
+}
+
+pub fn set_root(env: &Env, root: &BytesN<32>) {
+    env.storage().instance().set(&DataKey::Root, 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);
+}

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

@@ -1,9 +1,20 @@
+use soroban_sdk::{contracttype, BytesN};
 use soroban_sdk::{contracttype, Address, Symbol};
 
 #[contracttype]
-#[derive(Clone)]
-pub struct AddressMetadata {
-    pub label: Symbol,
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Proof {
+    pub a: BytesN<32>,
+    pub b: BytesN<32>,
+    pub c: BytesN<32>,
+}
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct PublicSignals {
+    pub old_root: BytesN<32>,
+    pub new_root: BytesN<32>,
+    pub commitment: BytesN<32>,
 }
 
 #[contracttype]