bitcoinrb 0.0.1

data/lib/bitcoin/nodes.rb

@@ -0,0 +1,5 @@
+module Bitcoin
+  module Nodes
+    autoload :SPV, 'bitcoin/nodes/spv'
+  end
+end

data/lib/bitcoin/nodes/spv.rb

@@ -0,0 +1,13 @@
+module Bitcoin
+  module Nodes
+
+    # SPV module
+    module SPV
+
+      autoload :CLI, 'bitcoin/nodes/spv/cli'
+      autoload :Daemon, 'bitcoin/nodes/spv/daemon'
+
+    end
+
+  end
+end

data/lib/bitcoin/nodes/spv/cli.rb

@@ -0,0 +1,12 @@
+require 'thor'
+
+module Bitcoin
+  module Nodes
+    module SPV
+
+      class CLI < Thor
+
+      end
+    end
+  end
+end

data/lib/bitcoin/nodes/spv/daemon.rb

@@ -0,0 +1,21 @@
+require 'daemon_spawn'
+module Bitcoin
+  module Nodes
+    module SPV
+
+      # SPV node daemon
+      class Daemon < DaemonSpawn::Base
+
+        def start(args)
+
+        end
+
+        def stop
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bitcoin/opcodes.rb

@@ -0,0 +1,172 @@
+module Bitcoin
+
+  # https://bitcoin.org/en/developer-reference#opcodes
+  module Opcodes
+
+    module_function
+
+    # https://en.bitcoin.it/wiki/Script#Constants
+    OP_0 = 0x00
+    OP_1 = 0x51
+    OP_2 = 0x52
+    OP_3 = 0x53
+    OP_4 = 0x54
+    OP_5 = 0x55
+    OP_6 = 0x56
+    OP_7 = 0x57
+    OP_8 = 0x58
+    OP_9 = 0x59
+    OP_10 = 0x5a
+    OP_11 = 0x5b
+    OP_12 = 0x5c
+    OP_13 = 0x5d
+    OP_14 = 0x5e
+    OP_15 = 0x5f
+    OP_16 = 0x60
+
+    OP_PUSHDATA1 = 0x4c
+    OP_PUSHDATA2 = 0x4d
+    OP_PUSHDATA4 = 0x4e
+    OP_1NEGATE = 0x4f
+
+    # https://en.bitcoin.it/wiki/Script#Flow_control
+    OP_NOP = 0x61
+    OP_IF = 0x63
+    OP_NOTIF = 0x64
+    OP_ELSE = 0x67
+    OP_ENDIF = 0x68
+    OP_VERIFY = 0x69
+    OP_RETURN = 0x6a
+
+    # https://en.bitcoin.it/wiki/Script#Stack
+    OP_TOALTSTACK = 0x6b
+    OP_FROMALTSTACK = 0x6c
+    OP_IFDUP = 0x73
+    OP_DEPTH = 0x74
+    OP_DROP = 0x75
+    OP_DUP = 0x76
+    OP_NIP = 0x77
+    OP_OVER = 0x78
+    OP_PICK = 0x79
+    OP_ROLL = 0x7a
+    OP_ROT = 0x7b
+    OP_SWAP = 0x7c
+    OP_TUCK = 0x7d
+    OP_2DROP = 0x6d
+    OP_2DUP = 0x6e
+    OP_3DUP = 0x6f
+    OP_2OVER = 0x70
+    OP_2ROT = 0x71
+    OP_2SWAP = 0x72
+
+    # https://en.bitcoin.it/wiki/Script#Splice
+    OP_CAT = 0x7e # disabled
+    OP_SUBSTR = 0x7f # disabled
+    OP_LEFT = 0x80 # disabled
+    OP_RIGHT = 0x81 # disabled
+    OP_SIZE = 0x82
+
+    # https://en.bitcoin.it/wiki/Script#Bitwise_logic
+    OP_INVERT = 0x83 # disabled
+    OP_AND = 0x84 # disabled
+    OP_OR = 0x85 # disabled
+    OP_XOR = 0x86 # disabled
+    OP_EQUAL = 0x87
+    OP_EQUALVERIFY = 0x88
+
+    # https://en.bitcoin.it/wiki/Script#Arithmetic
+    OP_1ADD = 0x8b
+    OP_1SUB = 0x8c
+    OP_2MUL = 0x8d # disabled
+    OP_2DIV = 0x8e # disabled
+    OP_NEGATE = 0x8f
+    OP_ABS = 0x90
+    OP_NOT = 0x91
+    OP_0NOTEQUAL = 0x92
+    OP_ADD = 0x93
+    OP_SUB = 0x94
+    OP_MUL = 0x95 # disabled
+    OP_DIV = 0x96 # disabled
+    OP_MOD = 0x97 # disabled
+    OP_LSHIFT = 0x98 # disabled
+    OP_RSHIFT = 0x99 # disabled
+    OP_BOOLAND = 0x9a
+    OP_BOOLOR = 0x9b
+    OP_NUMEQUAL = 0x9c
+    OP_NUMEQUALVERIFY = 0x9d
+    OP_NUMNOTEQUAL = 0x9e
+    OP_LESSTHAN = 0x9f
+    OP_GREATERTHAN = 0xa0
+    OP_LESSTHANOREQUAL = 0xa1
+    OP_GREATERTHANOREQUAL = 0xa2
+    OP_MIN = 0xa3
+    OP_MAX = 0xa4
+    OP_WITHIN = 0xa5
+
+    # https://en.bitcoin.it/wiki/Script#Crypto
+    OP_RIPEMD160 = 0xa6
+    OP_SHA1 = 0xa7
+    OP_SHA256 = 0xa8
+    OP_HASH160 = 0xa9
+    OP_HASH256 = 0xaa
+    OP_CODESEPARATOR = 0xab
+    OP_CHECKSIG = 0xac
+    OP_CHECKSIGVERIFY= 0xad
+    OP_CHECKMULTISIG = 0xae
+    OP_CHECKMULTISIGVERIFY = 0xaf
+
+    # https://en.bitcoin.it/wiki/Script#Locktime
+    OP_CHECKLOCKTIMEVERIFY = OP_NOP2 = 0xb1
+    OP_CHECKSEQUENCEVERIFY = OP_NOP3 = 0xb2
+
+    # https://en.bitcoin.it/wiki/Script#Reserved_words
+    OP_RESERVED = 0x50
+    OP_VER = 0x62
+    OP_VERIF = 0x65
+    OP_VERNOTIF = 0x66
+    OP_RESERVED1= 0x89
+    OP_RESERVED2 = 0x8a
+
+    OP_NOP1 = 0xb0
+    OP_NOP4 = 0xb3
+    OP_NOP5 = 0xb4
+    OP_NOP6 = 0xb5
+    OP_NOP7 = 0xb6
+    OP_NOP8 = 0xb7
+    OP_NOP9 = 0xb8
+    OP_NOP10 = 0xb9
+
+    OPCODES_MAP = Hash[*constants.grep(/^OP_/).map { |c| [const_get(c), c.to_s] }.flatten]
+    NAME_MAP = Hash[*constants.grep(/^OP_/).map { |c| [c.to_s, const_get(c)] }.flatten]
+
+    def opcode_to_name(opcode)
+      return OPCODES_MAP[opcode].delete('OP_') if opcode == OP_0 || (opcode <= OP_16 && opcode >= OP_1)
+      OPCODES_MAP[opcode]
+    end
+
+    def name_to_opcode(name)
+      return NAME_MAP['OP_' + name] if name =~ /^\d/ && name.to_i < 17 && name.to_i > -1
+      NAME_MAP[name]
+    end
+
+    # whether opcode is predefined opcode
+    def defined?(opcode)
+      !opcode_to_name(opcode).nil?
+    end
+
+    def small_int_to_opcode(int)
+      return OP_0 if int == 0
+      return OP_1NEGATE if int == -1
+      return OP_1 + (int - 1) if int >= 1 && int <= 16
+      nil
+    end
+
+    def opcode_to_small_int(opcode)
+      return 0 if opcode == ''.b || opcode == OP_0
+      return -1 if opcode == OP_1NEGATE
+      return opcode - (OP_1 - 1) if opcode >= OP_1 && opcode <= OP_16
+      nil
+    end
+
+  end
+end

