viem_rb 0.1.0

data/lib/viem/chains/definitions.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Viem
+  module Chains
+    MAINNET = Chain.new(
+      id: 1,
+      name: "Ethereum",
+      network: "homestead",
+      native_currency: NativeCurrency.new(name: "Ether", symbol: "ETH", decimals: 18),
+      rpc_urls: { default: { http: ["https://cloudflare-eth.com"] } },
+      block_explorers: { default: { name: "Etherscan", url: "https://etherscan.io" } },
+      testnet: false
+    )
+
+    SEPOLIA = Chain.new(
+      id: 11_155_111,
+      name: "Sepolia",
+      network: "sepolia",
+      native_currency: NativeCurrency.new(name: "Sepolia Ether", symbol: "ETH", decimals: 18),
+      rpc_urls: { default: { http: ["https://rpc.sepolia.org"] } },
+      block_explorers: { default: { name: "Etherscan", url: "https://sepolia.etherscan.io" } },
+      testnet: true
+    )
+
+    GOERLI = Chain.new(
+      id: 5,
+      name: "Goerli",
+      network: "goerli",
+      native_currency: NativeCurrency.new(name: "Goerli Ether", symbol: "ETH", decimals: 18),
+      rpc_urls: { default: { http: ["https://rpc.ankr.com/eth_goerli"] } },
+      block_explorers: { default: { name: "Etherscan", url: "https://goerli.etherscan.io" } },
+      testnet: true
+    )
+
+    POLYGON = Chain.new(
+      id: 137,
+      name: "Polygon",
+      network: "matic",
+      native_currency: NativeCurrency.new(name: "MATIC", symbol: "MATIC", decimals: 18),
+      rpc_urls: { default: { http: ["https://polygon-rpc.com"] } },
+      block_explorers: { default: { name: "PolygonScan", url: "https://polygonscan.com" } },
+      testnet: false
+    )
+
+    POLYGON_MUMBAI = Chain.new(
+      id: 80_001,
+      name: "Polygon Mumbai",
+      network: "maticmum",
+      native_currency: NativeCurrency.new(name: "MATIC", symbol: "MATIC", decimals: 18),
+      rpc_urls: { default: { http: ["https://rpc-mumbai.maticvigil.com"] } },
+      block_explorers: { default: { name: "PolygonScan", url: "https://mumbai.polygonscan.com" } },
+      testnet: true
+    )
+
+    OPTIMISM = Chain.new(
+      id: 10,
+      name: "Optimism",
+      network: "optimism",
+      native_currency: NativeCurrency.new(name: "Ether", symbol: "ETH", decimals: 18),
+      rpc_urls: { default: { http: ["https://mainnet.optimism.io"] } },
+      block_explorers: { default: { name: "Optimism Explorer", url: "https://optimistic.etherscan.io" } },
+      testnet: false
+    )
+
+    OPTIMISM_GOERLI = Chain.new(
+      id: 420,
+      name: "Optimism Goerli",
+      network: "optimism-goerli",
+      native_currency: NativeCurrency.new(name: "Goerli Ether", symbol: "ETH", decimals: 18),
+      rpc_urls: { default: { http: ["https://goerli.optimism.io"] } },
+      block_explorers: { default: { name: "Optimism Explorer", url: "https://goerli-optimism.etherscan.io" } },
+      testnet: true
+    )
+
+    ARBITRUM = Chain.new(
+      id: 42_161,
+      name: "Arbitrum One",
+      network: "arbitrum",
+      native_currency: NativeCurrency.new(name: "Ether", symbol: "ETH", decimals: 18),
+      rpc_urls: { default: { http: ["https://arb1.arbitrum.io/rpc"] } },
+      block_explorers: { default: { name: "Arbiscan", url: "https://arbiscan.io" } },
+      testnet: false
+    )
+
+    ARBITRUM_GOERLI = Chain.new(
+      id: 421_613,
+      name: "Arbitrum Goerli",
+      network: "arbitrum-goerli",
+      native_currency: NativeCurrency.new(name: "Arbitrum Goerli Ether", symbol: "AGOR", decimals: 18),
+      rpc_urls: { default: { http: ["https://goerli-rollup.arbitrum.io/rpc"] } },
+      block_explorers: { default: { name: "Arbiscan", url: "https://goerli.arbiscan.io" } },
+      testnet: true
+    )
+
+    BASE = Chain.new(
+      id: 8453,
+      name: "Base",
+      network: "base",
+      native_currency: NativeCurrency.new(name: "Ether", symbol: "ETH", decimals: 18),
+      rpc_urls: { default: { http: ["https://mainnet.base.org"] } },
+      block_explorers: { default: { name: "Basescan", url: "https://basescan.org" } },
+      testnet: false
+    )
+
+    BASE_GOERLI = Chain.new(
+      id: 84_531,
+      name: "Base Goerli",
+      network: "base-goerli",
+      native_currency: NativeCurrency.new(name: "Goerli Ether", symbol: "ETH", decimals: 18),
+      rpc_urls: { default: { http: ["https://goerli.base.org"] } },
+      block_explorers: { default: { name: "Basescan", url: "https://goerli.basescan.org" } },
+      testnet: true
+    )
+
+    AVALANCHE = Chain.new(
+      id: 43_114,
+      name: "Avalanche",
+      network: "avalanche",
+      native_currency: NativeCurrency.new(name: "Avalanche", symbol: "AVAX", decimals: 18),
+      rpc_urls: { default: { http: ["https://api.avax.network/ext/bc/C/rpc"] } },
+      block_explorers: { default: { name: "SnowTrace", url: "https://snowtrace.io" } },
+      testnet: false
+    )
+
+    AVALANCHE_FUJI = Chain.new(
+      id: 43_113,
+      name: "Avalanche Fuji",
+      network: "avalanche-fuji",
+      native_currency: NativeCurrency.new(name: "Avalanche", symbol: "AVAX", decimals: 18),
+      rpc_urls: { default: { http: ["https://api.avax-test.network/ext/bc/C/rpc"] } },
+      block_explorers: { default: { name: "SnowTrace", url: "https://testnet.snowtrace.io" } },
+      testnet: true
+    )
+
+    BSC = Chain.new(
+      id: 56,
+      name: "BNB Smart Chain",
+      network: "bsc",
+      native_currency: NativeCurrency.new(name: "BNB", symbol: "BNB", decimals: 18),
+      rpc_urls: { default: { http: ["https://bsc-dataseed.binance.org"] } },
+      block_explorers: { default: { name: "BscScan", url: "https://bscscan.com" } },
+      testnet: false
+    )
+
+    BSC_TESTNET = Chain.new(
+      id: 97,
+      name: "BNB Smart Chain Testnet",
+      network: "bsc-testnet",
+      native_currency: NativeCurrency.new(name: "BNB", symbol: "tBNB", decimals: 18),
+      rpc_urls: { default: { http: ["https://data-seed-prebsc-1-s1.binance.org:8545"] } },
+      block_explorers: { default: { name: "BscScan", url: "https://testnet.bscscan.com" } },
+      testnet: true
+    )
+
+    GNOSIS = Chain.new(
+      id: 100,
+      name: "Gnosis",
+      network: "gnosis",
+      native_currency: NativeCurrency.new(name: "xDAI", symbol: "xDAI", decimals: 18),
+      rpc_urls: { default: { http: ["https://rpc.gnosischain.com"] } },
+      block_explorers: { default: { name: "Gnosis Scan", url: "https://gnosisscan.io" } },
+      testnet: false
+    )
+
+    FANTOM = Chain.new(
+      id: 250,
+      name: "Fantom",
+      network: "fantom",
+      native_currency: NativeCurrency.new(name: "Fantom", symbol: "FTM", decimals: 18),
+      rpc_urls: { default: { http: ["https://rpc.ftm.tools"] } },
+      block_explorers: { default: { name: "FtmScan", url: "https://ftmscan.com" } },
+      testnet: false
+    )
+
+    CELO = Chain.new(
+      id: 42_220,
+      name: "Celo",
+      network: "celo",
+      native_currency: NativeCurrency.new(name: "CELO", symbol: "CELO", decimals: 18),
+      rpc_urls: { default: { http: ["https://forno.celo.org"] } },
+      block_explorers: { default: { name: "Celo Explorer", url: "https://explorer.celo.org" } },
+      testnet: false
+    )
+  end
+end

