hive-ruby 1.0.0.pre.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03ce4beaef9c60b95e78bcc6d5589f01ea02902a59a151669ce26a774bad3e20
-  data.tar.gz: f8f05b4c3763b3d06f20466bf691a7fd5d3d7ee0a808a99942d42d39086775e6
+  metadata.gz: 8bf5d72142c42463a6146346f0bdd4e9943da776894b26f19a6bf3bac7416670
+  data.tar.gz: a06c05f424bf354b792fc3a49dde1a064c1bd974a922c4a01ec9ef6281fc3611
 SHA512:
-  metadata.gz: 295873eef303017a329752b385478249490232e6bd6fe8862ce91b1fab6da3c73a53c71ea14f989fa376fbdc93669895a4de9b25a415c64c32c936b998dcde0f
-  data.tar.gz: d32254187206ed4f704355ec768e67e6746b52c05f7a1da02682e5714db6034faca654f9c9492cbaecc14d476da9cfe2c78a14429aeedf3c93f5a6713a4e8e42
+  metadata.gz: fff041bd517d2101d0d84b521d17880b0bb7d641751bfa5a1c22529fd3e451290f28556830726ca02f38a40fa39e521bf55f852885374d93842a3c4f6bd1b7dc
+  data.tar.gz: a6d4e6be972a57411d6c51894e5ba12c610496e06f4889f1e5c72493044c8fbcb1d5438b51d329209d66ce38fb88c165a6994dfa80c7f2ec2b6900f33763513a

data/Rakefile

@@ -112,20 +112,20 @@ namespace :test do
               [k, v] if keys.include? k.to_sym
             end.compact.to_h
             
-            sbd_exchange_rate = witness[:sbd_exchange_rate]
-            base = sbd_exchange_rate[:base].to_f
+            hbd_exchange_rate = witness[:hbd_exchange_rate] || witness[:hbd_exchange_rate]
+            base = hbd_exchange_rate[:base].to_f
             
-            if (quote = sbd_exchange_rate[:quote].to_f) > 0
+            if (quote = hbd_exchange_rate[:quote].to_f) > 0
               rate = (base / quote).round(3)
-              witnesses[witness.owner][:sbd_exchange_rate] = rate
+              witnesses[witness.owner][:hbd_exchange_rate] = rate
             else
-              witnesses[witness.owner][:sbd_exchange_rate] = nil
+              witnesses[witness.owner][:hbd_exchange_rate] = nil
             end
             
-            last_sbd_exchange_update = witness[:last_sbd_exchange_update]
-            last_sbd_exchange_update = Time.parse(last_sbd_exchange_update + 'Z')
-            last_sbd_exchange_elapsed = '%.2f hours ago' % ((Time.now.utc - last_sbd_exchange_update) / 60)
-            witnesses[witness.owner][:last_sbd_exchange_elapsed] = last_sbd_exchange_elapsed
+            last_hbd_exchange_update = witness[:last_hbd_exchange_update] || witness[:last_hbd_exchange_update]
+            last_hbd_exchange_update = Time.parse(last_hbd_exchange_update + 'Z')
+            last_hbd_exchange_elapsed = '%.2f hours ago' % ((Time.now.utc - last_hbd_exchange_update) / 60)
+            witnesses[witness.owner][:last_hbd_exchange_elapsed] = last_hbd_exchange_elapsed
           end
         end
       end
@@ -153,9 +153,13 @@ namespace :stream do
     first_block_num = args[:at_block_num].to_i if !!args[:at_block_num]
     stream = Hive::Stream.new(url: ENV['TEST_NODE'], mode: mode)
     api = Hive::Api.new(url: ENV['TEST_NODE'])
+    block_api = Hive::BlockApi.new(url: ENV['TEST_NODE'])
     last_block_num = nil
     last_timestamp = nil
     range_complete = false
+    round_pool = {}
+    aging_blocks = {}
+    aged_block_interval = 630
     
     api.get_dynamic_global_properties do |properties|
       current_block_num = if mode == :head
@@ -165,13 +169,14 @@ namespace :stream do
       end
       
       # First pass replays latest a random number of blocks to test chunking.
-      first_block_num ||= current_block_num - (rand * 200).to_i
+      first_block_num ||= current_block_num - (rand * 2000).to_i
       
       range = first_block_num..current_block_num
       puts "Initial block range: #{range.size}"
       
       stream.blocks(at_block_num: range.first) do |block, block_num|
         current_timestamp = Time.parse(block.timestamp + 'Z')
+        round_pool[current_timestamp] = {block_num: block_num, block: block}
         
         if !range_complete && block_num > range.last
           puts 'Done with initial range.'
@@ -188,9 +193,35 @@ namespace :stream do
           exit
         end
         
-        puts "\t#{block_num} Timestamp: #{current_timestamp}, witness: #{block.witness}"
+        round_pool.each do |k, v|
+          aging_blocks[k] = v if Time.now - k > aged_block_interval
+        end
+        
+        round_pool = round_pool.select{|k, v| Time.now - k <= aged_block_interval}.to_h
+        drift = last_timestamp.nil? ? 0 : (current_timestamp - last_timestamp) - Hive::Stream::BLOCK_INTERVAL.to_f
+        
+        puts "\t#{block_num} Timestamp: #{current_timestamp}, witness: #{block.witness}, aging blocks: #{aging_blocks.size}, drift: #{drift}"
+        
         last_block_num = block_num
         last_timestamp = current_timestamp
