interface.hpp

Go to the documentation of this file.

#pragma once
 
#include <sysio/chain/types.hpp>
#include <sysio/chain/webassembly/common.hpp>
#include <sysio/chain/webassembly/return_codes.hpp>
#include <fc/crypto/sha1.hpp>
#include <boost/hana/string.hpp>
 
namespace sysio { namespace chain {
class apply_context;
namespace webassembly {
 
   class interface {
      public:
         interface(apply_context& ctx) : context(ctx) {}
 
         inline apply_context& get_context() { return context; }
         inline const apply_context& get_context() const { return context; }
 
         int32_t get_context_free_data(uint32_t index, legacy_span<char> buffer) const;
 
         int32_t is_feature_active(int64_t feature_name) const;
 
         void activate_feature(int64_t feature_name) const;
 
         void preactivate_feature(legacy_ptr<const digest_type> feature_digest);
 
         void set_resource_limits(account_name account, int64_t ram_bytes, int64_t net_weight, int64_t cpu_weight);
 
         void get_resource_limits(account_name account, legacy_ptr<int64_t, 8> ram_bytes, legacy_ptr<int64_t, 8> net_weight, legacy_ptr<int64_t, 8> cpu_weight) const;
 
         uint32_t get_wasm_parameters_packed( span<char> packed_parameters, uint32_t max_version ) const;
 
         void set_wasm_parameters_packed( span<const char> packed_parameters );
 
         int64_t set_proposed_producers(legacy_span<const char> packed_producer_schedule);
 
         int64_t set_proposed_producers_ex(uint64_t packed_producer_format, legacy_span<const char> packed_producer_schedule);
 
         uint32_t get_blockchain_parameters_packed(legacy_span<char> packed_blockchain_parameters) const;
 
         void set_blockchain_parameters_packed(legacy_span<const char> packed_blockchain_parameters);
 
         uint32_t get_parameters_packed( span<const char> packed_parameter_ids, span<char> packed_parameters) const;
 
         void set_parameters_packed( span<const char> packed_parameters );
 
         bool is_privileged(account_name account) const;
 
         void set_privileged(account_name account, bool is_priv);
 
         // softfloat api
         float _sysio_f32_add(float, float) const;
         float _sysio_f32_sub(float, float) const;
         float _sysio_f32_div(float, float) const;
         float _sysio_f32_mul(float, float) const;
         float _sysio_f32_min(float, float) const;
         float _sysio_f32_max(float, float) const;
         float _sysio_f32_copysign(float, float) const;
         float _sysio_f32_abs(float) const;
         float _sysio_f32_neg(float) const;
         float _sysio_f32_sqrt(float) const;
         float _sysio_f32_ceil(float) const;
         float _sysio_f32_floor(float) const;
         float _sysio_f32_trunc(float) const;
         float _sysio_f32_nearest(float) const;
         bool _sysio_f32_eq(float, float) const;
         bool _sysio_f32_ne(float, float) const;
         bool _sysio_f32_lt(float, float) const;
         bool _sysio_f32_le(float, float) const;
         bool _sysio_f32_gt(float, float) const;
         bool _sysio_f32_ge(float, float) const;
         double _sysio_f64_add(double, double) const;
         double _sysio_f64_sub(double, double) const;
         double _sysio_f64_div(double, double) const;
         double _sysio_f64_mul(double, double) const;
         double _sysio_f64_min(double, double) const;
         double _sysio_f64_max(double, double) const;
         double _sysio_f64_copysign(double, double) const;
         double _sysio_f64_abs(double) const;
         double _sysio_f64_neg(double) const;
         double _sysio_f64_sqrt(double) const;
         double _sysio_f64_ceil(double) const;
         double _sysio_f64_floor(double) const;
         double _sysio_f64_trunc(double) const;
         double _sysio_f64_nearest(double) const;
         bool _sysio_f64_eq(double, double) const;
         bool _sysio_f64_ne(double, double) const;
         bool _sysio_f64_lt(double, double) const;
         bool _sysio_f64_le(double, double) const;
         bool _sysio_f64_gt(double, double) const;
         bool _sysio_f64_ge(double, double) const;
         double _sysio_f32_promote(float) const;
         float _sysio_f64_demote(double) const;
         int32_t _sysio_f32_trunc_i32s(float) const;
         int32_t _sysio_f64_trunc_i32s(double) const;
         uint32_t _sysio_f32_trunc_i32u(float) const;
         uint32_t _sysio_f64_trunc_i32u(double) const;
         int64_t _sysio_f32_trunc_i64s(float) const;
         int64_t _sysio_f64_trunc_i64s(double) const;
         uint64_t _sysio_f32_trunc_i64u(float) const;
         uint64_t _sysio_f64_trunc_i64u(double) const;
         float _sysio_i32_to_f32(int32_t) const;
         float _sysio_i64_to_f32(int64_t) const;
         float _sysio_ui32_to_f32(uint32_t) const;
         float _sysio_ui64_to_f32(uint64_t) const;
         double _sysio_i32_to_f64(int32_t) const;
         double _sysio_i64_to_f64(int64_t) const;
         double _sysio_ui32_to_f64(uint32_t) const;
         double _sysio_ui64_to_f64(uint64_t) const;
 
