// Dump everything known about a TX

#include <util.h>

#include <common.h>

#include <errlog.h>

#include <string.h>

#include <callback.h>

typedef GoogMap<Hash256, int, Hash256Hasher, Hash256Equal >::Map TxMap;

struct DumpTX:public Callback

{

optparse::OptionParser parser;

bool dump;

TxMap txMap;

bool isGenTX;

uint64_t bTime;

uint64_t valueIn;

uint64_t valueOut;

uint64_t nbInputs;

uint64_t nbOutputs;

uint64_t currBlock;

uint64_t nbDumped;

const uint8_t *txStart;

std::vector<uint256_t> rootHashes;

DumpTX()

{

parser

.usage("[list of transaction hashes]")

.version("")

.description(

"dumpp all the details of the list of specified transactions"

)

.epilog("")

;

}

virtual const char *name() const { return "dumpTX"; }

virtual const optparse::OptionParser *optionParser() const { return &parser; }

virtual bool needTXHash() const { return true; }

virtual void aliases(

std::vector<const char*> &v

) const

{

v.push_back("txinfo");

v.push_back("txshow");

v.push_back("showtx");

v.push_back("txdetails");

}

virtual int init(

int argc,

const char *argv[]

)

{

nbDumped = 0;

optparse::Values &values = parser.parse_args(argc, argv);

auto args = parser.args();

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

loadHash256List(rootHashes, args[i].c_str());

}

if(0<rootHashes.size()) {

info("dumping %d transactions\n", (int)rootHashes.size());

} else {

const char *defaultTX = "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d"; // Expensive pizza

warning("no TX hashes specified, using the infamous 10K pizza TX");

loadHash256List(rootHashes, defaultTX);

}

static uint8_t empty[kSHA256ByteSize] = { 0x42 };

txMap.setEmptyKey(empty);

for(auto const &txHash : rootHashes) {

txMap[txHash.v] = 1;

}

return 0;

}

virtual void startBlock(

const Block *b,

uint64_t

)

{

currBlock = b->height;

const uint8_t *p = b->data;

SKIP(uint32_t, version, p);

SKIP(uint256_t, prevBlkHash, p);

SKIP(uint256_t, blkMerkleRoot, p);

LOAD(uint32_t, blkTime, p);

bTime = blkTime;

}

virtual void startTX(

const uint8_t *p,

const uint8_t *hash

)

{

txStart = p;

nbInputs = 0;

nbOutputs = 0;

dump = (txMap.end()!=txMap.find(hash));

if(dump) {

struct tm gmTime;

time_t blockTime = bTime;

gmtime_r(&blockTime, &gmTime);

char timeBuf[256];

asctime_r(&gmTime, timeBuf);

size_t sz =strlen(timeBuf);

if(0<sz) timeBuf[sz-1] = 0;

LOAD(uint32_t, version, p);

printf("TX = {\n\n");

printf(" version = %" PRIu32 "\n", version);

printf(" minted in block = %" PRIu64 "\n", currBlock-1);

printf(" mint time = %" PRIu64 " (%s GMT)\n", bTime, timeBuf);

printf(" txHash = ");

showHex(hash);

printf("\n\n");

}

}

virtual void startInputs(

const uint8_t *p

)

{

}

virtual void endInputs(

const uint8_t *p

)

{

}

static void canonicalHexDump(

const uint8_t *p,

size_t size,

const char *indent

)

{

const uint8_t *s = p;

const uint8_t *e = size + p;

while(p<e) {

printf(

"%s%06x: ",

indent,

(int)(p-s)

);

const uint8_t *lp = p;

const uint8_t *np = 16 + p;

const uint8_t *le = std::min(e, 16+p);

while(lp<np) {

if(lp<le) printf("%02x ", (int)*lp);

else printf(" ");

++lp;

}

lp = p;

while(lp<le) {

int c = *(lp++);

printf("%c", isprint(c) ? c : '.');

}

printf("\n");

p = np;

}

}

virtual void startInput(

const uint8_t *p

)

{

if(dump) {

printf(

" input[%" PRIu64 "] = {\n\n",

nbInputs++

);

static uint256_t gNullHash;

LOAD(uint256_t, upTXHash, p);

LOAD(uint32_t, upOutputIndex, p);

LOAD_VARINT(inputScriptSize, p);

isGenTX = (0==memcmp(gNullHash.v, upTXHash.v, sizeof(gNullHash)));

if(isGenTX) {

uint64_t reward = getBaseReward(currBlock);

printf(" generation transaction\n");

printf(" based on block height, reward = %.8f\n", 1e-8*reward);

printf(" hex dump of coinbase follows:\n\n");

canonicalHexDump(p, inputScriptSize, " ");

valueIn += reward;

}

}

}

