erc20 0.0.4 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b5bccf0ea259136bad39ab36f01240da8a029958b627ed337cd20477a7a13c9
-  data.tar.gz: 4c5d605e086d38755d25d8153c0bf6b220460f5b984607fd304706fe0b3d942f
+  metadata.gz: ddbc3966b9eec2d455e33dde71df0427a7a99e4d59f0df69191d8f617434c8bf
+  data.tar.gz: 0d577a397eee74c5dae388ca620f8a681c4bec2af8d9b6cf5514ca32cbebc992
 SHA512:
-  metadata.gz: 0adbab22a3b752f63e1e001eac554ba8bcc8a40a2fea7234b9d674608eb281c912fb2e21931497006509b8cf2ae80e82d9de8dd49b7727f48759796da375d43b
-  data.tar.gz: ae3387a6c71c5ba367c8bd5814d2eebced21d6de6087dc214b083659811e2ed60efb5d0d981b7ba57b10030435566645ddd8328ac99ef4f9574b534192385383
+  metadata.gz: 1f87ab9c39b5476b9b90bd44020f21970edc8830826129b0a2c6386d562887627e346c55a1e8bb1fcf3e9983d1977e6e0851b7e2fdc162217898951988b2173f
+  data.tar.gz: 02d6b7e7058dd6c6f3a74b81ece853e674020a4df84b6fa439b74438ff8227616a76cf3abd1a6f82fdfb7f34391c4e541f96791e404e8e84cb3f364d72e92771

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,14 +21,17 @@
 # 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.
+# A wallet with ERC20 tokens on Etherium.
 #
-# It is NOT thread-safe!
+# Objects of this class are thread-safe.
 #
 # Author:: Yegor Bugayenko (yegor256@gmail.com)
 # Copyright:: Copyright (c) 2025 Yegor Bugayenko
@@ -37,34 +40,32 @@ 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
+    @mutex = Mutex.new
   end
 
   # Get balance of a public address.
@@ -86,7 +87,7 @@ class ERC20::Wallet
   # @param [String] priv Private key, in hex
   # @param [String] address Public key, in hex
   # @param [Integer] amount The amount of ERC20 tokens to send
-  # @param [Integer] gas_limit How much gas you are ready to spend
+  # @param [Integer] gas_limit How much gas you're ready to spend
   # @param [Integer] gas_price How much gas you pay per computation unit
   # @return [String] Transaction hash
   def pay(priv, address, amount, gas_limit: nil, gas_price: nil)
@@ -98,93 +99,160 @@ class ERC20::Wallet
     data = "0x#{func}#{to_padded}#{amt_padded}"
     key = Eth::Key.new(priv: priv)
     from = key.address
-    nonce = jsonrpc.eth_getTransactionCount(from, 'pending').to_i(16)
-    tx = Eth::Tx.new(
-      {
-        nonce:,
-        gas_price: gas_price || gas_best_price,
-        gas_limit: gas_limit || gas_estimate(from, data),
-        to: @contract,
-        value: 0,
-        data: data,
-        chain_id: @chain
-      }
-    )
-    tx.sign(key)
-    hex = "0x#{tx.hex}"
-    jsonrpc.eth_sendRawTransaction(hex)
-    @log.debug("Sent #{amount} from #{from} to #{address}: #{hex}")
-    hex
+    tnx =
+      @mutex.synchronize do
+        nonce = jsonrpc.eth_getTransactionCount(from, 'pending').to_i(16)
+        tx = Eth::Tx.new(
+          {
+            nonce:,
+            gas_price: gas_price || gas_best_price,
+            gas_limit: gas_limit || gas_estimate(from, data),
+            to: @contract,
+            value: 0,
+            data: data,
+            chain_id: @chain
+          }
+        )
+        tx.sign(key)
+        hex = "0x#{tx.hex}"
+        jsonrpc.eth_sendRawTransaction(hex)
+      end
+    @log.debug("Sent #{amount} from #{from} to #{address}: #{tnx}")
+    tnx
   end
 
   # 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+.
+  #
+  # The array with the list of addresses (+addresses+) may change its
+  # content on-fly. The +accept()+ method will +eht_subscribe+ to the addresses
+  # that are added and will +eth_unsubscribe+ from those that are removed.
+  # Once we actually start listening, the +active+ array will be updated
+  # with the list of addresses.
+  #
+  # Both +addresses+ and +active+ must have two methods implemented: +to_a()+
+  # and +append()+. Only these methods will be called.
   #
   # @param [Array<String>] addresses Addresses to monitor
