#include <algorithm>

#include <random>

#include <iostream>

#include <vector>

#include <iterator>

#include <numeric>

#include <string>

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wsign-compare"

#include <boost/test/unit_test.hpp>

#pragma GCC diagnostic pop

#include <boost/iostreams/concepts.hpp>

#include <boost/iostreams/stream_buffer.hpp>

#include <boost/algorithm/string/predicate.hpp>

#include <eosio/testing/tester.hpp>

#include <eosio/chain/exceptions.hpp>

#include <eosio/chain/account_object.hpp>

#include <eosio/chain/contract_table_objects.hpp>

#include <eosio/chain/block_summary_object.hpp>

#include <eosio/chain/global_property_object.hpp>

#include <eosio/chain/generated_transaction_object.hpp>

#include <eosio/chain/resource_limits.hpp>

#include <fc/crypto/digest.hpp>

#include <fc/exception/exception.hpp>

#include <fc/variant_object.hpp>

#include <Inline/BasicTypes.h>

#include <Runtime/Runtime.h>

#include <contracts.hpp>

#include "test_cfd_transaction.hpp"

#define DUMMY_ACTION_DEFAULT_A 0x45

#define DUMMY_ACTION_DEFAULT_B 0xab11cd1244556677

#define DUMMY_ACTION_DEFAULT_C 0x7451ae12

static constexpr unsigned int DJBH(const char* cp)

{

unsigned int hash = 5381;

while (*cp)

hash = 33 * hash ^ (unsigned char) *cp++;

return hash;

}

struct u128_action {

unsigned __int128 values[3]; //16*3

};

using namespace eosio::chain::literals;

struct invalid_access_action {

uint64_t code;

uint64_t val;

uint32_t index;

bool store;

};

FC_REFLECT( u128_action, (values) )

FC_REFLECT( invalid_access_action, (code)(val)(index)(store) )

#include <eosio/testing/backing_store_tester_macros.hpp>

using namespace eosio;

using namespace eosio::testing;

using namespace chain;

using namespace fc;

using backing_store_ts = boost::mpl::list<TESTER>;

namespace test_detail {

struct chainbase_backing_store_type {

operator eosio::chain::backing_store_type() const { return eosio::chain::backing_store_type::CHAINBASE; }

};

}

using backing_store_type_suite = boost::mpl::list<test_detail::chainbase_backing_store_type>;

namespace bio = boost::iostreams;

template<uint64_t NAME>

struct test_api_action {

static account_name get_account() {

return "testapi"_n;

}

static action_name get_name() {

return action_name(NAME);

}

};

FC_REFLECT_TEMPLATE((uint64_t T), test_api_action<T>, BOOST_PP_SEQ_NIL)

template<uint64_t NAME>

struct test_pause_action {

static account_name get_account() {

return "pause"_n;

}

static action_name get_name() {

return action_name(NAME);

}

};

FC_REFLECT_TEMPLATE((uint64_t T), test_pause_action<T>, BOOST_PP_SEQ_NIL)

template<uint64_t NAME>

struct test_chain_action {

static account_name get_account() {

return account_name(config::system_account_name);

}

static action_name get_name() {

return action_name(NAME);

}

};

FC_REFLECT_TEMPLATE((uint64_t T), test_chain_action<T>, BOOST_PP_SEQ_NIL)

struct check_auth {

account_name account;

permission_name permission;

vector<public_key_type> pubkeys;

};

FC_REFLECT(check_auth, (account)(permission)(pubkeys) )

struct test_permission_last_used_action {

account_name account;

permission_name permission;

fc::time_point last_used_time;

};

FC_REFLECT( test_permission_last_used_action, (account)(permission)(last_used_time) )

struct test_event_wrapper {

name tag;

std::string route;

std::vector<char> data;

};

FC_REFLECT(test_event_wrapper, (tag)(route)(data));

constexpr uint64_t TEST_METHOD(const char* CLASS, const char *METHOD) {

return ( (uint64_t(DJBH(CLASS))<<32) | uint32_t(DJBH(METHOD)) );

}

string I64Str(int64_t i)

{

std::stringstream ss;

ss << i;

return ss.str();

}

string U64Str(uint64_t i)

{

std::stringstream ss;

ss << i;

return ss.str();

}

string U128Str(unsigned __int128 i)

{

return fc::variant(fc::uint128(i)).get_string();

}

template <typename T>

transaction_trace_ptr CallAction(TESTER& test, T ac, const vector<account_name>& scope = {"testapi"_n}) {

signed_transaction trx;

auto pl = vector<permission_level>{{scope[0], config::active_name}};

if (scope.size() > 1)

for (size_t i = 1; i < scope.size(); i++)

pl.push_back({scope[i], config::active_name});

action act(pl, ac);

trx.actions.push_back(act);

test.set_transaction_headers(trx);

auto sigs = trx.sign(test.get_private_key(scope[0], "active"), test.control->get_chain_id());

flat_set<public_key_type> keys;

trx.get_signature_keys(test.control->get_chain_id(), fc::time_point::maximum(), keys);

auto res = test.push_transaction(trx);

BOOST_CHECK_EQUAL(res->receipt->status, transaction_receipt::executed);

test.produce_block();

return res;

}

template <typename T, typename Tester>

