tapyrus 0.1.0

data/lib/tapyrus/network/pool.rb

@@ -0,0 +1,135 @@
+module Tapyrus
+
+  module Network
+
+    # Time between pings automatically sent out for latency probing and keepalive (in seconds).
+    PING_INTERVAL = 2 * 60
+    # Time after which to disconnect, after waiting for a ping response (or inactivity).
+    TIMEOUT_INTERVAL = 20 * 60
+    # Maximum number of automatic outgoing nodes
+    MAX_OUTBOUND_CONNECTIONS = 4
+
+    # peer pool class.
+    class Pool
+      include Observable
+
+      attr_reader :peers # active peers
+      attr_reader :pending_peers # currently connecting peer
+      attr_reader :node
+      attr_reader :chain
+      attr_reader :max_outbound
+      attr_reader :logger
+      attr_reader :peer_discovery
+      attr_accessor :started
+      attr_reader :mutex
+
+      def initialize(node, chain, configuration)
+        @node = node
+        @peers = []
+        @pending_peers = []
+        @max_outbound = MAX_OUTBOUND_CONNECTIONS
+        @chain = chain
+        @logger = Tapyrus::Logger.create(:debug)
+        @configuration = configuration
+        @peer_discovery = PeerDiscovery.new(configuration)
+        @started = false
+        @mutex = Mutex.new
+      end
+
+      # connecting other peers and begin network activity.
+      def start
+        raise 'Cannot start a peer pool twice.' if started
+        logger.debug 'Start connecting other pears.'
+        addr_list = peer_discovery.peers
+
+        connect(addr_list)
+
+        @started = true
+      end
+
+      # detect new peer connection.
+      def handle_new_peer(peer)
+        logger.debug "connected new peer #{peer.addr}."
+        mutex.synchronize do
+          peer.id = allocate_peer_id
+          unless peers.find(&:primary?)
+            peer.primary = true
+            peer.start_block_header_download
+          end
+          peers << peer
+        end
+        pending_peers.delete(peer)
+        filter_load(peer) if node.wallet
+      end
+
+      def handle_close_peer(peer)
+        return unless started
+        peers.delete(peer)
+        pending_peers.delete(peer)
+        addr_list = peer_discovery.peers - peers.map(&:host) - pending_peers.map(&:host) - [peer.host]
+        connect(addr_list)
+      end
+
+      # terminate peers.
+      def terminate
+        peers.each { |peer| peer.close('terminate') }
+        pending_peers.each { |peer| peer.close('terminate') }
+        @peers = []
+        @started = false
+      end
+
+      # broadcast tx to connecting peer.
+      def broadcast(tx)
+        peers.each { |peer| peer.broadcast_tx(tx) }
+      end
+
+      # new bloom filter.
+      def filter_load(peer)
+        peer.send_filter_load(node.bloom)
+      end
+
+      # add element to bloom filter.
+      def filter_add(element)
+        peers.each { |peer| peer.send_filter_add(element) }
+      end
+
+      # clear bloom filter.
+      def filter_clear
+        peers.each { |peer| peer.send_filter_clear }
+      end
+
+      def handle_error(e)
+        terminate
+      end
+
+      private
+
+      # get primary peer
+      def primary_peer
+        peers.find(&:primary?)
+      end
+
+      # allocate new peer id
+      def allocate_peer_id
+        id = 0
+        until peers.empty? || peers.find{|p|p.id == id}.nil?
+          id += 1
+        end
+        id
+      end
+
+      def connect(addr_list)
+        port = Tapyrus.chain_params.default_port
+
+        EM::Iterator.new(addr_list, Tapyrus::PARALLEL_THREAD).each do |ip, iter|
+          if pending_peers.size + peers.size < MAX_OUTBOUND_CONNECTIONS
+            peer = Peer.new(ip, port, self, @configuration)
+            pending_peers << peer
+            peer.connect
+            iter.next
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tapyrus/network.rb