data/lib/viem/clients/public_client.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Viem
+  module Clients
+    class PublicClient
+      include Actions::Public::GetBalance
+      include Actions::Public::GetBlock
+      include Actions::Public::GetTransaction
+      include Actions::Public::Call
+      include Actions::Public::ReadContract
+      include Actions::Public::GetLogs
+      include Actions::Public::GetGas
+      include Actions::Public::GetCode
+      include Actions::Public::Ens
+
+      attr_reader :transport, :chain
+
+      def initialize(transport:, chain: nil)
+        @transport = transport
+        @chain     = chain
+      end
+
+      def chain_id
+        result = @transport.request("eth_chainId", [])
+        Utils::Hex.hex_to_number(result)
+      end
+
+      def get_network
+        { chain_id: chain_id, name: @chain&.name }
+      end
+
+      private
+
+      def stringify_keys(h)
+        h.transform_keys { |k| k.to_s.gsub(/_([a-z])/) { ::Regexp.last_match(1).upcase } }
+      end
+    end
+  end
+end

data/lib/viem/clients/test_client.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Viem
+  module Clients
+    class TestClient < PublicClient
+      def mine(blocks: 1, interval: 0)
+        @transport.request("anvil_mine", [
+          Utils::Hex.number_to_hex(blocks),
+          Utils::Hex.number_to_hex(interval)
+        ])
+      end
+
+      def set_balance(address:, value:)
+        @transport.request("anvil_setBalance", [address, Utils::Hex.number_to_hex(value)])
+      end
+
+      def set_code(address:, bytecode:)
+        @transport.request("anvil_setCode", [address, bytecode])
+      end
+
+      def set_storage_at(address:, slot:, value:)
+        @transport.request("anvil_setStorageAt", [address, slot, value])
+      end
+
+      def impersonate_account(address:)
+        @transport.request("anvil_impersonateAccount", [address])
+      end
+
+      def stop_impersonating_account(address:)
+        @transport.request("anvil_stopImpersonatingAccount", [address])
+      end
+
+      def snapshot
+        @transport.request("evm_snapshot", [])
+      end
+
+      def revert(id:)
+        @transport.request("evm_revert", [id])
+      end
+
+      def increase_time(seconds:)
+        @transport.request("evm_increaseTime", [seconds])
+      end
+
+      def set_next_block_timestamp(timestamp:)
+        @transport.request("evm_setNextBlockTimestamp", [timestamp])
+      end
+
+      def reset(url: nil, block_number: nil)
+        params = url ? [{ jsonRpcUrl: url, blockNumber: block_number }.compact] : []
+        @transport.request("anvil_reset", params)
+      end
+    end
+  end
+end

