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

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

@@ -1,58 +1,76 @@
 #![no_std]
 
-pub mod events;
-pub mod types;
+mod errors;
+mod events;
+mod storage;
+mod types;
 
-use soroban_sdk::{
-    contract, contracterror, contractimpl, contracttype, panic_with_error, Address, BytesN, Env,
-};
-use types::ResolveData;
+#[cfg(test)]
+mod test;
 
-#[contract]
-pub struct Contract;
+use soroban_sdk::{contract, contractclient, contractimpl, panic_with_error, Address, BytesN, Env};
 
-#[contracttype]
-#[derive(Clone)]
-pub enum DataKey {
-    Resolver(BytesN<32>),
-}
+pub use crate::errors::ContractError;
+pub use crate::events::UsernameRegistered;
+pub use crate::types::{Proof, PublicSignals};
+
+#[contract]
+pub struct CoreContract;
 
-#[contracterror]
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub enum ResolverError {
-    NotFound = 1,
+#[contractclient(name = "VerifierContractClient")]
+pub trait VerifierContract {
+    fn verify_proof(env: Env, proof: Proof, public_signals: PublicSignals) -> bool;
 }
 
 #[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 set_memo(env: Env, commitment: BytesN<32>, memo_id: u64) {
-        let key = DataKey::Resolver(commitment);
-        let mut data = env
-            .storage()
-            .persistent()
-            .get::<DataKey, ResolveData>(&key)
-            .unwrap_or_else(|| panic_with_error!(&env, ResolverError::NotFound));
+    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));
 
-        data.memo = Some(memo_id);
-        env.storage().persistent().set(&key, &data);
-    }
+        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);
+        }
 
-    pub fn resolve(env: Env, commitment: BytesN<32>) -> (Address, Option<u64>) {
-        let key = DataKey::Resolver(commitment);
+        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);
+        storage::set_root(&env, &public_signals.new_root);
 
-        match env.storage().persistent().get::<DataKey, ResolveData>(&key) {
-            Some(data) => (data.wallet, data.memo),
-            None => panic_with_error!(&env, ResolverError::NotFound),
+        UsernameRegistered {
+            commitment: public_signals.commitment,
         }
+        .publish(&env);
     }
-}
 
-#[cfg(test)]
-mod test;
+    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/test.rs

@@ -1,39 +1,160 @@
 #![cfg(test)]
 
-use crate::{Contract, ContractClient};
-use soroban_sdk::testutils::Address as _;
-use soroban_sdk::{Address, BytesN, Env};
+use crate::errors::ContractError;
+use crate::types::{Proof, PublicSignals};
+use crate::{CoreContract, CoreContractClient};
+use soroban_sdk::testutils::Events as _;
+use soroban_sdk::{
+    contract, contractimpl, contracttype, map, Address, BytesN, Env, Error, IntoVal, Map, Symbol,
+    Val,
+};
 
-fn setup_test(env: &Env) -> (ContractClient<'_>, BytesN<32>, Address) {
-    let contract_id = env.register(Contract, ());
-    let client = ContractClient::new(env, &contract_id);
-    let commitment = BytesN::from_array(env, &[7u8; 32]);
-    let wallet = Address::generate(env);
+#[contract]
+struct MockVerifierContract;
 
-    (client, commitment, wallet)
+#[contracttype]
+#[derive(Clone)]
+enum MockVerifierDataKey {
+    ShouldVerify,
+}
+
+#[contractimpl]
+impl MockVerifierContract {
+    pub fn set_should_verify(env: Env, should_verify: bool) {
+        env.storage()
+            .instance()
+            .set(&MockVerifierDataKey::ShouldVerify, &should_verify);
+    }
+
+    pub fn verify_proof(env: Env, proof: Proof, public_signals: PublicSignals) -> bool {
+        let should_verify = env
+            .storage()
+            .instance()
+            .get::<MockVerifierDataKey, bool>(&MockVerifierDataKey::ShouldVerify)
+            .unwrap_or(true);
+
+        should_verify
+            && proof.a == public_signals.old_root
+            && proof.b == public_signals.new_root
+            && proof.c == public_signals.commitment
+    }
+}
+
+fn bytes(env: &Env, byte: u8) -> BytesN<32> {
+    BytesN::from_array(env, &[byte; 32])
+}
+
+fn offchain_register_fixture(env: &Env) -> (Proof, PublicSignals) {
+    let old_root = bytes(env, 0);
+    let new_root = bytes(env, 42);
+    let commitment = bytes(env, 7);
+
+    (
+        Proof {
+            a: old_root.clone(),
+            b: new_root.clone(),
+            c: commitment.clone(),
+        },
+        PublicSignals {
+            old_root,
+            new_root,
+            commitment,
+        },
+    )
+}
+
+fn setup(env: &Env) -> (Address, CoreContractClient<'_>, Address) {
+    let verifier_id = env.register(MockVerifierContract, ());
+    let verifier_client = MockVerifierContractClient::new(env, &verifier_id);
+    verifier_client.set_should_verify(&true);
+
+    let contract_id = env.register(CoreContract, ());
+    let client = CoreContractClient::new(env, &contract_id);
+    client.init(&verifier_id, &bytes(env, 0));
+
+    (contract_id, client, verifier_id)
+}
+
+fn assert_submit_error(
+    result: Result<
+        Result<(), soroban_sdk::ConversionError>,
+        Result<Error, soroban_sdk::InvokeError>,
+    >,
+    expected: ContractError,
+) {
+    assert_eq!(result, Err(Ok(expected.into())));
 }
 
 #[test]
-fn test_resolve_returns_none_when_no_memo() {
+fn submit_proof_succeeds_and_updates_state() {
     let env = Env::default();
-    let (client, commitment, wallet) = setup_test(&env);
+    let (contract_id, client, _) = setup(&env);
+    let (proof, public_signals) = offchain_register_fixture(&env);
 
-    client.register_resolver(&commitment, &wallet, &None);
+    client.submit_proof(&proof, &public_signals);
 
-    let (resolved_wallet, memo) = client.resolve(&commitment);
-    assert_eq!(resolved_wallet, wallet);
-    assert_eq!(memo, None);
+    assert_eq!(client.get_root(), Some(public_signals.new_root.clone()));
+    assert!(client.has_commitment(&public_signals.commitment));
+
+    let expected_event_data: Map<Symbol, Val> = map![
+        &env,
+        (
+            Symbol::new(&env, "commitment"),
+            public_signals.commitment.clone().into_val(&env)
+        )
+    ];
+    assert_eq!(
+        env.events().all(),
+        soroban_sdk::vec![
+            &env,
+            (
+                contract_id,
+                (Symbol::new(&env, "username_registered"),).into_val(&env),
+                expected_event_data.into_val(&env),
+            )
+        ]
+    );
+}
+
+#[test]
+fn invalid_proof_is_rejected() {
+    let env = Env::default();
+    let (_, client, verifier_id) = setup(&env);
+    let verifier_client = MockVerifierContractClient::new(&env, &verifier_id);
+    verifier_client.set_should_verify(&false);
+
+    let (proof, public_signals) = offchain_register_fixture(&env);
+    let result = client.try_submit_proof(&proof, &public_signals);
+
+    assert_submit_error(result, ContractError::InvalidProof);
+    assert!(!client.has_commitment(&public_signals.commitment));
+    assert_eq!(client.get_root(), Some(public_signals.old_root));
 }
 
 #[test]
-fn test_set_memo_and_resolve_flow() {
+fn stale_root_is_rejected() {
     let env = Env::default();
-    let (client, commitment, wallet) = setup_test(&env);
+    let (_, client, _) = setup(&env);
+    let (proof, mut public_signals) = offchain_register_fixture(&env);
+    public_signals.old_root = bytes(&env, 1);
+
+    let result = client.try_submit_proof(&proof, &public_signals);
+
+    assert_submit_error(result, ContractError::RootMismatch);
+    assert!(!client.has_commitment(&public_signals.commitment));
+    assert_eq!(client.get_root(), Some(bytes(&env, 0)));
+}
+
+#[test]
+fn duplicate_commitment_is_rejected() {
+    let env = Env::default();
+    let (_, client, _) = setup(&env);
+    let (proof, public_signals) = offchain_register_fixture(&env);
+
+    client.submit_proof(&proof, &public_signals);
 
-    client.register_resolver(&commitment, &wallet, &None);
-    client.set_memo(&commitment, &4242u64);
+    let duplicate_result = client.try_submit_proof(&proof, &public_signals);
 
-    let (resolved_wallet, memo) = client.resolve(&commitment);
-    assert_eq!(resolved_wallet, wallet);
-    assert_eq!(memo, Some(4242u64));
+    assert_submit_error(duplicate_result, ContractError::DuplicateCommitment);
+    assert_eq!(client.get_root(), Some(public_signals.new_root));
 }