Module: Bitcoin::Protocol

Defined in:
lib/bitcoin/protocol.rb,
lib/bitcoin/protocol/tx.rb,
lib/bitcoin/protocol/txin.rb,
lib/bitcoin/protocol/alert.rb,
lib/bitcoin/protocol/block.rb,
lib/bitcoin/protocol/txout.rb,
lib/bitcoin/protocol/parser.rb,
lib/bitcoin/protocol/address.rb,
lib/bitcoin/protocol/handler.rb,
lib/bitcoin/protocol/version.rb

Defined Under Namespace

Classes: Addr, Alert, Block, Handler, Parser, Tx, TxIn, TxOut, Version

Constant Summary collapse

VERSION = 
60001
DNS_Seed = 
[ "bitseed.xf2.org", "bitseed.bitcoin.org.uk" ]
Uniq = 
rand(0xffffffffffffffff)
TypeLookup = 


DEFAULT_STOP_HASH =



"00"*32





Class Method Summary
collapse






Class Method Details





.getblocks_pkt(locator_hashes, stop_hash = DEFAULT_STOP_HASH) ⇒ Object










123
124
125




# File 'lib/bitcoin/protocol.rb', line 123

def self.getblocks_pkt(locator_hashes, stop_hash=DEFAULT_STOP_HASH)
  pkt "getblocks",  locator_payload(locator_hashes, stop_hash)
end












.getdata_pkt(type, hashes) ⇒ Object










100
101
102
103
104




# File 'lib/bitcoin/protocol.rb', line 100

def self.getdata_pkt(type, hashes)
  return if hashes.size >= 256
  t = [ TypeLookup[type] ].pack("I")
  pkt("getdata", [hashes.size].pack("C") + hashes.map{|hash| t + hash[0..32].reverse }.join)
end












.getheaders_pkt(locator_hashes, stop_hash = DEFAULT_STOP_HASH) ⇒ Object










127
128
129




# File 'lib/bitcoin/protocol.rb', line 127

def self.getheaders_pkt(locator_hashes, stop_hash=DEFAULT_STOP_HASH)
  pkt "getheaders", locator_payload(locator_hashes, stop_hash)
end












.htb(h) ⇒ Object










132




# File 'lib/bitcoin/protocol.rb', line 132

def self.htb(h); [h].pack("H*"); end












.hth(h) ⇒ Object










131




# File 'lib/bitcoin/protocol.rb', line 131

def self.hth(h); h.unpack("H*")[0]; end












.inv_pkt(type, hashes) ⇒ Object










106
107
108
109
110




# File 'lib/bitcoin/protocol.rb', line 106

def self.inv_pkt(type, hashes)
  return if hashes.size >= 256
  t = [ TypeLookup[type] ].pack("I")
  pkt("inv", [hashes.size].pack("C") + hashes.map{|hash| t + hash[0..32].reverse }.join)
end












.locator_payload(locator_hashes, stop_hash) ⇒ Object










114
115
116
117
118
119
120
121




# File 'lib/bitcoin/protocol.rb', line 114

def self.locator_payload(locator_hashes, stop_hash)
  payload = [
    Bitcoin.network[:magic_head],
    pack_var_int(locator_hashes.size),
    locator_hashes.map{|l| htb(l).reverse }.join,
    htb(stop_hash).reverse
  ].join
end












.pack_var_int(i) ⇒ Object










33
34
35
36
37
38
39
40




# File 'lib/bitcoin/protocol.rb', line 33

def self.pack_var_int(i)
  if    i <  0xfd;                [      i].pack("C")
  elsif i <= 0xffff;              [0xfd, i].pack("Cv")
  elsif i <= 0xffffffff;          [0xfe, i].pack("CV")
  elsif i <= 0xffffffffffffffff;  [0xff, i].pack("CQ")
  else raise "int(#{i}) too large!"
  end
end












.pack_var_string(payload) ⇒ Object










