erc20 0.1.6 → 0.2.1

data/test/erc20/test_wallet.rb

@@ -1,334 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require 'backtrace'
-require 'donce'
-require 'eth'
-require 'faraday'
-require 'fileutils'
-require 'json'
-require 'os'
-require 'random-port'
-require 'shellwords'
-require 'threads'
-require 'typhoeus'
-require_relative '../test__helper'
-require_relative '../../lib/erc20/wallet'
-
-# Test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2025 Yegor Bugayenko
-# License:: MIT
-class TestWallet < ERC20::Test
-  # One guy private hex.
-  JEFF = '81a9b2114d53731ecc84b261ef6c0387dde34d5907fe7b441240cc21d61bf80a'
-
-  # Another guy private hex.
-  WALTER = '91f9111b1744d55361e632771a4e53839e9442a9fef45febc0a5c838c686a15b'
-
-  def test_logs_to_stdout
-    WebMock.disable_net_connect!
-    stub_request(:post, 'https://example.org/').to_return(
-      body: { jsonrpc: '2.0', id: 42, result: '0x1F1F1F' }.to_json,
-      headers: { 'Content-Type' => 'application/json' }
-    )
-    w = ERC20::Wallet.new(
-      host: 'example.org',
-      http_path: '/',
-      log: $stdout
-    )
-    w.balance(Eth::Key.new(priv: JEFF).address.to_s)
-  end
-
-  def test_checks_balance_on_testnet
-    WebMock.enable_net_connect!
-    b = testnet.balance(Eth::Key.new(priv: JEFF).address.to_s)
-    refute_nil(b)
-    assert_predicate(b, :zero?)
-  end
-
-  def test_checks_gas_estimate_on_hardhat
-    WebMock.enable_net_connect!
-    sum = 100_000
-    on_hardhat do |wallet|
-      b1 = wallet.gas_estimate(
-        Eth::Key.new(priv: JEFF).address.to_s,
-        Eth::Key.new(priv: WALTER).address.to_s,
-        sum
-      )
-      assert_operator(b1, :>, 21_000)
-    end
-  end
-
-  def test_checks_balance_on_hardhat
-    WebMock.enable_net_connect!
-    on_hardhat do |wallet|
-      b = wallet.balance(Eth::Key.new(priv: JEFF).address.to_s)
-      assert_equal(123_000_100_000, b)
-    end
-  end
-
-  def test_checks_eth_balance_on_hardhat
-    WebMock.enable_net_connect!
-    on_hardhat do |wallet|
-      b = wallet.balance(Eth::Key.new(priv: WALTER).address.to_s)
-      assert_equal(456_000_000_000, b)
-    end
-  end
-
-  def test_checks_balance_on_hardhat_in_threads
-    WebMock.enable_net_connect!
-    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
-    WebMock.enable_net_connect!
-    on_hardhat do |wallet|
-      to = Eth::Key.new(priv: WALTER).address.to_s
-      before = wallet.balance(to)
-      sum = 42_000
-      from = Eth::Key.new(priv: JEFF).address.to_s
-      assert_operator(wallet.balance(from), :>, sum * 2)
-      txn = wallet.pay(JEFF, to, sum)
-      assert_equal(66, txn.length)
-      assert_match(/^0x[a-f0-9]{64}$/, txn)
-      assert_equal(before + sum, wallet.balance(to))
-    end
-  end
-
-  def test_eth_pays_on_hardhat
-    WebMock.enable_net_connect!
-    on_hardhat do |wallet|
-      to = Eth::Key.new(priv: WALTER).address.to_s
-      before = wallet.eth_balance(to)
-      sum = 42_000
-      from = Eth::Key.new(priv: JEFF).address.to_s
-      assert_operator(wallet.eth_balance(from), :>, sum * 2)
-      txn = wallet.eth_pay(JEFF, to, sum)
-      assert_equal(66, txn.length)
-      assert_match(/^0x[a-f0-9]{64}$/, txn)
-      assert_equal(before + sum, wallet.eth_balance(to))
-    end
-  end
-
-  def test_pays_on_hardhat_in_threads
-    WebMock.enable_net_connect!
-    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_pays_eth_on_hardhat_in_threads
-    WebMock.enable_net_connect!
-    on_hardhat do |wallet|
-      to = Eth::Key.new(priv: WALTER).address.to_s
-      before = wallet.eth_balance(to)
-      sum = 42_000
-      mul = 10
-      Threads.new(mul).assert do
-        wallet.eth_pay(JEFF, to, sum)
-      end
-      assert_equal(before + (sum * mul), wallet.eth_balance(to))
-    end
-  end
-
-  def test_accepts_payments_on_hardhat
-    WebMock.enable_net_connect!
-    walter = Eth::Key.new(priv: WALTER).address.to_s.downcase
-    jeff = Eth::Key.new(priv: JEFF).address.to_s.downcase
-    on_hardhat do |wallet|
-      active = []
-      event = nil
-      daemon =
-        Thread.new do
-          wallet.accept([walter, jeff], active) do |e|
-            event = e
-          end
-        rescue StandardError => e
-          fake_loog.error(Backtrace.new(e))
-        end
-      wait_for { !active.empty? }
-      sum = 77_000
-      wallet.pay(JEFF, walter, sum)
-      wait_for { !event.nil? }
-      daemon.kill
-      daemon.join(30)
-      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_hardhat_after_disconnect
-    skip('Works only on macOS') unless OS.mac?
-    WebMock.enable_net_connect!
-    walter = Eth::Key.new(priv: WALTER).address.to_s.downcase
-    Dir.mktmpdir do |home|
-      die = File.join(home, 'die.txt')
-      on_hardhat(die:) do |wallet|
-        active = []
-        events = []
-        daemon =
-          Thread.new do
-            wallet.accept([walter], active, subscription_id: 42) do |e|
-              events.append(e)
-            end
-          rescue StandardError => e
-            fake_loog.error(Backtrace.new(e))
-          end
-        wait_for { !active.empty? }
-        wallet.pay(JEFF, walter, 4_567)
-        wait_for { events.size == 1 }
-        FileUtils.touch(die)
-        on_hardhat(port: wallet.port) do
-          wallet.pay(JEFF, walter, 3_456)
-          wait_for { events.size > 1 }
-          daemon.kill
-          daemon.join(30)
-          assert_equal(3, events.size)
-        end
-      end
-    end
-  end
-
-  def test_accepts_many_payments_on_hardhat
-    WebMock.enable_net_connect!
-    walter = Eth::Key.new(priv: WALTER).address.to_s.downcase
-    on_hardhat do |wallet|
-      active = []
-      events = Concurrent::Set.new
-      total = 10
-      daemon =
-        Thread.new do
-          wallet.accept([walter], active) do |e|
-            events.add(e)
-          end
-        rescue StandardError => e
-          fake_loog.error(Backtrace.new(e))
-        end
-      wait_for { !active.empty? }
-      sum = 1_234
-      Threads.new(total).assert do
-        wallet.pay(JEFF, walter, sum)
-      end
-      wait_for { events.size == total }
-      daemon.kill
-      daemon.join(30)
-      assert_equal(total, events.size)
-    end
-  end
-
-  def test_accepts_payments_with_failures_on_hardhat
-    WebMock.enable_net_connect!
-    walter = Eth::Key.new(priv: WALTER).address.to_s.downcase
-    on_hardhat do |wallet|
-      active = []
-      events = Concurrent::Set.new
-      total = 10
-      daemon =
-        Thread.new do
-          wallet.accept([walter], active) do |e|
-            events.add(e)
-            raise 'intentional'
-          end
-        end
-      wait_for { !active.empty? }
-      sum = 1_234
-      Threads.new(total).assert do
-        wallet.pay(JEFF, walter, sum)
-      end
-      wait_for { events.size == total }
-      daemon.kill
-      daemon.join(30)
-      assert_equal(total, events.size)
-    end
-  end
-
-  def test_accepts_payments_on_changing_addresses_on_hardhat
-    WebMock.enable_net_connect!
-    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
-          fake_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
-    WebMock.enable_net_connect!
-    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
-            fake_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_checks_balance_via_proxy
-    WebMock.enable_net_connect!
-    b = nil
-    via_proxy do |proxy|
-      on_hardhat do |w|
-        wallet = through_proxy(w, proxy)
-        b = wallet.balance(Eth::Key.new(priv: JEFF).address.to_s)
-      end
-    end
-    assert_equal(123_000_100_000, b)
-  end
-end

