btcruby 0.0.0 → 1.0.0

data/lib/btcruby/block.rb

@@ -0,0 +1,170 @@
+module BTC
+  # Nodes collect new transactions into a block, hash them into a hash tree,
+  # and scan through nonce values to make the block's hash satisfy proof-of-work
+  # requirements.  When they solve the proof-of-work, they broadcast the block
+  # to everyone and the block is added to the block chain.  The first transaction
+  # in the block is a special one that creates a new coin owned by the creator
+  # of the block.
+  class Block < BlockHeader
+
+    # Array of BTC::Transaction objects
+    attr_accessor :transactions
+
+    def self.genesis_mainnet
+      self.new(
+        version:             1,
+        previous_block_hash: ZERO_HASH256,
+        merkle_root:         BTC::Data.data_from_hex("3ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a"),
+        timestamp:           1231006505,
+        bits:                0x1d00ffff,
+        nonce:               0x7c2bac1d,
+        transactions:        [BTC::Transaction.new(
+          version:   1,
+          inputs:    [
+            BTC::TransactionInput.new(
+              coinbase_data: BTC::Data.data_from_hex("04FFFF001D010445"+
+              "5468652054696D65732030332F4A616E2F32303039204368616E63656C6C6F72206F6E2062" +
+              "72696E6B206F66207365636F6E64206261696C6F757420666F722062616E6B73"),
+            )
+          ],
+          outputs:   [
+            BTC::TransactionOutput.new(
+              value: 50*COIN,
+              script: Script.new(data: BTC::Data.data_from_hex("4104678AFDB0FE5548271967F1"+
+              "A67130B7105CD6A828E03909A67962E0EA1F61DEB649F6BC3F4CEF38"+
+              "C4F35504E51EC112DE5C384DF7BA0B8D578A4C702B6BF11D5FAC"))
+            )
+          ],
+          lock_time: 0
+        )],
+        height: 0
+      )
+    end
+
+    def self.genesis_testnet
+      self.new(
+        version:             1,
+        previous_block_hash: ZERO_HASH256,
+        merkle_root:         BTC::Data.data_from_hex("3ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a"),
+        timestamp:           1296688602,
+        bits:                0x1d00ffff,
+        nonce:               0x18aea41a,
+        transactions:        [BTC::Transaction.new(
+          version:   1,
+          inputs:    [
+            BTC::TransactionInput.new(
+              coinbase_data: BTC::Data.data_from_hex("04FFFF001D010445"+
+              "5468652054696D65732030332F4A616E2F32303039204368616E63656C6C6F72206F6E2062" +
+              "72696E6B206F66207365636F6E64206261696C6F757420666F722062616E6B73"),
+            )
+          ],
+          outputs:   [
+            BTC::TransactionOutput.new(
+              value: 50*COIN,
+              script: Script.new(data: BTC::Data.data_from_hex("4104678AFDB0FE5548271967F1"+
+              "A67130B7105CD6A828E03909A67962E0EA1F61DEB649F6BC3F4CEF38"+
+              "C4F35504E51EC112DE5C384DF7BA0B8D578A4C702B6BF11D5FAC"))
+            )
+          ],
+          lock_time: 0
+        )],
+        height: 0
+      )
+    end
+
+    def initialize(data: nil,
+                   stream: nil,
+                   version: CURRENT_VERSION,
+                   previous_block_hash: nil,
+                   previous_block_id: nil,
+                   merkle_root: nil,
+                   timestamp: 0,
+                   time: nil,
+                   bits: 0,
+                   nonce: 0,
+                   transactions: [],
+
+                   # optional attributes
+                   height: nil,
+                   confirmations: nil)
+      super(
+                       data: data,
+                     stream: stream,
+                    version: version,
+        previous_block_hash: previous_block_hash,
+          previous_block_id: previous_block_id,
+                merkle_root: merkle_root,
+                  timestamp: timestamp,
+                       time: time,
+                       bits: bits,
+                      nonce: nonce,
+                     height: height,
+              confirmations: confirmations
+      )
+
+      @transactions = transactions if transactions
+    end
+
+    def init_with_stream(stream)
+      super(stream)
+      if !(txs_count = BTC::WireFormat.read_varint(stream: stream).first)
+        raise ArgumentError, "Failed to read count of transactions from the stream."
+      end
+      txs = (0...txs_count).map do
+        Transaction.new(stream: stream)
+      end
+      @transactions = txs
+    end
+
+    def data
+      data = super
+      data << BTC::WireFormat.encode_varint(self.transactions.size)
+      self.transactions.each do |tx|
+        data << tx.data
+      end
+      data
+    end
+
+    def block_header
+      BlockHeader.new(
+        version:             self.version,
+        previous_block_hash: self.previous_block_hash,
+        merkle_root:         self.merkle_root,
+        timestamp:           self.timestamp,
+        bits:                self.bits,
+        nonce:               self.nonce,
+        height:              self.height,
+        confirmations:       self.confirmations)
+    end
+
+    def ==(other)
+      super(other) && @transactions == other.transactions
+    end
+
+    def dup
+      self.class.new(
+        version:             self.version,
+        previous_block_hash: self.previous_block_hash,
+        merkle_root:         self.merkle_root,
+        timestamp:           self.timestamp,
+        bits:                self.bits,
+        nonce:               self.nonce,
+        transactions:        self.transactions.map{|t|t.dup},
+        height:              self.height,
+        confirmations:       self.confirmations)
+    end
+
+    def inspect
+      %{#<#{self.class.name}:#{self.block_id[0,24]}} +
+      %{ ver:#{self.version}} +
+      %{ prev:#{self.previous_block_id[0,24]}} +
+      %{ merkle_root:#{BTC.id_from_hash(self.merkle_root)[0,16]}} +
+      %{ timestamp:#{self.timestamp}} +
+      %{ bits:0x#{self.bits.to_s(16)}} +
+      %{ nonce:0x#{self.nonce.to_s(16)}} +
+      %{ txs(#{self.transactions.size}): #{self.transactions.inspect}} +
+      %{>}
+    end
+
+  end
+end

data/lib/btcruby/block_header.rb

@@ -0,0 +1,231 @@
+module BTC
+  # Block header is the 80-byte prefix of the block.
+  # Nodes collect new transactions into a block, hash them into a hash tree,
+  # and scan through nonce values to make the block's hash satisfy proof-of-work
+  # requirements.  When they solve the proof-of-work, they broadcast the block
+  # to everyone and the block is added to the block chain.  The first transaction
+  # in the block is a special one that creates a new coin owned by the creator
+  # of the block.
+  class BlockHeader
+
+    CURRENT_VERSION = 2
+    ZERO_HASH256  = "\x00".b*32
+
+    # Binary hash of the block
+    attr_reader :block_hash
+
+    # Hex big-endian hash of the block
+    attr_reader :block_id
+
+    # Block version.
+    attr_accessor :version
+
+    # Binary hash of the previous block
+    attr_accessor :previous_block_hash
+
+    # Hex big-endian hash of the previous block
+    attr_accessor :previous_block_id
+
+    # Raw binary root hash of the transaction merkle tree.
+    attr_accessor :merkle_root
+
+    # uint32 unix timestamp
+    attr_accessor :timestamp
+
+    # Time object derived from timestamp
+    attr_accessor :time
+
+    # uint32 proof-of-work in compact format
+    attr_accessor :bits
+
+    # uint32 nonce (used for mining iterations)
+    attr_accessor :nonce
+
+
+    # Optional attributes.
+    # These are not derived from block data, but attached externally (e.g. via external APIs).
+
+    # The distance from the first block in the chain (genesis block has height 0).
+    attr_accessor :height
+
+    # The number of blocks that have been processed since the previous block (including the block itself).
+    attr_accessor :confirmations
+
+    attr_accessor :my_name
+
+    def self.genesis_mainnet
+      self.new(
+        version:             1,
+        previous_block_hash: ZERO_HASH256,
+        merkle_root:         BTC::Data.data_from_hex("3ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a"),
+        timestamp:           1231006505,
+        bits:                0x1d00ffff,
+        nonce:               0x7c2bac1d,
+        height:              0
+      )
+    end
+
+    def self.genesis_testnet
+      self.new(
+        version:             1,
+        previous_block_hash: ZERO_HASH256,
+        merkle_root:         BTC::Data.data_from_hex("3ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a"),
+        timestamp:           1296688602,
+        bits:                0x1d00ffff,
+        nonce:               0x18aea41a,
+        height:              0
+      )
+    end
+
+    def self.with_data(data)
+      raise ArgumentError, "Use #{self}.new(data: ...) instead"
+    end
+
+    def self.with_stream(stream)
+      raise ArgumentError, "Use #{self}.new(stream: ...) instead"
+    end
+
+    def initialize(data: nil,
+                   stream: nil,
+                   version: CURRENT_VERSION,
+                   previous_block_hash: nil,
+                   previous_block_id: nil,
+                   merkle_root: nil,
+                   timestamp: 0,
+                   time: nil,
+                   bits: 0,
+                   nonce: 0,
+
+                   # optional attributes
+                   height: nil,
+                   confirmations: nil)
+
+      if stream || data
+        init_with_stream(stream || StringIO.new(data))
+      else
+        @version = version || CURRENT_VERSION
+        @previous_block_hash = previous_block_hash || ZERO_HASH256
+        @previous_block_hash = BTC.hash_from_id(previous_block_id) if previous_block_id
+        @merkle_root = merkle_root || ZERO_HASH256
+        @timestamp   = timestamp   || 0
+        @timestamp   = time.to_i if time
+        @bits        = bits        || 0
+        @nonce       = nonce       || 0
+      end
+
+      @height = height
+      @confirmations = confirmations
+    end
+
+    def init_with_stream(stream)
+      raise ArgumentError, "Stream is missing" if !stream
+      if stream.eof?
+        raise ArgumentError, "Can't parse block header from stream because it is already closed."
+      end
+
+      if !(version = BTC::WireFormat.read_int32le(stream: stream).first)
+        raise ArgumentError, "Failed to read block version prefix from the stream."
+      end
+
+      if !(prevhash = stream.read(32)) || prevhash.bytesize != 32
+        raise ArgumentError, "Failed to read 32-byte previous_block_hash from the stream."
+      end
+
+      if !(mrklroot = stream.read(32)) || mrklroot.bytesize != 32
+        raise ArgumentError, "Failed to read 32-byte block merkle_root from the stream."
+      end
+
+      if !(timestamp = BTC::WireFormat.read_uint32le(stream: stream).first)
+        raise ArgumentError, "Failed to read 32-byte block timestamp from the stream."
+      end
+
+      if !(bits = BTC::WireFormat.read_uint32le(stream: stream).first)
+        raise ArgumentError, "Failed to read 32-byte proof-of-work bits from the stream."
+      end
+
+      if !(nonce = BTC::WireFormat.read_uint32le(stream: stream).first)
+        raise ArgumentError, "Failed to read 32-byte nonce from the stream."
+      end
+
+      @version = version
+      @previous_block_hash = prevhash
+      @merkle_root = mrklroot
+      @timestamp = timestamp
+      @bits = bits
+      @nonce = nonce
+    end
+
+    def block_hash
+      BTC.hash256(self.header_data)
+    end
+
+    def block_id
+      BTC.id_from_hash(self.block_hash)
+    end
+
+    def previous_block_id
+      BTC.id_from_hash(self.previous_block_hash)
+    end
+
+    def previous_block_id=(block_id)
+      self.previous_block_hash = BTC.hash_from_id(block_id)
+    end
+
+    def time
+      Time.at(self.timestamp).utc
+    end
+
+    def time=(time)
+      self.timestamp = time.to_i
+    end
+
+    def data
+      header_data
+    end
+
+    def header_data # so that in subclass Block we don't hash the entire block
+      data = "".b
+      data << BTC::WireFormat.encode_int32le(self.version)
+      data << self.previous_block_hash
+      data << self.merkle_root
+      data << BTC::WireFormat.encode_uint32le(self.timestamp)
+      data << BTC::WireFormat.encode_uint32le(self.bits)
+      data << BTC::WireFormat.encode_uint32le(self.nonce)
+      data
+    end
+
+    def ==(other)
+                  @version == other.version &&
+      @previous_block_hash == other.previous_block_hash &&
+              @merkle_root == other.merkle_root &&
+                @timestamp == other.timestamp &&
+                     @bits == other.bits &&
+                    @nonce == other.nonce
+    end
+    alias_method :eql?, :==
+
+    def dup
+      self.class.new(
+        version:             self.version,
+        previous_block_hash: self.previous_block_hash,
+        merkle_root:         self.merkle_root,
+        timestamp:           self.timestamp,
+        bits:                self.bits,
+        nonce:               self.nonce,
+        height:              self.height,
+        confirmations:       self.confirmations)
+    end
+
+    def inspect
+      %{#<#{self.class.name}:#{self.block_id[0,24]}} +
+      %{ ver:#{self.version}} +
+      %{ prev:#{self.previous_block_id[0,24]}} +
+      %{ merkle_root:#{BTC.id_from_hash(self.merkle_root)[0,16]}} +
+      %{ timestamp:#{self.timestamp}} +
+      %{ bits:0x#{self.bits.to_s(16)}} +
+      %{ nonce:0x#{self.nonce.to_s(16)}} +
+      %{>}
+    end
+
+  end
+end

data/lib/btcruby/constants.rb

@@ -0,0 +1,59 @@
+module BTC
+
+  # Satoshi is the smallest unit representable in Bitcoin transactions.
+  SATOSHI = 1
+
+  # 100 mln satoshis is one Bitcoin
+  COIN = 100_000_000
+
+  # 1 bit is 100 satoshis (1 millionth of a bitcoin)
+  BIT  = 100
+
+  # Network Rules (changing these will result in incompatibility with other nodes)
+
+  # The maximum allowed size for a serialized block, in bytes
+  MAX_BLOCK_SIZE = 1000000
+
+  # The maximum allowed number of signature check operations in a block
+  MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50
+
+  # No amount larger than this (in satoshis) is valid
+  MAX_MONEY = 21_000_000 * COIN
+
+  # Coinbase transaction outputs can only be spent after this number of new blocks
+  COINBASE_MATURITY = 100
+
+  # Threshold for BTC::Transaction#lock_time: below this value it is interpreted
+  # as a block number, otherwise as UNIX timestamp.
+  LOCKTIME_THRESHOLD = 500000000 # Tue Nov  5 00:53:20 1985 UTC (max block number is in year ≈11521)
+
+  # P2SH BIP16 didn't become active until Apr 1 2012.
+  # All txs before this timestamp should not be verified with P2SH rule.
+  BIP16_TIMESTAMP = 1333238400
+
+  # Scripts longer than 10000 bytes are invalid.
+  MAX_SCRIPT_SIZE = 10000
+
+  # Maximum number of bytes per "pushdata" operation
+  MAX_SCRIPT_ELEMENT_SIZE = 520 # bytes
+
+  # Number of public keys allowed for OP_CHECKMULTISIG
+  MAX_KEYS_FOR_CHECKMULTISIG = 20
+
+  # Maximum number of operations allowed per script (excluding pushdata operations and OP_<N>)
+  # Multisig op additionally increases count by a number of pubkeys.
+  MAX_OPS_PER_SCRIPT = 201
+
+  # Soft Rules (can bend these without becoming incompatible with everyone)
+
+  # The maximum number of entries in an 'inv' protocol message
+  MAX_INV_SZ = 50000
+
+  # The maximum size for mined blocks
+  MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE / 2
+
+  # The maximum size for transactions we're willing to relay/mine
+  MAX_STANDARD_TX_SIZE = MAX_BLOCK_SIZE_GEN / 5
+
+
+end

data/lib/btcruby/currency_formatter.rb

@@ -0,0 +1,64 @@
+require 'bigdecimal'
+
+module BTC
+  # Modeled after NSNumberFormatter in Cocoa, this class allows to convert
+  # bitcoin amounts to their string representations and vice versa.
+  class CurrencyFormatter
+
+    STYLE_BTC       = :btc       # 1.0 is 1 btc (100_000_000 satoshis)
+    STYLE_BTC_LONG  = :btc_long  # 1.00000000 is 1 btc (100_000_000 satoshis)
+    STYLE_MBTC      = :mbtc      # 1.0 is 0.001 btc (100_000 satoshis)
+    STYLE_BIT       = :bit       # 1.0 is 0.000001 btc (100 satoshis)
+    STYLE_SATOSHIS  = :satoshis  # 1.0 is 0.00000001 btc (1 satoshi)
+
+    attr_accessor :style
+    attr_accessor :show_suffix
+
+    # Returns a singleton formatter for BTC values (1.0 is one bitcoin) without suffix.
+    def self.btc_formatter
+      @btc_formatter ||= self.new(style: STYLE_BTC)
+    end
+
+    # Returns a singleton formatter for BTC values where there are always 8 places
+    # after decimal point (e.g. "42.00000000").
+    def self.btc_long_formatter
+      @btc_long_formatter ||= self.new(style: STYLE_BTC_LONG)
+    end
+
+    def initialize(style: :btc, show_suffix: false)
+      @style = style
+      @show_suffix = show_suffix
+    end
+
+    # Returns formatted string for an amount in satoshis.
+    def string_from_number(number)
+      if @style == :btc
+        number = number.to_i
+        return "#{number / BTC::COIN}.#{'%08d' % [number % BTC::COIN]}".gsub(/0+$/,"").gsub(/\.$/,".0")
+      elsif @style == :btc_long
+        number = number.to_i
+        return "#{number / BTC::COIN}.#{'%08d' % [number % BTC::COIN]}"
+      else
+        # TODO: parse other styles
+        raise "Not implemented"
+      end
+    end
+
+    # Returns amount of satoshis parsed from a formatted string according to style attribute.
+    def number_from_string(string)
+      bd = BigDecimal.new(string)
+      if @style == :btc || @style == :btc_long
+        return (bd * BTC::COIN).to_i
+      else
+        # TODO: support other styles
+        raise "Not Implemented"
+      end
+    end
+
+    # Creates a copy if you want to customize another formatter (e.g. a global singleton like btc_formatter)
+    def dup
+      self.class.new(style: @style, show_suffix: @show_suffix)
+    end
+
+  end # BitcoinFormatter
+end # BTC

data/lib/btcruby/data.rb

@@ -0,0 +1,98 @@
+require 'securerandom'
+
+module BTC
+  module Data
+    extend self
+    include HashFunctions # obsolete, left for backwards compatibility
+
+    HEX_PACK_CODE = "H*".freeze
+    BYTE_PACK_CODE = "C*".freeze
+
+    # Generates a secure random number of a given length
+    def random_data(length = 32)
+      SecureRandom.random_bytes(length)
+    end
+
+    # Converts hexadecimal string to a binary data string.
+    def data_from_hex(hex_string)
+      raise ArgumentError, "Hex string is missing" if !hex_string
+      hex_string = hex_string.strip
+      data = [hex_string].pack(HEX_PACK_CODE)
+      if hex_from_data(data) != hex_string.downcase # invalid hex string was detected
+        raise FormatError, "Hex string is invalid: #{hex_string.inspect}"
+      end
+      return data
+    end
+
+    # Converts binary string to lowercase hexadecimal representation.
+    def hex_from_data(data)
+      raise ArgumentError, "Data is missing" if !data
+      return data.unpack(HEX_PACK_CODE).first
+    end
+
+    # Converts a binary string to an array of bytes (list of integers).
+    # Returns a much more efficient slice of bytes if offset/limit or
+    # range are specified. That is, avoids converting the entire buffer to byte array.
+    #
+    # Note 1: if range is specified, it takes precedence over offset/limit.
+    #
+    # Note 2: byteslice(...).bytes is less efficient as it creates
+    #         an intermediate shorter string.
+    #
+    def bytes_from_data(data, offset: 0, limit: nil, range: nil)
+      raise ArgumentError, "Data is missing" if !data
+      if offset == 0 && limit == nil && range == nil
+        return data.bytes
+      end
+      if range
+        offset = range.begin
+        limit  = range.size
+      end
+      bytes = []
+      data.each_byte do |byte|
+        if offset > 0
+          offset -= 1
+        else
+          if !limit || limit > 0
+            bytes << byte
+            limit -= 1 if limit
+          else
+            break
+          end
+        end
+      end
+      bytes
+    end
+
+    # Converts binary string to an array of bytes (list of integers).
+    def data_from_bytes(bytes)
+      raise ArgumentError, "Bytes are missing" if !bytes
+      bytes.pack(BYTE_PACK_CODE)
+    end
+
+    # Returns string as-is if it is ASCII-compatible
+    # (that is, if you are interested in 7-bit characters exposed as #bytes).
+    # If it is not, attempts to transcode to UTF8 replacing invalid characters if there are any.
+    # If options are not specified, uses safe default that replaces unknown characters with standard character.
+    # If options are specified, they are used as-is for String#encode method.
+    def ensure_ascii_compatible_encoding(string, options = nil)
+      if string.encoding.ascii_compatible?
+        string
+      else
+        string.encode(Encoding::UTF_8, options || {:invalid => :replace, :undef => :replace})
+      end
+    end
+
+    # Returns string as-is if it is already encoded in binary encoding (aka BINARY or ASCII-8BIT).
+    # If it is not, converts to binary by calling stdlib's method #b.
+    def ensure_binary_encoding(string)
+      raise ArgumentError, "String is missing" if !string
+      if string.encoding == Encoding::BINARY
+        string
+      else
+        string.b
+      end
+    end
+
+  end
+end