util.cpp

#include <string>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <openssl/bn.h>
#include <openssl/ecdsa.h>
#include <openssl/obj_mac.h>

#include <util.h>
#include <timer.h>
#include <alloca.h>
#include <common.h>
#include <errlog.h>
#include <rmd160.h>
#include <sha256.h>
#include <opcodes.h>

const uint8_t hexDigits[] = "0123456789abcdef";
const uint8_t b58Digits[] = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

template<> uint8_t *PagedAllocator<Block>::pool = 0;
template<> uint8_t *PagedAllocator<Block>::poolEnd = 0;

template<> uint8_t *PagedAllocator<uint256_t>::pool = 0;
template<> uint8_t *PagedAllocator<uint256_t>::poolEnd = 0;

template<> uint8_t *PagedAllocator<uint160_t>::pool = 0;
template<> uint8_t *PagedAllocator<uint160_t>::poolEnd = 0;

template<> uint8_t *PagedAllocator<Chunk>::pool = 0;
template<> uint8_t *PagedAllocator<Chunk>::poolEnd = 0;

void toHex(
          uint8_t *dst,     // 2*size +1
    const uint8_t *src,     // size
    size_t        size,
    bool          rev
) {
    int incr = 1;
    const uint8_t *p = src;
    const uint8_t *e = size + src;
    if(rev) {
        p = e-1;
        e = src-1;
        incr = -1;
    }
    
    while(likely(p!=e)) {
        uint8_t c = p[0];
        dst[0] = hexDigits[c>>4];
        dst[1] = hexDigits[c&0xF];
        p += incr;
        dst += 2;
    }
    dst[0] = 0;
}

void showHex(
    const uint8_t *p,
    size_t        size,
    bool          rev
) {
    uint8_t* buf = (uint8_t*)alloca(2*size + 1);
    toHex(buf, p, size, rev);
    printf("%s", buf);
}

uint8_t fromHexDigit(
    uint8_t h,
    bool abortOnErr
) {
    if(likely('0'<=h && h<='9')) return      (h - '0');
    if(likely('a'<=h && h<='f')) return 10 + (h - 'a');
    if(likely('A'<=h && h<='F')) return 10 + (h - 'A');
    if(abortOnErr) errFatal("incorrect hex digit %c", h);
    return 0xFF;
}

bool fromHex(
          uint8_t *dst,
    const uint8_t *src,
    size_t        dstSize,
    bool          rev,
    bool          abortOnErr
) {
    int incr = 2;
    uint8_t *end = dstSize + dst;
    if(rev) {
        src += 2*(dstSize-1);
        incr = -2;
    }

    while(likely(dst<end)) {
        uint8_t hi = fromHexDigit(src[0], abortOnErr);
        if(unlikely(0xFF==hi)) return false;

        uint8_t lo = fromHexDigit(src[1], abortOnErr);
        if(unlikely(0xFF==lo)) return false;

        *(dst++) = (hi<<4) + lo;
        src += incr;
    }

    return true;
}

static bool getOpPushData(
    const uint8_t *&p,
    uint64_t &dataSize
) {

    dataSize = 0;
    LOAD(uint8_t, c, p);

    bool isImmediate = (0<c && c<79);
    if(!isImmediate) {
        --p;
        return false;
    }

         if(likely(c<=75)) {                       dataSize = c; }
    else if(likely(76==c)) { LOAD( uint8_t, v, p); dataSize = v; }
    else if(likely(77==c)) { LOAD(uint16_t, v, p); dataSize = v; }
    else if(likely(78==c)) { LOAD(uint32_t, v, p); dataSize = v; }
    if(512*1024<dataSize) {
        return false;
    }

    p += dataSize;
    return true;
}