std::pair<transaction_trace_ptr, signed_block_ptr> _CallFunction(Tester& test, T ac, const vector<char>& data, const vector<account_name>& scope = {"testapi"_n}, bool no_throw = false) {

{

signed_transaction trx;

auto pl = vector<permission_level>{{scope[0], config::active_name}};

if (scope.size() > 1)

for (unsigned int i = 1; i < scope.size(); i++)

pl.push_back({scope[i], config::active_name});

action act(pl, ac);

act.data = data;

act.authorization = {{"testapi"_n, config::active_name}};

trx.actions.push_back(act);

test.set_transaction_headers(trx, test.DEFAULT_EXPIRATION_DELTA);

auto sigs = trx.sign(test.get_private_key(scope[0], "active"), test.control->get_chain_id());

flat_set<public_key_type> keys;

trx.get_signature_keys(test.control->get_chain_id(), fc::time_point::maximum(), keys);

auto res = test.push_transaction(trx, fc::time_point::maximum(), Tester::DEFAULT_BILLED_CPU_TIME_US, no_throw);

if (!no_throw) {

BOOST_CHECK_EQUAL(res->receipt->status, transaction_receipt::executed);

}

auto block = test.produce_block();

return { res, block };

}

}

template <typename T, typename Tester>

transaction_trace_ptr CallFunction(Tester& test, T ac, const vector<char>& data, const vector<account_name>& scope = {"testapi"_n}, bool no_throw = false) {

{

return _CallFunction(test, ac, data, scope, no_throw).first;

}

}

#define CALL_TEST_FUNCTION(_TESTER, CLS, MTH, DATA) CallFunction(_TESTER, test_api_action<TEST_METHOD(CLS, MTH)>{}, DATA)

#define CALL_TEST_FUNCTION_WITH_BLOCK(_TESTER, CLS, MTH, DATA) _CallFunction(_TESTER, test_api_action<TEST_METHOD(CLS, MTH)>{}, DATA)

#define CALL_TEST_FUNCTION_SYSTEM(_TESTER, CLS, MTH, DATA) CallFunction(_TESTER, test_chain_action<TEST_METHOD(CLS, MTH)>{}, DATA, {config::system_account_name} )

#define CALL_TEST_FUNCTION_SCOPE(_TESTER, CLS, MTH, DATA, ACCOUNT) CallFunction(_TESTER, test_api_action<TEST_METHOD(CLS, MTH)>{}, DATA, ACCOUNT)

#define CALL_TEST_FUNCTION_NO_THROW(_TESTER, CLS, MTH, DATA) CallFunction(_TESTER, test_api_action<TEST_METHOD(CLS, MTH)>{}, DATA, {"testapi"_n}, true)

#define CALL_TEST_FUNCTION_AND_CHECK_EXCEPTION(_TESTER, CLS, MTH, DATA, EXC, EXC_MESSAGE) \

BOOST_CHECK_EXCEPTION( \

CALL_TEST_FUNCTION( _TESTER, CLS, MTH, DATA), \

EXC, \

[](const EXC& e) { \

return expect_assert_message(e, EXC_MESSAGE); \

} \

);

bool is_access_violation(fc::unhandled_exception const & e) {

try {

std::rethrow_exception(e.get_inner_exception());

}

catch (const eosio::chain::wasm_execution_error& e) {

return true;

} catch (...) {

}

return false;

}

bool is_access_violation(const Runtime::Exception& e) { return true; }

bool is_assert_exception(fc::assert_exception const & e) { return true; }

bool is_page_memory_error(page_memory_error const &e) { return true; }

bool is_unsatisfied_authorization(unsatisfied_authorization const & e) { return true;}

bool is_wasm_execution_error(eosio::chain::wasm_execution_error const& e) {return true;}

bool is_tx_net_usage_exceeded(const tx_net_usage_exceeded& e) { return true; }

bool is_block_net_usage_exceeded(const block_net_usage_exceeded& e) { return true; }

bool is_tx_cpu_usage_exceeded(const tx_cpu_usage_exceeded& e) { return true; }

bool is_block_cpu_usage_exceeded(const block_cpu_usage_exceeded& e) { return true; }

bool is_deadline_exception(const deadline_exception& e) { return true; }

auto is_deadline_exception_or_wasm_execution_error(validating_tester& tester) {

return [&tester](const eosio::chain::exception& ex) {

return ex.code() == deadline_exception::code_value ||

(tester.get_config().wasm_runtime == chain::wasm_interface::vm_type::eos_vm_oc &&

ex.code() == wasm_execution_error::code_value);

};

}

/*

* register test suite `api_tests`

*/

BOOST_AUTO_TEST_SUITE(api_tests)

/*

* Print capturing stuff

*/

std::vector<std::string> capture;

struct MySink : public bio::sink

{

std::streamsize write(const char* s, std::streamsize n)

{

std::string tmp;

tmp.assign(s, n);

capture.push_back(tmp);

std::cout << "stream : [" << tmp << "]" << std::endl;

return n;

}

};

uint32_t last_fnc_err = 0;

