viem_rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a8cc9cafb976fa3b96e5dba8e7fbd21b64135eefeb0c3945333384b7ea7dfc7a
+  data.tar.gz: 165980b44b57a997c7ebb0f990ef9f6e10f2ffb05a4e415eac9e8895e16444f3
+SHA512:
+  metadata.gz: 06d884e59ec32a5130816f4f6d9f5471d0cd63ba9e625ab60a7b1cd5dd31e853e420d3ae37521815529aa1b8270d4bb56c4e12eb535347e0a11a79ce895ea807
+  data.tar.gz: 67d8964c2dd2e5cec9e0fc4b049b90416660d6eb89bb2c48b66fdd9f3863f3708c9433fb6c848370cb6545b6e94bc0b2cc2ac26f5660d1ebe145f0911061feb1

data/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2025-01-01
+
+### Added
+
+- Initial release
+- `PublicClient` with full read-only Ethereum JSON-RPC actions
+- `WalletClient` extending `PublicClient` with signing and transaction submission
+- `TestClient` extending `PublicClient` with Anvil/Hardhat test node helpers
+- HTTP transport (`Viem::Transports::Http`) using Faraday, thread-safe with Mutex
+- WebSocket transport (`Viem::Transports::WebSocket`) using websocket-client-simple
+- Fallback transport (`Viem::Transports::Fallback`) for automatic failover
+- `PrivateKeyAccount` for local key management and signing
+- ABI encoding/decoding via the `eth` gem
+- Human-readable ABI parser (`Viem::Abi::Parse`)
+- Hex utilities (`Viem::Utils::Hex`)
+- Unit conversion utilities (`Viem::Utils::Units`) — parse/format Ether, Gwei, and arbitrary decimals
+- Address utilities (`Viem::Utils::Address`) — validation and EIP-55 checksum
+- Hash utilities (`Viem::Utils::Hash`) — keccak256, hash_message, sha256
+- Full error hierarchy under `Viem::Error`
+- 18 pre-configured chain definitions (Mainnet, Sepolia, Polygon, Optimism, Arbitrum, Base, Avalanche, BSC, Gnosis, Fantom, Celo, and their testnets)
+- ENS resolution (`get_ens_address`, `get_ens_name`)

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Noryk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,365 @@
+# viem_rb
+
+A Ruby/Rails adaptation of [viem](https://viem.sh) — the TypeScript Ethereum library. Provides Ethereum clients, ABI encoding/decoding, account management, and utilities for Ruby 2.7+ and Rails 7+ applications.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "viem_rb"
+```
+
+Or install directly:
+
+```bash
+gem install viem_rb
+```
+
+## Quick Start
+
+### Public Client (read-only)
+
+```ruby
+require "viem_rb"
+
+# Create a transport
+transport = Viem.http("https://cloudflare-eth.com")
+
+# Create a public client
+client = Viem.create_public_client(
+  transport: transport,
+  chain: Viem::MAINNET
+)
+
+# Read the chain ID
+client.chain_id  # => 1
+
+# Get ETH balance
+balance = client.get_balance(address: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045")
+# => 1000000000000000000 (in wei)
+
+Viem::Utils::Units.format_ether(balance)  # => "1.0"
+
+# Get current block
+block = client.get_block
+# => { number: 18_000_000, hash: "0x...", timestamp: 1_700_000_000, ... }
+
+# Get block by number
+client.get_block(block_number: 17_000_000)
+
+# Get transaction
+tx = client.get_transaction(hash: "0xabc...")
+
+# Get transaction receipt
+receipt = client.get_transaction_receipt(hash: "0xabc...")
+
+# Read a contract
+erc20_abi = [
+  { "name" => "balanceOf", "type" => "function",
+    "inputs" => [{ "type" => "address", "name" => "account" }],
+    "outputs" => [{ "type" => "uint256", "name" => "" }],
+    "stateMutability" => "view" }
+]
+
+balance = client.read_contract(
+  address:       "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",  # USDC
+  abi:           erc20_abi,
+  function_name: "balanceOf",
+  args:          ["0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"]
+)
+```
+
+### Wallet Client (read + write)
+
+```ruby
+# Create an account from a private key
+account = Viem.private_key_to_account("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80")
+# => #<Viem::Accounts::PrivateKeyAccount address="0xf39Fd6e...">
+
+transport = Viem.http("https://mainnet.example.com")
+
+client = Viem.create_wallet_client(
+  transport: transport,
+  chain:     Viem::MAINNET,
+  account:   account
+)
+
+# Sign a message
+sig = client.sign_message(message: "Hello, Ethereum!")
+# => "0x..."
+
+# Send ETH
+tx_hash = client.send_transaction(
+  to:    "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
+  value: Viem::Utils::Units.parse_ether("0.01")
+)
+
+# Write to a contract
+erc20_abi = [...] # full ABI
+
+tx_hash = client.write_contract(
+  address:       "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+  abi:           erc20_abi,
+  function_name: "transfer",
+  args:          ["0xRecipient...", 1_000_000]  # 1 USDC (6 decimals)
+)
+
+# Wait for receipt
+receipt = client.wait_for_transaction_receipt(hash: tx_hash, timeout: 60)
+```
+
+### WebSocket Transport
+
+```ruby
+transport = Viem.web_socket("wss://mainnet.infura.io/ws/v3/YOUR_KEY")
+client    = Viem.create_public_client(transport: transport)
+```
+
+### Fallback Transport
+
+```ruby
+transport = Viem.fallback(
+  Viem.http("https://primary-rpc.com"),
+  Viem.http("https://backup-rpc.com")
+)
+client = Viem.create_public_client(transport: transport)
+```
+
+### Test Client (Anvil / Hardhat)
+
+```ruby
+transport = Viem.http("http://localhost:8545")
+test_client = Viem.create_test_client(transport: transport)
+
+test_client.mine(blocks: 5)
+test_client.set_balance(address: "0x...", value: Viem::Utils::Units.parse_ether("100"))
+test_client.impersonate_account(address: "0x...")
+
+id = test_client.snapshot
+# ... do stuff ...
+test_client.revert(id: id)
+```
+
+## Actions Reference
+
+### Public Client Actions
+
+| Method | Description |
+|--------|-------------|
+| `get_balance(address:, block_tag: "latest")` | Get ETH balance in wei |
+| `get_block(block_number:, block_hash:, block_tag:, include_transactions:)` | Get block by number, hash, or tag |
+| `get_block_number` | Get current block number |
+| `get_transaction(hash:)` | Get transaction by hash |
+| `get_transaction_receipt(hash:)` | Get receipt by tx hash |
+| `get_transaction_count(address:, block_tag:)` | Get nonce for address |
+| `wait_for_transaction_receipt(hash:, poll_interval:, timeout:)` | Poll for receipt |
+| `call(to:, data:, from:, value:, gas:, block_tag:)` | Execute eth_call |
+| `estimate_gas(to:, from:, data:, value:)` | Estimate gas for a tx |
+| `read_contract(address:, abi:, function_name:, args:, block_tag:)` | Read a contract function |
+| `simulate_contract(...)` | Simulate a state-changing function |
+| `get_logs(address:, event:, args:, from_block:, to_block:)` | Fetch event logs |
+| `get_gas_price` | Get current gas price in wei |
+| `get_fee_history(block_count:, newest_block:, reward_percentiles:)` | Get EIP-1559 fee history |
+| `get_max_priority_fee_per_gas` | Get suggested priority fee |
+| `get_code(address:, block_tag:)` | Get contract bytecode |
+| `get_storage_at(address:, slot:, block_tag:)` | Read a storage slot |
+| `get_ens_address(name:)` | Resolve ENS name to address |
+| `get_ens_name(address:)` | Reverse ENS lookup |
+| `chain_id` | Get chain ID |
+| `get_network` | Get network info |
+
+### Wallet Client Actions
+
+| Method | Description |
+|--------|-------------|
+| `send_transaction(to:, value:, data:, gas:, ...)` | Sign and send a transaction |
+| `sign_message(message:, account:)` | Sign a personal message (EIP-191) |
+| `sign_typed_data(domain:, types:, primary_type:, message:, account:)` | Sign EIP-712 typed data |
+| `write_contract(address:, abi:, function_name:, args:, ...)` | Call a state-changing contract function |
+| `deploy_contract(abi:, bytecode:, args:, ...)` | Deploy a contract |
+| `get_addresses` | List accounts |
+
+### Test Client Actions
+
+| Method | Description |
+|--------|-------------|
+| `mine(blocks:, interval:)` | Mine blocks |
+| `set_balance(address:, value:)` | Set ETH balance |
+| `set_code(address:, bytecode:)` | Set contract code |
+| `set_storage_at(address:, slot:, value:)` | Write a storage slot |
+| `impersonate_account(address:)` | Impersonate any address |
+| `stop_impersonating_account(address:)` | Stop impersonation |
+| `snapshot` | Take EVM snapshot |
+| `revert(id:)` | Revert to snapshot |
+| `increase_time(seconds:)` | Advance time |
+| `set_next_block_timestamp(timestamp:)` | Set next block's timestamp |
+| `reset(url:, block_number:)` | Reset to a forked state |
+
+## Utilities
+
+### Hex
+
+```ruby
+Viem::Utils::Hex.to_hex(255)          # => "0xff"
+Viem::Utils::Hex.hex_to_number("0xff") # => 255
+Viem::Utils::Hex.is_hex?("0xabc")     # => true
+Viem::Utils::Hex.string_to_hex("Hi")  # => "0x4869"
+Viem::Utils::Hex.hex_to_string("0x4869") # => "Hi"
+```
+
+### Units
+
+```ruby
+Viem::Utils::Units.parse_ether("1")          # => 1000000000000000000
+Viem::Utils::Units.format_ether(1_000_000_000_000_000_000) # => "1.0"
+Viem::Utils::Units.parse_gwei("10")          # => 10000000000
+Viem::Utils::Units.parse_units("1", 6)       # => 1000000 (USDC)
+```
+
+### Address
+
+```ruby
+Viem::Utils::Address.is_address?("0x...")   # => true/false
+Viem::Utils::Address.get_address("0x...")   # => checksummed address
+Viem::Utils::Address.zero_address           # => "0x000...000"
+```
+
+### Hash / Crypto
+
+```ruby
+Viem::Utils::Hash.keccak256("hello")       # => "0x1c8aff9..."
+Viem::Utils::Hash.hash_message("Hello!")   # => EIP-191 hash
+Viem::Utils::Hash.sha256("data")           # => "0x..."
+```
+
+### ABI
+
+```ruby
+# Encode
+Viem::Abi::Encoder.encode_abi_parameters(["uint256", "address"], [100, "0x..."])
+Viem::Abi::Encoder.encode_function_data(abi_item, args: [...])
+Viem::Abi::Encoder.get_selector(abi_item)   # => "0x70a08231"
+
+# Decode
+Viem::Abi::Decoder.decode_abi_parameters(["uint256"], "0x...")
+Viem::Abi::Decoder.decode_function_result(abi_item, "0x...")
+
+# Parse human-readable ABI
+Viem::Abi::Parse.parse_abi([
+  "function balanceOf(address account) view returns (uint256)",
+  "event Transfer(address indexed from, address indexed to, uint256 value)"
+])
+```
+
+## Chains
+
+All chains are accessible as constants:
+
+```ruby
+Viem::MAINNET          # Ethereum Mainnet (id: 1)
+Viem::SEPOLIA          # Sepolia Testnet (id: 11155111)
+Viem::GOERLI           # Goerli Testnet (id: 5)
+Viem::POLYGON          # Polygon (id: 137)
+Viem::POLYGON_MUMBAI   # Polygon Mumbai (id: 80001)
+Viem::OPTIMISM         # Optimism (id: 10)
+Viem::OPTIMISM_GOERLI  # Optimism Goerli (id: 420)
+Viem::ARBITRUM         # Arbitrum One (id: 42161)
+Viem::ARBITRUM_GOERLI  # Arbitrum Goerli (id: 421613)
+Viem::BASE             # Base (id: 8453)
+Viem::BASE_GOERLI      # Base Goerli (id: 84531)
+Viem::AVALANCHE        # Avalanche C-Chain (id: 43114)
+Viem::AVALANCHE_FUJI   # Avalanche Fuji (id: 43113)
+Viem::BSC              # BNB Smart Chain (id: 56)
+Viem::BSC_TESTNET      # BSC Testnet (id: 97)
+Viem::GNOSIS           # Gnosis (id: 100)
+Viem::FANTOM           # Fantom (id: 250)
+Viem::CELO             # Celo (id: 42220)
+```
+
+Chain objects expose:
+
+```ruby
+Viem::MAINNET.id          # => 1
+Viem::MAINNET.name        # => "Ethereum"
+Viem::MAINNET.rpc_url     # => "https://cloudflare-eth.com"
+Viem::MAINNET.testnet?    # => false
+Viem::SEPOLIA.testnet?    # => true
+```
+
+## Error Handling
+
+```ruby
+begin
+  client.get_balance(address: "invalid")
+rescue Viem::InvalidAddressError => e
+  puts e.message  # "Invalid Ethereum address: \"invalid\""
+rescue Viem::RpcError => e
+  puts "RPC error #{e.code}: #{e.message}"
+rescue Viem::HttpRequestError => e
+  puts "HTTP #{e.status}: #{e.body}"
+rescue Viem::ContractFunctionExecutionError => e
+  puts "Contract error in #{e.function_name}: #{e.cause.message}"
+rescue Viem::TransportError => e
+  puts "Transport failed: #{e.message}"
+rescue Viem::Error => e
+  puts "Viem error: #{e.message}"
+end
+```
+
+### Error Hierarchy
+
+```
+Viem::Error
+  Viem::TransportError
+    Viem::HttpRequestError          (.status, .body)
+  Viem::RpcError                    (.code, .data)
+    Viem::UserRejectedError
+  Viem::ContractFunctionExecutionError (.cause, .contract_address, .function_name, .args)
+  Viem::AbiEncodingError
+  Viem::AbiDecodingError
+  Viem::InvalidAddressError
+  Viem::ChainMismatchError
+  Viem::AccountRequiredError
+  Viem::BlockNotFoundError
+  Viem::TransactionNotFoundError
+  Viem::TransactionReceiptNotFoundError
+  Viem::WaitForTransactionReceiptTimeoutError
+```
+
+## Rails Integration
+
+Add to `config/initializers/viem.rb`:
+
+```ruby
+require "viem_rb"
+
+ETHEREUM_CLIENT = Viem.create_public_client(
+  transport: Viem.http(ENV.fetch("ETH_RPC_URL", "https://cloudflare-eth.com")),
+  chain: Viem::MAINNET
+)
+```
+
+Then in your models or services:
+
+```ruby
+class EthereumService
+  def self.balance_of(address)
+    ETHEREUM_CLIENT.get_balance(address: address)
+  end
+end
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch: `git checkout -b feature/my-feature`
+3. Run the test suite: `bundle exec rspec`
+4. Run the linter: `bundle exec rubocop`
+5. Commit your changes: `git commit -m "Add my feature"`
+6. Push to the branch: `git push origin feature/my-feature`
+7. Create a Pull Request
+
+## License
+
+MIT License. Copyright 2025 Noryk. See [LICENSE](LICENSE) for details.

data/lib/viem/abi/decoder.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "eth"
+
+module Viem
+  module Abi
+    module Decoder
+      def self.decode_abi_parameters(types, data)
+        data = data.delete_prefix("0x")
+        Eth::Abi.decode(types, [data].pack("H*"))
+      rescue Eth::Abi::DecodingError => e
+        raise AbiDecodingError, e.message
+      end
+
+      def self.decode_function_result(abi_item, data)
+        types  = (abi_item["outputs"] || []).map { |o| o["type"] }
+        result = decode_abi_parameters(types, data)
+        # Return single value if one output, array otherwise
+        result.length == 1 ? result.first : result
+      end
+
+      def self.decode_error_result(abi_item, data)
+        types = (abi_item["inputs"] || []).map { |i| i["type"] }
+        decode_abi_parameters(types, data[10..]) # skip 4-byte selector
+      end
+    end
+  end
+end

data/lib/viem/abi/encoder.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "eth"
+
+module Viem
+  module Abi
+    module Encoder
+      def self.encode_abi_parameters(types, values)
+        encoded = Eth::Abi.encode(types, values)
+        "0x#{encoded.unpack1("H*")}"
+      rescue Eth::Abi::EncodingError => e
+        raise AbiEncodingError, e.message
+      end
+
+      def self.encode_function_data(abi_item, args: [])
+        sig      = function_signature(abi_item)
+        selector = Eth::Util.keccak256(sig)[0, 4]
+        types    = (abi_item["inputs"] || []).map { |i| i["type"] }
+        encoded  = Eth::Abi.encode(types, args)
+        "0x#{selector.unpack1("H*")}#{encoded.unpack1("H*")}"
+      rescue Eth::Abi::EncodingError => e
+        raise AbiEncodingError, e.message
+      end
+
+      def self.encode_deploy_data(bytecode, abi_item = nil, args: [])
+        bytecode = bytecode.delete_prefix("0x")
+        return "0x#{bytecode}" if abi_item.nil? || args.empty?
+
+        types   = (abi_item["inputs"] || []).map { |i| i["type"] }
+        encoded = Eth::Abi.encode(types, args)
+        "0x#{bytecode}#{encoded.unpack1("H*")}"
+      rescue Eth::Abi::EncodingError => e
+        raise AbiEncodingError, e.message
+      end
+
+      def self.get_selector(abi_item)
+        sig = function_signature(abi_item)
+        "0x#{Eth::Util.keccak256(sig)[0, 4].unpack1("H*")}"
+      end
+
+      def self.function_signature(abi_item)
+        inputs = (abi_item["inputs"] || []).map { |i| i["type"] }.join(",")
+        "#{abi_item["name"]}(#{inputs})"
+      end
+      private_class_method :function_signature
+    end
+  end
+end

data/lib/viem/abi/parse.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Viem
+  module Abi
+    module Parse
+      TYPE_REGEX = /^(function|event|error|constructor|fallback|receive)\s+/
+
+      def self.parse_abi(signatures)
+        signatures.map { |sig| parse_abi_item(sig) }
+      end
+
+      def self.parse_abi_item(sig)
+        sig  = sig.strip
+        kind = case sig
+               when /^function /    then "function"
+               when /^event /       then "event"
+               when /^error /       then "error"
+               when /^constructor/  then "constructor"
+               else                      "function"
+               end
+
+        sig = sig.sub(TYPE_REGEX, "")
+        name, rest = sig.split("(", 2)
+        args_str, output_str = rest&.split(")")
+        inputs  = parse_params(args_str || "")
+        outputs = parse_outputs(output_str || "")
+
+        item = { "type" => kind, "name" => name&.strip, "inputs" => inputs }
+        item["outputs"]          = outputs if kind == "function"
+        item["stateMutability"]  = detect_mutability(sig)
+        item
+      end
+
+      private_class_method def self.parse_params(str)
+        return [] if str.nil? || str.strip.empty?
+
+        str.split(",").map.with_index do |p, i|
+          parts = p.strip.split(/\s+/)
+          { "type" => parts[0], "name" => parts[1] || "arg#{i}" }
+        end
+      end
+
+      private_class_method def self.parse_outputs(str)
+        return [] if str.nil? || str.strip.empty?
+
+        cleaned = str.sub(/\s*returns?\s*\(/, "").sub(/\)\s*$/, "")
+        parse_params(cleaned)
+      end
+
+      private_class_method def self.detect_mutability(sig)
+        return "view"     if sig.include?("view")
+        return "pure"     if sig.include?("pure")
+        return "payable"  if sig.include?("payable")
+
+        "nonpayable"
+      end
+    end
+  end
+end

data/lib/viem/accounts/mnemonic_account.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "eth"
+
+module Viem
+  module Accounts
+    class MnemonicAccount < PrivateKeyAccount
+      attr_reader :mnemonic, :path
+
+      def initialize(mnemonic, path: "m/44'/60'/0'/0/0")
+        @mnemonic = mnemonic
+        @path     = path
+        private_key = derive_private_key(mnemonic, path)
+        super(private_key)
+      end
+
+      private
+
+      def derive_private_key(mnemonic, path)
+        # eth gem >= 0.5.10 supports HD wallets via Eth::Key::HD
+        if defined?(Eth::Key::HD)
+          seed   = Eth::Key::HD.mnemonic_to_seed(mnemonic)
+          master = Eth::Key::HD.from_seed(seed)
+          child  = master.derive(path)
+          child.private_hex
+        else
+          raise NotImplementedError,
+                "Mnemonic accounts require eth gem >= 0.5.10 with HD wallet support. " \
+                "Use Viem.private_key_to_account instead."
+        end
+      end
+    end
+  end
+end

data/lib/viem/accounts/private_key_account.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "eth"
+
+module Viem
+  module Accounts
+    class PrivateKeyAccount
+      attr_reader :address, :type
+
+      def initialize(private_key)
+        private_key = private_key.delete_prefix("0x")
+        @key     = Eth::Key.new(priv: private_key)
+        @address = Eth::Address.new(@key.address.to_s).checksummed
+        @type    = :local
+      end
+
+      def sign_message(message)
+        prefixed = "\x19Ethereum Signed Message:\n#{message.bytesize}#{message}"
+        hash     = Eth::Util.keccak256(prefixed)
+        sig      = @key.sign(hash)
+        "0x#{sig.unpack1("H*")}"
+      end
+
+      def sign_transaction(tx_hash)
+        @key.sign(tx_hash)
+      end
+
+      def sign_typed_data(domain, types, value)
+        # EIP-712 encoding
+        encoded = Eth::Eip712.encode(domain, types, value)
+        hash    = Eth::Util.keccak256(encoded)
+        sig     = @key.sign(hash)
+        "0x#{sig.unpack1("H*")}"
+      rescue StandardError => e
+        raise Error, "Failed to sign typed data: #{e.message}"
+      end
+
+      def public_key
+        @key.public_hex
+      end
+
+      def private_key
+        "0x#{@key.private_hex}"
+      end
+
+      def to_h
+        { address: @address, type: @type }
+      end
+    end
+  end
+end

data/lib/viem/actions/public/call.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Viem
+  module Actions
+    module Public
+      module Call
+        def call(to:, data: nil, from: nil, value: nil, gas: nil, block_tag: "latest")
+          params = {}
+          params[:to]    = to    if to
+          params[:from]  = from  if from
+          params[:data]  = data  if data
+          params[:value] = Utils::Hex.number_to_hex(value) if value
+          params[:gas]   = Utils::Hex.number_to_hex(gas)   if gas
+          @transport.request("eth_call", [stringify_keys(params), block_tag.to_s])
+        end
+
+        def estimate_gas(to:, from: nil, data: nil, value: nil)
+          params = {}
+          params[:to]    = to    if to
+          params[:from]  = from  if from
+          params[:data]  = data  if data
+          params[:value] = Utils::Hex.number_to_hex(value) if value
+          result = @transport.request("eth_estimateGas", [stringify_keys(params)])
+          Utils::Hex.hex_to_number(result)
+        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
+end