// This is a tad arbitrary but works well in practice
bool isCommentScript(
    const uint8_t *p,
    size_t scriptSize
) {
    const uint8_t *e = scriptSize + p;
    while(likely(p<e)) {
        LOAD(uint8_t, c, p);
        bool isImmediate = (0<c && c<79);
        if(!isImmediate) {
            if(0x6A!=c) {
                return false;
            }
        } else {

            --p;

            uint64_t dataSize = 0;
            auto ok = getOpPushData(p, dataSize);
            if(!ok) {
                return false;
            }
        }
    }
    return true;
}

struct Compare160 {
    bool operator()(
        const uint160_t &a,
        const uint160_t &b
    ) const {
        auto as = a.v;
        auto bs = b.v;
        auto ae = kRIPEMD160ByteSize + as;
        while(as<ae) {
            int delta = ((int)*(as++)) - ((int)*(bs++));
            if(delta) {
                return (delta<0);
            }
        }
        return true;
    }
};

static void packMultiSig(
                   uint8_t *pubKeyHash,
    std::vector<uint160_t> &addresses,
                       int m,
                       int n
) {
    std::sort(
        addresses.begin(),
        addresses.end(),
        Compare160()
    );

    std::vector<uint8_t> data;
    data.reserve(2 + kRIPEMD160ByteSize*sizeof(addresses));
    data.push_back((uint8_t)m);
    data.push_back((uint8_t)n);
    for(const auto &addr:addresses) {
        data.insert(
            data.end(),
            addr.v,
            kRIPEMD160ByteSize + addr.v
        );
    }
    rmd160(
        pubKeyHash,
        &(data[0]),
        data.size()
    );
}

// Try to pattern match a multisig
bool isMultiSig(
    int &_m,
    int &_n,
    std::vector<uint160_t> &addresses,
    const uint8_t *p,
    size_t scriptSize
) {

    auto e = scriptSize + p;
    if(scriptSize<=5) {
        return false;
    }

    auto m = (*(p++) - 0x50);             // OP_1 ... OP-16
    auto isMValid = (1<=m && m<=16);
    if(!isMValid) {
        return false;
    }

    int count = 0;
    while(1) {
        uint64_t dataSize = 0;
        auto ok = getOpPushData(p, dataSize);
        if(e<=p) {
            return false;
        }
        if(!ok) {
            break;
        }

        uint160_t addr;
        auto sz = sizeof(addr);
        memcpy(addr.v, p-sz, sz);
        addresses.push_back(addr);
        ++count;
    }

    auto n = (*(p++) - 0x50);             // OP_1 ... OP-16
    auto isNValid = (1<=n && n<=16);
    if(!isNValid || n!=count) {
        return false;
    }

    auto lastOp = *(p++);
    bool ok = (0xAE==lastOp) &&          // OP_CHECKMULTISIG
              (m<=n)         &&
              (p==e);
    if(ok) {
        _m = m;
        _n = n;
    }
    return ok;
}

void showScript(
    const uint8_t *p,
    size_t        scriptSize,
    const char    *header,
    const char    *indent,
    bool          showAscii
) {
    bool first = true;
    const uint8_t *e = scriptSize + p;
    indent = indent ? indent : "";
    while(likely(p<e)) {
        LOAD(uint8_t, c, p);
        bool isImmediate = (0<c && c<79) ;
        if(!isImmediate) {
            printf(
                "    %s0x%02X %s%s\n",
                indent,
                c,
                getOpcodeName(c),
                (first && header) ? header : ""
            );
        } else {
            uint64_t dataSize = 0;
                 if(likely(c<=75)) {                       dataSize = c; }
            else if(likely(76==c)) { LOAD( uint8_t, v, p); dataSize = v; }
            else if(likely(77==c)) { LOAD(uint16_t, v, p); dataSize = v; }
            else if(likely(78==c)) { LOAD(uint32_t, v, p); dataSize = v; }

            printf("         %sOP_PUSHDATA(%" PRIu64 ", 0x", indent, dataSize);
            if(512*1024<dataSize) {
                printf(" -- dataSize is weird, likely an invalid script -- bailing.\n");
                return;
            } else {
                showHex(p, dataSize, false);
                printf(
                    ")%s\n",
                    (first && header) ? header : ""
                );
                if(showAscii) {
                    printf("ascii version of data:\n");
                    canonicalHexDump(p, dataSize, "");
                    printf("\n");
                }
                p += dataSize;
            }
        }
        first = false;
    }
}