@@ -0,0 +1,13 @@
+require 'eventmachine'
+
+module Tapyrus
+  module Network
+
+    autoload :MessageHandler, 'tapyrus/network/message_handler'
+    autoload :Connection, 'tapyrus/network/connection'
+    autoload :Pool, 'tapyrus/network/pool'
+    autoload :Peer, 'tapyrus/network/peer'
+    autoload :PeerDiscovery, 'tapyrus/network/peer_discovery'
+
+  end
+end

data/lib/tapyrus/node/cli.rb

@@ -0,0 +1,112 @@
+require 'rest-client'
+require 'thor'
+require 'json'
+
+module Tapyrus
+  module Node
+
+    class CLI < Thor
+
+      class_option :network, aliases: '-n', default: :mainnet
+
+      desc 'getblockchaininfo', 'Returns an object containing various state info regarding blockchain processing.'
+      def getblockchaininfo
+        request('getblockchaininfo')
+      end
+
+      desc 'stop', 'Stop Tapyrus server.'
+      def stop
+        request('stop')
+      end
+
+      desc 'getblockheader "hash" ( verbose )', 'If verbose is false, returns a string that is serialized, hex-encoded data for blockheader "hash". If verbose is true, returns an Object with information about blockheader <hash>.'
+      def getblockheader(hash, verbose = true)
+        verbose = verbose.is_a?(String) ? (verbose == 'true') : verbose
+        request('getblockheader', hash, verbose)
+      end
+
+      desc 'getpeerinfo', 'Returns data about each connected network node as a json array of objects.'
+      def getpeerinfo
+        request('getpeerinfo')
+      end
+
+      desc 'decoderawtransaction "hexstring"', 'Return a JSON object representing the serialized, hex-encoded transaction.'
+      def decoderawtransaction(hexstring)
+        request('decoderawtransaction', hexstring)
+      end
+
+      desc 'decodescript "hexstring"', 'Decode a hex-encoded script.'
+      def decodescript(hexstring)
+        request('decodescript', hexstring)
+      end
+
+      # wallet cli
+
+      desc 'sendrawtransaction', 'Submits raw transaction (serialized, hex-encoded) to local node and network.'
+      def sendrawtransaction(hex_tx)
+        request('sendrawtransaction', hex_tx)
+      end
+
+      desc 'createwallet "wallet_id"', 'Create new HD wallet. It returns an error if an existing wallet_id is specified. '
+      def createwallet(wallet_id)
+        request('createwallet', wallet_id)
+      end
+
+      desc 'listwallets', 'Returns a list of currently loaded wallets. For full information on the wallet, use "getwalletinfo"'
+      def listwallets
+        request('listwallets')
+      end
+
+      desc 'getwalletinfo', 'Returns an object containing various wallet state info.'
+      def getwalletinfo
+        request('getwalletinfo')
+      end
+
+      desc 'listaccounts', '[WIP]Returns Object that has account names as keys, account balances as values.'
+      def listaccounts
+        request('listaccounts')
+      end
+
+      desc 'encryptwallet "passphrase"', 'Encrypts the wallet with "passphrase". This is for first time encryption.After this, any calls that interact with private keys such as sending or signing will require the passphrase to be set prior the making these calls.'
+      def encryptwallet(passhphrase)
+        request('encryptwallet', passhphrase)
+      end
+
+      desc 'getnewaddress "account"', 'Returns a new Tapyrus address for receiving payments.'
+      def getnewaddress(account)
+        request('getnewaddress', account)
+      end
+
+      private
+
+      def config
+        opts = {}
+        opts[:network] = options['network'] if options['network']
+        @conf ||= Tapyrus::Node::Configuration.new(opts)
+      end
+
+      def request(command, *params)
+        data = {
+            :method => command,
+            :params => params,
+            :id => 'jsonrpc'
+        }
+        begin
+          RestClient::Request.execute(method: :post, url: config.server_url, payload: data.to_json,
+                                      headers: {content_type: :json}) do |response, request, result|
+            return false if !result.kind_of?(Net::HTTPSuccess) && response.empty?
+            begin
+              json = JSON.parse(response.to_str)
+              puts JSON.pretty_generate(json)
+            rescue Exception
+              puts response.to_str
+            end
+          end
+        rescue Exception => e
+          puts e.message
+        end
+      end
+
+    end
+  end
+end