+        
+        if range_complete && aging_blocks.any?
+          aging_block_nums = aging_blocks.map{|k, v| v[:block_num]}
+          wire_block_range = (aging_block_nums.first..aging_block_nums.last)
+          
+          block_api.get_block_headers(block_range: wire_block_range) do |wire_header, wire_block_num|
+            wire_timestamp = Time.parse(wire_header.timestamp + 'Z')
+            aging_block = aging_blocks[wire_timestamp][:block]
+            
+            if wire_header.previous == aging_block.previous
+              puts "\t\tAged block test #{wire_block_num}: √"
+              aging_blocks.delete(wire_timestamp)
+            else
+              puts "\t\tAged block test #{wire_block_num}: detected block-reorganization (#{wire_header.previous} != #{aging_block.previous})"
+              exit
+            end
+          end
+        end
       end
     end
   end
@@ -247,6 +278,8 @@ namespace :stream do
     first_block_num = args[:at_block_num].to_i if !!args[:at_block_num]
     stream = Hive::Stream.new(url: ENV['TEST_NODE'], mode: mode)
     api = Hive::Api.new(url: ENV['TEST_NODE'])
+    ah_api = Hive::AccountHistoryApi.new(url: ENV['TEST_NODE'])
+    round_vops = {}
     
     api.get_dynamic_global_properties do |properties|
       current_block_num = if mode == :head
@@ -259,6 +292,31 @@ namespace :stream do
       first_block_num ||= current_block_num - (rand * 200).to_i
       
       stream.operations(at_block_num: first_block_num, only_virtual: true) do |op, trx_id, block_num|
+        # 126 is about two shuffle rounds (if mode == :head), we need to avoid
+        # the current block_num because we're still in the middle of reading
+        # all of the vops for that block.
+        if round_vops.size > 126 && !round_vops.include?(block_num)
+          ah_api.enum_virtual_ops(block_range_begin: round_vops.keys.min, block_range_end: round_vops.keys.max + 1, include_reversible: true) do |result|
+            round_vops.each do |k, v|
+              later_ops = result.ops.select{|vop| vop.block == k}
+              if (verify_count = later_ops.size) == v.size
+                puts "\t\t#{k} :: streamed vop count was #{v.size} √"
+              else
+                puts "\t\t#{k} :: streamed vop count was #{v.size}, later became #{verify_count}"
+                puts "\t\t\t#{v.map{|op| op.type}.join(', ')}"
+                puts "\t\tLater ops:\n\t\t\t#{later_ops.map{|vop| vop.op.type}.join(', ')}"
+                
+                exit
+              end
+            end
+          end
+          
+          round_vops = {}
+        end
+        
+        round_vops[block_num] ||= []
+        round_vops[block_num] << op
+        
         puts "#{block_num} :: #{trx_id}; op: #{op.type}"
       end
     end
@@ -286,6 +344,78 @@ namespace :stream do
       end
     end
   end
+  
+  desc 'Test the ability to stream all operations (including virtual) that match a pattern.'
+  task :op_pattern, [:pattern, :mode, :at_block_num] do |t, args|
+    mode = (args[:mode] || 'irreversible').to_sym
+    first_block_num = args[:at_block_num].to_i if !!args[:at_block_num]
+    stream = Hive::Stream.new(url: ENV['TEST_NODE'], mode: mode)
+    api = Hive::Api.new(url: ENV['TEST_NODE'])
+    pattern = /#{args[:pattern]}/i
+    
+    api.get_dynamic_global_properties do |properties|
+      current_block_num = if mode == :head
+        properties.head_block_number
+      else
+        properties.last_irreversible_block_num
+      end
+      
+      # First pass replays latest a random number of blocks to test chunking.
+      first_block_num ||= current_block_num - (rand * 200).to_i
+      
+      stream.operations(at_block_num: first_block_num, include_virtual: true) do |op, trx_id, block_num|
+        next unless op.to_json =~ pattern
+        
+        puts "#{block_num} :: #{trx_id}; op: #{op.to_json}"
+      end
+    end
+  end
+  
+  desc 'Test the ability to stream all effective_comment_vote_operation operations.'
+  task :effective_comment_vote_operation, [:mode, :at_block_num] do |t, args|
+    mode = (args[:mode] || 'irreversible').to_sym
+    first_block_num = args[:at_block_num].to_i if !!args[:at_block_num]
+    stream = Hive::Stream.new(url: ENV['TEST_NODE'], mode: mode, no_warn: true)
+    api = Hive::Api.new(url: ENV['TEST_NODE'])
+    
+    api.get_dynamic_global_properties do |properties|
+      current_block_num = if mode == :head
+        properties.head_block_number
+      else
+        properties.last_irreversible_block_num
+      end
+      
+      # First pass replays latest a random number of blocks to test chunking.
+      first_block_num ||= current_block_num - (rand * 200).to_i
+      
+      stream.operations(at_block_num: first_block_num, include_virtual: true) do |op, trx_id, block_num|
+        next unless op.type == 'effective_comment_vote_operation'
+        pending_payout = Hive::Type::Amount.new(op.value.pending_payout)
+        
+        puts "#{block_num} :: #{trx_id}; voter: #{op.value.voter}, author: #{op.value.author}, pending_payout: #{pending_payout}"
+      end
+    end
+  end
+end
+
+desc 'List hardforks.'
+task :hardforks do
+  database_api = Hive::DatabaseApi.new(url: ENV['TEST_NODE'])
+  block_api = Hive::BlockApi.new(url: ENV['TEST_NODE'])
+  ah_api = Hive::AccountHistoryApi.new(url: ENV['TEST_NODE'])
+  last_hf_timestamp = block_api.get_block(block_num: 1) do |result|
+    Time.parse(result.block.timestamp + 'Z')
+  end
+  
+  database_api.get_hardfork_properties do |properties|
+    processed_hardforks = properties.processed_hardforks
+    
+    processed_hardforks.each_with_index do |timestamp, index|
+      timestamp = Time.parse(timestamp + 'Z')
+      
+      puts "HF#{index}: #{timestamp}"
+    end
+  end
 end
 
 YARD::Rake::YardocTask.new do |t|

