block_given 0.1.0 → 0.2.0

data/lib/block_given/wallet.rb

@@ -1,66 +1,240 @@
 # frozen_string_literal: true
 
 module BlockGiven
-  # A private key + (optional) client, able to sign and send transactions
-  # (viem's WalletClient + Account).
+  # A private key plus an optional {Client}, able to sign messages and to prepare, sign and send
+  # transactions (the equivalent of viem's WalletClient + Account).
   #
+  # Every value and fee is an Integer amount of wei. Transactions are EIP-1559 (type 2) by default;
+  # passing `gas_price:` to any transaction method builds a legacy (type 0) transaction instead.
+  # Missing fields (nonce, gas, fees, chain id) are resolved from {#client} at signing time.
+  #
+  # @example Create a wallet and send ether
   #   wallet = BlockGiven::Wallet.new(private_key: ENV["PRIVATE_KEY"])
-  #   wallet.address
+  #   wallet.address # => "0xAbC..." (EIP-55 checksummed)
   #   wallet.send_transaction(to: "0x...", value: BlockGiven::Utils.parse_ether("0.01")).wait
   class Wallet
+    # @return [String] the EIP-55 checksummed address derived from the private key
     attr_reader :address
 
+    # Creates a wallet with a freshly generated random private key.
+    #
+    # @param client [Client, nil] client used for RPC calls; when nil, {BlockGiven.client} is used
+    # @return [Wallet] a new wallet holding the generated key
     def self.generate(client: nil)
-      new(private_key: Eth::Key.new.private_hex, client: client)
+      new(private_key: Crypto::Secp256k1.int_to_bytes(Crypto::Secp256k1.generate_private_key).unpack1("H*"),
+          client: client)
     end
 
+    # Builds a wallet from an existing private key.
+    #
+    # @param private_key [String] 32-byte private key as 64 hex characters, with or without the `0x` prefix
+    #   (surrounding whitespace is ignored)
+    # @param client [Client, nil] client used for nonce, gas and fee lookups and for broadcasting; when nil,
+    #   every call falls back to {BlockGiven.client}
+    # @raise [BlockGiven::InvalidArgumentError] when the key is not exactly 32 bytes of hex, or is not a valid
+    #   secp256k1 key (zero, or not below the curve order)
+    # @example
+    #   wallet = BlockGiven::Wallet.new(private_key: "0x4c0883a6...d1e6") # 64 hex chars
+    #   wallet.address # => "0x..."
     def initialize(private_key:, client: nil)
       hex = Utils.strip_hex(private_key.to_s.strip)
       raise InvalidArgumentError, "private key must be 32 bytes hex" unless hex.match?(/\A[0-9a-fA-F]{64}\z/)
 
-      @key = Eth::Key.new(priv: hex)
-      @address = @key.address.checksummed
+      @private_key = hex.to_i(16)
+      unless Crypto::Secp256k1.valid_private_key?(@private_key)
+        raise InvalidArgumentError, "private key is out of the secp256k1 range"
+      end
+
+      @public_key = Crypto::Secp256k1.public_key(@private_key)
+      @address = Crypto.address(@public_key)
       @client = client
     end
 
-    def private_key = Utils.prefix_hex(@key.private_hex)
-    def public_key = Utils.prefix_hex(@key.public_hex)
+    # The private key, for persistence or export. It is never included in {#inspect} or {#to_s}.
+    #
+    # @return [String] the 32-byte private key as `0x`-prefixed hex
+    def private_key = Utils.bin_to_hex(Crypto::Secp256k1.int_to_bytes(@private_key))
 
+    # The uncompressed public key matching {#private_key}.
+    #
+    # @return [String] the 65-byte public key as `0x`-prefixed hex
+    def public_key = Utils.bin_to_hex(@public_key)
+
+    # The client used for every RPC call made by this wallet.
+    #
+    # @return [Client] the client given to {#initialize}, or {BlockGiven.client} when none was given
     def client = @client || BlockGiven.client