bool compressPublicKey(
          uint8_t *result,          // 33 bytes
    const uint8_t *decompressedKey  // 65 bytes
) {
    EC_KEY *key = EC_KEY_new_by_curve_name(NID_secp256k1);
    if(!key) {
        errFatal("EC_KEY_new_by_curve_name failed");
        return false;
    }

    EC_KEY *r = o2i_ECPublicKey(&key, &decompressedKey, 65);
    if(!r) {
        //warning("o2i_ECPublicKey failed");
        EC_KEY_free(key);
        return false;
    }

    EC_KEY_set_conv_form(key, POINT_CONVERSION_COMPRESSED);
    size_t size = i2o_ECPublicKey(key, &result);
    EC_KEY_free(key);

    if(33!=size) {
        errFatal("i2o_ECPublicKey failed");
        return false;
    }

    return true;
}

bool decompressPublicKey(
          uint8_t *result,          // 65 bytes
    const uint8_t *compressedKey    // 33 bytes
) {
    EC_KEY *key = EC_KEY_new_by_curve_name(NID_secp256k1);
    if(!key) {
        errFatal("EC_KEY_new_by_curve_name failed");
        return false;
    }

    EC_KEY *r = o2i_ECPublicKey(&key, &compressedKey, 33);
    if(!r) {
        //warning("o2i_ECPublicKey failed");
        EC_KEY_free(key);
        return false;
    }

    EC_KEY_set_conv_form(key, POINT_CONVERSION_UNCOMPRESSED);
    size_t size = i2o_ECPublicKey(key, &result);
    EC_KEY_free(key);

    if(65!=size) {
        errFatal("i2o_ECPublicKey failed");
        return false;
    }

    return true;
}

