main.cpp File Reference

#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 <sysio/chain/name.hpp>
#include <sysio/chain/config.hpp>
#include <sysio/chain/trace.hpp>
#include <sysio/chain_plugin/chain_plugin.hpp>
#include <sysio/chain/contract_types.hpp>
#include <sysio/version/version.hpp>
#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>
#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"

Include dependency graph for main.cpp:

Go to the source code of this file.

Classes
struct	set_account_permission_subcommand
struct	set_action_permission_subcommand
struct	register_producer_subcommand
struct	create_account_subcommand
struct	unregister_producer_subcommand
struct	vote_producer_proxy_subcommand
struct	vote_producers_subcommand
struct	approve_producer_subcommand
struct	unapprove_producer_subcommand
struct	list_producers_subcommand
struct	get_schedule_subcommand
struct	get_transaction_id_subcommand
struct	delegate_bandwidth_subcommand
struct	undelegate_bandwidth_subcommand
struct	bidname_subcommand
struct	bidname_info_subcommand
struct	list_bw_subcommand
struct	buyram_subcommand
struct	sellram_subcommand
struct	claimrewards_subcommand
struct	regproxy_subcommand
struct	unregproxy_subcommand
struct	canceldelay_subcommand
struct	deposit_subcommand
struct	withdraw_subcommand
struct	buyrex_subcommand
struct	lendrex_subcommand
struct	unstaketorex_subcommand
struct	sellrex_subcommand
struct	cancelrexorder_subcommand
struct	rentcpu_subcommand
struct	rentnet_subcommand
struct	fundcpuloan_subcommand
struct	fundnetloan_subcommand
struct	defcpuloan_subcommand
struct	defnetloan_subcommand
struct	mvtosavings_subcommand
struct	mvfrsavings_subcommand
struct	updaterex_subcommand
struct	consolidate_subcommand
struct	rexexec_subcommand
struct	closerex_subcommand

Macros
#define	CLI11_HAS_FILESYSTEM   0
#define	SYSC_ASSERT(TEST, ...)

Typedefs
using	auth_type = std::variant<public_key_type, permission_level>

Functions
	FC_DECLARE_EXCEPTION (explained_exception, 9000000, "explained exception, see error log")
	FC_DECLARE_EXCEPTION (localized_exception, 10000000, "an error occured")
bfs::path	determine_home_directory ()
std::string	clean_output (std::string str)
void	add_standard_transaction_options (CLI::App *cmd, string default_permission="")
vector< chain::permission_level >	get_account_permissions (const vector< string > &permissions)
vector< chain::permission_level >	get_account_permissions (const vector< string > &permissions, const chain::permission_level &default_permission)
template<typename T >
fc::variant	call (const std::string &url, const std::string &path, const T &v)
template<typename T >
fc::variant	call (const std::string &path, const T &v)
template<>
fc::variant	call (const std::string &url, const std::string &path)
sysio::chain_apis::read_only::get_info_results	get_info ()
string	generate_nonce_string ()
chain::action	generate_nonce_action ()
void	prompt_for_wallet_password (string &pw, const string &name)
fc::variant	determine_required_keys (const signed_transaction &trx)
void	sign_transaction (signed_transaction &trx, fc::variant &required_keys, const chain_id_type &chain_id)
fc::variant	push_transaction (signed_transaction &trx, packed_transaction::compression_type compression=packed_transaction::compression_type::none)
fc::variant	push_actions (std::vector< chain::action > &&actions, packed_transaction::compression_type compression=packed_transaction::compression_type::none)
void	print_return_value (const fc::variant &at)
void	print_action (const fc::variant &at)
bytes	variant_to_bin (const account_name &account, const action_name &action, const fc::variant &action_args_var)
fc::variant	bin_to_variant (const account_name &account, const action_name &action, const bytes &action_args)
fc::variant	json_from_file_or_string (const string &file_or_str, fc::json::parse_type ptype=fc::json::parse_type::legacy_parser)
bytes	json_or_file_to_bin (const account_name &account, const action_name &action, const string &data_or_filename)
void	print_action_tree (const fc::variant &action)
int	get_return_code (const fc::variant &result)
void	print_result (const fc::variant &result)
void	send_actions (std::vector< chain::action > &&actions, packed_transaction::compression_type compression=packed_transaction::compression_type::none)
void	send_transaction (signed_transaction &trx, packed_transaction::compression_type compression=packed_transaction::compression_type::none)
chain::permission_level	to_permission_level (const std::string &s)
chain::action	create_newaccount (const name &creator, const name &newaccount, auth_type owner, auth_type active)
chain::action	create_action (const vector< permission_level > &authorization, const account_name &code, const action_name &act, const fc::variant &args)
chain::action	create_buyram (const name &creator, const name &newaccount, const asset &quantity)
chain::action	create_buyrambytes (const name &creator, const name &newaccount, uint32_t numbytes)
chain::action	create_delegate (const name &from, const name &receiver, const asset &net, const asset &cpu, bool transfer)
fc::variant	regproducer_variant (const account_name &producer, const public_key_type &key, const string &url, uint16_t location)
chain::action	create_open (const string &contract, const name &owner, symbol sym, const name &ram_payer)
chain::action	create_transfer (const string &contract, const name &sender, const name &recipient, asset amount, const string &memo)
chain::action	create_setabi (const name &account, const bytes &abi)
chain::action	create_setcode (const name &account, const bytes &code)
chain::action	create_updateauth (const name &account, const name &permission, const name &parent, const authority &auth)
chain::action	create_deleteauth (const name &account, const name &permission)
chain::action	create_linkauth (const name &account, const name &code, const name &type, const name &requirement)
chain::action	create_unlinkauth (const name &account, const name &code, const name &type)
authority	parse_json_authority (const std::string &authorityJsonOrFile)
authority	parse_json_authority_or_key (const std::string &authorityJsonOrFile)
asset	to_asset (account_name code, const string &s)
asset	to_asset (const string &s)
bool	local_port_used ()
void	try_local_port (uint32_t duration)
void	ensure_kiod_running (CLI::App *app)
void	get_account (const string &accountName, const string &coresym, bool json_format)
int	main (int argc, char **argv)

Variables
string	url = "http://127.0.0.1:8888/"
string	default_wallet_url = "unix://" + (determine_home_directory() / "sysio-wallet" / (string(key_store_executable_name) + ".sock")).string()
string	wallet_url
bool	no_verify = false
vector< string >	headers
auto	tx_expiration = fc::seconds(30)
const fc::microseconds	abi_serializer_max_time = fc::seconds(10)
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	tx_rtn_failure_trace = true
bool	tx_read_only = false
bool	tx_retry_lib = false
uint16_t	tx_retry_num_blocks = 0
bool	tx_use_old_rpc = false
bool	tx_use_old_send_rpc = false
string	tx_json_save_file
bool	print_request = false
bool	print_response = false
bool	no_auto_kiod = false
bool	verbose = false
int	return_code = 0
uint8_t	tx_max_cpu_usage = 0
uint32_t	tx_max_net_usage = 0
uint32_t	delaysec = 0
vector< string >	tx_permission
sysio::client::http::http_context	context
auto	abi_serializer_resolver
CLI::callback_t	obsoleted_option_host_port
CLI::callback_t	header_opt_callback

Macro Definition Documentation

CLI11_HAS_FILESYSTEM

#define CLI11_HAS_FILESYSTEM   0

Definition at line 115 of file main.cpp.

SYSC_ASSERT

#define SYSC_ASSERT	(		TEST,
			... )

Value:

  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 \
  )

Definition at line 134 of file main.cpp.

#define SYSC_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 \
  )

Typedef Documentation

auth_type

using auth_type = std::variant<public_key_type, permission_level>

Definition at line 130 of file main.cpp.

Function Documentation

add_standard_transaction_options()

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

Definition at line 202 of file main.cpp.

                                                                                   {
   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_option("--json-file", tx_json_save_file, localized("Save result in JSON format into a file"));
   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)")));
   cmd->add_flag("--use-old-rpc", tx_use_old_rpc, localized("Use old RPC push_transaction, rather than new RPC send_transaction"));
   cmd->add_flag("--use-old-send-rpc", tx_use_old_send_rpc, localized("Use old RPC send_transaction, rather than new RPC /v1/chain/send_transaction2"));
 
   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"));
   cmd->add_option("-t,--return-failure-trace", tx_rtn_failure_trace, localized("Return partial traces on failed transactions"));
   cmd->add_option("--retry-irreversible", tx_retry_lib, localized("Request node to retry transaction until it is irreversible or expires, blocking call"));
   cmd->add_option("--retry-num-blocks", tx_retry_num_blocks, localized("Request node to retry transaction until in a block of given height, blocking call"));
}

Here is the call graph for this function:

Here is the caller graph for this function:

bin_to_variant()

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

