work towards EOSIO/eos#1062

removed scope from transaction
renamed scope on action to account
added scopes to shard
fixed up scheduling and tests
fixed up eosioc

contracts/eoslib/transaction.hpp

@@ -26,8 +26,8 @@ namespace eosio {
    class action {
    public:
       template<typename Payload, typename ...Permissions>
-      action(const scope_name& scope, const action_name& name, const Payload& payload, Permissions... permissions )
-      :_scope(scope), _name(name), _num_permissions(0)
+      action(const account_name& account, const action_name& name, const Payload& payload, Permissions... permissions )
+      :_account(account), _name(name), _num_permissions(0)
       {
          assert(sizeof(payload) <= MaxPayloadSize, "Payload exceeds maximum size");
          memcpy(_payload, &payload, sizeof(payload));
@@ -36,16 +36,16 @@ namespace eosio {
       }
 
       template<typename Payload>
-      action(const scope_name& scope, const action_name& name, const Payload& payload )
-      : _scope(scope), _name(name),  _num_permissions(0)
+      action(const account_name& account, const action_name& name, const Payload& payload )
+      : _account(account), _name(name),  _num_permissions(0)
       {
          assert(sizeof(payload) <= MaxPayloadSize, "payload exceeds maximum size");
          _payload_size = sizeof(payload);
          memcpy(_payload, &payload, sizeof(payload));
       }
 
-      action(const scope_name& scope, const action_name& name)
-      :_scope(scope), _name(name),  _payload_size(0), _num_permissions(0)
+      action(const account_name& account, const action_name& name)
+      :_account(account), _name(name),  _payload_size(0), _num_permissions(0)
       {
       }
 
@@ -69,7 +69,7 @@ namespace eosio {
          send_inline(buffer, used);
       }
 
-      scope_name        _scope;
+      account_name      _account;
       action_name       _name;
       char              _payload[MaxPayloadSize];
       size_t            _payload_size;
@@ -77,12 +77,12 @@ namespace eosio {
       size_t            _num_permissions;
 
       static constexpr size_t max_buffer_size() {
-         return sizeof(size_t) + MaxPayloadSize + sizeof(size_t) + (MaxPermissions * sizeof(account_permission)) + sizeof(scope_name) + sizeof(action_name);
+         return sizeof(size_t) + MaxPayloadSize + sizeof(size_t) + (MaxPermissions * sizeof(account_permission)) + sizeof(account_name) + sizeof(action_name);
       }
 
       size_t pack( char *buffer, size_t buffer_size ) const {
          datastream<char*>  ds( buffer, buffer_size );
-         eosio::raw::pack(ds, _scope);
+         eosio::raw::pack(ds, _account);
          eosio::raw::pack(ds, _name);
          eosio::raw::pack(ds, _permissions, _num_permissions);
          eosio::raw::pack(ds, _payload, _payload_size);
@@ -102,47 +102,17 @@ namespace eosio {
       {
       }
 
-      template<size_t MaxActionsSize, size_t MaxWriteScopes, size_t MaxReadScopes>
+      template<size_t MaxActionsSize>
       friend class deferred_transaction;
    };
 
-   template<size_t MaxActionsSize = 256, size_t MaxWriteScopes = 2, size_t MaxReadScopes = 4>
+   template<size_t MaxActionsSize = 256>
    class transaction {
-   private:
-      static void insert_sorted_unique( scope_name scope, scope_name *scopes, size_t &size, const char* non_unique_message) {
-         size_t insert_index = 0;
-         for (; insert_index < size; insert_index++) {
-            assert(scopes[insert_index] != scope, non_unique_message);
-            if (scopes[insert_index] > scope) {
-               break;
-            }
-         }
-
-         if (insert_index != size) {
-            for (size_t idx = size; idx > insert_index; idx--) {
-               scopes[idx] = scopes[idx - 1];
-            }
-         }
-
-         scopes[insert_index] = scope;
-         size++;
-      }
-
    public:
       transaction(time expiration = now() + 60, region_id region = 0)
-      :_expiration(expiration),_region(region),_num_read_scopes(0), _num_write_scopes(0), _action_buffer_size(0), _num_actions(0)
+      :_expiration(expiration),_region(region), _action_buffer_size(0), _num_actions(0)
       {}
 
-      void add_read_scope(account_name scope) {
-         assert(_num_read_scopes < MaxReadScopes, "Too many Read Scopes");
-         insert_sorted_unique(scope, _read_scopes, _num_read_scopes, "Duplicate Read Scope");
-      }
-
-      void add_write_scope(account_name scope) {
-         assert(_num_write_scopes < MaxWriteScopes, "Too many Write Scopes");
-         insert_sorted_unique(scope, _write_scopes, _num_write_scopes, "Duplicate Write Scope");
-      }
-
       template<size_t ...ActArgs>
       void add_action(const action<ActArgs...> &act) {
          _action_buffer_size += act.pack(_action_buffer + _action_buffer_size, MaxActionsSize - _action_buffer_size );
@@ -157,8 +127,6 @@ namespace eosio {
 
       static constexpr size_t max_buffer_size() {
          return sizeof(time) + sizeof(region_id) + sizeof(uint16_t) + sizeof(uint32_t) +
-                sizeof(size_t) + (MaxReadScopes * sizeof(scope_name)) +
-                sizeof(size_t) + (MaxWriteScopes * sizeof(scope_name)) +
                 sizeof(size_t) + MaxActionsSize;
       }
 
@@ -168,8 +136,6 @@ namespace eosio {
          eosio::raw::pack(ds, _region);
          eosio::raw::pack(ds, uint16_t(0));
          eosio::raw::pack(ds, uint32_t(0));
-         eosio::raw::pack(ds, _read_scopes, _num_read_scopes);
-         eosio::raw::pack(ds, _write_scopes, _num_write_scopes);
          eosio::raw::pack(ds, unsigned_int(_num_actions));
          ds.write(_action_buffer, _action_buffer_size);
          return ds.tellp();
@@ -191,12 +157,6 @@ namespace eosio {
       uint16_t        _ref_block_num;
       uint32_t        _ref_block_id;
 
-      scope_name      _read_scopes[MaxReadScopes];
-      size_t          _num_read_scopes;
-
-      scope_name      _write_scopes[MaxWriteScopes];
-      size_t          _num_write_scopes;
-
       char            _action_buffer[MaxActionsSize];
       size_t          _action_buffer_size;
 
@@ -206,7 +166,7 @@ namespace eosio {
       template<size_t MaxPayloadSize, size_t MaxPermissions>
       static size_t unpack_action(char* buffer, size_t size, size_t offset, action<MaxPayloadSize, MaxPermissions> &act) {
          datastream<char*> ds(buffer + offset, size - offset);
-         eosio::raw::unpack(ds, act._scope);
+         eosio::raw::unpack(ds, act._account);
          eosio::raw::unpack(ds, act._name);
          eosio::raw::unpack(ds, act._permissions, act._num_permissions, MaxPermissions);
          eosio::raw::unpack(ds, act._payload, act._payload_size, MaxPayloadSize);
@@ -214,15 +174,15 @@ namespace eosio {
       }
    };
 
-   template<size_t MaxActionsSize = 256, size_t MaxWriteScopes = 2, size_t MaxReadScopes = 4>
-   class deferred_transaction : public transaction<MaxActionsSize, MaxWriteScopes, MaxReadScopes> {
+   template<size_t MaxActionsSize = 256>
+   class deferred_transaction : public transaction<MaxActionsSize> {
       public:
          uint32_t     _sender_id;
          account_name _sender;
          time         _delay_until;
 
          static constexpr size_t max_buffer_size() {
-            return sizeof(uint32_t) + sizeof(account_name) + sizeof(time) + transaction<MaxActionsSize, MaxWriteScopes, MaxReadScopes>::max_buffer_size();
+            return sizeof(uint32_t) + sizeof(account_name) + sizeof(time) + transaction<MaxActionsSize>::max_buffer_size();
          }
 
          template< size_t MaxPayloadSize = 64, size_t MaxPermissions = 2 >
@@ -238,8 +198,6 @@ namespace eosio {
             eosio::raw::unpack(ds, result._region);
             eosio::raw::unpack(ds, result._ref_block_num);
             eosio::raw::unpack(ds, result._ref_block_id);
-            eosio::raw::unpack(ds, result._read_scopes, result._num_read_scopes, MaxReadScopes);
-            eosio::raw::unpack(ds, result._write_scopes, result._num_write_scopes, MaxWriteScopes);
             unsigned_int packed_num_actions;
             eosio::raw::unpack(ds, packed_num_actions);
             result._num_actions = packed_num_actions.value;
@@ -249,7 +207,7 @@ namespace eosio {
             size_t action_offset = 0;
             action<MaxPayloadSize, MaxPermissions> temp;
             for (size_t idx; idx < result._num_actions; idx++) {
-               action_offset = transaction<MaxActionsSize, MaxWriteScopes, MaxReadScopes>::unpack_action(temp_actions, temp_action_size, action_offset, temp);
+               action_offset = transaction<MaxActionsSize>::unpack_action(temp_actions, temp_action_size, action_offset, temp);
             }
             assert(action_offset <= MaxActionsSize, "Actions are too large to parse");
             result._action_buffer_size = action_offset;

contracts/proxy/proxy.cpp

@@ -30,8 +30,6 @@ namespace proxy {
 
          transaction<> out;
          out.add_action(out_act);
-         out.add_write_scope(self);
-         out.add_write_scope(code_config.owner);
          out.send(id, now() + code_config.delay);
       }
    }

libraries/chain/apply_context.cpp

@@ -11,7 +11,7 @@ namespace eosio { namespace chain {
 void apply_context::exec_one()
 {
    try {
-      auto native = mutable_controller.find_apply_handler(receiver, act.scope, act.name);
+      auto native = mutable_controller.find_apply_handler(receiver, act.account, act.name);
       if (native) {
          (*native)(*this);
       } else {
@@ -27,12 +27,19 @@ void apply_context::exec_one()
             wasm.apply(code, *this);
          }
       }
+
+      if (results.read_scopes.empty()) {
+         std::sort(results.read_scopes.begin(), results.read_scopes.end());
+      }
+      if (results.write_scopes.empty()) {
+         std::sort(results.write_scopes.begin(), results.write_scopes.end());
+      }
    } FC_CAPTURE_AND_RETHROW((_pending_console_output.str()));
 
    // create a receipt for this
    vector<data_access_info> data_access;
-   data_access.reserve(trx.write_scope.size() + trx.read_scope.size());
-   for (const auto& scope: trx.write_scope) {
+   data_access.reserve(results.write_scopes.size() + results.read_scopes.size());
+   for (const auto& scope: results.write_scopes) {
       auto key = boost::make_tuple(scope, receiver);
       const auto& scope_sequence = mutable_controller.get_database().find<scope_sequence_object, by_scope_receiver>(key);
       if (scope_sequence == nullptr) {
@@ -54,7 +61,7 @@ void apply_context::exec_one()
       }
    }
 
-   for (const auto& scope: trx.read_scope) {
+   for (const auto& scope: results.read_scopes) {
       auto key = boost::make_tuple(scope, receiver);
       const auto& scope_sequence = mutable_controller.get_database().find<scope_sequence_object, by_scope_receiver>(key);
       if (scope_sequence == nullptr) {
@@ -70,7 +77,7 @@ void apply_context::exec_one()
 
 void apply_context::exec()
 {
-   _notified.push_back(act.scope);
+   _notified.push_back(act.account);
 
    for( uint32_t i = 0; i < _notified.size(); ++i ) {
       receiver = _notified[i];
@@ -78,7 +85,7 @@ void apply_context::exec()
    }
 
    for( uint32_t i = 0; i < _inline_actions.size(); ++i ) {
-      apply_context ncontext( mutable_controller, mutable_db, trx, _inline_actions[i], published, sender);
+      apply_context ncontext( mutable_controller, mutable_db, _inline_actions[i], trx_meta);
       ncontext.exec();
       append_results(move(ncontext.results));
    }
@@ -100,28 +107,34 @@ void apply_context::require_authorization(const account_name& account,
               ("account",account)("permission",permission) );
 }
 
-void apply_context::require_write_scope(const account_name& account)const {
-   for( const auto& s : trx.write_scope )
-      if( s == account ) return;
-
-   if( trx.write_scope.size() == 1 && trx.write_scope.front() == config::eosio_all_scope )
-      return;
+static bool scopes_contain(const vector<scope_name>& scopes, const scope_name& scope) {
+   for (const auto &s : scopes) {
+      if (s == scope) {
+         return true;
+      }
+   }
 
-   EOS_ASSERT( false, tx_missing_write_scope, "missing write scope ${account}", 
-               ("account",account) );
+   return false;
 }
 
-void apply_context::require_read_scope(const account_name& account)const {
-   for( const auto& s : trx.write_scope )
-      if( s == account ) return;
-   for( const auto& s : trx.read_scope )
-      if( s == account ) return;
+void apply_context::require_write_scope(const scope_name& scope) {
+   if (trx_meta.allowed_write_scopes) {
+      EOS_ASSERT( scopes_contain(**trx_meta.allowed_write_scopes, scope), tx_missing_write_scope, "missing write scope ${scope}", ("scope",scope) );
+   }
 
-   if( trx.write_scope.size() == 1 && trx.write_scope.front() == config::eosio_all_scope )
-      return;
+   if (!scopes_contain(results.write_scopes, scope)) {
+      results.write_scopes.emplace_back(scope);
+   }
+}
 
-   EOS_ASSERT( false, tx_missing_read_scope, "missing read scope ${account}", 
-               ("account",account) );
+void apply_context::require_read_scope(const scope_name& scope) {
+   if (trx_meta.allowed_read_scopes) {
+      EOS_ASSERT( scopes_contain(**trx_meta.allowed_read_scopes, scope), tx_missing_read_scope, "missing read scope ${scope}", ("scope",scope) );
+   }
+
+   if (!scopes_contain(results.read_scopes, scope)) {
+      results.read_scopes.emplace_back(scope);
+   }
 }
 
 bool apply_context::has_recipient( account_name code )const {
@@ -161,8 +174,6 @@ void apply_context::execute_deferred( deferred_transaction&& trx ) {
          controller.check_authorization(trx.actions, flat_set<public_key_type>(), false, {receiver});
       }
 
-      controller.validate_scope( trx );
-
       trx.sender = receiver; //  "Attempting to send from another account"
       trx.set_reference_block(controller.head_block_id());
 

libraries/chain/block.cpp

@@ -67,7 +67,7 @@ namespace eosio { namespace chain {
             digest_type::encoder enc;
 
             fc::raw::pack(enc, at.receiver);
-            fc::raw::pack(enc, at.act.scope);
+            fc::raw::pack(enc, at.act.account);
             fc::raw::pack(enc, at.act.name);
             fc::raw::pack(enc, at.act.data);
             fc::raw::pack(enc, at.region_id);

libraries/chain/chain_controller.cpp

@@ -285,18 +285,7 @@ transaction_trace chain_controller::_push_transaction( transaction_metadata& dat
    // for now apply the transaction serially but schedule it according to those invariants
    validate_referenced_accounts(trx);
 
-   auto shardnum = 0;
    auto cyclenum = _pending_block->regions.back().cycles_summary.size() - 1;
-   bool new_cycle = false;
-
-   if (!force_new_cycle) {
-      shardnum = _pending_cycle.schedule( trx );
-   }
-   if (shardnum == -1 || force_new_cycle) {
-      cyclenum += 1;
-      shardnum = 0;
-      new_cycle = true;
-   }
 
    /// TODO: move _pending_cycle into db so that it can be undone if transation fails, for now we will apply
    /// the transaction first so that there is nothing to undo... this only works because things are currently
@@ -304,24 +293,17 @@ transaction_trace chain_controller::_push_transaction( transaction_metadata& dat
    // set cycle, shard, region etc
    data.region_id = 0;
    data.cycle_index = cyclenum;
-   data.shard_index = shardnum;
+   data.shard_index = 0;
    auto result = _apply_transaction( data );
 
-   if( new_cycle ) { /// schedule conflict start new cycle
-      _finalize_pending_cycle();
-      _start_pending_cycle();
-      FC_ASSERT(_pending_cycle.schedule( trx ) == shardnum);
-   }
-
-
    auto& bcycle = _pending_block->regions.back().cycles_summary.back();
-   if( shardnum >= bcycle.size() ) {
-      _start_pending_shard();
-   }
+   auto& bshard = bcycle.front();
 
+   copy_append_names(bshard.read_scopes, result.read_scopes);
+   copy_append_names(bshard.write_scopes, result.write_scopes);
+   bshard.transactions.emplace_back( result );
 
-   bcycle.at(shardnum).emplace_back( result );
-   _pending_cycle_trace->shard_traces.at(shardnum).append(result);
+   _pending_cycle_trace->shard_traces.at(0).append(result);
 
    // The transaction applied successfully. Merge its changes into the pending block session.
    temp_session.squash();
@@ -346,7 +328,6 @@ void chain_controller::_start_pending_block()
  */
 void chain_controller::_start_pending_cycle() {
    _pending_block->regions.back().cycles_summary.resize( _pending_block->regions[0].cycles_summary.size() + 1 );
-   _pending_cycle = pending_cycle_state();
    _pending_cycle_trace = cycle_trace();
    _start_pending_shard();
 
@@ -409,10 +390,10 @@ void chain_controller::_apply_cycle_trace( const cycle_trace& res )
          for (const auto &ar : tr.action_traces) {
             if (!ar.console.empty()) {
                auto prefix = fc::format_string(
-                  "[(${s},${a})->${r}]",
+                  "[(${a},${n})->${r}]",
                   fc::mutable_variant_object()
-                     ("s", ar.act.scope)
-                     ("a", ar.act.name)
+                     ("a", ar.act.account)
+                     ("n", ar.act.name)
                      ("r", ar.receiver));
                std::cerr << prefix << ": CONSOLE OUTPUT BEGIN =====================" << std::endl;
                std::cerr << ar.console;
@@ -598,7 +579,7 @@ void chain_controller::__apply_block(const signed_block& next_block)
          uint32_t shard_index = 0;
          for (const auto& shard: cycle) {
             shard_trace s_trace;
-            for (const auto& receipt : shard) {
+            for (const auto& receipt : shard.transactions) {
                 auto make_metadata = [&](){
                   auto itr = trx_index.find(receipt.id);
                   if( itr != trx_index.end() ) {
@@ -614,6 +595,8 @@ void chain_controller::__apply_block(const signed_block& next_block)
                mtrx.region_id = r.region;
                mtrx.cycle_index = cycle_index;
                mtrx.shard_index = shard_index;
+               mtrx.allowed_read_scopes = &shard.read_scopes;
+               mtrx.allowed_write_scopes = &shard.write_scopes;
 
                s_trace.transaction_traces.emplace_back(_apply_transaction(mtrx));
 
@@ -676,7 +659,7 @@ void chain_controller::check_authorization( const vector<action>& actions,
       for( const auto& declared_auth : act.authorization ) {
 
          // check a minimum permission if one is set, otherwise assume the contract code will validate
-         auto min_permission_name = lookup_minimum_permission(declared_auth.actor, act.scope, act.name);
+         auto min_permission_name = lookup_minimum_permission(declared_auth.actor, act.account, act.name);
          if (min_permission_name) {
             const auto& min_permission = _db.get<permission_object, by_owner>(boost::make_tuple(declared_auth.actor, *min_permission_name));
 
@@ -709,38 +692,6 @@ void chain_controller::check_transaction_authorization(const signed_transaction&
    check_authorization( trx.actions, trx.get_signature_keys( chain_id_type{} ), allow_unused_signatures );
 }
 
-void chain_controller::validate_scope( const transaction& trx )const {
-   for( uint32_t i = 1; i < trx.read_scope.size(); ++i ) {
-      EOS_ASSERT( trx.read_scope[i-1] < trx.read_scope[i], transaction_exception, 
-                  "Scopes must be sorted and unique" );
-   }
-   for( uint32_t i = 1; i < trx.write_scope.size(); ++i ) {
-      EOS_ASSERT( trx.write_scope[i-1] < trx.write_scope[i], transaction_exception, 
-                  "Scopes must be sorted and unique" );
-   }
-
-   /**
-    * We need to verify that all authorizing accounts have write scope because write
-    * access is necessary to update bandwidth usage.
-    */
-   ///{
-   auto has_write_scope = [&]( auto s ) { return std::binary_search( trx.write_scope.begin(),
-                                                                     trx.write_scope.end(),
-                                                                     s ); };
-   for( const auto& a : trx.actions ) {
-      for( const auto& auth : a.authorization ) {
-         FC_ASSERT( has_write_scope( auth.actor ), "write scope of the authorizing account is required" );
-      }
-   }
-   ///@}
-
-   vector<account_name> intersection;
-   std::set_intersection( trx.read_scope.begin(), trx.read_scope.end(),
-                          trx.write_scope.begin(), trx.write_scope.end(),
-                          std::back_inserter(intersection) );
-   FC_ASSERT( intersection.size() == 0, "a transaction may not redeclare scope in readscope" );
-}
-
 optional<permission_name> chain_controller::lookup_minimum_permission(account_name authorizer_account,
                                                                     account_name scope,
                                                                     action_name act_name) const {
@@ -797,13 +748,8 @@ void chain_controller::validate_tapos(const transaction& trx)const {
 
 void chain_controller::validate_referenced_accounts( const transaction& trx )const 
 { try { 
-   for( const auto& scope : trx.read_scope )
-      require_scope(scope);
-   for( const auto& scope : trx.write_scope )
-      require_scope(scope);
-
    for( const auto& act : trx.actions ) {
-      require_account(act.scope);
+      require_account(act.account);
       for (const auto& auth : act.authorization )
          require_account(auth.actor);
    }
@@ -1055,7 +1001,6 @@ void chain_controller::_initialize_chain(contracts::chain_initializer& starter)
          auto acts = starter.prepare_database(*this, _db);
 
          transaction genesis_setup_transaction;
-         genesis_setup_transaction.write_scope = { config::eosio_all_scope };
          genesis_setup_transaction.actions = move(acts);
 
          ilog( "applying genesis transaction" );
@@ -1371,11 +1316,13 @@ static void log_handled_exceptions(const transaction& trx) {
 transaction_trace chain_controller::__apply_transaction( transaction_metadata& meta ) {
    transaction_trace result(meta.id);
    for (const auto &act : meta.trx.actions) {
-      apply_context context(*this, _db, meta.trx, act, meta.published, meta.sender);
+      apply_context context(*this, _db, act, meta);
       context.exec();
       fc::move_append(result.action_traces, std::move(context.results.applied_actions));
       fc::move_append(result.deferred_transactions, std::move(context.results.generated_transactions));
       fc::move_append(result.canceled_deferred, std::move(context.results.canceled_deferred));
+      move_append_names(result.read_scopes, std::forward<vector<scope_name>>(context.results.read_scopes));
+      move_append_names(result.write_scopes, std::forward<vector<scope_name>>(context.results.write_scopes));
    }
 
    uint32_t act_usage = result.action_traces.size();
@@ -1384,7 +1331,7 @@ transaction_trace chain_controller::__apply_transaction( transaction_metadata& m
       at.region_id = meta.region_id;
       at.cycle_index = meta.cycle_index;
       if (at.receiver == config::system_account_name &&
-          at.act.scope == config::system_account_name &&
+          at.act.account == config::system_account_name &&
           at.act.name == N(setcode)) {
          act_usage += config::setcode_act_usage;
       }
@@ -1418,18 +1365,18 @@ transaction_trace chain_controller::_apply_error( transaction_metadata& meta ) {
    result.status = transaction_trace::soft_fail;
 
    transaction etrx;
-   etrx.read_scope = meta.trx.read_scope;
-   etrx.write_scope = meta.trx.write_scope;
    etrx.actions.emplace_back(vector<permission_level>{{meta.sender_id,config::active_name}},
                              contracts::onerror(meta.generated_data, meta.generated_data + meta.generated_size) );
 
    try {
       auto temp_session = _db.start_undo_session(true);
 
-      apply_context context(*this, _db, etrx, etrx.actions.front(), meta.published, meta.sender);
+      apply_context context(*this, _db, etrx.actions.front(), meta);
       context.exec();
       fc::move_append(result.action_traces, std::move(context.results.applied_actions));
       fc::move_append(result.deferred_transactions, std::move(context.results.generated_transactions));
+      move_append_names(result.read_scopes, std::forward<vector<scope_name>>(context.results.read_scopes));
+      move_append_names(result.write_scopes, std::forward<vector<scope_name>>(context.results.write_scopes));
 
       uint32_t act_usage = result.action_traces.size();
 

libraries/chain/contracts/eosio_contract.cpp

@@ -554,8 +554,8 @@ void apply_eosio_nonce(apply_context&) {
 }
 
 void apply_eosio_onerror(apply_context& context) {
-   assert(context.sender);
-   context.require_recipient(*context.sender);
+   assert(context.trx_meta.sender);
+   context.require_recipient(*context.trx_meta.sender);
 }
 
 static const abi_serializer& get_abi_serializer() {
@@ -676,7 +676,6 @@ void apply_eosio_postrecovery(apply_context& context) {
    dtrx.execute_after = context.controller.head_block_time() + delay_lock;
    dtrx.set_reference_block(context.controller.head_block_id());
    dtrx.expiration = dtrx.execute_after + fc::seconds(60);
-   dtrx.write_scope = sort_names({account, config::eosio_auth_scope, config::system_account_name});
    dtrx.actions.emplace_back(vector<permission_level>{{account,config::active_name}},
                              passrecovery { account });
 
@@ -700,7 +699,7 @@ void apply_eosio_passrecovery(apply_context& context) {
    const auto& account = pass_act.account;
 
    // ensure this is only processed if it is a deferred transaction from the system account
-   FC_ASSERT(context.sender && *context.sender == config::system_account_name);
+   FC_ASSERT(context.trx_meta.sender && *context.trx_meta.sender == config::system_account_name);
    context.require_authorization(account);
 
    auto maybe_recovery = get_pending_recovery(context, account);

libraries/chain/include/eosio/chain/apply_context.hpp

@@ -17,11 +17,10 @@ class chain_controller;
 class apply_context {
 
    public:
-      apply_context(chain_controller& con, chainbase::database& db,
-                    const transaction& t, const action& a, const time_point& published, const optional<account_name>& sender)
-      :controller(con), db(db), trx(t), act(a), mutable_controller(con),
+      apply_context(chain_controller& con, chainbase::database& db, const action& a, const transaction_metadata& trx_meta)
+      :controller(con), db(db), act(a), mutable_controller(con),
        mutable_db(db), used_authorizations(act.authorization.size(), false),
-       published(published), sender(sender) {}
+       trx_meta(trx_meta) {}
 
       void exec();
 
@@ -75,8 +74,8 @@ class apply_context {
        */
       void require_authorization(const account_name& account)const;
       void require_authorization(const account_name& account, const permission_name& permission)const;
-      void require_write_scope(const account_name& account)const;
-      void require_read_scope(const account_name& account)const;
+      void require_write_scope(const account_name& account);
+      void require_read_scope(const account_name& account);
 
       /**
        * Requires that the current action be delivered to account
@@ -96,7 +95,6 @@ class apply_context {
 
       const chain_controller&       controller;
       const chainbase::database&    db;  ///< database where state is stored
-      const transaction&            trx; ///< used to gather the valid read/write scopes
       const action&                 act; ///< message being applied
       account_name                  receiver; ///< the code that is currently running
 
@@ -107,10 +105,9 @@ class apply_context {
       ///< Parallel to act.authorization; tracks which permissions have been used while processing the message
       vector<bool> used_authorizations;
 
-      const time_point&             published;
-      const optional<account_name>& sender;
+      const transaction_metadata&   trx_meta;
 
-      ///< pending transaction construction
+   ///< pending transaction construction
      /*
       typedef uint32_t pending_transaction_handle;
       struct pending_transaction : public transaction {
@@ -159,6 +156,9 @@ class apply_context {
          vector<action_trace>          applied_actions;
          vector<deferred_transaction>  generated_transactions;
          vector<deferred_reference>    canceled_deferred;
+         vector<scope_name>            read_scopes;
+         vector<scope_name>            write_scopes;
+
       };
 
       apply_results results;
@@ -184,6 +184,8 @@ class apply_context {
          fc::move_append(results.applied_actions, move(other.applied_actions));
          fc::move_append(results.generated_transactions, move(other.generated_transactions));
          fc::move_append(results.canceled_deferred, move(other.canceled_deferred));
+         move_append_names(results.read_scopes, forward<vector<scope_name>>(other.read_scopes));
+         move_append_names(results.write_scopes, forward<vector<scope_name>>(other.write_scopes));
       }
 
       void exec_one();

libraries/chain/include/eosio/chain/block.hpp

@@ -49,8 +49,14 @@ namespace eosio { namespace chain {
    };
 
 
-   typedef vector<transaction_receipt>   shard; /// new or generated transactions
-   typedef vector<shard>                 cycle;
+   struct shard_summary {
+      vector<scope_name>            read_scopes;
+      vector<scope_name>            write_scopes;
+      vector<transaction_receipt>   transactions; /// new or generated transactions
+   };
+
+   typedef vector<shard_summary>    cycle;
+
    struct region_summary {
       uint16_t region = 0;
       vector<cycle>    cycles_summary;
@@ -140,6 +146,7 @@ FC_REFLECT(eosio::chain::block_header, (previous)(timestamp)
            (producer)(new_producers))
 
 FC_REFLECT_DERIVED(eosio::chain::signed_block_header, (eosio::chain::block_header), (producer_signature))
+FC_REFLECT( eosio::chain::shard_summary, (read_scopes)(write_scopes)(transactions))
 FC_REFLECT( eosio::chain::region_summary, (region)(cycles_summary) )
 FC_REFLECT_DERIVED(eosio::chain::signed_block_summary, (eosio::chain::signed_block_header), (regions))
 FC_REFLECT_DERIVED(eosio::chain::signed_block, (eosio::chain::signed_block_summary), (input_transactions))

libraries/chain/include/eosio/chain/chain_controller.hpp

@@ -19,7 +19,6 @@
 #include <eosio/chain/exceptions.hpp>
 #include <eosio/chain/contracts/genesis_state.hpp>
 #include <eosio/chain/wasm_interface.hpp>
-#include <eosio/chain/pending_cycle_state.hpp>
 
 #include <fc/log/logger.hpp>
 
@@ -354,7 +353,6 @@ namespace eosio { namespace chain {
          try {
             EOS_ASSERT(trx.messages.size() > 0, transaction_exception, "A transaction must have at least one message");
 
-            validate_scope(trx);
             validate_expiration(trx);
             validate_uniqueness(trx);
             validate_tapos(trx);
@@ -366,7 +364,6 @@ namespace eosio { namespace chain {
          void validate_tapos(const transaction& trx)const;
          void validate_referenced_accounts(const transaction& trx)const;
          void validate_expiration(const transaction& trx) const;
-         void validate_scope(const transaction& trx) const;
          void record_transaction(const transaction& trx);
          /// @}
 
@@ -421,7 +418,6 @@ namespace eosio { namespace chain {
          optional<signed_block>           _pending_block;
          optional<block_trace>            _pending_block_trace;
          uint32_t                         _pending_transaction_count = 0; 
-         pending_cycle_state              _pending_cycle;
          optional<cycle_trace>            _pending_cycle_trace;
 
          bool                             _currently_applying_block = false;

libraries/chain/include/eosio/chain/contracts/abi_serializer.hpp

@@ -213,11 +213,11 @@ namespace impl {
          void add( mutable_variant_object& vo, const char* name, const action& v )const
          {
             mutable_variant_object mvo;
-            mvo("scope", v.scope);
+            mvo("account", v.account);
             mvo("name", v.name);
             mvo("authorization", v.authorization);
 
-            auto abi = _resolver(v.scope);
+            auto abi = _resolver(v.account);
             if (abi.valid()) {
                auto type = abi->get_action_type(v.name);
                mvo("data", abi->binary_to_variant(type, v.data));
@@ -315,9 +315,9 @@ namespace impl {
          void extract( const variant& v, action& act )const
          {
             const variant_object& vo = v.get_object();
-            FC_ASSERT(vo.contains("scope"));
+            FC_ASSERT(vo.contains("account"));
             FC_ASSERT(vo.contains("name"));
-            from_variant(vo["scope"], act.scope);
+            from_variant(vo["account"], act.account);
             from_variant(vo["name"], act.name);
 
             if (vo.contains("authorization")) {
@@ -329,7 +329,7 @@ namespace impl {
                if( data.is_string() ) {
                   from_variant(data, act.data);
                } else if ( data.is_object() ) {
-                  auto abi = _resolver(act.scope);
+                  auto abi = _resolver(act.account);
                   if (abi.valid()) {
                      auto type = abi->get_action_type(act.name);
                      act.data = std::move(abi->variant_to_binary(type, data));
@@ -346,7 +346,7 @@ namespace impl {
                }
             }
 
-            FC_ASSERT(!act.data.empty(), "Failed to deserialize data for ${scope}:${name}", ("scope", act.scope)("name", act.name));
+            FC_ASSERT(!act.data.empty(), "Failed to deserialize data for ${account}:${name}", ("account", act.account)("name", act.name));
          }
 
 

libraries/chain/include/eosio/chain/contracts/types.hpp

@@ -109,7 +109,7 @@ struct transfer {
    uint64         amount;
    string         memo;
 
-   static name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -128,7 +128,7 @@ struct lock {
    account_name                      to;
    share_type                        amount;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -146,7 +146,7 @@ struct unlock {
    account_name                      account;
    share_type                        amount;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -164,7 +164,7 @@ struct claim {
    account_name                      account;
    share_type                        amount;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -181,7 +181,7 @@ struct newaccount {
    authority                        recovery;
    asset                            deposit;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -196,7 +196,7 @@ struct setcode {
    uint8                            vmversion;
    bytes                            code;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -209,7 +209,7 @@ struct setabi {
    account_name                     account;
    abi_def                          abi;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -228,7 +228,7 @@ struct setproducer {
    public_key_type         key;
    chain_config            configuration;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -247,7 +247,7 @@ struct okproducer {
    account_name                      producer;
    int8_t                            approve;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -265,7 +265,7 @@ struct setproxy {
    account_name                      stakeholder;
    account_name                      proxy;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -280,7 +280,7 @@ struct updateauth {
    permission_name                   parent;
    authority                         data;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -298,7 +298,7 @@ struct deleteauth {
    account_name                      account;
    permission_name                   permission;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -318,7 +318,7 @@ struct linkauth {
    action_name                       type;
    permission_name                   requirement;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -337,7 +337,7 @@ struct unlinkauth {
    account_name                      code;
    action_name                       type;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -349,7 +349,7 @@ struct unlinkauth {
 struct onerror : bytes {
    using bytes::bytes;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -363,7 +363,7 @@ struct postrecovery {
    authority          data;
    string             memo;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -375,7 +375,7 @@ struct postrecovery {
 struct passrecovery {
    account_name   account;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -388,7 +388,7 @@ struct passrecovery {
 struct vetorecovery {
    account_name   account;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 
@@ -401,7 +401,7 @@ using nonce_type = name;
 struct nonce {
    nonce_type value;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return config::system_account_name;
    }
 

libraries/chain/include/eosio/chain/name.hpp

@@ -100,6 +100,36 @@ namespace eosio { namespace chain {
       return names;
    }
 
+   /**
+    * append incoming scopes to a vector of scopes maintaining the invariants that the final
+    * vector is sorted and unique
+    *
+    * @param scopes
+    * @param incoming
+    */
+   inline void move_append_names(std::vector<name>& scopes, std::vector<name>&& incoming) {
+      fc::move_append(scopes, move(incoming));
+
+      if (!scopes.empty()) {
+         sort_names(std::forward<std::vector<name>>(scopes));
+      }
+   }
+
+   /**
+    * append incoming scopes to a vector of scopes maintaining the invariants that the final
+    * vector is sorted and unique
+    *
+    * @param scopes
+    * @param incoming
+    */
+   inline void copy_append_names(std::vector<name>& scopes, const std::vector<name>& incoming) {
+      scopes.insert(scopes.end(), incoming.begin(), incoming.end());
+
+      if (!scopes.empty()) {
+         sort_names(std::forward<std::vector<name>>(scopes));
+      }
+   }
+
 } } // eosio::chain
 
 namespace fc {

libraries/chain/include/eosio/chain/pending_cycle_state.hpp

-#pragma once 
-#include <eosio/chain/transaction.hpp>
-
-namespace eosio { namespace chain {
-
-   struct pending_cycle_state : cycle_trace {
-      set<scope_name>          read_scopes;
-      map<scope_name,uint32_t> write_scope_to_shard;
-
-      /**
-       *  @return the shard number this transation goes in or (-1) if it
-       *  cannot go on any shard due to conflict
-       */
-      uint32_t schedule( const transaction& trx ) {
-         uint32_t current_shard = -1;
-
-         for( const auto& ws : trx.write_scope ) {
-            if( read_scopes.find(ws) != read_scopes.end() )
-               return -1;
-            
-            auto itr = write_scope_to_shard.find(ws);
-            if( itr != write_scope_to_shard.end() ) {
-               if( current_shard == -1 ) {
-                  current_shard = itr->second;
-                  continue;
-               }
-               if( current_shard != itr->second )
-                  return -1;  /// conflict detected
-            }
-         }
-
-         for( const auto& rs : trx.read_scope )
-         {
-            auto itr = write_scope_to_shard.find(rs);
-            if( itr != write_scope_to_shard.end() ) {
-               if( current_shard == -1 ) {
-                  current_shard = itr->second;
-                  continue;
-               }
-               if( current_shard != itr->second )
-                   return -1; /// schedule conflict
-               current_shard = itr->second;
-            }
-         }
-
-         if( current_shard == -1 ) {
-            shards.resize( shards.size()+1 );
-            current_shard = shards.size() - 1;
-         }
-
-         for( auto ws : trx.write_scope )
-         {
-            shards.back().write_scopes.insert( ws );
-            write_scope_to_shard[ws] = current_shard;
-         }
-
-         for( auto rs : trx.read_scope )
-            read_scopes.insert(rs);
-
-         return current_shard;
-      } /// schedule
-
-      struct pending_shard {
-         set<scope_name> write_scopes;
-      };
-
-      vector<pending_shard> shards;
-   };
-
-
-} } /// eosio::chain

libraries/chain/include/eosio/chain/transaction.hpp

@@ -34,7 +34,7 @@ namespace eosio { namespace chain {
     *  were properly declared when it executes.
     */
    struct action {
-      scope_name                 scope;
+      account_name               account;
       action_name                name;
       vector<permission_level>   authorization;
       vector<char>               data;
@@ -43,7 +43,7 @@ namespace eosio { namespace chain {
 
       template<typename T, std::enable_if_t<std::is_base_of<bytes, T>::value, int> = 1>
       action( vector<permission_level> auth, const T& value ) {
-         scope       = T::get_scope();
+         account     = T::get_account();
          name        = T::get_name();
          authorization = move(auth);
          data.assign(value.data(), value.data() + value.size());
@@ -51,7 +51,7 @@ namespace eosio { namespace chain {
 
       template<typename T, std::enable_if_t<!std::is_base_of<bytes, T>::value, int> = 1>
       action( vector<permission_level> auth, const T& value ) {
-         scope       = T::get_scope();
+         account     = T::get_account();
          name        = T::get_name();
          authorization = move(auth);
          data        = fc::raw::pack(value);
@@ -59,8 +59,8 @@ namespace eosio { namespace chain {
 
       template<typename T>
       T as()const {
-         FC_ASSERT( scope == T::get_scope() );
-         FC_ASSERT( name  == T::get_name()  );
+         FC_ASSERT( account == T::get_account() );
+         FC_ASSERT( name == T::get_name()  );
          return fc::raw::unpack<T>(data);
       }
    };
@@ -128,8 +128,6 @@ namespace eosio { namespace chain {
     *  read and write scopes.
     */
    struct transaction : public transaction_header {
-      vector<account_name>   read_scope;
-      vector<account_name>   write_scope;
       vector<action>         actions;
 
       transaction_id_type id()const;
@@ -195,8 +193,11 @@ namespace eosio { namespace chain {
       vector<action_trace>          action_traces;
       vector<deferred_transaction>  deferred_transactions;
       vector<deferred_reference>    canceled_deferred;
+      vector<scope_name>            read_scopes;
+      vector<scope_name>            write_scopes;
    };
 
+
    struct transaction_metadata {
       transaction_metadata( const transaction& t )
       :trx(t)
@@ -230,14 +231,18 @@ namespace eosio { namespace chain {
       uint32_t                              sender_id = 0;
       const char*                           generated_data = nullptr;
       size_t                                generated_size = 0;
+
+      // scheduling related information
+      optional<const vector<scope_name>*>   allowed_read_scopes;
+      optional<const vector<scope_name>*>   allowed_write_scopes;
    };
 
 } } // eosio::chain
 
 FC_REFLECT( eosio::chain::permission_level, (actor)(permission) )
-FC_REFLECT( eosio::chain::action, (scope)(name)(authorization)(data) )
+FC_REFLECT( eosio::chain::action, (account)(name)(authorization)(data) )
 FC_REFLECT( eosio::chain::transaction_header, (expiration)(region)(ref_block_num)(ref_block_prefix) )
-FC_REFLECT_DERIVED( eosio::chain::transaction, (eosio::chain::transaction_header), (read_scope)(write_scope)(actions) )
+FC_REFLECT_DERIVED( eosio::chain::transaction, (eosio::chain::transaction_header), (actions) )
 FC_REFLECT_DERIVED( eosio::chain::signed_transaction, (eosio::chain::transaction), (signatures) )
 FC_REFLECT_DERIVED( eosio::chain::deferred_transaction, (eosio::chain::transaction), (sender_id)(sender)(execute_after) )
 FC_REFLECT_ENUM( eosio::chain::data_access_info::access_type, (read)(write))
@@ -245,7 +250,7 @@ FC_REFLECT( eosio::chain::data_access_info, (type)(scope)(sequence))
 FC_REFLECT( eosio::chain::action_trace, (receiver)(act)(console)(region_id)(cycle_index)(data_access) )
 FC_REFLECT( eosio::chain::transaction_receipt, (status)(id))
 FC_REFLECT_ENUM( eosio::chain::transaction_receipt::status_enum, (executed)(soft_fail)(hard_fail))
-FC_REFLECT_DERIVED( eosio::chain::transaction_trace, (eosio::chain::transaction_receipt), (action_traces)(deferred_transactions) )
+FC_REFLECT_DERIVED( eosio::chain::transaction_trace, (eosio::chain::transaction_receipt), (action_traces)(deferred_transactions)(read_scopes)(write_scopes) )
 
 
 

libraries/chain/wasm_interface.cpp

@@ -406,10 +406,10 @@ namespace eosio { namespace chain {
    }
 
    void wasm_interface::apply( wasm_cache::entry& code, apply_context& context ) {
-      if (context.act.scope == config::system_account_name && context.act.name == N(setcode)) {
+      if (context.act.account == config::system_account_name && context.act.name == N(setcode)) {
          my->call("init", {}, code, context);
       } else {
-         vector<Value> args = {Value(uint64_t(context.act.scope)),
+         vector<Value> args = {Value(uint64_t(context.act.account)),
                                Value(uint64_t(context.act.name))};
          my->call("apply", args, code, context);
       }
@@ -664,12 +664,12 @@ class action_api : public context_aware_api {
       }
 
       fc::time_point_sec publication_time() {
-         return context.published;
+         return context.trx_meta.published;
       }
 
       name current_sender() {
-         if (context.sender) {
-            return *context.sender;
+         if (context.trx_meta.sender) {
+            return *context.trx_meta.sender;
          } else {
             return name();
          }

libraries/fc/include/fc/utility.hpp

@@ -63,7 +63,9 @@ namespace fc {
 
   template<typename T>
   void move_append(std::vector<T> &dest, std::vector<T>&& src ) {
-    if (dest.empty()) {
+    if (src.empty()) {
+      return;
+    } else if (dest.empty()) {
       dest = std::move(src);
     } else {
       dest.insert(std::end(dest), std::make_move_iterator(std::begin(src)), std::make_move_iterator(std::end(src)));

libraries/testing/tester.cpp

@@ -60,7 +60,7 @@ namespace eosio { namespace testing {
          for( const auto& region : trace.block.regions) {
             for( const auto& cycle : region.cycles_summary ) {
                for ( const auto& shard : cycle ) {
-                  for( const auto& receipt: shard ) {
+                  for( const auto& receipt: shard.transactions ) {
                      chain_transactions.emplace(receipt.id, receipt);
                   }
                }
@@ -93,7 +93,6 @@ namespace eosio { namespace testing {
    void tester::create_account( account_name a, asset initial_balance, account_name creator, bool multisig ) {
       signed_transaction trx;
       set_tapos( trx );
-      trx.write_scope = { creator, config::eosio_auth_scope };
 
       authority owner_auth;
       if (multisig) {
@@ -133,7 +132,6 @@ namespace eosio { namespace testing {
    }
    transaction_trace tester::transfer( account_name from, account_name to, asset amount, string memo ) {
       signed_transaction trx;
-      trx.write_scope = {from,to};
       trx.actions.emplace_back( vector<permission_level>{{from,config::active_name}},
                                 contracts::transfer{
                                    .from   = from,
@@ -151,7 +149,6 @@ namespace eosio { namespace testing {
                                authority auth,
                                permission_name parent ) { try {
       signed_transaction trx;
-      trx.write_scope = {config::eosio_auth_scope};
       trx.actions.emplace_back( vector<permission_level>{{account,perm}},
                                 contracts::updateauth{
                                    .account    = account,
@@ -210,7 +207,6 @@ namespace eosio { namespace testing {
       auto wasm = assemble(wast);
 
       signed_transaction trx;
-      trx.write_scope = {config::eosio_auth_scope, account};
       trx.actions.emplace_back( vector<permission_level>{{account,config::active_name}},
                                 contracts::setcode{
                                    .account    = account,
@@ -227,7 +223,6 @@ namespace eosio { namespace testing {
    void tester::set_abi( account_name account, const char* abi_json) {
       auto abi = fc::json::from_string(abi_json).template as<contracts::abi_def>();
       signed_transaction trx;
-      trx.write_scope = {config::eosio_auth_scope};
       trx.actions.emplace_back( vector<permission_level>{{account,config::active_name}},
                                 contracts::setabi{
                                    .account    = account,

plugins/faucet_testnet_plugin/faucet_testnet_plugin.cpp

@@ -230,7 +230,6 @@ struct faucet_testnet_plugin_impl {
       auto active_auth  = chain::authority{1, {{active_pub_key, 1}}, {}};
       auto recovery_auth = chain::authority{1, {}, {{{_create_account_name, "active"}, 1}}};
 
-      trx.write_scope = sort_names({_create_account_name,config::eosio_auth_scope});
       trx.actions.emplace_back(vector<chain::permission_level>{{_create_account_name,"active"}},
                                contracts::newaccount{_create_account_name, new_account_name, owner_auth, active_auth, recovery_auth, deposit});
 

plugins/txn_test_gen_plugin/txn_test_gen_plugin.cpp

@@ -73,7 +73,6 @@ struct txn_test_gen_plugin_impl {
       signed_transaction trx;
       trx.expiration = cc.head_block_time() + fc::seconds(30);
       trx.set_reference_block(cc.head_block_id());
-      trx.write_scope = {creator, config::system_account_name, config::eosio_auth_scope};
       trx.actions.emplace_back(vector<chain::permission_level>{{creator,"active"}}, contracts::lock{creator, creator, 300});
 
       //create "A" account
@@ -98,7 +97,6 @@ struct txn_test_gen_plugin_impl {
       {
       uint64_t balance = 10000;
       signed_transaction trx;
-      trx.write_scope = sort_names({creator,newaccountA,newaccountB});
       trx.actions.emplace_back(vector<chain::permission_level>{{creator,"active"}}, contracts::transfer{creator, newaccountA, balance, memo});
       trx.actions.emplace_back(vector<chain::permission_level>{{creator,"active"}}, contracts::transfer{creator, newaccountB, balance, memo});
       trx.expiration = cc.head_block_time() + fc::seconds(30);
@@ -150,7 +148,6 @@ struct txn_test_gen_plugin_impl {
       //make transaction a->b
       {
       signed_transaction trx;
-      trx.write_scope = sort_names({sender,recipient});
       trx.actions.emplace_back(vector<chain::permission_level>{{sender,"active"}}, contracts::transfer{sender, recipient, 1, memo});
       trx.expiration = cc.head_block_time() + fc::seconds(30);
       trx.set_reference_block(cc.head_block_id());
@@ -163,7 +160,6 @@ struct txn_test_gen_plugin_impl {
       //make transaction b->a
       {
       signed_transaction trx;
-      trx.write_scope = sort_names({sender,recipient});
       trx.actions.emplace_back(vector<chain::permission_level>{{recipient,"active"}}, contracts::transfer{recipient, sender, 1, memo});
       trx.expiration = cc.head_block_time() + fc::seconds(30);
       trx.set_reference_block(cc.head_block_id());

programs/eosioc/main.cpp

@@ -275,8 +275,6 @@ fc::variant push_transaction( signed_transaction& trx, bool sign ) {
     auto info = get_info();
     trx.expiration = info.head_block_time + tx_expiration;
     trx.set_reference_block(info.head_block_id);
-    boost::sort( trx.write_scope );
-    boost::sort( trx.read_scope );
 
     if (sign) {
        sign_transaction(trx);
@@ -294,8 +292,7 @@ void create_account(name creator, name newaccount, public_key_type owner, public
       uint64_t deposit = 1;
 
       signed_transaction trx;
-      trx.write_scope = sort_names({creator,config::eosio_auth_scope});
-      trx.actions.emplace_back( vector<chain::permission_level>{{creator,"active"}}, 
+      trx.actions.emplace_back( vector<chain::permission_level>{{creator,"active"}},
                                 contracts::newaccount{creator, newaccount, owner_auth, active_auth, recovery_auth, deposit});
 
       std::cout << fc::json::to_pretty_string(push_transaction(trx, sign)) << std::endl;
@@ -321,9 +318,8 @@ chain::action create_unlinkauth(const name& account, const name& code, const nam
                    contracts::unlinkauth{account, code, type}};
 }
 
-void send_transaction(const std::vector<chain::action>& actions, const std::vector<name>& scopes, bool skip_sign = false) {
+void send_transaction(const std::vector<chain::action>& actions, bool skip_sign = false) {
    signed_transaction trx;
-   trx.write_scope = sort_names(scopes);
    for (const auto& m: actions) {
       trx.actions.emplace_back( m );
    }
@@ -362,7 +358,7 @@ struct set_account_permission_subcommand {
          bool is_delete = boost::iequals(authorityJsonOrFile, "null");
          
          if (is_delete) {
-            send_transaction({create_deleteauth(account, permission, name(permissionAuth))}, {account, config::system_account_name}, skip_sign);
+            send_transaction({create_deleteauth(account, permission, name(permissionAuth))}, skip_sign);
          } else {
             authority auth;
             if (boost::istarts_with(authorityJsonOrFile, "EOS")) {
@@ -401,7 +397,7 @@ struct set_account_permission_subcommand {
                parent = name(parentStr);
             }
 
-            send_transaction({create_updateauth(account, permission, parent, auth, name(permissionAuth))}, {name(account), config::system_account_name}, skip_sign);
+            send_transaction({create_updateauth(account, permission, parent, auth, name(permissionAuth))}, skip_sign);
          }      
       });
    }
@@ -431,10 +427,10 @@ struct set_action_permission_subcommand {
          bool is_delete = boost::iequals(requirementStr, "null");
          
          if (is_delete) {
-            send_transaction({create_unlinkauth(account, code, type)}, {account, config::system_account_name}, skip_sign);
+            send_transaction({create_unlinkauth(account, code, type)}, skip_sign);
          } else {
             name requirement = name(requirementStr);
-            send_transaction({create_linkauth(account, code, type, requirement)}, {name(account), config::system_account_name}, skip_sign);
+            send_transaction({create_linkauth(account, code, type, requirement)}, skip_sign);
          }      
       });
    }
@@ -513,7 +509,6 @@ int main( int argc, char** argv ) {
       auto account_permissions = get_account_permissions(permissions);
 
       signed_transaction trx;
-      trx.write_scope = sort_names({config::system_account_name, account_name});
       trx.actions.emplace_back(  account_permissions, contracts::setproducer{account_name, public_key_type(ownerKey), chain_config{}} );
 
       std::cout << fc::json::to_pretty_string(push_transaction(trx, !skip_sign)) << std::endl;
@@ -699,7 +694,6 @@ int main( int argc, char** argv ) {
       handler.code.assign(wasm.begin(), wasm.end());
 
       signed_transaction trx;
-      trx.write_scope = sort_names({config::eosio_auth_scope, account});
       trx.actions.emplace_back( vector<chain::permission_level>{{account,"active"}}, handler);
 
       if (abi->count()) {
@@ -734,7 +728,6 @@ int main( int argc, char** argv ) {
       auto account_permissions = get_account_permissions(permissions);
 
       signed_transaction trx;
-      trx.write_scope = sort_names({config::system_account_name, account_name});
       trx.actions.emplace_back( account_permissions, contracts::okproducer{account_name, producer, approve});
 
       push_transaction(trx, !skip_sign);
@@ -761,7 +754,6 @@ int main( int argc, char** argv ) {
       }
 
       signed_transaction trx;
-      trx.write_scope = sort_names({config::system_account_name, account_name});
       trx.actions.emplace_back( account_permissions, contracts::setproxy{account_name, proxy});
 
       push_transaction(trx, !skip_sign);
@@ -794,8 +786,7 @@ int main( int argc, char** argv ) {
    add_standard_transaction_options(transfer);
    transfer->set_callback([&] {
       signed_transaction trx;
-      trx.write_scope = sort_names({sender,recipient});
-      
+
       if (tx_force_unique) {
          if (memo.size() == 0) {
             // use the memo to add a nonce
@@ -996,8 +987,7 @@ int main( int argc, char** argv ) {
         uint64_t deposit = 1;
         
         signed_transaction trx;
-        trx.write_scope = sort_names({creator,config::system_account_name});
-        trx.actions.emplace_back( vector<chain::permission_level>{{creator,"active"}}, 
+        trx.actions.emplace_back( vector<chain::permission_level>{{creator,"active"}},
                                   contracts::newaccount{creator, newaccount, owner_auth, active_auth, recovery_auth, deposit});
 
         trx.expiration = info.head_block_time + tx_expiration; 
@@ -1029,7 +1019,6 @@ int main( int argc, char** argv ) {
          uint32_t amount = 100000;
 
          signed_transaction trx;
-         trx.write_scope = sort_names({sender,recipient});
          trx.actions.emplace_back( vector<chain::permission_level>{{sender,"active"}},
                                    contracts::transfer{ .from = sender, .to = recipient, .amount = amount, .memo = memo});
          trx.expiration = info.head_block_time + tx_expiration; 
@@ -1065,7 +1054,6 @@ int main( int argc, char** argv ) {
 
 
             auto memo = fc::variant(fc::time_point::now()).as_string() + " " + fc::variant(fc::time_point::now().time_since_epoch()).as_string();
-            trx.write_scope = sort_names({sender,recipient});
             trx.actions.emplace_back(  vector<chain::permission_level>{{sender,"active"}},
                                        contracts::transfer{ .from = sender, .to = recipient, .amount = amount, .memo = memo});
             trx.expiration = info.head_block_time + tx_expiration; 
@@ -1100,7 +1088,6 @@ int main( int argc, char** argv ) {
    string contract;
    string action;
    string data;
-   vector<string> scopes;
    auto actionsSubcommand = push->add_subcommand("actions", localized("Push a transaction with a single actions"));
    actionsSubcommand->fallthrough(false);
    actionsSubcommand->add_option("contract", contract,
@@ -1110,7 +1097,6 @@ int main( int argc, char** argv ) {
    actionsSubcommand->add_option("data", data, localized("The arguments to the contract"))->required();
    actionsSubcommand->add_option("-p,--permission", permissions,
                                  localized("An account and permission level to authorize, as in 'account@permission'"));
-   actionsSubcommand->add_option("-S,--scope", scopes, localized("An comma separated list of accounts in scope for this operation"), true);
    actionsSubcommand->add_flag("-s,--skip-sign", skip_sign, localized("Specify that unlocked wallet keys should not be used to sign transaction"));
    add_standard_transaction_options(actionsSubcommand);
    actionsSubcommand->set_callback([&] {
@@ -1133,12 +1119,6 @@ int main( int argc, char** argv ) {
          trx.actions.emplace_back( generate_nonce() );
       }                                                      
 
-      for( const auto& scope : scopes ) {
-         vector<string> subscopes;
-         boost::split( subscopes, scope, boost::is_any_of( ", :" ) );
-         for( const auto& s : subscopes )
-            trx.write_scope.emplace_back(s);
-      }
       std::cout << fc::json::to_pretty_string(push_transaction(trx, !skip_sign )) << std::endl;
    });
 

tests/chain_tests/proof_tests.cpp

@@ -211,7 +211,7 @@ BOOST_FIXTURE_TEST_CASE( prove_action_in_block, tester ) { try {
 
                      auto a_data = action_proof_data {
                         at.receiver,
-                        at.act.scope,
+                        at.act.account,
                         at.act.name,
                         at.act.data,
                         at.region_id,

tests/chain_tests/recovery_tests.cpp

@@ -11,7 +11,6 @@ using namespace eosio::testing;
 
 auto make_postrecovery(const tester &t, account_name account, string role) {
    signed_transaction trx;
-   trx.write_scope = {config::eosio_auth_scope, account};
    trx.actions.emplace_back( vector<permission_level>{{account,config::active_name}},
                              postrecovery{
                                 .account = account,
@@ -25,7 +24,6 @@ auto make_postrecovery(const tester &t, account_name account, string role) {
 
 auto make_vetorecovery(const tester &t, account_name account, permission_name vetoperm = N(active), optional<private_key_type> signing_key = optional<private_key_type>()) {
    signed_transaction trx;
-   trx.write_scope = {config::eosio_auth_scope, account};
    trx.actions.emplace_back( vector<permission_level>{{account,vetoperm}},
                              vetorecovery{
                                 .account = account
@@ -42,7 +40,6 @@ auto make_vetorecovery(const tester &t, account_name account, permission_name ve
 auto push_nonce(tester &t, const string& role) {
    // ensure the old owner key is valid
    signed_transaction trx;
-   trx.write_scope = {N(alice)};
    trx.actions.emplace_back( vector<permission_level>{{N(alice),config::owner_name}},
                              nonce{
                                 .value = t.control->head_block_num()

tests/chain_tests/transfer_tests.cpp

@@ -60,7 +60,6 @@ BOOST_AUTO_TEST_CASE( transfer_test ) { try {
       auto to   = N(dan);
       asset amount(1);
       signed_transaction trx;
-      trx.write_scope = {from,to};
       trx.actions.emplace_back( vector<permission_level>{{from,config::active_name}},
                                 contracts::transfer{
                                    .from   = from,
@@ -80,7 +79,6 @@ BOOST_AUTO_TEST_CASE( transfer_test ) { try {
       auto to   = N(dan);
       asset amount(1);
       signed_transaction trx;
-      trx.write_scope = {from,to};
       trx.actions.emplace_back( vector<permission_level>{{to,config::active_name}},
                                 contracts::transfer{
                                    .from   = from,
@@ -95,25 +93,6 @@ BOOST_AUTO_TEST_CASE( transfer_test ) { try {
       BOOST_REQUIRE_THROW( test.control->push_transaction( trx ), tx_missing_auth);
   }
 
-  {
-      auto from = N(bart);
-      auto to   = N(dan);
-      asset amount(1);
-      signed_transaction trx;
-     // trx.write_scope = {from,to};
-      trx.actions.emplace_back( vector<permission_level>{{from,config::active_name}},
-                                contracts::transfer{
-                                   .from   = from,
-                                   .to     = to,
-                                   .amount = amount.amount,
-                                   .memo   = "memo" 
-                                } );
-
-      test.set_tapos( trx );
-      trx.sign( test.get_private_key( from, "active" ), chain_id_type()  ); 
-      BOOST_REQUIRE_THROW( test.control->push_transaction( trx ), tx_missing_write_scope);
-  }
-
 } FC_LOG_AND_RETHROW() } /// transfer_test
 
 
@@ -151,7 +130,6 @@ BOOST_AUTO_TEST_CASE( transfer_delegation ) { try {
       asset amount(1);
 
       signed_transaction trx;
-      trx.write_scope = {from,to};
       trx.actions.emplace_back( vector<permission_level>{{from,config::active_name}},
                                 contracts::transfer{
                                    .from   = from,

tests/wasm_tests/wasm_tests.cpp

@@ -26,7 +26,7 @@ struct assertdef {
    int8_t      condition;
    string      message;
 
-   static scope_name get_scope() {
+   static account_name get_account() {
       return N(asserter);
    }
 
@@ -38,7 +38,7 @@ struct assertdef {
 FC_REFLECT(assertdef, (condition)(message));
 
 struct provereset {
-   static scope_name get_scope() {
+   static account_name get_account() {
       return N(asserter);
    }
 
@@ -64,7 +64,7 @@ constexpr uint64_t TEST_METHOD(const char* CLASS, const char *METHOD) {
 
 template<uint64_t NAME>
 struct test_api_action {
-   static scope_name get_scope() {
+   static account_name get_account() {
       return N(tester);
    }
 
@@ -102,7 +102,7 @@ BOOST_FIXTURE_TEST_CASE( basic_test, tester ) try {
       BOOST_CHECK_EQUAL(result.status, transaction_receipt::executed);
       BOOST_CHECK_EQUAL(result.action_traces.size(), 1);
       BOOST_CHECK_EQUAL(result.action_traces.at(0).receiver.to_string(),  name(N(asserter)).to_string() );
-      BOOST_CHECK_EQUAL(result.action_traces.at(0).act.scope.to_string(), name(N(asserter)).to_string() );
+      BOOST_CHECK_EQUAL(result.action_traces.at(0).act.account.to_string(), name(N(asserter)).to_string() );
       BOOST_CHECK_EQUAL(result.action_traces.at(0).act.name.to_string(),  name(N(procassert)).to_string() );
       BOOST_CHECK_EQUAL(result.action_traces.at(0).act.authorization.size(),  1 );
       BOOST_CHECK_EQUAL(result.action_traces.at(0).act.authorization.at(0).actor.to_string(),  name(N(asserter)).to_string() );
@@ -195,7 +195,7 @@ BOOST_FIXTURE_TEST_CASE( abi_from_variant, tester ) try {
    variant pretty_trx = mutable_variant_object()
       ("actions", variants({
          mutable_variant_object()
-            ("scope", "asserter")
+            ("account", "asserter")
             ("name", "procassert")
             ("authorization", variants({
                mutable_variant_object()
@@ -293,9 +293,8 @@ BOOST_FIXTURE_TEST_CASE( test_currency, tester ) try {
    // make a transfer from the contract to a user
    {
       signed_transaction trx;
-      trx.write_scope = {N(currency),N(alice)};
       action transfer_act;
-      transfer_act.scope = N(currency);
+      transfer_act.account = N(currency);
       transfer_act.name = N(transfer);
       transfer_act.authorization = vector<permission_level>{{N(currency), config::active_name}};
       transfer_act.data = abi_ser.variant_to_binary("transfer", mutable_variant_object()
@@ -316,9 +315,8 @@ BOOST_FIXTURE_TEST_CASE( test_currency, tester ) try {
    // Overspend!
    {
       signed_transaction trx;
-      trx.write_scope = {N(alice),N(bob)};
       action transfer_act;
-      transfer_act.scope = N(currency);
+      transfer_act.account = N(currency);
       transfer_act.name = N(transfer);
       transfer_act.authorization = vector<permission_level>{{N(alice), config::active_name}};
       transfer_act.data = abi_ser.variant_to_binary("transfer", mutable_variant_object()
@@ -339,9 +337,8 @@ BOOST_FIXTURE_TEST_CASE( test_currency, tester ) try {
    // Full spend
    {
       signed_transaction trx;
-      trx.write_scope = {N(alice),N(bob)};
       action transfer_act;
-      transfer_act.scope = N(currency);
+      transfer_act.account = N(currency);
       transfer_act.name = N(transfer);
       transfer_act.authorization = vector<permission_level>{{N(alice), config::active_name}};
       transfer_act.data = abi_ser.variant_to_binary("transfer", mutable_variant_object()
@@ -381,9 +378,8 @@ BOOST_FIXTURE_TEST_CASE( test_proxy, tester ) try {
    // set up proxy owner
    {
       signed_transaction trx;
-      trx.write_scope = {N(proxy)};
       action setowner_act;
-      setowner_act.scope = N(proxy);
+      setowner_act.account = N(proxy);
       setowner_act.name = N(setowner);
       setowner_act.authorization = vector<permission_level>{{N(proxy), config::active_name}};
       setowner_act.data = abi_ser.variant_to_binary("setowner", mutable_variant_object()
@@ -439,9 +435,8 @@ BOOST_FIXTURE_TEST_CASE( test_deferred_failure, tester ) try {
    // set up proxy owner
    {
       signed_transaction trx;
-      trx.write_scope = {N(proxy)};
       action setowner_act;
-      setowner_act.scope = N(proxy);
+      setowner_act.account = N(proxy);
       setowner_act.name = N(setowner);
       setowner_act.authorization = vector<permission_level>{{N(proxy), config::active_name}};
       setowner_act.data = abi_ser.variant_to_binary("setowner", mutable_variant_object()
@@ -481,9 +476,8 @@ BOOST_FIXTURE_TEST_CASE( test_deferred_failure, tester ) try {
    // set up bob owner
    {
       signed_transaction trx;
-      trx.write_scope = {N(bob)};
       action setowner_act;
-      setowner_act.scope = N(bob);
+      setowner_act.account = N(bob);
       setowner_act.name = N(setowner);
       setowner_act.authorization = vector<permission_level>{{N(bob), config::active_name}};
       setowner_act.data = abi_ser.variant_to_binary("setowner", mutable_variant_object()