+
+    # Returns a copy of this wallet (same key) bound to another client, e.g. to sign on another chain.
+    #
+    # @param client [Client] the client the copy will use
+    # @return [Wallet] a new wallet with the same private key and the given client
     def with_client(client) = self.class.new(private_key: private_key, client: client)
+
+    # The chain of {#client}.
+    #
+    # @return [Chain] the chain the wallet's transactions are built for
     def chain = client.chain
 
+    # Balance of {#address} in wei.
+    #
+    # @param block [Symbol, Integer, String] block tag (`:latest`, `:pending`, `:safe`, `:finalized`, `:earliest`)
+    #   or block number
+    # @return [Integer] the balance in wei at that block
     def balance(block: :latest) = client.get_balance(address, block: block)
+
+    # Transaction count of {#address}, i.e. the nonce the next transaction should use.
+    #
+    # @param block [Symbol, Integer, String] block tag or number; defaults to `:pending` so that transactions
+    #   still waiting in the mempool are counted
+    # @return [Integer] the transaction count at that block
     def nonce(block: :pending) = client.get_transaction_count(address, block: block)
 
-    # EIP-191 personal_sign. Returns the 65-byte signature as hex.
+    # Signs a message with the EIP-191 `personal_sign` scheme.
+    #
+    # The message is prefixed with `"\x19Ethereum Signed Message:\n" + length` before hashing, so the signature
+    # can be verified with `ecrecover` or viem's `verifyMessage`.
+    #
+    # @param message [String] the message to sign, as a plain string
+    # @return [String] the 65-byte signature (r, s, v) as `0x`-prefixed hex
+    # @example
+    #   signature = wallet.sign_message("Login to Bolero at 2024-01-01")
+    #   signature # => "0x..." (132 hex characters)
     def sign_message(message)
-      Utils.prefix_hex(@key.personal_sign(message))
+      bytes = message.to_s.b
+      sign_digest(Crypto::Keccak.digest("\x19Ethereum Signed Message:\n#{bytes.bytesize}".b + bytes))
     end
 
-    # EIP-712 typed data (Hash with :types, :primaryType, :domain, :message).
+    # Signs EIP-712 typed structured data.
+    #
+    # @param typed_data [Hash] the EIP-712 payload with `:types`, `:primaryType`, `:domain` and `:message` keys
+    #   (String keys are accepted too). `EIP712Domain` may be omitted from `:types`: it is then derived from the
+    #   domain keys present. Arrays are hashed as the specification (and viem) define them
+    # @return [String] the 65-byte signature (r, s, v) as `0x`-prefixed hex
+    # @raise [BlockGiven::InvalidArgumentError] when a section is missing, a type is unknown or a value does not
+    #   fit its type
+    # @example Sign an ERC-2612 permit
+    #   wallet.sign_typed_data(
+    #     types: { EIP712Domain: [...], Permit: [{ name: "owner", type: "address" }, ...] },
+    #     primaryType: "Permit",
+    #     domain: { name: "USD Coin", version: "2", chainId: 8453, verifyingContract: "0x..." },
+    #     message: { owner: wallet.address, spender: "0x...", value: 1_000_000, nonce: 0, deadline: 1_700_000_000 }
+    #   )
     def sign_typed_data(typed_data)
-      Utils.prefix_hex(@key.sign_typed_data(typed_data))
+      sign_digest(Eip712.hash(typed_data))
     end
 