data/hive-ruby.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test)/}) }
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.16', '>= 1.16.1'
+  spec.add_development_dependency 'bundler', '~> 2.1', '>= 2.1.4'
   spec.add_development_dependency 'rake', '~> 13.0.1', '>= 12.3.0'
   spec.add_development_dependency 'minitest', '~> 5.14', '>= 5.10.3'
   spec.add_development_dependency 'minitest-line', '~> 0.6', '>= 0.6.4'
@@ -32,8 +32,8 @@ Gem::Specification.new do |spec|
   
   spec.add_dependency 'json', '~> 2.1', '>= 2.1.0'
   spec.add_dependency 'logging', '~> 2.2', '>= 2.2.0'
-  spec.add_dependency 'hashie', '~> 3.5', '>= 3.5.7'
-  spec.add_dependency 'bitcoin-ruby', '~> 0.0', '>= 0.0.18'
+  spec.add_dependency 'hashie', '>= 3.5'
+  spec.add_dependency 'bitcoin-ruby', '~> 0.0', '0.0.20'
   spec.add_dependency 'ffi', '~> 1.9', '>= 1.9.23'
   spec.add_dependency 'bindata', '~> 2.4', '>= 2.4.4'
   spec.add_dependency 'base58', '~> 0.2', '>= 0.2.3'

data/lib/hive/api.rb

@@ -118,7 +118,9 @@ module Hive
         
         if Jsonrpc::UNLISTED_APIS.include? @api_name
           @methods ||= {}
-          @methods[@api_name] ||= Fallback::API_METHODS[@api_name]
+          @methods[@api_name] ||= []
+          @methods[@api_name] += Fallback::API_METHODS[@api_name]
+          @methods[@api_name] = @methods[@api_name].uniq
         end
         
         unless !!@methods[@api_name]
@@ -191,7 +193,18 @@ module Hive
           # Some argument are optional, but if the arguments passed are greater
           # than the expected arguments size, we can warn.
           if args_size > expected_args_size
-            @error_pipe.puts "Warning #{rpc_method_name} expects arguments: #{expected_args_size}, got: #{args_size}"
+            if rpc_method_name == 'account_history_api.get_account_history' && expected_args_size == 3 && args_size == 6
+              # TODO Remove this condition if they ever fix this issue:
+              # https://gitlab.syncad.com/hive/hive/-/issues/100
+            elsif rpc_method_name == 'account_history_api.get_ops_in_block' && expected_args_size == 2 && args_size == 3
+              # TODO Remove this condition if they ever fix this issue:
+              # https://gitlab.syncad.com/hive/hive/-/issues/100
+            elsif rpc_method_name == 'account_history_api.enum_virtual_ops' && expected_args_size == 2 && args_size == 3
+              # TODO Remove this condition if they ever fix this issue:
+              # https://gitlab.syncad.com/hive/hive/-/issues/100
+            else
+              @error_pipe.puts "Warning #{rpc_method_name} expects arguments: #{expected_args_size}, got: #{args_size}"
+            end
           end
         rescue NoMethodError => e
           error = Hive::ArgumentError.new("#{rpc_method_name} expects arguments: #{expected_args_size}", e)

data/lib/hive/base_error.rb

@@ -19,17 +19,21 @@ module Hive
       end
       
       if error.message.include? 'Internal Error'
-        raise Hive::RemoteNodeError, error.message, build_backtrace(error)
+        raise Hive::RemoteInternalError, error.message, build_backtrace(error)
       end
       
       if error.message.include? 'Server error'
-        raise Hive::RemoteNodeError, error.message, build_backtrace(error)
+        raise Hive::RemoteServerError, error.message, build_backtrace(error)
       end
       
-      if error.message.include? 'plugin not enabled'
+      if error.message.include?('plugin not enabled') || error.message.include?('Could not find API')
         raise Hive::PluginNotEnabledError, error.message, build_backtrace(error)
       end
       
+      if error.message.include? 'Supported by hivemind'
+        raise Hive::MethodNotEnabledError, error.message, build_backtrace(error)
+      end
+      
       if error.message.include? 'argument'
         raise Hive::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
       end
@@ -210,9 +214,12 @@ module Hive
   class IncorrectRequestIdError < BaseError; end
   class IncorrectResponseIdError < BaseError; end
   class RemoteNodeError < BaseError; end
+  class RemoteInternalError < BaseError; end
+  class RemoteServerError < BaseError; end
   class UpstreamResponseError < RemoteNodeError; end
   class RemoteDatabaseLockError < UpstreamResponseError; end
   class PluginNotEnabledError < UpstreamResponseError; end
+  class MethodNotEnabledError < UpstreamResponseError; end
   class RequestTimeoutUpstreamResponseError < UpstreamResponseError; end
   class BadOrMissingUpstreamResponseError < UpstreamResponseError; end
   class TransactionIndexDisabledError < BaseError; end

data/lib/hive/block_api.rb

@@ -6,6 +6,8 @@ module Hive
   # Also see: {https://developers.hive.io/apidefinitions/block-api.html Block API Definitions}
   class BlockApi < Api
     MAX_RANGE_SIZE = 50
+    MAX_NO_BATCH_RANGE_SIZE = 200
+    MAX_NO_BATCH_NO_RANGE_SIZE = 1
     
     def initialize(options = {})
       self.class.api_name = :block_api
@@ -20,24 +22,30 @@ module Hive
       get_block_objects(options.merge(object: :block_header), block)
     end
     