BOOST_AUTO_TEST_CASE_TEMPLATE(action_receipt_tests, TESTER_T, backing_store_ts) { try {

TESTER_T t;

t.produce_blocks(2);

t.create_account( "test"_n );

t.set_code( "test"_n, contracts::payloadless_wasm() );

t.produce_blocks(1);

auto call_doit_and_check = [&]( account_name contract, account_name signer, auto&& checker ) {

signed_transaction trx;

trx.actions.emplace_back( vector<permission_level>{{signer, config::active_name}}, contract, "doit"_n, bytes{} );

t.set_transaction_headers( trx, t.DEFAULT_EXPIRATION_DELTA );

trx.sign( t.get_private_key(signer, "active"), t.control->get_chain_id() );

auto res = t.push_transaction(trx);

checker( res );

};

auto call_provereset_and_check = [&]( account_name contract, account_name signer, auto&& checker ) {

signed_transaction trx;

trx.actions.emplace_back( vector<permission_level>{{signer, config::active_name}}, contract, "provereset"_n, bytes{} );

t.set_transaction_headers( trx, t.DEFAULT_EXPIRATION_DELTA );

trx.sign( t.get_private_key(signer, "active"), t.control->get_chain_id() );

auto res = t.push_transaction(trx);

checker( res );

};

auto result = t.push_reqauth( config::system_account_name, "active" );

BOOST_REQUIRE_EQUAL( result->receipt->status, transaction_receipt::executed );

BOOST_REQUIRE( result->action_traces[0].receipt->auth_sequence.find( config::system_account_name )

!= result->action_traces[0].receipt->auth_sequence.end() );

auto base_global_sequence_num = result->action_traces[0].receipt->global_sequence;

auto base_system_recv_seq_num = result->action_traces[0].receipt->recv_sequence;

auto base_system_auth_seq_num = result->action_traces[0].receipt->auth_sequence[config::system_account_name];

auto base_system_code_seq_num = result->action_traces[0].receipt->code_sequence.value;

auto base_system_abi_seq_num = result->action_traces[0].receipt->abi_sequence.value;

uint64_t base_test_recv_seq_num = 0;

uint64_t base_test_auth_seq_num = 0;

call_doit_and_check( "test"_n, "test"_n, [&]( const transaction_trace_ptr& res ) {

BOOST_CHECK_EQUAL( res->receipt->status, transaction_receipt::executed );

BOOST_CHECK_EQUAL( res->action_traces[0].receipt->global_sequence, base_global_sequence_num + 1 );

BOOST_CHECK_EQUAL( res->action_traces[0].receipt->code_sequence.value, 1 );

BOOST_CHECK_EQUAL( res->action_traces[0].receipt->abi_sequence.value, 0 );

base_test_recv_seq_num = res->action_traces[0].receipt->recv_sequence;

BOOST_CHECK( base_test_recv_seq_num > 0 );

base_test_recv_seq_num--;

const auto& m = res->action_traces[0].receipt->auth_sequence;

BOOST_CHECK_EQUAL( m.size(), 1 );

BOOST_CHECK_EQUAL( m.begin()->first.to_string(), "test" );

base_test_auth_seq_num = m.begin()->second;

BOOST_CHECK( base_test_auth_seq_num > 0 );

--base_test_auth_seq_num;

} );

t.set_code( "test"_n, contracts::asserter_wasm() );

t.set_code( config::system_account_name, contracts::payloadless_wasm() );

call_provereset_and_check( "test"_n, "test"_n, [&]( const transaction_trace_ptr& res ) {

BOOST_CHECK_EQUAL( res->receipt->status, transaction_receipt::executed );

BOOST_CHECK_EQUAL( res->action_traces[0].receipt->global_sequence, base_global_sequence_num + 4 );

BOOST_CHECK_EQUAL( res->action_traces[0].receipt->recv_sequence, base_test_recv_seq_num + 2 );

BOOST_CHECK_EQUAL( res->action_traces[0].receipt->code_sequence.value, 2 );

BOOST_CHECK_EQUAL( res->action_traces[0].receipt->abi_sequence.value, 0 );

const auto& m = res->action_traces[0].receipt->auth_sequence;

BOOST_CHECK_EQUAL( m.size(), 1 );

BOOST_CHECK_EQUAL( m.begin()->first.to_string(), "test" );

BOOST_CHECK_EQUAL( m.begin()->second, base_test_auth_seq_num + 3 );

} );

t.produce_blocks(1); // Added to avoid the last doit transaction from being considered a duplicate.

// Adding a block also retires an onblock action which increments both the global sequence number

// and the recv and auth sequences numbers for the system account.

call_doit_and_check( config::system_account_name, "test"_n, [&]( const transaction_trace_ptr& res ) {

BOOST_CHECK_EQUAL( res->receipt->status, transaction_receipt::executed );

BOOST_CHECK_EQUAL( res->action_traces[0].receipt->global_sequence, base_global_sequence_num + 6 );

BOOST_CHECK_EQUAL( res->action_traces[0].receipt->recv_sequence, base_system_recv_seq_num + 4 );

BOOST_CHECK_EQUAL( res->action_traces[0].receipt->code_sequence.value, base_system_code_seq_num + 1 );

BOOST_CHECK_EQUAL( res->action_traces[0].receipt->abi_sequence.value, base_system_abi_seq_num );

const auto& m = res->action_traces[0].receipt->auth_sequence;

BOOST_CHECK_EQUAL( m.size(), 1 );

BOOST_CHECK_EQUAL( m.begin()->first.to_string(), "test" );

BOOST_CHECK_EQUAL( m.begin()->second, base_test_auth_seq_num + 4 );

} );

t.set_code( config::system_account_name, contracts::eosio_bios_wasm() );

t.set_code( "test"_n, contracts::eosio_bios_wasm() );

t.set_abi( "test"_n, contracts::eosio_bios_abi().data() );

t.set_code( "test"_n, contracts::payloadless_wasm() );

call_doit_and_check( "test"_n, "test"_n, [&]( const transaction_trace_ptr& res ) {

BOOST_CHECK_EQUAL( res->receipt->status, transaction_receipt::executed);

BOOST_CHECK_EQUAL( res->action_traces[0].receipt->global_sequence, base_global_sequence_num + 11 );

BOOST_CHECK_EQUAL( res->action_traces[0].receipt->recv_sequence, base_test_recv_seq_num + 3 );

BOOST_CHECK_EQUAL( res->action_traces[0].receipt->code_sequence.value, 4 );

BOOST_CHECK_EQUAL( res->action_traces[0].receipt->abi_sequence.value, 1 );

const auto& m = res->action_traces[0].receipt->auth_sequence;

BOOST_CHECK_EQUAL( m.size(), 1 );

BOOST_CHECK_EQUAL( m.begin()->first.to_string(), "test" );

BOOST_CHECK_EQUAL( m.begin()->second, base_test_auth_seq_num + 8 );

} );

} FC_LOG_AND_RETHROW() }

