txcatcher 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d15212b3559d579704e262dc02ed9250a01e957c5b336a573f4a3499dd3bb00
-  data.tar.gz: f0f740d31b4e35e04d1fa65e664eb32fe73b1b1c3665f9e825bbb4640120096b
+  metadata.gz: b03f8177e761f95c4e004bdee74aa320bb19495799a2752a0fc0cf476840025a
+  data.tar.gz: 2604d5b41d3d7f8c750c91d06abfaa453bc7d15326ad96484cada3f3bd543d4c
 SHA512:
-  metadata.gz: 3fea87d4db4cf75cb92b9a86d96a52e430aa7fe219a2f636f1bab6cb9f3c344e11612bfb87bfcc3148e515769738cc92c37ec604be13e8c1c16299b0ffa845a2
-  data.tar.gz: 1257311dae7a0a84bce3057a69798a26e63b37e0aa4ee361e5aa44c13a6b1e3317c621710186d6089cca9bf30e67fb7b9488f2ec0b0f60b33a7a726500bcae2c
+  metadata.gz: 4cde58e8673c4b62e4acde2cb541fb1dd5e1a4d1fda9b07d10b259ebed15c3191508098561e3cdead7e49858ff3473458d25c01ed95791581e5f8012106babda
+  data.tar.gz: 12aabc4580072213a7010cb9c7d271aaf77b6829a03a2157420850f7ec1ecb1a7e627f37cea1f74eb64084a984c61c5586ba19d3ae97384ede4c36ef4ce0ca52

data/Gemfile.lock

@@ -17,10 +17,7 @@ GEM
       aws-sigv4 (~> 1.1)
     aws-sigv4 (1.1.0)
       aws-eventstream (~> 1.0, >= 1.0.2)
-    builder (3.2.3)
     crypto-unit (0.3.4)
-    descendants_tracker (0.0.4)
-      thread_safe (~> 0.3, >= 0.3.1)
     diff-lcs (1.3)
     einhorn (0.7.4)
     em-synchrony (1.0.6)
@@ -36,13 +33,6 @@ GEM
       ffi-rzmq-core (>= 1.0.7)
     ffi-rzmq-core (1.0.7)
       ffi
-    git (1.5.0)
-    github_api (0.18.2)
-      addressable (~> 2.4)
-      descendants_tracker (~> 0.0.4)
-      faraday (~> 0.8)
-      hashie (~> 3.5, >= 3.5.2)
-      oauth2 (~> 1.0)
     goliath (1.0.6)
       async-rack
       einhorn
@@ -55,35 +45,11 @@ GEM
       rack (>= 1.2.2)
       rack-contrib
       rack-respond_to
-    hashie (3.6.0)
-    highline (2.0.2)
     http_parser.rb (0.6.0)
-    jeweler (2.1.1)
-      builder
-      bundler (>= 1.0)
-      git (>= 1.2.5)
-      github_api
-      highline (>= 1.6.15)
-      nokogiri (>= 1.5.10)
-      rake
-      rdoc
-      semver
     jmespath (1.4.0)
-    jwt (2.2.1)
     log4r (1.1.10)
-    mini_portile2 (2.4.0)
     multi_json (1.13.1)
-    multi_xml (0.6.0)
     multipart-post (2.1.1)
-    nokogiri (1.10.3)
-      mini_portile2 (~> 2.4.0)
-    oauth2 (1.4.1)
-      faraday (>= 0.8, < 0.16.0)
-      jwt (>= 1.0, < 3.0)
-      multi_json (~> 1.3)
-      multi_xml (~> 0.5)
-      rack (>= 1.2, < 3)
-    pg (1.1.4)
     public_suffix (3.1.1)
     rack (1.6.11)
     rack-accept-media-types (0.9)
@@ -91,8 +57,6 @@ GEM
       rack (~> 1.4)
     rack-respond_to (0.9.8)
       rack-accept-media-types (>= 0.6)
-    rake (12.3.3)
-    rdoc (6.1.1)
     rspec (3.8.0)
       rspec-core (~> 3.8.0)
       rspec-expectations (~> 3.8.0)
@@ -106,12 +70,10 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.8.0)
     rspec-support (3.8.2)
-    semver (1.0.1)
     sentry-raven (2.11.0)
       faraday (>= 0.7.6, < 1.0)
     sequel (5.23.0)
     sqlite3 (1.4.1)