-    # Uses a batched requst on a range of blocks.
+    # Uses get_block_range (or batched requsts) on a range of blocks.
     #
     # @param options [Hash] The attributes to get a block range with.
     # @option options [Range] :block_range starting on one block number and ending on an higher block number.
-    def get_blocks(options = {block_range: (0..0)}, &block)
+    # @option options [Boolean] :use_batch use json-rpc batch instead of get_block_range (preferred)
+    def get_blocks(options = {block_range: (0..0), use_batch: false}, &block)
       get_block_objects(options.merge(object: :block), block)
     end
   private
-    def get_block_objects(options = {block_range: (0..0)}, block = nil)
+    def get_block_objects(options = {block_range: (0..0), use_batch: false}, block = nil)
       object = options[:object]
-      object_method = "get_#{object}".to_sym
       block_range = options[:block_range] || (0..0)
+      use_batch = !!options[:use_batch]
+      
+      object = :block_range if object == :block && !use_batch
+      object_method = "get_#{object}".to_sym
       
-      if (start = block_range.first) < 1
+      if !!block_range && block_range.any? && (start = block_range.first) < 1
         raise Hive::ArgumentError, "Invalid starting block: #{start}"
       end
       
-      chunks = if block_range.size > MAX_RANGE_SIZE
+      chunks = if object == :block_range
+        block_range.each_slice(MAX_NO_BATCH_RANGE_SIZE)
+      elsif block_range.size > MAX_RANGE_SIZE
         block_range.each_slice(MAX_RANGE_SIZE)
       else
         [block_range]
@@ -46,27 +54,65 @@ module Hive
       for sub_range in chunks do
         request_object = []
         
-        for i in sub_range do
-          @rpc_client.put(self.class.api_name, object_method, block_num: i, request_object: request_object)
+        if !!use_batch
+          for i in sub_range do
+            @rpc_client.put(self.class.api_name, object_method, block_num: i, request_object: request_object)
+          end
+        else
+          case object
+          when :block_header
+            # Must use json-rpc batch for block headers request.
+            for i in sub_range do
+              @rpc_client.put(self.class.api_name, :get_block_header, block_num: i, request_object: request_object)
+            end
+          when :block, :block_range
+            if sub_range.size == 1
+              @rpc_client.put(self.class.api_name, :get_block, block_num: sub_range.first, request_object: request_object)
+            else
+              @rpc_client.put(self.class.api_name, :get_block_range, starting_block_num: sub_range.first, count: sub_range.size, request_object: request_object)
+            end
+          end
         end
         
         if !!block
           index = 0
           @rpc_client.rpc_batch_execute(api_name: self.class.api_name, request_object: request_object) do |result, error, id|
+            raise Hive::RemoteNodeError, error.to_json if !!error
+            
             block_num = sub_range.to_a[index]
             index = index + 1
             
             case object
             when :block_header
-              block.call(result.nil? ? nil : result[:header], block_num)
+              block.call(result[:header], block_num)
             else
-              block.call(result.nil? ? nil : result[object], block_num)
+              if !!use_batch || !!result[:block]
+                block.call(result[:block] || result[object], block_num)
+              else
+                current_block_num = block_num
+                result[:blocks].each do |b|
+                  # Now verify that the previous block_num really is the
+                  # previous block.
+                  
+                  decoded_previous_block_num = b.previous[0..7].to_i(16)
+                  previous_block_num = current_block_num - 1
+                  
+                  unless decoded_previous_block_num == previous_block_num
+                    raise Hive::RemoteNodeError, "Wrong block_num.  Got #{decoded_previous_block_num}, expected #{previous_block_num}"
+                  end
+                  
+                  block.call(b, current_block_num)
+                  current_block_num = current_block_num + 1
+                end
+              end
             end
           end
         else
           blocks = []
           
           @rpc_client.rpc_batch_execute(api_name: self.class.api_name, request_object: request_object) do |result, error, id|
+            raise Hive::RemoteNodeError, error.to_json if !!error
+            
             blocks << result
           end
         end

data/lib/hive/broadcast.rb

@@ -137,7 +137,7 @@ module Hive
     #   * :parent_permlink (String) (automatic) Parent permlink of the content, defaults to first tag.
     #   * :parent_author (String) (optional) Parent author of the content (only used if reply).
     #   * :max_accepted_payout (String) (1000000.000 HBD) Maximum accepted payout, set to '0.000 HBD' to deline payout
-    #   * :percent_steem_dollars (Numeric) (5000) Percent HIVE Dollars is used to set 50/50 or 100% HIVE Power
+    #   * :percent_hbd (Numeric) (5000) Percent HIVE Dollars is used to set 50/50 or 100% HIVE Power
     #   * :allow_votes (Numeric) (true) Allow votes for this content.
     #   * :allow_curation_rewards (Numeric) (true) Allow curation rewards for this content.
     #   * :beneficiaries (Array<Hash>) Sets the beneficiaries of this content.
@@ -196,7 +196,7 @@ module Hive
         author: params[:author],
         permlink: params[:permlink],
         max_accepted_payout: max_accepted_payout,
-        percent_steem_dollars: params[:percent_steem_dollars] || 10000,
+        percent_hbd: params[:percent_hbd] || 10000,
         # allow_replies: allow_replies,
         allow_votes: allow_votes,
         allow_curation_rewards: allow_curation_rewards,
@@ -646,7 +646,7 @@ module Hive
     #         props: {
     #           account_creation_fee: '0.000 HIVE',
     #           maximum_block_size: 131072,
-    #           sbd_interest_rate:1000
+    #           hbd_interest_rate:1000
     #         },
     #         fee: '0.000 HIVE',
     #       }
