kv database

libraries/chain/CMakeLists.txt

@@ -60,6 +60,7 @@ set(CHAIN_WEBASSEMBLY_SOURCES
    webassembly/console.cpp
    webassembly/crypto.cpp
    webassembly/database.cpp
+   webassembly/kv_database.cpp
    webassembly/memory.cpp
    webassembly/permission.cpp
    webassembly/privileged.cpp
@@ -116,7 +117,8 @@ add_library( eosio_chain
              whitelisted_intrinsics.cpp
              thread_utils.cpp
              platform_timer_accuracy.cpp
-
+             kv_context.cpp
+             kv_context_chainbase.cpp
              ${PLATFORM_TIMER_IMPL}
              ${HEADERS}
              )

libraries/chain/controller.cpp

@@ -18,6 +18,7 @@
 #include <eosio/chain/genesis_intrinsics.hpp>
 #include <eosio/chain/whitelisted_intrinsics.hpp>
 #include <eosio/chain/database_header_object.hpp>
+#include <eosio/chain/kv_chainbase_objects.hpp>
 
 #include <eosio/chain/protocol_feature_manager.hpp>
 #include <eosio/chain/authorization_manager.hpp>
@@ -50,7 +51,8 @@ using controller_index_set = index_set<
    generated_transaction_multi_index,
    table_id_multi_index,
    code_index,
-   database_header_multi_index
+   database_header_multi_index,
+   kv_index
 >;
 
 using contract_database_index_set = index_set<
@@ -331,6 +333,7 @@ struct controller_impl {
       set_activation_handler<builtin_protocol_feature_t::webauthn_key>();
       set_activation_handler<builtin_protocol_feature_t::wtmsig_block_signatures>();
       set_activation_handler<builtin_protocol_feature_t::action_return_value>();
+      set_activation_handler<builtin_protocol_feature_t::kv_database>();
 
       self.irreversible_block.connect([this](const block_state_ptr& bsp) {
          wasmif.current_lib(bsp->block_num);
@@ -950,6 +953,7 @@ struct controller_impl {
          // special case for in-place upgrade of global_property_object
          if (std::is_same<value_t, global_property_object>::value) {
             using v2 = legacy::snapshot_global_property_object_v2;
+            using v3 = legacy::snapshot_global_property_object_v3;
 
             if (std::clamp(header.version, v2::minimum_version, v2::maximum_version) == header.version ) {
                fc::optional<genesis_state> genesis = extract_legacy_genesis_state(*snapshot, header.version);
@@ -961,13 +965,31 @@ struct controller_impl {
                   section.read_row(legacy_global_properties, db);
 
                   db.create<global_property_object>([&legacy_global_properties,&gs_chain_id](auto& gpo ){
-                     gpo.initalize_from(legacy_global_properties, gs_chain_id);
+                     gpo.initalize_from(legacy_global_properties, gs_chain_id, kv_config{});
+                  });
+               });
+               return; // early out to avoid default processing
+            }
+
+            if (std::clamp(header.version, v3::minimum_version, v3::maximum_version) == header.version ) {
+               snapshot->read_section<global_property_object>([&db=this->db]( auto &section ) {
+                  v3 legacy_global_properties;
+                  section.read_row(legacy_global_properties, db);
+
+                  db.create<global_property_object>([&legacy_global_properties](auto& gpo ){
+                     gpo.initalize_from(legacy_global_properties, kv_config{});
                   });
                });
                return; // early out to avoid default processing
             }
          }
 
+         // skip the kv index if the snapshot doesn't contain it
+         if constexpr (std::is_same_v<value_t, kv_object>) {
+            if ( header.version < kv_object::minimum_snapshot_version )
+               return;
+         }
+
          snapshot->read_section<value_t>([this]( auto& section ) {
             bool more = !section.empty();
             while(more) {
@@ -981,7 +1003,7 @@ struct controller_impl {
       read_contract_tables_from_snapshot(snapshot);
 
       authorization.read_from_snapshot(snapshot);
-      resource_limits.read_from_snapshot(snapshot);
+      resource_limits.read_from_snapshot(snapshot, header.version);
 
       db.set_revision( head->block_num );
       db.create<database_header_object>([](const auto& header){
@@ -1034,10 +1056,10 @@ struct controller_impl {
 
       std::string event_id;
       if (get_deep_mind_logger() != nullptr) {
-         event_id = RAM_EVENT_ID("${name}", ("name", name));
+         event_id = STORAGE_EVENT_ID("${name}", ("name", name));
       }
 
-      resource_limits.add_pending_ram_usage(name, ram_delta, ram_trace(0, event_id.c_str(), "account", "add", "newaccount"));
+      resource_limits.add_pending_ram_usage(name, ram_delta, storage_usage_trace(0, event_id.c_str(), "account", "add", "newaccount"));
       resource_limits.verify_account_ram_usage(name);
    }
 
@@ -1059,6 +1081,7 @@ struct controller_impl {
       genesis.initial_configuration.validate();
       db.create<global_property_object>([&genesis,&chain_id=this->chain_id](auto& gpo ){
          gpo.configuration = genesis.initial_configuration;
+         gpo.kv_configuration = kv_config{};
          gpo.chain_id = chain_id;
       });
 
@@ -1191,11 +1214,11 @@ struct controller_impl {
    int64_t remove_scheduled_transaction( const generated_transaction_object& gto ) {
       std::string event_id;
       if (get_deep_mind_logger() != nullptr) {
-         event_id = RAM_EVENT_ID("${id}", ("id", gto.id));
+         event_id = STORAGE_EVENT_ID("${id}", ("id", gto.id));
       }
 
       int64_t ram_delta = -(config::billable_size_v<generated_transaction_object> + gto.packed_trx.size());
-      resource_limits.add_pending_ram_usage( gto.payer, ram_delta, ram_trace(0, event_id.c_str(), "deferred_trx", "remove", "deferred_trx_removed") );
+      resource_limits.add_pending_ram_usage( gto.payer, ram_delta, storage_usage_trace(0, event_id.c_str(), "deferred_trx", "remove", "deferred_trx_removed") );
       // No need to verify_account_ram_usage since we are only reducing memory
 
       db.remove( gto );
@@ -3436,7 +3459,7 @@ void controller::replace_account_keys( name account, name permission, const publ
       p.auth = authority(key);
    });
    int64_t new_size = (int64_t)(chain::config::billable_size_v<permission_object> + perm->auth.get_billable_size());
-   rlm.add_pending_ram_usage(account, new_size - old_size, generic_ram_trace(0));
+   rlm.add_pending_ram_usage(account, new_size - old_size, generic_storage_usage_trace(0));
    rlm.verify_account_ram_usage(account);
 }
 
@@ -3471,10 +3494,10 @@ void controller_impl::on_activation<builtin_protocol_feature_t::replace_deferred
 
       std::string event_id;
       if (get_deep_mind_logger() != nullptr) {
-         event_id = RAM_EVENT_ID("${id}", ("id", itr->id._id));
+         event_id = STORAGE_EVENT_ID("${id}", ("id", itr->id._id));
       }
 
-      resource_limits.add_pending_ram_usage( itr->name, ram_delta, ram_trace(0, event_id.c_str(), "deferred_trx", "correction", "deferred_trx_ram_correction") );
+      resource_limits.add_pending_ram_usage( itr->name, ram_delta, storage_usage_trace(0, event_id.c_str(), "deferred_trx", "correction", "deferred_trx_ram_correction") );
       db.remove( *itr );
    }
 }
@@ -3500,6 +3523,31 @@ void controller_impl::on_activation<builtin_protocol_feature_t::action_return_va
    } );
 }
 
+template<>
+void controller_impl::on_activation<builtin_protocol_feature_t::kv_database>() {
+   db.modify( db.get<protocol_state_object>(), [&]( auto& ps ) {
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "kv_erase" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "kv_set" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "kv_get" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "kv_get_data" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "kv_it_create" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "kv_it_destroy" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "kv_it_status" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "kv_it_compare" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "kv_it_key_compare" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "kv_it_move_to_end" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "kv_it_next" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "kv_it_prev" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "kv_it_lower_bound" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "kv_it_key" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "kv_it_value" );
+      // resource management
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "set_resource_limit" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "get_resource_limit" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "set_kv_parameters_packed" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "get_kv_parameters_packed" );
+   } );
+}
 
 
 /// End of protocol feature activation handlers

libraries/chain/eosio_contract.cpp

@@ -119,10 +119,10 @@ void apply_eosio_newaccount(apply_context& context) {
 
    std::string event_id;
    if (context.control.get_deep_mind_logger() != nullptr) {
-      event_id = RAM_EVENT_ID("${name}", ("name", create.name));
+      event_id = STORAGE_EVENT_ID("${name}", ("name", create.name));
    }
 
-   context.add_ram_usage(create.name, ram_delta, ram_trace(context.get_action_id(), event_id.c_str(), "account", "add", "newaccount"));
+   context.add_ram_usage(create.name, ram_delta, storage_usage_trace(context.get_action_id(), event_id.c_str(), "account", "add", "newaccount"));
 
 } FC_CAPTURE_AND_RETHROW( (create) ) }
 
@@ -206,10 +206,10 @@ void apply_eosio_setcode(apply_context& context) {
             operation = "remove";
          }
 
-         event_id = RAM_EVENT_ID("${account}", ("account", act.account));
+         event_id = STORAGE_EVENT_ID("${account}", ("account", act.account));
       }
 
-      context.add_ram_usage( act.account, new_size - old_size, ram_trace(context.get_action_id(), event_id.c_str(), "code", operation.c_str(), "setcode") );
+      context.add_ram_usage( act.account, new_size - old_size, storage_usage_trace(context.get_action_id(), event_id.c_str(), "code", operation.c_str(), "setcode") );
    }
 }
 
