mirror of
https://github.com/twisterarmy/twister-core.git
synced 2025-01-25 05:54:19 +00:00
f81088be70
the basic idea is replace txIndex key with a pair (username,height). height = -1 for the most up-to-date key, otherwise height = last block where previous key was valid. by checking maxHeight and iterating backwards we can easily find the key to validate data from any given block number.
313 lines
10 KiB
C++
313 lines
10 KiB
C++
// Copyright (c) 2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2012 The Bitcoin developers
|
|
// Distributed under the MIT/X11 software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include <boost/assign/list_of.hpp>
|
|
|
|
#include "base58.h"
|
|
#include "bitcoinrpc.h"
|
|
#include "db.h"
|
|
#include "init.h"
|
|
#include "net.h"
|
|
#include "wallet.h"
|
|
#include "twister.h"
|
|
|
|
using namespace std;
|
|
using namespace boost;
|
|
using namespace boost::assign;
|
|
using namespace json_spirit;
|
|
|
|
//
|
|
// Utilities: convert hex-encoded Values
|
|
// (throws error if not hex).
|
|
//
|
|
uint256 ParseHashV(const Value& v, string strName)
|
|
{
|
|
string strHex;
|
|
if (v.type() == str_type)
|
|
strHex = v.get_str();
|
|
if (!IsHex(strHex)) // Note: IsHex("") is false
|
|
throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be hexadecimal string (not '"+strHex+"')");
|
|
uint256 result;
|
|
result.SetHex(strHex);
|
|
return result;
|
|
}
|
|
uint256 ParseHashO(const Object& o, string strKey)
|
|
{
|
|
return ParseHashV(find_value(o, strKey), strKey);
|
|
}
|
|
vector<unsigned char> ParseHexV(const Value& v, string strName)
|
|
{
|
|
string strHex;
|
|
if (v.type() == str_type)
|
|
strHex = v.get_str();
|
|
if (!IsHex(strHex))
|
|
throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be hexadecimal string (not '"+strHex+"')");
|
|
return ParseHex(strHex);
|
|
}
|
|
vector<unsigned char> ParseHexO(const Object& o, string strKey)
|
|
{
|
|
return ParseHexV(find_value(o, strKey), strKey);
|
|
}
|
|
|
|
void ScriptPubKeyToJSON(const CScript& scriptPubKey, Object& out)
|
|
{
|
|
txnouttype type;
|
|
vector<CTxDestination> addresses;
|
|
int nRequired;
|
|
|
|
out.push_back(Pair("asm", scriptPubKey.ToString()));
|
|
out.push_back(Pair("hex", HexStr(scriptPubKey.begin(), scriptPubKey.end())));
|
|
|
|
if (!ExtractDestinations(scriptPubKey, type, addresses, nRequired))
|
|
{
|
|
out.push_back(Pair("type", GetTxnOutputType(TX_NONSTANDARD)));
|
|
return;
|
|
}
|
|
|
|
out.push_back(Pair("reqSigs", nRequired));
|
|
out.push_back(Pair("type", GetTxnOutputType(type)));
|
|
|
|
Array a;
|
|
BOOST_FOREACH(const CTxDestination& addr, addresses)
|
|
a.push_back(CBitcoinAddress(addr).ToString());
|
|
out.push_back(Pair("addresses", a));
|
|
}
|
|
|
|
void TxToJSON(const CTransaction& tx, const uint256 hashBlock, Object& entry)
|
|
{
|
|
entry.push_back(Pair("txid", tx.GetUsernameHash().GetHex()));
|
|
entry.push_back(Pair("version", tx.nVersion));
|
|
entry.push_back(Pair("message", tx.message.ExtractPushDataString(0)));
|
|
entry.push_back(Pair("username", tx.userName.ExtractPushDataString(0)));
|
|
std::vector< std::vector<unsigned char> > vData;
|
|
if( tx.pubKey.ExtractPushData(vData) ) {
|
|
Array o;
|
|
BOOST_FOREACH(std::vector<unsigned char> vch, vData) {
|
|
o.push_back(HexStr(vch));
|
|
}
|
|
entry.push_back(Pair("pubKey", o));
|
|
}
|
|
entry.push_back(Pair("nonce", (int) tx.nNonce));
|
|
|
|
if (hashBlock != 0)
|
|
{
|
|
entry.push_back(Pair("blockhash", hashBlock.GetHex()));
|
|
map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
|
|
if (mi != mapBlockIndex.end() && (*mi).second)
|
|
{
|
|
CBlockIndex* pindex = (*mi).second;
|
|
if (pindex->IsInMainChain())
|
|
{
|
|
entry.push_back(Pair("height", pindex->nHeight));
|
|
entry.push_back(Pair("confirmations", 1 + nBestHeight - pindex->nHeight));
|
|
entry.push_back(Pair("time", (boost::int64_t)pindex->nTime));
|
|
entry.push_back(Pair("blocktime", (boost::int64_t)pindex->nTime));
|
|
}
|
|
else
|
|
entry.push_back(Pair("confirmations", 0));
|
|
}
|
|
}
|
|
}
|
|
|
|
Value getrawtransaction(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() < 1 || params.size() > 2)
|
|
throw runtime_error(
|
|
"getrawtransaction <username> [verbose=0]\n"
|
|
"If verbose=0, returns a string that is\n"
|
|
"serialized, hex-encoded data for <txid>.\n"
|
|
"If verbose is non-zero, returns an Object\n"
|
|
"with information about transaction.");
|
|
|
|
//uint256 hash = ParseHashV(params[0], "parameter 1");
|
|
std::string username = params[0].get_str();
|
|
|
|
bool fVerbose = false;
|
|
if (params.size() > 1)
|
|
fVerbose = (params[1].get_int() != 0);
|
|
|
|
CTransaction tx;
|
|
uint256 hashBlock = 0;
|
|
if (!GetTransaction(username, tx, hashBlock))
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available about transaction");
|
|
|
|
CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
|
|
ssTx << tx;
|
|
string strHex = HexStr(ssTx.begin(), ssTx.end());
|
|
|
|
if (!fVerbose)
|
|
return strHex;
|
|
|
|
Object result;
|
|
result.push_back(Pair("hex", strHex));
|
|
TxToJSON(tx, hashBlock, result);
|
|
return result;
|
|
}
|
|
|
|
Value createrawtransaction(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || (params.size() != 2 && params.size() != 3))
|
|
throw runtime_error(
|
|
"createrawtransaction <username> <pubKey> [signedByOldKey]\n"
|
|
"Create a transaction registering a new user\n"
|
|
"Returns hex-encoded raw transaction.\n"
|
|
"it is not stored in the wallet or transmitted to the network.");
|
|
|
|
CTransaction rawTx;
|
|
|
|
if (params[0].type() != str_type)
|
|
throw JSONRPCError(RPC_INVALID_PARAMETER, "username must be string");
|
|
string username = params[0].get_str();
|
|
rawTx.userName = CScript() << vector<unsigned char>((const unsigned char*)username.data(), (const unsigned char*)username.data() + username.size());
|
|
|
|
vector<unsigned char> vch(ParseHexV(params[1], "pubkey"));
|
|
CPubKey pubkey(vch);
|
|
if( !pubkey.IsValid() )
|
|
throw JSONRPCError(RPC_INTERNAL_ERROR, "pubkey is not valid");
|
|
|
|
rawTx.pubKey << vch;
|
|
if( params.size() > 2) {
|
|
vector<unsigned char> vchSign(ParseHexV(params[2], "signedByOldKey"));
|
|
rawTx.pubKey << vchSign;
|
|
}
|
|
|
|
DoTxProofOfWork(rawTx);
|
|
|
|
CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
|
|
ss << rawTx;
|
|
return HexStr(ss.begin(), ss.end());
|
|
}
|
|
|
|
Value decoderawtransaction(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() != 1)
|
|
throw runtime_error(
|
|
"decoderawtransaction <hex string>\n"
|
|
"Return a JSON object representing the serialized, hex-encoded transaction.");
|
|
|
|
vector<unsigned char> txData(ParseHexV(params[0], "argument"));
|
|
CDataStream ssData(txData, SER_NETWORK, PROTOCOL_VERSION);
|
|
CTransaction tx;
|
|
try {
|
|
ssData >> tx;
|
|
}
|
|
catch (std::exception &e) {
|
|
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
|
|
}
|
|
|
|
Object result;
|
|
TxToJSON(tx, 0, result);
|
|
|
|
return result;
|
|
}
|
|
|
|
Value sendrawtransaction(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() < 1 || params.size() > 1)
|
|
throw runtime_error(
|
|
"sendrawtransaction <hex string>\n"
|
|
"Submits raw transaction (serialized, hex-encoded) to local node and network.");
|
|
|
|
// parse hex string from parameter
|
|
vector<unsigned char> txData(ParseHexV(params[0], "parameter"));
|
|
CDataStream ssData(txData, SER_NETWORK, PROTOCOL_VERSION);
|
|
CTransaction tx;
|
|
|
|
// deserialize binary data stream
|
|
try {
|
|
ssData >> tx;
|
|
}
|
|
catch (std::exception &e) {
|
|
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
|
|
}
|
|
uint256 hashTx = tx.GetHash();
|
|
|
|
bool fHave = false;
|
|
uint256 hashBlock;
|
|
CTransaction tx2;
|
|
fHave = GetTransaction(tx.GetUsername(), tx2, hashBlock);
|
|
|
|
// treat replacement as !fHave
|
|
if( fHave && verifyDuplicateOrReplacementTx(tx, false, true) ) {
|
|
printf("sendrawtransaction: is ReplacementTx true\n");
|
|
fHave = false;
|
|
}
|
|
|
|
if (!fHave) {
|
|
// push to local node
|
|
CValidationState state;
|
|
if (!mempool.accept(state, tx, false, NULL))
|
|
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX rejected"); // TODO: report validation state
|
|
}
|
|
if (fHave) {
|
|
if (hashBlock != uint256())
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "transaction already in block chain");
|
|
if (tx.GetHash() != tx2.GetHash())
|
|
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "conflict transaction detected (same user, different tx)");
|
|
// Not in block, but already in the memory pool; will drop
|
|
// through to re-relay it.
|
|
} else {
|
|
SyncWithWallets(hashTx, tx, NULL, true);
|
|
}
|
|
RelayTransaction(tx, hashTx);
|
|
|
|
return hashTx.GetHex();
|
|
}
|
|
|
|
Value sendnewusertransaction(const Array& params, bool fHelp)
|
|
{
|
|
if (fHelp || params.size() != 1)
|
|
throw runtime_error(
|
|
"sendnewusertransaction <username>\n"
|
|
"Send a transaction registering a previously created new user\n"
|
|
"using createwalletuser or imported to the wallet\n"
|
|
"Submits raw transaction (serialized, hex-encoded) to local node and network.");
|
|
|
|
if (params[0].type() != str_type)
|
|
throw JSONRPCError(RPC_INVALID_PARAMETER, "username must be string");
|
|
string strUsername = params[0].get_str();
|
|
|
|
CKeyID oldKeyID;
|
|
bool replaceKey = pwalletMain->GetKeyIdBeingReplaced(strUsername, oldKeyID);
|
|
|
|
CKeyID keyID;
|
|
if( !pwalletMain->GetKeyIdFromUsername(strUsername, keyID) )
|
|
throw JSONRPCError(RPC_WALLET_INVALID_ACCOUNT_NAME, "Error: username must exist in wallet");
|
|
|
|
CPubKey pubkey;
|
|
if( !pwalletMain->GetPubKey(keyID, pubkey) )
|
|
throw JSONRPCError(RPC_WALLET_INVALID_ACCOUNT_NAME, "Error: no public key found");
|
|
|
|
// [MF] prevent redoing POW and resending an existing transaction
|
|
CTransaction txOut;
|
|
uint256 hashBlock;
|
|
bool userInTxIndex = GetTransaction(strUsername, txOut, hashBlock);
|
|
if( !replaceKey && userInTxIndex )
|
|
throw JSONRPCError(RPC_WALLET_INVALID_ACCOUNT_NAME, "Error: this username exists in tx database");
|
|
if( replaceKey && !userInTxIndex )
|
|
throw JSONRPCError(RPC_WALLET_INVALID_ACCOUNT_NAME, "Error: key replacemente requires old key in tx database");
|
|
|
|
Array createTxParams;
|
|
createTxParams.push_back(strUsername);
|
|
createTxParams.push_back(HexStr(pubkey));
|
|
if( replaceKey ) {
|
|
string newPubKey((const char *)pubkey.begin(), static_cast<size_t>(pubkey.size()));
|
|
string signedByOldKey;
|
|
signedByOldKey = createSignature(newPubKey, oldKeyID);
|
|
createTxParams.push_back(HexStr(signedByOldKey));
|
|
}
|
|
Value txValue = createrawtransaction(createTxParams, false);
|
|
|
|
if( replaceKey ) {
|
|
pwalletMain->ForgetReplacementMap(strUsername);
|
|
}
|
|
|
|
std::string strTxHex = txValue.get_str();
|
|
Array sendTxParams;
|
|
sendTxParams.push_back(strTxHex);
|
|
return sendrawtransaction(sendTxParams, false);
|
|
}
|
|
|