feat: fixed some issues in the logic, and refactors

theblockstalk · theblockstalk · commit 2b1e002b9100 · 2025-12-17T10:46:55.000+01:00
diff --git a/contracts/tonomy/include/tonomy/apps.hpp b/contracts/tonomy/include/tonomy/apps.hpp
@@ -306,7 +306,8 @@ namespace tonomysystem
          * @param origin - domain (unique)
          */
         [[eosio::action]] void admncrtapp(
-           name creator,
+           name   account_name,
+           name   creator,
            string json_data,
            string username,
            string origin);
@@ -327,6 +328,24 @@ namespace tonomysystem
            string origin,
            uint8_t plan);
 
+        /**
+         * Admin: register app data for an existing account
+         * Similar to admncrtapp but does not create the account or set resource limits.
+         * Used when the account already exists.
+         *
+         * @param account_name - the app account name (must already exist)
+         * @param creator - the creator account (used for active permission via updateauth)
+         * @param json_data - JSON with display details
+         * @param username - raw username (unique)
+         * @param origin - domain (unique)
+         */
+        [[eosio::action]] void adminregapp(
+           name account_name,
+           name creator,
+           string json_data,
+           string username,
+           string origin);
+
         /**
          * Admin: delete an app record
          *
@@ -362,6 +381,7 @@ namespace tonomysystem
 
         using admncrtapp_action = action_wrapper<"admncrtapp"_n, &apps::admncrtapp>;
         using admnupdapp_action = action_wrapper<"admnupdapp"_n, &apps::admnupdapp>;
+        using adminregapp_action = action_wrapper<"adminregapp"_n, &apps::adminregapp>;
         using admndelapp_action = action_wrapper<"admndelapp"_n, &apps::admndelapp>;
         using admnmigapp_action = action_wrapper<"admnmigapp"_n, &apps::admnmigapp>;
         using admnmigsc_action = action_wrapper<"admnmigsc"_n, &apps::admnmigsc>;
@@ -372,20 +392,39 @@ namespace tonomysystem
        *
        * @param username_hash - hash of the username of the account
        */    
-      void check_app_username(const checksum256 &username_hash);
+      // Helper: ensure the provided username is not already taken
+      void check_username_is_unique(const string &username);
     
       /**
        * Check if the app origin is already taken
        *
        * @param origin - domain associated with the app
        */
-      void check_app_origin(const string &origin);
+      void check_app_origin_is_unique(const string &origin);
 
       /**
        * Validate username characters against allowed set [A-Za-z0-9_-]
+       *
+       * @param username - raw username string
        */
       void check_app_username_chars(const string &username);
 
+      /**
+       * Update resource config and set resource limits for an account
+       *
+       * @param account_name - the account to set resource limits for
+       */
+      void update_resource_config_and_limits(name account_name);
+
+      /**
+       * Create a new account with specified owner and active authorities
+       *
+       * @param account_name - the new account name
+       * @param owner_account - the account name for owner permission
+       * @param active_account - the account name for active permission
+       */
+      void create_app_account(name account_name, name owner_account, name active_account);
+
       /**
        * Check if the raw username is already taken in appsv3
        *
@@ -399,5 +438,17 @@ namespace tonomysystem
          auto itr = idx.find(username_hash);
          check(itr == idx.end(), "Username already taken");
       }
+
+      /**
+       * Register app data in appsv3 table and update authority
+       * Common logic used by both admncrtapp and adminregapp
+       *
+       * @param account_name - the app account name
+       * @param creator - the creator account for active permission
+       * @param json_data - JSON with display details
+       * @param username - raw username string (unique)
+       * @param origin - domain (unique)
+       */
+      void register_app_data(name account_name, name creator, const string &json_data, const string &username, const string &origin);
    };
 }
diff --git a/contracts/tonomy/src/apps.cpp b/contracts/tonomy/src/apps.cpp
@@ -16,54 +16,42 @@ apps::apps(name receiver, name code, eosio::datastream<const char *> ds)
             _smartcontracts(receiver, receiver.value) {}
 
 // Admin create app with random account name