-    # Fills in nonce / gas / fees from the client and signs, without broadcasting.
-    # Returns a BlockGiven::SignedTransaction: its #hash and #nonce are known before
-    # any network call (persist them, then #broadcast). Same keywords as prepare_transaction;
-    # pass gas_price: to build a legacy (type 0) transaction instead of EIP-1559.
+    # Resolves the missing fields, signs, and returns the transaction without broadcasting it.
+    #
+    # The returned {SignedTransaction} knows its {SignedTransaction#hash} (keccak of the signed bytes) and
+    # {SignedTransaction#nonce} before any network call: persist them, then call {SignedTransaction#broadcast}.
+    # See {#prepare_transaction} for how each missing field is resolved.
+    #
+    # @overload signed_transaction(to: nil, value: 0, data: nil, gas: nil, nonce: nil, max_fee_per_gas: nil,
+    #                              max_priority_fee_per_gas: nil, gas_price: nil, chain_id: nil, access_list: nil)
+    #   @param to [String, nil] recipient address (any case, checksummed before signing); nil for contract creation
+    #   @param value [Integer, String, Float, BigDecimal, Rational] amount of wei to send; Strings may be decimal
+    #     or `0x` hex, non-Integer numerics must have no fractional part. Defaults to 0
+    #   @param data [String, nil] calldata as hex (with or without `0x`); nil or empty means no calldata
+    #   @param gas [Integer, nil] gas limit; defaults to `eth_estimateGas` multiplied by
+    #     `BlockGiven.config.gas_multiplier` (rounded up)
+    #   @param nonce [Integer, nil] nonce to use; defaults to the wallet's pending transaction count ({#nonce})
+    #   @param max_fee_per_gas [Integer, nil] EIP-1559 max fee per gas in wei; defaults to
+    #     {Client#estimate_fees_per_gas} when omitted (ignored when `gas_price:` is given)
+    #   @param max_priority_fee_per_gas [Integer, nil] EIP-1559 priority fee per gas in wei; defaults to
+    #     {Client#estimate_fees_per_gas} when omitted (ignored when `gas_price:` is given)
+    #   @param gas_price [Integer, nil] gas price in wei; when given, a legacy (type 0) transaction is built and
+    #     the EIP-1559 fee fields are not used. Never estimated: legacy transactions need an explicit value
+    #   @param chain_id [Integer, nil] chain id for EIP-155 replay protection; defaults to `client.chain.id`
+    #   @param access_list [Array<Hash>, nil] EIP-2930 access list; nil means an empty list (EIP-1559 only)
+    # @return [SignedTransaction] the signed transaction, ready to be broadcast or persisted
+    # @raise [BlockGiven::InvalidArgumentError] when `value:` is malformed or fractional, or when `to:` is nil
+    #   without an explicit `gas:` (contract creation cannot be estimated here)
+    # @example Persist the hash before broadcasting, replace the transaction if it gets stuck
+    #   signed = wallet.signed_transaction(to: usdc_address, data: calldata)
+    #   record.update!(tx_hash: signed.hash, nonce: signed.nonce, raw_tx: signed.raw)
+    #   tx = signed.broadcast                         # => BlockGiven::Transaction with the same hash
+    #   signed.replacement.broadcast if tx.pending?   # same nonce, fees bumped by 12.5%
     def signed_transaction(**params)
       prepared = prepare_transaction(**params)
-      tx = Eth::Tx.new(to_eth_tx_params(prepared))
-      tx.sign(@key)
-      SignedTransaction.new(raw: Utils.prefix_hex(tx.hex), params: prepared, wallet: self)
+      SignedTransaction.new(raw: TransactionEnvelope.sign(prepared, @private_key), params: prepared, wallet: self)
     end
 
-    # Signs and returns the raw tx hex.
+    # Signs a transaction and returns only the raw signed bytes, without broadcasting.
+    #
+    # Shorthand for `signed_transaction(**params).raw`; see {#signed_transaction} for the keyword semantics.
+    #
+    # @overload sign_transaction(to: nil, value: 0, data: nil, gas: nil, nonce: nil, max_fee_per_gas: nil,
+    #                            max_priority_fee_per_gas: nil, gas_price: nil, chain_id: nil, access_list: nil)
+    #   @param to [String, nil] recipient address; nil for contract creation (then `gas:` is required)
+    #   @param value [Integer, String, Float, BigDecimal, Rational] amount of wei to send (default 0)
+    #   @param data [String, nil] calldata as hex
+    #   @param gas [Integer, nil] gas limit; default `eth_estimateGas` times `BlockGiven.config.gas_multiplier`
+    #   @param nonce [Integer, nil] nonce; default the wallet's pending transaction count
+    #   @param max_fee_per_gas [Integer, nil] EIP-1559 max fee in wei; default from {Client#estimate_fees_per_gas}
+    #   @param max_priority_fee_per_gas [Integer, nil] EIP-1559 priority fee in wei; default from
+    #     {Client#estimate_fees_per_gas}
+    #   @param gas_price [Integer, nil] gas price in wei; switches to a legacy (type 0) transaction
+    #   @param chain_id [Integer, nil] chain id; default `client.chain.id`
+    #   @param access_list [Array<Hash>, nil] EIP-2930 access list (EIP-1559 only)
+    # @return [String] the RLP-encoded signed transaction as `0x`-prefixed hex, as accepted by
+    #   `eth_sendRawTransaction`
+    # @raise [BlockGiven::InvalidArgumentError] same conditions as {#signed_transaction}
     def sign_transaction(**params) = signed_transaction(**params).raw
 
