/**

* @file

* @copyright defined in eos/LICENSE

* @defgroup eosclienttool EOSIO Command Line Client Reference

* @brief Tool for sending transactions and querying state from @ref nodeos

* @ingroup eosclienttool

*/

/**

@defgroup eosclienttool

@section intro Introduction to cleos

`cleos` is a command line tool that interfaces with the REST api exposed by @ref nodeos. In order to use `cleos` you will need to

have a local copy of `nodeos` running and configured to load the 'eosio::chain_api_plugin'.

cleos contains documentation for all of its commands. For a list of all commands known to cleos, simply run it with no arguments:

```

$ ./cleos

Command Line Interface to EOSIO Client

Usage: programs/cleos/cleos [OPTIONS] SUBCOMMAND

Options:

-h,--help Print this help message and exit

-u,--url TEXT=http://localhost:8888/

the http/https URL where nodeos is running

--wallet-url TEXT=http://localhost:8888/

the http/https URL where keosd is running

-r,--header pass specific HTTP header, repeat this option to pass multiple headers

-n,--no-verify don't verify peer certificate when using HTTPS

-v,--verbose output verbose errors and action output

Subcommands:

version Retrieve version information

create Create various items, on and off the blockchain

get Retrieve various items and information from the blockchain

set Set or update blockchain state

transfer Transfer tokens from account to account

net Interact with local p2p network connections

wallet Interact with local wallet

sign Sign a transaction

push Push arbitrary transactions to the blockchain

multisig Multisig contract commands

```

To get help with any particular subcommand, run it with no arguments as well:

```

$ ./cleos create

Create various items, on and off the blockchain

Usage: ./cleos create SUBCOMMAND

Subcommands:

key Create a new keypair and print the public and private keys

account Create a new account on the blockchain (assumes system contract does not restrict RAM usage)

$ ./cleos create account

Create a new account on the blockchain (assumes system contract does not restrict RAM usage)

Usage: ./cleos create account [OPTIONS] creator name OwnerKey ActiveKey

Positionals:

creator TEXT The name of the account creating the new account

name TEXT The name of the new account

OwnerKey TEXT The owner public key for the new account

ActiveKey TEXT The active public key for the new account

Options:

-x,--expiration set the time in seconds before a transaction expires, defaults to 30s

-f,--force-unique force the transaction to be unique. this will consume extra bandwidth and remove any protections against accidently issuing the same transaction multiple times

-s,--skip-sign Specify if unlocked wallet keys should be used to sign transaction

-d,--dont-broadcast don't broadcast transaction to the network (just print to stdout)

-p,--permission TEXT ... An account and permission level to authorize, as in 'account@permission' (defaults to 'creator@active')

```

*/

#include <pwd.h>

#include <string>

#include <vector>

#include <regex>

#include <iostream>

#include <fc/crypto/hex.hpp>

#include <fc/variant.hpp>

#include <fc/io/datastream.hpp>

#include <fc/io/json.hpp>

#include <fc/io/console.hpp>

#include <fc/exception/exception.hpp>

#include <fc/variant_object.hpp>

#include <fc/static_variant.hpp>

#include <eosio/chain/name.hpp>

#include <eosio/chain/config.hpp>

#include <eosio/chain/wast_to_wasm.hpp>

#include <eosio/chain/trace.hpp>

#include <eosio/chain_plugin/chain_plugin.hpp>

#include <eosio/chain/contract_types.hpp>

#pragma push_macro("N")

#undef N

#include <boost/asio.hpp>

#include <boost/format.hpp>

#include <boost/dll/runtime_symbol_info.hpp>

#include <boost/filesystem.hpp>

#include <boost/process.hpp>

#include <boost/process/spawn.hpp>

#include <boost/range/algorithm/find_if.hpp>

#include <boost/range/algorithm/sort.hpp>

#include <boost/range/adaptor/transformed.hpp>

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

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

#include <boost/range/algorithm/copy.hpp>

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

#pragma pop_macro("N")

#include <Inline/BasicTypes.h>

#include <IR/Module.h>

#include <IR/Validate.h>

#include <WASM/WASM.h>

#include <Runtime/Runtime.h>

#include <fc/io/fstream.hpp>

#include "CLI11.hpp"

#include "help_text.hpp"

#include "localize.hpp"

#include "config.hpp"

#include "httpc.hpp"

using namespace std;

using namespace eosio;

using namespace eosio::chain;

using namespace eosio::client::help;

using namespace eosio::client::http;

using namespace eosio::client::localize;

using namespace eosio::client::config;

using namespace boost::filesystem;

using auth_type = fc::static_variant<public_key_type, permission_level>;

FC_DECLARE_EXCEPTION( explained_exception, 9000000, "explained exception, see error log" );

FC_DECLARE_EXCEPTION( localized_exception, 10000000, "an error occured" );