int solveOutputScript(
          uint8_t *pubKeyHash,
    const uint8_t *script,
    uint64_t      scriptSize,
    uint8_t       *addrType
) {
    // default: if we fail to solve the script, we make it pay to unspendable hash 0 (lost coins)
    memset(pubKeyHash, 0, kSHA256ByteSize);

    // The most common output script type that pays to hash160(pubKey)
    if(
        likely(
            0x76==script[0]              &&  // OP_DUP
            0xA9==script[1]              &&  // OP_HASH160
              20==script[2]              &&  // OP_PUSHDATA(20)
            0x88==script[scriptSize-2]   &&  // OP_EQUALVERIFY
            0xAC==script[scriptSize-1]   &&  // OP_CHECKSIG
              25==scriptSize
        )
    ) {
        memcpy(pubKeyHash, 3+script, kRIPEMD160ByteSize);
        addrType[0] = 0;
        return 0;
    }

    // Output script commonly found in block reward TX, that pays to an explicit pubKey
    if(
        likely(
              65==script[0]             &&  // OP_PUSHDATA(65)
            0xAC==script[scriptSize-1]  &&  // OP_CHECKSIG
              67==scriptSize
        )
    ) {
        uint256_t sha;
        sha256(sha.v, 1+script, 65);
        rmd160(pubKeyHash, sha.v, kSHA256ByteSize);
        addrType[0] = 0;
        return 1;
    }

    // A rather unusual output script that pays to and explicit compressed pubKey
    if(
        likely(
              33==script[0]            &&  // OP_PUSHDATA(33)
            0xAC==script[scriptSize-1] &&  // OP_CHECKSIG
              35==scriptSize
        )
    ) {
        //uint8_t pubKey[65];
        //bool ok = decompressPublicKey(pubKey, 1+script);
        //if(!ok) return -3;

        uint256_t sha;
        sha256(sha.v, 1+script, 33);
        rmd160(pubKeyHash, sha.v, kSHA256ByteSize);
        addrType[0] = 0;
        return 2;
    }

    // A modern output script type, that pays to hash160(script)
    if(
        likely(
            0xA9==script[0]             &&  // OP_HASH160
              20==script[1]             &&  // OP_PUSHDATA(20)
            0x87==script[scriptSize-1]  &&  // OP_EQUAL
              23==scriptSize
        )
    ) {
        memcpy(pubKeyHash, 2+script, kRIPEMD160ByteSize);
        addrType[0] = 5;
        return 3;
    }

    int m = 0;
    int n = 0;
    std::vector<uint160_t> addresses;
    if(
        isMultiSig(
            m,
            n,
            addresses,
            script,
            scriptSize
        )
    ) {
        packMultiSig(pubKeyHash, addresses, m, n);
        addrType[0] = 8;
        return 4;
    }

    // Broken output scripts that were created by p2pool for a while
    if(
        0x73==script[0] &&                  // OP_IFDUP
        0x63==script[1] &&                  // OP_IF
        0x72==script[2] &&                  // OP_2SWAP
        0x69==script[3] &&                  // OP_VERIFY
        0x70==script[4] &&                  // OP_2OVER
        0x74==script[5]                     // OP_DEPTH
    ) {
        return -2;
    }

    // A non-functional "comment" script
    if(isCommentScript(script, scriptSize)) {
        return -3;
    }

    // A challenge: anyone who can find X such that 0==RIPEMD160(X) stands to earn a bunch of coins
    if(
        0x76==script[0] &&                  // OP_DUP
        0xA9==script[1] &&                  // OP_HASH160
        0x00==script[2] &&                  // OP_0
        0x88==script[3] &&                  // OP_EQUALVERIFY
        0xAC==script[4]                     // OP_CHECKSIG
    ) {
        return -4;
    }

#if 0
    // TODO : some scripts are solved by satoshi's client and not by the above. track them
    // Unknown output script type -- very likely lost coins, but hit the satoshi script solver to make sure
    int result = extractAddress(pubKeyHash, script, scriptSize);
    if(result) return -1;
    return 5;
    printf("EXOTIC OUTPUT SCRIPT:\n");
    showScript(script, scriptSize);
#endif

    // Something we didn't understand
    return -1;
}

const uint8_t *loadKeyHash(
    const uint8_t *hexHash
) {
    static bool loaded = false;
    static uint8_t hash[kRIPEMD160ByteSize];
    const char *someHexHash = "0568015a9facccfd09d70d409b6fc1a5546cecc6"; // 1VayNert3x1KzbpzMGt2qdqrAThiRovi8 deepbit's very large address

    if(unlikely(!loaded))
    {
        if(0==hexHash)
            hexHash = reinterpret_cast<const uint8_t *>(someHexHash);

        if((2*kRIPEMD160ByteSize)!=strlen((const char *)hexHash))
            errFatal("specified hash has wrong length");

        fromHex(hash, hexHash, sizeof(hash), false);
        loaded = true;
    }

    return hash;
}

uint8_t fromB58Digit(
    uint8_t digit,
       bool abortOnErr
) {
    if('1'<=digit && digit<='9') return (digit - '1') +   0;
    if('A'<=digit && digit<='H') return (digit - 'A') +   9;
    if('J'<=digit && digit<='N') return (digit - 'J') +  17;
    if('P'<=digit && digit<='Z') return (digit - 'P') +  22;
    if('a'<=digit && digit<='k') return (digit - 'a') +  33;
    if('m'<=digit && digit<='z') return (digit - 'm') +  44;
    if(abortOnErr) errFatal("incorrect base58 digit %c", digit);
    return 0xff;
}