data/test/erc20/test_wallet_live.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require 'backtrace'
-require 'donce'
-require 'eth'
-require 'faraday'
-require 'fileutils'
-require 'json'
-require 'os'
-require 'random-port'
-require 'shellwords'
-require 'threads'
-require 'typhoeus'
-require_relative '../test__helper'
-require_relative '../../lib/erc20/wallet'
-
-# Test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2025 Yegor Bugayenko
-# License:: MIT
-class TestWalletLive < ERC20::Test
-  # At this address, in Ethereum mainnet, there are $8 USDT and 0.0042 ETH. I won't
-  # move them anyway, that's why tests can use this address forever.
-  STABLE = '0x7232148927F8a580053792f44D4d59d40Fd00ABD'
-
-  def test_checks_balance_on_mainnet
-    WebMock.enable_net_connect!
-    b = mainnet.balance(STABLE)
-    refute_nil(b)
-    assert_equal(8_000_000, b) # this is $8 USDT
-  end
-
-  def test_checks_eth_balance_on_mainnet
-    WebMock.enable_net_connect!
-    b = mainnet.eth_balance(STABLE)
-    refute_nil(b)
-    assert_equal(4_200_000_000_000_000, b) # this is 0.0042 ETH
-  end
-
-  def test_checks_balance_of_absent_address
-    WebMock.enable_net_connect!
-    a = '0xEB2fE8872A6f1eDb70a2632Effffffffffffffff'
-    b = mainnet.balance(a)
-    refute_nil(b)
-    assert_equal(0, b)
-  end
-
-  def test_checks_gas_estimate_on_mainnet
-    WebMock.enable_net_connect!
-    b = mainnet.gas_estimate(STABLE, '0x7232148927F8a580053792f44D4d5FFFFFFFFFFF', 44_000)
-    refute_nil(b)
-    assert_predicate(b, :positive?)
-    assert_operator(b, :>, 1000)
-  end
-
-  def test_fails_with_invalid_infura_key
-    WebMock.enable_net_connect!
-    skip('Apparently, even with invalid key, Infura returns balance')
-    w = ERC20::Wallet.new(
-      contract: ERC20::Wallet.USDT,
-      host: 'mainnet.infura.io',
-      http_path: '/v3/invalid-key-here',
-      log: fake_loog
-    )
-    assert_raises(StandardError) { w.balance(STABLE) }
-  end
-
-  def test_checks_balance_on_polygon
-    WebMock.enable_net_connect!
-    w = ERC20::Wallet.new(
-      contract: '0xc2132D05D31c914a87C6611C10748AEb04B58e8F',
-      host: 'polygon-mainnet.infura.io',
-      http_path: "/v3/#{env('INFURA_KEY')}",
-      log: fake_loog
-    )
-    b = w.balance(STABLE)
-    refute_nil(b)
-    assert_predicate(b, :zero?)
-  end
-
-  def test_accepts_payments_on_mainnet
-    WebMock.enable_net_connect!
-    active = []
-    failed = false
-    net = mainnet
-    daemon =
-      Thread.new do
-        net.accept([STABLE], active) do |_|
-          # ignore it
-        end
-      rescue StandardError => e
-        failed = true
-        fake_loog.error(Backtrace.new(e))
-      end
-    wait_for { !active.empty? }
-    daemon.kill
-    daemon.join(30)
-    refute(failed)
-  end
-
-  def test_checks_balance_via_proxy_on_mainnet
-    WebMock.enable_net_connect!
-    via_proxy do |proxy|
-      w = ERC20::Wallet.new(
-        host: 'mainnet.infura.io',
-        http_path: "/v3/#{env('INFURA_KEY')}",
-        proxy:, log: fake_loog
-      )
-      assert_equal(8_000_000, w.balance(STABLE))
-    end
-  end
-
-  def test_pays_on_mainnet
-    WebMock.enable_net_connect!
-    skip('This is live, must be run manually')
-    w = mainnet
-    print 'Enter Ethereum ERC20 private key (64 chars): '
-    priv = gets.chomp
-    to = '0xEB2fE8872A6f1eDb70a2632EA1f869AB131532f6'
-    txn = w.pay(priv, to, 1_990_000)
-    assert_equal(66, txn.length)
-  end
-end

