steem-ruby 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af48ecaba4ce86c2a21a91bd5299939408505ab7
-  data.tar.gz: e8dfa541ebb4000a6dbb6f05e318fdecda6a9f98
+  metadata.gz: 24650742975337b2832ba5ab426f609a5ff8c9ef
+  data.tar.gz: 827c4848766e9b54dc8f04f5e20c920d3964c4eb
 SHA512:
-  metadata.gz: 5d57efdf7b7e1d64b7b513b6e44c68304603525e6bb09001df3494c7616f823d3adf90572e6b73ee474f79c78aa55530a1a73338f8b2af519e38f070d41835b8
-  data.tar.gz: 1056b940f606dd018b5cfcd1f134273b7e59e0587776d7841f2a6ef80aa3b1cbe3e562ddcfb31581c885205e608e816c78a510831a29cdc46c4308d59c6659c9
+  metadata.gz: 40b66f82639c1db97bf844bc07414f4ef512decec1fa4bf99bbc789ac1916379d96d03eebc417a89a7fcc7dcbbcbd9c29d82c3dd08958e3331712b2af4450f04
+  data.tar.gz: 37183706e9bdb150df65afb03d697c6a8cca050d3e3a3ac605054e46ba10d6a0897dc28e55a8035cc10f0a8df7d144fe548bd887344b132fa47f29518ae945be

data/.gitignore

@@ -7,7 +7,7 @@
 /spec/reports/
 /spec/examples.txt
 /test/tmp/
-/test/fixtures/vcr_cassettes/
+/test/fixtures/vcr_cassettes/*.yml
 /test/version_tmp/
 /tmp/
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    steem-ruby (0.1.0)
+    steem-ruby (0.1.1)
       bitcoin-ruby (~> 0.0, >= 0.0.18)
       ffi (~> 1.9, >= 1.9.23)
       hashie (~> 3.5, >= 3.5.7)

data/README.md

@@ -1,9 +1,28 @@
+[![Gem Version](https://badge.fury.io/rb/steem-ruby.svg)](https://badge.fury.io/rb/steem-ruby)
+[![Inline docs](http://inch-ci.org/github/steemit/steem-ruby.svg?branch=master&style=shields)](http://inch-ci.org/github/steemit/steem-ruby)
+
 # `steem-ruby`
 
 Steem-ruby the Ruby API for Steem blockchain.
 
 Full documentation: http://www.rubydoc.info/gems/steem-ruby
 
+## `radiator` vs. `steem-ruby`
+
+The `steem-ruby` gem was written from the ground up by `@inertia`, who is also the author of [`radiator`](https://github.com/inertia186/radiator).
+
+> "I intend to continue work on `radiator` indefinitely. But in `radiator-0.5`, I intend to refactor `radiator` so that is uses `steem-ruby` as its core. This means that some features of `radiator` like Serialization will become redundant. I think it's still useful for radiator to do its own serialzation because it reduces the number of API requests." - @inertia
+
+| `radiator` | `steem-ruby` |
+|-|-|
+| Has internal failover logic | Can have failover delegated externally |
+| Passes `error` responses to the caller | Handles `error` responses and raises exceptions |
+| Supports tx signing, does its own serialization | Also supports tx signing, but delegates serialization to `database_api.get_transaction_hex` |
+| All apis and methods are hardcoded | Asks `jsonrpc` what apis and methods are available from the node |
+| (`radiator-0.4.x`) Only supports AppBase but relies on `condenser_api` | Only supports AppBase but does not rely on `condenser_api` **(WIP)**
+| Small list of helper methods for select ops (in addition to build your own transaction) | Complete implementation of helper methods for every op (in addition to build your own transaction) |
+| Does not (yet) support `json-rpc-batch` requests | Supports `json-rpc-batch` requests |
+
 ## Getting Started
 
 The steem-ruby gem is compatible with Ruby 2.2.5 or later.
@@ -47,6 +66,8 @@ Steem::Broadcast.vote(wif: wif, params: params) do |result|
 end
 ```
 
+*See: [Broadcast](https://www.rubydoc.info/gems/steem-ruby/Steem/Broadcast)*
+
 ### Get Accounts
 
 ```ruby
@@ -57,6 +78,8 @@ api.find_accounts(accounts: ['steemit', 'alice']) do |result|
 end
 ```
 
+*See: [Api](https://www.rubydoc.info/gems/steem-ruby/Steem/Api)*
+
 ### Reputation Formatter
 
 ```ruby
@@ -64,6 +87,35 @@ rep = Steem::Formatter.reputation(account.reputation)
 puts rep
 ```
 
+### Tests
+
+* Clone the client repository into a directory of your choice:
+  * `git clone https://github.com/steemit/steem-ruby.git`
+* Navigate into the new folder
+  * `cd steem-ruby`
+* All tests can be invoked as follows:
+  * `bundle exec rake test`
+* To run `static` tests:
+  * `bundle exec rake test:static`
+* To run `broadcast` tests (broadcast is simulated, only `verify` is actually used):
+  * `bundle exec rake test:broadcast`
+* To run `threads` tests (which quickly verifies thread safety):
+  * `bundle exec rake test:threads`
+* To run `testnet` tests (which does actual broadcasts)
+  * `TEST_NODE=https://testnet.steemitdev.com bundle exec rake test:testnet`
+
+You can also run other tests that are not part of the above `test` execution:
+
+* To run `block_range`, which streams blocks (using `json-rpc-batch`)
+  * `bundle exec rake stream:block_range`
+
+
+If you want to point to any node for tests, instead of letting the test suite pick the default, set the environment variable to `TEST_NODE`, e.g.:
+
+```bash
+$ TEST_NODE=https://api.steemitdev.com bundle exec rake test
+```
+
 ## Contributions
 
 Patches are welcome! Contributors are listed in the `steem-ruby.gemspec` file. Please run the tests (`rake test`) before opening a pull request and make sure that you are passing all of them. If you would like to contribute, but don't know what to work on, check the issues list.

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake/testtask'
 require 'yard'
 require 'steem'
 
-Rake::TestTask.new(test: 'clean:vcr') do |t|
+Rake::TestTask.new(test: ['clean:vcr', 'test:threads']) do |t|
   t.libs << 'test'
   t.libs << 'lib'
   t.test_files = FileList['test/**/*_test.rb']