data/lib/bitcoin/out_point.rb

@@ -0,0 +1,31 @@
+module Bitcoin
+
+  # outpoint class
+  class OutPoint
+
+    COINBASE_HASH = '0000000000000000000000000000000000000000000000000000000000000000'
+    COINBASE_INDEX = 4294967295
+
+    attr_reader :hash
+    attr_reader :index
+
+    def initialize(hash, index)
+      @hash = hash
+      @index = index
+    end
+
+    def coinbase?
+      hash == COINBASE_HASH && index == COINBASE_INDEX
+    end
+
+    def to_payload
+      [hash.htb.reverse, index].pack('a32V')
+    end
+
+    def self.create_coinbase_outpoint
+      new(COINBASE_HASH, COINBASE_INDEX)
+    end
+
+  end
+
+end

data/lib/bitcoin/script/script.rb

@@ -0,0 +1,347 @@
+module Bitcoin
+
+  # bitcoin script
+  class Script
+    include Bitcoin::Opcodes
+
+    # witness version
+    WITNESS_VERSION = 0x00
+
+    # Maximum script length in bytes
+    MAX_SCRIPT_SIZE = 10000
+
+    # Maximum number of public keys per multisig
+    MAX_PUBKEYS_PER_MULTISIG = 20
+
+    # Maximum number of non-push operations per script
+    MAX_OPS_PER_SCRIPT = 201
+
+    # Maximum number of bytes pushable to the stack
+    MAX_SCRIPT_ELEMENT_SIZE = 520
+
+    # Maximum number of size in the stack
+    MAX_STACK_SIZE = 1000
+
+    # Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
+    LOCKTIME_THRESHOLD = 500000000
+
+    # Signature hash types/flags
+    SIGHASH_TYPE = { all: 1, none: 2, single: 3, anyonecanpay: 128 }
+
+    # Maximum number length in bytes
+    DEFAULT_MAX_NUM_SIZE = 4
+
+    attr_accessor :chunks
+
+    def initialize
+      @chunks = []
+    end
+
+    # generate P2PKH script
+    def self.to_p2pkh(pubkey_hash)
+      new << OP_DUP << OP_HASH160 << pubkey_hash << OP_EQUALVERIFY << OP_CHECKSIG
+    end
+
+    # generate P2WPKH script
+    def self.to_p2wpkh(pubkey_hash)
+      new << WITNESS_VERSION << pubkey_hash
+    end
+
+    # generate m of n multisig p2sh script
+    # @param [String] m the number of signatures required for multisig
+    # @param [Array] pubkeys array of public keys that compose multisig
+    # @return [Script, Script] first element is p2sh script, second one is redeem script.
+    def self.to_p2sh_multisig_script(m, pubkeys)
+      redeem_script = to_multisig_script(m, pubkeys)
+      p2sh_script = new << OP_HASH160 << redeem_script.to_hash160 << OP_EQUAL
+      [p2sh_script, redeem_script]
+    end
+
+    # generate m of n multisig script
+    # @param [String] m the number of signatures required for multisig
+    # @param [Array] pubkeys array of public keys that compose multisig
+    # @return [Script] multisig script.
+    def self.to_multisig_script(m, pubkeys)
+      new << m << pubkeys << pubkeys.size << OP_CHECKMULTISIG
+    end
+
+    # generate p2wsh script for +redeem_script+
+    # @param [Script] redeem_script target redeem script
+    # @param [Script] p2wsh script
+    def self.to_p2wsh(redeem_script)
+      new << WITNESS_VERSION << redeem_script.to_sha256
+    end
+
+    # generate script from string.
+    def self.from_string(string)
+      script = new
+      string.split(' ').each do |v|
+        opcode = Opcodes.name_to_opcode(v)
+        if opcode
+          script << (v =~ /^\d/ && Opcodes.small_int_to_opcode(v.ord) ? v.ord : opcode)
+        else
+          script << v
+        end
+      end
+      script
+    end
+
+    def self.parse_from_payload(payload)
+      s = new
+      buf = StringIO.new(payload)
+      until buf.eof?
+        opcode = buf.read(1)
+        if opcode.pushdata?
+          pushcode = opcode.ord
+          len = case pushcode
+                  when OP_PUSHDATA1
+                    buf.read(1).unpack('C').first
+                  when OP_PUSHDATA2
+                    buf.read(2).unpack('v').first
+                  when OP_PUSHDATA4
+                    buf.read(4).unpack('V').first
+                  else
+                    pushcode if pushcode < OP_PUSHDATA1
+                end
+          s << buf.read(len).bth if len
+        else
+          s << opcode.ord
+        end
+      end
+      s
+    end
+
+    def to_payload
+      chunks.join
+    end
+
+    def to_addr
+      return p2pkh_addr if p2pkh?
+      return p2wpkh_addr if p2wpkh?
+      return p2wsh_addr if p2wsh?
+      return p2sh_addr if p2sh?
+    end
+
+    # whether this script is a P2PKH format script.
+    def p2pkh?
+      return false unless chunks.size == 5
+      [OP_DUP, OP_HASH160, OP_EQUALVERIFY, OP_CHECKSIG] ==
+          (chunks[0..1]+ chunks[3..4]).map(&:ord) && chunks[2].bytesize == 21
+    end
+
+    # whether this script is a P2WPKH format script.
+    def p2wpkh?
+      return false unless chunks.size == 2
+      chunks[0].ord == WITNESS_VERSION && chunks[1].bytesize == 21
+    end
+
+    def p2wsh?
+      return false unless chunks.size == 2
+      chunks[0].ord == WITNESS_VERSION && chunks[1].bytesize == 33
+    end
+
+    def p2sh?
+      return false unless chunks.size == 3
+      OP_HASH160 == chunks[0].ord && OP_EQUAL == chunks[2].ord && chunks[1].bytesize == 21
+    end
+
+    # whether data push only script which dose not include other opcode
+    def data_only?
+      chunks.each do |c|
+        return false if !c.opcode.nil? && c.opcode > OP_16
+      end
+      true
+    end
+
+    # A witness program is any valid Script that consists of a 1-byte push opcode followed by a data push between 2 and 40 bytes.
+    def witness_program?
+      return false if size < 4 || size > 42 || chunks.size < 2
+      opcode = chunks[0].opcode
+      return false if opcode != OP_0 && (opcode < OP_1 || opcode > OP_16)
+      return false unless chunks[1].pushdata?
+      program_size = chunks[1].pushed_data.bytesize
+      program_size >= 2 && program_size <= 40
+    end
+
+    # get witness version and witness program
+    def witness_data
+      version = opcode_to_small_int(chunks[0].opcode)
+      program = chunks[1].pushed_data
+      [version, program]
+    end
+
+    # append object to payload
+    def <<(obj)
+      if obj.is_a?(Integer)
+        push_int(obj)
+      elsif obj.is_a?(String)
+        append_data(obj.b)
+      elsif obj.is_a?(Array)
+        obj.each { |o| self.<< o}
+        self
+      end
+    end
+
+    # push integer to stack.
+    def push_int(n)
+      begin
+        append_opcode(n)
+      rescue ArgumentError
+        append_data(Script.encode_number(n))
+      end
+      self
+    end
+
+    # append opcode to payload
+    # @param [Integer] opcode append opcode which defined by Bitcoin::Opcodes
+    # @return [Script] return self
+    def append_opcode(opcode)
+      opcode = Opcodes.small_int_to_opcode(opcode) if -1 <= opcode && opcode <= 16
+      raise ArgumentError, "specified invalid opcode #{opcode}." unless Opcodes.defined?(opcode)
+      chunks << opcode.chr
+      self
+    end
+
+    # append data to payload with pushdata opcode
+    # @param [String] data append data. this data is not binary
+    # @return [Script] return self
+    def append_data(data)
+      chunks << Bitcoin::Script.pack_pushdata(data.htb)
+      self
+    end
+
+    def to_s
+      chunks.map { |c|
+        if c.pushdata?
+          v = Opcodes.opcode_to_small_int(c.ord)
+          v ? v : c.pushed_data.bth
+        else
+          Opcodes.opcode_to_name(c.ord)
+        end
+      }.join(' ')
+    end
+
+    # generate sha-256 hash for payload
+    def to_sha256
+      Bitcoin.sha256(to_payload).bth
+    end
+
+    # generate hash160 hash for payload
+    def to_hash160
+      Bitcoin.hash160(to_payload.bth)
+    end
+
+    # script size
+    def size
+      to_payload.bytesize
+    end
+
+    # encode int value to script number hex.
+    # The stacks hold byte vectors.
+    # When used as numbers, byte vectors are interpreted as little-endian variable-length integers
+    # with the most significant bit determining the sign of the integer.
+    # Thus 0x81 represents -1. 0x80 is another representation of zero (so called negative 0).
+    # Positive 0 is represented by a null-length vector.
+    # Byte vectors are interpreted as Booleans where False is represented by any representation of zero,
+    # and True is represented by any representation of non-zero.
+    def self.encode_number(i)
+      return '' if i == 0
+      negative = i < 0
+
+      hex = i.abs.to_s(16)
+      hex = '0' + hex unless (hex.length % 2).zero?
+      v = hex.htb.reverse # change endian
+
+      v = v << (negative ? 0x80 : 0x00) unless (v[-1].unpack('C').first & 0x80) == 0
+      v[-1] = [v[-1].unpack('C').first | 0x80].pack('C') if negative
+      v.bth
+    end
+
+    # decode script number hex to int value
+    def self.decode_number(s)
+      v = s.htb.reverse
+      return 0 if v.length.zero?
+      mbs = v[0].unpack('C').first
+      v[0] = [mbs - 0x80].pack('C') unless (mbs & 0x80) == 0
+      result = v.bth.to_i(16)
+      result = -result unless (mbs & 0x80) == 0
+      result
+    end
+
+    # binary +data+ convert pushdata which contains data length and append PUSHDATA opcode if necessary.
+    def self.pack_pushdata(data)
+      size = data.bytesize
+      header = if size < OP_PUSHDATA1
+                 [size].pack('C')
+               elsif size < 0xff
+                 [OP_PUSHDATA1, size].pack('CC')
+               elsif size < 0xffff
+                 [OP_PUSHDATA2, size].pack('Cv')
+               elsif size < 0xffffffff
+                 [OP_PUSHDATA4, size].pack('CV')
+               else
+                 raise ArgumentError, 'data size is too big.'
+               end
+      header + data
+    end
+
+    # subscript this script to the specified range.
+    def subscript(*args)
+      s = self.class.new
+      s.chunks = chunks[*args]
+      s
+    end
+
+    # removes chunks matching subscript byte-for-byte and returns as a new object.
+    def find_and_delete(subscript)
+      raise ArgumentError, 'subscript must be Bitcoin::Script' unless subscript.is_a?(Script)
+      diff = to_payload.bth.gsub(subscript.to_payload.bth, '')
+      Script.parse_from_payload(diff.htb)
+    end
+
+    def ==(other)
+      return false unless other
+      chunks == other.chunks
+    end
+
+    private
+
+    # generate p2pkh address. if script dose not p2pkh, return nil.
+    def p2pkh_addr
+      return nil unless p2pkh?
+      hash160 = chunks[2].pushed_data.bth
+      return nil unless hash160.htb.bytesize == 20
+      hex = Bitcoin.chain_params.address_version + hash160
+      Bitcoin.encode_base58_address(hex)
+    end
+
+    # generate p2wpkh address. if script dose not p2wpkh, return nil.
+    def p2wpkh_addr
+      p2wpkh? ? bech32_addr : nil
+    end
+
+    # generate p2sh address. if script dose not p2sh, return nil.
+    def p2sh_addr
+      return nil unless p2sh?
+      hash160 = chunks[1].pushed_data.bth
+      return nil unless hash160.htb.bytesize == 20
+      hex = Bitcoin.chain_params.p2sh_version + hash160
+      Bitcoin.encode_base58_address(hex)
+    end
+
+    # generate p2wsh address. if script dose not p2wsh, return nil.
+    def p2wsh_addr
+      p2wsh? ? bech32_addr : nil
+    end
+
+    # return bech32 address for payload
+    def bech32_addr
+      segwit_addr = Bech32::SegwitAddr.new
+      segwit_addr.hrp = Bitcoin.chain_params.bech32_hrp
+      segwit_addr.script_pubkey = to_payload.bth
+      segwit_addr.addr
+    end
+
+  end
+
+end