erc20 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b5bccf0ea259136bad39ab36f01240da8a029958b627ed337cd20477a7a13c9
-  data.tar.gz: 4c5d605e086d38755d25d8153c0bf6b220460f5b984607fd304706fe0b3d942f
+  metadata.gz: 14d84ab9ee2ac821f5f404dcea22437f622fe82bf5565a04c695f718974ba129
+  data.tar.gz: d2ec55f58ef13c62abfb0b870d541d3cc5bd8a32f5c685eda64fb484558af332
 SHA512:
-  metadata.gz: 0adbab22a3b752f63e1e001eac554ba8bcc8a40a2fea7234b9d674608eb281c912fb2e21931497006509b8cf2ae80e82d9de8dd49b7727f48759796da375d43b
-  data.tar.gz: ae3387a6c71c5ba367c8bd5814d2eebced21d6de6087dc214b083659811e2ed60efb5d0d981b7ba57b10030435566645ddd8328ac99ef4f9574b534192385383
+  metadata.gz: 2ef86114757f0b841b022a8cef64330610d68425d13e900487e4d99589065ed19640f393986f3ea62003fe2d24ae93513406611d4725d58dcc3165e7e70a5ffa
+  data.tar.gz: 92855745194e5cf9b6ff1902f0f7e4f44606aa4e306313668e7fb01849ab91e10fccf99e6f7ac6dfa0a6e176abc6d7aaa30f279b88e7c0f94b1133380f61d643

data/Gemfile

@@ -25,6 +25,7 @@ gemspec
 
 gem 'backtrace', '>0', require: false
 gem 'donce', '>0', require: false
+gem 'faraday', '>0', require: false
 gem 'loog', '>0', require: false
 gem 'minitest', '5.25.4', require: false
 gem 'minitest-reporters', '1.7.1', require: false

data/Gemfile.lock

@@ -2,11 +2,11 @@ PATH
   remote: .
   specs:
     erc20 (0.0.0)
-      backtrace (> 0)
-      eth (~> 0.4)
-      jsonrpc-client (> 0)
+      eth (>= 0.5.13)
+      faye-websocket (>= 0.11.3)
+      json (>= 2.10.1)
+      jsonrpc-client (>= 0.1.4)
       loog (> 0)
-      websocket-client-simple (> 0)
 
 GEM
   remote: https://rubygems.org/
@@ -71,13 +71,16 @@ GEM
       scrypt (~> 3.0)
     ethon (0.16.0)
       ffi (>= 1.15.0)
-    event_emitter (0.2.6)
+    eventmachine (1.2.7)
     faraday (2.12.2)
       faraday-net_http (>= 2.0, < 3.5)
       json
       logger
     faraday-net_http (3.4.0)
       net-http (>= 0.5.0)
+    faye-websocket (0.11.3)
+      eventmachine (>= 0.12.0)
+      websocket-driver (>= 0.5.1)
     ffi (1.17.1-arm64-darwin)
     ffi (1.17.1-x64-mingw-ucrt)
     ffi (1.17.1-x86_64-darwin)
@@ -93,7 +96,7 @@ GEM
       pp (>= 0.6.0)
       rdoc (>= 4.0.0)
       reline (>= 0.4.2)
-    json (2.10.0)
+    json (2.10.1)
     jsonrpc-client (0.1.4)
       faraday
       multi_json (>= 1.1.0)
@@ -115,7 +118,6 @@ GEM
     minitest-retry (0.2.5)
       minitest (>= 5.0)
     multi_json (1.15.0)
-    mutex_m (0.3.0)
     net-http (0.6.0)
       uri
     nokogiri (1.18.2-arm64-darwin)
@@ -251,12 +253,10 @@ GEM
     unicode-emoji (4.0.4)
     uri (1.0.2)
     useragent (0.16.11)
-    websocket (1.2.11)
-    websocket-client-simple (0.9.0)
+    websocket-driver (0.7.7)
       base64
-      event_emitter
-      mutex_m
-      websocket
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
     yard (0.9.37)
     zeitwerk (2.7.1)
 
@@ -273,6 +273,7 @@ DEPENDENCIES
   backtrace (> 0)
   donce (> 0)
   erc20!