@@ -59,6 +59,124 @@ namespace :test do
       '-W1'
     end
   end
+  
+  Rake::TestTask.new(testnet: 'clean:vcr') do |t|
+    t.description = <<-EOD
+      Run testnet tests, which are those that use network_broadcast_api to do
+      actual broadcast operations, on a specified (or default) testnet.
+    EOD
+    t.libs << 'test'
+    t.libs << 'lib'
+    t.test_files = [
+      'test/steem/testnet_test.rb'
+    ]
+    t.ruby_opts << if ENV['HELL_ENABLED']
+      '-W2'
+    else
+      '-W1'
+    end
+  end
+  
+  desc 'Tests the API using multiple threads.'
+  task :threads do
+    threads = []
+    api = Steem::Api.new(url: ENV['TEST_NODE'])
+    database_api = Steem::DatabaseApi.new(url: ENV['TEST_NODE'])
+    witnesses = {}
+    keys = %i(created url total_missed props running_version
+      hardfork_version_vote hardfork_time_vote)
+    
+    if defined? Thread.report_on_exception
+      Thread.report_on_exception = true
+    end
+    
+    database_api.get_active_witnesses do |result|
+      print "Found #{result.witnesses.size} witnesses ..."
+      
+      result.witnesses.each do |witness_name|
+        threads << Thread.new do
+          api.get_witness_by_account(witness_name) do |witness|
+            witnesses[witness.owner] = witness.map do |k, v|
+              [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
+            
+            if (quote = sbd_exchange_rate[:quote].to_f) > 0
+              rate = (base / quote).round(3)
+              witnesses[witness.owner][:sbd_exchange_rate] = rate
+            else
+              witnesses[witness.owner][:sbd_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
+          end
+        end
+      end
+    end
+    
+    threads.each do |thread|
+      print '.'
+      thread.join
+    end
+    
+    puts ' done!'
+    
+    if threads.size != witnesses.size
+      puts "Bug: expected #{threads.size} witnesses, only found #{witnesses.size}."
+    else
+      puts JSON.pretty_generate witnesses rescue puts witnesses
+    end
+  end
+end
+  
+namespace :stream do
+  desc 'Test the ability to stream a block range.'
+  task :block_range do
+    block_api = Steem::BlockApi.new(url: ENV['TEST_NODE'])
+    api = Steem::Api.new(url: ENV['TEST_NODE'])
+    last_block_num = nil
+    first_block_num = nil
+    last_timestamp = nil
+    
+    loop do
+      api.get_dynamic_global_properties do |properties|
+        current_block_num = properties.last_irreversible_block_num
+        # First pass replays latest 100 blocks.
+        first_block_num ||= current_block_num - (rand * 200).to_i
+        
+        if current_block_num >= first_block_num
+          range = first_block_num..current_block_num
+          puts "Got block range: #{range.size}"
+          block_api.get_blocks(block_range: range) do |block, block_num|
+            current_timestamp = Time.parse(block.timestamp + 'Z')
+            
+            if !!last_timestamp && block_num != last_block_num + 1
+              puts "Bug: Last block number was #{last_block_num} then jumped to: #{block_num}"
+              exit
+            end
+            
+            if !!last_timestamp && current_timestamp < last_timestamp
+              puts "Bug: Went back in time.  Last timestamp was #{last_timestamp}, then jumped back to #{current_timestamp}"
+              exit
+            end
+            
+            puts "\t#{block_num} Timestamp: #{current_timestamp}, witness: #{block.witness}"
+            last_block_num = block_num
+            last_timestamp = current_timestamp
+          end
+          
+          first_block_num = range.max + 1
+        end
+        
+        sleep 3
+      end
+    end
+  end
 end
 
 YARD::Rake::YardocTask.new do |t|

data/lib/steem/api.rb

@@ -1,6 +1,6 @@
 module Steem
   # This ruby API works with
-  # {https://github.com/steemit/steem/releases steemd-0.19.4} and other Appbase
+  # {https://github.com/steemit/steem/releases steemd-0.19.4} and other AppBase
   # compatible upstreams.  To access different API namespaces, use the
   # following:
   #
@@ -34,13 +34,13 @@ module Steem
   # * {TagsApi}
   # * {WitnessApi}
   #
-  # Also see: {https://developers.steem.io/apidefinitions.html Complete API Definitions}
+  # Also see: {https://developers.steem.io/apidefinitions/ Complete API Definitions}
   class Api
     attr_accessor :chain, :methods
     
     # Use this for debugging naive thread handler.
     # DEFAULT_RPC_CLIENT = RPC::BaseClient
-    DEFAULT_RPC_CLIENT = RPC::ThreadSafeClient
+    DEFAULT_RPC_CLIENT = RPC::ThreadSafeHttpClient
     
     def self.api_name=(api_name)
       @api_name = api_name.to_s.
@@ -103,16 +103,19 @@ module Steem
       "#<#{self.class.api_class_name} [#{properties}]>"
     end
   private
+    # @private
     def self.args_keys_to_s(rpc_method_name)
       args = signature(rpc_method_name).args
       args_keys = JSON[args.to_json]
     end
     
+    # @private
     def self.signature(rpc_method_name)
       @@signatures ||= {}
       @@signatures[rpc_method_name] ||= jsonrpc.get_signature(method: rpc_method_name).result
     end
     
+    # @private
     def self.raise_error_response(rpc_method_name, rpc_args, response)
       raise UnknownError, "#{rpc_method_name}: #{response}" if response.error.nil?
       
@@ -125,10 +128,12 @@ module Steem
       BaseError.build_error(error, rpc_method_name)
     end
     
+    # @private
     def respond_to_missing?(m, include_private = false)
       methods.nil? ? false : methods.include?(m.to_sym)
     end
     
+    # @private
     def method_missing(m, *args, &block)
       super unless respond_to_missing?(m)
       
@@ -150,19 +155,19 @@ module Steem
           # 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}"
+            @error_pipe.puts "Warning #{rpc_method_name} expects arguments: #{expected_args_size}, got: #{args_size}"
           end
         rescue NoMethodError => e
           error = Steem::ArgumentError.new("#{rpc_method_name} expects arguments: #{expected_args_size}", e)
           raise error
-        rescue
-          raise Steem::ArgumentError, "#{rpc_method_name} expects arguments: #{expected_args_size}"
+        rescue => e
+          raise UnknownError.new("#{rpc_method_name} unknown error.", e)
         end
         
         args
       end
       
-      response = @rpc_client.rpc_post(@api_name, m, rpc_args)
+      response = @rpc_client.rpc_execute(@api_name, m, rpc_args)
       
       if defined?(response.error) && !!response.error
         if !!response.error.message

data/lib/steem/base_error.rb

@@ -15,7 +15,7 @@ module Steem
     
     def self.build_error(error, context)
       if error.message == 'Unable to acquire database lock'
-        raise Steem::RemoteNodeError, error.message, JSON.pretty_generate(error)
+        raise Steem::RemoteDatabaseLockError, error.message, JSON.pretty_generate(error)
       end
       
       if error.message.include? 'Internal Error'
@@ -23,7 +23,7 @@ module Steem
       end
       
       if error.message.include? 'plugin not enabled'
-        raise Steem::RemoteNodeError, error.message, JSON.pretty_generate(error)
+        raise Steem::PluginNotEnabledError, error.message, JSON.pretty_generate(error)
       end
       
       if error.message.include? 'argument'
@@ -43,9 +43,29 @@ module Steem
       end
       
       if error.message.include? 'unknown key'
+        raise Steem::ArgumentError, "#{context}: #{error.message} (or content has been deleted)", JSON.pretty_generate(error)
+      end
+      
+      if error.message.include? 'Comment is not in account\'s comments'
+        raise Steem::ArgumentError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+      end
+      
+      if error.message.include? 'Could not find comment'
+        raise Steem::ArgumentError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+      end
+      
+      if error.message.include? 'unable to convert ISO-formatted string to fc::time_point_sec'
+        raise Steem::ArgumentError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+      end
+      
+      if error.message.include? 'Input data have to treated as object.'
         raise Steem::ArgumentError, "#{context}: #{error.message}", JSON.pretty_generate(error)
       end
       
+      if error.message.include? 'blk->transactions.size() > itr->trx_in_block'
+        raise Steem::VirtualOperationsNotAllowedError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+      end
+      
       if error.message.include? 'A transaction must have at least one operation'
         raise Steem::EmptyTransactionError, "#{context}: #{error.message}", JSON.pretty_generate(error)
       end
@@ -86,6 +106,10 @@ module Steem
         raise Steem::MissingOtherAuthorityError, "#{context}: #{error.message}", JSON.pretty_generate(error)
       end
       
+      if error.message.include? 'operator has disabled operation indexing by transaction_id'
+        raise Steem::TransactionIndexDisabledError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+      end
+      
       if error.message.include? 'is_valid_account_name'
         raise Steem::InvalidAccountError, "#{context}: #{error.message}", JSON.pretty_generate(error)
       end
@@ -114,10 +138,6 @@ module Steem
         raise Steem::UnexpectedAssetError, "#{context}: #{error.message}", JSON.pretty_generate(error)
       end
       
-      if error.message.include? 'unable to convert ISO-formatted string to fc::time_point_sec'
-        raise Steem::ArgumentError, "#{context}: #{error.message}", JSON.pretty_generate(error)
-      end
-      
       puts JSON.pretty_generate(error) if ENV['DEBUG']
       raise UnknownError, "#{context}: #{error.message}", JSON.pretty_generate(error)
     end
@@ -126,26 +146,34 @@ module Steem
   class UnsupportedChainError < BaseError; end
   class ArgumentError < BaseError; end
   class RemoteNodeError < BaseError; end
+  class RemoteDatabaseLockError < RemoteNodeError; end
+  class PluginNotEnabledError < RemoteNodeError; end
   class TypeError < BaseError; end
-  class EmptyTransactionError < BaseError; end
+  class EmptyTransactionError < ArgumentError; end
+  class InvalidAccountError < ArgumentError; end
+  class AuthorNotFoundError < ArgumentError; end
+  class ReachedMaximumTimeError < ArgumentError; end
+  class VirtualOperationsNotAllowedError < ArgumentError; end
+  class TheftError < ArgumentError; end
+  class NonZeroRequiredError < ArgumentError; end
+  class UnexpectedAssetError < ArgumentError; end
   class TransactionExpiredError < BaseError; end
-  class DuplicateTransactionError < BaseError; end
-  class NonCanonicalSignatureError < BaseError; end
+  class DuplicateTransactionError < TransactionExpiredError; end
+  class NonCanonicalSignatureError < TransactionExpiredError; end
   class BlockTooOldError < BaseError; end
   class IrrelevantSignatureError < BaseError; end
-  class MissingPostingAuthorityError < BaseError; end
-  class MissingActiveAuthorityError < BaseError; end
-  class MissingOwnerAuthorityError < BaseError; end
-  class MissingOtherAuthorityError < BaseError; end
-  class InvalidAccountError < BaseError; end
-  class AuthorNotFoundError < BaseError; end
-  class ReachedMaximumTimeError < BaseError; end
-  class TheftError < BaseError; end
-  class NonZeroRequiredError < BaseError; end
-  class UnexpectedAssetError < BaseError; end
+  class MissingAuthorityError < BaseError; end
+  class MissingPostingAuthorityError < MissingAuthorityError; end
+  class MissingActiveAuthorityError < MissingAuthorityError; end
+  class MissingOwnerAuthorityError < MissingAuthorityError; end
+  class MissingOtherAuthorityError < MissingAuthorityError; end
   class IncorrectRequestIdError < BaseError; end
   class IncorrectResponseIdError < BaseError; end
+  class TransactionIndexDisabledError < BaseError; end
+  class NotAppBaseError < BaseError; end
   class UnknownApiError < BaseError; end
   class UnknownOperationError < BaseError; end
+  class JsonRpcBatchMaximumSizeExceededError < BaseError; end
+  class TooManyTimeoutsError < BaseError; end
   class UnknownError < BaseError; end
 end

data/lib/steem/block_api.rb

@@ -5,7 +5,7 @@ module Steem
   #
   # Also see: {https://developers.steem.io/apidefinitions/block-api Block API Definitions}
   class BlockApi < Api
-    MAX_RANGE_SIZE = 3000
+    MAX_RANGE_SIZE = 50
     
     def initialize(options = {})
       self.class.api_name = :block_api
@@ -16,30 +16,43 @@ module Steem
     #
     # @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)
-      block_range = options[:block_range] || [0..0]
+    def get_blocks(options = {block_range: (0..0)}, &block)
+      block_range = options[:block_range] || (0..0)
       
-      if block_range.size > MAX_RANGE_SIZE
-        raise Steem::ArgumentError, "Too many blocks requested: #{block_range.size}; maximum request size: #{MAX_RANGE_SIZE}."
+      if (start = block_range.first) < 1
+        raise Steem::ArgumentError, "Invalid starting block: #{start}"
       end
       
-      request_body = []
-      
-      for i in block_range do
-        @rpc_client.put(self.class.api_name, :get_block, block_num: i, request_body: request_body)
+      chunks = if block_range.size > MAX_RANGE_SIZE
+        block_range.each_slice(MAX_RANGE_SIZE)
+      else
+        [block_range]
       end
       
-      if !!block
-        @rpc_client.rpc_post(nil, nil, request_body: request_body) do |result, error, id|
-          yield result.nil? ? nil : result.block, error, id
+      for sub_range in chunks do
+        request_object = []
+        
+        for i in sub_range do
+          @rpc_client.put(self.class.api_name, :get_block, block_num: i, request_object: request_object)
         end
-      else
-        blocks = []
         
-        @rpc_client.rpc_post(nil, nil, request_body: request_body) do |result, error, id|
-          blocks << result
+        if !!block
+          index = 0
+          @rpc_client.rpc_batch_execute(request_object: request_object) do |result, error, id|
+            block_num = sub_range.to_a[index]
+            index = index += 1
+            yield(result.nil? ? nil : result.block, block_num)
+          end
+        else
+          blocks = []
+          
+          @rpc_client.rpc_batch_execute(request_object: request_object) do |result, error, id|
+            blocks << result
+          end
         end
       end
+      
+      blocks
     end
   end
 end

data/lib/steem/broadcast.rb

@@ -105,6 +105,24 @@ module Steem
     #     }
     #     
     #     Steem::Broadcast.comment(options)
+    # 
+    # In addition to the above denormalized `comment_options` fields, the author
+    # can also vote for the content in the same transaction by setting `author_vote_weight`:
+    # 
+    #     options = {
+    #       wif: wif,
+    #       params: {
+    #         author: author,
+    #         title: 'This is my fancy post title.',
+    #         body: 'This is my fancy post body.',
+    #         metadata: {
+    #           tags: %w(these are my fancy tags)
+    #         },
+    #         author_vote_weight: 10000
+    #       }
+    #     }
+    #     
+    #     Steem::Broadcast.comment(options)
     #
     # @param options [Hash] options
     # @option options [String] :wif Posting wif
@@ -113,6 +131,7 @@ module Steem
     #   * :title (String) Title of the content.
     #   * :body (String) Body of the content.
     #   * :metadata (Hash) Metadata of the content, becomes `json_metadata`.
+    #   * :json_metadata (String) String version of `metadata` (use one or the other).
     #   * :permlink (String) (automatic) Permlink of the content, defaults to formatted title.
     #   * :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).
@@ -121,12 +140,19 @@ module Steem
     #   * :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.
+    #   * :author_vote_weight (Number) (optional) Cast a vote by the author in the same transaction.
     #   * :pretend (Boolean) Just validate, do not broadcast.
     # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_comment
     def self.comment(options, &block)
       required_fields = %i(author body permlink parent_permlink)
       params = options[:params]
-      metadata = (params[:metadata] rescue nil) || {}
+      
+      if !!params[:metadata] && !!params[:json_metadata]
+        raise Steem::ArgumentError, 'Assign either metadata or json_metadata, not both.'
+      end
+      
+      metadata = params[:metadata] || {}
+      metadata ||= (JSON[params[:json_metadata]] || nil) || {}
       metadata['app'] ||= Steem::AGENT_ID
       tags = metadata['tags'] || []
       params[:parent_permlink] ||= tags.first
@@ -181,6 +207,17 @@ module Steem
       
       ops << [:comment_options, comment_options]
       
+      if !!params[:author_vote_weight]
+        author_vote = {
+          voter: params[:author],
+          author: params[:author],
+          permlink: params[:permlink],
+          weight: params[:author_vote_weight]
+        }
+        
+        ops << [:vote, author_vote]
+      end
+      
       process(options.merge(ops: ops), &block)
     end
     
@@ -374,7 +411,7 @@ module Steem
       params = options[:params]
       check_required_fields(params, *required_fields)
       
-      exchange_rate = params[:exchange_rate] rescue {}
+      exchange_rate = params[:exchange_rate] rescue nil || {}
       base = exchange_rate[:base]
       quote = exchange_rate[:quote]
       params[:exchange_rate][:base] = Type::Amount.to_nia(base)
@@ -447,12 +484,22 @@ module Steem
     #   * :active (Hash)
     #   * :posting (Hash)
     #   * :memo_key (String)
-    #   * :json_metadata (String)
+    #   * :metadata (Hash) Metadata of the account, becomes `json_metadata`.
+    #   * :json_metadata (String) String version of `metadata` (use one or the other).
     # @option options [Boolean] :pretend Just validate, do not broadcast.
     # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_account_create
     def self.account_create(options, &block)
       required_fields = %i(fee creator new_account_name owner active posting memo_key json_metadata)
       params = options[:params]
+      
+      if !!params[:metadata] && !!params[:json_metadata]
+        raise Steem::ArgumentError, 'Assign either metadata or json_metadata, not both.'
+      end
+      
+      metadata = params.delete(:metadata) || {}
+      metadata ||= (JSON[params[:json_metadata]] || nil) || {}
+      params[:json_metadata] = metadata.to_json
+      
       check_required_fields(params, *required_fields)
       
       params[:fee] = Type::Amount.to_nia(params[:fee])
@@ -497,12 +544,22 @@ module Steem
     #   * :active (Hash) (optional)
     #   * :posting (Hash) (optional)
     #   * :memo_key (String) (optional)
-    # @option options [String] :json_metadata (optional)
+    #   * :metadata (Hash) Metadata of the account, becomes `json_metadata`.
+    #   * :json_metadata (String) String version of `metadata` (use one or the other).
     # @option options [Boolean] :pretend Just validate, do not broadcast.
     # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_account_update
     def self.account_update(options, &block)
       required_fields = %i(account)
       params = options[:params]
+      
+      if !!params[:metadata] && !!params[:json_metadata]
+        raise Steem::ArgumentError, 'Assign either metadata or json_metadata, not both.'
+      end
+      
+      metadata = params.delete(:metadata) || {}
+      metadata ||= (JSON[params[:json_metadata]] || nil) || {}
+      params[:json_metadata] = metadata.to_json
+      
       check_required_fields(params, *required_fields)
       
       ops = [[:account_update, params]]
@@ -642,12 +699,22 @@ module Steem
     #   * :required_auths (Array<String>)
     #   * :required_posting_auths (Arrat<String>)
     #   * :id (String)
-    #   * :json (String)
+    #   * :data (Hash) Data of the custom json, becomes `json`.
+    #   * :json (String) String version of `data` (use one or the other).
     # @option options [Boolean] :pretend Just validate, do not broadcast.
     # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_custom_json
     def self.custom_json(options, &block)
-      required_fields = %i(id json)
+      required_fields = %i(id)
       params = options[:params]
+      
+      if !!params[:data] && !!params[:json]
+        raise Steem::ArgumentError, 'Assign either data or json, not both.'
+      end
+      
+      data = params.delete(:data) || {}
+      data ||= (JSON[params[:json]] || nil) || {}
+      params[:json] = data.to_json
+      
       check_required_fields(params, *required_fields)
       
       params[:required_auths] ||= []
@@ -759,12 +826,22 @@ module Steem
     #   * :fee (String)
     #   * :ratification_deadline (String)
     #   * :escrow_expiration (String)
-    #   * :json_meta (String)
+    #   * :meta (Hash) Meta of the escrow transfer, becomes `json_meta`.
+    #   * :json_meta (String) String version of `metadata` (use one or the other).
     # @option options [Boolean] :pretend Just validate, do not broadcast.
     # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_escrow_transfer
     def self.escrow_transfer(options, &block)
-      required_fields = %i(from to agent escrow_id fee ratification_deadline json_meta)
+      required_fields = %i(from to agent escrow_id fee ratification_deadline)
       params = options[:params]
+      
+      if !!params[:meta] && !!params[:json_meta]
+        raise Steem::ArgumentError, 'Assign either meta or json_meta, not both.'
+      end
+      
+      meta = params.delete(:meta) || {}
+      meta ||= (JSON[params[:json_meta]] || nil) || {}
+      params[:json_meta] = meta.to_json
+      
       check_required_fields(params, *required_fields)
       
       params[:sbd_amount] = Type::Amount.to_nia(params[:sbd_amount])
@@ -979,13 +1056,23 @@ module Steem
     #   * :active (String)
     #   * :posting (String)
     #   * :memo_key (String)
-    #   * :json_metadata (String)
+    #   * :metadata (Hash) Metadata of the account, becomes `json_metadata`.
+    #   * :json_metadata (String) String version of `metadata` (use one or the other).
     #   * :extensions (Array)
     # @option options [Boolean] :pretend Just validate, do not broadcast.
     # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_account_create_with_delegation
     def self.account_create_with_delegation(options, &block)
-      required_fields = %i(fee delegation creator new_account_name owner active posting memo_key json_metadata)
+      required_fields = %i(fee delegation creator new_account_name owner active posting memo_key)
       params = options[:params]
+      
+      if !!params[:metadata] && !!params[:json_metadata]
+        raise Steem::ArgumentError, 'Assign either metadata or json_metadata, not both.'
+      end
+      
+      metadata = params.delete(:metadata) || {}
+      metadata ||= (JSON[params[:json_metadata]] || nil) || {}
+      params[:json_metadata] = metadata.to_json
+      
       check_required_fields(params, *required_fields)
       
       params[:fee] = Type::Amount.to_nia(params[:fee])
@@ -1032,14 +1119,17 @@ module Steem
       end
     end
   private
+    # @private
     def self.database_api(options)
       options[:database_api] ||= Steem::DatabaseApi.new(options)
     end
     
+    # @private
     def self.network_broadcast_api(options)
       options[:network_broadcast_api] ||= Steem::NetworkBroadcastApi.new(options)
     end
     
+    # @private
     def self.check_required_fields(hash, *fields)
       fields.each do |field|
         value = hash[field]

data/lib/steem/jsonrpc.rb

@@ -19,7 +19,7 @@ module Steem
     end
     
     def initialize(options = {})
-      self.class.api_name = :jsonrpc
+      @api_name = self.class.api_name = :jsonrpc
       @methods = API_METHODS
       super
     end
@@ -29,6 +29,8 @@ module Steem
       
       if api_methods.nil?
         get_methods do |result, error, rpc_id|
+          raise NotAppBaseError, "#{@rpc_client.uri} does not appear to run AppBase" unless defined? result.map
+          
           methods = result.map do |method|
             method.split('.').map(&:to_sym)
           end
@@ -54,14 +56,14 @@ module Steem
     end
     
     def get_all_signatures(&block)
-      request_body = []
+      request_object = []
       method_names = []
       method_map = {}
       signatures = {}
       offset = 0
       
       get_api_methods do |api, methods|
-        request_body += methods.map do |method|
+        request_object += methods.map do |method|
           method_name = "#{api}.#{method}"
           method_names << method_name
           current_rpc_id = @rpc_client.rpc_id
@@ -77,22 +79,30 @@ module Steem
         end
       end
       
-      @rpc_client.rpc_post(nil, nil, {request_body: request_body}) do |result, error, id|
-        api, method = method_map[id]
-        api = api.to_sym
-        method = method.to_sym
-        
-        signatures[api] ||= {}
-        signatures[api][method] = result
+      chunks = if request_object.size > Steem::RPC::HttpClient::JSON_RPC_BATCH_SIZE_MAXIMUM
+        request_object.each_slice(Steem::RPC::HttpClient::JSON_RPC_BATCH_SIZE_MAXIMUM)
+      else
+        request_object
       end
       
-      if !!block
-        signatures.each do |api, methods|
-          yield api, methods
+      for request_object in chunks do
+        @rpc_client.rpc_batch_execute(request_object: request_object) do |result, error, id|
+          api, method = method_map[id]
+          api = api.to_sym
+          method = method.to_sym
+          
+          signatures[api] ||= {}
+          signatures[api][method] = result
+        end
+        
+        if !!block
+          signatures.each do |api, methods|
+            yield api, methods
+          end
         end
-      else
-        return signatures
       end
+      
+      return signatures unless !!block
     end
   end
 end

data/lib/steem/mixins/retriable.rb

@@ -10,8 +10,7 @@ module Steem
     
     RETRYABLE_EXCEPTIONS = [
       NonCanonicalSignatureError, IncorrectRequestIdError,
-      IncorrectResponseIdError, Errno::EBADF, Errno::ECONNREFUSED,
-      JSON::ParserError, IOError, Net::OpenTimeout
+      IncorrectResponseIdError, RemoteDatabaseLockError
     ]
     
     # Expontential backoff.
@@ -41,10 +40,7 @@ module Steem
       @retry_count += 1
       
       can_retry = case e
-      when *RETRYABLE_EXCEPTIONS
-        true
-      when RemoteNodeError
-        e.inspect.include?('Unable to acquire database lock')
+      when *RETRYABLE_EXCEPTIONS then true
       else; false
       end
       

data/lib/steem/rpc/base_client.rb

@@ -6,10 +6,14 @@ module Steem
       attr_accessor :chain, :error_pipe
       
       # @private
-      POST_HEADERS = {
-        'Content-Type' => 'application/json; charset=utf-8',
-        'User-Agent' => Steem::AGENT_ID
-      }
+      MAX_TIMEOUT_RETRY_COUNT = 100
+      
+      # @private
+      MAX_TIMEOUT_BACKOFF = 30
+      
+      # @private
+      TIMEOUT_ERRORS = [Net::ReadTimeout, Errno::EBADF, Errno::ECONNREFUSED,
+        IOError]
       
       def initialize(options = {})
         @chain = options[:chain] || :steem
@@ -26,38 +30,67 @@ module Steem
         @uri ||= URI.parse(@url)
       end
       
-      def http
-        @http ||= Net::HTTP.new(uri.host, uri.port).tap do |http|
-          http.use_ssl = true
-          http.keep_alive_timeout = 2 # seconds
-          
-          # WARNING This method opens a serious security hole. Never use this
-          # method in production code.
-          # http.set_debug_output(STDOUT) if !!ENV['DEBUG']
-        end
-      end
-      
-      def http_post
-        @http_post ||= Net::HTTP::Post.new(uri.request_uri, POST_HEADERS)
-      end
-      
+      # Adds a request object to the stack.  Usually, this method is called
+      # internally by {BaseClient#rpc_execute}.  If you want to create a batched
+      # request, use this method to add to the batch then execute {BaseClient#rpc_batch_execute}.
       def put(api_name = @api_name, api_method = nil, options = {})
         current_rpc_id = rpc_id
         rpc_method_name = "#{api_name}.#{api_method}"
         options ||= {}
-        request_body = defined?(options.delete) ? options.delete(:request_body) : []
-        request_body ||= []
+        request_object = defined?(options.delete) ? options.delete(:request_object) : []
+        request_object ||= []
         
-        request_body << {
+        request_object << {
           jsonrpc: '2.0',
           id: current_rpc_id,
           method: rpc_method_name,
           params: options
         }
         
-        request_body
+        request_object
       end
-
+      
+      # @abstract Subclass is expected to implement #rpc_execute.
+      # @!method rpc_execute
+      
+      # @abstract Subclass is expected to implement #rpc_batch_execute.
+      # @!method rpc_batch_execute
+      
+      # To be called by {BaseClient#rpc_execute} and {BaseClient#rpc_batch_execute}
+      # when a response has been consructed.
+      def yield_response(response, &block)
+        if !!block
+          case response
+          when Hashie::Mash then yield response.result, response.error, response.id
+          when Hashie::Array
+            response.each do |r|
+              r = Hashie::Mash.new(r)
+              block.call r.result, r.error, r.id
+            end
+          else; block.call response
+          end
+        end
+        
+        response
+      end
+      
+      # Checks json-rpc request/response for corrilated id.  If they do not
+      # match, {IncorrectResponseIdError} is thrown.  This is usually caused by
+      # the client, involving thread safety.  It can also be caused by the node
+      # responding without an id.
+      # 
+      # To avoid {IncorrectResponseIdError}, make sure you implement your client
+      # correctly.
+      # 
+      # Setting DEBUG=true in the envrionment will cause this method to output
+      # both the request and response json.
+      # 
+      # @param options [Hash] options
+      # @option options [Boolean] :debug Enable or disable debug output.
+      # @option options [Hash] :request to compare id
+      # @option options [Hash] :response to compare id
+      # @option options [String] :api_method
+      # @see {ThreadSafeHttpClient}
       def evaluate_id(options = {})
         debug = options[:debug] || ENV['DEBUG'] == 'true'
         request = options[:request]
@@ -89,65 +122,45 @@ module Steem
         end
       end
       
-      def http_request(request)
-        http.request(request)
+      # Current json-rpc id used for a request.  This version auto-increments
+      # for each call.  Subclasses can use their own strategy.
+      def rpc_id
+        @rpc_id ||= 0
+        @rpc_id += 1
+      end
+    private
+      # @private
+      def reset_timeout
+        @timeout_retry_count = 0
+        @back_off = 0.1
       end
       
-      def rpc_post(api_name = @api_name, api_method = nil, options = {}, &block)
-        request = http_post
-        
-        request_body = if !!api_name && !!api_method
-          put(api_name, api_method, options)
-        elsif !!options && defined?(options.delete)
-          options.delete(:request_body)
-        end
+      # @private
+      def retry_timeout(context, cause = nil)
+        @timeout_retry_count += 1
         
-        request.body = if request_body.size == 1
-          request_body.first.to_json
-        else
-          request_body.to_json
+        if @timeout_retry_count > MAX_TIMEOUT_RETRY_COUNT
+          raise TooManyTimeoutsError.new("Too many timeouts for: #{context}", cause)
+        elsif @timeout_retry_count % 10 == 0
+          msg = "#{@timeout_retry_count} retry attempts for: #{context}"
+          msg += "; cause: #{e}" if !!cause
+          error_pipe.puts msg
         end
         
-        response = http_request(request)
+        backoff_timeout
         
-        case response.code
-        when '200'
-          response = JSON[response.body]
-          response = case response
-          when Hash
-            Hashie::Mash.new(response).tap do |r|
-              evaluate_id(request: request_body.first, response: r, api_method: api_method)
-            end
-          when Array
-            Hashie::Array.new(response).tap do |r|
-              request_body.each_with_index do |req, index|
-                evaluate_id(request: req, response: r[index], api_method: api_method)
-              end
-            end
-          else; response
-          end
-          
-          if !!block
-            case response
-            when Hashie::Mash then yield response.result, response.error, response.id
-            when Hashie::Array
-              response.each do |r|
-                r = Hashie::Mash.new(r)
-                yield r.result, r.error, r.id
-              end
-            else; yield response
-            end
-          else
-            return response
-          end
-        else
-          raise UnknownError, "#{api_name}.#{api_method}: #{response.body}"
-        end
+        context
       end
       
-      def rpc_id
-        @rpc_id ||= 0
-        @rpc_id += 1
+      # Expontential backoff.
+      #
+      # @private
+      def backoff_timeout
+        @backoff ||= 0.1
+        @backoff *= 2
+        @backoff = 0.1 if @backoff > MAX_TIMEOUT_BACKOFF
+        
+        sleep @backoff
       end
     end
   end

data/lib/steem/rpc/http_client.rb

@@ -0,0 +1,126 @@
+module Steem
+  module RPC
+    # {HttpClient} is intended for single-threaded applications.  For
+    # multi-threaded apps, use {ThreadSafeHttpClient}.
+    class HttpClient < BaseClient
+      # Timeouts are lower level errors, related in that retrying them is
+      # trivial, unlike, for example TransactionExpiredError, that *requires*
+      # the client to do something before retrying.
+      # 
+      # These situations are hopefully momentary interruptions or rate limiting
+      # but they might indicate a bigger problem with the node, so they are not
+      # retried forever, only up to MAX_TIMEOUT_RETRY_COUNT and then we give up.
+      # 
+      # *Note:* {JSON::ParserError} is included in this list because under
+      # certain timeout conditions, a web server may respond with a generic
+      # http status code of 200 and HTML page.
+      # 
+      # @private
+      TIMEOUT_ERRORS = [Net::OpenTimeout, Net::ReadTimeout, JSON::ParserError]
+      
+      # @private
+      POST_HEADERS = {
+        'Content-Type' => 'application/json; charset=utf-8',
+        'User-Agent' => Steem::AGENT_ID
+      }
+      
+      JSON_RPC_BATCH_SIZE_MAXIMUM = 50
+      
+      def http
+        @http ||= Net::HTTP.new(uri.host, uri.port).tap do |http|
+          http.use_ssl = true
+          http.keep_alive_timeout = 2 # seconds
+          
+          # WARNING This method opens a serious security hole. Never use this
+          # method in production code.
+          # http.set_debug_output(STDOUT) if !!ENV['DEBUG']
+        end
+      end
+      
+      def http_post
+        @http_post ||= Net::HTTP::Post.new(uri.request_uri, POST_HEADERS)
+      end
+      
+      def http_request(request)
+        http.request(request)
+      end
+      
+      # This is the main method used by API instances to actually fetch data
+      # from the remote node.  It abstracts the api namespace, method name, and
+      # parameters so that the API instance can be decoupled from the protocol.
+      # 
+      # @param api_name [String] API namespace of the method being called.
+      # @param api_method [String] API method name being called.
+      # @param options [Hash] options
+      # @option options [Object] :request_object Hash or Array to become json in request body.
+      def rpc_execute(api_name = @api_name, api_method = nil, options = {}, &block)
+        reset_timeout
+        
+        catch :tota_cera_pila do; begin
+          request = http_post
+          
+          request_object = if !!api_name && !!api_method
+            put(api_name, api_method, options)
+          elsif !!options && defined?(options.delete)
+            options.delete(:request_object)
+          end
+          
+          if request_object.size > JSON_RPC_BATCH_SIZE_MAXIMUM
+            raise JsonRpcBatchMaximumSizeExceededError, 'Maximum json-rpc-batch is 50 elements.'
+          end
+          
+          request.body = if request_object.class == Hash
+            request_object
+          elsif request_object.size == 1
+            request_object.first
+          else
+            request_object
+          end.to_json
+          
+          response = catch :http_request do; begin; http_request(request)
+          rescue *TIMEOUT_ERRORS => e
+            throw retry_timeout(:http_request, e)
+          end; end
+          
+          if response.nil?
+            throw retry_timeout(:tota_cera_pila, 'response was nil')
+          end
+          
+          case response.code
+          when '200'
+            response = catch :parse_json do; begin; JSON[response.body]
+            rescue *TIMEOUT_ERRORS => e
+              throw retry_timeout(:parse_json, e)
+            end; end
+            
+            response = case response
+            when Hash
+              Hashie::Mash.new(response).tap do |r|
+                evaluate_id(request: request_object.first, response: r, api_method: api_method)
+              end
+            when Array
+              Hashie::Array.new(response).tap do |r|
+                request_object.each_with_index do |req, index|
+                  evaluate_id(request: req, response: r[index], api_method: api_method)
+                end
+              end
+            else; response
+            end
+            
+            yield_response response, &block
+          when '504' # Gateway Timeout
+            throw retry_timeout(:tota_cera_pila, response.body)
+          when '502' # Bad Gateway
+            throw retry_timeout(:tota_cera_pila, response.body)
+          else
+            raise UnknownError, "#{api_name}.#{api_method}: #{response.body}"
+          end
+        end; end
+      end
+      
+      def rpc_batch_execute(options = {}, &block)
+        yield_response rpc_execute(nil, nil, options), &block
+      end
+    end
+  end
+end

data/lib/steem/rpc/thread_safe_http_client.rb

@@ -0,0 +1,35 @@
+module Steem
+  module RPC
+    # {ThreadSafeHttpClient} is the default RPC Client used by `steem-ruby.`
+    # It's perfect for simple requests.  But for higher performance, it's better
+    # to override {HttpClient} and implement something other than {Net::HTTP}.
+    # 
+    # It performs http requests in a {Mutex} critical section because {Net::HTTP}
+    # is not thread safe.  This is the very minimum level thread safety
+    # available.
+    class ThreadSafeHttpClient < HttpClient
+      SEMAPHORE = Mutex.new.freeze
+      
+      # Same as #{HttpClient#http_post}, but scoped to each thread so it is
+      # thread safe.
+      def http_post
+        thread = Thread.current
+        http_post = thread.thread_variable_get(:http_post)
+        http_post ||= Net::HTTP::Post.new(uri.request_uri, POST_HEADERS)
+        thread.thread_variable_set(:http_post, http_post)
+      end
+      
+      def http_request(request); SEMAPHORE.synchronize{super}; end
+      
+      # Same as #{BaseClient#rpc_id}, auto-increment, but scoped to each thread
+      # so it is thread safe.
+      def rpc_id
+        thread = Thread.current
+        rpc_id = thread.thread_variable_get(:rpc_id)
+        rpc_id ||= 0
+        rpc_id += 1
+        thread.thread_variable_set(:rpc_id, rpc_id)
+      end
+    end
+  end
+end

data/lib/steem/transaction_builder.rb

@@ -138,6 +138,22 @@ module Steem
     def put(type, op = nil)
       @expiration = nil
       
+      ## Saving this for later.  This block, or something like it, might replace
+      ## API broadcast operation structure.
+      # case type
+      # when Symbol, String
+      #   type_value = "#{type}_operation"
+      #   @operations << {type: type_value, value: op}
+      # when Hash
+      #   type_value = "#{type.keys.first}_operation"
+      #   @operations << {type: type_value, value: type.values.first}
+      # when Array
+      #   type_value = "#{type[0]}_operation"
+      #   @operations << {type: type_value, value: type[1]}
+      # else
+      #   # don't know what to do with it, skipped
+      # end
+      
       case type
       when Symbol then @operations << [type, op]
       when String then @operations << [type.to_sym, op]
@@ -252,6 +268,7 @@ module Steem
     end
   private
     # See: https://github.com/steemit/steem/issues/1944
+    # @private
     def canonical?(sig)
       sig = sig.unpack('C*')
       

data/lib/steem/version.rb

@@ -1,4 +1,4 @@
 module Steem
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
   AGENT_ID = "steem-ruby/#{VERSION}"
 end

data/lib/steem.rb

@@ -12,7 +12,8 @@ require 'steem/type/base_type'
 require 'steem/type/amount'
 require 'steem/transaction_builder'
 require 'steem/rpc/base_client'
-require 'steem/rpc/thread_safe_client'
+require 'steem/rpc/http_client'
+require 'steem/rpc/thread_safe_http_client'
 require 'steem/api'
 require 'steem/jsonrpc'
 require 'steem/block_api'
@@ -26,7 +27,7 @@ module Steem
   
   def self.const_missing(api_name)
     api = api_classes[api_name]
-    api ||= Api.clone(freeze: true)
+    api ||= Api.clone(freeze: true) rescue Api.clone
     api.api_name = api_name
     api_classes[api_name] = api
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steem-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Anthony Martin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-10 00:00:00.000000000 Z
+date: 2018-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -356,7 +356,8 @@ files:
 - lib/steem/jsonrpc.rb
 - lib/steem/mixins/retriable.rb
 - lib/steem/rpc/base_client.rb
-- lib/steem/rpc/thread_safe_client.rb
+- lib/steem/rpc/http_client.rb
+- lib/steem/rpc/thread_safe_http_client.rb
 - lib/steem/transaction_builder.rb
 - lib/steem/type/amount.rb
 - lib/steem/type/base_type.rb

data/lib/steem/rpc/thread_safe_client.rb

@@ -1,23 +0,0 @@
-module Steem
-  module RPC
-    # {ThreadSafeClient} is the default RPC Client used by `steem-ruby.`  It's
-    # perfect for simple requests.  But for higher performance, it's better to
-    # override {BaseClient} and implement something other than {Net::HTTP}.
-    class ThreadSafeClient < BaseClient
-      SEMAPHORE = Mutex.new.freeze
-      
-      def http_request(request)
-        response = SEMAPHORE.synchronize do
-          http.request(request)
-        end
-      end
-      
-      def rpc_id
-        SEMAPHORE.synchronize do
-          @rpc_id ||= 0
-          @rpc_id += 1
-        end
-      end
-    end
-  end
-end