/*************************************************************************************

* action_tests test case

*************************************************************************************/

BOOST_AUTO_TEST_CASE_TEMPLATE(action_tests, TESTER_T, backing_store_ts) { try {

TESTER_T t;

t.produce_blocks(2);

t.create_account( "testapi"_n );

t.create_account( "acc1"_n );

t.create_account( "acc2"_n );

t.create_account( "acc3"_n );

t.create_account( "acc4"_n );

t.produce_blocks(10);

t.set_code( "testapi"_n, contracts::test_api_wasm() );

t.produce_blocks(1);

// test assert_true

CALL_TEST_FUNCTION( t, "test_action", "assert_true", {});

//test assert_false

BOOST_CHECK_EXCEPTION( CALL_TEST_FUNCTION( t, "test_action", "assert_false", {} ),

eosio_assert_message_exception, eosio_assert_message_is("test_action::assert_false") );

// test read_action_normal

dummy_action dummy13{DUMMY_ACTION_DEFAULT_A, DUMMY_ACTION_DEFAULT_B, DUMMY_ACTION_DEFAULT_C};

CALL_TEST_FUNCTION( t, "test_action", "read_action_normal", fc::raw::pack(dummy13));

// test read_action_to_0

std::vector<char> raw_bytes((1<<16));

CALL_TEST_FUNCTION( t, "test_action", "read_action_to_0", raw_bytes );

// test read_action_to_0

raw_bytes.resize((1<<16)+1);

BOOST_CHECK_EXCEPTION(CALL_TEST_FUNCTION( t, "test_action", "read_action_to_0", raw_bytes), eosio::chain::wasm_execution_error,

[](const eosio::chain::wasm_execution_error& e) {

return expect_assert_message(e, "access violation");

}

);

// test read_action_to_64k

raw_bytes.resize(1);

CALL_TEST_FUNCTION( t, "test_action", "read_action_to_64k", raw_bytes );

// test read_action_to_64k

raw_bytes.resize(3);

BOOST_CHECK_EXCEPTION(CALL_TEST_FUNCTION( t, "test_action", "read_action_to_64k", raw_bytes ), eosio::chain::wasm_execution_error,

[](const eosio::chain::wasm_execution_error& e) {

return expect_assert_message(e, "access violation");

}

);

// test require_notice

auto scope = std::vector<account_name>{"testapi"_n};

auto test_require_notice = [&t](auto& test, std::vector<char>& data, std::vector<account_name>& scope){

signed_transaction trx;

auto tm = test_api_action<TEST_METHOD("test_action", "require_notice")>{};

action act(std::vector<permission_level>{{"testapi"_n, config::active_name}}, tm);

vector<char>& dest = *(vector<char> *)(&act.data);

std::copy(data.begin(), data.end(), std::back_inserter(dest));

trx.actions.push_back(act);

test.set_transaction_headers(trx);

trx.sign(test.get_private_key("inita"_n, "active"), t.control->get_chain_id());

auto res = test.push_transaction(trx);

BOOST_CHECK_EQUAL(res->receipt->status, transaction_receipt::executed);

};

BOOST_CHECK_EXCEPTION(test_require_notice(t, raw_bytes, scope), unsatisfied_authorization,

[](const unsatisfied_authorization& e) {

return expect_assert_message(e, "transaction declares authority");

}

);

// test require_auth

BOOST_CHECK_EXCEPTION(CALL_TEST_FUNCTION( t, "test_action", "require_auth", {}), missing_auth_exception,

[](const missing_auth_exception& e) {

return expect_assert_message(e, "missing authority of");

}

);

// test require_auth

auto a3only = std::vector<permission_level>{{"acc3"_n, config::active_name}};

BOOST_CHECK_EXCEPTION(CALL_TEST_FUNCTION( t, "test_action", "require_auth", fc::raw::pack(a3only)), missing_auth_exception,

[](const missing_auth_exception& e) {

return expect_assert_message(e, "missing authority of");

}

);

// test require_auth

auto a4only = std::vector<permission_level>{{"acc4"_n, config::active_name}};

BOOST_CHECK_EXCEPTION(CALL_TEST_FUNCTION( t, "test_action", "require_auth", fc::raw::pack(a4only)), missing_auth_exception,

[](const missing_auth_exception& e) {

return expect_assert_message(e, "missing authority of");

}

);

// test require_auth

auto a3a4 = std::vector<permission_level>{{"acc3"_n, config::active_name}, {"acc4"_n, config::active_name}};

auto a3a4_scope = std::vector<account_name>{"acc3"_n, "acc4"_n};

{

signed_transaction trx;

auto tm = test_api_action<TEST_METHOD("test_action", "require_auth")>{};

auto pl = a3a4;

if (a3a4_scope.size() > 1)

for (unsigned int i=1; i < a3a4_scope.size(); i++)

pl.push_back({a3a4_scope[i], config::active_name});

action act(pl, tm);

auto dat = fc::raw::pack(a3a4);

vector<char>& dest = *(vector<char> *)(&act.data);

std::copy(dat.begin(), dat.end(), std::back_inserter(dest));

act.authorization = {{"testapi"_n, config::active_name}, {"acc3"_n, config::active_name}, {"acc4"_n, config::active_name}};

trx.actions.push_back(act);

t.set_transaction_headers(trx);

trx.sign(t.get_private_key("testapi"_n, "active"), t.control->get_chain_id());

trx.sign(t.get_private_key("acc3"_n, "active"), t.control->get_chain_id());

trx.sign(t.get_private_key("acc4"_n, "active"), t.control->get_chain_id());

auto res = t.push_transaction(trx);

BOOST_CHECK_EQUAL(res->receipt->status, transaction_receipt::executed);

}

uint64_t now = static_cast<uint64_t>( t.control->head_block_time().time_since_epoch().count() );

now += config::block_interval_us;

CALL_TEST_FUNCTION( t, "test_action", "test_current_time", fc::raw::pack(now));

// test current_time

t.produce_block();

BOOST_CHECK_EXCEPTION( CALL_TEST_FUNCTION( t, "test_action", "test_current_time", fc::raw::pack(now) ),

eosio_assert_message_exception, eosio_assert_message_is("tmp == current_time()") );

// test test_current_receiver

CALL_TEST_FUNCTION( t, "test_action", "test_current_receiver", fc::raw::pack("testapi"_n));

// test send_action_sender

// CALL_TEST_FUNCTION( t, "test_transaction", "send_action_sender", fc::raw::pack("testapi"_n));

t.produce_block();

// test_publication_time

uint64_t pub_time = static_cast<uint64_t>( t.control->head_block_time().time_since_epoch().count() );

pub_time += config::block_interval_us;

CALL_TEST_FUNCTION( t, "test_action", "test_publication_time", fc::raw::pack(pub_time) );

// test test_abort

BOOST_CHECK_EXCEPTION(CALL_TEST_FUNCTION( t, "test_action", "test_abort", {} ), abort_called,

[](const fc::exception& e) {

return expect_assert_message(e, "abort() called");

}

);

dummy_action da = { DUMMY_ACTION_DEFAULT_A, DUMMY_ACTION_DEFAULT_B, DUMMY_ACTION_DEFAULT_C };

CallAction(t, da);

BOOST_REQUIRE_EQUAL( t.validate(), true );

} FC_LOG_AND_RETHROW() }