-    thread_safe (0.3.6)
 
 PLATFORMS
   ruby
@@ -124,8 +86,6 @@ DEPENDENCIES
   faraday
   ffi-rzmq
   goliath
-  jeweler
-  pg
   rack
   rspec
   sentry-raven

data/VERSION

@@ -1 +1 @@
-0.2.3
+0.2.4

data/lib/txcatcher/bitcoin_rpc.rb

@@ -28,18 +28,40 @@ class BitcoinRPC
   end
 
   def get_block_transactions(block_height)
-    TxCatcher::LOGGER.report "--- checking transactions in block #{block_height}"
     block_hash = self.getblockhash(block_height)
     TxCatcher.rpc_node.getblock(block_hash)
   end
 
-  def get_blocks(limit=100)
-    blocks = []
+  def get_blocks(limit=TxCatcher::Config[:max_blocks_in_memory])
+    # We cache blocks we get from RPC to avoid repetetive requests
+    # which are very slow.
+    @blocks ||= {}
+
+    blocks_removed = []
+    @blocks.delete_if do |height,hash|
+      if height < TxCatcher.current_block_height-TxCatcher::Config[:max_blocks_in_memory]
+        blocks_removed << height
+        true
+      end
+    end
+    TxCatcher::LOGGER.report(
+      "--- removing blocks\n#{blocks_removed.join(", ")}\nfrom cache, they're below the config " +
+      "setting of #{TxCatcher::Config[:max_blocks_in_memory]}"
+    ) unless blocks_removed.empty?
+
+    blocks_cached = []
     limit.times do |i|
       height = TxCatcher.current_block_height - i
-      blocks << get_block_transactions(height)
+      unless @blocks[height]
+        blocks_cached << height
+        @blocks[height] = get_block_transactions(height)
+      end
     end
-    blocks
+    TxCatcher::LOGGER.report(
+      "--- loading (from RPC) and caching transactions in blocks " +
+      blocks_cached.join(", ")
+    ) unless blocks_cached.empty?
+    @blocks
   end
 
   class JSONRPCError < RuntimeError

data/lib/txcatcher/catcher.rb

@@ -2,15 +2,71 @@ module TxCatcher
 
   class Catcher
 
-    attr_accessor :name, :sockets
+    attr_accessor :break_all_loops
+    attr_reader   :name, :queue, :zeromq_threads, :queue_threads, :sockets
 
-    def initialize(name:, socket: "ipc:///tmp/")
-     @queue = {}
-     @sockets  = {}
+    def initialize(name:, socket_prefix: "ipc:///tmp/", init_threads: true)
+      @socket_prefix  = socket_prefix
+      @name           = name
+      @queue          = {}
+      @sockets        = {}
+      @zeromq_threads = []
+      @queue_threads  = []
 
-      {'rawtx' => "#{socket}#{name}.rawtx", 'hashblock' => "#{socket}#{name}.hashblock"}.each do |channel, address|
-        LOGGER.report "Start listening on #{name} #{channel}... (#{address})"
-        listen_to_zeromq_message(channel: channel, address: address)
+      ['rawtx', 'hashblock'].each do |channel|
+        @queue_threads  << Thread.new { listen_to_action_queues(channel)   }
+        @zeromq_threads << Thread.new { listen_to_zeromq_channels(channel) }
+      end
+    end
+
+    def close_all_connections
+      @break_all_loops = true
+      (@zeromq_threads + @queue_threads).each { |t| t.kill }
+      @sockets.each { |k,v| v[:object].close }
+    end
+
+    # Responsible for actions after the message from ZeroMQ is parsed,
+    # typically it's writing data to DB through the models. We start it
+    # before we start listening to any messages from ZeroMQ.
+    def listen_to_action_queues(channel)
+      @queue[channel] = Queue.new
+      until @break_all_loops
+        LOGGER.report "in #{channel} queue: #{@queue[channel].size}" if Config["logger"]["log_queue_info"]
+        if @queue[channel].empty?
+          sleep 1
+        else
+          begin
+            @queue[channel].pop.call
+          rescue Sequel::ValidationFailed => e
+            LOGGER.report e, :warn, timestamp: true
+          rescue Exception => e
+            LOGGER.report e, :error, timestamp: true
+          end
+        end
+      end
+    end
+
+    # Now we can start receiving messages from ZeroMQ.
+    # On every received message we call a handler method, which parses it
+    # appropriately (each ZeroMQ channel has its own handler method) and then
+    # adds additional tasks, such as writing to the DB, in the queue.
+    # They queue itself is handled in the thread created above.
+    def listen_to_zeromq_channels(channel)
+      address = "#{@socket_prefix}#{@name}.#{channel}"
+      LOGGER.report "Start listening on #{@name} #{channel}... (#{address})"
+      context = ZMQ::Context.new
+      socket  = context.socket(ZMQ::SUB)
+      socket.setsockopt(ZMQ::SUBSCRIBE, channel)
+      socket.connect(address)
+      @sockets[channel] = { object: socket }
+      until @break_all_loops do
+        message = []
+        socket.recv_strings(message)
+        if message[1]
+          message_hex = hexlify(message[1]).downcase
+          @sockets[channel][:last_message] = message_hex
+          send("handle_#{channel}", "#{message_hex}")
+        end
       end
     end
 