@@ -688,10 +688,10 @@ module Hive
     #         props: {
     #           account_creation_fee: '0.000 HIVE',
     #           maximum_block_size: 131072,
-    #           sbd_interest_rate: 1000,
+    #           hbd_interest_rate: 1000,
     #           account_subsidy_budget: 50000,
     #           account_subsidy_decay: 330782,
-    #           sbd_exchange_rate: '1.000 HIVE',
+    #           hbd_exchange_rate: '1.000 HIVE',
     #           url: "https://hive.blog",
     #           new_signing_key: 'STM8LoQjQqJHvotqBo7HjnqmUbFW9oJ2theyqonzUd9DdJ7YYHsvD'
     #         }
@@ -719,15 +719,19 @@ module Hive
         props[:account_creation_fee] = hexlify normalize_amount(options.merge amount: account_creation_fee, serialize: true)
       end
       
-      if !!(sbd_exchange_rate = props[:sbd_exchange_rate] rescue nil)
-        props[:sbd_exchange_rate][:base] = normalize_amount(options.merge amount: sbd_exchange_rate[:base], serialize: true)
-        props[:sbd_exchange_rate][:quote] = normalize_amount(options.merge amount: sbd_exchange_rate[:quote], serialize: true)
-        props[:sbd_exchange_rate] = hexlify props[:sbd_exchange_rate].to_json
+      if !!(hbd_exchange_rate = props[:hbd_exchange_rate] rescue nil)
+        props[:hbd_exchange_rate][:base] = normalize_amount(options.merge amount: hbd_exchange_rate[:base], serialize: true)
+        props[:hbd_exchange_rate][:quote] = normalize_amount(options.merge amount: hbd_exchange_rate[:quote], serialize: true)
+        props[:hbd_exchange_rate] = hexlify props[:hbd_exchange_rate].to_json
       end
       
       %i(key new_signing_key).each do |key|
-        if !!props[key] && props[key].length == 53
-          props[key] = hexlify props[key][3..-1]
+        begin
+          if !!props[key] && props[key].length == 53
+            props[key] = hexlify props[key][3..-1]
+          end
+        rescue => e
+          raise Hive::ArgumentError, "Unable to parse #{key}: #{e}"
         end
       end
       
@@ -953,8 +957,8 @@ module Hive
     #   * :to (String)
     #   * :agent (String)
     #   * :escrow_id (String)
-    #   * :sbd_amount (String)
-    #   * :steem_amount (String)
+    #   * :hbd_amount (String)
+    #   * :hive_amount (String)
     #   * :fee (String)
     #   * :ratification_deadline (String)
     #   * :escrow_expiration (String)
@@ -976,8 +980,8 @@ module Hive
       
       check_required_fields(params, *required_fields)
       
-      params[:sbd_amount] = normalize_amount(options.merge amount: params[:sbd_amount])
-      params[:steem_amount] = normalize_amount(options.merge amount: params[:steem_amount])
+      params[:hbd_amount] = normalize_amount(options.merge amount: params[:hbd_amount])
+      params[:hive_amount] = normalize_amount(options.merge amount: params[:hive_amount])
       params[:fee] = normalize_amount(options.merge amount: params[:fee])
       
       params[:ratification_deadline] = Time.parse(params[:ratification_deadline].to_s)
@@ -1028,8 +1032,8 @@ module Hive
     #   * :who (String)
     #   * :receiver (String)
     #   * :escrow_id (String)
-    #   * :sbd_amount (String)
-    #   * :steem_amount (String)
+    #   * :hbd_amount (String)
+    #   * :hive_amount (String)
     # @option options [Boolean] :pretend Just validate, do not broadcast.
     # @see https://developers.hive.io/apidefinitions/broadcast-ops.html#broadcast_ops_escrow_release
     def self.escrow_release(options, &block)
@@ -1037,8 +1041,8 @@ module Hive
       params = options[:params]
       check_required_fields(params, *required_fields)
       
-      params[:sbd_amount] = normalize_amount(options.merge amount: params[:sbd_amount])
-      params[:steem_amount] = normalize_amount(options.merge amount: params[:steem_amount])
+      params[:hbd_amount] = normalize_amount(options.merge amount: params[:hbd_amount])
+      params[:hive_amount] = normalize_amount(options.merge amount: params[:hive_amount])
 
       ops = [[:escrow_release, params]]
       
@@ -1242,8 +1246,8 @@ module Hive
     # @option options [String] :wif Posting wif
     # @option options [Hash] :params
     #   * :account (String) Account claiming rewards.
-    #   * :reward_steem (Amount) Amount of HIVE to claim.
-    #   * :reward_sbd (Amount) Amount of HBD to claim.
+    #   * :reward_hive (Amount) Amount of HIVE to claim.
+    #   * :reward_hbd (Amount) Amount of HBD to claim.
     #   * :reward_vests (Amount) Amount of VESTS to claim.
     # @option options [Boolean] :pretend Just validate, do not broadcast.
     # @see https://developers.hive.io/apidefinitions/broadcast-ops.html#broadcast_ops_claim_reward_balance
@@ -1253,8 +1257,8 @@ module Hive
       
       check_required_fields(params, *required_fields)
       
-      params[:reward_steem] = normalize_amount(options.merge amount: params[:reward_steem])
-      params[:reward_sbd] = normalize_amount(options.merge amount: params[:reward_sbd])
+      params[:reward_hive] = normalize_amount(options.merge amount: params[:reward_hive])
+      params[:reward_hbd] = normalize_amount(options.merge amount: params[:reward_hbd])
       params[:reward_vests] = normalize_amount(options.merge amount: params[:reward_vests])
       
       ops = [[:claim_reward_balance, params]]

data/lib/hive/fallback.rb