// test require_recipient loop (doesn't cause infinite loop)

BOOST_AUTO_TEST_CASE_TEMPLATE(require_notice_tests, TESTER_T, backing_store_ts) { try {

TESTER_T t;

t.produce_blocks(2);

t.create_account( "testapi"_n );

t.create_account( "acc5"_n );

t.produce_blocks(1);

t.set_code( "testapi"_n, contracts::test_api_wasm() );

t.set_code( "acc5"_n, contracts::test_api_wasm() );

t.produce_blocks(1);

// test require_notice

signed_transaction trx;

auto tm = test_api_action<TEST_METHOD( "test_action", "require_notice_tests" )>{};

action act( std::vector<permission_level>{{"testapi"_n, config::active_name}}, tm );

trx.actions.push_back( act );

t.set_transaction_headers( trx );

trx.sign( t.get_private_key( "testapi"_n, "active" ), t.control->get_chain_id() );

auto res = t.push_transaction( trx );

BOOST_CHECK_EQUAL( res->receipt->status, transaction_receipt::executed );

} FC_LOG_AND_RETHROW() }

BOOST_AUTO_TEST_CASE_TEMPLATE(ram_billing_in_notify_tests, TYPE_T, backing_store_type_suite) { try {

TYPE_T bs_type;

fc::temp_directory tempdir;

validating_tester chain( tempdir, true, {bs_type} );

chain.execute_setup_policy( setup_policy::preactivate_feature_and_new_bios );

const auto& pfm = chain.control->get_protocol_feature_manager();

const auto& d = pfm.get_builtin_digest(builtin_protocol_feature_t::action_return_value); // testapi requires this

BOOST_REQUIRE(d);

chain.preactivate_protocol_features( {*d} );

const auto& d2 = pfm.get_builtin_digest(builtin_protocol_feature_t::configurable_wasm_limits); // needed to avoid 'Too many function defs' when using CDT 3.0

BOOST_REQUIRE(d2);

chain.preactivate_protocol_features( {*d2} );

const auto& d3 = pfm.get_builtin_digest(builtin_protocol_feature_t::event_generation); // testapi requires this since it uses push_event

BOOST_REQUIRE(d3);

chain.preactivate_protocol_features( {*d3} );

chain.produce_blocks(2);

chain.create_account( "testapi"_n );

chain.create_account( "testapi2"_n );

chain.produce_blocks(10);

chain.set_code( "testapi"_n, contracts::test_api_wasm() );

chain.produce_blocks(1);

chain.set_code( "testapi2"_n, contracts::test_api_wasm() );

chain.produce_blocks(1);

BOOST_CHECK_EXCEPTION( CALL_TEST_FUNCTION( chain, "test_action", "test_ram_billing_in_notify",

fc::raw::pack( ((unsigned __int128)"testapi2"_n.to_uint64_t() << 64) | "testapi"_n.to_uint64_t() ) ),

subjective_block_production_exception,

fc_exception_message_is("Cannot charge RAM to other accounts during notify.")

);

CALL_TEST_FUNCTION( chain, "test_action", "test_ram_billing_in_notify", fc::raw::pack( ((unsigned __int128)"testapi2"_n.to_uint64_t() << 64) | 0 ) );

CALL_TEST_FUNCTION( chain, "test_action", "test_ram_billing_in_notify", fc::raw::pack( ((unsigned __int128)"testapi2"_n.to_uint64_t() << 64) | "testapi2"_n.to_uint64_t() ) );

BOOST_REQUIRE_EQUAL( chain.validate(), true );

} FC_LOG_AND_RETHROW() }

/*************************************************************************************

* context free action tests

*************************************************************************************/

