static void parseTX(
const uint8_t *&p
)
{
uint8_t *txHash = 0;
const uint8_t *txStart = p;
if(gNeedTXHash && !skip) {
const uint8_t *txEnd = p;
parseTX<true>(txEnd);
txHash = allocHash256();
sha256Twice(txHash, txStart, txEnd - txStart);
}
if(!skip) startTX(p, txHash);
SKIP(uint32_t, version, p);
parseInputs<skip>(p, txHash);
if(gNeedTXHash && !skip)
gTXMap[txHash] = p;
parseOutputs<skip, false>(p, txHash);
SKIP(uint32_t, lockTime, p);
if(!skip) endTX(p);
}
virtual void startBlock(
const Block *b,
uint64_t
)
{
if(0<=cutoffBlock && cutoffBlock<b->height) wrapup();
uint8_t blockHash[kSHA256ByteSize];
sha256Twice(blockHash, b->data, 80);
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);
// id BIGINT PRIMARY KEY
// hash BINARY(32)
// time BIGINT
fprintf(blockFile, "%" PRIu64 "\t", (blkID = b->height-1));
writeEscapedBinaryBuffer(blockFile, blockHash, kSHA256ByteSize);
fputc('\t', blockFile);
fprintf(blockFile, "%" PRIu64 "\n", (uint64_t)blkTime);
if(0==(b->height)%500) {
fprintf(
stderr,
"block=%8" PRIu64 " "
"nbOutputs=%8" PRIu64 "\n",
b->height,
outputMap.size()
);
}
}
virtual void startBlock(
const Block *b,
uint64_t chainBase
)
{
if (lastBlock >= 0 && lastBlock < b->height - 1) wrapup();
if (b->height - 1 == firstBlock) active = 1;
if (active) {
uint8_t blockHash[kSHA256ByteSize];
sha256Twice(blockHash, b->data, 80);
const uint8_t *p = b->data;
// Total block size is 81 bytes plus transactions
blkSize = 81;
totalBlkFees = 0;
totalBlkOutput = 0;
numBlkTxs = 0;
LOAD(uint32_t, version, p);
SKIP(uint256_t, prevBlkHash, p);
LOAD(uint256_t, blkMerkleRoot, p);
LOAD(uint32_t, blkTime, p);
LOAD(uint32_t, difficultyBits, p);
LOAD(uint32_t, nonce, p);
// ID
fprintf(blockFile, "%" PRIu64 ",", blkID);
// Hash
uint8_t buf[1 + 2*kSHA256ByteSize];
toHex(buf, blockHash);
fprintf(blockFile, "\"%s\",", buf);
// Version
fprintf(blockFile, "%" PRIu32 ",", version);
// Timestamp
time_t blockTime = blkTime;
char tbuf[23];
strftime(tbuf, sizeof tbuf, "%FT%TZ", gmtime(&blockTime));
fprintf(blockFile, "\"%s\",", tbuf);
// Nonce
fprintf(blockFile, "%" PRIu32 ",", nonce);
// Difficulty
fprintf(blockFile, "%f,", difficulty(difficultyBits));
// Merkle root
uint8_t buf2[kSHA256ByteSize];
uint8_t buf3[1 + 2*kSHA256ByteSize];
memcpy(buf2, &blkMerkleRoot, kSHA256ByteSize);
toHex(buf3, buf2);
fprintf(blockFile, "\"%s\",", buf3);
}
}
static void getBlockHeader(
size_t &size,
Block *&prev,
uint8_t *&hash,
size_t &earlyMissCnt,
const uint8_t *p
) {
LOAD(uint32_t, magic, p);
if(unlikely(gExpectedMagic!=magic)) {
hash = 0;
return;
}
LOAD(uint32_t, sz, p);
size = sz;
prev = 0;
hash = allocHash256();
#if defined(DARKCOIN)
h9(hash, p, gHeaderSize);
#elif defined(PAYCON)
h13(hash, p, gHeaderSize);
#elif defined(MARTEXCOIN)
h13(hash, p, gHeaderSize);
#elif defined(CLAM)
auto pBis = p;
LOAD(uint32_t, nVersion, pBis);
if(6<nVersion) {
sha256Twice(hash, p, gHeaderSize);
} else {
scrypt(hash, p, gHeaderSize);
}
#elif defined(JUMBUCKS)
scrypt(hash, p, gHeaderSize);
#else
sha256Twice(hash, p, gHeaderSize);
#endif
auto i = gBlockMap.find(p + 4);
if(likely(gBlockMap.end()!=i)) {
prev = i->second;
} else {
++earlyMissCnt;
}
}
static bool buildBlock(
const uint8_t *&p,
const uint8_t *e
)
{
//litcoin 0xfb, 0xc0, 0xb6, 0xdb
//unsigned char pchMessageStart[4] = { 0xce, 0xfb, 0xfa, 0xdb };
static const uint32_t expected =
#if defined(UVCCOIN)
0xdbfafbce
#elif defined(LITECOIN)
0xdbb6c0fb
#else
0xd9b4bef9
#endif
;
if(unlikely(e<=(8+p))) {
//printf("end of map, reason : pointer past EOF\n");
return true;
}
LOAD(uint32_t, magic, p);
if(unlikely(expected!=magic)) {
//printf("end of map, reason : magic is f****d %d away from EOF\n", (int)(e-p));
return true;
}
LOAD(uint32_t, size, p);
if(unlikely(e<(p+size))) {
//printf("end of map, reason : end of block past EOF, %d past EOF\n", (int)((p+size)-e));
return true;
}
Block *block = allocBlock();
block->height = -1;
block->data = p;
block->prev = 0;
block->next = 0;
uint8_t *hash = allocHash256();
sha256Twice(hash, p, 80);
gBlockMap[hash] = block;
p += size;
return false;
}
static bool buildBlock(
const uint8_t *&p,
const uint8_t *e
)
{
static const uint32_t expected =
#if defined(REDDCOIN)
0xdbb6c0fb
#else
0xd9b4bef9
#endif
;
if(unlikely(e<=(8+p))) {
//printf("end of map, reason : pointer past EOF\n");
return true;
}
LOAD(uint32_t, magic, p);
if(unlikely(expected!=magic)) {
//printf("end of map, reason : magic is f****d %d away from EOF\n", (int)(e-p));
return true;
}
LOAD(uint32_t, size, p);
if(unlikely(e<(p+size))) {
//printf("end of map, reason : end of block past EOF, %d past EOF\n", (int)((p+size)-e));
return true;
}
Block *block = allocBlock();
block->height = -1;
block->data = p;
block->prev = 0;
block->next = 0;
uint8_t *hash = allocHash256();
sha256Twice(hash, p, 80);
gBlockMap[hash] = block;
p += size;
return false;
}
virtual void startBlock(
const Block *b,
uint64_t chainSize
)
{
uint8_t blockHash[kSHA256ByteSize];
sha256Twice(blockHash, b->data, 80);
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);
blkID = b->height - 1;
if (blkID >= cutoffBlock)
{
// block_id BIGINT PRIMARY KEY
// block_hash BINARY(32)
// time BIGINT
fprintf(blockFile, "%" PRIu64 "|", blkID);
writeEscapedBinaryBuffer(blockFile, blockHash, kSHA256ByteSize);
fputc('|', blockFile);
fprintf(blockFile, "%" PRIu64 "\n", (uint64_t)blkTime);
}
if (0 == (blkID) % 5000)
{
fprintf(
stderr,
"block=%8" PRIu64 " "
"nbOutputs=%9" PRIu64 "\n",
blkID,
outputMap.size()
);
}
}
virtual void startBlock(
const Block *b,
uint64_t
) {
if (lastBlock < b->height) {
wrapup();
}
auto p = b->chunk->getData();
uint8_t blockHash[kSHA256ByteSize];
sha256Twice(blockHash, p, 80);
SKIP(uint32_t, version, p);
SKIP(uint256_t, prevBlkHash, p);
SKIP(uint256_t, blkMerkleRoot, p);
LOAD(uint32_t, blkTime, p);
blkID = b->height - 1;
if (blkID >= firstBlock) {
fprintf(blockFile, "%" PRIu64 "|", blkID);
writeHexEscapedBinaryBuffer(blockFile, blockHash, kSHA256ByteSize);
fputc('|', blockFile);
fprintf(blockFile, "%" PRIu64 "\n", (uint64_t)blkTime);
}
if (0 == blkID % 5000) {
fprintf(
stderr,
"block=%8" PRIu64 " "
"nbOutputs=%9" PRIu64 "\n",
blkID,
outputMap.size()
);
}
}
static void parseTX(
const Block *block,
const uint8_t *&p
) {
auto txStart = p;
uint8_t *txHash = 0;
if(gNeedTXHash && !skip) {
auto txEnd = p;
txHash = allocHash256();
parseTX<true>(block, txEnd);
sha256Twice(txHash, txStart, txEnd - txStart);
}
if(!skip) {
startTX(p, txHash);
}
#if defined(CLAM)
LOAD(uint32_t, nVersion, p);
#else
SKIP(uint32_t, nVersion, p);
#endif
#if defined(PEERCOIN) || defined(CLAM) || defined(JUMBUCKS)
SKIP(uint32_t, nTime, p);
#endif
parseInputs<skip>(block, p, txHash);
Chunk *txo = 0;
size_t txoOffset = -1;
const uint8_t *outputsStart = p;
if(gNeedTXHash && !skip) {
txo = Chunk::alloc();
txoOffset = block->chunk->getOffset() + (p - block->chunk->getData());
gTXOMap[txHash] = txo;
}
parseOutputs<skip, false>(p, txHash);
if(txo) {
size_t txoSize = p - outputsStart;
txo->init(
block->chunk->getMap(),
txoSize,
txoOffset
);
}
SKIP(uint32_t, lockTime, p);
#if defined(CLAM)
if(1<nVersion) {
LOAD_VARINT(strCLAMSpeechLen, p);
p += strCLAMSpeechLen;
}
#endif
if(!skip) {
endTX(p);
}
}
