raiblocks_rpc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 80b65b8a94a9de27dc3c58f9c04b69b7b3a40e8395db0fbad5f2a9e764951628
+  data.tar.gz: 6bb5855728354d9ae1cfaf2e5fca3ac6c61fd82e8db08f9f3a8e34744320d105
+SHA512:
+  metadata.gz: c4ab4f72e63fe1c86fe82d2ee77b238705e735103768e0a9e1375ca98881e1e5adb9e481b08ade5ba3349a58ba758327b95422b63ede2a61d67f877d7fa93301
+  data.tar.gz: 403d5679bc3b9717bb2d6cc540e649ba54eae73d52c68999e96834f06bbf55f596c186183e8091863fdc0faefd2ec5ec98202fb5103555ea682f9ba4be558c70

data/.gitignore

@@ -0,0 +1,11 @@
+.DS_Store
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.rspec_status
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 2.5.0
+  Exclude:
+    - 'bin/*'
+  DisplayCopNames: true
+Style/ClassAndModuleChildren:
+  EnforcedStyle: compact
+Style/EmptyMethod:
+  EnforcedStyle: expanded
+Layout/EmptyLineAfterMagicComment:
+  Enabled: false
+Documentation:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Justin Craig-Kuhn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,97 @@
+# RaiBlocksRpc
+
+An RPC wrapper for RaiBlocks written in Ruby.  It connects to an individual node that you control.  There's a client object you can use to make explicit RPC calls as well as proxy objects with logically grouped methods.
+
+To run a RaiBlocks node locally, see [Docker documentation](https://github.com/clemahieu/raiblocks/wiki/Docker-node).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'raiblocks_rpc'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install raiblocks_rpc
+
+## Usage
+
+There are two ways to use this gem.  You can make direct calls to the RPC client or use the provided proxy objects.
+
+In either case, the client should first be configured to connect to a RaiBlocks node.  If you do not specify host or port before using the client, then `localhost:7076` will be used by default.
+
+```ruby
+  RaiblocksRpc::Client.host = 'localhost'
+  RaiblocksRpc::Client.port = 7076
+````
+
+### Raw RPC Calls
+
+You can use the RPC client to make raw RPC calls to a RaiBlocks node according to the [documentation](https://github.com/clemahieu/raiblocks/wiki/RPC-protocol).
+
+Every call requires an `action`, which is passed as the first argument to `call`.  Depending on the action, there may be additional required or optional parameters that are passed as an options hash.
+
+```ruby
+  RaiblocksRpc::Client.instance.call(:account_balance, account: 'xrb_someaddress1234')
+  # => {"balance"=>100, "pending"=>0}
+````
+
+Response data are provided as `Hashie` objects with integer coercion, indifferent access, and method access included so you have several options for accessing values.
+
+```ruby
+  data = RaiblocksRpc::Client.instance.call(:account_balance, account: 'xrb_someaddress1234')
+  # => {"balance"=>100, "pending"=>0}
+  data.balance
+  # => 100
+  data[:balance]
+  # => 100
+  data['balance']
+  # => 100
+````
+
+### Proxy Objects
+
+A few proxy objects are provided as a means to logically group RPC calls. Here we do not strictly follow the grouping as expressed in the [RaiBlocks RPC documentation](https://github.com/clemahieu/raiblocks/wiki/RPC-protocol).  Instead, the following objects are provided:
+
+```ruby
+  RaiblocksRpc::Account # { account: 'xrb_address12345' }
+  RaiblocksRpc::Accounts # { accounts: ['xrb_address12345', 'xrb_address67890] }
+  RaiblocksRpc::Wallet # { wallet: 'F3093AB' }
+  RaiblocksRpc::Network
+  RaiblocksRpc::Node
+  RaiblocksRpc::Util
+```
+
+`Account`, `Accounts`, and `Wallet` each require parameters to be passed during initialization.  You can then make calls on these objects without needing to pass in the params for subsequent calls.
+
+Methods whose prefix matches the class name, such as `account_balance`, also have an abbreviated version, in this case `balance`.
+
+
+```ruby
+  account = RaiblocksRpc::Account.new('xrb_someaddress1234')
+
+  account.balance
+  # => {"balance"=>100, "pending"=>0}
+  account.account_balance
+  # => {"balance"=>100, "pending"=>0}
+```
+
+Some methods appear on multiple objects for convenience.
+
+```ruby
+  RaiblocksRpc::Node.new.block_count
+  # => {"count"=>314848, "unchecked"=>4793586}
+
+  RaiblocksRpc::Network.new.block_count
+  # => {"count"=>314848, "unchecked"=>4793642}
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'raiblocks_rpc'
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/raiblocks_rpc/client.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require 'singleton'
+require 'rest-client'
+require 'json'
+
+class RaiblocksRpc::Client
+  include Singleton
+
+  class << self
+    attr_accessor :host, :port
+  end
+
+  def call(action, params = {})
+    post({ action: action }.merge(params))
+  end
+
+  private
+
+  def post(params)
+    response = RestClient.post(url, params.to_json)
+    ensure_status_success!(response)
+
+    data = RaiblocksRpc::Response.new(JSON[response.body])
+    ensure_valid_response!(data)
+
+    data
+  end
+
+  def url
+    self.class.host ||= 'localhost'
+    self.class.port ||= 7076
+    "http://#{self.class.host}:#{self.class.port}"
+  end
+
+  def ensure_status_success!(response)
+    return if response.code == 200
+    raise RaiblocksRpc::BadRequest,
+          "Error response from node: #{JSON[response.body]}"
+  end
+
+  def ensure_valid_response!(data)
+    return unless data['error']
+    raise RaiblocksRpc::InvalidRequest,
+          "Invalid request: #{data['error']}"
+  end
+end

data/lib/raiblocks_rpc/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module RaiblocksRpc
+  class BadRequest < StandardError; end
+  class InvalidRequest < StandardError; end
+  class InvalidParameterType < StandardError; end
+  class ForbiddenParameter < StandardError; end
+  class MissingParameters < StandardError; end
+end

data/lib/raiblocks_rpc/proxies/account.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+class RaiblocksRpc::Account < RaiblocksRpc::Proxy
+  attr_accessor :address
+
+  def initialize(address)
+    unless address
+      raise RaiblocksRpc::MissingArguments,
+            'Missing argument: address (str)'
+    end
+
+    self.address = address
+  end
+
+  def proxy_params
+    { account: :address }
+  end
+
+  def proxy_methods
+    {
+      account_balance: nil,
+      account_block_count: nil,
+      account_info: nil,
+      account_create: { required: %i[wallet] },
+      account_history: { required: %i[count] },
+      account_list: nil,
+      account_move: { required: %i[wallet source accounts] },
+      account_key: nil,
+      account_remove: { required: %i[wallet] },
+      account_representative: nil,
+      account_representative_set: { required: %i[wallet representative] },
+      account_weight: nil,
+      delegators: nil,
+      delegators_count: nil,
+      frontiers: { required: %i[count] },
+      frontier_count: nil,
+      ledger: { required: %i[count] },
+      validate_account_number: nil,
+      pending: { required: %i[count], optional: %i[threshold exists] },
+      payment_wait: { required: %i[amount timeout] },
+      accounts_balances: { required: %i[accounts] },
+      accounts_create: {
+        required: %i[accounts wallet count], optional: %i[work]
+      },
+      accounts_frontiers: { required: %i[accounts] },
+      accounts_pending: {
+        required: %i[accounts count], optional: %i[threshold source]
+      }
+    }
+  end
+end

data/lib/raiblocks_rpc/proxies/accounts.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+class RaiblocksRpc::Accounts < RaiblocksRpc::Proxy
+  attr_accessor :addresses
+
+  def initialize(addresses)
+    unless addresses.is_a?(Array)
+      raise RaiblocksRpc::MissingArguments,
+            'Missing argument: addresses (str[])'
+    end
+
+    self.addresses = addresses
+  end
+
+  def proxy_params
+    { accounts: :addresses }
+  end
+
+  def proxy_methods
+    {
+      accounts_balances: nil,
+      accounts_create: { required: %i[wallet count], optional: %i[work] },
+      accounts_frontiers: nil,
+      accounts_pending: { required: %i[count], optional: %i[threshold source] }
+    }
+  end
+
+  # TODO implement ability to instantiate Account instances like
+  # accounts = Accounts.new(['abc', 'def'])
+  # accounts.first
+  # => RaiblocksRpc::Account address='abc'
+  # [], each (more iterators?)
+end

data/lib/raiblocks_rpc/proxies/network.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+class RaiblocksRpc::Network < RaiblocksRpc::Proxy
+  def proxy_methods
+    {
+      available_supply: nil,
+      block: { required: %i[hash] },
+      blocks: { required: %i[hashes] },
+      blocks_info: { required: %i[hashes], optional: %i[pending source] },
+      block_account: { required: %i[hash] },
+      block_count: nil,
+      block_count_type: nil,
+      chain: { required: %i[block count] },
+      history: { required: %i[hash count] },
+      block_create: {
+        required: %i[type key representative source], optional: %i[work]
+      },
+      process: { required: %i[block] },
+      republish: {
+        required: %i[hash], optional: %i[count sources destinations]
+      },
+      successors: { required: %i[block count] },
+      pending_exists: { required: %i[hash] },
+      unchecked: { required: %i[count] },
+      unchecked_clear: nil,
+      unchecked_get: { required: %i[hash] },
+      unchecked_keys: { required: %i[key count] },
+      work_cancel: { required: %i[hash] },
+      work_generate: { required: %i[hash] },
+      payment_wait: { required: %i[account amount timeout] },
+      work_validate: { required: %i[work hash] },
+      bootstrap: { required: %i[address port] },
+      keepalive: { required: %i[address port] },
+      work_peer_add: { required: %i[address port] },
+      bootstrap_any: nil
+    }
+  end
+end

data/lib/raiblocks_rpc/proxies/node.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+class RaiblocksRpc::Node < RaiblocksRpc::Proxy
+  def proxy_methods
+    {
+      bootstrap: { required: %i[address port] },
+      bootstrap_any: nil,
+      keepalive: { required: %i[address port] },
+      work_peer_add: { required: %i[address port] },
+      deterministic_key: { required: %i[seed index] },
+      receive_minimum: nil,
+      receive_minimum_set: { required: %i[amount] },
+      representatives: nil,
+      stop: nil,
+      version: nil,
+      peers: nil,
+      work_peers: nil,
+      work_peers_clear: nil,
+      work_validate: { required: %i[work hash] },
+      search_pending: { required: %i[wallet] },
+      search_pending_all: nil,
+      available_supply: nil,
+      block: { required: %i[hash] },
+      blocks: { required: %i[hashes] },
+      blocks_info: { required: %i[hashes], optional: %i[pending source] },
+      block_account: { required: %i[hash] },
+      block_count: nil,
+      block_count_type: nil,
+      unchecked: { required: %i[count] },
+      unchecked_clear: nil,
+      unchecked_get: { required: %i[hash] },
+      unchecked_keys: { required: %i[key count] },
+      payment_wait: { required: %i[account amount timeout] }
+    }
+  end
+end

data/lib/raiblocks_rpc/proxies/util.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+class RaiblocksRpc::Util < RaiblocksRpc::Proxy
+  def proxy_methods
+    {
+      mrai_from_raw: { required: %i[amount] },
+      mrai_to_raw: { required: %i[amount] },
+      krai_from_raw: { required: %i[amount] },
+      krai_to_raw: { required: %i[amount] },
+      rai_from_raw: { required: %i[amount] },
+      rai_to_raw: { required: %i[amount] },
+      key_create: nil,
+      key_expand: { required: %i[key] },
+      work_validate: { required: %i[work hash] }
+    }
+  end
+end

data/lib/raiblocks_rpc/proxies/wallet.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+class RaiblocksRpc::Wallet < RaiblocksRpc::Proxy
+  attr_accessor :seed
+
+  def initialize(wallet_seed)
+    unless wallet_address.is_a?(String) || public_key.is_a?(Symbol)
+      raise RaiblocksRpc::MissingArguments,
+            'Missing argument: wallet_seed (str)'
+    end
+
+    self.seed = wallet_seed
+  end
+
+  def proxy_params
+    { wallet: :seed }
+  end
+
+  def proxy_methods
+    {
+      wallet_balances: nil,
+      wallet_add: { required: %i[key], optional: %i[work] },
+      password_change: { required: %i[password] },
+      wallet_change_seed: { required: %i[seed] },
+      wallet_contains: { required: %i[account] },
+      wallet_create: nil,
+      wallet_destroy: nil,
+      wallet_export: nil,
+      wallet_frontiers: nil,
+      wallet_locked: nil,
+      password_enter: { required: %i[password] },
+      wallet_pending: { required: %i[count], optional: %i[threshold source] },
+      wallet_republish: { required: %i[count] },
+      wallet_balance_total: nil,
+      password_valid: nil,
+      wallet_work_get: nil,
+      send: { required: %[wallet source destination amount] },
+      work_get: nil,
+      work_set: nil,
+      search_pending: nil,
+      wallet_representative: nil,
+      wallet_representative_set: %i[representative],
+      payment_begin: nil,
+      payment_init: nil,
+      payment_end: { required: %i[account] },
+      receive: { required: %i[account block] }
+    }
+  end
+end

data/lib/raiblocks_rpc/proxy.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+class RaiblocksRpc::Proxy
+  attr_accessor :params, :param_signature, :m
+
+  private
+
+  def proxy_methods
+    raise 'Child class must override `proxy_methods` method'
+  end
+
+  def proxy_params
+    {}
+  end
+
+  # Define proxy methods based on #proxy_methods
+  def method_missing(m, *args, &_block)
+    set_accessors(m)
+    if valid_proxy_method?
+      define_proxy_method(m)
+      return send(m, args.first)
+    end
+
+    super
+  end
+
+  def respond_to_missing?(m, include_private = false)
+    set_accessors(m)
+    valid_proxy_method? || super
+  end
+
+  # Valid proxy methods are:
+  # (1) The raw name of an `action` as passed to the RPC server
+  #     (e.g. `account_balance`)
+  # (2) An abbreviation of an `action` such as `balance` from `account_balance`
+  #     where `account` is the lowercase name of the encapsulating class.
+  def valid_proxy_method?
+    rpc_action? || rpc_action_abbrev?
+  end
+
+  def rpc_action
+    return method_expansion if rpc_action_abbrev?
+    m
+  end
+
+  def rpc_action?
+    proxy_method_names.include?(m)
+  end
+
+  def rpc_action_abbrev?
+    proxy_method_names.each do |proxy_m|
+      proxy_m = proxy_m.to_s
+      next unless proxy_m.start_with?(action_prefix)
+      return true if m.to_s == action_abbrev(proxy_m)
+    end
+
+    false
+  end
+
+  def action_abbrev(proxy_m)
+    proxy_m.to_s[action_prefix.size..-1]
+  end
+
+  def method_expansion
+    "#{action_prefix}#{m}"
+  end
+
+  def proxy_method_names
+    @proxy_method_names ||= proxy_methods.keys
+  end
+
+  def action_prefix
+    @action_prefix ||= self.class.name.split('::').last.downcase + '_'
+  end
+
+  def define_proxy_method(m)
+    self.class.send(:define_method, m) do |opts = {}|
+      set_accessors(m, opts)
+      populate_and_validate_params!
+      RaiblocksRpc::Client.instance.call(rpc_action, params)
+    end
+  end
+
+  def set_accessors(m, opts = nil)
+    self.m = m
+    self.param_signature = proxy_methods[m.to_sym]
+    self.params = validate_opts!(opts)
+  end
+
+  def populate_and_validate_params!
+    proxy_params.each { |k, v| self.params[k] ||= send(v) }
+    validate_params!
+  end
+
+  def validate_params!
+    return if param_signature.nil?
+    ensure_required_params!
+    ensure_no_forbidden_params!
+  end
+
+  def allowed_params
+    proxy_params.keys +
+      (param_signature[:required] || []) +
+      (param_signature[:optional] || [])
+  end
+
+  def validate_opts!(opts)
+    return opts if opts.is_a?(Hash)
+    return {} if opts.nil?
+    raise RaiblocksRpc::InvalidParameterType,
+          'You must pass a hash to an action method'
+  end
+
+  def params_keys
+    params.keys.map(&:to_sym)
+  end
+
+  def ensure_required_params!
+    missing_params = param_signature[:required] - params_keys
+    return unless missing_params.any?
+    raise RaiblocksRpc::MissingParameters,
+          "Missing required parameter(s): #{missing_params.join(', ')}"
+  end
+
+  def ensure_no_forbidden_params!
+    forbidden_params = params_keys - allowed_params
+    return unless forbidden_params.any?
+    raise RaiblocksRpc::ForbiddenParameter,
+          "Forbidden parameter(s) passed: #{forbidden_params.join(', ')}"
+  end
+end

data/lib/raiblocks_rpc/response.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require 'hashie'
+
+class RaiblocksRpc::Response < Hash
+  include ::Hashie::Extensions::MergeInitializer
+  include ::Hashie::Extensions::IndifferentAccess
+  include ::Hashie::Extensions::MethodAccess
+
+  def initialize(hash = {})
+    super
+    coerce_integers
+  end
+
+  def coerce_integers
+    merge!(self) do |_k, v|
+      Integer(v)
+    rescue ArgumentError
+      v
+    end
+  end
+end

data/lib/raiblocks_rpc/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module RaiblocksRpc
+  VERSION = '0.1.0'
+end

data/lib/raiblocks_rpc.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+require 'raiblocks_rpc/client'
+require 'raiblocks_rpc/errors'
+require 'raiblocks_rpc/proxy'
+require 'raiblocks_rpc/response'
+require 'raiblocks_rpc/version'
+require 'raiblocks_rpc/proxies/account'
+require 'raiblocks_rpc/proxies/accounts'
+require 'raiblocks_rpc/proxies/network'
+require 'raiblocks_rpc/proxies/node'
+require 'raiblocks_rpc/proxies/util'
+require 'raiblocks_rpc/proxies/wallet'

data/raiblocks_rpc.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'raiblocks_rpc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'raiblocks_rpc'
+  spec.version       = RaiblocksRpc::VERSION
+  spec.authors       = ['Justin Craig-Kuhn (JCK)']
+  spec.email         = ['jcraigk@gmail.com']
+
+  spec.summary       = 'RPC wrapper for RaiBlocks nodes written in Ruby'
+  spec.description   = 'An RPC wrapper for RaiBlocks nodes written in Ruby.' \
+                       'It connects to an individual node that you control. ' \
+                       "There's a client object you can use to make explicit " \
+                       'RPC calls as well as proxy objects with logically ' \
+                       'grouped methods.'
+  spec.homepage      = 'https://github.com/jcraigk/ruby_raiblocks_rpc'
+  spec.license       = 'MIT'
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = %w[lib]
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'pry', '~> 0.11.3'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'simplecov', '~> 0.15.1'
+  spec.add_development_dependency 'rubocop', '~> 0.52.1'
+
+  spec.add_runtime_dependency 'hashie', '~> 3.5', '>= 3.5.7'
+  spec.add_runtime_dependency 'rest-client', '~> 2.0', '>= 2.0.2'
+end

metadata

@@ -0,0 +1,192 @@
+--- !ruby/object:Gem::Specification
+name: raiblocks_rpc
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Justin Craig-Kuhn (JCK)
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-01-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.15.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.15.1
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.52.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.52.1
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.7
+  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
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+description: An RPC wrapper for RaiBlocks nodes written in Ruby.It connects to an
+  individual node that you control. There's a client object you can use to make explicit
+  RPC calls as well as proxy objects with logically grouped methods.
+email:
+- jcraigk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/raiblocks_rpc.rb
+- lib/raiblocks_rpc/client.rb
+- lib/raiblocks_rpc/errors.rb
+- lib/raiblocks_rpc/proxies/account.rb
+- lib/raiblocks_rpc/proxies/accounts.rb
+- lib/raiblocks_rpc/proxies/network.rb
+- lib/raiblocks_rpc/proxies/node.rb
+- lib/raiblocks_rpc/proxies/util.rb
+- lib/raiblocks_rpc/proxies/wallet.rb
+- lib/raiblocks_rpc/proxy.rb
+- lib/raiblocks_rpc/response.rb
+- lib/raiblocks_rpc/version.rb
+- raiblocks_rpc.gemspec
+homepage: https://github.com/jcraigk/ruby_raiblocks_rpc
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: RPC wrapper for RaiBlocks nodes written in Ruby
+test_files: []