Refactor eosio.bios to use new contract structure

- fix bootseq tests
- related to #1614 and #1752
- new dispatch_inline helper
- define producer_schedule_type
- implement eosio.token as a independent contract in new contract style

Author: bytemaster

contracts/CMakeLists.txt

@@ -8,6 +8,7 @@ add_subdirectory(eosiolib)
 add_subdirectory(musl)
 add_subdirectory(libc++)
 add_subdirectory(simple.token)
+add_subdirectory(eosio.token)
 add_subdirectory(multi_index_test)
 add_subdirectory(eosio.system)
 add_subdirectory(identity)

contracts/eosio.bios/eosio.bios.abi

@@ -10,7 +10,7 @@
         {"name":"cpu_weight", "type":"int64"}
       ]
     },{
-        "name": "set_priv",
+        "name": "setpriv",
         "base": "",
         "fields": [
           {"name":"account",    "type":"account_name"},
@@ -56,8 +56,8 @@
       "name": "setglimits",
       "type": "set_global_limits"
     },{
-       "name": "setprivileged",
-       "type": "set_priv"
+       "name": "setpriv",
+       "type": "setpriv"
     },{
       "name": "setprods",
       "type": "set_producers"

contracts/eosio.bios/eosio.bios.cpp

@@ -1,113 +1,3 @@
-/**
- *  @file
- *  @copyright defined in eos/LICENSE.txt
- */
+#include <eosio.bios/eosio.bios.hpp>
 
-#include <eosiolib/action.hpp>
-#include <eosiolib/chain.h>
-#include <eosiolib/types.hpp>
-#include <eosiolib/serialize.hpp>
-#include <eosiolib/system.h>
-#include <eosiolib/privileged.h>
-
-using namespace eosio;
-
-namespace eosiobios {
-   template<uint64_t Val>
-   struct dispatchable {
-      constexpr static uint64_t action_name = Val;
-   };
-
-   struct set_account_limits : dispatchable<N(setalimits)> {
-      account_name      account;
-      uint64_t          ram_bytes  = 0;
-      uint64_t          net_weight = 0;
-      uint64_t          cpu_weight = 0;
-
-      static void process(const set_account_limits& act) {
-         set_resource_limits(act.account, act.ram_bytes, act.net_weight, act.cpu_weight, 0);
-      }
-
-      EOSLIB_SERIALIZE( set_account_limits, (account)(ram_bytes)(net_weight)(cpu_weight) )
-   };
-
-    struct set_priv : dispatchable<N(setprivileged)> {
-        account_name      account;
-        bool              is_priv;
-
-        static void process(const set_priv& priv) {
-            set_privileged(priv.account, priv.is_priv);
-        }
-
-        EOSLIB_SERIALIZE( set_priv, (account)(is_priv) )
-    };
-
-
-    struct set_global_limits : dispatchable<N(setglimits)> {
-      int64_t          cpu_usec_per_period;
-
-      static void process(const set_global_limits& ) {
-         // TODO: support this
-      }
-
-      EOSLIB_SERIALIZE( set_global_limits, (cpu_usec_per_period) )
-   };
-
-   struct producer_key {
-      account_name          account;
-      std::string           public_key;
-
-      EOSLIB_SERIALIZE( producer_key, (account) ) //(public_key) )
-   };
-
-   struct set_producers : dispatchable<N(setprods)> {
-      static void process(const set_producers&) {
-         char buffer[action_data_size()];
-         read_action_data( buffer, sizeof(buffer) );
-         set_active_producers(buffer, sizeof(buffer));
-      }
-   };
-
-   struct require_auth : dispatchable<N(reqauth)> {
-      account_name from;
-
-      static void process(const require_auth& r) {
-         ::require_auth(r.from);
-      }
-   };
-
-   template<typename ...Ts>
-   struct dispatcher_impl;
-
-   template<typename T>
-   struct dispatcher_impl<T> {
-      static bool dispatch(uint64_t action) {
-         if (action == T::action_name) {
-            T::process(current_action_data<T>());
-            return true;
-         }
-
-         return false;
-      }
-   };
-
-   template<typename T, typename ...Rem>
-   struct dispatcher_impl<T, Rem...> {
-      static bool dispatch(uint64_t action) {
-         return dispatcher_impl<T>::dispatch(action) || dispatcher_impl<Rem...>::dispatch(action);
-      }
-   };
-
-   using dispatcher = dispatcher_impl<set_account_limits, set_priv,  set_producers, require_auth>;
-};
-
-extern "C" {
-
-/// The apply method implements the dispatch of events to this contract
-void apply( uint64_t code, uint64_t act ) {
-   if (code == current_receiver()) {
-      eosiobios::dispatcher::dispatch(act);
-   }
-}
-
-} // extern "C"
+EOSIO_ABI( eosio::bios, (setpriv)(setalimits)(setglimits)(setprods)(reqauth) )

contracts/eosio.bios/eosio.bios.hpp

@@ -0,0 +1,38 @@
+#include <eosiolib/eosio.hpp>
+#include <eosiolib/privileged.h>
+#include <eosiolib/producer_schedule.hpp>
+
+namespace eosio {
+
+   class bios : public contract {
+      public:
+         bios( action_name self ):contract(self){}
+
+         void setpriv( account_name account, uint8_t ispriv ) {
+            require_auth( _self );
+            set_privileged( account, ispriv );
+         }
+
+         void setalimits( account_name account, uint64_t ram_bytes, uint64_t net_weight, uint64_t cpu_weight ) {
+            require_auth( _self );
+            set_resource_limits( account, ram_bytes, net_weight, cpu_weight, 0 );
+         }
+
+         void setglimits( uint64_t ram, uint64_t net, uint64_t cpu ) {
+            require_auth( _self );
+         }
+
+         void setprods( producer_schedule sch ) {
+            char buffer[action_data_size()];
+            read_action_data( buffer, sizeof(buffer) );
+            set_active_producers(buffer, sizeof(buffer));
+         }
+
+         void reqauth( action_name from ) {
+            require_auth( from );
+         }
+
+      private:
+   };
+
+} /// namespace eosio

contracts/eosio.token/CMakeLists.txt

@@ -0,0 +1,8 @@
+file(GLOB ABI_FILES "*.abi")
+configure_file("${ABI_FILES}" "${CMAKE_CURRENT_BINARY_DIR}" COPYONLY)
+
+add_wast_executable(TARGET eosio.token
+  INCLUDE_FOLDERS "${STANDARD_INCLUDE_FOLDERS}"
+  LIBRARIES libc++ libc eosiolib
+  DESTINATION_FOLDER ${CMAKE_CURRENT_BINARY_DIR}
+)

contracts/eosio.token/eosio.token.abi

@@ -0,0 +1,76 @@
+{
+  "types": [{
+      "new_type_name": "account_name",
+      "type": "name"
+    }
+  ],
+  "structs": [{
+      "name": "transfer",
+      "base": "",
+      "fields": [
+        {"name":"from", "type":"account_name"},
+        {"name":"to", "type":"account_name"},
+        {"name":"quantity", "type":"asset"},
+        {"name":"memo", "type":"string"}
+      ]
+    },{
+     "name": "create",
+     "base": "",
+     "fields": [
+        {"name":"issuer", "type":"account_name"},
+        {"name":"maximum_supply", "type":"asset"},
+        {"name":"can_freeze", "type":"uint8"},
+        {"name":"can_recall", "type":"uint8"},
+        {"name":"can_whitelist", "type":"uint8"}
+     ]
+  },{
+     "name": "issue",
+     "base": "",
+     "fields": [
+        {"name":"to", "type":"account_name"},
+        {"name":"quantity", "type":"asset"},
+        {"name":"memo", "type":"string"}
+     ]
+  },{
+      "name": "account",
+      "base": "",
+      "fields": [
+        {"name":"currency", "type":"uint64"},
+        {"name":"balance", "type":"uint64"}
+      ]
+    },{
+      "name": "currency_stats",
+      "base": "",
+      "fields": [
+        {"name":"currency", "type":"uint64"},
+        {"name":"supply", "type":"uint64"}
+      ]
+    }
+  ],
+  "actions": [{
+      "name": "transfer",
+      "type": "transfer"
+    },{
+      "name": "issue",
+      "type": "issue"
+    }, {
+      "name": "create",
+      "type": "create"
+    }
+
+  ],
+  "tables": [{
+      "name": "account",
+      "type": "account",
+      "index_type": "i64",
+      "key_names" : ["currency"],
+      "key_types" : ["uint64"]
+    },{
+      "name": "stat",
+      "type": "currency_stats",
+      "index_type": "i64",
+      "key_names" : ["currency"],
+      "key_types" : ["uint64"]
+    }
+  ]
+}

contracts/eosio.token/eosio.token.cpp

@@ -0,0 +1,121 @@
+/**
+ *  @file
+ *  @copyright defined in eos/LICENSE.txt
+ */
+
+#include <eosio.token/eosio.token.hpp>
+
+namespace eosio {
+
+void token::create( account_name issuer,
+                    asset        maximum_supply,
+                    uint8_t      issuer_can_freeze,
+                    uint8_t      issuer_can_recall,  
+                    uint8_t      issuer_can_whitelist ) 
+{
+    require_auth( _self );
+
+    auto sym = maximum_supply.symbol;
+    eosio_assert( sym.is_valid(), "invalid symbol name" );
+
+    stats statstable( _self, sym.name() );
+    auto existing = statstable.find( sym.name() );
+    eosio_assert( existing == statstable.end(), "token with symbol already exists" );
+
+    statstable.emplace( _self, [&]( auto& s ) {
+       s.supply.symbol = maximum_supply.symbol;
+       s.max_supply    = maximum_supply;
+       s.issuer        = issuer;
+       s.can_freeze    = issuer_can_freeze;
+       s.can_recall    = issuer_can_recall;
+       s.can_whitelist = issuer_can_whitelist;
+    });
+}
+
+
+void token::issue( account_name to, asset quantity, string memo ) 
+{
+    print( "issue" );
+    auto sym = quantity.symbol.name();
+    stats statstable( _self, sym );
+    const auto& st = statstable.get( sym );
+
+    require_auth( st.issuer );
+    eosio_assert( quantity.is_valid(), "invalid quantity" );
+    eosio_assert( quantity.amount > 0, "must issue positive quantity" );
+
+    statstable.modify( st, 0, [&]( auto& s ) {
+       s.supply.amount += quantity.amount;
+    });
+
+    add_balance( st.issuer, quantity, st, st.issuer );
+
+    if( to != st.issuer )
+    {
+       dispatch_inline( permission_level{st.issuer,N(active)}, _self, N(transfer), &token::transfer, { st.issuer, to, quantity, memo } );
+    }
+}
+
+void token::transfer( account_name from, 
+                      account_name to,
+                      asset        quantity,
+                      string       /*memo*/ ) 
+{
+    print( "transfer" );
+    require_auth( from );
+    auto sym = quantity.symbol.name();
+    stats statstable( _self, sym );
+    const auto& st = statstable.get( sym );
+
+    require_recipient( from );
+    require_recipient( to );
+
+    eosio_assert( quantity.is_valid(), "invalid quantity" );
+    eosio_assert( quantity.amount > 0, "must transfer positive quantity" );
+
+    sub_balance( from, quantity, st );
+    add_balance( to, quantity, st, from );
+}
+
+
+void token::sub_balance( account_name owner, asset value, const currency_stats& st ) {
+   accounts from_acnts( _self, owner );
+
+   const auto& from = from_acnts.get( value.symbol );
+   eosio_assert( from.balance.amount >= value.amount, "overdrawn balance" );
+
+   if( has_auth( owner ) ) {
+      eosio_assert( !st.can_freeze || !from.frozen, "account is frozen by issuer" );
+      eosio_assert( !st.can_freeze || !st.is_frozen, "all transfers are frozen by issuer" );
+      eosio_assert( !st.enforce_whitelist || from.whitelist, "account is not white listed" );
+   } else if( has_auth( st.issuer ) ) {
+      eosio_assert( st.can_recall, "issuer may not recall token" );
+   } else {
+      eosio_assert( false, "insufficient authority" );
+   }
+
+   from_acnts.modify( from, owner, [&]( auto& a ) {
+       a.balance.amount -= value.amount;
+   });
+}
+
+void token::add_balance( account_name owner, asset value, const currency_stats& st, account_name ram_payer )
+{
+   accounts to_acnts( _self, owner );
+   auto to = to_acnts.find( value.symbol );
+   if( to == to_acnts.end() ) {
+      eosio_assert( !st.enforce_whitelist, "can only transfer to white listed accounts" );
+      to_acnts.emplace( ram_payer, [&]( auto& a ){
+        a.balance = value;
+      });
+   } else {
+      eosio_assert( !st.enforce_whitelist || to->whitelist, "receiver requires whitelist by issuer" );
+      to_acnts.modify( to, 0, [&]( auto& a ) {
+        a.balance.amount += value.amount;
+      });
+   }
+}
+
+} /// namespace eosio
+
+EOSIO_ABI( eosio::token, (create)(issue)(transfer) )