data/lib/viem/clients/wallet_client.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Viem
+  module Clients
+    class WalletClient < PublicClient
+      include Actions::Wallet::SendTransaction
+      include Actions::Wallet::SignMessage
+      include Actions::Wallet::WriteContract
+      include Actions::Wallet::SignTypedData
+
+      attr_reader :account
+
+      def initialize(transport:, chain: nil, account: nil)
+        super(transport: transport, chain: chain)
+        @account = account
+      end
+
+      def get_addresses
+        return [@account.address] if @account
+
+        @transport.request("eth_accounts", [])
+      end
+    end
+  end
+end

data/lib/viem/errors.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Viem
+  class Error < StandardError; end
+
+  class TransportError < Error; end
+
+  class HttpRequestError < TransportError
+    attr_reader :status, :body
+
+    def initialize(msg = nil, status: nil, body: nil)
+      @status = status
+      @body   = body
+      super(msg)
+    end
+  end
+
+  class RpcError < Error
+    attr_reader :code, :data
+
+    def initialize(msg = nil, code: nil, data: nil)
+      @code = code
+      @data = data
+      super(msg)
+    end
+  end
+
+  class UserRejectedError < RpcError; end
+
+  class ContractFunctionExecutionError < Error
+    attr_reader :cause, :contract_address, :function_name, :args
+
+    def initialize(cause, contract_address: nil, function_name: nil, args: [])
+      @cause            = cause
+      @contract_address = contract_address
+      @function_name    = function_name
+      @args             = args
+      super("Contract function '#{function_name}' reverted: #{cause.message}")
+    end
+  end
+
+  class AbiEncodingError < Error; end
+  class AbiDecodingError < Error; end
+
+  class InvalidAddressError < Error
+    def initialize(address)
+      super("Invalid Ethereum address: #{address.inspect}")
+    end
+  end
+
+  class ChainMismatchError < Error; end
+
+  class AccountRequiredError < Error
+    def initialize
+      super("No account set on WalletClient. Pass an account to the client or action.")
+    end
+  end
+
+  class BlockNotFoundError < Error; end
+  class TransactionNotFoundError < Error; end
+  class TransactionReceiptNotFoundError < Error; end
+  class WaitForTransactionReceiptTimeoutError < Error; end
+end

