Bitcoin Forum

hash:00000000000000b31371edd3656af35ef5ddf71aab394ffbdbe14c06a0c9d3ad , txQty:733
hash:00000000000000bee901ddf3cc51943b22e0915ede7818131597c4f4cc5b3d13 , txQty:1263
hash:00000000000000a8dcc7b7f534b74c0e7e43686407e687217a1d10b40f0bea32 , txQty:1323
hash:0000000000000052e1ab840ab54644689275b031fb493a9cbdf6af8cb8c99f1c , txQty:1333
hash:0000000000000013b9efa409b459baf11b4ccb43a60f853bdd8d25fb9b867ec3 , txQty:1399
hash:0000000000000068a1197cfe03640004ea2d0e45776b5c40d4044dc1d1599ca5 , txQty:1432
hash:00000000000000f99af4a59d3105cd411fd0adf42225f6857e6f75837c7ea97e , txQty:1495
hash:000000000000000e00d6df5ea6cbbb5ea12bc634668f18480c8e7eeb41c8af41 , txQty:1544
hash:00000000000000832b120849bb5201d10d4a698a3574bd9da2ab970c5dc1287c , txQty:1678
hash:000000000000033818fb20338be1fe1b223f7018bdad8ee4cea5f396cf5523e8 , txQty:1976

1976,225203
1871,191716
1852,193271
1836,193645
1833,191652
1798,194208
1771,193419
1721,224986
1684,224982
1678,230532
1633,213772
1601,230037
1589,192627
1552,213616
1544,231376
1506,220277
1495,232259
1491,230732
1483,191384
1480,230389

#! /usr/bin/perl

use strict;
use warnings;
use mylibs::json;

sub get_credentials {
        my $envUserName = $ENV{'USER'};
        my $confFile = "/Users/".$envUserName."/Library/Application Support/Bitcoin/bitcoin.conf";
        my ($user, $password);
        my $server = 0;

        chomp $confFile;

        if (open(MYCONFFILE, "< " . $confFile)) {
                my(@lines) = <MYCONFFILE>;
                close(MYCONFFILE);

                foreach (@lines)
                {
                        chomp;
                        if ( /^rpcuser=(.*)$/i ) { $user = $1 }
                        elsif ( /^rpcpassword=(.*)$/i ) { $password = $1 }
                        elsif ( /server=1/i ) { $server = 1 }
                }
        }
        else {
                print "Error opening bitcoin.conf file $!\n";
                exit;
        }

        return $user, $password, $server;
}

################################################
#
#  BEGIN Main
#
################################################


###########
# Authentication
###########
my ($user, $password, $server) = get_credentials();


if ($server != 1) {
        print "ERROR: client is not running in server mode\n";
        exit;
}

###########
# Current Block Height
###########
my $currBlockCommand = "curl --silent --user " .
        $user                       .
        ":"                         .
        $password                   .
        " --data-binary '{\"method\": \"getblockcount\"}' http://127.0.0.1:8332/";

my $currIndexLine = `$currBlockCommand`;

my %currIndex = parse_json($currIndexLine);

###########
# Current Block Hash
###########
my $currHashCommand = "curl --silent --user " .
        $user                       .
        ":"                         .
        $password                   .
        " --data-binary '{\"method\": \"getblockhash\", \"params\": [" .
        ${$currIndex{"result"}} .
        "] }' http://127.0.0.1:8332/";

my $currHashLine = `$currHashCommand`;

my %currHash = parse_json($currHashLine);

###########
# Current Block Details
###########
my $blockDetailsCommand = "curl --silent --user " .
        $user                       .
        ":"                         .
        $password                   .
        " --data-binary '{\"method\": \"getblock\", \"params\": [\"" .
        ${$currHash{"result"}} .
        "\"] }' http://127.0.0.1:8332/";

my $blockDetailsLine = `$blockDetailsCommand`;

my %blockDetails = parse_json($blockDetailsLine);

###########
# Loop through blocks
###########
my $maxTxQty = @{$blockDetails{"result"}{"tx"}};
my $biggestBlock = ${$blockDetails{"result"}{"hash"}};
my $blockTxQty;
my $progress = 0;

while (exists $blockDetails{"result"}{"previousblockhash"}) {
  if ( $progress++ % 100 == 0) {
    print $progress . " , " . $biggestBlock . " , " . $maxTxQty . "\n";
  }
  $blockDetailsCommand = "curl --silent --user " .
          $user                       .
          ":"                         .
          $password                   .
          " --data-binary '{\"method\": \"getblock\", \"params\": [\"" .
          ${$blockDetails{"result"}{"previousblockhash"}} .
          "\"] }' http://127.0.0.1:8332/";

  $blockDetailsLine = `$blockDetailsCommand`;

  %blockDetails = parse_json($blockDetailsLine);

  $blockTxQty = @{$blockDetails{"result"}{"tx"}};
  if ($maxTxQty < $blockTxQty) {
    $maxTxQty = $blockTxQty;
    $biggestBlock = ${$blockDetails{"result"}{"hash"}}
  }
}

