erc20 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14d84ab9ee2ac821f5f404dcea22437f622fe82bf5565a04c695f718974ba129
-  data.tar.gz: d2ec55f58ef13c62abfb0b870d541d3cc5bd8a32f5c685eda64fb484558af332
+  metadata.gz: 47883e48393686ed5d357fb9f5f762e0744a30a8f0999724dd2ddba369ac75ae
+  data.tar.gz: bad63b9aa6269a79cc2276c10c0f6aec02d8bf94bf18057b89fc0e9f896833be
 SHA512:
-  metadata.gz: 2ef86114757f0b841b022a8cef64330610d68425d13e900487e4d99589065ed19640f393986f3ea62003fe2d24ae93513406611d4725d58dcc3165e7e70a5ffa
-  data.tar.gz: 92855745194e5cf9b6ff1902f0f7e4f44606aa4e306313668e7fb01849ab91e10fccf99e6f7ac6dfa0a6e176abc6d7aaa30f279b88e7c0f94b1133380f61d643
+  metadata.gz: bf78c2548b09b33c9e67ba7476d9e14576f9be07ca1cbb1620067899451c96c587a87849d7c86c88ec449254362db9d921a4d0fde9534954b8ad9c48405f4b51
+  data.tar.gz: 224500ace20e3abaa25bbdc4a6be32fe7fca7b57b7d7b2bf4a4b01a8dac50a3fb45bf2a70c13f2f737b502a5ea80c4f452eeda5d0737ed6c5087d1458b590f20

data/README.md

@@ -37,7 +37,8 @@ hex = w.pay(private_key, to_address, amount)
 # 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[:txt] # hash of transaction
+  puts event[:amount] # how much, in tokens (1000000 = $1 USDT)
   puts event[:from] # who sent the payment
   puts event[:to] # who was the receiver
 end

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,84 @@ 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}",
+                txn: event['transactionHash']
+              }
+              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 +212,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.7'
 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'
@@ -38,7 +39,7 @@ require_relative '../test__helper'
 # Copyright:: Copyright (c) 2025 Yegor Bugayenko
 # License:: MIT
 class TestWallet < Minitest::Test
-  # At this address, in Etherium mainnet, there are a few USDT tokens. I won't
+  # At this address, in Etherium mainnet, there are a ~$27 USDT. I won't
   # move them anyway, that's why tests can use this address forever.
   STABLE = '0xEB2fE8872A6f1eDb70a2632EA1f869AB131532f6'
 
@@ -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
@@ -101,26 +111,40 @@ class TestWallet < Minitest::Test
       sum = 42_000
       from = Eth::Key.new(priv: JEFF).address.to_s
       assert_operator(wallet.balance(from), :>, sum * 2)
-      wallet.pay(JEFF, to, sum)
+      txn = wallet.pay(JEFF, to, sum)
+      assert_equal(66, txn.length)
       assert_equal(before + sum, wallet.balance(to))
     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? }
@@ -129,6 +153,39 @@ class TestWallet < Minitest::Test
       assert_equal(sum, event[:amount])
       assert_equal(jeff, event[:from])
       assert_equal(walter, event[:to])
+      assert_equal(66, event[:txn].length)
+    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
 
@@ -138,17 +195,17 @@ class TestWallet < Minitest::Test
       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 +217,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 +260,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 +370,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.7
 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