data/lib/tapyrus/node/configuration.rb

@@ -0,0 +1,38 @@
+require 'iniparse'
+
+module Tapyrus
+  module Node
+    class Configuration
+
+      attr_reader :conf
+
+      def initialize(opts = {})
+        # TODO apply configuration file.
+        opts[:network] = :mainnet unless opts[:network]
+        opts[:relay] = false unless opts[:relay]
+        Tapyrus.chain_params = opts[:network]
+
+        begin
+          ini_file = IniParse.parse(File.read("#{Tapyrus.base_dir}/tapyrusrb.conf"))
+          @conf = Hash[ ini_file.to_h['__anonymous__'].map{|k,v| [k.to_sym, v] } ]
+        rescue => e
+          @conf = {}
+        end
+        @conf.merge!(opts)
+      end
+
+      def host
+        'localhost'
+      end
+
+      def port
+        Tapyrus.chain_params.default_port - 1
+      end
+
+      def server_url
+        "http://#{host}:#{port}"
+      end
+
+    end
+  end
+end

data/lib/tapyrus/node/spv.rb

@@ -0,0 +1,79 @@
+module Tapyrus
+  module Node
+
+    # SPV class
+    class SPV
+
+      attr_reader :chain
+      attr_reader :pool
+      attr_reader :logger
+      attr_accessor :running
+      attr_reader :configuration
+      attr_accessor :server
+      attr_accessor :wallet
+      attr_accessor :bloom
+
+      def initialize(configuration)
+        @chain = Tapyrus::Store::SPVChain.new
+        @configuration = configuration
+        @pool = Tapyrus::Network::Pool.new(self, @chain, @configuration)
+        @logger = Tapyrus::Logger.create(:debug)
+        @running = false
+        @wallet = Tapyrus::Wallet::Base.current_wallet
+        # TODO : optimize bloom filter parameters
+        setup_filter
+      end
+
+      # open the node.
+      def run
+        # TODO need process running check.
+        return if running
+        logger.debug 'SPV node start running.'
+        EM.run do
+          # EM.start_server('0.0.0.0', Tapyrus.chain_params.default_port, Tapyrus::Network::InboundConnector, self)
+          pool.start
+          @server = Tapyrus::RPC::HttpServer.run(self, configuration.port)
+        end
+      end
+
+      # close the node.
+      def shutdown
+        pool.terminate
+        logger.debug 'SPV node shutdown.'
+      end
+
+      # broadcast a transaction
+      def broadcast(tx)
+        pool.broadcast(tx)
+        logger.debug "broadcast tx: #{tx.to_payload.bth}"
+      end
+
+      # add filter element to bloom filter.
+      # [String] element. the hex string of txid, public key, public key hash or outpoint.
+      def filter_add(element)
+        bloom.add(element)
+        pool.filter_add(element)
+      end
+
+      # clear bloom filter.
+      def filter_clear
+        pool.filter_clear
+      end
+
+      def add_observer(observer)
+        pool.add_observer(observer)
+      end
+
+      def delete_observer(observer)
+        pool.delete_observer(observer)
+      end
+
+      private
+
+      def setup_filter
+        @bloom = Tapyrus::BloomFilter.create_filter(512, 0.01)
+        wallet.watch_targets.each{|t|bloom.add(t.htb)} if wallet
+      end
+    end
+  end
+end

data/lib/tapyrus/node.rb