static int getCoinType() {
    return
        #if defined(PROTOSHARES)
            56
        #endif

        #if defined(DARKCOIN)
            48 + 28
        #endif

        #if defined(PAYCON)
            55
        #endif

        #if defined(LITECOIN)
            48
        #endif

        #if defined(BITCOIN)
            0
        #endif
        
        #if defined(TESTNET3)
            0
        #endif        
        
        #if defined(FEDORACOIN)
            33
        #endif

        #if defined(PEERCOIN)
            48 + 7
        #endif

        #if defined(CLAM)
            137
        #endif

        #if defined(JUMBUCKS)
            43
        #endif

        #if defined(DOGECOIN)
            30
        #endif

        #if defined(MYRIADCOIN)
            50
        #endif
                
        #if defined(UNOBTANIUM)
            130
        #endif
    ;
}

bool addrToHash160(
          uint8_t *hash160,
    const uint8_t *addr,
             bool checkHash,
             bool verbose
) {
    static BIGNUM *sum = 0;
    static BN_CTX *ctx = 0;
    if(unlikely(!ctx)) {
        ctx = BN_CTX_new();
        // BN_CTX_init(ctx);
        sum = BN_new();
    }

    BN_zero(sum);
    while(1) {
        uint8_t c = *(addr++);
        if(unlikely(0==c)) break;

        uint8_t dg = fromB58Digit(c);
        BN_mul_word(sum, 58);
        BN_add_word(sum, dg);
    }

    uint8_t buf[4 + 2 + kRIPEMD160ByteSize + 4];
    size_t size = BN_bn2mpi(sum, 0);
    if(sizeof(buf)<size) {
        warning(
            "BN_bn2mpi returned weird buffer size %d, expected %d\n",
            (int)size,
            (int)sizeof(buf)
        );
        return false;
    }

    BN_bn2mpi(sum, buf);

    uint32_t recordedSize = 
        (buf[0]<<24)    |
        (buf[1]<<16)    |
        (buf[2]<< 8)    |
        (buf[3]<< 0)
    ;
    if(size!=(4+recordedSize)) {
        warning(
            "BN_bn2mpi returned bignum size %d, expected %d\n",
            (int)recordedSize,
            (int)size-4
        );
        return false;
    }

    uint8_t *bigNumEnd;
    uint8_t *dataEnd = size + buf;
    uint8_t *bigNumStart = 4 + buf;
    uint8_t *checkSumStart = bigNumEnd = (-4 + dataEnd);
    while(0==bigNumStart[0] && bigNumStart<checkSumStart) ++bigNumStart;

    ptrdiff_t bigNumSize = bigNumEnd - bigNumStart;
    ptrdiff_t padSize = kRIPEMD160ByteSize - bigNumSize;
    if(0<padSize) {
        if(0<bigNumSize) {
            memcpy(padSize + hash160, bigNumStart, bigNumSize);
        }
        memset(hash160, 0, padSize);
    } else {
        memcpy(hash160, bigNumStart - padSize, kRIPEMD160ByteSize);
    }

    bool hashOK = true;
    if(checkHash) {

        uint8_t data[1+kRIPEMD160ByteSize];
        memcpy(1+data, hash160, kRIPEMD160ByteSize);
        data[0] = getCoinType();

        uint8_t sha[kSHA256ByteSize];
        sha256Twice(sha, data, 1+kRIPEMD160ByteSize);

        hashOK =
            sha[0]==checkSumStart[0]  &&
            sha[1]==checkSumStart[1]  &&
            sha[2]==checkSumStart[2]  &&
            sha[3]==checkSumStart[3];

        if(!hashOK) {
            warning(
                "checksum of address %s failed. Expected 0x%x%x%x%x, got 0x%x%x%x%x.",
                addr,
                checkSumStart[0],
                checkSumStart[1],
                checkSumStart[2],
                checkSumStart[3],
                sha[0],
                sha[1],
                sha[2],
                sha[3]
            );
        }
    }

    return hashOK;
}

