feat(core): contract root anchoring

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

@@ -2,6 +2,12 @@ use soroban_sdk::contracterror;
 
 #[contracterror]
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum ContractError {
+    AlreadyInitialized = 1,
+    NotInitialized = 2,
+    RootMismatch = 3,
+    InvalidProof = 4,
+    DuplicateCommitment = 5,
 #[repr(u32)]
 pub enum CoreError {
     /// The requested resource was not found.

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

@@ -1,16 +1,39 @@
-#![allow(dead_code)]
+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>,
+}
 
 use soroban_sdk::{symbol_short, Symbol};
 
+#[allow(dead_code)]
 pub const INIT_EVENT: Symbol = symbol_short!("INIT");
+#[allow(dead_code)]
 pub const TRANSFER_EVENT: Symbol = symbol_short!("TRANSFER");
+#[allow(dead_code)]
 pub const REGISTER_EVENT: Symbol = symbol_short!("REGISTER");
+#[allow(dead_code)]
 pub const ROOT_UPDATED: Symbol = symbol_short!("ROOT_UPD");
+#[allow(dead_code)]
 pub const MASTER_SET: Symbol = symbol_short!("MSTR_SET");
+#[allow(dead_code)]
 pub const ADDR_ADDED: Symbol = symbol_short!("ADDR_ADD");
+#[allow(dead_code)]
 pub const CHAIN_ADD: Symbol = symbol_short!("CHAIN_ADD");
+#[allow(dead_code)]
 pub const CHAIN_REM: Symbol = symbol_short!("CHAIN_REM");
+#[allow(dead_code)]
 pub const VAULT_CREATE: Symbol = symbol_short!("VAULT_CRT");
+#[allow(dead_code)]
 pub const DEPOSIT: Symbol = symbol_short!("DEPOSIT");
+#[allow(dead_code)]
 pub const WITHDRAW: Symbol = symbol_short!("WITHDRAW");
+#[allow(dead_code)]
 pub const SCHED_PAY: Symbol = symbol_short!("SCHED_PAY");

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

@@ -1,5 +1,9 @@
 #![no_std]
 
+mod errors;
+mod events;
+mod storage;
+mod types;
 pub mod address_manager;
 pub mod errors;
 pub mod events;
@@ -12,6 +16,11 @@ pub mod zk_verifier;
 #[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};
 use address_manager::AddressManager;
 use errors::CoreError;
 use events::REGISTER_EVENT;
@@ -20,8 +29,52 @@ use soroban_sdk::{contract, contractimpl, panic_with_error, Address, Bytes, Byte
 use types::{ChainType, PublicSignals, ResolveData};
 
 #[contract]
-pub struct Contract;
+pub struct CoreContract;
+
+#[contractclient(name = "VerifierContractClient")]
+pub trait VerifierContract {
+    fn verify_proof(env: Env, proof: Proof, public_signals: PublicSignals) -> bool;
+}
+
+fn current_merkle_root(env: &Env) -> BytesN<32> {
+    storage::get_merkle_root(env)
+        .unwrap_or_else(|| panic_with_error!(env, ContractError::NotInitialized))
+}
+
+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 CoreContract {
+    pub fn init(env: Env, verifier: Address, root: BytesN<32>) {
+        if storage::is_initialized(&env) {
+            panic_with_error!(&env, ContractError::AlreadyInitialized);
+        }
+
+        storage::set_verifier(&env, &verifier);
+        storage::set_merkle_root(&env, &root);
+    }
+
+    pub fn submit_proof(env: Env, proof: Proof, public_signals: PublicSignals) {
+        let current_root = current_merkle_root(&env);
+
+        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);
 #[contractimpl]
 impl Contract {
     /// Get the current SMT root.
@@ -106,8 +159,26 @@ impl Contract {
             Some(data) => (data.wallet, data.memo),
             None => panic_with_error!(&env, CoreError::NotFound),
         }
+
+        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)
     /// Register a username commitment, mapping it to the caller's address.
     pub fn register(env: Env, caller: Address, commitment: BytesN<32>) {
         Registration::register(env, caller, commitment);

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

@@ -1,3 +1,46 @@
+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);
 use soroban_sdk::{contracttype, BytesN};
 
 /// Storage keys for the Core contract's persistent and instance storage.