viem_rb 0.1.0

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Viem
+  module Actions
+    module Public
+      module Ens
+        ENS_REGISTRY = "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
+
+        ENS_PUBLIC_RESOLVER_ABI = [
+          {
+            "name"            => "addr",
+            "type"            => "function",
+            "inputs"          => [{ "type" => "bytes32", "name" => "node" }],
+            "outputs"         => [{ "type" => "address", "name" => "" }],
+            "stateMutability" => "view"
+          },
+          {
+            "name"            => "name",
+            "type"            => "function",
+            "inputs"          => [{ "type" => "bytes32", "name" => "node" }],
+            "outputs"         => [{ "type" => "string",  "name" => "" }],
+            "stateMutability" => "view"
+          }
+        ].freeze
+
+        REGISTRY_ABI = [
+          {
+            "name"            => "resolver",
+            "type"            => "function",
+            "inputs"          => [{ "type" => "bytes32", "name" => "node" }],
+            "outputs"         => [{ "type" => "address", "name" => "" }],
+            "stateMutability" => "view"
+          }
+        ].freeze
+
+        def get_ens_address(name:)
+          node          = namehash(name)
+          resolver_addr = read_contract(
+            address: ENS_REGISTRY, abi: REGISTRY_ABI,
+            function_name: "resolver", args: [node]
+          )
+          return nil if Utils::Address.is_zero_address?(resolver_addr)
+
+          read_contract(
+            address: resolver_addr, abi: ENS_PUBLIC_RESOLVER_ABI,
+            function_name: "addr", args: [node]
+          )
+        rescue StandardError => e
+          raise Error, "ENS resolution failed for #{name}: #{e.message}"
+        end
+
+        def get_ens_name(address:)
+          address  = Utils::Address.get_address(address)
+          reversed = "#{address.downcase.delete_prefix("0x")}.addr.reverse"
+          node     = namehash(reversed)
+          resolver_addr = read_contract(
+            address: ENS_REGISTRY, abi: REGISTRY_ABI,
+            function_name: "resolver", args: [node]
+          )
+          return nil if Utils::Address.is_zero_address?(resolver_addr)
+
+          read_contract(
+            address: resolver_addr, abi: ENS_PUBLIC_RESOLVER_ABI,
+            function_name: "name", args: [node]
+          )
+        rescue StandardError
+          nil
+        end
+
+        private
+
+        def namehash(name)
+          node = "\x00" * 32
+          return Eth::Util.keccak256(node) if name.empty?
+
+          name.split(".").reverse.each do |label|
+            label_hash = Eth::Util.keccak256(label)
+            node       = Eth::Util.keccak256(node + label_hash)
+          end
+          node
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Viem
+  module Actions
+    module Public
+      module GetBalance
+        def get_balance(address:, block_tag: "latest")
+          address = Utils::Address.get_address(address)
+          result  = @transport.request("eth_getBalance", [address, block_tag.to_s])
+          Utils::Hex.hex_to_number(result)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Viem
+  module Actions
+    module Public
+      module GetBlock
+        def get_block(block_number: nil, block_hash: nil, block_tag: "latest", include_transactions: false)
+          if block_hash
+            result = @transport.request("eth_getBlockByHash", [block_hash, include_transactions])
+          else
+            tag    = block_number ? Utils::Hex.number_to_hex(block_number) : block_tag.to_s
+            result = @transport.request("eth_getBlockByNumber", [tag, include_transactions])
+          end
+          raise BlockNotFoundError, "Block not found" unless result
+
+          format_block(result)
+        end
+
+        def get_block_number
+          result = @transport.request("eth_blockNumber", [])
+          Utils::Hex.hex_to_number(result)
+        end
+
+        private
+
+        # Fields that should remain as hex strings (hashes, addresses)
+        BLOCK_STRING_FIELDS = %w[
+          hash parentHash sha3Uncles miner stateRoot transactionsRoot
+          receiptsRoot logsBloom mixHash nonce extraData
+        ].freeze
+
+        def format_block(raw)
+          raw.each_with_object({}) do |(k, v), h|
+            key = k.to_sym
+            if BLOCK_STRING_FIELDS.include?(k.to_s)
+              h[key] = v
+            elsif v.is_a?(String) && v.start_with?("0x") && v.match?(/\A0x[0-9a-f]+\z/)
+              h[key] = Utils::Hex.hex_to_number(v)
+            else
+              h[key] = v
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Viem
+  module Actions
+    module Public
+      module GetCode
+        def get_code(address:, block_tag: "latest")
+          address = Utils::Address.get_address(address)
+          result  = @transport.request("eth_getCode", [address, block_tag.to_s])
+          result == "0x" ? nil : result
+        end
+
+        def get_storage_at(address:, slot:, block_tag: "latest")
+          address = Utils::Address.get_address(address)
+          slot    = slot.is_a?(Integer) ? Utils::Hex.number_to_hex(slot, size: 32) : slot
+          @transport.request("eth_getStorageAt", [address, slot, block_tag.to_s])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Viem
+  module Actions
+    module Public
+      module GetGas
+        def get_gas_price
+          result = @transport.request("eth_gasPrice", [])
+          Utils::Hex.hex_to_number(result)
+        end
+
+        def get_fee_history(block_count:, newest_block: "latest", reward_percentiles: [])
+          result = @transport.request("eth_feeHistory", [
+            Utils::Hex.number_to_hex(block_count),
+            newest_block.to_s,
+            reward_percentiles
+          ])
+          result
+        end
+
+        def get_max_priority_fee_per_gas
+          result = @transport.request("eth_maxPriorityFeePerGas", [])
+          Utils::Hex.hex_to_number(result)
+        rescue RpcError
+          # Fallback: estimate from fee history
+          history = get_fee_history(block_count: 4, newest_block: "latest", reward_percentiles: [50])
+          rewards = (history["reward"] || []).flatten.map { |r| Utils::Hex.hex_to_number(r) }
+          rewards.sum / [rewards.size, 1].max
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Viem
+  module Actions
+    module Public
+      module GetLogs
+        def get_logs(address: nil, event: nil, args: {}, from_block: nil, to_block: nil)
+          params = {}
+          params[:address]   = address if address
+          params[:fromBlock] = from_block.is_a?(Integer) ? Utils::Hex.number_to_hex(from_block) : (from_block || "earliest")
+          params[:toBlock]   = to_block.is_a?(Integer) ? Utils::Hex.number_to_hex(to_block) : (to_block || "latest")
+          params[:topics]    = encode_event_topics(event, args) if event
+          results = @transport.request("eth_getLogs", [stringify_keys(params)])
+          results.map { |l| format_log(l) }
+        end
+
+        private
+
+        def encode_event_topics(event_abi, args)
+          sig    = event_signature(event_abi)
+          topic0 = Utils::Hash.keccak256(sig)
+          [topic0]
+        end
+
+        def event_signature(abi_item)
+          inputs = (abi_item["inputs"] || []).map { |i| i["type"] }.join(",")
+          "#{abi_item["name"]}(#{inputs})"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Viem
+  module Actions
+    module Public
+      module GetTransaction
+        def get_transaction(hash:)
+          result = @transport.request("eth_getTransactionByHash", [hash])
+          raise TransactionNotFoundError, "Transaction #{hash} not found" unless result
+
+          format_transaction(result)
+        end
+
+        def get_transaction_receipt(hash:)
+          result = @transport.request("eth_getTransactionReceipt", [hash])
+          raise TransactionReceiptNotFoundError, "Receipt for #{hash} not found" unless result
+
+          format_receipt(result)
+        end
+
+        def get_transaction_count(address:, block_tag: "latest")
+          address = Utils::Address.get_address(address)
+          result  = @transport.request("eth_getTransactionCount", [address, block_tag.to_s])
+          Utils::Hex.hex_to_number(result)
+        end
+
+        def wait_for_transaction_receipt(hash:, poll_interval: 4, timeout: 120)
+          deadline = Time.now + timeout
+          loop do
+            receipt = @transport.request("eth_getTransactionReceipt", [hash])
+            return format_receipt(receipt) if receipt
+            raise WaitForTransactionReceiptTimeoutError, "Timeout after #{timeout}s waiting for #{hash}" if Time.now > deadline
+
+            sleep poll_interval
+          end
+        end
+
+        private
+
+        def format_transaction(raw)
+          raw.transform_keys(&:to_sym).tap do |tx|
+            tx[:block_number]      = Utils::Hex.hex_to_number(tx[:blockNumber])      if tx[:blockNumber]
+            tx[:transaction_index] = Utils::Hex.hex_to_number(tx[:transactionIndex]) if tx[:transactionIndex]
+            tx[:nonce]             = Utils::Hex.hex_to_number(tx[:nonce])             if tx[:nonce]
+            tx[:gas]               = Utils::Hex.hex_to_number(tx[:gas])               if tx[:gas]
+            tx[:gas_price]         = Utils::Hex.hex_to_number(tx[:gasPrice])          if tx[:gasPrice]
+            tx[:value]             = Utils::Hex.hex_to_number(tx[:value])             if tx[:value]
+          end
+        end
+
+        def format_receipt(raw)
+          raw.transform_keys(&:to_sym).tap do |r|
+            r[:block_number]         = Utils::Hex.hex_to_number(r[:blockNumber])        if r[:blockNumber]
+            r[:transaction_index]    = Utils::Hex.hex_to_number(r[:transactionIndex])   if r[:transactionIndex]
+            r[:gas_used]             = Utils::Hex.hex_to_number(r[:gasUsed])            if r[:gasUsed]
+            r[:cumulative_gas_used]  = Utils::Hex.hex_to_number(r[:cumulativeGasUsed])  if r[:cumulativeGasUsed]
+            r[:status]               = Utils::Hex.hex_to_number(r[:status])             if r[:status]
+            r[:logs]                 = (r[:logs] || []).map { |l| format_log(l) }
+          end
+        end
+
+        def format_log(raw)
+          raw.transform_keys(&:to_sym).tap do |l|
+            l[:block_number]      = Utils::Hex.hex_to_number(l[:blockNumber])      if l[:blockNumber]
+            l[:transaction_index] = Utils::Hex.hex_to_number(l[:transactionIndex]) if l[:transactionIndex]
+            l[:log_index]         = Utils::Hex.hex_to_number(l[:logIndex])         if l[:logIndex]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Viem
+  module Actions
+    module Public
+      module ReadContract
+        def read_contract(address:, abi:, function_name:, args: [], block_tag: "latest")
+          abi_item = find_abi_item(abi, function_name, type: "function")
+          data     = Abi::Encoder.encode_function_data(abi_item, args: args)
+          result   = call(to: address, data: data, block_tag: block_tag)
+          Abi::Decoder.decode_function_result(abi_item, result)
+        rescue RpcError => e
+          raise ContractFunctionExecutionError.new(e,
+            contract_address: address, function_name: function_name, args: args)
+        end
+
+        def simulate_contract(address:, abi:, function_name:, args: [], account: nil, value: nil, block_tag: "latest")
+          abi_item = find_abi_item(abi, function_name, type: "function")
+          data     = Abi::Encoder.encode_function_data(abi_item, args: args)
+          from     = account&.address
+          result   = call(to: address, data: data, from: from, value: value, block_tag: block_tag)
+          Abi::Decoder.decode_function_result(abi_item, result)
+        rescue RpcError => e
+          raise ContractFunctionExecutionError.new(e,
+            contract_address: address, function_name: function_name, args: args)
+        end
+
+        private
+
+        def find_abi_item(abi, name, type: nil)
+          item = abi.find do |i|
+            i["name"] == name.to_s && (type.nil? || i["type"] == type)
+          end
+          raise AbiEncodingError, "Function '#{name}' not found in ABI" unless item
+
+          item
+        end
+      end
+    end
+  end
+end