void hash160ToAddr(
          uint8_t *addr,    // 36 bytes is safe, even with pad on
    const uint8_t *hash160,
             bool pad,
          uint8_t type
) {
    uint8_t buf[4 + 2 + kRIPEMD160ByteSize + kSHA256ByteSize];
    const uint32_t size = 4 + 2 + kRIPEMD160ByteSize;
    memcpy(4 + 2 + buf, hash160, kRIPEMD160ByteSize);
    buf[ 0] = (size>>24) & 0xff;
    buf[ 1] = (size>>16) & 0xff;
    buf[ 2] = (size>> 8) & 0xff;
    buf[ 3] = (size>> 0) & 0xff;
    buf[ 4] = 0;
    buf[ 5] = getCoinType() + type;
    sha256Twice(
        4 + 2 + kRIPEMD160ByteSize + buf,
        4 + 1 + buf,
        1 + kRIPEMD160ByteSize
    );

    static BIGNUM *b58 = 0;
    static BIGNUM *num = 0;
    static BIGNUM *div = 0;
    static BIGNUM *rem = 0;
    static BN_CTX *ctx = 0;

    if(!ctx) {
        ctx = BN_CTX_new();
        // BN_CTX_init(ctx);

        b58 = BN_new();
        num = BN_new();
        div = BN_new();
        rem = BN_new();
        BN_set_word(b58, 58);
    }

    BN_mpi2bn(buf, 4+size, num);

    uint8_t *p = addr;
    while(!BN_is_zero(num)) {
        int r = BN_div(div, rem, num, b58, ctx);
        if(!r) errFatal("BN_div failed");
        BN_copy(num, div);

        uint32_t digit = BN_get_word(rem);
        *(p++) = b58Digits[digit];
    }

    const uint8_t *a =                          (5+buf);
    const uint8_t *e = 1 + kRIPEMD160ByteSize + (5+buf);
    while(a<e && 0==a[0]) {
        *(p++) = b58Digits[0];
        ++a;
    }
    *p = 0;

    auto l = addr;
    auto r = p - 1;
    while(l<r) {
        uint8_t a = *l;
        uint8_t b = *r;
        *(l++) = b;
        *(r--) = a;
    }

    if(pad) {
        auto sz = p - addr;
        auto delta = 34 - sz;
        if(0<delta) {
            while(delta--) {
                *(p++) = ' ';
            }
            *(p++) = 0;
        }
    }
}

bool guessHash160(
          uint8_t *hash160,
    const uint8_t *addr,
             bool verbose
) {
    const uint8_t *p = addr;
    while(1) {
        uint8_t c = *p;
        uint8_t h = fromHexDigit(c, false);
        if(0xff==h) {
            break;
        }
        ++p;
    }

    ptrdiff_t size = p - addr;
    if(2*kRIPEMD160ByteSize==size) {
        fromHex(hash160, addr, kRIPEMD160ByteSize, false);
        return true;
    }

    return addrToHash160(hash160, addr, true, verbose);
}

static bool addAddr(
    std::vector<uint160_t> &result,
    const uint8_t *buf,
    bool verbose
) {
    uint160_t h160;
    bool ok = guessHash160(h160.v, buf, verbose);
    if(ok) result.push_back(h160);
    return ok;
}

void loadKeyList(
    std::vector<uint160_t> &result,
    const char *str,
    bool verbose
) {
    bool isFile = (
        'f'==str[0] &&
        'i'==str[1] &&
        'l'==str[2] &&
        'e'==str[3] &&
        ':'==str[4]
    );
    if(!isFile) {
        addAddr(result, (uint8_t*)str, true);
        return;
    }

    const char *fileName = 5+str;
    bool isStdIn = ('-'==fileName[0] && 0==fileName[1]);
    FILE *f = isStdIn ? stdin : fopen(fileName, "r");
    if(!f) {
        warning("couldn't open %s for reading\n", fileName);
        return;
    }

    size_t found = 0;
    size_t lineCount = 0;
    double start = Timer::usecs();
    while(1) {

        char buf[1024];
        char *r = fgets(buf, sizeof(buf), f);
        if(r==0) break;
        ++lineCount;

        size_t sz = strlen(buf);
        if('\n'==buf[sz-1]) buf[sz-1] = 0;

        uint160_t h160;
        bool ok = addAddr(result, (uint8_t*)buf, verbose);
        if(ok) {
            ++found;
        } else {
            if(verbose) {
                warning(
                    "in file %s, line %d, %s is not an address\n",
                    fileName,
                    lineCount,
                    buf
                );
            }
        }
    }
    fclose(f);

    double elapsed = (Timer::usecs() - start)*1e-6;
    info(
        "file %s loaded in %.2f secs, found %d addresses",
        fileName,
        elapsed,
        (int)found
    );
}