print "Block:" . $biggestBlock . ", TxQty:" . $maxTxQty . "\n";

#!/usr/bin/perl

use warnings;
use strict;
use List::MoreUtils qw/natatime/;
use Data::Dumper;

my $MAGIC = 3652501241;
my $BLOCKS_DIR = '/home/btc/.bitcoin/blocks';

## xxd-like output
sub print_dump {
    my ($data) = @_;

    my $offset = 0;
    open my $fd, '<', \$data or die "open: $!";
    while (1) {
        my $read = read $fd, my $bytes, 16;
        last unless $read;
        my @bytes = split '', $bytes;
        my $rawchars = $bytes; $rawchars =~ s/[^ -~]/./g;
        my @hexpairs;
        my $iter = natatime 2, @bytes;
        while (my @vals = $iter->()) {
            push @hexpairs, join '', map { sprintf '%02x', ord } @vals;
        }
        printf "%08x: %-39s  %s\n", $offset, (join ' ', @hexpairs), $rawchars;
        $offset += $read;
    }
    close $fd;
}

sub read_var_int {
    my ($fd, $rem) = @_;
    my $val;

    my $read = read $fd, $val, 1; $$rem -= 1;
    if (!$read) { return undef; }
    $val = unpack 'C', $val;
    if ($val == 0xfd) {
        $read = read $fd, $val, 2; $$rem -= 2;
        $val = unpack 'S', $val;
    } elsif ($val == 0xfe) {
        $read = read $fd, $val, 4; $$rem -= 4;
        $val = unpack 'L', $val;
    } elsif ($val == 0xff) {
        $read = read $fd, $val, 8; $$rem -= 8;
        $val = unpack 'Q', $val;
    }

    return $val;
}

sub read_inputs {
    my ($fd, $count, $rem) = @_;
    my $read;  ## should be used to check ret vals from read/sysread
    my $inputs;

    for my $input (1 .. $count) {
        my ($prev_txid, $prev_idx, $sig_script, $seq);

        $read = read $fd, $prev_txid, 32; $$rem -= 32;
        $prev_txid = unpack 'H64', $prev_txid;
        #print "    prev_txid ($prev_txid)\n";

        $read = read $fd, $prev_idx, 4; $$rem -= 4;
        $prev_idx = unpack 'L', $prev_idx;
        #print "    prev_idx ($prev_idx)\n";

        my $sig_script_len = read_var_int $fd, $rem;
        if (!defined $sig_script_len) { print 'sig_script_len undef'; die; }

        $read = read $fd, $sig_script, $sig_script_len; $$rem -= $sig_script_len;
        #printf "    sig_script: %d bytes\n", length $sig_script;

        $read = read $fd, $seq, 4; $$rem -= 4;
        $seq = unpack 'L', $seq;
        #print "    seq ($seq)\n";

        push @$inputs, {
            prev_txid  => $prev_txid,
            prev_idx   => $prev_idx,
            sig_script => $sig_script,
            seq        => $seq,
        }
    }

    return $inputs;
}

sub read_outputs {
    my ($fd, $count, $rem) = @_;
    my $read;  ## should be used to check ret vals from read/sysread
    my $outputs;

    for my $output (1 .. $count) {
        my ($val, $pubkey_script_len, $pubkey_script);

        $read = read $fd, $val, 8; $$rem -= 8;
        $val = unpack 'Q', $val;

        $pubkey_script_len = read_var_int $fd, $rem;
        if (!defined $pubkey_script_len) { print 'pubkey_script_len undef'; die; }

        $read = read $fd, $pubkey_script, $pubkey_script_len; $$rem -= $pubkey_script_len;
        #printf "    pubkey_script: %d bytes\n", length $pubkey_script;

        push @$outputs, {
            val           => $val,
            pubkey_script => $pubkey_script,
        };
    }

    return $outputs;
}