@@ -0,0 +1,7 @@
+module Tapyrus
+  module Node
+    autoload :SPV, 'tapyrus/node/spv'
+    autoload :CLI, 'tapyrus/node/cli'
+    autoload :Configuration, 'tapyrus/node/configuration'
+  end
+end

data/lib/tapyrus/opcodes.rb

@@ -0,0 +1,178 @@
+module Tapyrus
+
+  # 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_NOP2 = OP_CHECKLOCKTIMEVERIFY = OP_CLTV = 0xb1
+    OP_NOP3 = OP_CHECKSEQUENCEVERIFY = OP_CSV = 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
+
+    # https://en.bitcoin.it/wiki/Script#Pseudo-words
+    OP_PUBKEYHASH = 0xfd
+    OP_PUBKEY = 0xfe
+    OP_INVALIDOPCODE = 0xff
+
+    DUPLICATE_KEY = [:OP_NOP2, :OP_NOP3]
+    OPCODES_MAP = Hash[*(constants.grep(/^OP_/) - [:OP_NOP2, :OP_NOP3, :OP_CHECKLOCKTIMEVERIFY, :OP_CHECKSEQUENCEVERIFY]).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/tapyrus/out_point.rb

@@ -0,0 +1,44 @@
+module Tapyrus
+
+  # outpoint class
+  class OutPoint
+
+    COINBASE_HASH = '0000000000000000000000000000000000000000000000000000000000000000'
+    COINBASE_INDEX = 4294967295
+
+    attr_reader :tx_hash
+    attr_reader :index
+
+    def initialize(tx_hash, index = -1)
+      @tx_hash = tx_hash
+      @index = index
+    end
+
+    def self.from_txid(txid, index)
+      self.new(txid.rhex, index)
+    end
+
+    def coinbase?
+      tx_hash == COINBASE_HASH && index == COINBASE_INDEX
+    end
+
+    def to_payload
+      [tx_hash.htb, index].pack('a32V')
+    end
+
+    def self.create_coinbase_outpoint
+      new(COINBASE_HASH, COINBASE_INDEX)
+    end
+
+    def valid?
+      index >= 0 && (!coinbase? && tx_hash != COINBASE_HASH)
+    end
+
+    # convert hash to txid
+    def txid
+      tx_hash.rhex
+    end
+
+  end
+
+end

data/lib/tapyrus/rpc/http_server.rb

@@ -0,0 +1,65 @@
+require 'evma_httpserver'
+require 'json'
+
+module Tapyrus
+  module RPC
+
+    # Tapyrusrb RPC server.
+    class HttpServer < EM::Connection
+      include EM::HttpServer
+      include RequestHandler
+
+      attr_reader :node
+      attr_accessor :logger
+
+      def initialize(node)
+        @node = node
+        @logger = Tapyrus::Logger.create(:debug)
+      end
+
+      def post_init
+        super
+        logger.debug 'start http server.'
+      end
+
+      def self.run(node, port = 8332)
+        EM.start_server('0.0.0.0', port, HttpServer, node)
+      end
+
+      # process http request.
+      def process_http_request
+        operation = proc {
+          command, args = parse_json_params
+          logger.debug("process http request. command = #{command}")
+          begin
+            send(command, *args).to_json
+          rescue Exception => e
+            e
+          end
+        }
+        callback = proc{ |result|
+          response = EM::DelegatedHttpResponse.new(self)
+          if result.is_a?(Exception)
+            response.status = 500
+            response.content = result.message
+          else
+            response.status = 200
+            response.content = result
+          end
+          response.content_type 'application/json'
+          response.send_response
+        }
+        EM.defer(operation, callback)
+      end
+
+      # parse request parameter.
+      # @return [Array] the array of command and args
+      def parse_json_params
+        params = JSON.parse(@http_post_content)
+        [params['method'], params['params']]
+      end
+
+    end
+
+  end
+end