erc20 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14d84ab9ee2ac821f5f404dcea22437f622fe82bf5565a04c695f718974ba129
-  data.tar.gz: d2ec55f58ef13c62abfb0b870d541d3cc5bd8a32f5c685eda64fb484558af332
+  metadata.gz: ddbc3966b9eec2d455e33dde71df0427a7a99e4d59f0df69191d8f617434c8bf
+  data.tar.gz: 0d577a397eee74c5dae388ca620f8a681c4bec2af8d9b6cf5514ca32cbebc992
 SHA512:
-  metadata.gz: 2ef86114757f0b841b022a8cef64330610d68425d13e900487e4d99589065ed19640f393986f3ea62003fe2d24ae93513406611d4725d58dcc3165e7e70a5ffa
-  data.tar.gz: 92855745194e5cf9b6ff1902f0f7e4f44606aa4e306313668e7fb01849ab91e10fccf99e6f7ac6dfa0a6e176abc6d7aaa30f279b88e7c0f94b1133380f61d643
+  metadata.gz: 1f87ab9c39b5476b9b90bd44020f21970edc8830826129b0a2c6386d562887627e346c55a1e8bb1fcf3e9983d1977e6e0851b7e2fdc162217898951988b2173f
+  data.tar.gz: 02d6b7e7058dd6c6f3a74b81ece853e674020a4df84b6fa439b74438ff8227616a76cf3abd1a6f82fdfb7f34391c4e541f96791e404e8e84cb3f364d72e92771

data/lib/erc20/wallet.rb

@@ -29,9 +29,9 @@ require 'loog'
 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
@@ -65,6 +65,7 @@ class ERC20::Wallet
     @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,23 +99,26 @@ 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
@@ -122,22 +126,83 @@ class ERC20::Wallet
   # 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)
-    EM.run do
+  # @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}...")
-      ws = Faye::WebSocket::Client.new(u, [], proxy: @proxy ? { origin: @proxy } : {})
+      @log.debug("Connecting to #{u.hostname}:#{u.port}...")
+      ws = Faye::WebSocket::Client.new(u.to_s, [], proxy: @proxy ? { origin: @proxy } : {})
       log = @log
       contract = @contract
+      id = rand(99_999)
+      attempt = []
       ws.on(:open) do
-        log.debug("Connected to #{@host}")
+        verbose do
+          log.debug("Connected to ws://#{u.hostname}:#{u.port}")
+        end
+      end
+      ws.on(:message) do |msg|
+        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
+        end
+      end
+      ws.on(:close) do
+        verbose do
+          log.debug("Disconnected from ws://#{u.hostname}:#{u.port}")
+        end
+      end
+      ws.on(:error) do |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: 1,
+            id:,
             method: 'eth_subscribe',
             params: [
               'logs',
@@ -146,48 +211,31 @@ class ERC20::Wallet
                 topics: [
                   '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
                   nil,
-                  addresses.map { |a| "0x000000000000000000000000#{a[2..]}" }
+                  addresses.to_a.map { |a| "0x000000000000000000000000#{a[2..]}" }
                 ]
               }
             ]
           }.to_json
         )
-        connected.append(1)
-        log.debug("Subscribed to #{addresses.count} addresses")
-      end
-      ws.on(:message) do |msg|
-        data =
-          begin
-            JSON.parse(msg.data)
-          rescue StandardError
-            {}
-          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 #{@host}")
-      end
-      ws.on(:error) do |e|
-        log.debug("Error at #{@host}: #{e.message}")
+        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)
-    "#{http ? 'http' : 'ws'}#{@ssl ? 's' : ''}://#{@host}:#{@port}#{http ? @http_path : @ws_path}"
+    URI.parse("#{http ? 'http' : 'ws'}#{@ssl ? 's' : ''}://#{@host}:#{@port}#{http ? @http_path : @ws_path}")
   end
 
   def jsonrpc

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.5'
+  VERSION = '0.0.6'
 end

data/test/erc20/test_wallet.rb

@@ -28,6 +28,7 @@ require 'loog'
 require 'minitest/autorun'
 require 'random-port'
 require 'shellwords'
+require 'threads'
 require 'typhoeus'
 require_relative '../../lib/erc20'
 require_relative '../../lib/erc20/wallet'
@@ -94,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
@@ -106,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
           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? }
@@ -132,23 +155,55 @@ 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)
-        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
             loog.error(Backtrace.new(e))
           end
-        wait_for { !connected.empty? }
+        wait_for { !active.empty? }
         sum = 55_000
         wallet.pay(JEFF, walter, sum)
         wait_for { !event.nil? }
@@ -160,19 +215,19 @@ class TestWallet < Minitest::Test
   end
 
   def test_accepts_payments_on_mainnet
-    connected = []
+    active = []
     failed = false
     net = mainnet
     daemon =
       Thread.new do
-        net.accept([STABLE], connected:) do |_|
+        net.accept([STABLE], active) do |_|
           # ignore it
         end
       rescue StandardError => e
         failed = true
         loog.error(Backtrace.new(e))
       end
-    wait_for { !connected.empty? }
+    wait_for { !active.empty? }
     daemon.kill
     daemon.join(30)
     refute(failed)
@@ -203,7 +258,7 @@ class TestWallet < Minitest::Test
   private
 
   def loog
-    ENV['RAKE'] ? Loog::NULL : Loog::VERBOSE
+    ENV['RAKE'] ? Loog::ERRORS : Loog::VERBOSE
   end
 
   def wait_for
@@ -313,4 +368,18 @@ class TestWallet < Minitest::Test
       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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: erc20
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Yegor Bugayenko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-11 00:00:00.000000000 Z
+date: 2025-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eth