-  # @param [Array] ready When connected, TRUE will be added to this array
+  # @param [Array] active List of addresses that we are actually listening to
   # @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|
+  # @param [Integer] delay How many seconds to wait between +eth_subscribe+ calls
+  def accept(addresses, active = [], raw: false, delay: 1)
+    EventMachine.run do
+      u = url(http: false)
+      @log.debug("Connecting to #{u.hostname}:#{u.port}...")
+      ws = Faye::WebSocket::Client.new(u.to_s, [], proxy: @proxy ? { origin: @proxy } : {})
       log = @log
       contract = @contract
-      wss = @wss
+      id = rand(99_999)
+      attempt = []
       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)
-        connected.append(1)
-        log.debug("Subscribed to #{addresses.count} addresses")
+        verbose do
+          log.debug("Connected to ws://#{u.hostname}:#{u.port}")
+        end
       end
       ws.on(:message) do |msg|
-        data =
-          begin
-            JSON.parse(msg.data)
-          rescue StandardError
-            {}
+        verbose do
+          data =
+            begin
+              JSON.parse(msg.data)
+            rescue StandardError
+              {}
+            end
+          if data['id']
+            before = active.to_a
+            attempt.each do |a|
+              active.append(a) unless before.include?(a)
+            end
+            log.debug(
+              "Subscribed ##{id} to #{active.to_a.size} addresses: " \
+              "#{active.to_a.map { |a| a[0..6] }.join(', ')}"
+            )
+          elsif data['method'] == 'eth_subscription' && data.dig('params', 'result')
+            event = data['params']['result']
+            if raw
+              log.debug("New event arrived from #{event['address']}")
+            else
+              event = {
+                amount: event['data'].to_i(16),
+                from: "0x#{event['topics'][1][26..].downcase}",
+                to: "0x#{event['topics'][2][26..].downcase}"
+              }
+              log.debug("Payment of #{event[:amount]} tokens arrived from #{event[:from]} to #{event[:to]}")
+            end
+            yield event
           end
-        if data['method'] == 'eth_subscription' && data.dig('params', 'result')
-          event = data['params']['result']
-          unless raw
-            event = {
-              amount: event['data'].to_i(16),
-              from: "0x#{event['topics'][1][26..].downcase}",
-              to: "0x#{event['topics'][2][26..].downcase}"
-            }
-          end
-          log.debug("New event arrived from #{event['address']}")
-          yield event
         end
       end
-      ws.on(:close) do |_e|
-        log.debug("Disconnected from #{wss}")
+      ws.on(:close) do
+        verbose do
+          log.debug("Disconnected from ws://#{u.hostname}:#{u.port}")
+        end
       end
       ws.on(:error) do |e|
-        log.debug("Error at #{wss}: #{e}")
+        verbose do
+          log.debug("Error at #{u.hostname}: #{e.message}")
+        end
+      end
+      EventMachine.add_periodic_timer(delay) do
+        next if active.to_a.sort == addresses.to_a.sort
+        attempt = addresses.to_a
+        ws.send(
+          {
+            jsonrpc: '2.0',
+            id:,
+            method: 'eth_subscribe',
+            params: [
+              'logs',
+              {
+                address: contract,
+                topics: [
+                  '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+                  nil,
+                  addresses.to_a.map { |a| "0x000000000000000000000000#{a[2..]}" }
+                ]
+              }
+            ]
+          }.to_json
+        )
+        log.debug(
+          "Requested to subscribe ##{id} to #{addresses.to_a.size} addresses: " \
+          "#{addresses.to_a.map { |a| a[0..6] }.join(', ')}"
+        )
       end
     end
   end
 
   private
 