data/lib/viem/transports/base.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Viem
+  module Transports
+    class Base
+      def request(method, params = [])
+        raise NotImplementedError
+      end
+
+      private
+
+      def build_rpc_body(method, params, id = 1)
+        { jsonrpc: "2.0", id: id, method: method, params: params }
+      end
+
+      def parse_response(body)
+        data = body.is_a?(String) ? JSON.parse(body, symbolize_names: true) : body
+        raise Viem::RpcError.new(data[:error][:message], code: data[:error][:code]) if data[:error]
+
+        data[:result]
+      end
+    end
+  end
+end

data/lib/viem/transports/fallback.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Viem
+  module Transports
+    class Fallback < Base
+      def initialize(*transports)
+        raise ArgumentError, "At least one transport required" if transports.empty?
+
+        @transports = transports
+      end
+
+      def request(method, params = [])
+        last_error = nil
+        @transports.each do |t|
+          return t.request(method, params)
+        rescue TransportError, RpcError => e
+          last_error = e
+          next
+        end
+        raise last_error || TransportError.new("All transports failed")
+      end
+    end
+  end
+end

data/lib/viem/transports/http.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Viem
+  module Transports
+    class Http < Base
+      attr_reader :url
+
+      def initialize(url, headers: {}, timeout: 30)
+        @url     = url
+        @headers = headers
+        @timeout = timeout
+        @mutex   = Mutex.new
+        @conn    = build_connection
+      end
+
+      def request(method, params = [])
+        body = build_rpc_body(method, params)
+        resp = @mutex.synchronize { @conn.post("/", body.to_json) }
+        unless resp.success?
+          raise HttpRequestError.new("HTTP #{resp.status}", status: resp.status, body: resp.body)
+        end
+
+        parse_response(resp.body)
+      rescue Faraday::Error => e
+        raise TransportError, e.message
+      end
+
+      private
+
+      def build_connection
+        Faraday.new(url: @url) do |f|
+          f.headers["Content-Type"] = "application/json"
+          f.headers["User-Agent"]   = "viem_rb/#{Viem::VERSION}"
+          @headers.each { |k, v| f.headers[k.to_s] = v }
+          f.options.timeout      = @timeout
+          f.options.open_timeout = 10
+          f.adapter Faraday.default_adapter
+        end
+      end
+    end
+  end
+end

data/lib/viem/transports/web_socket.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "websocket-client-simple"
+require "json"
+
+module Viem
+  module Transports
+    class WebSocket < Base
+      def initialize(url, timeout: 30)
+        @url     = url
+        @timeout = timeout
+        @pending = {}
+        @mutex   = Mutex.new
+        @id      = 0
+        connect
+      end
+
+      def request(method, params = [])
+        id   = next_id
+        body = build_rpc_body(method, params, id)
+        q    = Queue.new
+        @mutex.synchronize { @pending[id] = q }
+        @ws.send(body.to_json)
+        result = q.pop(timeout: @timeout)
+        raise TransportError, "WebSocket timeout waiting for response to #{method}" if result.nil?
+        raise RpcError.new(result[:error][:message], code: result[:error][:code]) if result[:error]
+
+        result[:result]
+      end
+
+      def close
+        @ws.close
+      end
+
+      private
+
+      def next_id
+        @mutex.synchronize { @id += 1 }
+      end
+
+      def connect
+        url     = @url
+        pending = @pending
+        mutex   = @mutex
+
+        @ws = ::WebSocket::Client::Simple.connect(url) do |ws|
+          ws.on :message do |msg|
+            data = JSON.parse(msg.data, symbolize_names: true)
+            q    = mutex.synchronize { pending.delete(data[:id]) }
+            q&.push(data)
+          end
+
+          ws.on :error do |e|
+            mutex.synchronize do
+              pending.each_value { |q| q.push({ error: { message: e.message, code: -32_000 } }) }
+            end
+          end
+        end
+
+        sleep 0.1 # let connection establish
+      end
+    end
+  end
+end