void loadHash256List(
    std::vector<uint256_t> &result,
    const char *str,
    bool verbose
) {
    bool isFile = (
        'f'==str[0] &&
        'i'==str[1] &&
        'l'==str[2] &&
        'e'==str[3] &&
        ':'==str[4]
    );

    if(!isFile) {

        size_t sz = strlen(str);
        if(2*kSHA256ByteSize!=sz) errFatal("%s is not a valid TX hash", str);

        uint256_t h256;
        fromHex(h256.v, (const uint8_t *)str);
        result.push_back(h256);
        return;
    }

    const char *fileName = 5+str;
    bool isStdIn = ('-'==fileName[0] && 0==fileName[1]);
    FILE *f = isStdIn ? stdin : fopen(fileName, "r");
    if(!f) {
        warning("couldn't open %s for reading\n", fileName);
        return;
    }

    size_t lineCount = 0;
    while(1) {

        char buf[1024];
        char *r = fgets(buf, sizeof(buf), f);
        if(r==0) break;
        ++lineCount;

        size_t sz = strlen(buf);
        if(2*kSHA256ByteSize<=sz) {

            uint256_t h256;
            bool ok = fromHex(h256.v, (const uint8_t *)buf, kSHA256ByteSize, true, false);
            if(ok)
                result.push_back(h256);
            else if(verbose) {
                warning(
                    "in file %s, line %d, %s is not a valid TX hash\n",
                    fileName,
                    lineCount,
                    buf
                );
            }
        }

    }
    fclose(f);
}

std::string pr128(
    const uint128_t &y
) {
    static char result[1024];
    char *p = 1023+result;
    *(p--) = 0;

    auto x = y;
    while(1) {
        *(p--) = (char)((x % 10) + '0');
        if(unlikely(0==x)) break;
        x /= 10;
    }
    ++p;

    return std::string(p[0]!='0' ? p : (1022+result==p) ? p : p+1);
}

void showFullAddr(
    const Hash160 &addr,
    bool both
) {
    uint8_t b58[128];
    if(both) {
        showHex(addr, sizeof(uint160_t), false);
    }

    hash160ToAddr(b58, addr);
    printf(
        "%s%s",
        both ? " " : "", b58
    );
}

uint64_t getBaseReward(
    uint64_t h
) {
    static const uint64_t kCoin = 100000000;
    uint64_t reward = (50 * kCoin);
    uint64_t shift = (h/210000);
    reward >>= shift;
    return reward;
}

const char *getInterestingAddr() {

    const char *addr =

    #if defined(BITCOIN)

        "1dice8EMZmqKvrGE4Qc9bUFf9PX3xaYDp"
        
    #elif defined(TESTNET3)
    
        "mxRN6AQJaDi5R6KmvMaEmZGe3n5ScV9u33"

    #elif defined(LITECOIN)

        "LKvTVnkK2rAkJXfgPdkaDRgvEGvazxWS9o"

    #elif defined(DARKCOIN)

        "XnuCAYmAiVHE6Xv3D7Xw685wWzqtcfexLh"

    #elif defined(PEERCOIN)

        "PDH9AeruMUGh2JzYYTpaNtjLAcfGV5LEto"

    #elif defined(CLAM)

        "xQKq1LwJQQkg1A5cmB9znGozCKLkAaKJHW"

    #elif defined(PAYCON)

        "PShpEEfcy8UrBPWoefsNnq8oz6bX7dNxnP"

    #elif defined(JUMBUCKS)

        "JhbrvAmM7kNpwA6wD5KoAsbtikLWWMNPcM"

    #elif defined(MYRIADCOIN)

        "MDiceoNDTQboRxYKMTstxxRBY493Lg9bV2"

    #elif defined(UNOBTANIUM)

        "udicetdXSo6Zc7vhWgAZfz4XrwagAX34RK"

    #else

        fatal("no address specified")

    #endif
    ;

    warning("no addresses specified, using popular address %s", addr);
    return addr;
}