+  def verbose
+    yield
+  rescue StandardError => e
+    @log.error(Backtrace.new(e).to_s)
+    raise e
+  end
+
+  def url(http: true)
+    URI.parse("#{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.6'
 end

data/test/erc20/test_wallet.rb

@@ -23,22 +23,25 @@
 require 'backtrace'
 require 'donce'
 require 'eth'
+require 'faraday'
 require 'loog'
+require 'minitest/autorun'
 require 'random-port'
 require 'shellwords'
+require 'threads'
 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 +50,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 +64,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
@@ -82,6 +95,15 @@ class TestWallet < Minitest::Test
     end
   end
 
+  def test_checks_balance_on_hardhat_in_threads
+    on_hardhat do |wallet|
+      Threads.new.assert do
+        b = wallet.balance(Eth::Key.new(priv: JEFF).address.to_s)
+        assert_equal(123_000_100_000, b)
+      end
+    end
+  end
+
   def test_pays_on_hardhat
     on_hardhat do |wallet|
       to = Eth::Key.new(priv: WALTER).address.to_s
@@ -94,21 +116,34 @@ class TestWallet < Minitest::Test
     end
   end
 
+  def test_pays_on_hardhat_in_threads
+    on_hardhat do |wallet|
+      to = Eth::Key.new(priv: WALTER).address.to_s
+      before = wallet.balance(to)
+      sum = 42_000
+      mul = 10
+      Threads.new(mul).assert do
+        wallet.pay(JEFF, to, sum)
+      end
+      assert_equal(before + (sum * mul), wallet.balance(to))
+    end
+  end
+
   def test_accepts_payments_on_hardhat
     walter = Eth::Key.new(priv: WALTER).address.to_s.downcase
     jeff = Eth::Key.new(priv: JEFF).address.to_s.downcase
     on_hardhat do |wallet|
-      connected = []
+      active = []
       event = nil
       daemon =
         Thread.new do
-          wallet.accept([walter, jeff], connected:) do |e|
+          wallet.accept([walter, jeff], active) do |e|
             event = e
           end
         rescue StandardError => e
-          puts Backtrace.new(e)
+          loog.error(Backtrace.new(e))
         end
-      wait_for { !connected.empty? }
+      wait_for { !active.empty? }
       sum = 77_000
       wallet.pay(JEFF, walter, sum)
       wait_for { !event.nil? }
@@ -120,8 +155,112 @@ class TestWallet < Minitest::Test
     end
   end
 
+  def test_accepts_payments_on_changing_addresses_on_hardhat
+    walter = Eth::Key.new(priv: WALTER).address.to_s.downcase
+    jeff = Eth::Key.new(priv: JEFF).address.to_s.downcase
+    addresses = Primitivo.new([walter])
+    on_hardhat do |wallet|
+      active = Primitivo.new([])
+      event = nil
+      daemon =
+        Thread.new do
+          wallet.accept(addresses, active) do |e|
+            event = e
+          end
+        rescue StandardError => e
+          loog.error(Backtrace.new(e))
+        end
+      wait_for { active.to_a.include?(walter) }
+      sum1 = 453_000
+      wallet.pay(JEFF, walter, sum1)
+      wait_for { !event.nil? }
+      assert_equal(sum1, event[:amount])
+      sum2 = 22_000
+      event = nil
+      addresses.append(jeff)
+      wait_for { active.to_a.include?(jeff) }
+      wallet.pay(WALTER, jeff, sum2)
+      wait_for { !event.nil? }
+      assert_equal(sum2, event[:amount])
+      daemon.kill
+      daemon.join(30)
+    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)
+        active = []
+        event = nil
+        daemon =
+          Thread.new do
+            wallet.accept([walter, jeff], active) do |e|
+              event = e
+            end
+          rescue StandardError => e
+            loog.error(Backtrace.new(e))
+          end
+        wait_for { !active.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
+    active = []
+    failed = false
+    net = mainnet
+    daemon =
+      Thread.new do
+        net.accept([STABLE], active) do |_|
+          # ignore it
+        end
+      rescue StandardError => e
+        failed = true
+        loog.error(Backtrace.new(e))
+      end
+    wait_for { !active.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::ERRORS : Loog::VERBOSE
+  end
+
   def wait_for
     start = Time.now
     loop do
@@ -145,29 +284,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,16 +356,30 @@ 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
     end
   end
+
+  class Primitivo
+    def initialize(array)
+      @array = array
+    end
+
+    def to_a
+      @array.to_a
+    end
+
+    def append(item)
+      @array.append(item)
+    end
+  end
 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.6
 platform: ruby
 authors:
 - Yegor Bugayenko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-10 00:00:00.000000000 Z
+date: 2025-02-13 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: []