-void apps::admncrtapp(name creator,
+void apps::admncrtapp(name   account_name,
+                      name   creator,
                       string json_data,
                       string username,
                       string origin)
 {
     require_auth(get_self());
+    check(is_account(creator), "Creator account does not exist");
+    create_app_account(account_name, app_controller_account, creator);
+    register_app_data(account_name, creator, json_data, username, origin);
+}
 
+// Admin register app data for an existing account (without creating account)
+void apps::adminregapp(name   account_name,
+                       name   creator,
+                       string json_data,
+                       string username,
+                       string origin)
+{
+    require_auth(get_self());
+    check(is_account(account_name), "Account does not exist");
     check(is_account(creator), "Creator account does not exist");
+    register_app_data(account_name, creator, json_data, username, origin);
+}
 
+// Private helper: Register app data, account type, and update authority
+void apps::register_app_data(name account_name, name creator, const string &json_data, const string &username, const string &origin)
+{
     check_app_username_chars(username);
-
-    // Uniqueness checks for username and origin
-    checksum256 username_hash = eosio::sha256(username.c_str(), std::strlen(username.c_str()));
-    {
-        auto uidx = _appsv3.get_index<"usernamehash"_n>();
-        check(uidx.find(username_hash) == uidx.end(), "Username already taken");
-    }
-    checksum256 origin_hash = eosio::sha256(origin.c_str(), std::strlen(origin.c_str()));
-    {
-        auto oidx = _appsv3.get_index<"originhash"_n>();
-        check(oidx.find(origin_hash) == oidx.end(), "Origin already taken");
-    }
-
-    // Generate random account name from username and json_data hashes
-    auto json_hash = eosio::sha256(json_data.c_str(), std::strlen(json_data.c_str()));
-    const eosio::name random_name = random_account_name(username_hash, json_hash, enum_account_type::App);
-
-    // Create account with owner=gov.tmy, active=creator
-    authority owner_authority = create_authority_with_account(app_controller_account);
-    authority active_authority = create_authority_with_account(creator);
-    active_authority.accounts.push_back({.permission = create_eosio_code_permission_level(get_self()), .weight = 1});
-
-    newaccount_action newaccountaction("eosio"_n, {get_self(), "active"_n});
-    newaccountaction.send(get_self(), random_name, owner_authority, active_authority);
-
-    // Update resource config
-    tonomy::resource_config_table _resource_config(get_self(), get_self().value);
-    auto config = _resource_config.get();
-    config.total_cpu_weight_allocated = this->initial_cpu_weight_allocation;
-    config.total_net_weight_allocated = this->initial_net_weight_allocation;
-    _resource_config.set(config, get_self());
-
-    // Set resource limits: ram=0, net=initial, cpu=initial
-    eosio::set_resource_limits(random_name, 0, this->initial_net_weight_allocation, this->initial_cpu_weight_allocation);
+    check_username_is_unique(username);
+    check_app_origin_is_unique(origin);
+    update_resource_config_and_limits(account_name);
 
     // Register in appsv3
     _appsv3.emplace(get_self(), [&](auto &row) {
-        row.account_name = random_name;
+        row.account_name = account_name;
         row.json_data = json_data;
         row.version = 3;
         row.username = username;
@@ -74,23 +62,23 @@ void apps::admncrtapp(name creator,
     // Set account type
     tonomy::account_type_table account_type(get_self(), get_self().value);
     account_type.emplace(get_self(), [&](auto &row) {
-        row.account_name = random_name;
+        row.account_name = account_name;
         row.acc_type = enum_account_type::App;
         row.version = 1;
     });
 }
 
-
-void apps::check_app_username(const checksum256 &username_hash)
+void apps::check_username_is_unique(const string &username)
 {
+    checksum256 username_hash = eosio::sha256(username.c_str(), std::strlen(username.c_str()));
     auto apps_by_username_hash_itr = _appsv3.get_index<"usernamehash"_n>();
     const auto username_itr = apps_by_username_hash_itr.find(username_hash);
     if (username_itr != apps_by_username_hash_itr.end()) {
         throwError("TCON1001", "This app username is already taken");
     }
 }
 
-void apps::check_app_origin(const string &origin)
+void apps::check_app_origin_is_unique(const string &origin)
 {
     auto origin_hash = eosio::sha256(origin.c_str(), std::strlen(origin.c_str()));
     auto apps_by_origin_hash_itr = _appsv3.get_index<"originhash"_n>();
@@ -113,29 +101,48 @@ void apps::check_app_username_chars(const string &username)
     }
 }
 
+void apps::update_resource_config_and_limits(name account_name)
+{
+    // Update resource config
+    tonomy::resource_config_table _resource_config(get_self(), get_self().value);
+    auto config = _resource_config.get();
+    config.total_cpu_weight_allocated += this->initial_cpu_weight_allocation;
+    config.total_net_weight_allocated += this->initial_net_weight_allocation;
+    _resource_config.set(config, get_self());
+
+    // Set resource limits: ram=0, net=initial, cpu=initial
+    eosio::set_resource_limits(account_name, 0, this->initial_net_weight_allocation, this->initial_cpu_weight_allocation);
+}
+
+void apps::create_app_account(name account_name, name owner_account, name active_account)
+{
+    // Create account with specified owner and active authorities
+    authority owner_authority = create_authority_with_account(owner_account);
+    authority active_authority = create_authority_with_account(active_account);
+    active_authority.accounts.push_back({.permission = create_eosio_code_permission_level(get_self()), .weight = 1});
+
+    newaccount_action newaccountaction("eosio"_n, {get_self(), "active"_n});
+    newaccountaction.send(get_self(), account_name, owner_authority, active_authority);
+}
+
 void apps::admnupdapp(name account_name,
                        string json_data,
                        string username,
                        string origin,
                        uint8_t plan)
 {
     require_auth(get_self());
-    check(is_account(account_name), "Account does not exist");
 
     auto itr = _appsv3.find(account_name.value);
     check(itr != _appsv3.end(), "App does not exist; use admncrtapp to create");
 
     // validate and uniqueness checks if changed
     if (itr->username != username) {
         check_app_username_chars(username);
-        auto uidx = _appsv3.get_index<"usernamehash"_n>();
-        checksum256 username_hash = eosio::sha256(username.c_str(), std::strlen(username.c_str()));
-        check(uidx.find(username_hash) == uidx.end(), "Username already taken");
+        check_username_is_unique(username);
     }
     if (itr->origin != origin) {
-        auto oidx = _appsv3.get_index<"originhash"_n>();
-        checksum256 origin_hash = eosio::sha256(origin.c_str(), std::strlen(origin.c_str()));
-        check(oidx.find(origin_hash) == oidx.end(), "Origin already taken");
+        check_app_origin_is_unique(origin);
     }
     _appsv3.modify(itr, get_self(), [&](auto &row) {
         row.json_data = json_data;
@@ -276,41 +283,17 @@ void apps::appcreate(name creator,
                      string origin)
 {
     require_auth(creator);
-
-    // Uniqueness checks for username and origin
     check_app_username_chars(username);
-    checksum256 username_hash = eosio::sha256(username.c_str(), std::strlen(username.c_str()));
-    {
-        auto uidx = _appsv3.get_index<"usernamehash"_n>();
-        check(uidx.find(username_hash) == uidx.end(), "Username already taken");
-    }
-    checksum256 origin_hash = eosio::sha256(origin.c_str(), std::strlen(origin.c_str()));
-    {
-        auto oidx = _appsv3.get_index<"originhash"_n>();
-        check(oidx.find(origin_hash) == oidx.end(), "Origin already taken");
-    }
+    check_username_is_unique(username);
+    check_app_origin_is_unique(origin);
 
     // Generate random account name from username and json_data hashes
+    checksum256 username_hash = eosio::sha256(username.c_str(), std::strlen(username.c_str()));
     auto json_hash = eosio::sha256(json_data.c_str(), std::strlen(json_data.c_str()));
     const eosio::name random_name = random_account_name(username_hash, json_hash, enum_account_type::App);
 
-    // Create account with owner=gov.tmy, active=creator
-    authority owner_authority = create_authority_with_account(app_controller_account);
-    authority active_authority = create_authority_with_account(creator);
-    active_authority.accounts.push_back({.permission = create_eosio_code_permission_level(get_self()), .weight = 1});
-
-    newaccount_action newaccountaction("eosio"_n, {get_self(), "active"_n});
-    newaccountaction.send(get_self(), random_name, owner_authority, active_authority);
-
-    // Update resource config
-    tonomy::resource_config_table _resource_config(get_self(), get_self().value);
-    auto config = _resource_config.get();
-    config.total_cpu_weight_allocated = this->initial_cpu_weight_allocation;
-    config.total_net_weight_allocated = this->initial_net_weight_allocation;
-    _resource_config.set(config, get_self());
-
-    // Set resource limits: ram=0, net=initial, cpu=initial
-    eosio::set_resource_limits(random_name, 0, this->initial_net_weight_allocation, this->initial_cpu_weight_allocation);
+    create_app_account(random_name, app_controller_account, creator);
+    update_resource_config_and_limits(random_name);
 
     // Register in appsv3
     _appsv3.emplace(get_self(), [&](auto &row) {
@@ -342,9 +325,7 @@ void apps::appupdate(name account_name,
     // If username changed, ensure uniqueness
     if (itr->username != username) {
         check_app_username_chars(username);
-        checksum256 username_hash = eosio::sha256(username.c_str(), std::strlen(username.c_str()));
-        auto uidx = _appsv3.get_index<"usernamehash"_n>();
-        check(uidx.find(username_hash) == uidx.end(), "Username already taken");
+        check_username_is_unique(username);
     }
 
     _appsv3.modify(itr, get_self(), [&](auto &row) {
@@ -359,7 +340,7 @@ void apps::appupdplan(name account_name,
                       uint8_t plan)
 {
     // Plan updates assumed admin-governed
-    require_auth(get_self());
+    require_auth(account_name);
     auto itr = _appsv3.find(account_name.value);
     check(itr != _appsv3.end(), "App does not exist");
     _appsv3.modify(itr, get_self(), [&](auto &row) {
@@ -374,7 +355,7 @@ void apps::scdeploy(name account_name,
                     const std::vector<char> &abi,
                     string source_code_url)
 {
-    require_auth(get_self());
+    require_auth(account_name);
     // TODO: Implement smart contract deployment
     check(false, "scdeploy not yet implemented");
 }
@@ -386,23 +367,23 @@ void apps::scupdate(name account_name,
                     const std::vector<char> &abi,
                     string source_code_url)
 {
-    require_auth(get_self());
+    require_auth(account_name);
     // TODO: Implement smart contract update
     check(false, "scupdate not yet implemented");
 }
 
 void apps::appaddkey(name account_name,
                      public_key key)
 {
-    require_auth(get_self());
+    require_auth(account_name);
     // TODO: Implement key addition to app account's active permission
     check(false, "appaddkey not yet implemented");
 }
 
 void apps::appremkey(name account_name,
                      public_key key)
 {
-    require_auth(get_self());
+    require_auth(account_name);
     // TODO: Implement key removal from app account's active permission
     check(false, "appremkey not yet implemented");
 }
@@ -412,7 +393,7 @@ void apps::admnmigapp(name account_name,
                       uint8_t plan,
                       public_key key)
 {
-    require_auth(get_self());
+    require_auth(account_name);
     // TODO: Implement V2 to V3 app migration
     check(false, "admnmigapp not yet implemented");
 }