@@ -106,7 +106,6 @@ module Hive::Fallback
       :find_limit_orders,
       :find_owner_histories,
       :find_savings_withdrawals,
-      :find_sbd_conversion_requests,
       :find_vesting_delegation_expirations,
       :find_vesting_delegations,
       :find_votes,
@@ -134,7 +133,6 @@ module Hive::Fallback
       :list_limit_orders,
       :list_owner_histories,
       :list_savings_withdrawals,
-      :list_sbd_conversion_requests,
       :list_vesting_delegation_expirations,
       :list_vesting_delegations,
       :list_votes,
@@ -242,7 +240,7 @@ module Hive::Fallback
       find_owner_histories: {owner: String},
       find_proposals: {proposal_ids: []},
       find_savings_withdrawals: {account: String},
-      find_sbd_conversion_requests: {account: String},
+      find_hbd_conversion_requests: {account: String},
       find_vesting_delegation_expirations: {account: String},
       find_vesting_delegations: {account: String},
       find_votes: {author: String, permlink: String},
@@ -272,7 +270,7 @@ module Hive::Fallback
       list_proposal_votes: {start: NilClass, limit: Integer, order: String, order_direction: String, status: String},
       list_proposals: {start: NilClass, limit: Integer, order: String, order_direction: String, status: String},
       list_savings_withdrawals: {start: NilClass, limit: Integer, order: String},
-      list_sbd_conversion_requests: {start: NilClass, limit: Integer, order: String},
+      list_hbd_conversion_requests: {start: NilClass, limit: Integer, order: String},
       list_vesting_delegation_expirations: {start: NilClass, limit: Integer, order: String},
       list_vesting_delegations: {start: NilClass, limit: Integer, order: String},
       list_votes: {start: NilClass, limit: Integer, order: String},

data/lib/hive/jsonrpc.rb

@@ -11,7 +11,7 @@ module Hive
     
     # APIs that the RPC server will (or likely will) respond to that is
     # maintained outside the view of jsonrpc.
-    UNLISTED_APIS = %i(bridge)
+    UNLISTED_APIS = %i(bridge database_api)
     
     def self.api_methods
       @api_methods ||= {}

data/lib/hive/marshal.rb

@@ -144,7 +144,7 @@ module Hive
       {
         account_creation_fee: amount,
         maximum_block_size: uint32,
-        sbd_interest_rate: uint16
+        hbd_interest_rate: uint16
       }
     end
     
@@ -161,12 +161,12 @@ module Hive
         when :account_creation_fee then Hive::Type::Amount.new(string)
         # when :account_subsidy_budget then int32
         # when :account_subsidy_decay, :maximum_block_size then uint32
-        when :sbd_exchange_rate
+        when :hbd_exchange_rate
           JSON[string].tap do |rate|
             rate["base"] = Hive::Type::Amount.new(rate["base"])
             rate["quote"] = Hive::Type::Amount.new(rate["quote"])
           end
-        # when :sbd_interest_rate then uint16
+        # when :hbd_interest_rate then uint16
         when :url, :key, :new_signing_key then string
         else; warn "Unsupported witness property: #{key}"
         end

data/lib/hive/operation.rb

@@ -5,7 +5,7 @@ module Hive
     include Utils
     
     # IDs derrived from:
-    # https://gitlab.syncad.com/hive/hive/-/blob/master/libraries/protocol/include/steem/protocol/operations.hpp
+    # https://gitlab.syncad.com/hive/hive/-/blob/master/libraries/protocol/include/hive/protocol/operations.hpp
     
     IDS = [
       :vote_operation,
@@ -64,18 +64,18 @@ module Hive
       :create_proposal_operation,
       :update_proposal_votes_operation,
       :remove_proposal_operation,
+      :update_proposal_operation,
       
       # SMT operations
       :claim_reward_balance2_operation,
       
       :smt_setup_operation,
-      :smt_cap_reveal_operation,
-      :smt_refund_operation,
       :smt_setup_emissions_operation,
       :smt_set_setup_parameters_operation,
       :smt_set_runtime_parameters_operation,
       :smt_create_operation,
-      
+      :smt_contribute_operation
+    ] + VIRTUAL_OP_IDS = [
       # virtual operations below this point
       :fill_convert_request_operation,
       :author_reward_operation,
@@ -92,7 +92,16 @@ module Hive
       :return_vesting_delegation_operation,
       :comment_benefactor_reward_operation,
       :producer_reward_operation,
-      :clear_null_account_balance_operation
+      :clear_null_account_balance_operation,
+      :proposal_pay_operation,
+      :sps_fund_operation,
+      :hardfork_hive_operation,
+      :hardfork_hive_restore_operation,
+      :delayed_voting_operation,
+      :consolidate_treasury_balance_operation,
+      :effective_comment_vote_operation,
+      :ineffective_delete_comment_operation,
+      :sps_convert_operation
     ]
     
     def self.op_id(op)

data/lib/hive/operation/claim_reward_balance.rb

@@ -1,6 +1,6 @@
 class Hive::Operation::ClaimRewardBalance < Hive::Operation
   def_attr account: :string
-  def_attr reward_steem: :amount
-  def_attr reward_sbd: :amount
+  def_attr reward_hive: :amount
+  def_attr reward_hbd: :amount
   def_attr reward_vests: :amount
 end

data/lib/hive/operation/comment_options.rb

@@ -2,7 +2,7 @@ class Hive::Operation::CommentOptions < Hive::Operation
   def_attr author: :string
   def_attr permlink: :string
   def_attr max_accepted_payout: :amount
-  def_attr percent_steem_dollars: :uint32
+  def_attr percent_hbd: :uint32
   # def_attr allow_replies: :boolean
   def_attr allow_votes: :boolean
   def_attr allow_curation_rewards: :boolean