-    # Signs and broadcasts. Returns a BlockGiven::Transaction.
+    # Signs a transaction and broadcasts it right away.
+    #
+    # Shorthand for `signed_transaction(**params).broadcast`; see {#signed_transaction} for the keyword semantics.
+    #
+    # @overload send_transaction(to: nil, value: 0, data: nil, gas: nil, nonce: nil, max_fee_per_gas: nil,
+    #                            max_priority_fee_per_gas: nil, gas_price: nil, chain_id: nil, access_list: nil)
+    #   @param to [String, nil] recipient address; nil for contract creation (then `gas:` is required)
+    #   @param value [Integer, String, Float, BigDecimal, Rational] amount of wei to send (default 0)
+    #   @param data [String, nil] calldata as hex
+    #   @param gas [Integer, nil] gas limit; default `eth_estimateGas` times `BlockGiven.config.gas_multiplier`
+    #   @param nonce [Integer, nil] nonce; default the wallet's pending transaction count
+    #   @param max_fee_per_gas [Integer, nil] EIP-1559 max fee in wei; default from {Client#estimate_fees_per_gas}
+    #   @param max_priority_fee_per_gas [Integer, nil] EIP-1559 priority fee in wei; default from
+    #     {Client#estimate_fees_per_gas}
+    #   @param gas_price [Integer, nil] gas price in wei; switches to a legacy (type 0) transaction
+    #   @param chain_id [Integer, nil] chain id; default `client.chain.id`
+    #   @param access_list [Array<Hash>, nil] EIP-2930 access list (EIP-1559 only)
+    # @return [Transaction] a handle on the broadcast transaction, carrying the locally computed hash
+    # @raise [BlockGiven::InvalidArgumentError] same conditions as {#signed_transaction}
+    # @raise [BlockGiven::RpcError] when the node rejects the transaction (a revert during the node's
+    #   pre-check is raised as {ContractRevertError})
+    # @example
+    #   tx = wallet.send_transaction(to: "0x...", value: BlockGiven::Utils.parse_ether("0.5"))
+    #   tx.hash          # => "0x..."
+    #   receipt = tx.wait!
     def send_transaction(**params) = signed_transaction(**params).broadcast
 