         int32_t get_active_producers(legacy_span<account_name> producers) const;
 
         void assert_recover_key(legacy_ptr<const fc::sha256> digest, legacy_span<const char> sig, legacy_span<const char> pub) const;
 
         int32_t recover_key(legacy_ptr<const fc::sha256> digest, legacy_span<const char> sig, legacy_span<char> pub) const;
 
         void assert_sha256(legacy_span<const char> data, legacy_ptr<const fc::sha256> hash_val) const;
 
         void assert_sha1(legacy_span<const char> data, legacy_ptr<const fc::sha1> hash_val) const;
 
         void assert_sha512(legacy_span<const char> data, legacy_ptr<const fc::sha512> hash_val) const;
 
         void assert_ripemd160(legacy_span<const char> data, legacy_ptr<const fc::ripemd160> hash_val) const;
 
         void sha256(legacy_span<const char> data, legacy_ptr<fc::sha256> hash_val) const;
 
         void sha1(legacy_span<const char> data, legacy_ptr<fc::sha1> hash_val) const;
 
         void sha512(legacy_span<const char> data, legacy_ptr<fc::sha512> hash_val) const;
 
         void ripemd160(legacy_span<const char> data, legacy_ptr<fc::ripemd160> hash_val) const;
 
         bool check_transaction_authorization(legacy_span<const char> trx_data, legacy_span<const char> pubkeys_data, legacy_span<const char> perms_data) const;
 
         bool check_permission_authorization(account_name account, permission_name permission, legacy_span<const char> pubkeys_data, legacy_span<const char> perms_data, uint64_t delay_us) const;
 
         int64_t get_permission_last_used(account_name account, permission_name permission) const;
 
         int64_t get_account_creation_time(account_name account) const;
 
         void require_auth(account_name account) const;
 
         void require_auth2(account_name account, permission_name permission) const;
 
         bool has_auth(account_name account) const;
 
         void require_recipient(account_name recipient);
 
         bool is_account(account_name account) const;
 
         uint32_t get_code_hash(
            account_name account,
            uint32_t struct_version,
            vm::span<char> packed_result) const;
 
         uint64_t current_time() const;
 
         uint32_t get_block_num() const;
 
         uint64_t publication_time() const;
 
         bool is_feature_activated(legacy_ptr<const digest_type> feature_digest) const;
 
         name get_sender() const;
 
         void abort() const;
 
         void sysio_assert(bool condition, null_terminated_ptr msg) const;
 
         void sysio_assert_message(bool condition, legacy_span<const char> msg) const;
 
         void sysio_assert_code(bool condition, uint64_t error_code) const;
 
         void sysio_exit(int32_t code) const;
 
         int32_t read_action_data(legacy_span<char> memory) const;
 
         int32_t action_data_size() const;
 
         name current_receiver() const;
 
         void set_action_return_value(span<const char> packed_blob);
 
         void prints(null_terminated_ptr str);
 
         void prints_l(legacy_span<const char> str);
 
         void printi(int64_t val);
 
         void printui(uint64_t val);
 
         void printi128(legacy_ptr<const __int128> val);
 
         void printui128(legacy_ptr<const unsigned __int128> val);
 
         void printsf(float32_t val);
 
         void printdf(float64_t val);
 
         void printqf(legacy_ptr<const float128_t> val);
 
         void printn(name value);
 
         void printhex(legacy_span<const char> data);
 
         int32_t db_store_i64(uint64_t scope, uint64_t table, uint64_t payer, uint64_t id, legacy_span<const char> buffer);
 
         void db_update_i64(int32_t itr, uint64_t payer, legacy_span<const char> buffer);
 
         void db_remove_i64(int32_t itr);
 
         int32_t db_get_i64(int32_t itr, legacy_span<char> buffer);
 