@@ -24,55 +80,6 @@ module TxCatcher
         a.join
       end
 
-      def listen_to_zeromq_message(channel:, address:)
-        @queue[channel] = Queue.new
-
-        # This thread is responsible for actions after the message from ZeroMQ is parsed,
-        # typically it's writing data to DB through the models. We start it
-        # before we start listening to any messages from ZeroMQ.
-        queue_thread = Thread.new do
-          loop do
-            LOGGER.report "in #{channel} queue: #{@queue[channel].size}" if Config["logger"]["log_queue_info"]
-            if @queue[channel].empty?
-              sleep 1
-            else
-              begin
-                @queue[channel].pop.call
-              rescue Sequel::ValidationFailed => e
-                LOGGER.report e, :warn, timestamp: true
-              rescue Exception => e
-                LOGGER.report e, :error, timestamp: true
-              end
-            end
-          end
-        end
-
-        # Now we can start receiving messages from ZeroMQ.
-        # On every received message we call a handler method, which parses it
-        # appropriately (each ZeroMQ channel has its own handler method) and then
-        # adds additional tasks, such as writing to the DB, in the queue.
-        # They queue itself is handled in the thread created above.
-        key = "#{channel}#{address}"
-        handler_thread = Thread.new do
-          context = ZMQ::Context.new
-          socket  = context.socket(ZMQ::SUB)
-          socket.setsockopt(ZMQ::SUBSCRIBE, channel)
-          socket.connect(address)
-          @sockets[key] = { object: socket }
-          loop do
-            topic   = []
-            message = []
-            socket.recv_strings(message)
-            if message[1]
-              message_hex                  = hexlify(message[1]).downcase
-              @sockets[key][:last_message] = message_hex
-              send("handle_#{channel}", "#{message_hex}")
-            end
-          end
-        end
-
-      end # listen_to_zeromq_message
-
       def handle_rawtx(txhex)
         LOGGER.report "received tx hex: #{txhex[0..50]}..."
         @queue["rawtx"] << ( Proc.new {

data/lib/txcatcher/logger.rb

@@ -10,17 +10,20 @@ module TxCatcher
       unknown: 5
     }
 
-    def initialize(log_file: "txcatcher.log", error_file: "error.log", error_log_delimiter: "\n\n")
+    attr_accessor :reporters
+
+    def initialize(log_file: "txcatcher.log", error_file: "error.log", error_log_delimiter: "\n\n", reporters: [:logfile, :stdout, :sentry])
       @log_file_name       = log_file
       @error_log_file_name = error_file
       @error_log_delimiter = error_log_delimiter
+      @reporters           = reporters
     end
 
 
     def report(message, log_level=:info, data: nil, timestamp: false)
-      [:logfile, :stdout, :sentry].each do |out|
+      @reporters.each do |out|
         if LOG_LEVELS[log_level] >= LOG_LEVELS[Config["logger"]["#{out}_level"].to_sym]
-          send("report_to_#{out}", message, log_level, data: data, timestamp: timestamp) 
+          send("report_to_#{out}", message, log_level, data: data, timestamp: timestamp)
         end
       end
     end
@@ -54,7 +57,8 @@ module TxCatcher
 
       def prepare_message(e, timestamp: false)
         result = if e.kind_of?(Exception)
-          result =  e.to_s + "\n"
+          result =  e.class.to_s + " - "
+          result += e.to_s + "\n"
           result += e.message + "\n\n" if e.message != e.to_s
           result += (e.backtrace&.join("\n") || "[no backtrace]")
           result

data/lib/txcatcher/models/transaction.rb

@@ -2,9 +2,16 @@ module TxCatcher
 
   class Transaction < Sequel::Model
 
-    plugin      :validation_helpers
+    plugin :validation_helpers
     one_to_many :deposits
 
+    # Updates only those transactions that have changed
+    def self.update_all(transactions)
+      transactions_to_update = transactions.select { |t| !t.column_changes.empty? }
+      transactions_to_update.each(&:save)
+      return transactions_to_update.map(&:id)
+    end
+
     def before_validation
       return if !self.new? || !self.deposits.empty?
       parse_transaction
@@ -44,11 +51,11 @@ module TxCatcher
 
     # Queries rpc node to check whether the transaction has been included in any of the blocks,
     # but only if current block_height is nil.
-    def update_block_height!(dont_save: false, blocks: nil)
+    def check_block_height!(dont_save: false, blocks: nil)
       return self.block_height if self.block_height
       blocks = TxCatcher.rpc_node.get_blocks(blocks_to_check_for_inclusion_if_unconfirmed) unless blocks
 
-      for block in blocks do
+      for block in blocks.values do
         if block["tx"] && block["tx"].include?(self.txid)
           LOGGER.report "tx #{self.txid} block height updated to #{block["height"]}"
           self.update(block_height: block["height"]) if !dont_save
@@ -65,7 +72,7 @@ module TxCatcher
     # However, to make absolute sure, we always bump up this number by 10 blocks.
     # Over larger periods of time, the avg block per minute value should even out, so
     # it's probably going to be fine either way.
-    def blocks_to_check_for_inclusion_if_unconfirmed(limit=100)
+    def blocks_to_check_for_inclusion_if_unconfirmed(limit=TxCatcher::Config[:max_blocks_in_memory])
       return false if self.block_height
       created_minutes_ago = ((self.created_at - Time.now).to_i/60)
       blocks_to_check = (created_minutes_ago / 10).abs + 10

data/lib/txcatcher/server.rb

@@ -36,16 +36,20 @@ module TxCatcher
     end
 
     def address(path)
-      path = path.split("/").delete_if { |i| i.empty? }
+      path = path.sub(/\?.*/, '').split("/").delete_if { |i| i.empty? }
       addr = path.last
 
-      address = Address.where(address: addr).eager(deposits: :transactions).first
+      address  = Address.where(address: addr).first
       if address
-        transactions_ids = address.deposits.map { |d| d.transaction.txid }
-        deposits = address.deposits.map do |d|
+        deposits       = Deposit.where(address_id: address.id)
+        deposits_count = deposits.count
+        deposits       = deposits.eager(:transaction).limit(params["limit"] || 100)
+        transactions   = deposits.map { |d| d.transaction }
+        deposits = deposits.map do |d|
           t = d.transaction
           t.update(protected: true) unless t.protected
-          t.update_block_height!
+          t.check_block_height!(dont_save: true)
+
           {
             txid:          t.txid,
             amount:        d.amount_in_btc,
@@ -54,68 +58,51 @@ module TxCatcher
             block_height:  t.block_height
           }
         end
-        [200, {}, { address: address.address, received: address.received, deposits: deposits }.to_json]
+        return [200, {}, { address: address.address, received: address.received, deposits_count: deposits_count, deposits_shown: deposits.size, deposits: deposits }.to_json]
       else
-        [200, {}, { address: addr, received: 0, deposits: [] }.to_json]
+        return [200, {}, { address: addr, received: 0, deposits: [] }.to_json]
       end
     end
 
     def utxo(path)
-      path = path.split("/").delete_if { |i| i.empty? }
+      path = path.sub(/\?.*/, '').split("/").delete_if { |i| i.empty? }
       path.pop
       addr = path.last
 
-      model = Address.where(address: addr).eager(deposits: :transactions).first
-      return [200, {}, "{}"] unless model
+      address  = Address.where(address: addr).first
+      return [200, {}, "{}"] unless address
+      deposits = Deposit.where(address_id: address.id).limit(params["limit"] || 100).eager(:transaction)
+
+      transactions = deposits.map { |d| d.transaction }
+      transactions.sort!          { |t1,t2| t2.created_at <=> t1.created_at }
+
+      transactions.each do |t|
+        # If we see a transaction with 0 confirmations, let's check if it got any news confirmations
+        # by querying Bitcoind RPC.
+        t.check_block_height!(dont_save: true) if t.confirmations == 0
+        # If still not confirmed, let's make it protected so it's not deleted during cleanup.
+        t.protected = true if t.confirmations == 0
+      end
 
-      confirmed_txs_to_update       = []
-      unconfirmed_txs_to_update     = []
-      newly_confirmed_txs_to_update = []
+      Transaction.update_all(transactions) # will only update the ones that changed!
 
-      transactions = model.deposits.map { |d| d.transaction }
-      transactions.sort!                { |t1,t2| t2.created_at <=> t1.created_at }
       utxos = transactions.map do |t|
         outs = t.tx_hash["vout"].select { |out| out["scriptPubKey"]["addresses"] == [addr] }
         outs.map! do |out|
-          out["confirmations"] = t.confirmations || 0
-          out["txid"]          = t.txid
-          confirmed_txs_to_update   << t if out["confirmations"] > 0
-          unconfirmed_txs_to_update << t if out["confirmations"] == 0
+          out["confirmations"]   = t.confirmations || 0
+          out["txid"]            = t.txid
           out
         end
         outs
       end.flatten
 
-      unless unconfirmed_txs_to_update.empty?
-        blocks = TxCatcher.rpc_node.get_blocks(unconfirmed_txs_to_update.first.blocks_to_check_for_inclusion_if_unconfirmed)
-
-        unconfirmed_txs_to_update = unconfirmed_txs_to_update.map do |t|
-          tx_block_height = t.update_block_height!(dont_save: true, blocks: blocks)
-          if tx_block_height && tx_block_height > 0
-            newly_confirmed_txs_to_update << t
-            nil
-          else
-            t
-          end
-        end.compact
-      end
-
-      # Update all txs after we map them. We don't use regular Transaction#update
-      # in the #map loop above, because this will quickly get out of hand and result
-      # in a gateway timeout, if there are a lot of transactions to be updated. Instead,
-      # we collect all txs in an array and then update them in bulk here.
-      no_block_height_change_txs_ids = (confirmed_txs_to_update + unconfirmed_txs_to_update).map(&:id)
-      block_height_change_txs_ids = newly_confirmed_txs_to_update.map(&:id)
-      TxCatcher.db_connection[:transactions].where(id: no_block_height_change_txs_ids).update(protected: true)
-      TxCatcher.db_connection[:transactions].where(id: block_height_change_txs_ids).update(protected: true, block_height: TxCatcher.current_block_height)
-
-      [200, {}, utxos.to_json]
+      return [200, {}, utxos.to_json]
     end
 
     def broadcast_tx(txhex)
       TxCatcher.rpc_node.sendrawtransaction(txhex)
       tx = TxCatcher.rpc_node.decoderawtransaction(txhex)
-      [200, {}, tx.to_json]
+      return [200, {}, tx.to_json]
     end
 
     def feerate(blocks_target)
@@ -127,7 +114,7 @@ module TxCatcher
         result = { "feerate" => result, "blocks" => blocks_target}
       end
 
-      [200, {}, result["feerate"].to_s]
+      return [200, {}, result["feerate"].to_s]
     end
 
   end

data/lib/txcatcher.rb

@@ -22,3 +22,4 @@ prepare
 require_relative 'txcatcher/models/transaction'
 require_relative 'txcatcher/models/address'
 require_relative 'txcatcher/models/deposit'
+Sequel::Model.plugin :dirty

data/spec/catcher_spec.rb

@@ -9,93 +9,77 @@ require_relative '../lib/txcatcher/catcher'
 RSpec.describe TxCatcher::Catcher do
 
   before(:all) do
-    @tx_sock     = ZMQ::Context.create(1).socket(ZMQ::PUB)
-    @block_sock  = ZMQ::Context.create(2).socket(ZMQ::PUB)
-    @tx_sock.bind("ipc:///tmp/bitcoind.rawtx")
-    @block_sock.bind("ipc:///tmp/bitcoind.hashblock")
+    @tx_sock     = ZMQ::Context.create.socket(ZMQ::PUB)
+    @block_sock  = ZMQ::Context.create.socket(ZMQ::PUB)
+
+    @tx_sock.bind("ipc:///tmp/bitcoind_test.rawtx")
+    @block_sock.bind("ipc:///tmp/bitcoind_test.hashblock")
+
     @hextx = File.read(File.dirname(__FILE__) + "/fixtures/transaction.txt").strip
     @rawtx = unhexlify(File.read(File.dirname(__FILE__) + "/fixtures/transaction.txt"))
-    @catcher = TxCatcher::Catcher.new(name: "bitcoind")
+    @catcher = TxCatcher::Catcher.new(name: "bitcoind_test")
     sleep 1
   end
 
   after(:all) do
-    @tx_sock.unbind('ipc:///tmp/bitcoind_testnet.rawtx')
-    @block_sock.unbind('ipc:///tmp/bitcoind_testnet.hashblock')
+    @catcher.close_all_connections
+    @tx_sock.unbind("ipc:///tmp/bitcoind_test.rawtx")
+    @block_sock.unbind('ipc:///tmp/bitcoind_test.hashblock')
   end
 
-  it "creates a new transaction in the DB" do
-    @tx_sock.send_string('rawtx', ZMQ::SNDMORE)
-    @tx_sock.send_string(@rawtx)
-
-    i = 0
-    until (@catcher.sockets.values&.first && @catcher.sockets.values.first[:last_message]) || i > 10
-      sleep 1 and i += 1
-    end
+  after(:each) do
+    @catcher.sockets["rawtx"][:last_message] = nil
+    @catcher.sockets["hashblock"][:last_message] = nil
+  end
 
+  it "creates a new transaction in the DB" do
+    @tx_sock.send_strings(['rawtx', @rawtx])
     i = 0
-    until tx = TxCatcher::Transaction.last
-      sleep 1 and i += 1
+    until (tx = TxCatcher::Transaction.last) || i > 3
+      sleep 1
+      i+=1
     end
     expect(tx.hex).to eq(@hextx)
-
   end
 
-  describe "upon receiving a new block" do
+  it "updates transactions block height upon receiving a new block " do
+    transaction = TxCatcher::Transaction.create(hex: @hextx)
+    expect(TxCatcher.rpc_node).to receive(:getblock).at_least(:once).and_return({ "height" => TxCatcher.current_block_height + 1, "tx" => [transaction.txid]})
 
-    it "updates transactions block height" do
-      transaction = TxCatcher::Transaction.create(hex: @hextx)
-      allow(TxCatcher.rpc_node).to receive(:getblock).and_return({ "height" => TxCatcher.current_block_height + 1, "tx" => [transaction.txid]})
-      @block_sock.send_string('hashblock', ZMQ::SNDMORE)
-      @block_sock.send_string("hello")
-      #transaction.update_block_height!
+    @block_sock.send_strings(["hashblock", 'hello'])
 
-      i = 0
-      until transaction.reload.confirmations == 1
-        sleep 1 and i += 1
-      end
-      expect(transaction.block_height).to eq(TxCatcher.current_block_height)
-
-    end
+    i = 0
+    begin
+      sleep 1 and i += 1
+    end until @catcher.sockets["hashblock"][:last_message] || i > 3
 
+    expect(transaction.reload.block_height).to eq(TxCatcher.current_block_height)
   end
 
-  describe "error logging" do
-
-    before(:each) do
-      @error_log = File.dirname(__FILE__) + "/config/error.log"
-      TxCatcher::Config.config_dir = File.dirname(@error_log)
-    end
+  it "ignores validation errors" do
+    tx = eval File.read(File.dirname(__FILE__) + "/fixtures/transaction_decoded_no_outputs.txt")
+    expect(TxCatcher.rpc_node).to receive(:decoderawtransaction).at_least(:once).and_return(tx)
+    @tx_sock.send_strings(["rawtx", @rawtx])
 
-    after(:each) do
-      File.delete(@error_log) if File.exists?(@error_log)
-    end
-
-    it "ignores validation errors" do
-      tx = eval File.read(File.dirname(__FILE__) + "/fixtures/transaction_decoded_no_outputs.txt")
-      allow(TxCatcher.rpc_node).to receive(:decoderawtransaction).and_return(tx)
-      @tx_sock.send_string('rawtx', ZMQ::SNDMORE)
-      @tx_sock.send_string(@rawtx)
-
-      i = 0
-      until (@catcher.sockets.values&.first && @catcher.sockets.values.first[:last_message]) || i > 10
-        sleep 1 and i += 1
-      end
-      expect(File.exists?(@error_log)).to be_falsey
-    end
+    i = 0
+    begin
+      sleep 1 and i += 1
+    end until @catcher.sockets["rawtx"][:last_message] || i > 3
 
-    it "logs all other errors" do
-      allow(TxCatcher.rpc_node).to receive(:decoderawtransaction).and_raise(StandardError)
-      @tx_sock.send_string('rawtx', ZMQ::SNDMORE)
-      @tx_sock.send_string(@rawtx)
+    expect(File.exists?(ERRFILE)).to be_falsey
+  end
 
-      i = 0
-      until File.exists?(@error_log)
-        sleep 1 and i += 1
-      end
-      expect(File.read(@error_log)).not_to be_empty
-    end
+  it "logs all other errors" do
+    sleep 1
+    expect(TxCatcher.rpc_node).to receive(:decoderawtransaction).at_least(:once).and_raise(StandardError)
+    @tx_sock.send_strings(["rawtx", @rawtx])
 
+    i = 0
+    begin
+      sleep 1 and i += 1
+    end until @catcher.sockets["rawtx"][:last_message] || i > 3
+    expect(File.read(ERRFILE)).not_to be_empty
   end
 
+
 end

data/spec/config/config.yml.sample

@@ -26,6 +26,7 @@ logger:
 
 zeromq: bitcoind
 max_db_transactions_stored: 10
+max_blocks_in_memory: 100
 db_clean_period_seconds: 300
 protected_transactions: true
 host: localhost

data/spec/models/transaction_spec.rb

@@ -2,6 +2,12 @@ require_relative '../spec_helper'
 
 RSpec.describe TxCatcher::Transaction do
 
+  class TxCatcher::Transaction
+    def assign_transaction_attrs
+      self.txid = @tx_hash["txid"] unless self.txid
+    end
+  end
+
   before(:each) do
     @hextx = File.read(File.dirname(__FILE__) + "/../fixtures/transaction.txt").strip
     @transaction = TxCatcher::Transaction.create(hex: @hextx)
@@ -29,8 +35,19 @@ RSpec.describe TxCatcher::Transaction do
   it "updates block height by making manual requests to RPC and searching if tx is included in one of the previous blocks" do
     expect(TxCatcher.rpc_node).to receive(:getblockhash).exactly(10).times.and_return("blockhash123")
     expect(TxCatcher.rpc_node).to receive(:getblock).exactly(10).times.and_return({ "height" => "123", "tx" => [@transaction.txid], "hash" => "blockhash123"})
-    @transaction.update_block_height!
+    @transaction.check_block_height!
     expect(@transaction.block_height).to eq(123)
   end
 
+  it "updates multiple records at once" do
+    transaction1 = TxCatcher::Transaction.create(hex: @hextx, txid: "123")
+    transaction2 = TxCatcher::Transaction.create(hex: @hextx, txid: "1234")
+    transaction3 = TxCatcher::Transaction.create(hex: @hextx, txid: "1235")
+    transaction2.block_height = 2
+    transaction3.block_height = 3
+    expect(
+      TxCatcher::Transaction.update_all([transaction1, transaction2, transaction3])
+    ).to eq([transaction2.id, transaction3.id])
+  end
+
 end

data/spec/spec_helper.rb

@@ -28,6 +28,7 @@ connect_to_rpc_node
 require_relative '../lib/txcatcher/models/transaction'
 require_relative '../lib/txcatcher/models/address'
 require_relative '../lib/txcatcher/models/deposit'
+Sequel::Model.plugin :dirty
 
 def unhexlify(msg)
   msg.scan(/../).collect { |c| c.to_i(16).chr }.join
@@ -40,6 +41,7 @@ RSpec.configure do |config|
 
   config.default_formatter = 'doc'
   config.before(:all) do
+    #TxCatcher::LOGGER.reporters = [:logfile]
   end
 
   config.after(:all) do
@@ -52,6 +54,10 @@ RSpec.configure do |config|
   end
 
   config.after(:each) do
+    delete_log_files
+  end
+
+  def delete_log_files
     [LOGFILE, ERRFILE].each do |f|
       FileUtils.rm(f) if File.exist?(f)
     end

data/txcatcher.gemspec

@@ -1,12 +1,6 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-# stub: txcatcher 0.2.2 ruby lib
-
 Gem::Specification.new do |s|
   s.name = "txcatcher".freeze
-  s.version = "0.2.3"
+  s.version = "0.2.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: txcatcher
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Roman Snitko