-    # Resolves every missing field (nonce, gas, fees, chain id) without signing.
+    # Resolves every missing transaction field from the client, without signing anything.
+    #
+    # This is the shared first step of {#signed_transaction}, {#sign_transaction} and {#send_transaction}.
+    # It normalises the inputs (checksummed `to`, Integer `value`, `0x`-prefixed `data`) and fills in the
+    # chain id, nonce, gas limit and fees from the node. When `gas_price:` is given the result describes a
+    # legacy (type 0) transaction and contains `:gas_price`; otherwise it contains `:max_fee_per_gas` and
+    # `:max_priority_fee_per_gas`.
+    #
+    # @param to [String, nil] recipient address (any case, checksummed in the result); nil for contract creation
+    # @param value [Integer, String, Float, BigDecimal, Rational, nil] amount of wei; Strings may be decimal or
+    #   `0x` hex, non-Integer numerics must have no fractional part; nil is treated as 0
+    # @param data [String, nil] calldata as hex (with or without `0x`); nil or empty becomes `""`
+    # @param gas [Integer, nil] gas limit; defaults to `eth_estimateGas` (from {#address}, with `to`, `data` and
+    #   `value`) multiplied by `BlockGiven.config.gas_multiplier` and rounded up
+    # @param nonce [Integer, nil] nonce; defaults to the wallet's pending transaction count ({#nonce})
+    # @param max_fee_per_gas [Integer, nil] EIP-1559 max fee per gas in wei; when either EIP-1559 field is
+    #   omitted the missing one comes from {Client#estimate_fees_per_gas}. Ignored with `gas_price:`
+    # @param max_priority_fee_per_gas [Integer, nil] EIP-1559 priority fee per gas in wei; see `max_fee_per_gas`
+    # @param gas_price [Integer, nil] gas price in wei for a legacy (type 0) transaction; never estimated
+    # @param chain_id [Integer, nil] chain id; defaults to `client.chain.id`
+    # @param access_list [Array<Hash>, nil] EIP-2930 access list, kept as given (nil when omitted)
+    # @return [Hash{Symbol => Object}] the resolved parameters: `:from`, `:to`, `:value`, `:data`, `:chain_id`,
+    #   `:nonce`, `:gas`, `:access_list`, plus either `:gas_price` or `:max_fee_per_gas` and
+    #   `:max_priority_fee_per_gas`
+    # @raise [BlockGiven::InvalidArgumentError] when `value` cannot be coerced to an Integer amount of wei (for
+    #   example a fractional Float), or when `to` is nil without an explicit `gas`
     def prepare_transaction(to: nil, value: 0, data: nil, gas: nil, nonce: nil, max_fee_per_gas: nil,
                             max_priority_fee_per_gas: nil, gas_price: nil, chain_id: nil, access_list: nil)
       to = Utils.checksum_address(to) if to
@@ -90,14 +264,34 @@ module BlockGiven
       params
     end
 
+    # Two wallets are equal when they control the same address, whatever their client.
+    #
+    # @param other [Object] the object to compare with
+    # @return [Boolean] true when `other` is a {Wallet} with the same {#address}
     def ==(other) = other.is_a?(Wallet) && other.address == address
     alias eql? ==
+
+    # Hash code consistent with {#==}, so wallets can be used as Hash keys and in Sets.
+    #
+    # @return [Integer] the hash of {#address}
     def hash = address.hash
+
+    # @return [String] the checksummed {#address}
     def to_s = address
+
+    # Debug representation showing only the address. The private key is never printed.
+    #
+    # @return [String] e.g. `#<BlockGiven::Wallet 0xAbC...>`
     def inspect = "#<BlockGiven::Wallet #{address}>"
 
     private
 
+    # r || s || v with v = 27 + recovery id, as `personal_sign` and `eth_signTypedData` return.
+    def sign_digest(digest)
+      r, s, recovery_id = Crypto::Secp256k1.sign(digest, @private_key)
+      Utils.bin_to_hex(Crypto::Secp256k1.int_to_bytes(r) + Crypto::Secp256k1.int_to_bytes(s) + (27 + recovery_id).chr)
+    end
+
     def estimate_gas(to:, data:, value:)
       raise InvalidArgumentError, "contract creation requires an explicit gas: value" if to.nil?
 
@@ -120,18 +314,5 @@ module BlockGiven
       else raise InvalidArgumentError, "invalid value: #{value.inspect}"
       end
     end
-
-    def to_eth_tx_params(params)
-      base = {
-        chain_id: params[:chain_id], nonce: params[:nonce], gas_limit: params[:gas],
-        to: params[:to], value: params[:value], data: params[:data]
-      }
-      if params[:gas_price]
-        base.merge(gas_price: params[:gas_price])
-      else
-        base[:access_list] = params[:access_list] || []
-        base.merge(priority_fee: params[:max_priority_fee_per_gas], max_gas_fee: params[:max_fee_per_gas])
-      end
-    end
   end
 end

data/lib/block_given.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require "eth"
-
 require_relative "block_given/version"
 require_relative "block_given/errors"
 require_relative "block_given/utils"