BOOST_AUTO_TEST_CASE_TEMPLATE(cf_action_tests, TESTER_T, backing_store_ts) { try {

TESTER_T t;

t.produce_blocks(2);

t.create_account( "testapi"_n );

t.create_account( "dummy"_n );

t.produce_blocks(10);

t.set_code( "testapi"_n, contracts::test_api_wasm() );

t.produce_blocks(1);

cf_action cfa;

signed_transaction trx;

t.set_transaction_headers(trx);

// need at least one normal action

BOOST_CHECK_EXCEPTION(t.push_transaction(trx), tx_no_auths,

[](const fc::assert_exception& e) {

return expect_assert_message(e, "transaction must have at least one authorization");

}

);

action act({}, cfa);

trx.context_free_actions.push_back(act);

trx.context_free_data.emplace_back(fc::raw::pack<uint32_t>(100)); // verify payload matches context free data

trx.context_free_data.emplace_back(fc::raw::pack<uint32_t>(200));

t.set_transaction_headers(trx);

BOOST_CHECK_EXCEPTION(t.push_transaction(trx), tx_no_auths,

[](const fc::exception& e) {

return expect_assert_message(e, "transaction must have at least one authorization");

}

);

trx.signatures.clear();

// add a normal action along with cfa

dummy_action da = { DUMMY_ACTION_DEFAULT_A, DUMMY_ACTION_DEFAULT_B, DUMMY_ACTION_DEFAULT_C };

auto pl = vector<permission_level>{{"testapi"_n, config::active_name}};

action act1(pl, da);

trx.actions.push_back(act1);

t.set_transaction_headers(trx);

// run normal passing case

auto sigs = trx.sign(t.get_private_key("testapi"_n, "active"), t.control->get_chain_id());

auto res = t.push_transaction(trx);

BOOST_CHECK_EQUAL(res->receipt->status, transaction_receipt::executed);

// attempt to access context free api in non context free action

da = { DUMMY_ACTION_DEFAULT_A, 200, DUMMY_ACTION_DEFAULT_C };

action act2(pl, da);

trx.signatures.clear();

trx.actions.clear();

trx.actions.push_back(act2);

t.set_transaction_headers(trx);

// run (dummy_action.b = 200) case looking for invalid use of context_free api

sigs = trx.sign(t.get_private_key("testapi"_n, "active"), t.control->get_chain_id());

BOOST_CHECK_EXCEPTION(t.push_transaction(trx), unaccessible_api,

[](const fc::exception& e) {

return expect_assert_message(e, "this API may only be called from context_free apply");

}

);

{

// back to normal action

action act1(pl, da);

signed_transaction trx;

trx.context_free_actions.push_back(act);

trx.context_free_data.emplace_back(fc::raw::pack<uint32_t>(100)); // verify payload matches context free data

trx.context_free_data.emplace_back(fc::raw::pack<uint32_t>(200));

trx.actions.push_back(act1);

// attempt to access non context free api

for (uint32_t i = 200; i <= 213; ++i) {

trx.context_free_actions.clear();

trx.context_free_data.clear();

cfa.payload = i;

cfa.cfd_idx = 1;

action cfa_act({}, cfa);

trx.context_free_actions.emplace_back(cfa_act);

trx.signatures.clear();

t.set_transaction_headers(trx);

sigs = trx.sign(t.get_private_key("testapi"_n, "active"), t.control->get_chain_id());

BOOST_CHECK_EXCEPTION(t.push_transaction(trx), unaccessible_api,

[](const fc::exception& e) {

return expect_assert_message(e, "only context free api's can be used in this context" );

}

);

}

}

t.produce_block();

// test send context free action

auto ttrace = CALL_TEST_FUNCTION( t, "test_transaction", "send_cf_action", {} );

BOOST_REQUIRE_EQUAL(ttrace->action_traces.size(), 2);

BOOST_CHECK_EQUAL((int)(ttrace->action_traces[1].creator_action_ordinal), 1);

BOOST_CHECK_EQUAL(ttrace->action_traces[1].receiver, account_name("dummy"));

BOOST_CHECK_EQUAL(ttrace->action_traces[1].act.account, account_name("dummy"));

BOOST_CHECK_EQUAL(ttrace->action_traces[1].act.name, account_name("event1"));

BOOST_CHECK_EQUAL(ttrace->action_traces[1].act.authorization.size(), 0);

BOOST_CHECK_EXCEPTION( CALL_TEST_FUNCTION( t, "test_transaction", "send_cf_action_fail", {} ),

eosio_assert_message_exception,

eosio_assert_message_is("context free actions cannot have authorizations") );

BOOST_REQUIRE_EQUAL( t.validate(), true );

} FC_LOG_AND_RETHROW() }

BOOST_AUTO_TEST_CASE_TEMPLATE(cfa_tx_signature, TESTER_T, backing_store_ts) { try {

TESTER_T t;

action cfa({}, cf_action());

signed_transaction tx1;

tx1.context_free_data.emplace_back(fc::raw::pack<uint32_t>(100));

tx1.context_free_actions.push_back(cfa);

t.set_transaction_headers(tx1);

signed_transaction tx2;

tx2.context_free_data.emplace_back(fc::raw::pack<uint32_t>(200));

tx2.context_free_actions.push_back(cfa);

t.set_transaction_headers(tx2);

const private_key_type& priv_key = t.get_private_key(name("dummy"), "active");

BOOST_TEST(tx1.sign(priv_key, t.control->get_chain_id()).to_string() != tx2.sign(priv_key, t.control->get_chain_id()).to_string());

BOOST_REQUIRE_EQUAL( t.validate(), true );

} FC_LOG_AND_RETHROW() }

BOOST_FIXTURE_TEST_CASE(cfa_stateful_api, TESTER) try {

create_account( "testapi"_n );

produce_blocks(1);

set_code( "testapi"_n, contracts::test_api_wasm() );

account_name a = "testapi2"_n;

account_name creator = config::system_account_name;

signed_transaction trx;

trx.actions.emplace_back( vector<permission_level>{{creator,config::active_name}},

newaccount{

.creator = creator,

.name = a,

.owner = authority( get_public_key( a, "owner" ) ),

.active = authority( get_public_key( a, "active" ) )

});

action act({}, test_api_action<TEST_METHOD("test_transaction", "stateful_api")>{});

trx.context_free_actions.push_back(act);

set_transaction_headers(trx);

trx.sign( get_private_key( creator, "active" ), control->get_chain_id() );

BOOST_CHECK_EXCEPTION(push_transaction( trx ), fc::exception,

[&](const fc::exception &e) {

return expect_assert_message(e, "only context free api's can be used in this context");

});

BOOST_REQUIRE_EQUAL( validate(), true );

} FC_LOG_AND_RETHROW()