+  faraday (> 0)
   loog (> 0)
   minitest (= 5.25.4)
   minitest-reporters (= 1.7.1)

data/README.md

@@ -23,18 +23,19 @@ require 'erc20'
 w = ERC20::Wallet.new(
   contract: ERC20::Wallet.USDT, # hex of it
   host: 'mainnet.infura.io',
-  path: '/v3/<your-key>',
+  http_path: '/v3/<your-infura-key>',
+  ws_path: '/ws/v3/<your-infura-key>',
   log: $stdout
 )
 
-# Check balance on the address:
+# Check how many ERC20 tokens are on the given address:
 usdt = w.balance(address)
 
-# Send a few tokens to someone and get transaction hash:
-txn = w.pay(private_key, to_address, amount)
+# Send a few ERC20 tokens to someone and get transaction hash:
+hex = w.pay(private_key, to_address, amount)
 
-# Stay waiting, and trigger the block when transactions arrive:
-addresses = ['0x...', '0x...']
+# Stay waiting, and trigger the block when new ERC20 payments show up:
+addresses = ['0x...', '0x...'] # only wait for payments to these addresses
 w.accept(addresses) do |event|
   puts event[:amount] # how much
   puts event[:from] # who sent the payment
@@ -55,6 +56,22 @@ To get address from private one:
 public_hex = Eth::Key.new(priv: key).address
 ```
 
+To connect to the server via [HTTP proxy] with [basic authentication]:
+
+```ruby
+w = ERC20::Wallet.new(
+  host: 'go.getblock.io',
+  http_path: '/<your-rpc-getblock-key>',
+  ws_path: '/<your-ws-getblock-key>',
+  proxy: 'http://jeffrey:swordfish@example.com:3128' # here!
+)
+```
+
+You can use [squid-proxy] [Docker] image to set up your own [HTTP proxy] server.
+
+Of course, this library works with [Polygon], [Optimism],
+and other forks of [Etherium].
+
 ## How to contribute
 
 Read
@@ -78,3 +95,9 @@ If it's clean and you don't see any error messages, submit your pull request.
 [Infura]: https://infura.io/
 [Alchemy]: https://alchemy.com/
 [GetBlock]: https://getblock.io/
+[basic authentication]: https://en.wikipedia.org/wiki/Basic_access_authentication
+[HTTP proxy]: https://en.wikipedia.org/wiki/Proxy_server
+[squid-proxy]: https://github.com/yegor256/squid-proxy
+[Docker]: https://www.docker.com/
+[Polygon]: https://polygon.technology/
+[Optimism]: https://www.optimism.io/

data/Rakefile

@@ -24,6 +24,8 @@ require 'rubygems'
 require 'rake'
 require 'rake/clean'
 
+ENV['RAKE'] = 'true'
+
 def name
   @name ||= File.basename(Dir['*.gemspec'].first, '.*')
 end

data/erc20.gemspec

@@ -31,18 +31,20 @@ Gem::Specification.new do |s|
   s.license = 'MIT'
   s.summary = 'Sending and receiving ERC20 tokens in Etherium network'
   s.description =
-    'A simple library for making ERC20 manipulations as easy as they' \
-    'can be for cryptocurrency newbies'
+    'A simple library for making ERC20 manipulations as easy as they ' \
+    'can be for cryptocurrency newbies: checking balance, sending payments, ' \
+    'and monitoring addresses for incoming payments. The library expects ' \
+    'Etherium node to provide JSON RPC and Websockets API.'
   s.authors = ['Yegor Bugayenko']
   s.email = 'yegor256@gmail.com'
   s.homepage = 'http://github.com/yegor256/erc20.rb'
   s.files = `git ls-files`.split($RS)
   s.rdoc_options = ['--charset=UTF-8']
   s.extra_rdoc_files = ['README.md', 'LICENSE.txt']
-  s.add_dependency 'backtrace', '>0'
-  s.add_dependency 'eth', '~>0.4'
-  s.add_dependency 'jsonrpc-client', '>0'
+  s.add_dependency 'eth', '>=0.5.13'
+  s.add_dependency 'faye-websocket', '>=0.11.3'
+  s.add_dependency 'json', '>=2.10.1'
+  s.add_dependency 'jsonrpc-client', '>=0.1.4'
   s.add_dependency 'loog', '>0'
-  s.add_dependency 'websocket-client-simple', '>0'
   s.metadata['rubygems_mfa_required'] = 'true'
 end

data/lib/erc20/wallet.rb

@@ -21,9 +21,12 @@
 # SOFTWARE.
 
 require 'eth'
+require 'eventmachine'
+require 'faye/websocket'
+require 'json'
 require 'jsonrpc/client'
 require 'loog'
-require 'websocket-client-simple'
+require 'uri'
 require_relative '../erc20'
 
 # A wallet.
@@ -37,34 +40,31 @@ class ERC20::Wallet
   # Address of USDT contract.
   USDT = '0xdac17f958d2ee523a2206206994597c13d831ec7'
 
+  # These properties are read-only:
+  attr_reader :host, :port, :ssl, :chain, :contract, :ws_path, :http_path
+
   # Constructor.
   # @param [String] contract Hex of the contract in Etherium
-  # @param [String] rpc The URL of Etherium JSON-RPC provider
   # @param [Integer] chain The ID of the chain (1 for mainnet)
   # @param [String] host The host to connect to
   # @param [Integer] port TCP port to use
-  # @param [String] path The path in the connection URL
+  # @param [String] http_path The path in the connection URL, for HTTP RPC
+  # @param [String] ws_path The path in the connection URL, for Websockets
   # @param [Boolean] ssl Should we use SSL (for https and wss)
+  # @param [String] proxy The URL of the proxy to use
   # @param [Object] log The destination for logs
-  def initialize(contract: USDT, rpc: nil, wss: nil, chain: 1, log: $stdout,
-                 host: nil, port: 443, path: '/', ssl: true)
+  def initialize(contract: USDT, chain: 1, log: $stdout,
+                 host: nil, port: 443, http_path: '/', ws_path: '/',
+                 ssl: true, proxy: nil)
     @contract = contract
-    raise 'Use either host or rpc' if rpc && host
-    raise 'Use either host or wss' if wss && host
-    if rpc
-      @rpc = rpc
-    else
-      raise 'Either rpc or host+port+path are required' unless host && port && path
-      @rpc = "http#{ssl ? 's' : ''}://#{host}:#{port}#{path}"
-    end
-    if wss
-      @wss = wss
-    else
-      raise 'Either wss or host+port+path are required' unless host && port && path
-      @wss = "http#{ssl ? 's' : ''}://#{host}:#{port}#{path}"
-    end
+    @host = host
+    @port = port
+    @ssl = ssl
+    @http_path = http_path
+    @ws_path = ws_path
     @log = log
     @chain = chain
+    @proxy = proxy
   end
 
   # Get balance of a public address.
@@ -119,35 +119,39 @@ class ERC20::Wallet
 
   # Wait for incoming transactions and let the block know when they
   # arrive. It's a blocking call, it's better to run it in a separate
-  # thread.
+  # thread. It will never finish. In order to stop it, you should do
+  # +Thread.kill+.
   #
   # @param [Array<String>] addresses Addresses to monitor
   # @param [Array] ready When connected, TRUE will be added to this array
   # @param [Boolean] raw TRUE if you need to get JSON events as they arrive from Websockets
   def accept(addresses, connected: [], raw: false)
-    WebSocket::Client::Simple.connect(@wss) do |ws|
+    EM.run do
+      u = url(http: false)
+      @log.debug("Connecting to #{u}...")
+      ws = Faye::WebSocket::Client.new(u, [], proxy: @proxy ? { origin: @proxy } : {})
       log = @log
       contract = @contract
-      wss = @wss
       ws.on(:open) do
-        log.debug("Connected to #{wss}")
-        msg = {
-          jsonrpc: '2.0',
-          id: 1,
-          method: 'eth_subscribe',
-          params: [
-            'logs',
-            {
-              address: contract,
-              topics: [
-                '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
-                nil,
-                addresses.map { |a| "0x000000000000000000000000#{a[2..]}" }
-              ]
-            }
-          ]
-        }
-        ws.send(msg.to_json)
+        log.debug("Connected to #{@host}")
+        ws.send(
+          {
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'eth_subscribe',
+            params: [
+              'logs',
+              {
+                address: contract,
+                topics: [
+                  '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+                  nil,
+                  addresses.map { |a| "0x000000000000000000000000#{a[2..]}" }
+                ]
+              }
+            ]
+          }.to_json
+        )
         connected.append(1)
         log.debug("Subscribed to #{addresses.count} addresses")
       end
@@ -172,19 +176,35 @@ class ERC20::Wallet
         end
       end
       ws.on(:close) do |_e|
-        log.debug("Disconnected from #{wss}")
+        log.debug("Disconnected from #{@host}")
       end
       ws.on(:error) do |e|
-        log.debug("Error at #{wss}: #{e}")
+        log.debug("Error at #{@host}: #{e.message}")
       end
     end
   end
 
   private
 
+  def url(http: true)
+    "#{http ? 'http' : 'ws'}#{@ssl ? 's' : ''}://#{@host}:#{@port}#{http ? @http_path : @ws_path}"
+  end
+
   def jsonrpc
     JSONRPC.logger = Loog::NULL
-    JSONRPC::Client.new(@rpc)
+    connection =
+      if @proxy
+        uri = URI.parse(@proxy)
+        Faraday.new do |f|
+          f.adapter(Faraday.default_adapter)
+          f.proxy = {
+            uri: "#{uri.scheme}://#{uri.hostname}:#{uri.port}",
+            user: uri.user,
+            password: uri.password
+          }
+        end
+      end
+    JSONRPC::Client.new(url, connection:)
   end
 
   def gas_estimate(from, data)

data/lib/erc20.rb

@@ -27,5 +27,5 @@
 # License:: MIT
 module ERC20
   # Current version of the gem (changed by .rultor.yml on every release)
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/test/erc20/test_wallet.rb

@@ -23,22 +23,24 @@
 require 'backtrace'
 require 'donce'
 require 'eth'
+require 'faraday'
 require 'loog'
+require 'minitest/autorun'
 require 'random-port'
 require 'shellwords'
 require 'typhoeus'
-require 'minitest/autorun'
 require_relative '../../lib/erc20'
 require_relative '../../lib/erc20/wallet'
+require_relative '../test__helper'
 
 # Test.
 # Author:: Yegor Bugayenko (yegor256@gmail.com)
 # Copyright:: Copyright (c) 2025 Yegor Bugayenko
 # License:: MIT
 class TestWallet < Minitest::Test
-  # At this address, in the mainnet, there are a few USDT tokens. I won't
+  # At this address, in Etherium mainnet, there are a few USDT tokens. I won't
   # move them anyway, that's why tests can use this address forever.
-  STABLE_ADDRESS = '0xEB2fE8872A6f1eDb70a2632EA1f869AB131532f6'
+  STABLE = '0xEB2fE8872A6f1eDb70a2632EA1f869AB131532f6'
 
   # One guy private hex.
   JEFF = '81a9b2114d53731ecc84b261ef6c0387dde34d5907fe7b441240cc21d61bf80a'
@@ -47,7 +49,7 @@ class TestWallet < Minitest::Test
   WALTER = '91f9111b1744d55361e632771a4e53839e9442a9fef45febc0a5c838c686a15b'
 
   def test_checks_balance_on_mainnet
-    b = mainnet.balance(STABLE_ADDRESS)
+    b = mainnet.balance(STABLE)
     refute_nil(b)
     assert_equal(27_258_889, b)
   end
@@ -61,18 +63,28 @@ class TestWallet < Minitest::Test
 
   def test_fails_with_invalid_infura_key
     w = ERC20::Wallet.new(
-      rpc: 'https://mainnet.infura.io/v3/invalid-key-here',
-      wss: 'https://mainnet.infura.io/v3/another-invalid-key-here',
-      log: Loog::NULL
+      host: 'mainnet.infura.io',
+      http_path: '/v3/invalid-key-here',
+      log: loog
     )
-    assert_raises(StandardError) { w.balance(STABLE_ADDRESS) }
+    assert_raises(StandardError) { w.balance(STABLE) }
   end
 
   def test_checks_balance_on_testnet
-    skip('does not work')
-    b = testnet.balance(STABLE_ADDRESS)
+    b = testnet.balance(STABLE)
+    refute_nil(b)
+    assert_predicate(b, :zero?)
+  end
+
+  def test_checks_balance_on_polygon
+    w = ERC20::Wallet.new(
+      contract: '0xc2132D05D31c914a87C6611C10748AEb04B58e8F',
+      host: 'polygon-mainnet.infura.io', http_path: "/v3/#{env('INFURA_KEY')}",
+      log: loog
+    )
+    b = w.balance(STABLE)
     refute_nil(b)
-    assert_predicate(b, :positive?)
+    assert_predicate(b, :zero?)
   end
 
   def test_checks_balance_on_hardhat
@@ -106,7 +118,7 @@ class TestWallet < Minitest::Test
             event = e
           end
         rescue StandardError => e
-          puts Backtrace.new(e)
+          loog.error(Backtrace.new(e))
         end
       wait_for { !connected.empty? }
       sum = 77_000
@@ -120,8 +132,80 @@ class TestWallet < Minitest::Test
     end
   end
 
+  def test_accepts_payments_on_hardhat_via_proxy
+    via_proxy do |proxy|
+      walter = Eth::Key.new(priv: WALTER).address.to_s.downcase
+      jeff = Eth::Key.new(priv: JEFF).address.to_s.downcase
+      on_hardhat do |w|
+        wallet = through_proxy(w, proxy)
+        connected = []
+        event = nil
+        daemon =
+          Thread.new do
+            wallet.accept([walter, jeff], connected:) do |e|
+              event = e
+            end
+          rescue StandardError => e
+            loog.error(Backtrace.new(e))
+          end
+        wait_for { !connected.empty? }
+        sum = 55_000
+        wallet.pay(JEFF, walter, sum)
+        wait_for { !event.nil? }
+        daemon.kill
+        daemon.join(30)
+        assert_equal(sum, event[:amount])
+      end
+    end
+  end
+
+  def test_accepts_payments_on_mainnet
+    connected = []
+    failed = false
+    net = mainnet
+    daemon =
+      Thread.new do
+        net.accept([STABLE], connected:) do |_|
+          # ignore it
+        end
+      rescue StandardError => e
+        failed = true
+        loog.error(Backtrace.new(e))
+      end
+    wait_for { !connected.empty? }
+    daemon.kill
+    daemon.join(30)
+    refute(failed)
+  end
+
+  def test_checks_balance_via_proxy
+    via_proxy do |proxy|
+      on_hardhat do |w|
+        wallet = through_proxy(w, proxy)
+        b = wallet.balance(Eth::Key.new(priv: JEFF).address.to_s)
+        assert_equal(123_000_100_000, b)
+      end
+    end
+  end
+
+  def test_checks_balance_via_proxy_on_mainnet
+    via_proxy do |proxy|
+      on_hardhat do
+        w = ERC20::Wallet.new(
+          host: 'mainnet.infura.io', http_path: "/v3/#{env('INFURA_KEY')}",
+          proxy:, log: loog
+        )
+        assert_equal(27_258_889, w.balance(STABLE))
+      end
+    end
+  end
+
   private
 
+  def loog
+    ENV['RAKE'] ? Loog::NULL : Loog::VERBOSE
+  end
+
   def wait_for
     start = Time.now
     loop do
@@ -145,29 +229,66 @@ class TestWallet < Minitest::Test
 
   def mainnet
     [
-      "https://mainnet.infura.io/v3/#{env('INFURA_KEY')}",
-      "https://go.getblock.io/#{env('GETBLOCK_KEY')}"
-    ].map do |url|
-      ERC20::Wallet.new(rpc: url, wss: url, log: Loog::NULL)
+      {
+        host: 'mainnet.infura.io',
+        http_path: "/v3/#{env('INFURA_KEY')}",
+        ws_path: "/ws/v3/#{env('INFURA_KEY')}"
+      },
+      {
+        host: 'go.getblock.io',
+        http_path: "/#{env('GETBLOCK_KEY')}",
+        ws_path: "/#{env('GETBLOCK_WS_KEY')}"
+      }
+    ].map do |server|
+      ERC20::Wallet.new(host: server[:host], http_path: server[:http_path], ws_path: server[:ws_path], log: loog)
     end.sample
   end
 
   def testnet
     [
-      "https://sepolia.infura.io/v3/#{env('INFURA_KEY')}",
-      "https://go.getblock.io/#{env('GETBLOCK_SEPOILA_KEY')}"
-    ].map do |url|
-      ERC20::Wallet.new(rpc: url, wss: url, log: Loog::NULL)
+      {
+        host: 'sepolia.infura.io',
+        http_path: "/v3/#{env('INFURA_KEY')}",
+        ws_path: "/ws/v3/#{env('INFURA_KEY')}"
+      },
+      {
+        host: 'go.getblock.io',
+        http_path: "/#{env('GETBLOCK_SEPOILA_KEY')}",
+        ws_path: "/#{env('GETBLOCK_SEPOILA_KEY')}"
+      }
+    ].map do |server|
+      ERC20::Wallet.new(host: server[:host], http_path: server[:http_path], ws_path: server[:ws_path], log: loog)
     end.sample
   end
 
+  def through_proxy(wallet, proxy)
+    ERC20::Wallet.new(
+      contract: wallet.contract, chain: wallet.chain,
+      host: donce_host, port: wallet.port, http_path: wallet.http_path, ws_path: wallet.ws_path,
+      ssl: wallet.ssl, proxy:, log: loog
+    )
+  end
+
+  def via_proxy
+    RandomPort::Pool::SINGLETON.acquire do |port|
+      donce(
+        image: 'yegor256/squid-proxy:latest',
+        ports: { port => 3128 },
+        env: { 'USERNAME' => 'jeffrey', 'PASSWORD' => 'swordfish' },
+        root: true, log: loog
+      ) do
+        yield "http://jeffrey:swordfish@localhost:#{port}"
+      end
+    end
+  end
+
   def on_hardhat
     RandomPort::Pool::SINGLETON.acquire do |port|
       donce(
         home: File.join(__dir__, '../../hardhat'),
         ports: { port => 8545 },
         command: 'npx hardhat node',
-        log: Loog::NULL
+        log: loog
       ) do
         wait_for_port(port)
         cmd = [
@@ -180,13 +301,13 @@ class TestWallet < Minitest::Test
           home: File.join(__dir__, '../../hardhat'),
           command: "/bin/bash -c #{Shellwords.escape(cmd)}",
           build_args: { 'HOST' => donce_host, 'PORT' => port },
-          log: Loog::NULL,
+          log: loog,
           root: true
         ).split("\n").last
         wallet = ERC20::Wallet.new(
           contract:, chain: 4242,
-          host: 'localhost', port:, path: '/', ssl: false,
-          log: Loog::NULL
+          host: 'localhost', port:, http_path: '/', ws_path: '/', ssl: false,
+          log: loog
         )
         yield wallet
       end

data/test/test__helper.rb

@@ -35,5 +35,7 @@ require 'minitest/reporters'
 Minitest::Reporters.use! [Minitest::Reporters::SpecReporter.new]
 
 # To make tests retry on failure:
-require 'minitest/retry'
-Minitest::Retry.use!(methods_to_skip: [])
+if ENV['RAKE']
+  require 'minitest/retry'
+  Minitest::Retry.use!(methods_to_skip: [])
+end

metadata

@@ -1,73 +1,73 @@
 --- !ruby/object:Gem::Specification
 name: erc20
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Yegor Bugayenko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-10 00:00:00.000000000 Z
+date: 2025-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: backtrace
+  name: eth
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.13
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.13
 - !ruby/object:Gem::Dependency
-  name: eth
+  name: faye-websocket
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.11.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.11.3
 - !ruby/object:Gem::Dependency
-  name: jsonrpc-client
+  name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.10.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.10.1
 - !ruby/object:Gem::Dependency
-  name: loog
+  name: jsonrpc-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.4
 - !ruby/object:Gem::Dependency
-  name: websocket-client-simple
+  name: loog
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">"
@@ -80,8 +80,10 @@ dependencies:
     - - ">"
       - !ruby/object:Gem::Version
         version: '0'
-description: A simple library for making ERC20 manipulations as easy as theycan be
-  for cryptocurrency newbies
+description: 'A simple library for making ERC20 manipulations as easy as they can
+  be for cryptocurrency newbies: checking balance, sending payments, and monitoring
+  addresses for incoming payments. The library expects Etherium node to provide JSON
+  RPC and Websockets API.'
 email: yegor256@gmail.com
 executables: []
 extensions: []