static void showScriptInfo(

const uint8_t *outputScript,

uint64_t outputScriptSize

)

{

uint8_t type[128];

const char *typeName = "unknown";

uint8_t pubKeyHash[kSHA256ByteSize];

int r = solveOutputScript(pubKeyHash, outputScript, outputScriptSize, type);

switch(r) {

case 0: {

typeName = "pays to hash160(pubKey)";

break;

}

case 1: {

typeName = "pays to explicit uncompressed pubKey";

break;

}

case 2: {

typeName = "pays to explicit compressed pubKey";

break;

}

case 3: {

typeName = "pays to hash160(script)";

break;

}

case 4: {

typeName = "pays to hash160(script)";

break;

}

case -2: {

typeName = "broken script generated by p2pool - coins lost";

break;

}

case -1: {

typeName = "couldn't parse script";

break;

}

}

printf("\n");

printf(" script type = %s\n", typeName);

if(0<=r) {

uint8_t btcAddr[64];

hash160ToAddr(btcAddr, pubKeyHash);

printf(" script pays to address %s\n", btcAddr);

}

}

virtual void edge(

uint64_t value,

const uint8_t *upTXHash,

uint64_t outputIndex,

const uint8_t *outputScript,

uint64_t outputScriptSize,

const uint8_t *downTXHash,

uint64_t inputIndex,

const uint8_t *inputScript,

uint64_t inputScriptSize

)

{

if(dump) {

uint8_t buf[1 + 2*kSHA256ByteSize];

toHex(buf, upTXHash);

printf(" outputIndex = %" PRIu64 "\n", outputIndex);

printf(" value = %.8f\n", value*1e-8);

printf(" upTXHash = %s\n\n", buf);

printf(" # challenge answer script, bytes=%" PRIu64 " (on downstream input) =\n", inputScriptSize);

showScript(inputScript, inputScriptSize, 0, " ");

printf(" ||\n");

printf(" VV\n");

printf(" # challenge script, bytes=%" PRIu64 " (on upstream output)=\n", outputScriptSize);

showScript(outputScript, outputScriptSize, 0, " ");

showScriptInfo(outputScript, outputScriptSize);

valueIn += value;

}

}

virtual void endInput(

const uint8_t *p

)

{

if(dump) {

printf(" }\n\n");

}

}

virtual void startOutputs(

const uint8_t *p

)

{

}

virtual void endOutputs(

const uint8_t *p

)

{

}

virtual void startOutput(

const uint8_t *p

)

{

if(dump) {

printf(

"\n"

" output[%" PRIu64 "] = {\n\n",

nbOutputs++

);

}

}

virtual void endOutput(

const uint8_t *p, // Pointer to TX output raw data

uint64_t value, // Number of satoshis on this output

const uint8_t *txHash, // sha256 of the current transaction

uint64_t outputIndex, // Index of this output in the current transaction

const uint8_t *outputScript, // Raw script (challenge to would-be spender) carried by this output

uint64_t outputScriptSize // Byte size of raw script

)

{

if(dump) {

printf(" value = %.8f\n", value*1e-8);

printf(" challenge script, bytes=%" PRIu64 " :\n", outputScriptSize);

showScript(outputScript, outputScriptSize, 0, " ");

showScriptInfo(outputScript, outputScriptSize);

printf(" }\n\n");

valueOut += value;

}

}

virtual void endTX(

const uint8_t *p

)

{

if(dump) {

LOAD(uint32_t, lockTime, p);

printf(" nbInputs = %" PRIu64 "\n", (uint64_t)nbInputs);

printf(" nbOutputs = %" PRIu64 "\n", (uint64_t)nbOutputs);

printf(" byteSize = %" PRIu64 "\n", (uint64_t)(p - txStart));

printf(" lockTime = %" PRIu32 "\n", (uint32_t)lockTime);

printf(" valueIn = %.2f\n", valueIn*1e-8);

printf(" valueOut = %.2f\n", valueOut*1e-8);

if(!isGenTX) {

printf(" fees = %.2f\n", (valueIn-valueOut)*1e-8);

}

printf("}\n");

++nbDumped;

}

if(nbDumped==txMap.size()) {

exit(0);

}

}

};

static DumpTX dumpTX;