Module: Bitcoin::Protocol

Defined in:
lib/bitcoin/protocol.rb,
lib/bitcoin/protocol/tx.rb,
lib/bitcoin/protocol/txin.rb,
lib/bitcoin/protocol/block.rb,
lib/bitcoin/protocol/txout.rb,
lib/bitcoin/protocol/parser.rb,
lib/bitcoin/protocol/reject.rb,
lib/bitcoin/protocol/address.rb,
lib/bitcoin/protocol/aux_pow.rb,
lib/bitcoin/protocol/handler.rb,
lib/bitcoin/protocol/version.rb,
lib/bitcoin/protocol/script_witness.rb,
lib/bitcoin/protocol/partial_merkle_tree.rb

Defined Under Namespace

Classes: Addr, AuxPow, Block, Handler, Parser, PartialMerkleTree, Reject, ScriptWitness, Tx, TxIn, TxOut, Version

Constant Summary collapse

MAX_INV_SZ =

bitcoin/src/main.h

50000
BIP0031_VERSION =

BIP 0031, pong message, is enabled for all versions AFTER this one

60000
Uniq = 
rand(0xffffffffffffffff)
BINARY = 
Encoding.find('ASCII-8BIT')
TypeLookup = 

      
        
DEFAULT_STOP_HASH =
          
        

        
"00"*32

      
    

  







  
    

      Class Method Summary
      collapse
    


    
  



  

    
Class Method Details


    
      

  

  
    .getblocks_pkt(version, locator_hashes, stop_hash = DEFAULT_STOP_HASH)  ⇒ Object 
  

  

  




  

    
      


174
175
176

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

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

    		
  





    
      

  

  
    .getdata_pkt(type, hashes)  ⇒ Object 
  

  

  




  

    
      


151
152
153
154
155

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

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

    		
  





    
      

  

  
    .getheaders_pkt(version, locator_hashes, stop_hash = DEFAULT_STOP_HASH)  ⇒ Object 
  

  

  




  

    
      


178
179
180

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

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

    		
  





    
      

  

  
    .headers_pkt(version, blocks)  ⇒ Object 
  

  

  




  

    
      


182
183
184

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

def self.headers_pkt(version, blocks)
  pkt "headers", [pack_var_int(blocks.size), blocks.map{|block| block.block_header}.join].join
end

    		
  





    
      

  

  
    .inv_pkt(type, hashes)  ⇒ Object 
  

  

  




  

    
      


157
158
159
160
161

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

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

    		
  





    
      

  

  
    .locator_payload(version, locator_hashes, stop_hash)  ⇒ Object 
  

  

  




  

    
      


165
166
167
168
169
170
171
172

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

def self.locator_payload(version, locator_hashes, stop_hash)
  [
    [version].pack("V"),
    pack_var_int(locator_hashes.size),
    locator_hashes.map{|l| l.htb_reverse }.join,
    stop_hash.htb_reverse
  ].join
end

    		
  





    
      

  

  
    .pack_boolean(b)  ⇒ Object 
  

  

  




  

    
      


105
106
107

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

def self.pack_boolean(b)
  (b == true) ? [0xFF].pack("C") : [0x00].pack("C")
end

    		
  





    
      

  

  
    .pack_var_int(i)  ⇒ Object 
  

  

  




  

    
      


53
54
55
56
57
58
59
60

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

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 
  

  

  




  

    
      


72
73
74

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

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

    		
  





    
      

  

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

  

  




  

    
      


137
138
139

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

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

    		
  





    
      

  

  
    .pkt(command, payload)  ⇒ Object 
  

  

  




  

    
      


111
112
113
114
115
116
117
118
119
120
121

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

def self.pkt(command, payload)
  cmd      = command.ljust(12, "\x00")[0...12]
  length   = [payload.bytesize].pack("V")
  checksum = Digest::SHA256.digest(Digest::SHA256.digest(payload))[0...4]
  pkt      = "".force_encoding(BINARY)
  pkt << Bitcoin.network[:magic_head].force_encoding(BINARY)
  pkt << cmd.force_encoding(BINARY)
  pkt << length
  pkt << checksum
  pkt << payload.dup.force_encoding(BINARY)
end

    		
  





    
      

  

  
    .pong_pkt(nonce)  ⇒ Object 
  

  

  




  

    
      


141
142
143

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

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

    		
  





    
      

  

  
    .read_binary_file(path)  ⇒ Object 
  

  

  




  

    
      


186
187
188

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

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

    		
  





    
      

  

  
    .unpack_boolean(payload)  ⇒ Object 
  

  

  




  

    
      


100
101
102
103

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

def self.unpack_boolean(payload)
  bdata, payload = payload.unpack("Ca*")
  [ (bdata == 0 ? false : true), payload ]
end

    		
  





    
      

  

  
    .unpack_var_int(payload)  ⇒ Object 
  

  

  




  

    

var_int refers to en.bitcoin.it/wiki/Protocol_specification#Variable_length_integer and is what Satoshi called “CompactSize” BitcoinQT has later added even more compact format called CVarInt to use in its local block storage. CVarInt is not implemented here.



  





  



  

    
      


34
35
36
37
38
39
40
41

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

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>



  





  



  

    
      


88
89
90
91
92
93
94
95
96
97
98

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

def self.unpack_var_int_array(payload) # unpacks set<int>
  buf = StringIO.new(payload)
  size =  unpack_var_int_from_io(buf)
  return [nil, buf.read] if size == 0
  ints = []
  size.times{
    break if buf.eof?
    ints << unpack_var_int_from_io(buf)
  }
  [ints, buf.read]
end

    		
  





    
      

  

  
    .unpack_var_int_from_io(io)  ⇒ Object 
  

  

  




  

    
      


43
44
45
46
47
48
49
50
51

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

def self.unpack_var_int_from_io(io)
  uchar = io.read(1).unpack("C")[0]
  case uchar
  when 0xfd; io.read(2).unpack("v")[0]
  when 0xfe; io.read(4).unpack("V")[0]
  when 0xff; io.read(8).unpack("Q")[0]
  else;      uchar
  end
end

    		
  





    
      

  

  
    .unpack_var_string(payload)  ⇒ Object 
  

  

  




  

    
      


62
63
64
65

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

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

    		
  





    
      

  

  
    .unpack_var_string_array(payload)  ⇒ Object 
  

  

  




  

    

unpacks set<string>



  





  



  

    
      


76
77
78
79
80
81
82
83
84
85
86

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

def self.unpack_var_string_array(payload) # unpacks set<string>
  buf = StringIO.new(payload)
  size = unpack_var_int_from_io(buf)
  return [nil, buf.read] if size == 0
  strings = []
  size.times{
    break if buf.eof?
    strings << unpack_var_string_from_io(buf)
  }
  [strings, buf.read]
end

    		
  





    
      

  

  
    .unpack_var_string_from_io(buf)  ⇒ Object 
  

  

  




  

    
      


67
68
69
70

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

def self.unpack_var_string_from_io(buf)
  size = unpack_var_int_from_io(buf)
  size > 0 ? buf.read(size) : nil
end

    		
  





    
      

  

  
    .verack_pkt  ⇒ Object 
  

  

  




  

    
      


145
146
147

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

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 
  

  

  




  

    
      


123
124
125
126
127
128
129
130
131
132
133
134
135

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

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