@@ -246,10 +246,10 @@ void apply_eosio_setabi(apply_context& context) {
             operation = "remove";
          }
 
-         event_id = RAM_EVENT_ID("${account}", ("account", act.account));
+         event_id = STORAGE_EVENT_ID("${account}", ("account", act.account));
       }
 
-      context.add_ram_usage( act.account, new_size - old_size, ram_trace(context.get_action_id(), event_id.c_str(), "abi", operation.c_str(), "setabi") );
+      context.add_ram_usage( act.account, new_size - old_size, storage_usage_trace(context.get_action_id(), event_id.c_str(), "abi", operation.c_str(), "setabi") );
    }
 }
 
@@ -309,21 +309,21 @@ void apply_eosio_updateauth(apply_context& context) {
 
       std::string event_id;
       if (context.control.get_deep_mind_logger() != nullptr) {
-         event_id = RAM_EVENT_ID("${id}", ("id", permission->id));
+         event_id = STORAGE_EVENT_ID("${id}", ("id", permission->id));
       }
 
-      context.add_ram_usage( permission->owner, new_size - old_size, ram_trace(context.get_action_id(), event_id.c_str(), "auth", "update", "updateauth_update") );
+      context.add_ram_usage( permission->owner, new_size - old_size, storage_usage_trace(context.get_action_id(), event_id.c_str(), "auth", "update", "updateauth_update") );
    } else {
       const auto& p = authorization.create_permission( update.account, update.permission, parent_id, update.auth, context.get_action_id() );
 
       int64_t new_size = (int64_t)(config::billable_size_v<permission_object> + p.auth.get_billable_size());
 
       std::string event_id;
       if (context.control.get_deep_mind_logger() != nullptr) {
-         event_id = RAM_EVENT_ID("${id}", ("id", p.id));
+         event_id = STORAGE_EVENT_ID("${id}", ("id", p.id));
       }
 
-      context.add_ram_usage( update.account, new_size, ram_trace(context.get_action_id(), event_id.c_str(), "auth", "add", "updateauth_create") );
+      context.add_ram_usage( update.account, new_size, storage_usage_trace(context.get_action_id(), event_id.c_str(), "auth", "add", "updateauth_create") );
    }
 }
 