sub parse_txs {
    my ($txn_data, $len) = @_;
    my $read;  ## should be used to check ret vals from read/sysread
    my $txs;

    my $remaining = $len;
    open my $txn_fd, '<', \$txn_data or die "open: $!";

    my $txn_count = read_var_int $txn_fd, \$remaining;
    if (!defined $txn_count) { print 'txn_count undef'; die; }
    #print "  txn_count ($txn_count)\n";

    #print_dump $txn_data;

    my ($tx_ver, $input_count, $inputs, $output_count, $outputs, $lock_time);
    for my $tx_idx (1 .. $txn_count) {
        $read = read $txn_fd, $tx_ver, 4; $remaining -= 4;
        $tx_ver = unpack 'L', $tx_ver;
        #print "    tx_ver ($tx_ver)\n";

        $input_count = read_var_int $txn_fd, \$remaining;
        if (!defined $input_count) { print 'input_count undef'; die; }
        #print "    input_count ($input_count)\n";

        $inputs = read_inputs $txn_fd, $input_count, \$remaining;
        #print Data::Dumper->Dump ([$inputs],['inputs']);

        $output_count = read_var_int $txn_fd, \$remaining;
        if (!defined $output_count) { print 'output_count undef'; die; }
        #print "    output_count ($output_count)\n";

        $outputs = read_outputs $txn_fd, $output_count, \$remaining;
        #print Data::Dumper->Dump ([$outputs],['outputs']);

        $read = read $txn_fd, $lock_time, 4; $remaining -= 4;
        $lock_time = unpack 'L', $lock_time;
        #print "    lock_time ($lock_time)\n";

        push @$txs, {
            version   => $tx_ver,
            inputs    => $inputs,
            outputs   => $outputs,
            lock_time => $lock_time,
        };
    }

    return $txs;
}

sub parse_block {
    my ($height, $block_data, $len) = @_;
    my $read;  ## should be used to check ret vals from read/sysread

    my $remaining = $len;
    open my $block_fd, '<', \$block_data or die "open: $!";

    my $block_header;
    $read = read $block_fd, $block_header, 80; $remaining -= 80;

    my ($ver, $prev_block, $mrkl, $ts, $bits, $nonce) = unpack 'L H64 H64 L H8 L', $block_header;
    $prev_block = reverse $prev_block=~/../g;
    $mrkl = reverse $mrkl=~/../g;

    my $txn_data;
    $read = read $block_fd, $txn_data, $remaining;

    close $block_fd;

    #my $tx = parse_txs $txn_data, $remaining;  ## commented out for faster parsing

    return {
        version     => $ver,
        height      => $height,
        prev_block  => $prev_block,
        merkle_tree => $mrkl,
        timestamp   => $ts,
        bits        => $bits,
        nonce       => $nonce,
        #tx          => $tx,
    };
}

my $blk_file_num = -1;
my $fd;
sub open_next_blk_file {
    close $fd if defined $fd;
    $blk_file_num++;
    my $blkfile = sprintf "$BLOCKS_DIR/blk%05d.dat", $blk_file_num;
    sysopen $fd, $blkfile, 0 or die "sysopen: $!";
    binmode $fd;
}

#################################################################################################

open_next_blk_file;

my $height = 0;
my %prev_blocks_seen;
while (1) {
    my $read;  ## should be used to check ret vals from read/sysread
    my $data;
    my ($magic, $len, $remaining);

    $read = sysread $fd, $data, 8;
    if (!defined $read) { die "sysread: $!"; }
    if (!$read) {
        warn "sysread: null, going to next file";
        open_next_blk_file;
        redo;
    }
    if ($read < 8) {
        warn "sysread: short read, going to next file";
        open_next_blk_file;
        redo;
    }
    ($magic, $len) = unpack 'L L', $data;
    $remaining = $len;
    next unless $magic;    ## magic == 0, probably near end of file
    if ($MAGIC != $magic) { die "got magic ($magic) instead of ($MAGIC) at block $height\n"; }
    ## read whole block
    $read = sysread $fd, $data, $len;
    if ($len != $read) { $read or last; die "sysread: $!"; }

    #print_dump $block_data;
    my $block = parse_block $height, $data, $len;
    ## orphan detection, untested on orphan chains larger than one single block
    if ($height and exists $prev_blocks_seen{ $block->{'prev_block'} }) {
        my $to_downgrade = ($height-1) - $prev_blocks_seen{ $block->{'prev_block'} };
        warn "orphan, height ($block->{'height'}) pb ($block->{'prev_block'}) ts ($block->{'timestamp'}) to_downgrade ($to_downgrade)\n";
        $height -= ($height-1) - $prev_blocks_seen{ $block->{'prev_block'} };
        next;
    }
    print "$height,$len\n";
#    if (128352 == $block->{'height'}) {
#        use bignum;
#        my $bits = join '', reverse $block->{'bits'} =~ /../g;
#        my ($b1, $b2) = map { hex $_ } $bits =~ /^(..)(.*)$/;
#        my $diff = (0xffff << 208) / ($b2 * 2 ** (8 * ($b1-3)));
#        $block->{'difficulty'} = "$diff";
#
#        print Data::Dumper->Dump ([$block],['block']);
#    }

    $prev_blocks_seen{ $block->{'prev_block'} } = $height;
    $height++;
} 
close $fd;