+require_relative "block_given/crypto"
+require_relative "block_given/rlp"
 require_relative "block_given/chain"
 require_relative "block_given/configuration"
 require_relative "block_given/connectors/base"
@@ -15,31 +15,74 @@ require_relative "block_given/normalizer"
 require_relative "block_given/poller"
 require_relative "block_given/receipt"
 require_relative "block_given/transaction"
+require_relative "block_given/transaction_envelope"
+require_relative "block_given/transaction_envelope/fields"
 require_relative "block_given/signed_transaction"
 require_relative "block_given/client"
+require_relative "block_given/eip712"
 require_relative "block_given/wallet"
+require_relative "block_given/abi/type"
+require_relative "block_given/abi/codec"
+require_relative "block_given/abi/codec/decoder"
 require_relative "block_given/abi/parameter"
 require_relative "block_given/abi/coder"
 require_relative "block_given/abi/function"
 require_relative "block_given/abi/event"
 require_relative "block_given/abi/custom_error"
 require_relative "block_given/abi/interface"
+require_relative "block_given/abi/standards"
 require_relative "block_given/event"
 require_relative "block_given/contract"
 require_relative "block_given/railtie" if defined?(Rails::Railtie)
 
 # viem-inspired toolkit to read from and write to EVM smart contracts.
 #
+# The gem is organised around a handful of entry points:
+#
+# - {BlockGiven.configure} sets the global {Configuration}: JSON-RPC connector, chain, polling and fee
+#   defaults, and the directory application ABIs live in.
+# - {BlockGiven.client} returns the default {Client}: thin wrappers over JSON-RPC (`eth_*`) that return Ruby
+#   values (Integer quantities in wei, checksummed addresses, snake_case symbol keys), plus fee estimation,
+#   receipt polling, log fetching and stoppable `watch_*` pollers.
+# - {Contract} is a class-level DSL (`abi_file`, `address`, `chain`) that generates typed read, write and
+#   simulate methods and decoded events from an ABI.
+# - {Wallet} holds a private key and signs transactions (EIP-1559 and legacy), personal messages (EIP-191)
+#   and typed data (EIP-712).
+# - {Connectors} carry the transport: {Connectors::Alchemy} and {Connectors::Http} for real nodes,
+#   {Connectors::Stub} for tests.
+# - {Utils}, {Normalizer} and {Chains} are stateless helpers (unit parsing, hex handling, keccak256,
+#   RPC payload normalisation and the catalogue of known networks).
+#
+# Every error raised by the gem inherits from {BlockGiven::Error}.
+#
+# @example Configure once, then use the default client
 #   BlockGiven.configure do |c|
 #     c.connector = BlockGiven::Connectors::Alchemy.new(api_key: ENV["ALCHEMY_API_KEY"])
 #     c.chain = :base
 #   end
+#
+#   BlockGiven.client.block_number # => 12_345_678
 module BlockGiven
   class << self
+    # Global configuration shared by the default client and by contracts without an explicit chain or connector.
+    #
+    # @return [BlockGiven::Configuration] the memoised configuration, created with defaults on first access
     def config
       @config ||= Configuration.new
     end
 
+    # Configure the gem and discard the memoised default client so the next {.client} call reflects the changes.
+    #
+    # @yield [config] the global configuration to mutate
+    # @yieldparam config [BlockGiven::Configuration]
+    # @return [BlockGiven::Configuration] the updated configuration
+    # @example
+    #   BlockGiven.configure do |c|
+    #     c.connector = BlockGiven::Connectors::Alchemy.new(api_key: ENV["ALCHEMY_API_KEY"])
+    #     c.chain = :base_sepolia
+    #     c.polling_interval = 1.0
+    #     c.abi_path = Rails.root.join("abis")
+    #   end
     def configure
       yield config
       @client = nil
@@ -47,22 +90,42 @@ module BlockGiven
     end
 
     # Default client built from the global configuration.