         int32_t db_next_i64(int32_t itr, legacy_ptr<uint64_t> primary);
 
         int32_t db_previous_i64(int32_t itr, legacy_ptr<uint64_t> primary);
 
         int32_t db_find_i64(uint64_t code, uint64_t scope, uint64_t table, uint64_t id);
 
         int32_t db_lowerbound_i64(uint64_t code, uint64_t scope, uint64_t table, uint64_t id);
 
         int32_t db_upperbound_i64(uint64_t code, uint64_t scope, uint64_t table, uint64_t id);
 
         int32_t db_end_i64(uint64_t code, uint64_t scope, uint64_t table);
 
         int32_t db_idx64_store(uint64_t scope, uint64_t table, uint64_t payer, uint64_t id, legacy_ptr<const uint64_t> secondary);
 
         void db_idx64_update(int32_t iterator, uint64_t payer, legacy_ptr<const uint64_t> secondary);
 
         void db_idx64_remove(int32_t iterator);
 
         int32_t db_idx64_find_secondary(uint64_t code, uint64_t scope, uint64_t table, legacy_ptr<const uint64_t> secondary, legacy_ptr<uint64_t> primary);
 
         int32_t db_idx64_find_primary(uint64_t code, uint64_t scope, uint64_t table, legacy_ptr<uint64_t> secondary, uint64_t primary);
 
         int32_t db_idx64_lowerbound(uint64_t code, uint64_t scope, uint64_t table, legacy_ptr<uint64_t, 8> secondary, legacy_ptr<uint64_t, 8> primary);
 
         int32_t db_idx64_upperbound(uint64_t code, uint64_t scope, uint64_t table, legacy_ptr<uint64_t, 8> secondary, legacy_ptr<uint64_t, 8> primary);
 
         int32_t db_idx64_end(uint64_t code, uint64_t scope, uint64_t table);
 
         int32_t db_idx64_next(int32_t iterator, legacy_ptr<uint64_t> primary);
 
         int32_t db_idx64_previous(int32_t iterator, legacy_ptr<uint64_t> primary);
 
         int32_t db_idx128_store(uint64_t scope, uint64_t table, uint64_t payer, uint64_t id, legacy_ptr<const uint128_t> secondary);
 
         void db_idx128_update(int32_t iterator, uint64_t payer, legacy_ptr<const uint128_t> secondary);
 
         void db_idx128_remove(int32_t iterator);
 
         int32_t db_idx128_find_secondary(uint64_t code, uint64_t scope, uint64_t table, legacy_ptr<const uint128_t> secondary, legacy_ptr<uint64_t> primary);
 
         int32_t db_idx128_find_primary(uint64_t code, uint64_t scope, uint64_t table, legacy_ptr<uint128_t> secondary, uint64_t primary);
 
         int32_t db_idx128_lowerbound(uint64_t code, uint64_t scope, uint64_t table, legacy_ptr<uint128_t, 16> secondary, legacy_ptr<uint64_t, 8> primary);
 
         int32_t db_idx128_upperbound(uint64_t code, uint64_t scope, uint64_t table, legacy_ptr<uint128_t, 16> secondary, legacy_ptr<uint64_t, 8> primary);
 
         int32_t db_idx128_end(uint64_t code, uint64_t scope, uint64_t table);
 
         int32_t db_idx128_next(int32_t iterator, legacy_ptr<uint64_t> primary);
 
         int32_t db_idx128_previous(int32_t iterator, legacy_ptr<uint64_t> primary);
 
         int32_t db_idx256_store(uint64_t scope, uint64_t table, uint64_t payer, uint64_t id, legacy_span<const uint128_t> data);
 
         void db_idx256_update(int32_t iterator, uint64_t payer, legacy_span<const uint128_t> data);
 
         void db_idx256_remove(int32_t iterator);
 
         int32_t db_idx256_find_secondary(uint64_t code, uint64_t scope, uint64_t table, legacy_span<const uint128_t> data, legacy_ptr<uint64_t> primary);
 
         int32_t db_idx256_find_primary(uint64_t code, uint64_t scope, uint64_t table, legacy_span<uint128_t> data, uint64_t primary);
 
         int32_t db_idx256_lowerbound(uint64_t code, uint64_t scope, uint64_t table, legacy_span<uint128_t, 16> data, legacy_ptr<uint64_t, 8> primary);
 
         int32_t db_idx256_upperbound(uint64_t code, uint64_t scope, uint64_t table, legacy_span<uint128_t, 16> data, legacy_ptr<uint64_t, 8> primary);
 