data/lib/viem/utils/address.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "eth"
+
+module Viem
+  module Utils
+    module Address
+      def self.is_address?(value)
+        return false unless value.is_a?(String)
+
+        Eth::Address.new(value).valid?
+      rescue StandardError
+        false
+      end
+
+      def self.get_address(address)
+        raise InvalidAddressError, address unless is_address?(address)
+
+        Eth::Address.new(address).checksummed
+      end
+
+      def self.zero_address
+        "0x0000000000000000000000000000000000000000"
+      end
+
+      def self.is_zero_address?(address)
+        address.downcase == zero_address
+      end
+    end
+  end
+end

data/lib/viem/utils/hash.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "eth"
+require "digest"
+
+module Viem
+  module Utils
+    module Hash
+      def self.keccak256(data)
+        bytes = if data.is_a?(String) && data.start_with?("0x")
+                  [data.delete_prefix("0x")].pack("H*")
+                else
+                  data.to_s
+                end
+        "0x#{Eth::Util.keccak256(bytes).unpack1("H*")}"
+      end
+
+      def self.hash_message(message)
+        keccak256("\x19Ethereum Signed Message:\n#{message.bytesize}#{message}")
+      end
+
+      def self.sha256(data)
+        "0x#{Digest::SHA256.hexdigest(data.to_s)}"
+      end
+    end
+  end
+end

data/lib/viem/utils/hex.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Viem
+  module Utils
+    module Hex
+      def self.is_hex?(value, strict: false)
+        return false unless value.is_a?(String)
+
+        if strict
+          value.match?(/\A0x[0-9a-fA-F]+\z/)
+        else
+          value.match?(/\A0x[0-9a-fA-F]*\z/)
+        end
+      end
+
+      def self.to_hex(value, size: nil)
+        hex = case value
+              when Integer
+                value.negative? ? twos_complement(value) : value.to_s(16)
+              when String
+                value.unpack1("H*")
+              when Array
+                value.pack("C*").unpack1("H*")
+              else
+                raise ArgumentError, "Cannot convert #{value.class} to hex"
+              end
+        hex = hex.rjust(size * 2, "0") if size
+        "0x#{hex}"
+      end
+
+      def self.hex_to_number(hex)
+        strip(hex).to_i(16)
+      end
+
+      def self.number_to_hex(num, size: nil)
+        to_hex(num, size: size)
+      end
+
+      def self.hex_to_bytes(hex)
+        [strip(hex)].pack("H*").bytes
+      end
+
+      def self.bytes_to_hex(bytes)
+        "0x#{bytes.pack("C*").unpack1("H*")}"
+      end
+
+      def self.hex_to_string(hex)
+        [strip(hex)].pack("H*")
+      end
+
+      def self.string_to_hex(str)
+        "0x#{str.unpack1("H*")}"
+      end
+
+      def self.strip(hex)
+        hex.delete_prefix("0x")
+      end
+
+      private_class_method def self.twos_complement(value)
+        bits = value.bit_length + 1
+        bits += (8 - bits % 8) if (bits % 8) != 0
+        (2**bits + value).to_s(16)
+      end
+    end
+  end
+end

data/lib/viem/utils/units.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "bigdecimal/util"
+
+module Viem
+  module Utils
+    module Units
+      WEI_PER_ETHER = 10**18
+      WEI_PER_GWEI  = 10**9
+
+      def self.parse_ether(ether)
+        (BigDecimal(ether.to_s) * WEI_PER_ETHER).to_i
+      end
+
+      def self.format_ether(wei)
+        (BigDecimal(wei.to_s) / WEI_PER_ETHER).to_s("F")
+      end
+
+      def self.parse_gwei(gwei)
+        (BigDecimal(gwei.to_s) * WEI_PER_GWEI).to_i
+      end
+
+      def self.format_gwei(wei)
+        (BigDecimal(wei.to_s) / WEI_PER_GWEI).to_s("F")
+      end
+
+      def self.parse_units(value, decimals)
+        (BigDecimal(value.to_s) * 10**decimals).to_i
+      end
+
+      def self.format_units(value, decimals)
+        (BigDecimal(value.to_s) / 10**decimals).to_s("F")
+      end
+    end
+  end
+end