data/lib/viem/actions/wallet/send_transaction.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Viem
+  module Actions
+    module Wallet
+      module SendTransaction
+        def send_transaction(
+          to:,
+          value: 0,
+          data: nil,
+          gas: nil,
+          gas_price: nil,
+          max_fee_per_gas: nil,
+          max_priority_fee_per_gas: nil,
+          nonce: nil,
+          account: nil
+        )
+          acct = account || @account
+          raise AccountRequiredError unless acct
+
+          nonce     ||= get_transaction_count(address: acct.address)
+          chain_id    = @chain&.id || get_chain_id
+
+          if max_fee_per_gas
+            gas ||= begin
+              estimate_gas(to: to, from: acct.address, data: data, value: value)
+            rescue StandardError
+              21_000
+            end
+            tx = build_eip1559_tx(
+              to: to, value: value, data: data, gas: gas,
+              max_fee_per_gas: max_fee_per_gas,
+              max_priority_fee_per_gas: max_priority_fee_per_gas,
+              nonce: nonce, chain_id: chain_id
+            )
+          else
+            gas       ||= begin
+              estimate_gas(to: to, from: acct.address, data: data, value: value)
+            rescue StandardError
+              21_000
+            end
+            gas_price ||= get_gas_price
+            tx = build_legacy_tx(
+              to: to, value: value, data: data, gas: gas,
+              gas_price: gas_price, nonce: nonce, chain_id: chain_id
+            )
+          end
+
+          signed = sign_tx(acct, tx)
+          @transport.request("eth_sendRawTransaction", [signed])
+        end
+
+        private
+
+        def get_chain_id
+          result = @transport.request("eth_chainId", [])
+          Utils::Hex.hex_to_number(result)
+        end
+
+        def build_eip1559_tx(to:, value:, data:, gas:, max_fee_per_gas:, max_priority_fee_per_gas:, nonce:, chain_id:)
+          Eth::Tx::Eip1559.new({
+            chain_id:                 chain_id,
+            nonce:                    nonce,
+            max_priority_fee_per_gas: max_priority_fee_per_gas || Utils::Units.parse_gwei("1.5"),
+            max_fee_per_gas:          max_fee_per_gas,
+            gas_limit:                gas,
+            to:                       to,
+            value:                    value,
+            data:                     data || ""
+          })
+        end
+
+        def build_legacy_tx(to:, value:, data:, gas:, gas_price:, nonce:, chain_id:)
+          Eth::Tx::Legacy.new({
+            chain_id:  chain_id,
+            nonce:     nonce,
+            gas_price: gas_price,
+            gas_limit: gas,
+            to:        to,
+            value:     value,
+            data:      data || ""
+          })
+        end
+
+        def sign_tx(account, tx)
+          tx.sign(Eth::Key.new(priv: account.private_key.delete_prefix("0x")))
+          "0x#{tx.hex}"
+        end
+      end
+    end
+  end
+end