         int32_t db_idx256_end(uint64_t code, uint64_t scope, uint64_t table);
 
         int32_t db_idx256_next(int32_t iterator, legacy_ptr<uint64_t> primary);
 
         int32_t db_idx256_previous(int32_t iterator, legacy_ptr<uint64_t> primary);
 
         int32_t db_idx_double_store(uint64_t scope, uint64_t table, uint64_t payer, uint64_t id, legacy_ptr<const float64_t> secondary);
 
         void db_idx_double_update(int32_t iterator, uint64_t payer, legacy_ptr<const float64_t> secondary);
 
         void db_idx_double_remove(int32_t iterator);
 
         int32_t db_idx_double_find_secondary(uint64_t code, uint64_t scope, uint64_t table, legacy_ptr<const float64_t> secondary, legacy_ptr<uint64_t> primary);
 
         int32_t db_idx_double_find_primary(uint64_t code, uint64_t scope, uint64_t table, legacy_ptr<float64_t> secondary, uint64_t primary);
 
         int32_t db_idx_double_lowerbound(uint64_t code, uint64_t scope, uint64_t table, legacy_ptr<float64_t, 8> secondary, legacy_ptr<uint64_t, 8> primary);
 
         int32_t db_idx_double_upperbound(uint64_t code, uint64_t scope, uint64_t table, legacy_ptr<float64_t, 8> secondary, legacy_ptr<uint64_t, 8> primary);
 
         int32_t db_idx_double_end(uint64_t code, uint64_t scope, uint64_t table);
 
         int32_t db_idx_double_next(int32_t iterator, legacy_ptr<uint64_t> primary);
 
         int32_t db_idx_double_previous(int32_t iterator, legacy_ptr<uint64_t> primary);
 
         int32_t db_idx_long_double_store(uint64_t scope, uint64_t table, uint64_t payer, uint64_t id, legacy_ptr<const float128_t> secondary);
 
         void db_idx_long_double_update(int32_t iterator, uint64_t payer, legacy_ptr<const float128_t> secondary);
 
         void db_idx_long_double_remove(int32_t iterator);
 
         int32_t db_idx_long_double_find_secondary(uint64_t code, uint64_t scope, uint64_t table, legacy_ptr<const float128_t> secondary, legacy_ptr<uint64_t> primary);
 
         int32_t db_idx_long_double_find_primary(uint64_t code, uint64_t scope, uint64_t table, legacy_ptr<float128_t> secondary, uint64_t primary);
 
         int32_t db_idx_long_double_lowerbound(uint64_t code, uint64_t scope, uint64_t table, legacy_ptr<float128_t, 8> secondary, legacy_ptr<uint64_t, 8> primary);
 
         int32_t db_idx_long_double_upperbound(uint64_t code, uint64_t scope, uint64_t table, legacy_ptr<float128_t, 8> secondary,  legacy_ptr<uint64_t, 8> primary);
 
         int32_t db_idx_long_double_end(uint64_t code, uint64_t scope, uint64_t table);
 
         int32_t db_idx_long_double_next(int32_t iterator, legacy_ptr<uint64_t> primary);
 
         int32_t db_idx_long_double_previous(int32_t iterator, legacy_ptr<uint64_t> primary);
 
         // memory api
         void* memcpy(memcpy_params) const;
         void* memmove(memcpy_params) const;
         int32_t memcmp(memcmp_params) const;
         void* memset(memset_params) const;
 
         void send_inline(legacy_span<const char> data);
 
         void send_context_free_inline(legacy_span<const char> data);
 
         void send_deferred(legacy_ptr<const uint128_t> sender_id, account_name payer, legacy_span<const char> data, uint32_t replace_existing);
 
         bool cancel_deferred(legacy_ptr<const uint128_t> val);
 
         int32_t read_transaction(legacy_span<char> data) const;
 
         int32_t transaction_size() const;
 
         int32_t expiration() const;
 
         int32_t tapos_block_num() const;
 
         int32_t tapos_block_prefix() const;
 
         int32_t get_action(uint32_t type, uint32_t index, legacy_span<char> buffer) const;
 
         int32_t alt_bn128_add(span<const char> op1, span<const char> op2, span<char> result) const;
 
         int32_t alt_bn128_mul(span<const char> g1_point, span<const char> scalar, span<char> result) const;
 
         int32_t alt_bn128_pair(span<const char> g1_g2_pairs) const;
 