@@ -354,12 +354,12 @@ void apply_eosio_deleteauth(apply_context& context) {
 
    std::string event_id;
    if (context.control.get_deep_mind_logger() != nullptr) {
-      event_id = RAM_EVENT_ID("${id}", ("id", permission.id));
+      event_id = STORAGE_EVENT_ID("${id}", ("id", permission.id));
    }
 
    authorization.remove_permission( permission, context.get_action_id() );
 
-   context.add_ram_usage( remove.account, -old_size, ram_trace(context.get_action_id(), event_id.c_str(), "auth", "remove", "deleteauth") );
+   context.add_ram_usage( remove.account, -old_size, storage_usage_trace(context.get_action_id(), event_id.c_str(), "auth", "remove", "deleteauth") );
 }
 
 void apply_eosio_linkauth(apply_context& context) {
@@ -411,13 +411,13 @@ void apply_eosio_linkauth(apply_context& context) {
 
          std::string event_id;
          if (context.control.get_deep_mind_logger() != nullptr) {
-            event_id = RAM_EVENT_ID("${id}", ("id", l.id));
+            event_id = STORAGE_EVENT_ID("${id}", ("id", l.id));
          }
 
          context.add_ram_usage(
             l.account,
             (int64_t)(config::billable_size_v<permission_link_object>),
-            ram_trace(context.get_action_id(), event_id.c_str(), "auth_link", "add", "linkauth")
+            storage_usage_trace(context.get_action_id(), event_id.c_str(), "auth_link", "add", "linkauth")
          );
       }
 
@@ -438,13 +438,13 @@ void apply_eosio_unlinkauth(apply_context& context) {
 
    std::string event_id;
    if (context.control.get_deep_mind_logger() != nullptr) {
-      event_id = RAM_EVENT_ID("${id}", ("id", link->id));
+      event_id = STORAGE_EVENT_ID("${id}", ("id", link->id));
    }
 
    context.add_ram_usage(
       link->account,
       -(int64_t)(config::billable_size_v<permission_link_object>),
-      ram_trace(context.get_action_id(), event_id.c_str(), "auth_link", "remove", "unlinkauth")
+      storage_usage_trace(context.get_action_id(), event_id.c_str(), "auth_link", "remove", "unlinkauth")
    );
 
    db.remove(*link);