data/lib/hive/operation/escrow_release.rb

@@ -5,6 +5,6 @@ class Hive::Operation::EscrowRelease < Hive::Operation
   def_attr who: :string
   def_attr receiver: :string
   def_attr escrow_id: :uint32
-  def_attr sbd_amount: :amount
-  def_attr steem_amount: :amount
+  def_attr hbd_amount: :amount
+  def_attr hive_amount: :amount
 end

data/lib/hive/operation/escrow_transfer.rb

@@ -1,8 +1,8 @@
 class Hive::Operation::EscrowTransfer < Hive::Operation
   def_attr from: :string
   def_attr to: :string
-  def_attr sbd_amount: :amount
-  def_attr steem_amount: :amount
+  def_attr hbd_amount: :amount
+  def_attr hive_amount: :amount
   def_attr escrow_id: :uint32
   def_attr agent: :string
   def_attr fee: :amount

data/lib/hive/rpc/http_client.rb

@@ -18,7 +18,8 @@ module Hive
       # @private
       TIMEOUT_ERRORS = [Net::OpenTimeout, JSON::ParserError, Net::ReadTimeout,
         Errno::EBADF, IOError, Errno::ENETDOWN, Hive::RemoteDatabaseLockError,
-        Hive::RequestTimeoutUpstreamResponseError, Hive::RemoteNodeError]
+        Hive::RequestTimeoutUpstreamResponseError, Hive::RemoteServerError,
+        Hive::RemoteServerError]
       
       # @private
       POST_HEADERS = {
@@ -61,12 +62,13 @@ module Hive
         response = nil
         
         loop do
+          sub_options = options.dup
           request = http_post(api_name)
           
           request_object = if !!api_name && !!api_method
-            put(api_name, api_method, options)
-          elsif !!options && defined?(options.delete)
-            options.delete(:request_object)
+            put(api_name, api_method, sub_options)
+          elsif !!options && defined?(sub_options.delete)
+            sub_options.delete(:request_object)
           end
           
           if request_object.size > JSON_RPC_BATCH_SIZE_MAXIMUM
@@ -123,7 +125,7 @@ module Hive
                     raise_error_response rpc_method_name, rpc_args, r
                   rescue *TIMEOUT_ERRORS => e
                     timeout_detected = true
-                    timeout_cause = nil
+                    timeout_cause = JSON[e.message]['error'] + " while posting: #{rpc_args}" rescue e.to_s
                     
                     break # fail fast
                   end

data/lib/hive/stream.rb

@@ -35,7 +35,9 @@ module Hive
     MAX_RETRY_COUNT = 10
     
     VOP_TRX_ID = ('0' * 40).freeze
-
+    MAX_VOP_READ_AHEAD = 100
+    SHUFFLE_ROUND_LENGTH = 21
+    
     # @param options [Hash] additional options
     # @option options [Hive::DatabaseApi] :database_api
     # @option options [Hive::BlockApi] :block_api
@@ -92,7 +94,7 @@ module Hive
     def transactions(options = {}, &block)
       blocks(options) do |block, block_num|
         if block.nil?
-          warn "Batch missing block_num: #{block_num}, retrying ..."
+          warn "Batch missing block_num: #{block_num}, retrying ..." unless @no_warn
           
           block = block_api.get_block(block_num: block_num) do |result|
             result.block
@@ -173,7 +175,7 @@ module Hive
     #   stream = Hive::Stream.new
     #   stream.operations(types: :author_reward_operation, only_virtual: true) do |vop|
     #     v = vop.value
-    #     puts "#{v.author} got paid for #{v.permlink}: #{[v.sbd_payout, v.steem_payout, v.vesting_payout]}"
+    #     puts "#{v.author} got paid for #{v.permlink}: #{[v.hbd_payout, v.hive_payout, v.vesting_payout]}"
     #   end
     #
     # ... or multiple virtual operation types;
@@ -214,6 +216,10 @@ module Hive
       only_virtual = false
       include_virtual = false
       last_block_num = nil
+      within_shuffle_round = nil
+      initial_head_block_number = database_api.get_dynamic_global_properties do |dgpo|
+        dgpo.head_block_number
+      end
       
       case args.first
       when Hash
@@ -226,7 +232,9 @@ module Hive
       
       if only_virtual
         block_numbers(options) do |block_num|
-          get_virtual_ops(types, block_num, block)
+          within_shuffle_round ||= initial_head_block_number - block_num < SHUFFLE_ROUND_LENGTH * 2
+
+          get_virtual_ops(types, block_num, within_shuffle_round, block)
         end
       else
         transactions(options) do |transaction, trx_id, block_num|
@@ -236,8 +244,9 @@ module Hive
             next unless last_block_num != block_num
             
             last_block_num = block_num
+            within_shuffle_round ||= initial_head_block_number - block_num < SHUFFLE_ROUND_LENGTH * 2
             
-            get_virtual_ops(types, block_num, block) if include_virtual
+            get_virtual_ops(types, block_num, within_shuffle_round, block) if include_virtual
           end
         end
       end
@@ -257,6 +266,7 @@ module Hive
       object = options[:object]
       object_method = "get_#{object}".to_sym
       block_interval = BLOCK_INTERVAL
+      use_block_range = true
       
       at_block_num, until_block_num = if !!block_range = options[:block_range]
         [block_range.first, block_range.last]
@@ -281,9 +291,32 @@ module Hive
                 block_interval = BLOCK_INTERVAL
               end
             else
-              block_api.send(object_method, block_range: range) do |b, n|
-                block.call b, n
-                block_interval = BLOCK_INTERVAL
+              loop do
+                begin
+                  if use_block_range
+                    block_api.send(object_method, block_range: range) do |b, n|
+                      block.call b, n
+                      block_interval = BLOCK_INTERVAL
+                    end
+                  else
+                    range.each do |block_num|
+                      block_api.get_block(block_num: block_num) do |b, n|
+                        block.call b.block, b.block.block_id[0..7].to_i(16)
+                        block_interval = BLOCK_INTERVAL
+                      end
+                    end
+                  end
+                rescue Hive::UnknownError => e
+                  if e.message =~ /Could not find method get_block_range/
+                    use_block_range = false
+                    
+                    redo
+                  end
+                  
+                  raise e
+                end
+                
+                break
               end
             end
             
@@ -325,22 +358,96 @@ module Hive
     end
     
     # @private
-    def get_virtual_ops(types, block_num, block)
+    def get_virtual_ops(types, block_num, within_shuffle_round, block)
       retries = 0
+      vop_read_ahead = within_shuffle_round ? 1 : MAX_VOP_READ_AHEAD
+
+      @virtual_ops_cache ||= {}
+      @virtual_ops_cache = @virtual_ops_cache.reject do |k, v|
+        if k < block_num
+          warn "Found orphaned virtual operations for block_num #{k}: #{v.to_json}" unless @no_warn
+          
+          true
+        end
+        
+        false
+      end
       
       loop do
-        get_ops_in_block_options = case account_history_api
+        vops_found = false
+        
+        if account_history_api.class == Hive::AccountHistoryApi || @enum_virtual_ops_supported.nil? && @enum_virtual_ops_supported != false
+          begin
+            # Use account_history_api.enum_virtual_ops, if supported.
+            
+            if @virtual_ops_cache.empty? || !@virtual_ops_cache.keys.include?(block_num)
+              (block_num..(block_num + vop_read_ahead)).each do |block_num|
+                @virtual_ops_cache[block_num] = []
+              end
+              
+              enum_virtual_ops_options = {
+                block_range_begin: block_num,
+                block_range_end: block_num + vop_read_ahead,
+                # TODO Use: mode != :irreversible
+                include_reversible: true
+              }
+              
+              account_history_api.enum_virtual_ops(enum_virtual_ops_options) do |result|
+                @enum_virtual_ops_supported = true
+                
+                result.ops.each do |vop|
+                  @virtual_ops_cache[vop.block] << vop
+                end
+              end
+            end
+            
+            vops_found = true
+            
+            if !!@virtual_ops_cache[block_num]
+              @virtual_ops_cache[block_num].each do |vop|
+                next unless block_num == vop.block
+                next if types.any? && !types.include?(vop.op.type)
+                
+                if vop.virtual_op == 0
+                  # require 'pry' ; binding.pry if vop.op.type == 'producer_reward_operation'
+                  warn "Found non-virtual operation (#{vop.op.type}) in enum_virtual_ops result for block: #{block_num}" unless @no_warn
+                  
+                  next
+                end
+                
+                block.call vop.op, vop.trx_id, block_num
+              end
+              
+              @virtual_ops_cache.delete(block_num)
+            end
+          rescue Hive::UnknownError => e
+            if e.message =~ /This API is not supported for account history backed by Chainbase/
+              warn "Retrying with get_ops_in_block (api does not support enum_virtual_ops)" unless @no_warn
+              @enum_virtual_ops_supported = false
+              vops_found = false
+            else
+              raise e
+            end
+          end
+        end
+        
+        break if vops_found
+        
+        # Fallback to previous method.
+        warn "Retrying with get_ops_in_block (did not find ops for block #{block_num} using enum_virtual_ops)" unless @no_warn
+        
+        response = case account_history_api
         when Hive::CondenserApi
-          [block_num, true]
+          account_history_api.get_ops_in_block(block_num, true)
         when Hive::AccountHistoryApi
-          {
+          account_history_api.get_ops_in_block(
             block_num: block_num,
-            only_virtual: true
-          }
+            only_virtual: true,
+            # TODO Use: mode != :irreversible
+            include_reversible: true
+          )
         end
         
-        response = account_history_api.get_ops_in_block(*get_ops_in_block_options)
-        
         if response.nil? || (result = response.result).nil?
           if retries < MAX_RETRY_COUNT
             warn "Retrying get_ops_in_block on block #{block_num}" unless @no_warn
@@ -367,7 +474,7 @@ module Hive
             retries = retries + 1
             redo
           else
-            warn "unable to find virtual operations for block: #{block_num}"
+            warn "unable to find virtual operations for block: #{block_num}" unless @no_warn
             # raise TooManyRetriesError, "unable to find virtual operations for block: #{block_num}"
           end
         end
@@ -375,7 +482,7 @@ module Hive
         ops.each do |op|
           next if types.any? && !types.include?(op.type)
           
-          block.call op, VOP_TRX_ID, block_num
+          block.call op, vop.trx_id, block_num
         end
         
         break

data/lib/hive/version.rb

@@ -1,4 +1,4 @@
 module Hive
-  VERSION = '1.0.0-2'
+  VERSION = '1.0.3'
   AGENT_ID = "hive-ruby/#{VERSION}"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hive-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Anthony Martin
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-15 00:00:00.000000000 Z
+date: 2021-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.16.1
+        version: 2.1.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.16.1
+        version: 2.1.4
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -294,22 +294,16 @@ dependencies:
   name: hashie
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.5.7
+        version: '3.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.5.7
+        version: '3.5'
 - !ruby/object:Gem::Dependency
   name: bitcoin-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -317,9 +311,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.0'
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.18
+        version: 0.0.20
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -327,9 +321,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.0'
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.18
+        version: 0.0.20
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
@@ -497,9 +491,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.0.8
 signing_key: