fix: tests still fail

Author: phertyameen

Cargo.toml

@@ -6,4 +6,6 @@ members = [
     "contracts/shared",
     "contracts/reserve_contract",
     "contracts/native_transfer",
+    "contracts/account_factory",
+    "contracts/claim_verifier",
 ]

contracts/account_factory/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "account-factory"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["rlib", "cdylib"]
+
+[dependencies]
+soroban-sdk = "22.0.0"
+bridgelet-shared = { path = "../shared" }
+ephemeral_account = { path = "../ephemeral_account" }
+
+[dev-dependencies]
+soroban-sdk = { version = "22.0.0", features = ["testutils"] }
+bridgelet-shared = { path = "../shared", features = ["testutils"] }
+ephemeral_account = { path = "../ephemeral_account", features = ["testutils"] }
+
+[features]
+testutils = ["soroban-sdk/testutils"]

contracts/account_factory/src/errors.rs

@@ -0,0 +1,10 @@
+use soroban_sdk::contracterror;
+
+#[contracterror]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum Error {
+    NotInitialized = 1,
+    AlreadyInitialized = 2,
+    DeploymentFailed = 3,
+    Unauthorized = 4,
+}

contracts/account_factory/src/events.rs

@@ -0,0 +1,23 @@
+use soroban_sdk::{contracttype, symbol_short, Address, Env};
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct AccountDeployed {
+    pub account_address: Address,
+    pub creator: Address,
+    pub expiry_ledger: u32,
+}
+
+pub fn emit_account_deployed(
+    env: &Env,
+    account_address: Address,
+    creator: Address,
+    expiry_ledger: u32,
+) {
+    let event = AccountDeployed {
+        account_address,
+        creator,
+        expiry_ledger,
+    };
+    env.events().publish((symbol_short!("deployed"),), event);
+}

contracts/account_factory/src/lib.rs

@@ -0,0 +1,91 @@
+#![no_std]
+
+mod errors;
+mod events;
+mod storage;
+#[cfg(test)]
+mod test;
+
+use soroban_sdk::{contract, contractimpl, xdr::ToXdr, Address, Bytes, BytesN, Env};
+
+pub use errors::Error;
+pub use events::AccountDeployed;
+pub use storage::DataKey;
+
+#[contract]
+pub struct AccountFactoryContract;
+
+#[contractimpl]
+impl AccountFactoryContract {
+    /// Initialize the factory with admin and ephemeral account wasm hash.
+    pub fn initialize(
+        env: Env,
+        admin: Address,
+        ephemeral_wasm_hash: BytesN<32>,
+    ) -> Result<(), Error> {
+        if storage::has_admin(&env) {
+            return Err(Error::AlreadyInitialized);
+        }
+
+        admin.require_auth();
+
+        storage::set_admin(&env, &admin);
+        storage::set_ephemeral_wasm_hash(&env, &ephemeral_wasm_hash);
+
+        Ok(())
+    }
+
+    /// Deploy and initialize a new ephemeral account contract instance.
+    pub fn create_account(
+        env: Env,
+        creator: Address,
+        expiry_ledger: u32,
+        recovery_address: Address,
+        native_transfer_address: Address,
+        claim_verifier_address: Address,
+    ) -> Result<Address, Error> {
+        let wasm_hash = storage::get_ephemeral_wasm_hash(&env).ok_or(Error::NotInitialized)?;
+
+        creator.require_auth();
+
+        let salt = Self::account_salt(&env, &creator, expiry_ledger);
+        let deployed_address = env
+            .deployer()
+            .with_current_contract(salt)
+            .deploy_v2(wasm_hash, ());
+
+        let account_client =
+            ephemeral_account::EphemeralAccountContractClient::new(&env, &deployed_address);
+        account_client.initialize(
+            &creator,
+            &expiry_ledger,
+            &recovery_address,
+            &native_transfer_address,
+            &claim_verifier_address,
+        );
+
+        storage::add_deployed_account(&env, &creator, &deployed_address);
+        events::emit_account_deployed(&env, deployed_address.clone(), creator, expiry_ledger);
+
+        Ok(deployed_address)
+    }
+
+    /// Get all accounts deployed by a specific creator.
+    pub fn get_accounts_by_creator(env: Env, creator: Address) -> soroban_sdk::Vec<Address> {
+        storage::get_accounts_by_creator(&env, &creator)
+    }
+
+    /// Get all deployed accounts.
+    pub fn get_all_accounts(env: Env) -> soroban_sdk::Vec<Address> {
+        storage::get_all_accounts(&env)
+    }
+
+    fn account_salt(env: &Env, creator: &Address, expiry_ledger: u32) -> BytesN<32> {
+        let mut salt_preimage = Bytes::new(env);
+        salt_preimage.append(&creator.to_xdr(env));
+        salt_preimage.append(&expiry_ledger.to_xdr(env));
+        salt_preimage.append(&env.ledger().sequence().to_xdr(env));
+
+        env.crypto().sha256(&salt_preimage).into()
+    }
+}

contracts/account_factory/src/storage.rs

@@ -0,0 +1,75 @@
+use soroban_sdk::{contracttype, Address, BytesN, Env, Map, Vec};
+
+#[contracttype]
+#[derive(Clone)]
+pub enum DataKey {
+    Admin,
+    EphemeralWasmHash,
+    DeployedAccounts,
+    AllAccounts,
+}
+
+pub fn set_admin(env: &Env, admin: &Address) {
+    env.storage().instance().set(&DataKey::Admin, admin);
+}
+
+pub fn has_admin(env: &Env) -> bool {
+    env.storage().instance().has(&DataKey::Admin)
+}
+
+pub fn set_ephemeral_wasm_hash(env: &Env, hash: &BytesN<32>) {
+    env.storage()
+        .instance()
+        .set(&DataKey::EphemeralWasmHash, hash);
+}
+
+pub fn get_ephemeral_wasm_hash(env: &Env) -> Option<BytesN<32>> {
+    env.storage().instance().get(&DataKey::EphemeralWasmHash)
+}
+
+pub fn add_deployed_account(env: &Env, creator: &Address, account: &Address) {
+    let mut by_creator: Map<Address, Vec<Address>> = env
+        .storage()
+        .instance()
+        .get(&DataKey::DeployedAccounts)
+        .unwrap_or_else(|| Map::new(env));
+
+    let mut creator_accounts = by_creator
+        .get(creator.clone())
+        .unwrap_or_else(|| Vec::new(env));
+    creator_accounts.push_back(account.clone());
+    by_creator.set(creator.clone(), creator_accounts);
+
+    env.storage()
+        .instance()
+        .set(&DataKey::DeployedAccounts, &by_creator);
+
+    let mut all_accounts: Vec<Address> = env
+        .storage()
+        .instance()
+        .get(&DataKey::AllAccounts)
+        .unwrap_or_else(|| Vec::new(env));
+    all_accounts.push_back(account.clone());
+    env.storage()
+        .instance()
+        .set(&DataKey::AllAccounts, &all_accounts);
+}
+
+pub fn get_accounts_by_creator(env: &Env, creator: &Address) -> Vec<Address> {
+    let by_creator: Map<Address, Vec<Address>> = env
+        .storage()
+        .instance()
+        .get(&DataKey::DeployedAccounts)
+        .unwrap_or_else(|| Map::new(env));
+
+    by_creator
+        .get(creator.clone())
+        .unwrap_or_else(|| Vec::new(env))
+}
+
+pub fn get_all_accounts(env: &Env) -> Vec<Address> {
+    env.storage()
+        .instance()
+        .get(&DataKey::AllAccounts)
+        .unwrap_or_else(|| Vec::new(env))
+}