data/lib/viem/actions/wallet/sign_message.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Viem
+  module Actions
+    module Wallet
+      module SignMessage
+        def sign_message(message:, account: nil)
+          acct = account || @account
+          raise AccountRequiredError unless acct
+
+          acct.sign_message(message)
+        end
+      end
+    end
+  end
+end

data/lib/viem/actions/wallet/sign_typed_data.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Viem
+  module Actions
+    module Wallet
+      module SignTypedData
+        def sign_typed_data(domain:, types:, primary_type:, message:, account: nil)
+          acct = account || @account
+          raise AccountRequiredError unless acct
+
+          acct.sign_typed_data(domain, types, message)
+        end
+      end
+    end
+  end
+end

data/lib/viem/actions/wallet/write_contract.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Viem
+  module Actions
+    module Wallet
+      module WriteContract
+        def write_contract(
+          address:,
+          abi:,
+          function_name:,
+          args: [],
+          value: nil,
+          gas: nil,
+          gas_price: nil,
+          max_fee_per_gas: nil,
+          max_priority_fee_per_gas: nil,
+          account: nil
+        )
+          acct = account || @account
+          raise AccountRequiredError unless acct
+
+          abi_item = find_abi_item(abi, function_name, type: "function")
+          data     = Abi::Encoder.encode_function_data(abi_item, args: args)
+
+          send_transaction(
+            to: address, data: data, value: value || 0,
+            gas: gas, gas_price: gas_price,
+            max_fee_per_gas: max_fee_per_gas,
+            max_priority_fee_per_gas: max_priority_fee_per_gas,
+            account: acct
+          )
+        rescue RpcError => e
+          raise ContractFunctionExecutionError.new(e,
+            contract_address: address, function_name: function_name, args: args)
+        end
+
+        def deploy_contract(abi:, bytecode:, args: [], value: nil, gas: nil, account: nil)
+          acct = account || @account
+          raise AccountRequiredError unless acct
+
+          constructor = abi.find { |i| i["type"] == "constructor" }
+          data        = Abi::Encoder.encode_deploy_data(bytecode, constructor, args: args)
+          send_transaction(to: nil, data: data, value: value || 0, gas: gas, account: acct)
+        end
+      end
+    end
+  end
+end

data/lib/viem/chains/base.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Viem
+  module Chains
+    Chain = Struct.new(
+      :id, :name, :network, :native_currency,
+      :rpc_urls, :block_explorers, :testnet,
+      keyword_init: true
+    ) do
+      def rpc_url
+        rpc_urls.dig(:default, :http, 0)
+      end
+
+      def testnet?
+        !!testnet
+      end
+    end
+
+    NativeCurrency = Struct.new(:name, :symbol, :decimals, keyword_init: true)
+  end
+end