native.hpp

См. документацию.

#pragma once
 
#include <eosio/action.hpp>
#include <eosio/binary_extension.hpp>
#include <eosio/contract.hpp>
#include <eosio/crypto.hpp>
#include <eosio/fixed_bytes.hpp>
#include <eosio/ignore.hpp>
#include <eosio/print.hpp>
#include <eosio/privileged.hpp>
#include <eosio/producer_schedule.hpp>
 
namespace eosiosystem {
 
   using eosio::binary_extension;
   using eosio::checksum256;
   using eosio::ignore;
   using eosio::name;
   using eosio::permission_level;
   using eosio::public_key;
 
   struct permission_level_weight {
      permission_level  permission;
      uint16_t          weight;
 
      // explicit serialization macro is not necessary, used here only to improve compilation time
      EOSLIB_SERIALIZE( permission_level_weight, (permission)(weight) )
   };
 
   struct key_weight {
      eosio::public_key  key;
      uint16_t           weight;
 
      // explicit serialization macro is not necessary, used here only to improve compilation time
      EOSLIB_SERIALIZE( key_weight, (key)(weight) )
   };
 
   struct wait_weight {
      uint32_t           wait_sec;
      uint16_t           weight;
 
      // explicit serialization macro is not necessary, used here only to improve compilation time
      EOSLIB_SERIALIZE( wait_weight, (wait_sec)(weight) )
   };
 
   struct authority {
      uint32_t                              threshold = 0;
      std::vector<key_weight>               keys;
      std::vector<permission_level_weight>  accounts;
      std::vector<wait_weight>              waits;
 
      // explicit serialization macro is not necessary, used here only to improve compilation time
      EOSLIB_SERIALIZE( authority, (threshold)(keys)(accounts)(waits) )
   };
 
   struct block_header {
      uint32_t                                  timestamp;
      name                                      producer;
      uint16_t                                  confirmed = 0;
      checksum256                               previous;
      checksum256                               transaction_mroot;
      checksum256                               action_mroot;
      uint32_t                                  schedule_version = 0;
      std::optional<eosio::producer_schedule>   new_producers;
 
      // explicit serialization macro is not necessary, used here only to improve compilation time
      EOSLIB_SERIALIZE(block_header, (timestamp)(producer)(confirmed)(previous)(transaction_mroot)(action_mroot)
                                     (schedule_version)(new_producers))
   };
 
   struct [[eosio::table("abihash"), eosio::contract("eosio.system")]] abi_hash {
      name              owner;
      checksum256       hash;
      uint64_t primary_key()const { return owner.value; }
 
      EOSLIB_SERIALIZE( abi_hash, (owner)(hash) )
   };
 
   void check_auth_change(name contract, name account, const binary_extension<name>& authorized_by);
 
   // Method parameters commented out to prevent generation of code that parses input data.
   class [[eosio::contract("eosio.system")]] native : public eosio::contract {
      public:
 
         using eosio::contract::contract;
 
         [[eosio::action]]
         void newaccount( const name&       creator,
                          const name&       name,
                          ignore<authority> owner,
                          ignore<authority> active);
 
         [[eosio::action]]
         void updateauth( name                   account,
                          name                   permission,
                          name                   parent,
                          authority              auth,
                          binary_extension<name> authorized_by ) {
            check_auth_change(get_self(), account, authorized_by);
         }
 
         [[eosio::action]]
         void deleteauth( name                   account,
                          name                   permission,
                          binary_extension<name> authorized_by ) {
            check_auth_change(get_self(), account, authorized_by);
         }
 
         [[eosio::action]]
         void linkauth( name                   account,
                        name                   code,
                        name                   type,
                        name                   requirement,
                        binary_extension<name> authorized_by ) {
            check_auth_change(get_self(), account, authorized_by);
         }
 
         [[eosio::action]]
         void unlinkauth( name                   account,
                          name                   code,
                          name                   type,
                          binary_extension<name> authorized_by ) {
            check_auth_change(get_self(), account, authorized_by);
         }
 
         [[eosio::action]]
         void canceldelay( ignore<permission_level> canceling_auth, ignore<checksum256> trx_id ) {}
 
         [[eosio::action]]
         void onerror( ignore<uint128_t> sender_id, ignore<std::vector<char>> sent_trx );
 
         [[eosio::action]]
         void setabi( const name& account, const std::vector<char>& abi, const binary_extension<std::string>& memo );
 
         using newaccount_action = eosio::action_wrapper<"newaccount"_n, &native::newaccount>;
         using updateauth_action = eosio::action_wrapper<"updateauth"_n, &native::updateauth>;
         using deleteauth_action = eosio::action_wrapper<"deleteauth"_n, &native::deleteauth>;
         using linkauth_action = eosio::action_wrapper<"linkauth"_n, &native::linkauth>;
         using unlinkauth_action = eosio::action_wrapper<"unlinkauth"_n, &native::unlinkauth>;
         using canceldelay_action = eosio::action_wrapper<"canceldelay"_n, &native::canceldelay>;
         using setabi_action = eosio::action_wrapper<"setabi"_n, &native::setabi>;
   };
}