BOOST_AUTO_TEST_CASE_TEMPLATE(light_validation_skip_cfa, TYPE_T, backing_store_type_suite) { try {

TYPE_T bs_type;

tester chain(setup_policy::full, db_read_mode::SPECULATIVE, std::optional<uint32_t>{}, std::optional<uint32_t>{}, {bs_type});

std::vector<signed_block_ptr> blocks;

blocks.push_back(chain.produce_block());

chain.create_account( "testapi"_n );

chain.create_account( "dummy"_n );

blocks.push_back(chain.produce_block());

chain.set_code( "testapi"_n, contracts::test_api_wasm() );

blocks.push_back(chain.produce_block());

cf_action cfa;

signed_transaction trx;

action act({}, cfa);

trx.context_free_actions.push_back(act);

trx.context_free_data.emplace_back(fc::raw::pack<uint32_t>(100)); // verify payload matches context free data

trx.context_free_data.emplace_back(fc::raw::pack<uint32_t>(200));

// add a normal action along with cfa

dummy_action da = { DUMMY_ACTION_DEFAULT_A, DUMMY_ACTION_DEFAULT_B, DUMMY_ACTION_DEFAULT_C };

action act1(vector<permission_level>{{"testapi"_n, config::active_name}}, da);

trx.actions.push_back(act1);

chain.set_transaction_headers(trx);

// run normal passing case

auto sigs = trx.sign(chain.get_private_key("testapi"_n, "active"), chain.control->get_chain_id());

auto trace = chain.push_transaction(trx);

blocks.push_back(chain.produce_block());

BOOST_REQUIRE(trace->receipt);

BOOST_CHECK_EQUAL(trace->receipt->status, transaction_receipt::executed);

BOOST_CHECK_EQUAL(2, trace->action_traces.size());

BOOST_CHECK(trace->action_traces.at(0).context_free); // cfa

BOOST_CHECK_EQUAL("test\n", trace->action_traces.at(0).console); // cfa executed

BOOST_CHECK(!trace->action_traces.at(1).context_free); // non-cfa

BOOST_CHECK_EQUAL("", trace->action_traces.at(1).console);

fc::temp_directory tempdir;

auto conf_genesis = tester::default_config( tempdir );

auto& cfg = conf_genesis.first;

cfg.trusted_producers = { "eosio"_n }; // light validation

tester other( conf_genesis.first, conf_genesis.second );

other.execute_setup_policy( setup_policy::full );

transaction_trace_ptr other_trace;

auto cc = other.control->applied_transaction.connect( [&](std::tuple<const transaction_trace_ptr&, const packed_transaction_ptr&> x) {

auto& t = std::get<0>(x);

if( t && t->id == trace->id ) {

other_trace = t;

}

} );

for (auto& new_block : blocks) {

other.push_block(new_block);

}

blocks.clear();

BOOST_REQUIRE(other_trace);

BOOST_REQUIRE(other_trace->receipt);

BOOST_CHECK_EQUAL(other_trace->receipt->status, transaction_receipt::executed);

BOOST_CHECK(*trace->receipt == *other_trace->receipt);

BOOST_CHECK_EQUAL(2, other_trace->action_traces.size());

BOOST_CHECK(other_trace->action_traces.at(0).context_free); // cfa

BOOST_CHECK_EQUAL("", other_trace->action_traces.at(0).console); // cfa not executed for light validation (trusted t.validater)

BOOST_CHECK_EQUAL(trace->action_traces.at(0).receipt->global_sequence, other_trace->action_traces.at(0).receipt->global_sequence);

BOOST_CHECK_EQUAL(trace->action_traces.at(0).receipt->digest(), other_trace->action_traces.at(0).receipt->digest());

BOOST_CHECK(!other_trace->action_traces.at(1).context_free); // non-cfa

BOOST_CHECK_EQUAL("", other_trace->action_traces.at(1).console);

BOOST_CHECK_EQUAL(trace->action_traces.at(1).receipt->global_sequence, other_trace->action_traces.at(1).receipt->global_sequence);

BOOST_CHECK_EQUAL(trace->action_traces.at(1).receipt->digest(), other_trace->action_traces.at(1).receipt->digest());

other.close();

} FC_LOG_AND_RETHROW() }

/*************************************************************************************

* checktime_tests test case

*************************************************************************************/

BOOST_AUTO_TEST_CASE_TEMPLATE(checktime_pass_tests, TESTER_T, backing_store_ts) { try {

TESTER_T t;

t.produce_blocks(2);

t.create_account( "testapi"_n );

t.produce_blocks(10);

t.set_code( "testapi"_n, contracts::test_api_wasm() );

t.produce_blocks(1);

// test checktime_pass

CALL_TEST_FUNCTION( t, "test_checktime", "checktime_pass", {});

BOOST_REQUIRE_EQUAL( t.validate(), true );

} FC_LOG_AND_RETHROW() }

template<class T, typename Tester>