+    #
+    # Memoised until {.configure} or {.reset!} runs, or until a client is assigned through {.client=}.
+    #
+    # @return [BlockGiven::Client]
+    # @raise [BlockGiven::ConfigurationError] when no connector or no chain is configured
+    # @example
+    #   BlockGiven.client.get_balance("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045") # => 1_000_000_000_000_000_000
     def client
       @client ||= Client.new
     end
 
+    # Replace the default client, for instance with one built on a {Connectors::Stub} in tests.
+    #
+    # @param value [BlockGiven::Client, nil] nil makes the next {.client} call rebuild one from the configuration
+    # @return [BlockGiven::Client, nil]
     attr_writer :client
 
-    # Running background watchers (see BlockGiven::Watcher.find / stop / stop_all).
+    # Running background watchers, oldest first (see {Watcher.find}, {Watcher.stop} and {Watcher.stop_all}).
+    #
+    # @return [Array<BlockGiven::Watcher>]
     def watchers = Watcher.all
 
-    # Forget configuration and default client, stop every watcher (useful in tests).
+    # Forget configuration and default client, and stop every watcher (useful in tests).
+    #
+    # Watchers are asked to stop gracefully and joined for up to one second each before the state is cleared.
+    #
+    # @return [void]
     def reset!
       Watcher.stop_all(join: 1)
       @config = nil
       @client = nil
     end
 
+    # Logger from the global configuration.
+    #
+    # @return [Logger] a `$stderr` logger at WARN level unless the application set one (see {Configuration#logger})
     def logger = config.logger
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: block_given
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Remi Wallaere
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-11 00:00:00.000000000 Z
+date: 2026-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -24,26 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.1'
-- !ruby/object:Gem::Dependency
-  name: eth
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.5.17
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.5.17
 - !ruby/object:Gem::Dependency
   name: logger
   requirement: !ruby/object:Gem::Requirement
@@ -63,6 +43,7 @@ description: |
   inspired by viem: typed contract classes generated from an ABI, wallets that sign
   EIP-1559 transactions, pluggable JSON-RPC connectors (Alchemy first) and
   polling helpers for receipts, blocks and events.
+  Documentation: https://rubydoc.info/gems/block_given
 email:
 - remi@boleromusic.com
 executables: []
@@ -73,12 +54,20 @@ files:
 - LICENSE.txt
 - README.md
 - lib/block_given.rb
+- lib/block_given/abi/codec.rb
+- lib/block_given/abi/codec/decoder.rb
 - lib/block_given/abi/coder.rb
 - lib/block_given/abi/custom_error.rb
 - lib/block_given/abi/event.rb
 - lib/block_given/abi/function.rb
 - lib/block_given/abi/interface.rb
 - lib/block_given/abi/parameter.rb
+- lib/block_given/abi/standards.rb
+- lib/block_given/abi/standards/erc1155.rb
+- lib/block_given/abi/standards/erc20.rb
+- lib/block_given/abi/standards/erc4626.rb
+- lib/block_given/abi/standards/erc721.rb
+- lib/block_given/abi/type.rb
 - lib/block_given/chain.rb
 - lib/block_given/client.rb
 - lib/block_given/configuration.rb
@@ -87,14 +76,21 @@ files:
 - lib/block_given/connectors/http.rb
 - lib/block_given/connectors/stub.rb
 - lib/block_given/contract.rb
+- lib/block_given/crypto.rb
+- lib/block_given/crypto/keccak.rb
+- lib/block_given/crypto/secp256k1.rb
+- lib/block_given/eip712.rb
 - lib/block_given/errors.rb
 - lib/block_given/event.rb
 - lib/block_given/normalizer.rb
 - lib/block_given/poller.rb
 - lib/block_given/railtie.rb
 - lib/block_given/receipt.rb
+- lib/block_given/rlp.rb
 - lib/block_given/signed_transaction.rb
 - lib/block_given/transaction.rb
+- lib/block_given/transaction_envelope.rb
+- lib/block_given/transaction_envelope/fields.rb
 - lib/block_given/utils.rb
 - lib/block_given/version.rb
 - lib/block_given/wallet.rb
@@ -123,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: viem-inspired Ruby client for EVM smart contracts.