Definition at line 500 of file main.cpp.

                                                                                                            {
   auto abis = abi_serializer_resolver( account );
   FC_ASSERT( abis, "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::create_yield_function( abi_serializer_max_time ) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

call() [1/3]

template<typename T >

fc::variant call	(	const std::string &	path,
		const T &	v )

Definition at line 280 of file main.cpp.

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

Here is the call graph for this function:

call() [2/3]

template<>

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

Definition at line 284 of file main.cpp.

                                         { return call( url, path, fc::variant() ); }

Here is the call graph for this function:

call() [3/3]

template<typename T >

fc::variant call	(	const std::string &	url,
		const std::string &	path,
		const T &	v )

Definition at line 258 of file main.cpp.

                               {
   try {
      auto sp = std::make_unique<sysio::client::http::connection_param>(context, parse_url(url) + path, no_verify ? false : true, headers);
      return sysio::client::http::do_http_call(*sp, fc::variant(v), print_request, print_response );
   }
   catch(boost::system::system_error& e) {
      std::string exec_name;
      if(url == ::url) {
         exec_name = node_executable_name;
      } else if(url == ::wallet_url) {
         exec_name = key_store_executable_name;
      }
      std::cerr << localized( "Failed http request to ${n} at ${u}; is ${n} running?\n"
                              "  Error: ${e}",
                              ("n", exec_name)("u", url)("e", e.what()) ) << std::endl;
      throw connection_exception(fc::log_messages{FC_LOG_MESSAGE(error, e.what())});
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

clean_output()

std::string clean_output

(

std::string

str

)

Definition at line 161 of file main.cpp.

                                        {
   const bool escape_control_chars = false;
   return fc::escape_string( str, nullptr, escape_control_chars );
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_action()

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

Definition at line 683 of file main.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

create_buyram()

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

Definition at line 687 of file main.cpp.

                                                                                              {
   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, "buyram"_n, act_payload);
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_buyrambytes()

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

Definition at line 696 of file main.cpp.

                                                                                               {
   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, "buyrambytes"_n, act_payload);
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_delegate()

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

Definition at line 705 of file main.cpp.

                                                                                                                       {
   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, "delegatebw"_n, act_payload);
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_deleteauth()

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

Definition at line 777 of file main.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

create_linkauth()

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

Definition at line 782 of file main.cpp.

                                                                                                              {
   return action { get_account_permissions(tx_permission, {account,config::active_name}),
                   linkauth{account, code, type, requirement}};
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_newaccount()

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

Definition at line 671 of file main.cpp.

                                                                                                              {
   return action {
      get_account_permissions(tx_permission, {creator,config::active_name}),
      sysio::chain::newaccount{
         .creator      = creator,
         .name         = newaccount,
         .owner        = std::holds_alternative<public_key_type>(owner) ? authority(std::get<public_key_type>(owner)) : authority(std::get<permission_level>(owner)),
         .active       = std::holds_alternative<public_key_type>(active) ? authority(std::get<public_key_type>(active)) : authority(std::get<permission_level>(active))
      }
   };
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_open()

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

Definition at line 725 of file main.cpp.

                                                                                                      {
   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}),
      name(contract), "open"_n, variant_to_bin( name(contract), "open"_n, open_ )
   };
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_setabi()

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

Definition at line 750 of file main.cpp.

                                                                 {
   return action {
      get_account_permissions(tx_permission, {account,config::active_name}),
      setabi{
         .account   = account,
         .abi       = abi
      }
   };
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_setcode()

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

Definition at line 760 of file main.cpp.

                                                                   {
   return action {
      get_account_permissions(tx_permission, {account,config::active_name}),
      setcode{
         .account   = account,
         .vmtype    = 0,
         .vmversion = 0,
         .code      = code
      }
   };
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_transfer()

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

Definition at line 736 of file main.cpp.

                                                                                                                                  {
 
   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}),
      name(contract), "transfer"_n, variant_to_bin( name(contract), "transfer"_n, transfer )
   };
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_unlinkauth()

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

Definition at line 787 of file main.cpp.

                                                                                       {
   return action { get_account_permissions(tx_permission, {account,config::active_name}),
                   unlinkauth{account, code, type}};
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_updateauth()

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

Definition at line 772 of file main.cpp.

                                                                                                                      {
   return action { get_account_permissions(tx_permission, {account,config::active_name}),
                   updateauth{account, permission, parent, auth}};
}

Here is the call graph for this function:

Here is the caller graph for this function:

determine_home_directory()

bfs::path determine_home_directory

(

)

Definition at line 146 of file main.cpp.

{
   bfs::path home;
   struct passwd* pwd = getpwuid(getuid());
   if(pwd) {
      home = pwd->pw_dir;
   }
   else {
      home = getenv("HOME");
   }
   if(home.empty())
      home = "./";
   return home;
}

determine_required_keys()

fc::variant determine_required_keys

(

const signed_transaction &

trx

)

Definition at line 308 of file main.cpp.

                                                                 {
   // 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"];
}

Here is the call graph for this function:

Here is the caller graph for this function:

ensure_kiod_running()

void ensure_kiod_running

(

CLI::App *

app

)

Definition at line 1033 of file main.cpp.

                                      {
    if (no_auto_kiod)
        return;
    // get, version, net, convert do not require kiod
    if (tx_skip_sign || app->got_subcommand("get") || app->got_subcommand("version") || app->got_subcommand("net") || app->got_subcommand("convert"))
        return;
    if (app->get_subcommand("create")->got_subcommand("key")) // create key does not require wallet
       return;
    if (app->get_subcommand("multisig")->got_subcommand("review")) // multisig review 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 clio like this: ./clio ...
    if (binPath.filename_is_dot())
        binPath.remove_filename();
    binPath.append(key_store_executable_name); // if clio and kiod are in the same installation directory
    if (!boost::filesystem::exists(binPath)) {
        binPath.remove_filename().remove_filename().append("kiod").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 " << key_store_executable_name << " because " << key_store_executable_name << " was not found." << std::endl;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

FC_DECLARE_EXCEPTION() [1/2]

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

FC_DECLARE_EXCEPTION() [2/2]

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

generate_nonce_action()

chain::action generate_nonce_action

(

)

Definition at line 295 of file main.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

generate_nonce_string()

string generate_nonce_string

(

)

Definition at line 291 of file main.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_account()

void get_account	(	const string &	accountName,
		const string &	coresym,
		bool	json_format )

Definition at line 2211 of file main.cpp.

                                                                                       {
   fc::variant json;
   if (coresym.empty()) {
      json = call(get_account_func, fc::mutable_variant_object("account_name", accountName));
   }
   else {
      json = call(get_account_func, fc::mutable_variant_object("account_name", accountName)("expected_core_symbol", symbol::from_string(coresym)));
   }
 
   auto res = json.as<sysio::chain_apis::read_only::get_account_results>();
   if (!json_format) {
      asset staked;
      asset unstaking;
 
      if( res.core_liquid_balance ) {
         unstaking = asset( 0, res.core_liquid_balance->get_symbol() ); // Correct core symbol for unstaking asset.
         staked = asset( 0, res.core_liquid_balance->get_symbol() );    // Correct core symbol for staked asset.
      }
 
      std::cout << "created: " << string(res.created) << std::endl;
 
      if(res.privileged) std::cout << "privileged: true" << std::endl;
 
      constexpr size_t indent_size = 5;
      const string indent(indent_size, ' ');
 
      std::cout << "permissions: " << std::endl;
      unordered_map<name, vector<name>/*children*/> tree;
      vector<name> roots; //we don't have multiple roots, but we can easily handle them here, so let's do it just in case
      unordered_map<name, sysio::chain_apis::permission> cache;
      for ( auto& perm : res.permissions ) {
         if ( perm.parent ) {
            tree[perm.parent].push_back( perm.perm_name );
         } else {
            roots.push_back( perm.perm_name );
         }
         auto name = perm.perm_name; //keep copy before moving `perm`, since thirst argument of emplace can be evaluated first
         // looks a little crazy, but should be efficient
         cache.insert( std::make_pair(name, std::move(perm)) );
      }
      
      using dfs_fn_t = std::function<void (const sysio::chain_apis::permission&, int)>;
      std::function<void (account_name, int, dfs_fn_t&)> dfs_exec = [&]( account_name name, int depth, dfs_fn_t& f ) -> void {
         auto& p = cache.at(name);
 
         f(p, depth);
         auto it = tree.find( name );
         if (it != tree.end()) {
            auto& children = it->second;
            sort( children.begin(), children.end() );
            for ( auto& n : children ) {
               // we have a tree, not a graph, so no need to check for already visited nodes
               dfs_exec( n, depth+1, f );
            }
         } // else it's a leaf node
      };
 
      dfs_fn_t print_auth = [&]( const sysio::chain_apis::permission& p, int depth ) -> void {
         std::cout << indent << std::string(depth*3, ' ') << p.perm_name << ' ' << std::setw(5) << p.required_auth.threshold << ":    ";
 
         const char *sep = "";
         for ( auto it = p.required_auth.keys.begin(); it != p.required_auth.keys.end(); ++it ) {
            std::cout << sep << it->weight << ' ' << it->key.to_string();
            sep = ", ";
         }
         for ( auto& acc : p.required_auth.accounts ) {
            std::cout << sep << acc.weight << ' ' << acc.permission.actor.to_string() << '@' << acc.permission.permission.to_string();
            sep = ", ";
         }
         std::cout << std::endl;
      };
      std::sort(roots.begin(), roots.end());
      for ( auto r : roots ) {
         dfs_exec( r, 0, print_auth );
      }
      std::cout << std::endl;
 
      std::cout << "permission links: " << std::endl;
      dfs_fn_t print_links = [&](const sysio::chain_apis::permission& p, int) -> void {
         if (p.linked_actions) {
            if (!p.linked_actions->empty()) {
               std::cout << indent << p.perm_name.to_string() + ":" << std::endl;
               for ( auto it = p.linked_actions->begin(); it != p.linked_actions->end(); ++it ) {
                  auto action_value = it->action ? it->action->to_string() : std::string("*");
                  std::cout << indent << indent << it->account << "::" << action_value << std::endl;
               }
            }
         }
      };
 
      for ( auto r : roots ) {
         dfs_exec( r, 0, print_links);
      }
 
      // print linked actions 
      std::cout << indent << "sysio.any: " << std::endl;
      for (const auto& it : res.sysio_any_linked_actions) {
         auto action_value = it.action ? it.action->to_string() : std::string("*");
         std::cout << indent << indent << it.account << "::" << action_value << std::endl;
      }
 
      std::cout << std::endl;
 
      auto to_pretty_net = []( int64_t nbytes, uint8_t width_for_units = 5 ) {
         if(nbytes == -1) {
             // special case. Treat it as unlimited
             return std::string("unlimited");
         }
 
         string unit = "bytes";
         double bytes = static_cast<double> (nbytes);
         if (bytes >= 1024 * 1024 * 1024 * 1024ll) {
             unit = "TiB";
             bytes /= 1024 * 1024 * 1024 * 1024ll;
         } else if (bytes >= 1024 * 1024 * 1024) {
             unit = "GiB";
             bytes /= 1024 * 1024 * 1024;
         } else if (bytes >= 1024 * 1024) {
             unit = "MiB";
             bytes /= 1024 * 1024;
         } else if (bytes >= 1024) {
             unit = "KiB";
             bytes /= 1024;
         }
         std::stringstream ss;
         ss << setprecision(4);
         ss << bytes << " ";
         if( width_for_units > 0 )
            ss << std::left << setw( width_for_units );
         ss << unit;
         return ss.str();
      };
 
 
 
      std::cout << "memory: " << std::endl
                << indent << "quota: " << std::setw(15) << to_pretty_net(res.ram_quota) << "  used: " << std::setw(15) << to_pretty_net(res.ram_usage) << std::endl << std::endl;
 
      std::cout << "net bandwidth: " << std::endl;
      if ( res.total_resources.is_object() ) {
         auto net_total = to_asset(res.total_resources.get_object()["net_weight"].as_string());
 
         if( net_total.get_symbol() != unstaking.get_symbol() ) {
            // Core symbol of nodeop responding to the request is different than core symbol built into clio
            unstaking = asset( 0, net_total.get_symbol() ); // Correct core symbol for unstaking asset.
            staked = asset( 0, net_total.get_symbol() ); // Correct core symbol for staked asset.
         }
 
         if( res.self_delegated_bandwidth.is_object() ) {
            asset net_own =  asset::from_string( res.self_delegated_bandwidth.get_object()["net_weight"].as_string() );
            staked = net_own;
 
            auto net_others = net_total - net_own;
 
            std::cout << indent << "staked:" << std::setw(20) << net_own
                      << std::string(11, ' ') << "(total stake delegated from account to self)" << std::endl
                      << indent << "delegated:" << std::setw(17) << net_others
                      << std::string(11, ' ') << "(total staked delegated to account from others)" << std::endl;
         }
         else {
            auto net_others = net_total;
            std::cout << indent << "delegated:" << std::setw(17) << net_others
                      << std::string(11, ' ') << "(total staked delegated to account from others)" << std::endl;
         }
      }
 
 
      auto to_pretty_time = []( int64_t nmicro, uint8_t width_for_units = 5 ) {
         if(nmicro == -1) {
             // special case. Treat it as unlimited
             return std::string("unlimited");
         }
         string unit = "us";
         double micro = static_cast<double>(nmicro);
 
         if( micro > 1000000*60*60ll ) {
            micro /= 1000000*60*60ll;
            unit = "hr";
         }
         else if( micro > 1000000*60 ) {
            micro /= 1000000*60;
            unit = "min";
         }
         else if( micro > 1000000 ) {
            micro /= 1000000;
            unit = "sec";
         }
         else if( micro > 1000 ) {
            micro /= 1000;
            unit = "ms";
         }
         std::stringstream ss;
         ss << setprecision(4);
         ss << micro << " ";
         if( width_for_units > 0 )
            ss << std::left << setw( width_for_units );
         ss << unit;
         return ss.str();
      };
 
 
      std::cout << std::fixed << setprecision(3);
      std::cout << indent << std::left << std::setw(11) << "used:"      << std::right << std::setw(18) << to_pretty_net( res.net_limit.used ) << "\n";
      std::cout << indent << std::left << std::setw(11) << "available:" << std::right << std::setw(18) << to_pretty_net( res.net_limit.available ) << "\n";
      std::cout << indent << std::left << std::setw(11) << "limit:"     << std::right << std::setw(18) << to_pretty_net( res.net_limit.max ) << "\n";
      std::cout << std::endl;
 
      std::cout << "cpu bandwidth:" << std::endl;
 
      if ( res.total_resources.is_object() ) {
         auto cpu_total = to_asset(res.total_resources.get_object()["cpu_weight"].as_string());
 
         if( res.self_delegated_bandwidth.is_object() ) {
            asset cpu_own = asset::from_string( res.self_delegated_bandwidth.get_object()["cpu_weight"].as_string() );
            staked += cpu_own;
 
            auto cpu_others = cpu_total - cpu_own;
 
            std::cout << indent << "staked:" << std::setw(20) << cpu_own
                      << std::string(11, ' ') << "(total stake delegated from account to self)" << std::endl
                      << indent << "delegated:" << std::setw(17) << cpu_others
                      << std::string(11, ' ') << "(total staked delegated to account from others)" << std::endl;
         } else {
            auto cpu_others = cpu_total;
            std::cout << indent << "delegated:" << std::setw(17) << cpu_others
                      << std::string(11, ' ') << "(total staked delegated to account from others)" << std::endl;
         }
      }
 
      std::cout << std::fixed << setprecision(3);
      std::cout << indent << std::left << std::setw(11) << "used:"      << std::right << std::setw(18) << to_pretty_time( res.cpu_limit.used ) << "\n";
      std::cout << indent << std::left << std::setw(11) << "available:" << std::right << std::setw(18) << to_pretty_time( res.cpu_limit.available ) << "\n";
      std::cout << indent << std::left << std::setw(11) << "limit:"     << std::right << std::setw(18) << to_pretty_time( res.cpu_limit.max ) << "\n";
      std::cout << std::endl;
 
      if( res.subjective_cpu_bill_limit ) {
         std::cout << "subjective cpu bandwidth:" << std::endl;
         std::cout << indent << std::left << std::setw(11) << "used:"      << std::right << std::setw(18) << to_pretty_time( (res.subjective_cpu_bill_limit)->used ) << "\n";
         std::cout << std::endl;
      }
 
      if( res.refund_request.is_object() ) {
         auto obj = res.refund_request.get_object();
         auto request_time = fc::time_point_sec::from_iso_string( obj["request_time"].as_string() );
         fc::time_point refund_time = request_time + fc::days(3);
         auto now = res.head_block_time;
         asset net = asset::from_string( obj["net_amount"].as_string() );
         asset cpu = asset::from_string( obj["cpu_amount"].as_string() );
         unstaking = net + cpu;
 
         if( unstaking > asset( 0, unstaking.get_symbol() ) ) {
            std::cout << std::fixed << setprecision(3);
            std::cout << "unstaking tokens:" << std::endl;
            std::cout << indent << std::left << std::setw(25) << "time of unstake request:" << std::right << std::setw(20) << string(request_time);
            if( now >= refund_time ) {
               std::cout << " (available to claim now with 'sysio::refund' action)\n";
            } else {
               std::cout << " (funds will be available in " << to_pretty_time( (refund_time - now).count(), 0 ) << ")\n";
            }
            std::cout << indent << std::left << std::setw(25) << "from net bandwidth:" << std::right << std::setw(18) << net << std::endl;
            std::cout << indent << std::left << std::setw(25) << "from cpu bandwidth:" << std::right << std::setw(18) << cpu << std::endl;
            std::cout << indent << std::left << std::setw(25) << "total:" << std::right << std::setw(18) << unstaking << std::endl;
            std::cout << std::endl;
         }
      }
 
      if( res.core_liquid_balance ) {
         std::cout << res.core_liquid_balance->get_symbol().name() << " balances: " << std::endl;
         std::cout << indent << std::left << std::setw(11)
                   << "liquid:" << std::right << std::setw(18) << *res.core_liquid_balance << std::endl;
         std::cout << indent << std::left << std::setw(11)
                   << "staked:" << std::right << std::setw(18) << staked << std::endl;
         std::cout << indent << std::left << std::setw(11)
                   << "unstaking:" << std::right << std::setw(18) << unstaking << std::endl;
         std::cout << indent << std::left << std::setw(11) << "total:" << std::right << std::setw(18) << (*res.core_liquid_balance + staked + unstaking) << std::endl;
         std::cout << std::endl;
      }
 
      if( res.rex_info.is_object() ) {
         auto& obj = res.rex_info.get_object();
         asset vote_stake = asset::from_string( obj["vote_stake"].as_string() );
         asset rex_balance = asset::from_string( obj["rex_balance"].as_string() );
         std::cout << rex_balance.get_symbol().name() << " balances: " << std::endl;
         std::cout << indent << std::left << std::setw(11)
                   << "balance:" << std::right << std::setw(18) << rex_balance << std::endl;
         std::cout << indent << std::left << std::setw(11)
                   << "staked:" << std::right << std::setw(18) << vote_stake << std::endl;
         std::cout << std::endl;
      }
 
      if ( res.voter_info.is_object() ) {
         auto& obj = res.voter_info.get_object();
         string proxy = obj["proxy"].as_string();
         if ( proxy.empty() ) {
            auto& prods = obj["producers"].get_array();
            std::cout << "producers:";
            if ( !prods.empty() ) {
               for ( size_t i = 0; i < prods.size(); ++i ) {
                  if ( i%3 == 0 ) {
                     std::cout << std::endl << indent;
                  }
                  std::cout << std::setw(16) << std::left << prods[i].as_string();
               }
               std::cout << std::endl;
            } else {
               std::cout << indent << "<not voted>" << std::endl;
            }
         } else {
            std::cout << "proxy:" << indent << proxy << std::endl;
         }
      }
      std::cout << std::endl;
   } else {
      std::cout << fc::json::to_pretty_string(json) << std::endl;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_account_permissions() [1/2]

vector< chain::permission_level > get_account_permissions

(

const vector< string > &

permissions

)

Definition at line 238 of file main.cpp.

                                                                                         {
   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 = name(pieces[0]), .permission = name(pieces[1]) };
   });
   vector<chain::permission_level> accountPermissions;
   boost::range::copy(fixedPermissions, back_inserter(accountPermissions));
   return accountPermissions;
}

Here is the caller graph for this function:

get_account_permissions() [2/2]

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

Definition at line 250 of file main.cpp.

                                                                                                                                          {
   if (permissions.empty())
      return vector<chain::permission_level>{default_permission};
   else
      return get_account_permissions(tx_permission);
}

Here is the call graph for this function:

get_info()

sysio::chain_apis::read_only::get_info_results get_info

(

)

Definition at line 287 of file main.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_return_code()

int get_return_code

(

const fc::variant &

result

)

Definition at line 542 of file main.cpp.

                                               {
   // if a trx with a processed, then check to see if it failed execution for return value
   int r = 0;
   if (result.is_object() && result.get_object().contains("processed")) {
      const auto& processed = result["processed"];
      if( processed.is_object() && processed.get_object().contains( "except" ) ) {
         const auto& except = processed["except"];
         if( except.is_object() ) {
            try {
               auto soft_except = except.as<fc::exception>();
               auto code = soft_except.code();
               if( code > std::numeric_limits<int>::max() ) {
                  r = 1;
               } else {
                  r = static_cast<int>( code );
               }
               if( r == 0 ) r = 1;
            } catch( ... ) {
               r = 1;
            }
         }
      }
   }
   return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

json_from_file_or_string()

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

Definition at line 509 of file main.cpp.

{
   regex r("^[ \t]*[\{\[]");
   if ( !regex_search(file_or_str, r) && fc::is_regular_file(file_or_str) ) {
      try {
         return fc::json::from_file(file_or_str, ptype);
      } SYS_RETHROW_EXCEPTIONS(json_parse_exception, "Fail to parse JSON from file: ${file}", ("file", file_or_str));
 
   } else {
      try {
         return fc::json::from_string(file_or_str, ptype);
      } SYS_RETHROW_EXCEPTIONS(json_parse_exception, "Fail to parse JSON from string: ${string}", ("string", file_or_str));
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

json_or_file_to_bin()

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

Definition at line 524 of file main.cpp.

                                                                                                                    {
   fc::variant action_args_var;
   if( !data_or_filename.empty() ) {
      action_args_var = json_from_file_or_string(data_or_filename, fc::json::parse_type::relaxed_parser);
   }
   return variant_to_bin( account, action, action_args_var );
}

Here is the call graph for this function:

local_port_used()

bool local_port_used

(

)

Definition at line 1010 of file main.cpp.

                       {
    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;
}

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv )

Definition at line 2538 of file main.cpp.

                                  {
   fc::logger::get(DEFAULT_LOGGER).set_log_level(fc::log_level::debug);
   context = sysio::client::http::create_http_context();
   wallet_url = default_wallet_url;
 
   CLI::App app{"Command Line Interface to SYSIO Client"};
   app.require_subcommand();
   // Hide obsolete options by putting them into a group with an empty name.
   app.add_option( "-H,--host", obsoleted_option_host_port, localized("The host where ${n} is running", ("n", node_executable_name)) )->group("");
   app.add_option( "-p,--port", obsoleted_option_host_port, localized("The port where ${n} is running", ("n", node_executable_name)) )->group("");
   app.add_option( "--wallet-host", obsoleted_option_host_port, localized("The host where ${k} is running", ("k", key_store_executable_name)) )->group("");
   app.add_option( "--wallet-port", obsoleted_option_host_port, localized("The port where ${k} is running", ("k", key_store_executable_name)) )->group("");
 
   app.add_option( "-u,--url", url, localized("The http/https URL where ${n} is running", ("n", node_executable_name)), true );
   app.add_option( "--wallet-url", wallet_url, localized("The http/https URL where ${k} is running", ("k", key_store_executable_name)), true );
 
   app.add_option( "-r,--header", header_opt_callback, localized("Pass specific HTTP header; repeat this option to pass multiple headers"));
   app.add_flag( "-n,--no-verify", no_verify, localized("Don't verify peer certificate when using HTTPS"));
   app.add_flag( "--no-auto-" + string(key_store_executable_name), no_auto_kiod, localized("Don't automatically launch a ${k} if one is not currently running", ("k", key_store_executable_name)));
   app.parse_complete_callback([&app]{ ensure_kiod_running(&app);});
 
   app.add_flag( "-v,--verbose", verbose, localized("Output verbose errors and action console output"));
   app.add_flag("--print-request", print_request, localized("Print HTTP request to STDERR"));
   app.add_flag("--print-response", print_response, localized("Print HTTP response to STDERR"));
 
   auto version = app.add_subcommand("version", localized("Retrieve version information"));
   version->require_subcommand();
 
   version->add_subcommand("client", localized("Retrieve basic version information of the client"))->callback([] {
      std::cout << sysio::version::version_client() << '\n';
   });
 
   version->add_subcommand("full", localized("Retrieve full version information of the client"))->callback([] {
     std::cout << sysio::version::version_full() << '\n';
   });
 
   // Create subcommand
   auto create = app.add_subcommand("create", localized("Create various items, on and off the blockchain"));
   create->require_subcommand();
 
   bool r1 = false;
   string key_file;
   bool print_console = false;
   // create key
   auto create_key = create->add_subcommand("key", localized("Create a new keypair and print the public and private keys"))->callback( [&r1, &key_file, &print_console](){
      if (key_file.empty() && !print_console) {
         std::cerr << "ERROR: Either indicate a file using \"--file\" or pass \"--to-console\"" << std::endl;
         return;
      }
 
      auto pk    = r1 ? private_key_type::generate_r1() : private_key_type::generate();
      auto privs = pk.to_string();
      auto pubs  = pk.get_public_key().to_string();
      if (print_console) {
         std::cout << localized("Private key: ${key}", ("key",  privs) ) << std::endl;
         std::cout << localized("Public key: ${key}", ("key", pubs ) ) << std::endl;
      } else {
         std::cerr << localized("saving keys to ${filename}", ("filename", key_file)) << std::endl;
         std::ofstream out( key_file.c_str() );
         out << localized("Private key: ${key}", ("key",  privs) ) << std::endl;
         out << localized("Public key: ${key}", ("key", pubs ) ) << std::endl;
      }
   });
   create_key->add_flag( "--r1", r1, "Generate a key using the R1 curve (iPhone), instead of the K1 curve (Bitcoin)"  );
   create_key->add_option("-f,--file", key_file, localized("Name of file to write private/public key output to. (Must be set, unless \"--to-console\" is passed"));
   create_key->add_flag( "--to-console", print_console, localized("Print private/public keys to console."));
 
   // create account
   auto createAccount = create_account_subcommand( create, true /*simple*/ );
 
   // convert subcommand
   auto convert = app.add_subcommand("convert", localized("Pack and unpack transactions")); // TODO also add converting action args based on abi from here ?
   convert->require_subcommand();
 
   // pack transaction
   string plain_signed_transaction_json;
   bool pack_action_data_flag = false;
   auto pack_transaction = convert->add_subcommand("pack_transaction", localized("From plain signed JSON to packed form"));
   pack_transaction->add_option("transaction", plain_signed_transaction_json, localized("The plain signed JSON (string)"))->required();
   pack_transaction->add_flag("--pack-action-data", pack_action_data_flag, localized("Pack all action data within transaction, needs interaction with ${n}", ("n", node_executable_name)));
   pack_transaction->callback([&] {
      fc::variant trx_var = json_from_file_or_string( plain_signed_transaction_json );
      if( pack_action_data_flag ) {
         signed_transaction trx;
         try {
            abi_serializer::from_variant( trx_var, trx, abi_serializer_resolver, abi_serializer::create_yield_function( abi_serializer_max_time ) );
         } SYS_RETHROW_EXCEPTIONS( transaction_type_exception, "Invalid transaction format: '${data}'",
                                   ("data", fc::json::to_string(trx_var, fc::time_point::maximum())))
         std::cout << fc::json::to_pretty_string( packed_transaction( trx, packed_transaction::compression_type::none )) << std::endl;
      } else {
         try {
            signed_transaction trx = trx_var.as<signed_transaction>();
            std::cout << fc::json::to_pretty_string( fc::variant( packed_transaction( trx, packed_transaction::compression_type::none ))) << std::endl;
         } SYS_RETHROW_EXCEPTIONS( transaction_type_exception, "Fail to convert transaction, --pack-action-data likely needed" )
      }
   });
 
   // unpack transaction
   string packed_transaction_json;
   bool unpack_action_data_flag = false;
   auto unpack_transaction = convert->add_subcommand("unpack_transaction", localized("From packed to plain signed JSON form"));
   unpack_transaction->add_option("transaction", packed_transaction_json, localized("The packed transaction JSON (string containing packed_trx and optionally compression fields)"))->required();
   unpack_transaction->add_flag("--unpack-action-data", unpack_action_data_flag, localized("Unpack all action data within transaction, needs interaction with ${n}", ("n", node_executable_name)));
   unpack_transaction->callback([&] {
      fc::variant packed_trx_var = json_from_file_or_string( packed_transaction_json );
      packed_transaction packed_trx;
      try {
         fc::from_variant<packed_transaction>( packed_trx_var, packed_trx );
      } SYS_RETHROW_EXCEPTIONS( transaction_type_exception, "Invalid packed transaction format: '${data}'",
                                ("data", fc::json::to_string(packed_trx_var, fc::time_point::maximum())))
      signed_transaction strx = packed_trx.get_signed_transaction();
      fc::variant trx_var;
      if( unpack_action_data_flag ) {
         abi_serializer::to_variant( strx, trx_var, abi_serializer_resolver, abi_serializer::create_yield_function( abi_serializer_max_time ) );
      } else {
         trx_var = strx;
      }
      std::cout << fc::json::to_pretty_string( trx_var ) << std::endl;
   });
 
   // pack action data
   string unpacked_action_data_account_string;
   string unpacked_action_data_name_string;
   string unpacked_action_data_string;
   auto pack_action_data = convert->add_subcommand("pack_action_data", localized("From JSON action data to packed form"));
   pack_action_data->add_option("account", unpacked_action_data_account_string, localized("The name of the account hosting the contract"))->required();
   pack_action_data->add_option("name", unpacked_action_data_name_string, localized("The name of the function called by this action"))->required();
   pack_action_data->add_option("unpacked_action_data", unpacked_action_data_string, localized("The action data expressed as JSON"))->required();
   pack_action_data->callback([&] {
      fc::variant unpacked_action_data_json = json_from_file_or_string(unpacked_action_data_string);
      bytes packed_action_data_string;
      try {
         packed_action_data_string = variant_to_bin(name(unpacked_action_data_account_string), name(unpacked_action_data_name_string), unpacked_action_data_json);
      } SYS_RETHROW_EXCEPTIONS(transaction_type_exception, "Fail to parse unpacked action data JSON")
      std::cout << fc::to_hex(packed_action_data_string.data(), packed_action_data_string.size()) << std::endl;
   });
 
   // unpack action data
   string packed_action_data_account_string;
   string packed_action_data_name_string;
   string packed_action_data_string;
   auto unpack_action_data = convert->add_subcommand("unpack_action_data", localized("From packed to JSON action data form"));
   unpack_action_data->add_option("account", packed_action_data_account_string, localized("The name of the account that hosts the contract"))->required();
   unpack_action_data->add_option("name", packed_action_data_name_string, localized("The name of the function that's called by this action"))->required();
   unpack_action_data->add_option("packed_action_data", packed_action_data_string, localized("The action data expressed as packed hex string"))->required();
   unpack_action_data->callback([&] {
      SYS_ASSERT( packed_action_data_string.size() >= 2, transaction_type_exception, "No packed_action_data found" );
      vector<char> packed_action_data_blob(packed_action_data_string.size()/2);
      fc::from_hex(packed_action_data_string, packed_action_data_blob.data(), packed_action_data_blob.size());
      fc::variant unpacked_action_data_json = bin_to_variant(name(packed_action_data_account_string), name(packed_action_data_name_string), packed_action_data_blob);
      std::cout << fc::json::to_pretty_string(unpacked_action_data_json) << std::endl;
   });
 
   // Get subcommand
   auto get = app.add_subcommand("get", localized("Retrieve various items and information from the blockchain"));
   get->require_subcommand();
 
   // get info
   get->add_subcommand("info", localized("Get current blockchain information"))->callback([] {
      std::cout << fc::json::to_pretty_string(get_info()) << std::endl;
   });
 
   // get transaction status
   string status_transaction_id;
   auto getTransactionStatus = get->add_subcommand("transaction-status", localized("Get transaction status information"));
   getTransactionStatus->add_option("id", status_transaction_id, localized("ID of the transaction to retrieve"))->required();
   getTransactionStatus->callback([&status_transaction_id] {
      try {
         chain::transaction_id_type transaction_id(status_transaction_id);
      } catch (...) {
         std::cerr << "Unable to convert " << status_transaction_id << " to transaction id." << std::endl;
         throw;
      }
      auto arg= fc::mutable_variant_object( "id", status_transaction_id);
      std::cout << fc::json::to_pretty_string(call(get_transaction_status_func, arg)) << std::endl;
   });
 
   // get block
   string blockArg;
   bool get_bhs = false;
   bool get_binfo = false;
   auto getBlock = get->add_subcommand("block", localized("Retrieve a full block from the blockchain"));
   getBlock->add_option("block", blockArg, localized("The number or ID of the block to retrieve"))->required();
   getBlock->add_flag("--header-state", get_bhs, localized("Get block header state from fork database instead") );
   getBlock->add_flag("--info", get_binfo, localized("Get block info from the blockchain by block num only") );
   getBlock->callback([&blockArg, &get_bhs, &get_binfo] {
      SYSC_ASSERT( !(get_bhs && get_binfo), "ERROR: Either --header-state or --info can be set" );
      if (get_binfo) {
         std::optional<int64_t> block_num;
         try {
            block_num = fc::to_int64(blockArg);
         } catch (...) {
            // error is handled in assertion below
         }
         SYSC_ASSERT( block_num.has_value() && (*block_num > 0), "Invalid block num: ${block_num}", ("block_num", blockArg) );
         const auto arg = fc::variant_object("block_num", static_cast<uint32_t>(*block_num));
         std::cout << fc::json::to_pretty_string(call(get_block_info_func, arg)) << std::endl;
      } else {
         const auto arg = fc::variant_object("block_num_or_id", blockArg);
         if (get_bhs) {
            std::cout << fc::json::to_pretty_string(call(get_block_header_state_func, arg)) << std::endl;
         } else {
            std::cout << fc::json::to_pretty_string(call(get_block_func, arg)) << std::endl;
         }
      }
   });
 
   // get account
   string accountName;
   string coresym;
   bool print_json = false;
   auto getAccount = get->add_subcommand("account", localized("Retrieve an account from the blockchain"));
   getAccount->add_option("name", accountName, localized("The name of the account to retrieve"))->required();
   getAccount->add_option("core-symbol", coresym, localized("The expected core symbol of the chain you are querying"));
   getAccount->add_flag("--json,-j", print_json, localized("Output in JSON format") );
   getAccount->callback([&]() { get_account(accountName, coresym, print_json); });
 
   // get code
   string codeFilename;
   string abiFilename;
   bool code_as_wasm = true;
   auto getCode = get->add_subcommand("code", localized("Retrieve the code and ABI for an account"));
   getCode->add_option("name", accountName, localized("The name of the account whose code should be retrieved"))->required();
   getCode->add_option("-c,--code",codeFilename, localized("The name of the file to save the contract wasm to") );
   getCode->add_option("-a,--abi",abiFilename, localized("The name of the file to save the contract .abi to") );
   getCode->add_flag("--wasm", code_as_wasm, localized("Save contract as wasm (ignored, default)"));
   getCode->callback([&] {
      string code_hash, wasm, abi;
      try {
         const auto result = call(get_raw_code_and_abi_func, fc::mutable_variant_object("account_name", accountName));
         const std::vector<char> wasm_v = result["wasm"].as_blob().data;
         const std::vector<char> abi_v = result["abi"].as_blob().data;
 
         fc::sha256 hash;
         if(wasm_v.size())
            hash = fc::sha256::hash(wasm_v.data(), wasm_v.size());
         code_hash = (string)hash;
 
         wasm = string(wasm_v.begin(), wasm_v.end());
 
         abi_def abi_d;
         if(abi_serializer::to_abi(abi_v, abi_d))
            abi = fc::json::to_pretty_string(abi_d);
      }
      catch(chain::missing_chain_api_plugin_exception&) {
         //see if this is an old nodeop that doesn't support get_raw_code_and_abi
         const auto old_result = call(get_code_func, fc::mutable_variant_object("account_name", accountName)("code_as_wasm",code_as_wasm));
         code_hash = old_result["code_hash"].as_string();
         wasm = old_result["wasm"].as_string();
         std::cout << localized("Warning: communicating to older ${n} which returns malformed binary wasm", ("n", node_executable_name)) << std::endl;
         abi = fc::json::to_pretty_string(old_result["abi"]);
      }
 
      std::cout << localized("code hash: ${code_hash}", ("code_hash", code_hash)) << std::endl;
 
      if( codeFilename.size() ){
         std::cout << localized("saving wasm to ${codeFilename}", ("codeFilename", codeFilename)) << std::endl;
 
         std::ofstream out( codeFilename.c_str() );
         out << wasm;
      }
      if( abiFilename.size() ) {
         std::cout << localized("saving abi to ${abiFilename}", ("abiFilename", abiFilename)) << std::endl;
         std::ofstream abiout( abiFilename.c_str() );
         abiout << abi;
      }
   });
 
   // get abi
   string filename;
   auto getAbi = get->add_subcommand("abi", localized("Retrieve the ABI for an account"));
   getAbi->add_option("name", accountName, localized("The name of the account whose abi should be retrieved"))->required();
   getAbi->add_option("-f,--file",filename, localized("The name of the file to save the contract .abi to instead of writing to console") );
   getAbi->callback([&] {
      auto result = call(get_abi_func, fc::mutable_variant_object("account_name", accountName));
 
      auto abi  = fc::json::to_pretty_string( result["abi"] );
      if( filename.size() ) {
         std::cerr << localized("saving abi to ${filename}", ("filename", filename)) << std::endl;
         std::ofstream abiout( filename.c_str() );
         abiout << abi;
      } else {
         std::cout << abi << "\n";
      }
   });
 
   // get table
   string scope;
   string code;
   string table;
   string lower;
   string upper;
   string table_key;
   string key_type;
   string encode_type{"dec"};
   bool binary = false;
   uint32_t limit = 10;
   string index_position;
   bool reverse = false;
   bool show_payer = false;
   auto getTable = get->add_subcommand( "table", localized("Retrieve the contents of a database table"));
   getTable->add_option( "account", code, localized("The account who owns the table") )->required();
   getTable->add_option( "scope", scope, localized("The scope within the contract in which the table is found") )->required();
   getTable->add_option( "table", table, localized("The name of the table as specified by the contract abi") )->required();
   getTable->add_option( "-l,--limit", limit, localized("The maximum number of rows to return") );
   getTable->add_option( "-k,--key", table_key, localized("Deprecated") );
   getTable->add_option( "-L,--lower", lower, localized("JSON representation of lower bound value of key, defaults to first") );
   getTable->add_option( "-U,--upper", upper, localized("JSON representation of upper bound value of key, defaults to last") );
   getTable->add_option( "--index", index_position,
                         localized("Index number, 1 - primary (first), 2 - secondary index (in order defined by multi_index), 3 - third index, etc.\n"
                                   "\t\t\t\tNumber or name of index can be specified, e.g. 'secondary' or '2'."));
   getTable->add_option( "--key-type", key_type,
                         localized("The key type of --index, primary only supports (i64), all others support (i64, i128, i256, float64, float128, ripemd160, sha256).\n"
                                   "\t\t\t\tSpecial type 'name' indicates an account name."));
   getTable->add_option( "--encode-type", encode_type,
                         localized("The encoding type of key_type (i64 , i128 , float64, float128) only support decimal encoding e.g. 'dec'"
                                    "i256 - supports both 'dec' and 'hex', ripemd160 and sha256 is 'hex' only"));
   getTable->add_flag("-b,--binary", binary, localized("Return the value as BINARY rather than using abi to interpret as JSON"));
   getTable->add_flag("-r,--reverse", reverse, localized("Iterate in reverse order"));
   getTable->add_flag("--show-payer", show_payer, localized("Show RAM payer"));
 
 
   getTable->callback([&] {
      auto result = call(get_table_func, fc::mutable_variant_object("json", !binary)
                         ("code",code)
                         ("scope",scope)
                         ("table",table)
                         ("table_key",table_key) // not used
                         ("lower_bound",lower)
                         ("upper_bound",upper)
                         ("limit",limit)
                         ("key_type",key_type)
                         ("index_position", index_position)
                         ("encode_type", encode_type)
                         ("reverse", reverse)
                         ("show_payer", show_payer)
                         );
 
      std::cout << fc::json::to_pretty_string(result)
                << std::endl;
   });
 
   auto getScope = get->add_subcommand( "scope", localized("Retrieve a list of scopes and tables owned by a contract"));
   getScope->add_option( "contract", code, localized("The contract who owns the table") )->required();
   getScope->add_option( "-t,--table", table, localized("The name of the table as filter") );
   getScope->add_option( "-l,--limit", limit, localized("The maximum number of rows to return") );
   getScope->add_option( "-L,--lower", lower, localized("Lower bound of scope") );
   getScope->add_option( "-U,--upper", upper, localized("Upper bound of scope") );
   getScope->add_flag("-r,--reverse", reverse, localized("Iterate in reverse order"));
   getScope->callback([&] {
      auto result = call(get_table_by_scope_func, fc::mutable_variant_object("code",code)
                         ("table",table)
                         ("lower_bound",lower)
                         ("upper_bound",upper)
                         ("limit",limit)
                         ("reverse", reverse)
                         );
      std::cout << fc::json::to_pretty_string(result)
                << std::endl;
   });
 
   // currency accessors
   // get currency balance
   string symbol;
   bool currency_balance_print_json = false;
   auto get_currency = get->add_subcommand( "currency", localized("Retrieve information related to standard currencies"));
   get_currency->require_subcommand();
   auto get_balance = get_currency->add_subcommand( "balance", localized("Retrieve the balance of an account for a given currency"));
   get_balance->add_option( "contract", code, localized("The contract that operates the currency") )->required();
   get_balance->add_option( "account", accountName, localized("The account to query balances for") )->required();
   get_balance->add_option( "symbol", symbol, localized("The symbol for the currency if the contract operates multiple currencies") );
   get_balance->add_flag("--json,-j", currency_balance_print_json, localized("Output in JSON format") );
   get_balance->callback([&] {
      auto result = call(get_currency_balance_func, fc::mutable_variant_object
         ("account", accountName)
         ("code", code)
         ("symbol", symbol.empty() ? fc::variant() : symbol)
      );
      if (!currency_balance_print_json) {
        const auto& rows = result.get_array();
        for( const auto& r : rows ) {
           std::cout << clean_output( r.as_string() ) << std::endl;
        }
      } else {
        std::cout << fc::json::to_pretty_string(result) << std::endl;
      }
   });
 
   auto get_currency_stats = get_currency->add_subcommand( "stats", localized("Retrieve the stats of for a given currency"));
   get_currency_stats->add_option( "contract", code, localized("The contract that operates the currency") )->required();
   get_currency_stats->add_option( "symbol", symbol, localized("The symbol for the currency if the contract operates multiple currencies") )->required();
   get_currency_stats->callback([&] {
      auto result = call(get_currency_stats_func, fc::mutable_variant_object("json", false)
         ("code", code)
         ("symbol", symbol)
      );
 
      std::cout << fc::json::to_pretty_string(result)
                << std::endl;
   });
 
   // get accounts
   string public_key_str;
   auto getAccounts = get->add_subcommand("accounts", localized("Retrieve accounts associated with a public key"));
   getAccounts->add_option("public_key", public_key_str, localized("The public key to retrieve accounts for"))->required();
   getAccounts->callback([&] {
      public_key_type public_key;
      try {
         public_key = public_key_type(public_key_str);
      } SYS_RETHROW_EXCEPTIONS(public_key_type_exception, "Invalid public key: ${public_key}", ("public_key", public_key_str))
      auto arg = fc::mutable_variant_object( "public_key", public_key);
      std::cout << fc::json::to_pretty_string(call(get_key_accounts_func, arg)) << std::endl;
   });
 
 
   // get servants
   string controllingAccount;
   auto getServants = get->add_subcommand("servants", localized("Retrieve accounts which are servants of a given account "));
   getServants->add_option("account", controllingAccount, localized("The name of the controlling account"))->required();
   getServants->callback([&] {
      auto arg = fc::mutable_variant_object( "controlling_account", controllingAccount);
      std::cout << fc::json::to_pretty_string(call(get_controlled_accounts_func, arg)) << std::endl;
   });
 
   // get transaction (history api plugin)
   string transaction_id_str;
   uint32_t block_num_hint = 0;
   auto getTransaction = get->add_subcommand("transaction", localized("Retrieve a transaction from the blockchain"));
   getTransaction->add_option("id", transaction_id_str, localized("ID of the transaction to retrieve"))->required();
   getTransaction->add_option( "-b,--block-hint", block_num_hint, localized("The block number this transaction may be in") );
   getTransaction->callback([&] {
      auto arg= fc::mutable_variant_object( "id", transaction_id_str);
      if ( block_num_hint > 0 ) {
         arg = arg("block_num_hint", block_num_hint);
      }
      std::cout << fc::json::to_pretty_string(call(get_transaction_func, arg)) << std::endl;
   });
 
   // get transaction_trace (trace api plugin)
   auto getTransactionTrace = get->add_subcommand("transaction_trace", localized("Retrieve a transaction from trace logs"));
   getTransactionTrace->add_option("id", transaction_id_str, localized("ID of the transaction to retrieve"))->required();
   getTransactionTrace->callback([&] {
      auto arg= fc::mutable_variant_object( "id", transaction_id_str);
      std::cout << fc::json::to_pretty_string(call(get_transaction_trace_func, arg)) << std::endl;
   });
 
   // get block_trace
   string blockNum;
   auto getBlockTrace = get->add_subcommand("block_trace", localized("Retrieve a block from trace logs"));
   getBlockTrace->add_option("block", blockNum, localized("The number of the block to retrieve"))->required();
 
   getBlockTrace->callback([&] {
      auto arg= fc::mutable_variant_object( "block_num", blockNum);
      std::cout << fc::json::to_pretty_string(call(get_block_trace_func, arg)) << std::endl;
   });
 
   // get actions
   string account_name;
   string skip_seq_str;
   string num_seq_str;
   bool printjson = false;
   bool fullact = false;
   bool prettyact = false;
   bool printconsole = false;
 
   int32_t pos_seq = -1;
   int32_t offset = -20;
   auto getActions = get->add_subcommand("actions", localized("Retrieve all actions with specific account name referenced in authorization or receiver"));
   getActions->add_option("account_name", account_name, localized("Name of account to query on"))->required();
   getActions->add_option("pos", pos_seq, localized("Sequence number of action for this account, -1 for last"));
   getActions->add_option("offset", offset, localized("Get actions [pos,pos+offset] for positive offset or [pos-offset,pos) for negative offset"));
   getActions->add_flag("--json,-j", printjson, localized("Print full JSON"));
   getActions->add_flag("--full", fullact, localized("Don't truncate action output"));
   getActions->add_flag("--pretty", prettyact, localized("Pretty print full action JSON"));
   getActions->add_flag("--console", printconsole, localized("Print console output generated by action "));
   getActions->callback([&] {
      fc::mutable_variant_object arg;
      arg( "account_name", account_name );
      arg( "pos", pos_seq );
      arg( "offset", offset);
 
      auto result = call(get_actions_func, arg);
 
 
      if( printjson ) {
         std::cout << fc::json::to_pretty_string(result) << std::endl;
      } else {
          auto& traces = result["actions"].get_array();
          uint32_t lib = result["last_irreversible_block"].as_uint64();
 
 
          cout  << "#" << setw(5) << "seq" << "  " << setw( 24 ) << left << "when"<< "  " << setw(24) << right << "contract::action" << " => " << setw(13) << left << "receiver" << " " << setw(11) << left << "trx id..." << " args\n";
          cout  << "================================================================================================================\n";
          for( const auto& trace: traces ) {
              std::stringstream out;
              if( trace["block_num"].as_uint64() <= lib )
                 out << "#";
              else
                 out << "?";
 
              out << setw(5) << trace["account_action_seq"].as_uint64() <<"  ";
              out << setw(24) << trace["block_time"].as_string() <<"  ";
 
              const auto& at = trace["action_trace"].get_object();
 
              auto id = at["trx_id"].as_string();
              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();
              string args;
              if( prettyact ) {
                  args = fc::json::to_pretty_string( act["data"] );
              }
              else {
                 args = fc::json::to_string( act["data"], fc::time_point::maximum() );
                 if( !fullact ) {
                    args = args.substr(0,60) + "...";
                 }
              }
              out << std::setw(24) << std::right<< (code +"::" + func) << " => " << left << std::setw(13) << receiver;
 
              out << " " << setw(11) << (id.substr(0,8) + "...");
 
              if( fullact || prettyact ) out << "\n";
              else out << " ";
 
              out << args ;//<< "\n";
 
              if( trace["block_num"].as_uint64() <= lib ) {
                 dlog( "\r${m}", ("m",out.str()) );
              } else {
                 wlog( "\r${m}", ("m",out.str()) );
              }
              if( printconsole ) {
                 auto console = at["console"].as_string();
                 if( console.size() ) {
                    stringstream sout;
                    std::stringstream ss(console);
                    string line;
                    while( std::getline( ss, line ) ) {
                       sout << ">> " << clean_output( std::move( line ) ) << "\n";
                       if( !fullact ) break;
                       line.clear();
                    }
                    cerr << sout.str(); //ilog( "\r${m}                                   ", ("m",out.str()) );
                 }
              }
          }
      }
   });
 
   auto getSchedule = get_schedule_subcommand{get};
   auto getTransactionId = get_transaction_id_subcommand{get};
 
   // set subcommand
   auto setSubcommand = app.add_subcommand("set", localized("Set or update blockchain state"));
   setSubcommand->require_subcommand();
 
   // set contract subcommand
   string account;
   string contractPath;
   string wasmPath;
   string abiPath;
   bool shouldSend = true;
   bool contract_clear = false;
   bool suppress_duplicate_check = false;
   auto codeSubcommand = setSubcommand->add_subcommand("code", localized("Create or update the code on an account"));
   codeSubcommand->add_option("account", account, localized("The account to set code for"))->required();
   codeSubcommand->add_option("code-file", wasmPath, localized("The path containing the contract WASM"));//->required();
   codeSubcommand->add_flag( "-c,--clear", contract_clear, localized("Remove code on an account"));
   codeSubcommand->add_flag( "--suppress-duplicate-check", suppress_duplicate_check, localized("Don't check for duplicate"));
 
   auto abiSubcommand = setSubcommand->add_subcommand("abi", localized("Create or update the abi on an account"));
   abiSubcommand->add_option("account", account, localized("The account to set the ABI for"))->required();
   abiSubcommand->add_option("abi-file", abiPath, localized("The path containing the contract ABI"));//->required();
   abiSubcommand->add_flag( "-c,--clear", contract_clear, localized("Remove abi on an account"));
   abiSubcommand->add_flag( "--suppress-duplicate-check", suppress_duplicate_check, localized("Don't check for duplicate"));
 
   auto contractSubcommand = setSubcommand->add_subcommand("contract", localized("Create or update the contract on an account"));
   contractSubcommand->add_option("account", account, localized("The account to publish a contract for"))
                     ->required();
   contractSubcommand->add_option("contract-dir", contractPath, localized("The path containing the .wasm and .abi"));
                     // ->required();
   contractSubcommand->add_option("wasm-file", wasmPath, localized("The file containing the contract WASM relative to contract-dir"));
//                     ->check(CLI::ExistingFile);
   contractSubcommand->add_option("abi-file,-a,--abi", abiPath, localized("The ABI for the contract relative to contract-dir"));
//                                ->check(CLI::ExistingFile);
   contractSubcommand->add_flag( "-c,--clear", contract_clear, localized("Remove contract on an account"));
   contractSubcommand->add_flag( "--suppress-duplicate-check", suppress_duplicate_check, localized("Don't check for duplicate"));
 
   std::vector<chain::action> actions;
   auto set_code_callback = [&]() {
 
      std::vector<char> old_wasm;
      bool duplicate = false;
      fc::sha256 old_hash, new_hash;
      if (!suppress_duplicate_check) {
         try {
            const auto result = call(get_code_hash_func, fc::mutable_variant_object("account_name", account));
            old_hash = fc::sha256(result["code_hash"].as_string());
         } catch (...) {
            std::cerr << "Failed to get existing code hash, continue without duplicate check..." << std::endl;
            suppress_duplicate_check = true;
         }
      }
 
      bytes code_bytes;
      if(!contract_clear){
        std::string wasm;
        fc::path cpath = fc::canonical(fc::path(contractPath));
 
        if( wasmPath.empty() ) {
           wasmPath = (cpath / (cpath.filename().generic_string()+".wasm")).generic_string();
        } else if ( boost::filesystem::path(wasmPath).is_relative() ) {
           wasmPath = (cpath / wasmPath).generic_string();
        }
 
        std::cerr << localized(("Reading WASM from " + wasmPath + "...").c_str()) << std::endl;
        fc::read_file_contents(wasmPath, wasm);
        SYS_ASSERT( !wasm.empty(), wasm_file_not_found, "no wasm file found ${f}", ("f", wasmPath) );
 
        const string binary_wasm_header("\x00\x61\x73\x6d\x01\x00\x00\x00", 8);
        if(wasm.compare(0, 8, binary_wasm_header))
           std::cerr << localized("WARNING: ") << wasmPath << localized(" doesn't look like a binary WASM file. Is it something else, like WAST? Trying anyway...") << std::endl;
        code_bytes = bytes(wasm.begin(), wasm.end());
      } else {
        code_bytes = bytes();
      }
 
      if (!suppress_duplicate_check) {
         if (code_bytes.size()) {
            new_hash = fc::sha256::hash(&(code_bytes[0]), code_bytes.size());
         }
         duplicate = (old_hash == new_hash);
      }
 
      if (!duplicate) {
         actions.emplace_back( create_setcode(name(account), code_bytes ) );
         if ( shouldSend ) {
            std::cerr << localized("Setting Code...") << std::endl;
            send_actions(std::move(actions), packed_transaction::compression_type::zlib);
         }
      } else {
         std::cerr << localized("Skipping set code because the new code is the same as the existing code") << std::endl;
      }
   };
 
   auto set_abi_callback = [&]() {
 
      bytes old_abi;
      bool duplicate = false;
      if (!suppress_duplicate_check) {
         try {
            const auto result = call(get_raw_abi_func, fc::mutable_variant_object("account_name", account));
            old_abi = result["abi"].as_blob().data;
         } catch (...) {
            std::cerr << "Failed to get existing raw abi, continue without duplicate check..." << std::endl;
            suppress_duplicate_check = true;
         }
      }
 
      bytes abi_bytes;
      if(!contract_clear){
        fc::path cpath = fc::canonical(fc::path(contractPath));
 
        if( abiPath.empty() ) {
           abiPath = (cpath / (cpath.filename().generic_string()+".abi")).generic_string();
        } else if ( boost::filesystem::path(abiPath).is_relative() ) {
           abiPath = (cpath / abiPath).generic_string();
        }
 
        SYS_ASSERT( fc::exists( abiPath ), abi_file_not_found, "no abi file found ${f}", ("f", abiPath)  );
 
        abi_bytes = fc::raw::pack(fc::json::from_file(abiPath).as<abi_def>());
      } else {
        abi_bytes = bytes();
      }
 
      if (!suppress_duplicate_check) {
         duplicate = (old_abi.size() == abi_bytes.size() && std::equal(old_abi.begin(), old_abi.end(), abi_bytes.begin()));
      }
 
      if (!duplicate) {
         try {
            actions.emplace_back( create_setabi(name(account), abi_bytes) );
         } SYS_RETHROW_EXCEPTIONS(abi_type_exception,  "Fail to parse ABI JSON")
         if ( shouldSend ) {
            std::cerr << localized("Setting ABI...") << std::endl;
            send_actions(std::move(actions), packed_transaction::compression_type::zlib);
         }
      } else {
         std::cerr << localized("Skipping set abi because the new abi is the same as the existing abi") << std::endl;
      }
   };
 
   add_standard_transaction_options(contractSubcommand, "account@active");
   add_standard_transaction_options(codeSubcommand, "account@active");
   add_standard_transaction_options(abiSubcommand, "account@active");
   contractSubcommand->callback([&] {
      if(!contract_clear) SYS_ASSERT( !contractPath.empty(), contract_exception, " contract-dir is null ", ("f", contractPath) );
      shouldSend = false;
      set_code_callback();
      set_abi_callback();
      if (actions.size()) {
         std::cerr << localized("Publishing contract...") << std::endl;
         send_actions(std::move(actions), packed_transaction::compression_type::zlib);
      } else {
         std::cout << "no transaction is sent" << std::endl;
      }
   });
   codeSubcommand->callback(set_code_callback);
   abiSubcommand->callback(set_abi_callback);
 
   // set account
   auto setAccount = setSubcommand->add_subcommand("account", localized("Set or update blockchain account state"))->require_subcommand();
 
   // set account permission
   auto setAccountPermission = set_account_permission_subcommand(setAccount);
 
   // set action
   auto setAction = setSubcommand->add_subcommand("action", localized("Set or update blockchain action state"))->require_subcommand();
 
   // set action permission
   auto setActionPermission = set_action_permission_subcommand(setAction);
 
   // Transfer subcommand
   string con = "sysio.token";
   string sender;
   string recipient;
   string amount;
   string memo;
   bool pay_ram = false;
   auto transfer = app.add_subcommand("transfer", localized("Transfer tokens from account to account"));
   transfer->add_option("sender", sender, localized("The account sending tokens"))->required();
   transfer->add_option("recipient", recipient, localized("The account receiving tokens"))->required();
   transfer->add_option("amount", amount, localized("The amount of tokens to send"))->required();
   transfer->add_option("memo", memo, localized("The memo for the transfer"));
   transfer->add_option("--contract,-c", con, localized("The contract that controls the token"));
   transfer->add_flag("--pay-ram-to-open", pay_ram, localized("Pay RAM to open recipient's token balance row"));
 
   add_standard_transaction_options(transfer, "sender@active");
   transfer->callback([&] {
      if (tx_force_unique && memo.size() == 0) {
         // use the memo to add a nonce
         memo = generate_nonce_string();
         tx_force_unique = false;
      }
 
      auto transfer_amount = to_asset(name(con), amount);
      auto transfer = create_transfer(con, name(sender), name(recipient), transfer_amount, memo);
      if (!pay_ram) {
         send_actions( { transfer });
      } else {
         auto open_ = create_open(con, name(recipient), transfer_amount.get_symbol(), name(sender));
         send_actions( { open_, transfer } );
      }
   });
 
   // Net subcommand
   string new_host;
   auto net = app.add_subcommand( "net", localized("Interact with local p2p network connections"));
   net->require_subcommand();
   auto connect = net->add_subcommand("connect", localized("Start a new connection to a peer"));
   connect->add_option("host", new_host, localized("The hostname:port to connect to."))->required();
   connect->callback([&] {
      const auto& v = call(url, net_connect, new_host);
      std::cout << fc::json::to_pretty_string(v) << std::endl;
   });
 
   auto disconnect = net->add_subcommand("disconnect", localized("Close an existing connection"));
   disconnect->add_option("host", new_host, localized("The hostname:port to disconnect from."))->required();
   disconnect->callback([&] {
      const auto& v = call(url, net_disconnect, new_host);
      std::cout << fc::json::to_pretty_string(v) << std::endl;
   });
 
   auto status = net->add_subcommand("status", localized("Status of existing connection"));
   status->add_option("host", new_host, localized("The hostname:port to query status of connection"))->required();
   status->callback([&] {
      const auto& v = call(url, net_status, new_host);
      std::cout << fc::json::to_pretty_string(v) << std::endl;
   });
 
   auto connections = net->add_subcommand("peers", localized("Status of all existing peers"));
   connections->callback([&] {
      const auto& v = call(url, net_connections);
      std::cout << fc::json::to_pretty_string(v) << std::endl;
   });
 
 
 
   // Wallet subcommand
   auto wallet = app.add_subcommand( "wallet", localized("Interact with local wallet"));
   wallet->require_subcommand();
   // create wallet
   string wallet_name = "default";
   string password_file;
   auto createWallet = wallet->add_subcommand("create", localized("Create a new wallet locally"));
   createWallet->add_option("-n,--name", wallet_name, localized("The name of the new wallet"), true);
   createWallet->add_option("-f,--file", password_file, localized("Name of file to write wallet password output to. (Must be set, unless \"--to-console\" is passed"));
   createWallet->add_flag( "--to-console", print_console, localized("Print password to console."));
   createWallet->callback([&wallet_name, &password_file, &print_console] {
      SYSC_ASSERT( !password_file.empty() ^ print_console, "ERROR: Either indicate a file using \"--file\" or pass \"--to-console\"" );
      SYSC_ASSERT( password_file.empty() || !std::ofstream(password_file.c_str()).fail(), "ERROR: Failed to create file in specified path" );
 
      const auto& v = call(wallet_url, wallet_create, wallet_name);
      std::cout << localized("Creating wallet: ${wallet_name}", ("wallet_name", wallet_name)) << std::endl;
      std::cout << localized("Save password to use in the future to unlock this wallet.") << std::endl;
      std::cout << localized("Without password imported keys will not be retrievable.") << std::endl;
      if (print_console) {
         std::cout << fc::json::to_pretty_string(v) << std::endl;
      } else {
         std::cerr << localized("saving password to ${filename}", ("filename", password_file)) << std::endl;
         auto password_str = fc::json::to_pretty_string(v);
         boost::replace_all(password_str, "\"", "");
         std::ofstream out( password_file.c_str() );
         out << password_str;
      }
   });
 
   // open wallet
   auto openWallet = wallet->add_subcommand("open", localized("Open an existing wallet"));
   openWallet->add_option("-n,--name", wallet_name, localized("The name of the wallet to open"));
   openWallet->callback([&wallet_name] {
      call(wallet_url, wallet_open, wallet_name);
      std::cout << localized("Opened: ${wallet_name}", ("wallet_name", wallet_name)) << std::endl;
   });
 
   // lock wallet
   auto lockWallet = wallet->add_subcommand("lock", localized("Lock wallet"));
   lockWallet->add_option("-n,--name", wallet_name, localized("The name of the wallet to lock"));
   lockWallet->callback([&wallet_name] {
      call(wallet_url, wallet_lock, wallet_name);
      std::cout << localized("Locked: ${wallet_name}", ("wallet_name", wallet_name)) << std::endl;
   });
 
   // lock all wallets
   auto locakAllWallets = wallet->add_subcommand("lock_all", localized("Lock all unlocked wallets"));
   locakAllWallets->callback([] {
      call(wallet_url, wallet_lock_all);
      std::cout << localized("Locked All Wallets") << std::endl;
   });
 
   // unlock wallet
   string wallet_pw;
   auto unlockWallet = wallet->add_subcommand("unlock", localized("Unlock wallet"));
   unlockWallet->add_option("-n,--name", wallet_name, localized("The name of the wallet to unlock"));
   unlockWallet->add_option("--password", wallet_pw, localized("The password returned by wallet create"))->expected(0, 1);
   unlockWallet->callback([&wallet_name, &wallet_pw] {
      prompt_for_wallet_password(wallet_pw, wallet_name);
 
      fc::variants vs = {fc::variant(wallet_name), fc::variant(wallet_pw)};
      call(wallet_url, wallet_unlock, vs);
      std::cout << localized("Unlocked: ${wallet_name}", ("wallet_name", wallet_name)) << std::endl;
   });
 
   // import keys into wallet
   string wallet_key_str;
   auto importWallet = wallet->add_subcommand("import", localized("Import private key into wallet"));
   importWallet->add_option("-n,--name", wallet_name, localized("The name of the wallet to import key into"));
   importWallet->add_option("--private-key", wallet_key_str, localized("Private key in WIF format to import"))->expected(0, 1);
   importWallet->callback([&wallet_name, &wallet_key_str] {
      if( wallet_key_str.size() == 0 ) {
         std::cout << localized("private key: ");
         fc::set_console_echo(false);
         std::getline( std::cin, wallet_key_str, '\n' );
         fc::set_console_echo(true);
      }
 
      private_key_type wallet_key;
      try {
         wallet_key = private_key_type( wallet_key_str );
      } catch (...) {
         SYS_THROW(private_key_type_exception, "Invalid private key")
      }
      public_key_type pubkey = wallet_key.get_public_key();
 
      fc::variants vs = {fc::variant(wallet_name), fc::variant(wallet_key)};
      call(wallet_url, wallet_import_key, vs);
      std::cout << localized("imported private key for: ${pubkey}", ("pubkey", pubkey.to_string())) << std::endl;
   });
 
   // remove keys from wallet
   string wallet_rm_key_str;
   auto removeKeyWallet = wallet->add_subcommand("remove_key", localized("Remove key from wallet"));
   removeKeyWallet->add_option("-n,--name", wallet_name, localized("The name of the wallet to remove key from"));
   removeKeyWallet->add_option("key", wallet_rm_key_str, localized("Public key in WIF format to remove"))->required();
   removeKeyWallet->add_option("--password", wallet_pw, localized("The password returned by wallet create"))->expected(0, 1);
   removeKeyWallet->callback([&wallet_name, &wallet_pw, &wallet_rm_key_str] {
      prompt_for_wallet_password(wallet_pw, wallet_name);
      public_key_type pubkey;
      try {
         pubkey = public_key_type( wallet_rm_key_str );
      } catch (...) {
         SYS_THROW(public_key_type_exception, "Invalid public key: ${public_key}", ("public_key", wallet_rm_key_str))
      }
      fc::variants vs = {fc::variant(wallet_name), fc::variant(wallet_pw), fc::variant(wallet_rm_key_str)};
      call(wallet_url, wallet_remove_key, vs);
      std::cout << localized("removed private key for: ${pubkey}", ("pubkey", wallet_rm_key_str)) << std::endl;
   });
 
   // create a key within wallet
   string wallet_create_key_type;
   auto createKeyInWallet = wallet->add_subcommand("create_key", localized("Create private key within wallet"));
   createKeyInWallet->add_option("-n,--name", wallet_name, localized("The name of the wallet to create key into"), true);
   createKeyInWallet->add_option("key_type", wallet_create_key_type, localized("Key type to create (K1/R1)"), true)->type_name("K1/R1");
   createKeyInWallet->callback([&wallet_name, &wallet_create_key_type] {
      //an empty key type is allowed -- it will let the underlying wallet pick which type it prefers
      fc::variants vs = {fc::variant(wallet_name), fc::variant(wallet_create_key_type)};
      const auto& v = call(wallet_url, wallet_create_key, vs);
      std::cout << localized("Created new private key with a public key of: ") << fc::json::to_pretty_string(v) << std::endl;
   });
 
   // list wallets
   auto listWallet = wallet->add_subcommand("list", localized("List opened wallets, * = unlocked"));
   listWallet->callback([] {
      std::cout << localized("Wallets:") << std::endl;
      const auto& v = call(wallet_url, wallet_list);
      std::cout << fc::json::to_pretty_string(v) << std::endl;
   });
 
   // list keys
   auto listKeys = wallet->add_subcommand("keys", localized("List of public keys from all unlocked wallets."));
   listKeys->callback([] {
      const auto& v = call(wallet_url, wallet_public_keys);
      std::cout << fc::json::to_pretty_string(v) << std::endl;
   });
 
   // list private keys
   auto listPrivKeys = wallet->add_subcommand("private_keys", localized("List of private keys from an unlocked wallet in wif or PVT_R1 format."));
   listPrivKeys->add_option("-n,--name", wallet_name, localized("The name of the wallet to list keys from"), true);
   listPrivKeys->add_option("--password", wallet_pw, localized("The password returned by wallet create"))->expected(0, 1);
   listPrivKeys->callback([&wallet_name, &wallet_pw] {
      prompt_for_wallet_password(wallet_pw, wallet_name);
      fc::variants vs = {fc::variant(wallet_name), fc::variant(wallet_pw)};
      const auto& v = call(wallet_url, wallet_list_keys, vs);
      std::cout << fc::json::to_pretty_string(v) << std::endl;
   });
 
   auto stopKiod = wallet->add_subcommand("stop", localized("Stop ${k}.", ("k", key_store_executable_name)));
   stopKiod->callback([] {
      const auto& v = call(wallet_url, kiod_stop);
      if ( !v.is_object() || v.get_object().size() != 0 ) { //on success kiod responds with empty object
         std::cerr << fc::json::to_pretty_string(v) << std::endl;
      } else {
         std::cout << "OK" << std::endl;
      }
   });
 
   // sign subcommand
   string trx_json_to_sign;
   string str_private_key;
   string str_chain_id;
   string str_private_key_file;
   string str_public_key;
   bool push_trx = false;
 
   auto sign = app.add_subcommand("sign", localized("Sign a transaction"));
   sign->add_option("transaction", trx_json_to_sign,
                                 localized("The JSON string or filename defining the transaction to sign"), true)->required();
   sign->add_option("-k,--private-key", str_private_key, localized("The private key that will be used to sign the transaction"))->expected(0, 1);
   sign->add_option("--public-key", str_public_key, localized("Ask ${exec} to sign with the corresponding private key of the given public key", ("exec", key_store_executable_name)));
   sign->add_option("-c,--chain-id", str_chain_id, localized("The chain id that will be used to sign the transaction"));
   sign->add_flag("-p,--push-transaction", push_trx, localized("Push transaction after signing"));
 
   sign->callback([&] {
 
      SYSC_ASSERT( str_private_key.empty() || str_public_key.empty(), "ERROR: Either -k/--private-key or --public-key or none of them can be set" );
      fc::variant trx_var = json_from_file_or_string(trx_json_to_sign);
 
      // If transaction was packed, unpack it before signing 
      bool was_packed_trx = false;
      if( trx_var.is_object() ) {
         fc::variant_object& vo = trx_var.get_object();
         if( vo.contains("packed_trx") ) {
            packed_transaction packed_trx;
            try {
              fc::from_variant<packed_transaction>( trx_var, packed_trx );
            } SYS_RETHROW_EXCEPTIONS( transaction_type_exception, "Invalid packed transaction format: '${data}'",
                                ("data", fc::json::to_string(trx_var, fc::time_point::maximum())))
           const signed_transaction& strx = packed_trx.get_signed_transaction();
           trx_var = strx;
           was_packed_trx = true;
         }
      }
 
      signed_transaction trx;
      try {
        trx = trx_var.as<signed_transaction>();
      } SYS_RETHROW_EXCEPTIONS(transaction_type_exception, "Invalid transaction format: '${data}'",
                               ("data", fc::json::to_string(trx_var, fc::time_point::maximum())))
 
      std::optional<chain_id_type> chain_id;
 
      if( str_chain_id.size() == 0 ) {
         ilog( "grabbing chain_id from ${n}", ("n", node_executable_name) );
         auto info = get_info();
         chain_id = info.chain_id;
      } else {
         chain_id = chain_id_type(str_chain_id);
      }
 
      if( str_public_key.size() > 0 ) {
         public_key_type pub_key;
         try {
            pub_key = public_key_type(str_public_key);
         } SYS_RETHROW_EXCEPTIONS(public_key_type_exception, "Invalid public key: ${public_key}", ("public_key", str_public_key))
         fc::variant keys_var(flat_set<public_key_type>{ pub_key });
         sign_transaction(trx, keys_var, *chain_id);
      } else {
         if( str_private_key.size() == 0 ) {
            std::cerr << localized("private key: ");
            fc::set_console_echo(false);
            std::getline( std::cin, str_private_key, '\n' );
            fc::set_console_echo(true);
         }
         private_key_type priv_key;
         try {
            priv_key = private_key_type(str_private_key);
         } SYS_RETHROW_EXCEPTIONS(private_key_type_exception, "Invalid private key")
         trx.sign(priv_key, *chain_id);
      }
 
      if(push_trx) {
         auto trx_result = call(push_txn_func, packed_transaction(trx, packed_transaction::compression_type::none));
         std::cout << fc::json::to_pretty_string(trx_result) << std::endl;
      } else {
         if ( was_packed_trx ) { // pack it as before
           std::cout << fc::json::to_pretty_string(packed_transaction(trx,packed_transaction::compression_type::none)) << std::endl;
         } else {
           std::cout << fc::json::to_pretty_string(trx) << std::endl;
         }
      }
   });
 
   // Push subcommand
   auto push = app.add_subcommand("push", localized("Push arbitrary transactions to the blockchain"));
   push->require_subcommand();
 
   // push action
   string contract_account;
   string action;
   string data;
   vector<string> permissions;
   auto actionsSubcommand = push->add_subcommand("action", localized("Push a transaction with a single action"));
   actionsSubcommand->fallthrough(false);
   actionsSubcommand->add_option("account", contract_account,
                                 localized("The account providing the contract to execute"), true)->required();
   actionsSubcommand->add_option("action", action,
                                 localized("A JSON string or filename defining the action to execute on the contract"), true)->required();
   actionsSubcommand->add_option("data", data, localized("The arguments to the contract"))->required();
 
   add_standard_transaction_options(actionsSubcommand);
   actionsSubcommand->callback([&] {
      fc::variant action_args_var;
      if( !data.empty() ) {
         action_args_var = json_from_file_or_string(data, fc::json::parse_type::relaxed_parser);
      }
      auto accountPermissions = get_account_permissions(tx_permission);
 
      send_actions({chain::action{accountPermissions, name(contract_account), name(action),
                                  variant_to_bin( name(contract_account), name(action), action_args_var ) }});
   });
 
   // push transaction
   string trx_to_push;
   auto trxSubcommand = push->add_subcommand("transaction", localized("Push an arbitrary JSON transaction"));
   trxSubcommand->add_option("transaction", trx_to_push, localized("The JSON string or filename defining the transaction to push"))->required();
   add_standard_transaction_options(trxSubcommand);
   trxSubcommand->add_flag("-o,--read-only", tx_read_only, localized("Specify a transaction is read-only"));
 
   trxSubcommand->callback([&] {
      fc::variant trx_var = json_from_file_or_string(trx_to_push);
      try {
         signed_transaction trx = trx_var.as<signed_transaction>();
         std::cout << fc::json::to_pretty_string( push_transaction( trx )) << std::endl;
      } catch( const std::exception& ) {
         // unable to convert so try via abi
         signed_transaction trx;
         abi_serializer::from_variant( trx_var, trx, abi_serializer_resolver, abi_serializer::create_yield_function( abi_serializer_max_time ) );
         std::cout << fc::json::to_pretty_string( push_transaction( trx )) << std::endl;
      }
   });
 
   // push transactions
   string trxsJson;
   auto trxsSubcommand = push->add_subcommand("transactions", localized("Push an array of arbitrary JSON transactions"));
   trxsSubcommand->add_option("transactions", trxsJson, localized("The JSON string or filename defining the array of the transactions to push"))->required();
   trxsSubcommand->callback([&] {
      fc::variant trx_var = json_from_file_or_string(trxsJson);
      auto trxs_result = call(push_txns_func, trx_var);
      std::cout << fc::json::to_pretty_string(trxs_result) << std::endl;
   });
 
 
   // multisig subcommand
   auto msig = app.add_subcommand("multisig", localized("Multisig contract commands"));
   msig->require_subcommand();
 
   // multisig propose
   string proposal_name;
   string requested_perm;
   string transaction_perm;
   string proposed_transaction;
   string proposed_contract;
   string proposed_action;
   string proposer;
   unsigned int proposal_expiration_hours = 24;
   CLI::callback_t parse_expiration_hours = [&](CLI::results_t res) -> bool {
      unsigned int value_s;
      if (res.size() == 0 || !CLI::detail::lexical_cast(res[0], value_s)) {
         return false;
      }
 
      proposal_expiration_hours = static_cast<uint64_t>(value_s);
      return true;
   };
 
   auto propose_action = msig->add_subcommand("propose", localized("Propose action"));
   add_standard_transaction_options(propose_action, "proposer@active");
   propose_action->add_option("proposal_name", proposal_name, localized("The proposal name (string)"))->required();
   propose_action->add_option("requested_permissions", requested_perm, localized("The JSON string or filename defining requested permissions"))->required();
   propose_action->add_option("trx_permissions", transaction_perm, localized("The JSON string or filename defining transaction permissions"))->required();
   propose_action->add_option("contract", proposed_contract, localized("The contract to which deferred transaction should be delivered"))->required();
   propose_action->add_option("action", proposed_action, localized("The action of deferred transaction"))->required();
   propose_action->add_option("data", proposed_transaction, localized("The JSON string or filename defining the action to propose"))->required();
   propose_action->add_option("proposer", proposer, localized("Account proposing the transaction"));
   propose_action->add_option("proposal_expiration", parse_expiration_hours, localized("Proposal expiration interval in hours"));
 
   propose_action->callback([&] {
      fc::variant requested_perm_var = json_from_file_or_string(requested_perm);
      fc::variant transaction_perm_var = json_from_file_or_string(transaction_perm);
      fc::variant trx_var = json_from_file_or_string(proposed_transaction);
      transaction proposed_trx;
      try {
         proposed_trx = trx_var.as<transaction>();
      } SYS_RETHROW_EXCEPTIONS(transaction_type_exception, "Invalid transaction format: '${data}'",
                               ("data", fc::json::to_string(trx_var, fc::time_point::maximum())))
      bytes proposed_trx_serialized = variant_to_bin( name(proposed_contract), name(proposed_action), trx_var );
 
      vector<permission_level> reqperm;
      try {
         reqperm = requested_perm_var.as<vector<permission_level>>();
      } SYS_RETHROW_EXCEPTIONS(transaction_type_exception, "Wrong requested permissions format: '${data}'", ("data",requested_perm_var));
 
      vector<permission_level> trxperm;
      try {
         trxperm = transaction_perm_var.as<vector<permission_level>>();
      } SYS_RETHROW_EXCEPTIONS(transaction_type_exception, "Wrong transaction permissions format: '${data}'", ("data",transaction_perm_var));
 
      auto accountPermissions = get_account_permissions(tx_permission);
      if (accountPermissions.empty()) {
         if (!proposer.empty()) {
            accountPermissions = vector<permission_level>{{name(proposer), config::active_name}};
         } else {
            SYS_THROW(missing_auth_exception, "Authority is not provided (either by multisig parameter <proposer> or -p)");
         }
      }
      if (proposer.empty()) {
         proposer = name(accountPermissions.at(0).actor).to_string();
      }
 
      transaction trx;
 
      trx.expiration = fc::time_point_sec( fc::time_point::now() + fc::hours(proposal_expiration_hours) );
      trx.ref_block_num = 0;
      trx.ref_block_prefix = 0;
      trx.max_net_usage_words = 0;
      trx.max_cpu_usage_ms = 0;
      trx.delay_sec = 0;
      trx.actions = { chain::action(trxperm, name(proposed_contract), name(proposed_action), proposed_trx_serialized) };
 
      fc::to_variant(trx, trx_var);
 
      auto args = fc::mutable_variant_object()
         ("proposer", proposer )
         ("proposal_name", proposal_name)
         ("requested", requested_perm_var)
         ("trx", trx_var);
 
      send_actions({chain::action{accountPermissions, "sysio.msig"_n, "propose"_n, variant_to_bin( "sysio.msig"_n, "propose"_n, args ) }});
   });
 
   //multisig propose transaction
   auto propose_trx = msig->add_subcommand("propose_trx", localized("Propose transaction"));
   add_standard_transaction_options(propose_trx, "proposer@active");
   propose_trx->add_option("proposal_name", proposal_name, localized("The proposal name (string)"))->required();
   propose_trx->add_option("requested_permissions", requested_perm, localized("The JSON string or filename defining requested permissions"))->required();
   propose_trx->add_option("transaction", trx_to_push, localized("The JSON string or filename defining the transaction to push"))->required();
   propose_trx->add_option("proposer", proposer, localized("Account proposing the transaction"));
 
   propose_trx->callback([&] {
      fc::variant requested_perm_var = json_from_file_or_string(requested_perm);
      fc::variant trx_var = json_from_file_or_string(trx_to_push);
 
      auto accountPermissions = get_account_permissions(tx_permission);
      if (accountPermissions.empty()) {
         if (!proposer.empty()) {
            accountPermissions = vector<permission_level>{{name(proposer), config::active_name}};
         } else {
            SYS_THROW(missing_auth_exception, "Authority is not provided (either by multisig parameter <proposer> or -p)");
         }
      }
      if (proposer.empty()) {
         proposer = name(accountPermissions.at(0).actor).to_string();
      }
 
      auto args = fc::mutable_variant_object()
         ("proposer", proposer )
         ("proposal_name", proposal_name)
         ("requested", requested_perm_var)
         ("trx", trx_var);
 
      send_actions({chain::action{accountPermissions, "sysio.msig"_n, "propose"_n, variant_to_bin( "sysio.msig"_n, "propose"_n, args ) }});
   });
 
 
   // multisig review
   bool show_approvals_in_multisig_review = false;
   auto review = msig->add_subcommand("review", localized("Review transaction"));
   review->add_option("proposer", proposer, localized("The proposer name (string)"))->required();
   review->add_option("proposal_name", proposal_name, localized("The proposal name (string)"))->required();
   review->add_flag( "--show-approvals", show_approvals_in_multisig_review, localized("Show the status of the approvals requested within the proposal") );
 
   review->callback([&] {
      const auto result1 = call(get_table_func, fc::mutable_variant_object("json", true)
                                 ("code", "sysio.msig")
                                 ("scope", proposer)
                                 ("table", "proposal")
                                 ("table_key", "")
                                 ("lower_bound", name(proposal_name).to_uint64_t())
                                 ("upper_bound", name(proposal_name).to_uint64_t() + 1)
                                 // Less than ideal upper_bound usage preserved so clio can still work with old buggy nodeop versions
                                 // Change to name(proposal_name).value when clio no longer needs to support nodeop versions older than 1.5.0
                                 ("limit", 1)
                           );
      //std::cout << fc::json::to_pretty_string(result) << std::endl;
 
      const auto& rows1 = result1.get_object()["rows"].get_array();
      // Condition in if statement below can simply be rows.empty() when clio no longer needs to support nodeop versions older than 1.5.0
      if( rows1.empty() || rows1[0].get_object()["proposal_name"] != proposal_name ) {
         std::cerr << "Proposal not found" << std::endl;
         return;
      }
 
      const auto& proposal_object = rows1[0].get_object();
 
      enum class approval_status {
         unapproved,
         approved,
         invalidated
      };
 
      std::map<permission_level, std::pair<fc::time_point, approval_status>>                               all_approvals;
      std::map<sysio::account_name, std::pair<fc::time_point, vector<decltype(all_approvals)::iterator>>>  provided_approvers;
 
      bool new_multisig = true;
      if( show_approvals_in_multisig_review ) {
         fc::variants rows2;
 
         try {
            const auto& result2 = call(get_table_func, fc::mutable_variant_object("json", true)
                                       ("code", "sysio.msig")
                                       ("scope", proposer)
                                       ("table", "approvals2")
                                       ("table_key", "")
                                       ("lower_bound", name(proposal_name).to_uint64_t())
                                       ("upper_bound", name(proposal_name).to_uint64_t() + 1)
                                       // Less than ideal upper_bound usage preserved so clio can still work with old buggy nodeop versions
                                       // Change to name(proposal_name).value when clio no longer needs to support nodeop versions older than 1.5.0
                                       ("limit", 1)
                                 );
            rows2 = result2.get_object()["rows"].get_array();
         } catch( ... ) {
            new_multisig = false;
         }
 
         if( !rows2.empty() && rows2[0].get_object()["proposal_name"] == proposal_name ) {
            const auto& approvals_object = rows2[0].get_object();
 
            for( const auto& ra : approvals_object["requested_approvals"].get_array() ) {
               auto pl = ra["level"].as<permission_level>();
               all_approvals.emplace( pl, std::make_pair(ra["time"].as<fc::time_point>(), approval_status::unapproved) );
            }
 
            for( const auto& pa : approvals_object["provided_approvals"].get_array() ) {
               auto pl = pa["level"].as<permission_level>();
               auto res = all_approvals.emplace( pl, std::make_pair(pa["time"].as<fc::time_point>(), approval_status::approved) );
               provided_approvers[pl.actor].second.push_back( res.first );
            }
         } else {
            const auto result3 = call(get_table_func, fc::mutable_variant_object("json", true)
                                       ("code", "sysio.msig")
                                       ("scope", proposer)
                                       ("table", "approvals")
                                       ("table_key", "")
                                       ("lower_bound", name(proposal_name).to_uint64_t())
                                       ("upper_bound", name(proposal_name).to_uint64_t() + 1)
                                       // Less than ideal upper_bound usage preserved so clio can still work with old buggy nodeop versions
                                       // Change to name(proposal_name).value when clio no longer needs to support nodeop versions older than 1.5.0
                                       ("limit", 1)
                                 );
            const auto& rows3 = result3.get_object()["rows"].get_array();
            if( rows3.empty() || rows3[0].get_object()["proposal_name"] != proposal_name ) {
               std::cerr << "Proposal not found" << std::endl;
               return;
            }
 
            const auto& approvals_object = rows3[0].get_object();
 
            for( const auto& ra : approvals_object["requested_approvals"].get_array() ) {
               auto pl = ra.as<permission_level>();
               all_approvals.emplace( pl, std::make_pair(fc::time_point{}, approval_status::unapproved) );
            }
 
            for( const auto& pa : approvals_object["provided_approvals"].get_array() ) {
               auto pl = pa.as<permission_level>();
               auto res = all_approvals.emplace( pl, std::make_pair(fc::time_point{}, approval_status::approved) );
               provided_approvers[pl.actor].second.push_back( res.first );
            }
         }
 
         if( new_multisig ) {
            for( auto& a : provided_approvers ) {
               const auto result4 = call(get_table_func, fc::mutable_variant_object("json", true)
                                          ("code", "sysio.msig")
                                          ("scope", "sysio.msig")
                                          ("table", "invals")
                                          ("table_key", "")
                                          ("lower_bound", a.first.to_uint64_t())
                                          ("upper_bound", a.first.to_uint64_t() + 1)
                                          // Less than ideal upper_bound usage preserved so clio can still work with old buggy nodeop versions
                                          // Change to name(proposal_name).value when clio no longer needs to support nodeop versions older than 1.5.0
                                          ("limit", 1)
                                    );
               const auto& rows4 = result4.get_object()["rows"].get_array();
               if( rows4.empty() || rows4[0].get_object()["account"].as<sysio::name>() != a.first ) {
                  continue;
               }
 
               auto invalidation_time = rows4[0].get_object()["last_invalidation_time"].as<fc::time_point>();
               a.second.first = invalidation_time;
 
               for( auto& itr : a.second.second ) {
                  if( invalidation_time >= itr->second.first ) {
                     itr->second.second = approval_status::invalidated;
                  }
               }
            }
         }
      }
 
      auto trx_hex = proposal_object["packed_transaction"].as_string();
      vector<char> trx_blob(trx_hex.size()/2);
      fc::from_hex(trx_hex, trx_blob.data(), trx_blob.size());
      transaction trx = fc::raw::unpack<transaction>(trx_blob);
 
      fc::mutable_variant_object obj;
      obj["proposer"] = proposer;
      obj["proposal_name"] = proposal_object["proposal_name"];
      obj["transaction_id"] = trx.id();
 
      for( const auto& entry : proposal_object ) {
         if( entry.key() == "proposal_name" ) continue;
         obj.set( entry.key(), entry.value() );
      }
 
      fc::variant trx_var;
      abi_serializer abi;
      abi.to_variant(trx, trx_var, abi_serializer_resolver, abi_serializer::create_yield_function( abi_serializer_max_time ));
      obj["transaction"] = trx_var;
 
      if( show_approvals_in_multisig_review ) {
         fc::variants approvals;
 
         for( const auto& approval : all_approvals ) {
            fc::mutable_variant_object approval_obj;
            approval_obj["level"] = approval.first;
            switch( approval.second.second ) {
               case approval_status::unapproved:
               {
                  approval_obj["status"] = "unapproved";
                  if( approval.second.first != fc::time_point{} ) {
                     approval_obj["last_unapproval_time"] = approval.second.first;
                  }
               }
               break;
               case approval_status::approved:
               {
                  approval_obj["status"] = "approved";
                  if( new_multisig ) {
                     approval_obj["last_approval_time"] = approval.second.first;
                  }
               }
               break;
               case approval_status::invalidated:
               {
                  approval_obj["status"] = "invalidated";
                  approval_obj["last_approval_time"] = approval.second.first;
                  approval_obj["invalidation_time"] = provided_approvers[approval.first.actor].first;
               }
               break;
            }
 
            approvals.push_back( std::move(approval_obj) );
         }
 
         obj["approvals"] = std::move(approvals);
      }
 
      std::cout << fc::json::to_pretty_string(obj) << std::endl;
   });
 
   string perm;
   string proposal_hash;
   auto approve_or_unapprove = [&](const string& action) {
      fc::variant perm_var = json_from_file_or_string(perm);
 
      auto args = fc::mutable_variant_object()
         ("proposer", proposer)
         ("proposal_name", proposal_name)
         ("level", perm_var);
 
      if( proposal_hash.size() ) {
         args("proposal_hash", proposal_hash);
      }
 
      auto accountPermissions = get_account_permissions(tx_permission, {name(proposer), config::active_name});
      send_actions({chain::action{accountPermissions, "sysio.msig"_n, name(action), variant_to_bin( "sysio.msig"_n, name(action), args ) }});
   };
 
   // multisig approve
   auto approve = msig->add_subcommand("approve", localized("Approve proposed transaction"));
   add_standard_transaction_options(approve, "proposer@active");
   approve->add_option("proposer", proposer, localized("The proposer name (string)"))->required();
   approve->add_option("proposal_name", proposal_name, localized("The proposal name (string)"))->required();
   approve->add_option("permissions", perm, localized("The JSON string of filename defining approving permissions"))->required();
   approve->add_option("proposal_hash", proposal_hash, localized("Hash of proposed transaction (i.e. transaction ID) to optionally enforce as a condition of the approval"));
   approve->callback([&] { approve_or_unapprove("approve"); });
 
   // multisig unapprove
   auto unapprove = msig->add_subcommand("unapprove", localized("Unapprove proposed transaction"));
   add_standard_transaction_options(unapprove, "proposer@active");
   unapprove->add_option("proposer", proposer, localized("The proposer name (string)"))->required();
   unapprove->add_option("proposal_name", proposal_name, localized("The proposal name (string)"))->required();
   unapprove->add_option("permissions", perm, localized("The JSON string of filename defining approving permissions"))->required();
   unapprove->callback([&] { approve_or_unapprove("unapprove"); });
 
   // multisig invalidate
   string invalidator;
   auto invalidate = msig->add_subcommand("invalidate", localized("Invalidate all multisig approvals of an account"));
   add_standard_transaction_options(invalidate, "invalidator@active");
   invalidate->add_option("invalidator", invalidator, localized("invalidator name (string)"))->required();
   invalidate->callback([&] {
      auto args = fc::mutable_variant_object()
         ("account", invalidator);
 
      auto accountPermissions = get_account_permissions(tx_permission, {name(invalidator), config::active_name});
      send_actions({chain::action{accountPermissions, "sysio.msig"_n, "invalidate"_n, variant_to_bin( "sysio.msig"_n, "invalidate"_n, args ) }});
   });
 
   // multisig cancel
   string canceler;
   auto cancel = msig->add_subcommand("cancel", localized("Cancel proposed transaction"));
   add_standard_transaction_options(cancel, "canceler@active");
   cancel->add_option("proposer", proposer, localized("The proposer name (string)"))->required();
   cancel->add_option("proposal_name", proposal_name, localized("proposal name (string)"))->required();
   cancel->add_option("canceler", canceler, localized("The canceler name (string)"));
   cancel->callback([&]() {
      auto accountPermissions = get_account_permissions(tx_permission);
      if (accountPermissions.empty()) {
         if (!canceler.empty()) {
            accountPermissions = vector<permission_level>{{name(canceler), config::active_name}};
         } else {
            SYS_THROW(missing_auth_exception, "Authority is not provided (either by multisig parameter <canceler> or -p)");
         }
      }
      if (canceler.empty()) {
         canceler = name(accountPermissions.at(0).actor).to_string();
      }
      auto args = fc::mutable_variant_object()
         ("proposer", proposer)
         ("proposal_name", proposal_name)
         ("canceler", canceler);
 
      send_actions({chain::action{accountPermissions, "sysio.msig"_n, "cancel"_n, variant_to_bin( "sysio.msig"_n, "cancel"_n, args ) }});
      }
   );
 
   // multisig exec
   string executer;
   auto exec = msig->add_subcommand("exec", localized("Execute proposed transaction"));
   add_standard_transaction_options(exec, "executer@active");
   exec->add_option("proposer", proposer, localized("The proposer name (string)"))->required();
   exec->add_option("proposal_name", proposal_name, localized("The proposal name (string)"))->required();
   exec->add_option("executer", executer, localized("The account paying for execution (string)"));
   exec->callback([&] {
      auto accountPermissions = get_account_permissions(tx_permission);
      if (accountPermissions.empty()) {
         if (!executer.empty()) {
            accountPermissions = vector<permission_level>{{name(executer), config::active_name}};
         } else {
            SYS_THROW(missing_auth_exception, "Authority is not provided (either by multisig parameter <executer> or -p)");
         }
      }
      if (executer.empty()) {
         executer = name(accountPermissions.at(0).actor).to_string();
      }
 
      auto args = fc::mutable_variant_object()
         ("proposer", proposer )
         ("proposal_name", proposal_name)
         ("executer", executer);
 
      send_actions({chain::action{accountPermissions, "sysio.msig"_n, "exec"_n, variant_to_bin( "sysio.msig"_n, "exec"_n, args ) }});
      }
   );
 
   // wrap subcommand
   auto wrap = app.add_subcommand("wrap", localized("Wrap contract commands"));
   wrap->require_subcommand();
 
   // wrap exec
   string wrap_con = "sysio.wrap";
   executer = "";
   string trx_to_exec;
   auto wrap_exec = wrap->add_subcommand("exec", localized("Execute a transaction while bypassing authorization checks"));
   add_standard_transaction_options(wrap_exec, "executer@active & --contract@active");
   wrap_exec->add_option("executer", executer, localized("Account executing the transaction and paying for the deferred transaction RAM"))->required();
   wrap_exec->add_option("transaction", trx_to_exec, localized("The JSON string or filename defining the transaction to execute"))->required();
   wrap_exec->add_option("--contract,-c", wrap_con, localized("The account which controls the wrap contract"));
 
   wrap_exec->callback([&] {
      fc::variant trx_var = json_from_file_or_string(trx_to_exec);
 
      auto accountPermissions = get_account_permissions(tx_permission);
      if( accountPermissions.empty() ) {
         accountPermissions = vector<permission_level>{{name(executer), config::active_name}, {name(wrap_con), config::active_name}};
      }
 
      auto args = fc::mutable_variant_object()
         ("executer", executer )
         ("trx", trx_var);
 
      send_actions({chain::action{accountPermissions, name(wrap_con), "exec"_n, variant_to_bin( name(wrap_con), "exec"_n, args ) }});
   });
 
   // system subcommand
   auto system = app.add_subcommand("system", localized("Send sysio.system contract action to the blockchain."));
   system->require_subcommand();
 
   auto createAccountSystem = create_account_subcommand( system, false /*simple*/ );
   auto registerProducer = register_producer_subcommand(system);
   auto unregisterProducer = unregister_producer_subcommand(system);
 
   auto voteProducer = system->add_subcommand("voteproducer", localized("Vote for a producer"));
   voteProducer->require_subcommand();
   auto voteProxy = vote_producer_proxy_subcommand(voteProducer);
   auto voteProducers = vote_producers_subcommand(voteProducer);
   auto approveProducer = approve_producer_subcommand(voteProducer);
   auto unapproveProducer = unapprove_producer_subcommand(voteProducer);
 
   auto listProducers = list_producers_subcommand(system);
 
   auto delegateBandWidth = delegate_bandwidth_subcommand(system);
   auto undelegateBandWidth = undelegate_bandwidth_subcommand(system);
   auto listBandWidth = list_bw_subcommand(system);
   auto bidname = bidname_subcommand(system);
   auto bidnameinfo = bidname_info_subcommand(system);
 
   auto buyram = buyram_subcommand(system);
   auto sellram = sellram_subcommand(system);
 
   auto claimRewards = claimrewards_subcommand(system);
 
   auto regProxy = regproxy_subcommand(system);
   auto unregProxy = unregproxy_subcommand(system);
 
   auto cancelDelay = canceldelay_subcommand(system);
 
   auto rex = system->add_subcommand("rex", localized("Actions related to REX (the resource exchange)"));
   rex->require_subcommand();
   auto deposit        = deposit_subcommand(rex);
   auto withdraw       = withdraw_subcommand(rex);
   auto buyrex         = buyrex_subcommand(rex);
   auto lendrex        = lendrex_subcommand(rex);
   auto unstaketorex   = unstaketorex_subcommand(rex);
   auto sellrex        = sellrex_subcommand(rex);
   auto cancelrexorder = cancelrexorder_subcommand(rex);
   auto mvtosavings    = mvtosavings_subcommand(rex);
   auto mvfromsavings  = mvfrsavings_subcommand(rex);
   auto rentcpu        = rentcpu_subcommand(rex);
   auto rentnet        = rentnet_subcommand(rex);
   auto fundcpuloan    = fundcpuloan_subcommand(rex);
   auto fundnetloan    = fundnetloan_subcommand(rex);
   auto defcpuloan     = defcpuloan_subcommand(rex);
   auto defnetloan     = defnetloan_subcommand(rex);
   auto consolidate    = consolidate_subcommand(rex);
   auto updaterex      = updaterex_subcommand(rex);
   auto rexexec        = rexexec_subcommand(rex);
   auto closerex       = closerex_subcommand(rex);
 
   auto handle_error = [&](const auto& e)
   {
      // attempt to extract the error code if one is present
      if (!print_recognized_errors(e, verbose)) {
         // Error is not recognized
         if (!print_help_text(e) || verbose) {
            elog("Failed with error: ${e}", ("e", verbose ? e.to_detail_string() : e.to_string()));
         }
      }
      return 1;
   };
 
   try {
       app.parse(argc, argv);
   } catch (const CLI::ParseError &e) {
       return app.exit(e);
   } catch (const explained_exception& e) {
      return 1;
   } catch (connection_exception& e) {
      if (verbose) {
         elog("connect error: ${e}", ("e", e.to_detail_string()));
      }
      return 1;
   } catch ( const std::bad_alloc& ) {
      elog("bad alloc");
      return 1;
   } catch( const boost::interprocess::bad_alloc& ) {
      elog("bad alloc");
      return 1;
   } catch (const fc::exception& e) {
      return handle_error(e);
   } catch (const std::exception& e) {
      return handle_error(fc::std_exception_wrapper::from_current_exception(e));
   }
 
   return return_code;
}

parse_json_authority()

authority parse_json_authority

(

const std::string &

authorityJsonOrFile

)

Definition at line 792 of file main.cpp.

                                                                     {
   fc::variant authority_var = json_from_file_or_string(authorityJsonOrFile);
   try {
      return authority_var.as<authority>();
   } SYS_RETHROW_EXCEPTIONS(authority_type_exception, "Invalid authority format '${data}'",
                            ("data", fc::json::to_string(authority_var, fc::time_point::maximum())))
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_json_authority_or_key()

authority parse_json_authority_or_key

(

const std::string &

authorityJsonOrFile

)

Definition at line 800 of file main.cpp.

                                                                            {
   if (boost::istarts_with(authorityJsonOrFile, "SYS") || boost::istarts_with(authorityJsonOrFile, "PUB_R1")) {
      try {
         return authority(public_key_type(authorityJsonOrFile));
      } SYS_RETHROW_EXCEPTIONS(public_key_type_exception, "Invalid public key: ${public_key}", ("public_key", authorityJsonOrFile))
   } else {
      auto result = parse_json_authority(authorityJsonOrFile);
      SYS_ASSERT( sysio::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;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_action()

void print_action

(

const fc::variant &

at

)

Definition at line 441 of file main.cpp.

                                         {
   auto receiver = at["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"], fc::time_point::maximum() );
   auto console = at["console"].as_string();
 
   /*
   if( code == "sysio" && 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";
   print_return_value(at);
   if( console.size() ) {
      std::stringstream ss(console);
      string line;
      while( std::getline( ss, line ) ) {
         cout << ">> " << clean_output( std::move( line ) ) << "\n";
         if( !verbose ) break;
         line.clear();
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_action_tree()

void print_action_tree

(

const fc::variant &

action

)

Definition at line 532 of file main.cpp.

                                                  {
   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 );
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_result()

void print_result

(

const fc::variant &

result

)

Definition at line 568 of file main.cpp.

                                             { 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<std::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) ) }

Here is the call graph for this function:

Here is the caller graph for this function:

print_return_value()

void print_return_value

(

const fc::variant &

at

)

Definition at line 420 of file main.cpp.

                                               {
   std::string return_value, return_value_prefix{"return value: "};
   const auto  & iter_value = at.get_object().find("return_value_data");
   const auto  & iter_hex   = at.get_object().find("return_value_hex_data");
 
   if( iter_value != at.get_object().end() ) {
      return_value = fc::json::to_string(iter_value->value(), fc::time_point::maximum());
   }
   else if( iter_hex != at.get_object().end() ) {
      return_value = iter_hex->value().as_string();
      return_value_prefix = "return value (hex): ";
   }
 
   if( !return_value.empty() ) {
      if( return_value.size() > 100 ) {
         return_value = return_value.substr(0, 100) + "...";
      }
      cout << "=>" << std::setw(46) << std::right << return_value_prefix << return_value << "\n";
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

prompt_for_wallet_password()

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

Definition at line 299 of file main.cpp.

                                                                {
   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);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

push_actions()

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

Definition at line 413 of file main.cpp.

                                                                                                                                                   {
   signed_transaction trx;
   trx.actions = std::forward<decltype(actions)>(actions);
 
   return push_transaction(trx, compression);
}

Here is the call graph for this function:

Here is the caller graph for this function:

push_transaction()

fc::variant push_transaction	(	signed_transaction &	trx,
		packed_transaction::compression_type	compression = packed_transaction::compression_type::none )

Definition at line 325 of file main.cpp.

                                                                                                                                               {
   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>();
         }
      } SYS_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) {
      SYSC_ASSERT( !(tx_use_old_rpc && tx_use_old_send_rpc), "ERROR: --use-old-rpc and --use-old-send-rpc are mutually exclusive" );
      SYSC_ASSERT( !(tx_retry_lib && tx_retry_num_blocks > 0), "ERROR: --retry-irreversible and --retry-num-blocks are mutually exclusive" );
      if (tx_use_old_rpc) {
         SYSC_ASSERT( !tx_read_only, "ERROR: --read-only can not be used with --use-old-rpc" );
         SYSC_ASSERT( !tx_rtn_failure_trace, "ERROR: --return-failure-trace can not be used with --use-old-rpc" );
         SYSC_ASSERT( !tx_retry_lib, "ERROR: --retry-irreversible can not be used with --use-old-rpc" );
         SYSC_ASSERT( !tx_retry_num_blocks, "ERROR: --retry-num-blocks can not be used with --use-old-rpc" );
         return call( push_txn_func, packed_transaction( trx, compression ) );
      } else if (tx_use_old_send_rpc) {
         SYSC_ASSERT( !tx_read_only, "ERROR: --read-only can not be used with --use-old-send-rpc" );
         SYSC_ASSERT( !tx_rtn_failure_trace, "ERROR: --return-failure-trace can not be used with --use-old-send-rpc" );
         SYSC_ASSERT( !tx_retry_lib, "ERROR: --retry-irreversible can not be used with --use-old-send-rpc" );
         SYSC_ASSERT( !tx_retry_num_blocks, "ERROR: --retry-num-blocks can not be used with --use-old-send-rpc" );
         try {
            return call( send_txn_func, packed_transaction( trx, compression ) );
         } catch( chain::missing_chain_api_plugin_exception& ) {
            std::cerr << "New RPC send_transaction may not be supported. Add flag --use-old-rpc to use old RPC push_transaction instead." << std::endl;
            throw;
         }
      } else {
         if( tx_read_only ) {
            SYSC_ASSERT( !tx_retry_lib, "ERROR: --retry-irreversible can not be used with --read-only" );
            SYSC_ASSERT( !tx_retry_num_blocks, "ERROR: --retry-num-blocks can not be used with --read-only" );
            try {
               auto compute_txn_arg = fc::mutable_variant_object ("transaction",
                                                                  packed_transaction(trx,compression));
               return call( compute_txn_func, compute_txn_arg);
            } catch( chain::missing_chain_api_plugin_exception& ) {
               std::cerr << "New RPC compute_transaction may not be supported. Submit to a different node." << std::endl;
               throw;
            }
         } else {
            try {
               bool retry = tx_retry_lib || tx_retry_num_blocks > 0;
               auto args = fc::mutable_variant_object()
                     ( "return_failure_trace", tx_rtn_failure_trace )
                     ( "retry_trx", retry );
               if( tx_retry_num_blocks > 0 ) args( "retry_trx_num_blocks", tx_retry_num_blocks );
               args( "transaction", packed_transaction( trx, compression ) );
               return call( send2_txn_func, args );
            } catch( chain::missing_chain_api_plugin_exception& ) {
               std::cerr << "New RPC send_transaction2 may not be supported.\n"
                         << "Add flag --use-old-send-rpc or --use-old-rpc to use old RPC send_transaction." << std::endl;
               throw;
            }
         }
      }
   } else {
      if (!tx_return_packed) {
        return fc::variant(trx);
      } else {
        return fc::variant(packed_transaction(trx, compression));
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

regproducer_variant()

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

Definition at line 716 of file main.cpp.

                                                                                                                              {
   return fc::mutable_variant_object()
            ("producer", producer)
            ("producer_key", key)
            ("url", url)
            ("location", location)
            ;
}

Here is the caller graph for this function:

send_actions()

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

Definition at line 616 of file main.cpp.

                                                                                                                                              {
   std::ofstream out;
   if (tx_json_save_file.length()) {
      out.open(tx_json_save_file);
      SYSC_ASSERT(!out.fail(), "ERROR: Failed to create file \"${p}\"", ("p", tx_json_save_file));
   }
   auto result = push_actions( move(actions), compression);
 
   string jsonstr;
   if (tx_json_save_file.length()) {
      jsonstr = fc::json::to_pretty_string( result );
      out << jsonstr;
      out.close();
   }
   return_code = get_return_code( result );
   if( tx_print_json ) {
      if (jsonstr.length() == 0) {
         jsonstr = fc::json::to_pretty_string( result );
      }
      cout << jsonstr << endl;
   } else {
      print_result( result );
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

send_transaction()

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

Definition at line 641 of file main.cpp.

                                                                                                                                           {
   std::ofstream out;
   if (tx_json_save_file.length()) {
      out.open(tx_json_save_file);
      SYSC_ASSERT(!out.fail(), "ERROR: Failed to create file \"${p}\"", ("p", tx_json_save_file));
   }
   auto result = push_transaction(trx, compression);
 
   string jsonstr;
   if (tx_json_save_file.length()) {
      jsonstr = fc::json::to_pretty_string( result );
      out << jsonstr;
      out.close();
   }
   return_code = get_return_code( result );
   if( tx_print_json ) {
      if (jsonstr.length() == 0) {
         jsonstr = fc::json::to_pretty_string( result );
      }
      cout << jsonstr << endl;
   } else {
      print_result( result );
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

sign_transaction()

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

Definition at line 319 of file main.cpp.

                                                                                                        {
   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>();
}

Here is the call graph for this function:

Here is the caller graph for this function:

to_asset() [1/2]

asset to_asset	(	account_name	code,
		const string &	s )

Definition at line 812 of file main.cpp.

                                                     {
   static map< pair<account_name, sysio::chain::symbol_code>, sysio::chain::symbol> cache;
   auto a = asset::from_string( s );
   sysio::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<sysio::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 {
         SYS_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() ) {
      SYS_THROW(symbol_type_exception, "Too many decimal digits in ${a}, only ${d} supported", ("a", a)("d", expected_symbol.decimals()));
   } // else precision matches
   return a;
}

Here is the call graph for this function:

Here is the caller graph for this function:

to_asset() [2/2]

asset to_asset ( const string & s )

inline

Definition at line 843 of file main.cpp.

                                         {
   return to_asset( "sysio.token"_n, s );
}

Here is the call graph for this function:

to_permission_level()

chain::permission_level to_permission_level

(

const std::string &

s

)

Definition at line 666 of file main.cpp.

                                                              {
   auto at_pos = s.find('@');
   return permission_level { name(s.substr(0, at_pos)), name(s.substr(at_pos + 1)) };
}

Here is the caller graph for this function:

try_local_port()

void try_local_port

(

uint32_t

duration

)

Definition at line 1022 of file main.cpp.

                                       {
   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 " << key_store_executable_name << ", if " << key_store_executable_name << " is running please kill the process and try again.\n";
         throw connection_exception(fc::log_messages{FC_LOG_MESSAGE(error, "Unable to connect to ${k}", ("k", key_store_executable_name))});
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

variant_to_bin()

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

Definition at line 491 of file main.cpp.

                                                                                                                 {
   auto abis = abi_serializer_resolver( account );
   FC_ASSERT( abis, "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::create_yield_function( abi_serializer_max_time ) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

abi_serializer_max_time

const fc::microseconds abi_serializer_max_time = fc::seconds(10)

Definition at line 173 of file main.cpp.

abi_serializer_resolver

auto abi_serializer_resolver

Initial value:

= [](const name& account) -> std::optional<abi_serializer> {
   static unordered_map<account_name, std::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<sysio::chain_apis::read_only::get_abi_results>();
 
      std::optional<abi_serializer> abis;
      if( abi_results.abi.has_value() ) {
         abis.emplace( *abi_results.abi, abi_serializer::create_yield_function( 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;
}

Definition at line 470 of file main.cpp.

                                                                                      {
   static unordered_map<account_name, std::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<sysio::chain_apis::read_only::get_abi_results>();
 
      std::optional<abi_serializer> abis;
      if( abi_results.abi.has_value() ) {
         abis.emplace( *abi_results.abi, abi_serializer::create_yield_function( 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;
};

context

sysio::client::http::http_context context

Definition at line 200 of file main.cpp.

default_wallet_url

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

Definition at line 167 of file main.cpp.

delaysec

uint32_t delaysec = 0

Definition at line 196 of file main.cpp.

header_opt_callback

CLI::callback_t header_opt_callback

Initial value:

= [](CLI::results_t res) {
   vector<string>::iterator itr;
 
   for (itr = res.begin(); itr != res.end(); itr++) {
       headers.push_back(*itr);
   }
 
   return true;
}

Definition at line 2528 of file main.cpp.

                                                         {
   vector<string>::iterator itr;
 
   for (itr = res.begin(); itr != res.end(); itr++) {
       headers.push_back(*itr);
   }
 
   return true;
};

headers

vector<string> headers

Definition at line 170 of file main.cpp.

no_auto_kiod

bool no_auto_kiod = false

Definition at line 189 of file main.cpp.

no_verify

bool no_verify = false

Definition at line 169 of file main.cpp.

obsoleted_option_host_port

CLI::callback_t obsoleted_option_host_port

Initial value:

= [](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;
}

Definition at line 1093 of file main.cpp.

                                                            {
   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;
};

print_request

bool print_request = false

Definition at line 187 of file main.cpp.

print_response

bool print_response = false

Definition at line 188 of file main.cpp.

return_code

int return_code = 0

Definition at line 191 of file main.cpp.

tx_dont_broadcast

bool tx_dont_broadcast = false

Definition at line 176 of file main.cpp.

tx_expiration

auto tx_expiration = fc::seconds(30)

Definition at line 172 of file main.cpp.

tx_force_unique

bool tx_force_unique = false

Definition at line 175 of file main.cpp.

tx_json_save_file

string tx_json_save_file

Definition at line 186 of file main.cpp.

tx_max_cpu_usage

uint8_t tx_max_cpu_usage = 0

Definition at line 193 of file main.cpp.

tx_max_net_usage

uint32_t tx_max_net_usage = 0

Definition at line 194 of file main.cpp.

tx_permission

vector<string> tx_permission

Definition at line 198 of file main.cpp.

tx_print_json

bool tx_print_json = false

Definition at line 179 of file main.cpp.

tx_read_only

bool tx_read_only = false

Definition at line 181 of file main.cpp.

tx_ref_block_num_or_id

string tx_ref_block_num_or_id

Definition at line 174 of file main.cpp.

tx_retry_lib

bool tx_retry_lib = false

Definition at line 182 of file main.cpp.

tx_retry_num_blocks

uint16_t tx_retry_num_blocks = 0

Definition at line 183 of file main.cpp.

tx_return_packed

bool tx_return_packed = false

Definition at line 177 of file main.cpp.

tx_rtn_failure_trace

bool tx_rtn_failure_trace = true

Definition at line 180 of file main.cpp.

tx_skip_sign

bool tx_skip_sign = false

Definition at line 178 of file main.cpp.

tx_use_old_rpc

bool tx_use_old_rpc = false

Definition at line 184 of file main.cpp.

tx_use_old_send_rpc

bool tx_use_old_send_rpc = false

Definition at line 185 of file main.cpp.

url

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

Definition at line 166 of file main.cpp.

verbose

bool verbose = false

Definition at line 190 of file main.cpp.

wallet_url

string wallet_url

Definition at line 168 of file main.cpp.