data/test/test__helper.rb

@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-$stdout.sync = true
-
-require 'simplecov'
-require 'simplecov-cobertura'
-unless SimpleCov.running
-  SimpleCov.command_name('test')
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
-    [
-      SimpleCov::Formatter::HTMLFormatter,
-      SimpleCov::Formatter::CoberturaFormatter
-    ]
-  )
-  SimpleCov.minimum_coverage 90
-  SimpleCov.minimum_coverage_by_file 90
-  SimpleCov.start do
-    add_filter 'test/'
-    add_filter 'vendor/'
-    add_filter 'target/'
-    track_files 'lib/**/*.rb'
-    track_files '*.rb'
-  end
-end
-
-require 'minitest/autorun'
-require 'minitest/reporters'
-Minitest::Reporters.use! [Minitest::Reporters::SpecReporter.new]
-
-# To make tests retry on failure:
-if ENV['RAKE']
-  require 'minitest/retry'
-  Minitest::Retry.use!
-end
-
-# Primitive array.
-class Primitivo
-  def initialize(array)
-    @array = array
-  end
-
-  def clear
-    @array.clear
-  end
-
-  def to_a
-    @array.to_a
-  end
-
-  def append(item)
-    @array.append(item)
-  end
-end
-
-require 'webmock/minitest'
-
-# Test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2025 Yegor Bugayenko
-# License:: MIT
-class ERC20::Test < Minitest::Test
-  def fake_loog
-    ENV['RAKE'] ? Loog::ERRORS : Loog::VERBOSE
-  end
-
-  def wait_for(seconds = 30)
-    start = Time.now
-    loop do
-      sleep(0.1)
-      break if yield
-      passed = Time.now - start
-      raise "Giving up after #{passed} seconds of waiting" if passed > seconds
-    rescue Errno::ECONNREFUSED
-      retry
-    end
-  end
-
-  def wait_for_port(port)
-    wait_for { Typhoeus::Request.get("http://localhost:#{port}").code == 200 }
-  end
-
-  def env(var)
-    key = ENV.fetch(var, nil)
-    skip("The #{var} environment variable is not set") if key.nil?
-    skip("The #{var} environment variable is empty") if key.empty?
-    key
-  end
-
-  def mainnet
-    [
-      {
-        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: fake_loog
-      )
-    end.sample
-  end
-
-  def testnet
-    [
-      {
-        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: fake_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: fake_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: fake_loog
-      ) do
-        yield "http://jeffrey:swordfish@localhost:#{port}"
-      end
-    end
-  end
-
-  def on_hardhat(port: nil, die: nil)
-    RandomPort::Pool::SINGLETON.acquire do |rnd|
-      port = rnd if port.nil?
-      if die
-        killer = [
-          '&',
-          'HARDHAT_PID=$!;',
-          'export HARDHAT_PID;',
-          'while true; do',
-          "  if [ -e #{Shellwords.escape(File.join('/die', File.basename(die)))} ]; then",
-          '    kill -9 "${HARDHAT_PID}";',
-          '    break;',
-          '  else',
-          '    sleep 0.1;',
-          '  fi;',
-          'done'
-        ].join(' ')
-      end
-      cmd = "npx hardhat node #{killer if die}"
-      donce(
-        home: File.join(__dir__, '../hardhat'),
-        ports: { port => 8545 },
-        volumes: die ? { File.dirname(die) => '/die' } : {},
-        command: "/bin/bash -c #{Shellwords.escape(cmd)}",
-        log: fake_loog
-      ) do
-        wait_for_port(port)
-        cmd = [
-          '(cat hardhat.config.js)',
-          '(ls -al)',
-          '(echo y | npx hardhat ignition deploy ./ignition/modules/Foo.ts --network foo --deployment-id foo)',
-          '(npx hardhat ignition status foo | tail -1 | cut -d" " -f3)'
-        ].join(' && ')
-        contract = donce(
-          home: File.join(__dir__, '../hardhat'),
-          command: "/bin/bash -c #{Shellwords.escape(cmd)}",
-          build_args: { 'HOST' => donce_host, 'PORT' => port },
-          log: fake_loog,
-          root: true
-        ).split("\n").last
-        wallet = ERC20::Wallet.new(
-          contract:, chain: 4242,
-          host: 'localhost', port:, http_path: '/', ws_path: '/', ssl: false,
-          log: fake_loog
-        )
-        yield wallet
-      end
-    end
-  end
-end