#if defined(DARKCOIN)

    #include <h9/h9.h>

    void h9(
              uint8_t *h9r,
        const uint8_t *buf,
        uint64_t      size
    ) {
        uint256 hash = Hash9(buf, size + buf);
        memcpy(h9r, &hash, sizeof(hash));
    }

#endif

#if defined(PAYCON)

    #include <h9/h13.h>

    void h13(
        uint8_t       *h9r,
        const uint8_t *buf,
        uint64_t      size
    ) {
        uint256 hash = Hash13(buf, size + buf);
        memcpy(h9r, &hash, sizeof(hash));
    }

#endif

#if defined(CLAM) || defined(JUMBUCKS)

    #include <scrypt/scrypt.h>

    void scrypt(
              uint8_t *scr,
        const uint8_t *buf,
        uint64_t      size
    ) {
        unsigned char scratchpad[SCRYPT_BUFFER_SIZE];
        uint256 hash = scrypt_nosalt(buf, size, scratchpad);
        memcpy(scr, &hash, sizeof(hash));
    }

#endif

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

        lp = p;
        while(lp<le) {
            int c = *(lp++);
            printf("%c", isprint(c) ? c : '.');
        }

        printf("\n");
        p = np;
    }
}

void showScriptInfo(
    const uint8_t *outputScript,
    uint64_t      outputScriptSize,
    const uint8_t *indent
) {

    uint8_t addrType[128];
    const char *typeName = "unknown";
    uint8_t pubKeyHash[kSHA256ByteSize];
    auto scriptType = solveOutputScript(
        pubKeyHash,
        outputScript,
        outputScriptSize,
        addrType
    );

    switch(scriptType) {
        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 = "M of N multi-sig";
            break;
        }
        case -4: {
            typeName = "pays to 0=hash160(X) ... challenge script: anyone who can find X such that 0==RIPEMD160(X) stands to earn a bunch of coins";
            break;
        }
        case -3: {
            typeName = "non functional comment script - coins lost";
            break;
        }
        case -2: {
            typeName = "broken script generated by p2pool - coins lost";
            break;
        }
        case -1: {
            typeName = "couldn't parse script";
            break;
        }
    }
    printf(
        "%sscriptType = '%s'\n",
        indent,
        typeName
    );

    if(0<=scriptType) {
        uint8_t btcAddr[64];
        hash160ToAddr(btcAddr, pubKeyHash, false, addrType[0]);
        printf(
            "%sscriptPaysToAddr = '%s'\n",
            indent,
            btcAddr
        );
        printf(
            "%sscriptPaysToHash160 = '",
            indent
        );
        showHex(pubKeyHash, kRIPEMD160ByteSize, false);
        printf("'\n");
    }
}

static inline void writeEscapedChar(
    int  c,
    FILE *f
) {
         if(unlikely(0==c))  { fputc('\\', f); c = '0'; }
    else if(unlikely('\n'==c)) fputc('\\', f);
    else if(unlikely('\t'==c)) fputc('\\', f);
    else if(unlikely('\\'==c)) fputc('\\', f);
    fputc(c, f);
}

void writeEscapedBinaryBufferRev(
    FILE          *f,
    const uint8_t *p,
    size_t        n
) {
    p += n;
    while(n--) {
        uint8_t c = *(--p);
        writeEscapedChar(c, f);
    }
}

void writeEscapedBinaryBuffer(
    FILE          *f,
    const uint8_t *p,
    size_t        n
) {
    while(n--) {
        uint8_t c = *(p++);
        writeEscapedChar(c, f);
    }
}