void call_test(Tester& test, T ac, uint32_t billed_cpu_time_us, uint32_t max_cpu_usage_ms, uint32_t max_block_cpu_ms, std::vector<char> payload = {}, name account = "testapi"_n ) {

signed_transaction trx;

auto pl = vector<permission_level>{{account, config::active_name}};

action act(pl, ac);

act.data = payload;

trx.actions.push_back(act);

test.set_transaction_headers(trx);

auto sigs = trx.sign(test.get_private_key(account, "active"), test.control->get_chain_id());

flat_set<public_key_type> keys;

trx.get_signature_keys(test.control->get_chain_id(), fc::time_point::maximum(), keys);

auto ptrx = std::make_shared<packed_transaction>( std::move(trx), true );

auto fut = transaction_metadata::start_recover_keys( std::move( ptrx ), test.control->get_thread_pool(),

test.control->get_chain_id(), fc::microseconds::maximum(),

transaction_metadata::trx_type::input );

auto res = test.control->push_transaction( fut.get(), fc::time_point::now() + fc::milliseconds(max_block_cpu_ms),

fc::milliseconds(max_cpu_usage_ms), billed_cpu_time_us, billed_cpu_time_us > 0, 0 );

if( res->except_ptr ) std::rethrow_exception( res->except_ptr );

if( res->except ) throw *res->except;

test.produce_block();

};

BOOST_AUTO_TEST_CASE_TEMPLATE(checktime_fail_tests, TESTER_T, backing_store_ts) { try {

TESTER_T t;

t.produce_blocks(2);

ilog( "create account" );

t.create_account( "testapi"_n );

ilog( "set code" );

t.set_code( "testapi"_n, contracts::test_api_wasm() );

ilog( "produce block" );

t.produce_blocks(1);

int64_t ram_bytes; int64_t net; int64_t cpu;

auto& rl = t.control->get_resource_limits_manager();

rl.get_account_limits( "testapi"_n, ram_bytes, net, cpu );

idump(("account")(net)(cpu));

auto net_limit = rl.get_block_net_limit();

auto cpu_limit = rl.get_block_cpu_limit();

idump(("block")(net_limit)(cpu_limit));

BOOST_CHECK_EXCEPTION( call_test( t, test_api_action<TEST_METHOD("test_checktime", "checktime_failure")>{},

5000, 200, 200, fc::raw::pack(10000000000000000000ULL) ),

deadline_exception, is_deadline_exception );

BOOST_CHECK_EXCEPTION( call_test( t, test_api_action<TEST_METHOD("test_checktime", "checktime_failure")>{},

0, 200, 200, fc::raw::pack(10000000000000000000ULL) ),

tx_cpu_usage_exceeded, is_tx_cpu_usage_exceeded );

// test override_chain_cpu_limits

cpu_limit = rl.get_block_cpu_limit();

BOOST_CHECK( cpu_limit <= 775000 ); // verify block cpu limit lower than allowed otherwise not testing deadline

auto before = fc::time_point::now();

t.control->set_override_chain_cpu_limits(true);

BOOST_CHECK_EXCEPTION( call_test( t, test_api_action<TEST_METHOD("test_checktime", "checktime_failure")>{},

0, 775, 775, fc::raw::pack(10000000000000000000ULL) ),

tx_cpu_usage_exceeded, is_tx_cpu_usage_exceeded );

auto after = fc::time_point::now();

BOOST_CHECK( (after - before).count() >= 775*1000 );

dlog("elapsed {e}", ("e", (after - before).count()));

t.control->set_override_chain_cpu_limits(false);

// test block_cpu_usage restriction

uint32_t time_left_in_block_us = config::default_max_block_cpu_usage - config::default_min_transaction_cpu_usage;

std::string dummy_string = "nonce";

uint32_t increment = config::default_max_transaction_cpu_usage / 3;

for( auto i = 0; time_left_in_block_us > 2*increment; ++i ) {

t.push_dummy( "testapi"_n, dummy_string + std::to_string(i), increment );

time_left_in_block_us -= increment;

}

net_limit = rl.get_block_net_limit();

cpu_limit = rl.get_block_cpu_limit();

idump(("block")(net_limit)(cpu_limit));

BOOST_CHECK( cpu_limit <= 200000 ); // verify block cpu limit lower than 200 otherwise not testing block_cpu limit

BOOST_CHECK_EXCEPTION( call_test( t, test_api_action<TEST_METHOD("test_checktime", "checktime_failure")>{},

0, 200, 200, fc::raw::pack(10000000000000000000ULL) ),

block_cpu_usage_exceeded, is_block_cpu_usage_exceeded );

BOOST_REQUIRE_EQUAL( t.validate(), true );

} FC_LOG_AND_RETHROW() }

BOOST_AUTO_TEST_CASE(checktime_pause_override_test) { try {

fc::temp_directory tempdir;

auto conf_genesis = tester::default_config( tempdir );

auto& cfg = conf_genesis.second.initial_configuration;

cfg.max_block_cpu_usage = 150'000;

cfg.max_transaction_cpu_usage = 24'999; // needs to be large enough for create_account and set_code

cfg.min_transaction_cpu_usage = 1;

tester t( conf_genesis.first, conf_genesis.second );

if( t.get_config().wasm_runtime == wasm_interface::vm_type::eos_vm_oc || t.get_config().wasm_runtime == wasm_interface::vm_type::native_module ) {

// eos_vm_oc wasm_runtime does not tier-up and completes compile before continuing execution.

// A completely different test with different constraints would be needed to test with eos_vm_oc.

// Since non-tier-up is not a normal valid nodeos runtime, just skip this test for eos_vm_oc.

// native_module loads very quickly so can't really tell difference by timing.

return;

}

t.execute_setup_policy( setup_policy::full );

t.produce_blocks(2);

ilog( "create account" );

t.create_account( "pause"_n );

ilog( "set code" );

t.set_code( "pause"_n, contracts::test_api_wasm() );

ilog( "produce block" );

t.produce_blocks(1);

int64_t ram_bytes; int64_t net; int64_t cpu;

auto& rl = t.control->get_resource_limits_manager();

rl.get_account_limits( "pause"_n, ram_bytes, net, cpu );