#define EOSC_ASSERT( TEST, ... ) \

FC_EXPAND_MACRO( \

FC_MULTILINE_MACRO_BEGIN \

if( UNLIKELY(!(TEST)) ) \

{ \

std::cerr << localized( __VA_ARGS__ ) << std::endl; \

FC_THROW_EXCEPTION( explained_exception, #TEST ); \

} \

FC_MULTILINE_MACRO_END \

)

//copy pasta from keosd's main.cpp

bfs::path determine_home_directory()

{

bfs::path home;

struct passwd* pwd = getpwuid(getuid());

if(pwd) {

home = pwd->pw_dir;

}

else {

home = getenv("HOME");

}

if(home.empty())

home = "./";

return home;

}

string url = "http://127.0.0.1:8888/";

string default_wallet_url = "unix://" + (determine_home_directory() / "eosio-wallet" / (string(key_store_executable_name) + ".sock")).string();

string wallet_url; //to be set to default_wallet_url in main

bool no_verify = false;

vector<string> headers;

auto tx_expiration = fc::seconds(30);

const fc::microseconds abi_serializer_max_time = fc::seconds(10); // No risk to client side serialization taking a long time

string tx_ref_block_num_or_id;

bool tx_force_unique = false;

bool tx_dont_broadcast = false;

bool tx_return_packed = false;

bool tx_skip_sign = false;

bool tx_print_json = false;

bool print_request = false;

bool print_response = false;

bool no_auto_keosd = false;

bool verbose = false;

uint8_t tx_max_cpu_usage = 0;

uint32_t tx_max_net_usage = 0;

uint32_t delaysec = 0;

vector<string> tx_permission;

eosio::client::http::http_context context;

void add_standard_transaction_options(CLI::App* cmd, string default_permission = "") {

CLI::callback_t parse_expiration = [](CLI::results_t res) -> bool {

double value_s;

if (res.size() == 0 || !CLI::detail::lexical_cast(res[0], value_s)) {

return false;

}

tx_expiration = fc::seconds(static_cast<uint64_t>(value_s));

return true;

};

cmd->add_option("-x,--expiration", parse_expiration, localized("set the time in seconds before a transaction expires, defaults to 30s"));

cmd->add_flag("-f,--force-unique", tx_force_unique, localized("force the transaction to be unique. this will consume extra bandwidth and remove any protections against accidently issuing the same transaction multiple times"));

cmd->add_flag("-s,--skip-sign", tx_skip_sign, localized("Specify if unlocked wallet keys should be used to sign transaction"));

cmd->add_flag("-j,--json", tx_print_json, localized("print result as json"));

cmd->add_flag("-d,--dont-broadcast", tx_dont_broadcast, localized("don't broadcast transaction to the network (just print to stdout)"));

cmd->add_flag("--return-packed", tx_return_packed, localized("used in conjunction with --dont-broadcast to get the packed transaction"));

cmd->add_option("-r,--ref-block", tx_ref_block_num_or_id, (localized("set the reference block num or block id used for TAPOS (Transaction as Proof-of-Stake)")));

string msg = "An account and permission level to authorize, as in 'account@permission'";

if(!default_permission.empty())

msg += " (defaults to '" + default_permission + "')";

cmd->add_option("-p,--permission", tx_permission, localized(msg.c_str()));

cmd->add_option("--max-cpu-usage-ms", tx_max_cpu_usage, localized("set an upper limit on the milliseconds of cpu usage budget, for the execution of the transaction (defaults to 0 which means no limit)"));

cmd->add_option("--max-net-usage", tx_max_net_usage, localized("set an upper limit on the net usage budget, in bytes, for the transaction (defaults to 0 which means no limit)"));

cmd->add_option("--delay-sec", delaysec, localized("set the delay_sec seconds, defaults to 0s"));

}

vector<chain::permission_level> get_account_permissions(const vector<string>& permissions) {

auto fixedPermissions = permissions | boost::adaptors::transformed([](const string& p) {

vector<string> pieces;

split(pieces, p, boost::algorithm::is_any_of("@"));

if( pieces.size() == 1 ) pieces.push_back( "active" );

return chain::permission_level{ .actor = pieces[0], .permission = pieces[1] };

});

vector<chain::permission_level> accountPermissions;

boost::range::copy(fixedPermissions, back_inserter(accountPermissions));

return accountPermissions;

}

vector<chain::permission_level> get_account_permissions(const vector<string>& permissions, const chain::permission_level& default_permission) {

if (permissions.empty())

return vector<chain::permission_level>{default_permission};

else

return get_account_permissions(tx_permission);

}

template<typename T>

fc::variant call( const std::string& url,

const std::string& path,

const T& v ) {

try {

auto sp = std::make_unique<eosio::client::http::connection_param>(context, parse_url(/sitelet?url=https%3A%2F%2Fgithub.com%2FDorianRust%2Feos%2Fblob%2Fmaster%2Fprograms%2Fcleos%2Furl) + path, no_verify ? false : true, headers);

return eosio::client::http::do_http_call(*sp, fc::variant(v), print_request, print_response );

}

catch(boost::system::system_error& e) {

if(url == ::url)

std::cerr << localized("Failed to connect to nodeos at ${u}; is nodeos running?", ("u", url)) << std::endl;

else if(url == ::wallet_url)

std::cerr << localized("Failed to connect to keosd at ${u}; is keosd running?", ("u", url)) << std::endl;

throw connection_exception(fc::log_messages{FC_LOG_MESSAGE(error, e.what())});

}

}

template<typename T>

fc::variant call( const std::string& path,

const T& v ) { return call( url, path, fc::variant(v) ); }

template<>

fc::variant call( const std::string& url,

const std::string& path) { return call( url, path, fc::variant() ); }

eosio::chain_apis::read_only::get_info_results get_info() {

return call(url, get_info_func).as<eosio::chain_apis::read_only::get_info_results>();

}

string generate_nonce_string() {

return fc::to_string(fc::time_point::now().time_since_epoch().count());

}

chain::action generate_nonce_action() {

return chain::action( {}, config::null_account_name, "nonce", fc::raw::pack(fc::time_point::now().time_since_epoch().count()));

}

void prompt_for_wallet_password(string& pw, const string& name) {

if(pw.size() == 0 && name != "SecureEnclave") {

std::cout << localized("password: ");

fc::set_console_echo(false);

std::getline( std::cin, pw, '\n' );

fc::set_console_echo(true);

}

}

fc::variant determine_required_keys(const signed_transaction& trx) {

// TODO better error checking

//wdump((trx));

const auto& public_keys = call(wallet_url, wallet_public_keys);

auto get_arg = fc::mutable_variant_object

("transaction", (transaction)trx)

("available_keys", public_keys);

const auto& required_keys = call(get_required_keys, get_arg);

return required_keys["required_keys"];

}

void sign_transaction(signed_transaction& trx, fc::variant& required_keys, const chain_id_type& chain_id) {

fc::variants sign_args = {fc::variant(trx), required_keys, fc::variant(chain_id)};

const auto& signed_trx = call(wallet_url, wallet_sign_trx, sign_args);

trx = signed_trx.as<signed_transaction>();

}

fc::variant push_transaction( signed_transaction& trx, int32_t extra_kcpu = 1000, packed_transaction::compression_type compression = packed_transaction::none ) {

auto info = get_info();

if (trx.signatures.size() == 0) { // #5445 can't change txn content if already signed

trx.expiration = info.head_block_time + tx_expiration;

// Set tapos, default to last irreversible block if it's not specified by the user

block_id_type ref_block_id = info.last_irreversible_block_id;

try {

fc::variant ref_block;

if (!tx_ref_block_num_or_id.empty()) {

ref_block = call(get_block_func, fc::mutable_variant_object("block_num_or_id", tx_ref_block_num_or_id));

ref_block_id = ref_block["id"].as<block_id_type>();

}

} EOS_RETHROW_EXCEPTIONS(invalid_ref_block_exception, "Invalid reference block num or id: ${block_num_or_id}", ("block_num_or_id", tx_ref_block_num_or_id));

trx.set_reference_block(ref_block_id);

if (tx_force_unique) {

trx.context_free_actions.emplace_back( generate_nonce_action() );

}

trx.max_cpu_usage_ms = tx_max_cpu_usage;

trx.max_net_usage_words = (tx_max_net_usage + 7)/8;

trx.delay_sec = delaysec;

}

if (!tx_skip_sign) {

auto required_keys = determine_required_keys(trx);

sign_transaction(trx, required_keys, info.chain_id);

}

if (!tx_dont_broadcast) {

return call(push_txn_func, packed_transaction(trx, compression));

} else {

if (!tx_return_packed) {

return fc::variant(trx);

} else {

return fc::variant(packed_transaction(trx, compression));

}

}

}

fc::variant push_actions(std::vector<chain::action>&& actions, int32_t extra_kcpu, packed_transaction::compression_type compression = packed_transaction::none ) {

signed_transaction trx;

trx.actions = std::forward<decltype(actions)>(actions);

return push_transaction(trx, extra_kcpu, compression);

}

void print_action( const fc::variant& at ) {

const auto& receipt = at["receipt"];

auto receiver = receipt["receiver"].as_string();

const auto& act = at["act"].get_object();

auto code = act["account"].as_string();

auto func = act["name"].as_string();

auto args = fc::json::to_string( act["data"] );

auto console = at["console"].as_string();

/*

if( code == "eosio" && func == "setcode" )

args = args.substr(40)+"...";

if( name(code) == config::system_account_name && func == "setabi" )

args = args.substr(40)+"...";

*/

if( args.size() > 100 ) args = args.substr(0,100) + "...";

cout << "#" << std::setw(14) << right << receiver << " <= " << std::setw(28) << std::left << (code +"::" + func) << " " << args << "\n";

if( console.size() ) {

std::stringstream ss(console);

string line;

while( std::getline( ss, line ) ) {

cout << ">> " << line << "\n";

if( !verbose ) break;

}

}

}

//resolver for ABI serializer to decode actions in proposed transaction in multisig contract

auto abi_serializer_resolver = [](const name& account) -> optional<abi_serializer> {

static unordered_map<account_name, optional<abi_serializer> > abi_cache;

auto it = abi_cache.find( account );

if ( it == abi_cache.end() ) {

auto result = call(get_abi_func, fc::mutable_variant_object("account_name", account));

auto abi_results = result.as<eosio::chain_apis::read_only::get_abi_results>();

optional<abi_serializer> abis;

if( abi_results.abi.valid() ) {

abis.emplace( *abi_results.abi, abi_serializer_max_time );

} else {

std::cerr << "ABI for contract " << account.to_string() << " not found. Action data will be shown in hex only." << std::endl;

}

abi_cache.emplace( account, abis );

return abis;

}

return it->second;

};

bytes variant_to_bin( const account_name& account, const action_name& action, const fc::variant& action_args_var ) {

auto abis = abi_serializer_resolver( account );

FC_ASSERT( abis.valid(), "No ABI found for ${contract}", ("contract", account));

auto action_type = abis->get_action_type( action );

FC_ASSERT( !action_type.empty(), "Unknown action ${action} in contract ${contract}", ("action", action)( "contract", account ));

return abis->variant_to_binary( action_type, action_args_var, abi_serializer_max_time );

}

fc::variant bin_to_variant( const account_name& account, const action_name& action, const bytes& action_args) {

auto abis = abi_serializer_resolver( account );

FC_ASSERT( abis.valid(), "No ABI found for ${contract}", ("contract", account));

auto action_type = abis->get_action_type( action );

FC_ASSERT( !action_type.empty(), "Unknown action ${action} in contract ${contract}", ("action", action)( "contract", account ));

return abis->binary_to_variant( action_type, action_args, abi_serializer_max_time );

}

fc::variant json_from_file_or_string(const string& file_or_str, fc::json::parse_type ptype = fc::json::legacy_parser)

{

regex r("^[ \t]*[\{\[]");

if ( !regex_search(file_or_str, r) && fc::is_regular_file(file_or_str) ) {

return fc::json::from_file(file_or_str, ptype);

} else {

return fc::json::from_string(file_or_str, ptype);

}

}

bytes json_or_file_to_bin( const account_name& account, const action_name& action, const string& data_or_filename ) {

fc::variant action_args_var;

if( !data_or_filename.empty() ) {

try {

action_args_var = json_from_file_or_string(data_or_filename, fc::json::relaxed_parser);

} EOS_RETHROW_EXCEPTIONS(action_type_exception, "Fail to parse action JSON data='${data}'", ("data", data_or_filename));

}

return variant_to_bin( account, action, action_args_var );

}

void print_action_tree( const fc::variant& action ) {

print_action( action );

if( action.get_object().contains( "inline_traces" ) ) {

const auto& inline_traces = action["inline_traces"].get_array();

for( const auto& t : inline_traces ) {

print_action_tree( t );

}

}

}

void print_result( const fc::variant& result ) { try {

if (result.is_object() && result.get_object().contains("processed")) {

const auto& processed = result["processed"];

const auto& transaction_id = processed["id"].as_string();

string status = "failed";

int64_t net = -1;

int64_t cpu = -1;

if( processed.get_object().contains( "receipt" )) {

const auto& receipt = processed["receipt"];

if( receipt.is_object()) {

status = receipt["status"].as_string();

net = receipt["net_usage_words"].as_int64() * 8;

cpu = receipt["cpu_usage_us"].as_int64();

}

}

cerr << status << " transaction: " << transaction_id << " ";

if( net < 0 ) {

cerr << "<unknown>";

} else {

cerr << net;

}

cerr << " bytes ";

if( cpu < 0 ) {

cerr << "<unknown>";

} else {

cerr << cpu;

}

cerr << " us\n";

if( status == "failed" ) {

auto soft_except = processed["except"].as<optional<fc::exception>>();

if( soft_except ) {

edump((soft_except->to_detail_string()));

}

} else {

const auto& actions = processed["action_traces"].get_array();

for( const auto& a : actions ) {

print_action_tree( a );

}

wlog( "\rwarning: transaction executed locally, but may not be confirmed by the network yet" );

}

} else {

cerr << fc::json::to_pretty_string( result ) << endl;

}

} FC_CAPTURE_AND_RETHROW( (result) ) }

using std::cout;

void send_actions(std::vector<chain::action>&& actions, int32_t extra_kcpu = 1000, packed_transaction::compression_type compression = packed_transaction::none ) {

auto result = push_actions( move(actions), extra_kcpu, compression);

if( tx_print_json ) {

cout << fc::json::to_pretty_string( result ) << endl;

} else {

print_result( result );

}

}

void send_transaction( signed_transaction& trx, int32_t extra_kcpu, packed_transaction::compression_type compression = packed_transaction::none ) {

auto result = push_transaction(trx, extra_kcpu, compression);

if( tx_print_json ) {

cout << fc::json::to_pretty_string( result ) << endl;

} else {

print_result( result );

}

}

chain::permission_level to_permission_level(const std::string& s) {

auto at_pos = s.find('@');

return permission_level { s.substr(0, at_pos), s.substr(at_pos + 1) };

}

chain::action create_newaccount(const name& creator, const name& newaccount, auth_type owner, auth_type active) {

return action {

get_account_permissions(tx_permission, {creator,config::active_name}),

eosio::chain::newaccount{

.creator = creator,

.name = newaccount,

.owner = owner.contains<public_key_type>() ? authority(owner.get<public_key_type>()) : authority(owner.get<permission_level>()),

.active = active.contains<public_key_type>() ? authority(active.get<public_key_type>()) : authority(active.get<permission_level>())

}

};

}

chain::action create_action(const vector<permission_level>& authorization, const account_name& code, const action_name& act, const fc::variant& args) {

return chain::action{authorization, code, act, variant_to_bin(code, act, args)};

}

chain::action create_buyram(const name& creator, const name& newaccount, const asset& quantity) {

fc::variant act_payload = fc::mutable_variant_object()

("payer", creator.to_string())

("receiver", newaccount.to_string())

("quant", quantity.to_string());

return create_action(get_account_permissions(tx_permission, {creator,config::active_name}),

config::system_account_name, N(buyram), act_payload);

}

chain::action create_buyrambytes(const name& creator, const name& newaccount, uint32_t numbytes) {

fc::variant act_payload = fc::mutable_variant_object()

("payer", creator.to_string())

("receiver", newaccount.to_string())

("bytes", numbytes);

return create_action(get_account_permissions(tx_permission, {creator,config::active_name}),

config::system_account_name, N(buyrambytes), act_payload);

}

chain::action create_delegate(const name& from, const name& receiver, const asset& net, const asset& cpu, bool transfer) {

fc::variant act_payload = fc::mutable_variant_object()

("from", from.to_string())

("receiver", receiver.to_string())

("stake_net_quantity", net.to_string())

("stake_cpu_quantity", cpu.to_string())

("transfer", transfer);

return create_action(get_account_permissions(tx_permission, {from,config::active_name}),

config::system_account_name, N(delegatebw), act_payload);

}

fc::variant regproducer_variant(const account_name& producer, const public_key_type& key, const string& url, uint16_t location) {

return fc::mutable_variant_object()

("producer", producer)

("producer_key", key)

("url", url)

("location", location)

;

}

chain::action create_open(const string& contract, const name& owner, symbol sym, const name& ram_payer) {

auto open_ = fc::mutable_variant_object

("owner", owner)

("symbol", sym)

("ram_payer", ram_payer);

return action {

get_account_permissions(tx_permission, {ram_payer,config::active_name}),

contract, "open", variant_to_bin( contract, N(open), open_ )

};

}

chain::action create_transfer(const string& contract, const name& sender, const name& recipient, asset amount, const string& memo ) {

auto transfer = fc::mutable_variant_object

("from", sender)

("to", recipient)

("quantity", amount)

("memo", memo);

return action {

get_account_permissions(tx_permission, {sender,config::active_name}),

contract, "transfer", variant_to_bin( contract, N(transfer), transfer )

};

}

chain::action create_setabi(const name& account, const bytes& abi) {

return action {

get_account_permissions(tx_permission, {account,config::active_name}),

setabi{

.account = account,

.abi = abi

}

};

}

chain::action create_setcode(const name& account, const bytes& code) {

return action {

get_account_permissions(tx_permission, {account,config::active_name}),

setcode{

.account = account,

.vmtype = 0,

.vmversion = 0,

.code = code

}

};

}

chain::action create_updateauth(const name& account, const name& permission, const name& parent, const authority& auth) {

return action { get_account_permissions(tx_permission, {account,config::active_name}),

updateauth{account, permission, parent, auth}};

}

chain::action create_deleteauth(const name& account, const name& permission) {

return action { get_account_permissions(tx_permission, {account,config::active_name}),

deleteauth{account, permission}};

}

chain::action create_linkauth(const name& account, const name& code, const name& type, const name& requirement) {

return action { get_account_permissions(tx_permission, {account,config::active_name}),

linkauth{account, code, type, requirement}};

}

chain::action create_unlinkauth(const name& account, const name& code, const name& type) {

return action { get_account_permissions(tx_permission, {account,config::active_name}),

unlinkauth{account, code, type}};

}

authority parse_json_authority(const std::string& authorityJsonOrFile) {

try {

return json_from_file_or_string(authorityJsonOrFile).as<authority>();

} EOS_RETHROW_EXCEPTIONS(authority_type_exception, "Fail to parse Authority JSON '${data}'", ("data",authorityJsonOrFile))

}

authority parse_json_authority_or_key(const std::string& authorityJsonOrFile) {

if (boost::istarts_with(authorityJsonOrFile, "EOS") || boost::istarts_with(authorityJsonOrFile, "PUB_R1")) {

try {

return authority(public_key_type(authorityJsonOrFile));

} EOS_RETHROW_EXCEPTIONS(public_key_type_exception, "Invalid public key: ${public_key}", ("public_key", authorityJsonOrFile))

} else {

auto result = parse_json_authority(authorityJsonOrFile);

EOS_ASSERT( eosio::chain::validate(result), authority_type_exception, "Authority failed validation! ensure that keys, accounts, and waits are sorted and that the threshold is valid and satisfiable!");

return result;

}

}

asset to_asset( account_name code, const string& s ) {

static map< pair<account_name, eosio::chain::symbol_code>, eosio::chain::symbol> cache;

auto a = asset::from_string( s );

eosio::chain::symbol_code sym = a.get_symbol().to_symbol_code();

auto it = cache.find( make_pair(code, sym) );

auto sym_str = a.symbol_name();

if ( it == cache.end() ) {

auto json = call(get_currency_stats_func, fc::mutable_variant_object("json", false)

("code", code)

("symbol", sym_str)

);

auto obj = json.get_object();

auto obj_it = obj.find( sym_str );

if (obj_it != obj.end()) {

auto result = obj_it->value().as<eosio::chain_apis::read_only::get_currency_stats_result>();

auto p = cache.emplace( make_pair( code, sym ), result.max_supply.get_symbol() );

it = p.first;

} else {

EOS_THROW(symbol_type_exception, "Symbol ${s} is not supported by token contract ${c}", ("s", sym_str)("c", code));

}

}

auto expected_symbol = it->second;

if ( a.decimals() < expected_symbol.decimals() ) {

auto factor = expected_symbol.precision() / a.precision();

a = asset( a.get_amount() * factor, expected_symbol );

} else if ( a.decimals() > expected_symbol.decimals() ) {

EOS_THROW(symbol_type_exception, "Too many decimal digits in ${a}, only ${d} supported", ("a", a)("d", expected_symbol.decimals()));

} // else precision matches

return a;

}

inline asset to_asset( const string& s ) {

return to_asset( N(eosio.token), s );

}

struct set_account_permission_subcommand {

name account;

name permission;

string authority_json_or_file;

name parent;

bool add_code;

bool remove_code;

set_account_permission_subcommand(CLI::App* accountCmd) {

auto permissions = accountCmd->add_subcommand("permission", localized("set parameters dealing with account permissions"));

permissions->add_option("account", account, localized("The account to set/delete a permission authority for"))->required();

permissions->add_option("permission", permission, localized("The permission name to set/delete an authority for"))->required();

permissions->add_option("authority", authority_json_or_file, localized("[delete] NULL, [create/update] public key, JSON string or filename defining the authority, [code] contract name"));

permissions->add_option("parent", parent, localized("[create] The permission name of this parents permission, defaults to 'active'"));

permissions->add_flag("--add-code", add_code, localized("[code] add '${code}' permission to specified permission authority", ("code", name(config::eosio_code_name))));

permissions->add_flag("--remove-code", remove_code, localized("[code] remove '${code}' permission from specified permission authority", ("code", name(config::eosio_code_name))));

add_standard_transaction_options(permissions, "account@active");

permissions->set_callback([this] {

EOSC_ASSERT( !(add_code && remove_code), "ERROR: Either --add-code or --remove-code can be set" );

EOSC_ASSERT( (add_code ^ remove_code) || !authority_json_or_file.empty(), "ERROR: authority should be specified unless add or remove code permission" );

authority auth;

bool need_parent = parent.empty() && (permission != name("owner"));

bool need_auth = add_code || remove_code;

if ( !need_auth && boost::iequals(authority_json_or_file, "null") ) {

send_actions( { create_deleteauth(account, permission) } );

return;

}

if ( need_parent || need_auth ) {

fc::variant json = call(get_account_func, fc::mutable_variant_object("account_name", account.to_string()));

auto res = json.as<eosio::chain_apis::read_only::get_account_results>();

auto itr = std::find_if(res.permissions.begin(), res.permissions.end(), [&](const auto& perm) {

return perm.perm_name == permission;

});

if ( need_parent ) {

// see if we can auto-determine the proper parent

if ( itr != res.permissions.end() ) {

parent = (*itr).parent;

} else {

// if this is a new permission and there is no parent we default to "active"

parent = name(config::active_name);

}

}

if ( need_auth ) {

auto actor = (authority_json_or_file.empty()) ? account : name(authority_json_or_file);

auto code_name = name(config::eosio_code_name);

if ( itr != res.permissions.end() ) {

// fetch existing authority

auth = std::move((*itr).required_auth);

auto code_perm = permission_level { actor, code_name };

auto itr2 = std::lower_bound(auth.accounts.begin(), auth.accounts.end(), code_perm, [&](const auto& perm_level, const auto& value) {

return perm_level.permission < value; // Safe since valid authorities must order the permissions in accounts in ascending order

});

if ( add_code ) {

if ( itr2 != auth.accounts.end() && itr2->permission == code_perm ) {

// authority already contains code permission, promote its weight to satisfy threshold

if ( (*itr2).weight < auth.threshold ) {

if ( auth.threshold > std::numeric_limits<weight_type>::max() ) {

std::cerr << "ERROR: Threshold is too high to be satisfied by sole code permission" << std::endl;

return;

}

std::cerr << localized("The weight of '${actor}@${code}' in '${permission}' permission authority will be increased up to threshold",

("actor", actor)("code", code_name)("permission", permission)) << std::endl;

(*itr2).weight = static_cast<weight_type>(auth.threshold);

} else {

std::cerr << localized("ERROR: The permission '${permission}' already contains '${actor}@${code}'",

("permission", permission)("actor", actor)("code", code_name)) << std::endl;

return ;

}

} else {

// add code permission to specified authority

if ( auth.threshold > std::numeric_limits<weight_type>::max() ) {

std::cerr << "ERROR: Threshold is too high to be satisfied by sole code permission" << std::endl;

return;

}

auth.accounts.insert( itr2, permission_level_weight {

.permission = { actor, code_name },

.weight = static_cast<weight_type>(auth.threshold)

});

}

} else {

if ( itr2 != auth.accounts.end() && itr2->permission == code_perm ) {

// remove code permission, if authority becomes empty by the removal of code permission, delete permission

auth.accounts.erase( itr2 );

if ( auth.keys.empty() && auth.accounts.empty() && auth.waits.empty() ) {

send_actions( { create_deleteauth(account, permission) } );

return;

}

} else {

// authority doesn't contain code permission

std::cerr << localized("ERROR: '${actor}@${code}' does not exist in '${permission}' permission authority",

("actor", actor)("code", code_name)("permission", permission)) << std::endl;

return;

}

}

} else {

if ( add_code ) {

// create new permission including code permission

auth.threshold = 1;

auth.accounts.push_back( permission_level_weight {

.permission = { actor, code_name },

.weight = 1

});

} else {

// specified permission doesn't exist, so failed to remove code permission from it

std::cerr << localized("ERROR: The permission '${permission}' does not exist", ("permission", permission)) << std::endl;

return;

}

}

}

}

if ( !need_auth ) {

auth = parse_json_authority_or_key(authority_json_or_file);

}

send_actions( { create_updateauth(account, permission, parent, auth) } );

});

}

};

struct set_action_permission_subcommand {

string accountStr;

string codeStr;

string typeStr;

string requirementStr;

set_action_permission_subcommand(CLI::App* actionRoot) {

auto permissions = actionRoot->add_subcommand("permission", localized("set parmaters dealing with account permissions"));

permissions->add_option("account", accountStr, localized("The account to set/delete a permission authority for"))->required();

permissions->add_option("code", codeStr, localized("The account that owns the code for the action"))->required();

permissions->add_option("type", typeStr, localized("the type of the action"))->required();

permissions->add_option("requirement", requirementStr, localized("[delete] NULL, [set/update] The permission name require for executing the given action"))->required();

add_standard_transaction_options(permissions, "account@active");

permissions->set_callback([this] {

name account = name(accountStr);

name code = name(codeStr);

name type = name(typeStr);

bool is_delete = boost::iequals(requirementStr, "null");

if (is_delete) {

send_actions({create_unlinkauth(account, code, type)});

} else {

name requirement = name(requirementStr);

send_actions({create_linkauth(account, code, type, requirement)});

}

});

}

};

bool local_port_used() {

using namespace boost::asio;

io_service ios;

local::stream_protocol::endpoint endpoint(wallet_url.substr(strlen("unix://")));

local::stream_protocol::socket socket(ios);

boost::system::error_code ec;

socket.connect(endpoint, ec);

return !ec;

}

void try_local_port(uint32_t duration) {

using namespace std::chrono;

auto start_time = duration_cast<std::chrono::milliseconds>( system_clock::now().time_since_epoch() ).count();

while ( !local_port_used()) {

if (duration_cast<std::chrono::milliseconds>( system_clock::now().time_since_epoch()).count() - start_time > duration ) {

std::cerr << "Unable to connect to keosd, if keosd is running please kill the process and try again.\n";

throw connection_exception(fc::log_messages{FC_LOG_MESSAGE(error, "Unable to connect to keosd")});

}

}

}

void ensure_keosd_running(CLI::App* app) {

if (no_auto_keosd)

return;

// get, version, net do not require keosd

if (tx_skip_sign || app->got_subcommand("get") || app->got_subcommand("version") || app->got_subcommand("net"))

return;

if (app->get_subcommand("create")->got_subcommand("key")) // create key does not require wallet

return;

if (auto* subapp = app->get_subcommand("system")) {

if (subapp->got_subcommand("listproducers") || subapp->got_subcommand("listbw") || subapp->got_subcommand("bidnameinfo")) // system list* do not require wallet

return;

}

if (wallet_url != default_wallet_url)

return;

if (local_port_used())

return;

boost::filesystem::path binPath = boost::dll::program_location();

binPath.remove_filename();

// This extra check is necessary when running cleos like this: ./cleos ...

if (binPath.filename_is_dot())

binPath.remove_filename();

binPath.append(key_store_executable_name); // if cleos and keosd are in the same installation directory

if (!boost::filesystem::exists(binPath)) {

binPath.remove_filename().remove_filename().append("keosd").append(key_store_executable_name);

}

if (boost::filesystem::exists(binPath)) {

namespace bp = boost::process;

binPath = boost::filesystem::canonical(binPath);

vector<std::string> pargs;

pargs.push_back("--http-server-address");

pargs.push_back("");

pargs.push_back("--https-server-address");

pargs.push_back("");

pargs.push_back("--unix-socket-path");

pargs.push_back(string(key_store_executable_name) + ".sock");

::boost::process::child keos(binPath, pargs,

bp::std_in.close(),

bp::std_out > bp::null,

bp::std_err > bp::null);

if (keos.running()) {

std::cerr << binPath << " launched" << std::endl;

keos.detach();

try_local_port(2000);

} else {

std::cerr << "No wallet service listening on " << wallet_url << ". Failed to launch " << binPath << std::endl;

}

} else {

std::cerr << "No wallet service listening on "

<< ". Cannot automatically start keosd because keosd was not found." << std::endl;

}

}

CLI::callback_t obsoleted_option_host_port = [](CLI::results_t) {

std::cerr << localized("Host and port options (-H, --wallet-host, etc.) have been replaced with -u/--url and --wallet-url\n"

"Use for example -u http://localhost:8888 or --url https://example.invalid/\n");

exit(1);

return false;

};

struct register_producer_subcommand {

string producer_str;

string producer_key_str;

string url;

uint16_t loc = 0;

register_producer_subcommand(CLI::App* actionRoot) {

auto register_producer = actionRoot->add_subcommand("regproducer", localized("Register a new producer"));

register_producer->add_option("account", producer_str, localized("The account to register as a producer"))->required();

register_producer->add_option("producer_key", producer_key_str, localized("The producer's public key"))->required();

register_producer->add_option("url", url, localized("url where info about producer can be found"), true);

register_producer->add_option("location", loc, localized("relative location for purpose of nearest neighbor scheduling"), true);

add_standard_transaction_options(register_producer, "account@active");

register_producer->set_callback([this] {

public_key_type producer_key;

try {

producer_key = public_key_type(producer_key_str);

} EOS_RETHROW_EXCEPTIONS(public_key_type_exception, "Invalid producer public key: ${public_key}", ("public_key", producer_key_str))

auto regprod_var = regproducer_variant(producer_str, producer_key, url, loc );

auto accountPermissions = get_account_permissions(tx_permission, {producer_str,config::active_name});

send_actions({create_action(accountPermissions, config::system_account_name, N(regproducer), regprod_var)});

});

}

};

struct create_account_subcommand {

string creator;

string account_name;

string owner_key_str;

string active_key_str;

string stake_net;

string stake_cpu;

uint32_t buy_ram_bytes_in_kbytes = 0;

uint32_t buy_ram_bytes = 0;

string buy_ram_eos;

bool transfer;

bool simple;

create_account_subcommand(CLI::App* actionRoot, bool s) : simple(s) {

auto createAccount = actionRoot->add_subcommand(

(simple ? "account" : "newaccount"),

(simple ? localized("Create a new account on the blockchain (assumes system contract does not restrict RAM usage)")

: localized("Create a new account on the blockchain with initial resources") )

);

createAccount->add_option("creator", creator, localized("The name of the account creating the new account"))->required();