// {
// ledger_hash : <ledger>,
// ledger_index : <ledger_index>
// }
//
// XXX In this case, not specify either ledger does not mean ledger current. It
// means any ledger.
Json::Value doTransactionEntry (RPC::Context& context)
{
Ledger::pointer lpLedger;
Json::Value jvResult = RPC::lookupLedger (
context.params_,
lpLedger,
context.netOps_);
if (!lpLedger)
return jvResult;
if (!context.params_.isMember ("tx_hash"))
{
jvResult["error"] = "fieldNotFoundTransaction";
}
else if (!context.params_.isMember ("ledger_hash")
&& !context.params_.isMember ("ledger_index"))
{
// We don't work on ledger current.
// XXX We don't support any transaction yet.
jvResult["error"] = "notYetImplemented";
}
else
{
uint256 uTransID;
// XXX Relying on trusted WSS client. Would be better to have a strict
// routine, returning success or failure.
uTransID.SetHex (context.params_["tx_hash"].asString ());
if (!lpLedger)
{
jvResult["error"] = "ledgerNotFound";
}
else
{
Transaction::pointer tpTrans;
TransactionMetaSet::pointer tmTrans;
if (!lpLedger->getTransaction (uTransID, tpTrans, tmTrans))
{
jvResult["error"] = "transactionNotFound";
}
else
{
jvResult["tx_json"] = tpTrans->getJson (0);
if (tmTrans)
jvResult["metadata"] = tmTrans->getJson (0);
// 'accounts'
// 'engine_...'
// 'ledger_...'
}
}
}
return jvResult;
}
Json::Value doTx (RPC::Context& context)
{
if (!context.params.isMember (jss::transaction))
return rpcError (rpcINVALID_PARAMS);
bool binary = context.params.isMember (jss::binary)
&& context.params[jss::binary].asBool ();
auto const txid = context.params[jss::transaction].asString ();
if (!isHexTxID (txid))
return rpcError (rpcNOT_IMPL);
auto txn = getApp().getMasterTransaction ().fetch (uint256 (txid), true);
if (!txn)
return rpcError (rpcTXN_NOT_FOUND);
Json::Value ret = txn->getJson (1, binary);
if (txn->getLedger () == 0)
return ret;
if (auto lgr = context.netOps.getLedgerBySeq (txn->getLedger ()))
{
bool okay = false;
if (binary)
{
std::string meta;
if (lgr->getMetaHex (txn->getID (), meta))
{
ret[jss::meta] = meta;
okay = true;
}
}
else
{
TransactionMetaSet::pointer txMeta;
if (lgr->getTransactionMeta (txn->getID (), txMeta))
{
okay = true;
auto meta = txMeta->getJson (0);
addPaymentDeliveredAmount (meta, context, txn, txMeta);
ret[jss::meta] = meta;
}
}
if (okay)
ret[jss::validated] = context.netOps.isValidated (lgr);
}
return ret;
}
// {
// transaction: <hex>
// }
Json::Value doTx (RPC::Context& context)
{
context.lock_.unlock ();
if (!context.params_.isMember (jss::transaction))
return rpcError (rpcINVALID_PARAMS);
bool binary = context.params_.isMember (jss::binary) && context.params_[jss::binary].asBool ();
std::string strTransaction = context.params_[jss::transaction].asString ();
if (Transaction::isHexTxID (strTransaction))
{
// transaction by ID
uint256 txid (strTransaction);
Transaction::pointer txn = getApp().getMasterTransaction ().fetch (txid, true);
if (!txn)
return rpcError (rpcTXN_NOT_FOUND);
#ifdef READY_FOR_NEW_TX_FORMAT
Json::Value ret;
ret[jss::transaction] = txn->getJson (0, binary);
#else
Json::Value ret = txn->getJson (0, binary);
#endif
if (txn->getLedger () != 0)
{
Ledger::pointer lgr = context.netOps_.getLedgerBySeq (txn->getLedger ());
if (lgr)
{
bool okay = false;
if (binary)
{
std::string meta;
if (lgr->getMetaHex (txid, meta))
{
ret[jss::meta] = meta;
okay = true;
}
}
else
{
TransactionMetaSet::pointer set;
if (lgr->getTransactionMeta (txid, set))
{
okay = true;
ret[jss::meta] = set->getJson (0);
}
}
if (okay)
ret[jss::validated] = context.netOps_.isValidated (lgr);
}
}
return ret;
}
return rpcError (rpcNOT_IMPL);
}
// {
// transaction: <hex>
// }
Json::Value RPCHandler::doTx (Json::Value params, Resource::Charge& loadType, Application::ScopedLockType& masterLockHolder)
{
masterLockHolder.unlock ();
if (!params.isMember ("transaction"))
return rpcError (rpcINVALID_PARAMS);
bool binary = params.isMember ("binary") && params["binary"].asBool ();
std::string strTransaction = params["transaction"].asString ();
if (Transaction::isHexTxID (strTransaction))
{
// transaction by ID
uint256 txid (strTransaction);
Transaction::pointer txn = getApp().getMasterTransaction ().fetch (txid, true);
if (!txn)
return rpcError (rpcTXN_NOT_FOUND);
#ifdef READY_FOR_NEW_TX_FORMAT
Json::Value ret;
ret["transaction"] = txn->getJson (0, binary);
#else
Json::Value ret = txn->getJson (0, binary);
#endif
if (txn->getLedger () != 0)
{
Ledger::pointer lgr = mNetOps->getLedgerBySeq (txn->getLedger ());
if (lgr)
{
bool okay = false;
if (binary)
{
std::string meta;
if (lgr->getMetaHex (txid, meta))
{
ret["meta"] = meta;
okay = true;
}
}
else
{
TransactionMetaSet::pointer set;
if (lgr->getTransactionMeta (txid, set))
{
okay = true;
ret["meta"] = set->getJson (0);
}
}
if (okay)
ret["validated"] = mNetOps->isValidated (lgr);
}
}
return ret;
}
return rpcError (rpcNOT_IMPL);
}