47
48
49




# File 'lib/bitcoin/protocol.rb', line 47

def self.pack_var_string(payload)
  pack_var_int(payload.bytesize) + payload
end












.ping_pkt(nonce = rand(0xffffffff)) ⇒ Object










86
87
88




# File 'lib/bitcoin/protocol.rb', line 86

def self.ping_pkt(nonce = rand(0xffffffff))
  pkt("ping", [nonce].pack("Q"))
end












.pkt(command, payload) ⇒ Object










64
65
66
67
68
69
70




# File 'lib/bitcoin/protocol.rb', line 64

def self.pkt(command, payload)
  cmd      = command.ljust(12, "\x00")[0...12]
  length   = [payload.bytesize].pack("I")
  checksum = Digest::SHA256.digest(Digest::SHA256.digest(payload))[0...4]

  [Bitcoin.network[:magic_head], cmd, length, checksum, payload].join
end












.pong_pkt(nonce) ⇒ Object










90
91
92




# File 'lib/bitcoin/protocol.rb', line 90

def self.pong_pkt(nonce)
  pkt("pong", [nonce].pack("Q"))
end












.read_binary_file(path) ⇒ Object










134
135
136




# File 'lib/bitcoin/protocol.rb', line 134

def self.read_binary_file(path)
  File.open(path, 'rb'){|f| f.read }
end












.unpack_var_int(payload) ⇒ Object










24
25
26
27
28
29
30
31




# File 'lib/bitcoin/protocol.rb', line 24

def self.unpack_var_int(payload)
  case payload.unpack("C")[0] # TODO add test cases
  when 0xfd; payload.unpack("xva*")
  when 0xfe; payload.unpack("xVa*")
  when 0xff; payload.unpack("xQa*") # TODO add little-endian version of Q
  else;      payload.unpack("Ca*")
  end
end












.unpack_var_int_array(payload) ⇒ Object







unpacks set<int>















57
58
59
60
61




# File 'lib/bitcoin/protocol.rb', line 57

def self.unpack_var_int_array(payload) # unpacks set<int>
  size, payload = unpack_var_int(payload)
  return [nil, payload] if size == 0
  [(0...size).map{ i, payload = unpack_var_int(payload); i }, payload]
end












.unpack_var_string(payload) ⇒ Object










42
43
44
45




# File 'lib/bitcoin/protocol.rb', line 42

def self.unpack_var_string(payload)
  size, payload = unpack_var_int(payload)
  size > 0 ? (string, payload = payload.unpack("a#{size}a*")) : [nil, payload]
end












.unpack_var_string_array(payload) ⇒ Object







unpacks set<string>















51
52
53
54
55




# File 'lib/bitcoin/protocol.rb', line 51

def self.unpack_var_string_array(payload) # unpacks set<string>
  size, payload = unpack_var_int(payload)
  return [nil, payload] if size == 0
  [(0...size).map{ s, payload = unpack_var_string(payload); s }, payload]
end












.verack_pkt ⇒ Object










94
95
96




# File 'lib/bitcoin/protocol.rb', line 94

def self.verack_pkt
  pkt("verack", "")
end












.version_pkt(from_id, from = nil, to = nil, last_block = nil, time = nil, user_agent = nil, version = nil) ⇒ Object










72
73
74
75
76
77
78
79
80
81
82
83
84




# File 'lib/bitcoin/protocol.rb', line 72

def self.version_pkt(from_id, from=nil, to=nil, last_block=nil, time=nil, user_agent=nil, version=nil)
  opts = if from_id.is_a?(Hash)
    from_id
  else
    STDERR.puts "Bitcoin::Protocol.version_pkt - API deprecated. please change it soon.."
    {
      :nonce => from_id, :from => from, :to => to, :last_block => last_block,
      :time => time, :user_agent => user_agent, :version => version
    }
  end
  version = Protocol::Version.new(opts)
  version.to_pkt
end