         int32_t mod_exp(span<const char> base, span<const char> exp, span<const char> modulus, span<char> out) const;
 
         int32_t blake2_f( uint32_t rounds, span<const char> state, span<const char> message, span<const char> t0_offset, span<const char> t1_offset, int32_t final, span<char> result) const;
 
         void sha3( span<const char> data, span<char> hash_val, int32_t keccak) const;
 
         int32_t k1_recover( span<const char> signature, span<const char> digest, span<char> pub) const;
 
         // compiler builtins api
         void __ashlti3(legacy_ptr<int128_t>, uint64_t, uint64_t, uint32_t) const;
         void __ashrti3(legacy_ptr<int128_t>, uint64_t, uint64_t, uint32_t) const;
         void __lshlti3(legacy_ptr<int128_t>, uint64_t, uint64_t, uint32_t) const;
         void __lshrti3(legacy_ptr<int128_t>, uint64_t, uint64_t, uint32_t) const;
         void __divti3(legacy_ptr<int128_t>, uint64_t, uint64_t, uint64_t, uint64_t) const;
         void __udivti3(legacy_ptr<uint128_t>, uint64_t, uint64_t, uint64_t, uint64_t) const;
         void __multi3(legacy_ptr<int128_t>, uint64_t, uint64_t, uint64_t, uint64_t) const;
         void __modti3(legacy_ptr<int128_t>, uint64_t, uint64_t, uint64_t, uint64_t) const;
         void __umodti3(legacy_ptr<uint128_t>, uint64_t, uint64_t, uint64_t, uint64_t) const;
         void __addtf3(legacy_ptr<float128_t>, uint64_t, uint64_t, uint64_t, uint64_t) const;
         void __subtf3(legacy_ptr<float128_t>, uint64_t, uint64_t, uint64_t, uint64_t) const;
         void __multf3(legacy_ptr<float128_t>, uint64_t, uint64_t, uint64_t, uint64_t) const;
         void __divtf3(legacy_ptr<float128_t>, uint64_t, uint64_t, uint64_t, uint64_t) const;
         void __negtf2(legacy_ptr<float128_t>, uint64_t, uint64_t) const;
         void __extendsftf2(legacy_ptr<float128_t>, float) const;
         void __extenddftf2(legacy_ptr<float128_t>, double) const;
         double __trunctfdf2(uint64_t, uint64_t) const;
         float __trunctfsf2(uint64_t, uint64_t) const;
         int32_t __fixtfsi(uint64_t, uint64_t) const;
         int64_t __fixtfdi(uint64_t, uint64_t) const;
         void __fixtfti(legacy_ptr<int128_t>, uint64_t, uint64_t) const;
         uint32_t __fixunstfsi(uint64_t, uint64_t) const;
         uint64_t __fixunstfdi(uint64_t, uint64_t) const;
         void __fixunstfti(legacy_ptr<uint128_t>, uint64_t, uint64_t) const;
         void __fixsfti(legacy_ptr<int128_t>, float) const;
         void __fixdfti(legacy_ptr<int128_t>, double) const;
         void __fixunssfti(legacy_ptr<uint128_t>, float) const;
         void __fixunsdfti(legacy_ptr<uint128_t>, double) const;
         double __floatsidf(int32_t) const;
         void __floatsitf(legacy_ptr<float128_t>, int32_t) const;
         void __floatditf(legacy_ptr<float128_t>, uint64_t) const;
         void __floatunsitf(legacy_ptr<float128_t>, uint32_t) const;
         void __floatunditf(legacy_ptr<float128_t>, uint64_t) const;
         double __floattidf(uint64_t, uint64_t) const;
         double __floatuntidf(uint64_t, uint64_t) const;
         int32_t __cmptf2(uint64_t, uint64_t, uint64_t, uint64_t) const;
         int32_t __eqtf2(uint64_t, uint64_t, uint64_t, uint64_t) const;
         int32_t __netf2(uint64_t, uint64_t, uint64_t, uint64_t) const;
         int32_t __getf2(uint64_t, uint64_t, uint64_t, uint64_t) const;
         int32_t __gttf2(uint64_t, uint64_t, uint64_t, uint64_t) const;
         int32_t __letf2(uint64_t, uint64_t, uint64_t, uint64_t) const;
         int32_t __lttf2(uint64_t, uint64_t, uint64_t, uint64_t) const;
         int32_t __unordtf2(uint64_t, uint64_t, uint64_t, uint64_t) const;
 
      private:
         apply_context& context;
   };
 
}}} // ns sysio::chain::webassembly