SYMBOL INDEX (550 symbols across 52 files)

FILE: lib/eth.rb
  type Eth (line 16) | module Eth

FILE: lib/eth/abi.rb
  type Eth (line 20) | module Eth
    type Abi (line 24) | module Abi
      class EncodingError (line 28) | class EncodingError < StandardError; end
      class DecodingError (line 31) | class DecodingError < StandardError; end
      class ValueOutOfBounds (line 34) | class ValueOutOfBounds < StandardError; end
      function encode (line 43) | def encode(types, args, packed = false)
      function solidity_packed (line 79) | def solidity_packed(types, args)
      function decode (line 98) | def decode(types, data)

FILE: lib/eth/abi/decoder.rb
  type Eth (line 18) | module Eth
    type Abi (line 21) | module Abi
      type Decoder (line 24) | module Decoder
        function type (line 33) | def type(type, arg)
        function primitive_type (line 132) | def primitive_type(type, data)
        function tuple_dynamic_ranges (line 195) | def tuple_dynamic_ranges(offsets, total_size, head_size)

FILE: lib/eth/abi/encoder.rb
  type Eth (line 19) | module Eth
    type Abi (line 22) | module Abi
      type Encoder (line 25) | module Encoder
        function type (line 34) | def type(type, arg)
        function primitive_type (line 60) | def primitive_type(type, arg)
        function uint (line 88) | def uint(arg, type)
        function int (line 99) | def int(arg, type)
        function bool (line 110) | def bool(arg)
        function ufixed (line 116) | def ufixed(arg, type)
        function fixed (line 125) | def fixed(arg, type)
        function bytes (line 135) | def bytes(arg, type)
        function tuple (line 155) | def tuple(arg, type)
        function coerce_number (line 190) | def coerce_number(arg)
        function encode_array (line 203) | def encode_array(type, values)
        function encode_dynamic_array (line 225) | def encode_dynamic_array(nested_sub, values)
        function encode_static_array (line 236) | def encode_static_array(nested_sub, values)
        function encode_array_elements (line 246) | def encode_array_elements(nested_sub, values)
        function hash (line 264) | def hash(arg, type)
        function address (line 285) | def address(arg)
        function handle_hex_string (line 313) | def handle_hex_string(arg, type)

FILE: lib/eth/abi/event.rb
  type Eth (line 18) | module Eth
    type Abi (line 21) | module Abi
      type Event (line 24) | module Event
        function compute_topic (line 31) | def compute_topic(interface)
        function signature (line 40) | def signature(interface)
        function type (line 51) | def type(input)
        class LogDescription (line 62) | class LogDescription
          method initialize (line 79) | def initialize(event_interface, log)
          method name (line 92) | def name
          method signature (line 97) | def signature
        function decode_logs (line 107) | def decode_logs(interfaces, logs)
        function decode_log (line 130) | def decode_log(inputs, data, topics, anonymous = false)

FILE: lib/eth/abi/function.rb
  type Eth (line 18) | module Eth
    type Abi (line 21) | module Abi
      type Function (line 24) | module Function
        function signature (line 31) | def signature(interface)
        function selector (line 42) | def selector(interface)
        function type (line 51) | def type(input)
        class CallDescription (line 62) | class CallDescription
          method initialize (line 81) | def initialize(function_interface, selector, args, kwargs)
          method name (line 89) | def name
          method signature (line 94) | def signature
        function decode (line 104) | def decode(interfaces, data)

FILE: lib/eth/abi/packed/encoder.rb
  type Eth (line 18) | module Eth
    type Abi (line 21) | module Abi
      type Packed (line 24) | module Packed
        type Encoder (line 27) | module Encoder
          function type (line 38) | def type(type, arg)
          function uint (line 74) | def uint(value, byte_size)
          function int (line 82) | def int(value, byte_size)
          function bool (line 91) | def bool(value)
          function ufixed (line 97) | def ufixed(value, byte_size, decimals)
          function fixed (line 105) | def fixed(value, byte_size, decimals)
          function bytes (line 113) | def bytes(value, length)
          function string (line 121) | def string(value)
          function tuple (line 127) | def tuple(types, values)
          function hash (line 132) | def hash(value, byte_size)
          function address (line 139) | def address(value)
          function array (line 166) | def array(type, values)
          function fixed_array (line 171) | def fixed_array(type, values, size)
          function handle_hex_string (line 178) | def handle_hex_string(val, len)

FILE: lib/eth/abi/type.rb
  type Eth (line 18) | module Eth
    type Abi (line 21) | module Abi
      class Type (line 24) | class Type
        class ParseError (line 27) | class ParseError < StandardError; end
        method initialize (line 53) | def initialize(base_type, sub_type, dimensions, components = nil, ...
        method parse (line 73) | def parse(type, components = nil, component_name = nil)
        method size_type (line 121) | def self.size_type
        method == (line 129) | def ==(another_type)
        method size (line 138) | def size
        method dynamic? (line 155) | def dynamic?
        method nested_sub (line 162) | def nested_sub
        method to_s (line 169) | def to_s
        method validate_base_type (line 186) | def validate_base_type(base_type, sub_type)
        method extract_tuple (line 237) | def extract_tuple(type)
        method split_tuple_types (line 256) | def split_tuple_types(str)

FILE: lib/eth/address.rb
  type Eth (line 16) | module Eth
    class Address (line 19) | class Address
      class CheckSumError (line 25) | class CheckSumError < StandardError; end
      method initialize (line 34) | def initialize(address)
      method valid? (line 47) | def valid?
      method zero? (line 60) | def zero?
      method checksummed (line 67) | def checksummed
      method checksum_matches? (line 82) | def checksum_matches?
      method not_checksummed? (line 87) | def not_checksummed?
      method all_uppercase? (line 92) | def all_uppercase?
      method all_lowercase? (line 97) | def all_lowercase?
      method matches_any_format? (line 102) | def matches_any_format?
      method checksum (line 107) | def checksum
      method unprefixed (line 112) | def unprefixed

FILE: lib/eth/api.rb
  type Eth (line 16) | module Eth
    type Api (line 19) | module Api

FILE: lib/eth/bls.rb
  type Eth (line 5) | module Eth
    type Bls (line 7) | module Bls
      function decode_public_key (line 13) | def decode_public_key(hex)
      function encode_public_key (line 20) | def encode_public_key(point)
      function decode_signature (line 27) | def decode_signature(hex)
      function encode_signature (line 34) | def encode_signature(point)
      function get_public_key (line 41) | def get_public_key(priv_hex)
      function sign (line 50) | def sign(message, priv_hex)
      function verify (line 62) | def verify(message, signature_hex, pubkey_hex)

FILE: lib/eth/chain.rb
  type Eth (line 16) | module Eth
    type Chain (line 20) | module Chain
      class ReplayProtectionError (line 24) | class ReplayProtectionError < StandardError; end
      function ledger? (line 175) | def ledger?(v)
      function legacy? (line 184) | def legacy?(v)
      function to_recovery_id (line 195) | def to_recovery_id(v, chain_id = ETHEREUM)
      function to_v (line 220) | def to_v(recovery_id, chain_id = nil)
      function to_chain_id (line 234) | def to_chain_id(v)

FILE: lib/eth/client.rb
  type Eth (line 16) | module Eth
    class Client (line 20) | class Client
      class ContractExecutionError (line 41) | class ContractExecutionError < StandardError; end
      class RpcError (line 45) | class RpcError < IOError
        method initialize (line 54) | def initialize(message, data = nil, code = nil)
      method create (line 73) | def self.create(host)
      method initialize (line 82) | def initialize(_)
      method default_account (line 94) | def default_account
      method chain_id (line 102) | def chain_id
      method get_balance (line 110) | def get_balance(address)
      method get_nonce (line 118) | def get_nonce(address)
      method resolve_ens (line 128) | def resolve_ens(ens_name, registry = Ens::DEFAULT_ADDRESS, coin_type...
      method transfer_and_wait (line 140) | def transfer_and_wait(destination, amount, **kwargs)
      method transfer (line 161) | def transfer(destination, amount, **kwargs)
      method transfer_erc20_and_wait (line 176) | def transfer_erc20_and_wait(erc20_contract, destination, amount, **k...
      method transfer_erc20 (line 199) | def transfer_erc20(erc20_contract, destination, amount, **kwargs)
      method deploy_and_wait (line 210) | def deploy_and_wait(contract, *args, **kwargs)
      method deploy (line 236) | def deploy(contract, *args, **kwargs)
      method call (line 275) | def call(contract, function, *args, **kwargs)
      method transact (line 322) | def transact(contract, function, *args, **kwargs)
      method transact_and_wait (line 345) | def transact_and_wait(contract, function, *args, **kwargs)
      method is_valid_signature (line 364) | def is_valid_signature(contract, hash, signature, magic = "1626ba7e")
      method reset_id (line 377) | def reset_id
      method tx_mined? (line 385) | def tx_mined?(hash)
      method tx_succeeded? (line 394) | def tx_succeeded?(hash)
      method wait_for_tx (line 404) | def wait_for_tx(hash)
      method local? (line 427) | def local?
      method send_transaction (line 438) | def send_transaction(params, legacy, key, nonce)
      method encode_constructor_params (line 472) | def encode_constructor_params(contract, args)
      method send_command (line 478) | def send_command(command, args)
      method next_id (line 495) | def next_id
      method camelize! (line 500) | def camelize!(params)
      method marshal (line 509) | def marshal(params)

FILE: lib/eth/client/http.rb
  type Eth (line 19) | module Eth
    class Client::Http (line 22) | class Client::Http < Client
      method initialize (line 43) | def initialize(host)
      method send_request (line 68) | def send_request(payload)

FILE: lib/eth/client/ipc.rb
  type Eth (line 18) | module Eth
    class Client::Ipc (line 21) | class Client::Ipc < Client
      method initialize (line 30) | def initialize(path)
      method send_request (line 39) | def send_request(payload)

FILE: lib/eth/client/ws.rb
  type Eth (line 25) | module Eth
    class Client::Ws (line 28) | class Client::Ws < Client
      method initialize (line 46) | def initialize(host)
      method send_request (line 63) | def send_request(payload)
      method close (line 82) | def close
      method ensure_socket (line 88) | def ensure_socket
      method open_socket (line 115) | def open_socket
      method perform_handshake (line 132) | def perform_handshake(socket)
      method build_handshake_request (line 140) | def build_handshake_request(key)
      method read_handshake_response (line 152) | def read_handshake_response(socket)
      method verify_handshake! (line 164) | def verify_handshake!(response, key)
      method write_frame (line 176) | def write_frame(socket, payload, opcode = 0x1)
      method read_message (line 196) | def read_message(socket)
      method read_frame (line 203) | def read_frame(socket)
      method read_bytes (line 251) | def read_bytes(socket, length)
      method apply_mask (line 261) | def apply_mask(payload, mask_key)
      method build_origin_header (line 266) | def build_origin_header
      method build_host_header (line 275) | def build_host_header
      method format_origin_host (line 279) | def format_origin_host(host)
      method format_host (line 284) | def format_host(host)
      method loopback_host? (line 289) | def loopback_host?(host)
      method close_socket (line 297) | def close_socket
      method build_path (line 315) | def build_path(uri)

FILE: lib/eth/constant.rb
  type Eth (line 18) | module Eth
    type Constant (line 21) | module Constant

FILE: lib/eth/contract.rb
  type Eth (line 20) | module Eth
    class Contract (line 23) | class Contract
      method initialize (line 38) | def initialize(name, bin, abi)
      method from_file (line 56) | def self.from_file(file:, contract_index: 0)
      method from_abi (line 71) | def self.from_abi(abi:, address:, name:)
      method from_bin (line 88) | def self.from_bin(bin:, abi:, name:)
      method address= (line 98) | def address=(addr)
      method function (line 115) | def function(name, args: nil)
      method error (line 127) | def error(name, args: nil)
      method decode_error (line 137) | def decode_error(rpc_error)
      method build (line 156) | def build
      method parse_abi (line 183) | def parse_abi(abi)

FILE: lib/eth/contract/error.rb
  type Eth (line 18) | module Eth
    class Contract::Error (line 20) | class Contract::Error
      method initialize (line 26) | def initialize(data)
      method calc_signature (line 40) | def self.calc_signature(name, inputs)
      method encoded_error_signature (line 48) | def self.encoded_error_signature(signature)
      method decode (line 56) | def decode(data)

FILE: lib/eth/contract/event.rb
  type Eth (line 18) | module Eth
    class Contract::Event (line 20) | class Contract::Event
      method initialize (line 24) | def initialize(data)
      method name (line 31) | def name
      method input_types (line 38) | def input_types
      method inputs (line 45) | def inputs
      method event_string (line 52) | def event_string
      method signature (line 59) | def signature
      method address (line 66) | def address
      method set_address (line 73) | def set_address(address)
      method decode_params (line 82) | def decode_params(topics, data = "0x")
      method type_name (line 100) | def type_name(x)

FILE: lib/eth/contract/function.rb
  type Eth (line 18) | module Eth
    class Contract::Function (line 21) | class Contract::Function
      method initialize (line 27) | def initialize(data)
      method calc_signature (line 45) | def self.calc_signature(name, inputs)
      method encoded_function_signature (line 53) | def self.encoded_function_signature(signature)
      method encode_call (line 61) | def encode_call(*args)
      method decode_call_result (line 71) | def decode_call_result(data)

FILE: lib/eth/contract/function_input.rb
  type Eth (line 18) | module Eth
    class Contract::FunctionInput (line 21) | class Contract::FunctionInput
      method initialize (line 27) | def initialize(data)
      method type (line 34) | def type
      method parsed_type (line 39) | def parsed_type

FILE: lib/eth/contract/function_output.rb
  type Eth (line 18) | module Eth
    class Contract::FunctionOutput (line 21) | class Contract::FunctionOutput
      method initialize (line 27) | def initialize(data)
      method type (line 34) | def type
      method parsed_type (line 41) | def parsed_type

FILE: lib/eth/contract/initializer.rb
  type Eth (line 18) | module Eth
    class Contract::Initializer (line 21) | class Contract::Initializer
      method initialize (line 27) | def initialize(file)
      method build_all (line 41) | def build_all

FILE: lib/eth/eip712.rb
  type Eth (line 16) | module Eth
    type Eip712 (line 20) | module Eip712
      class TypedDataError (line 25) | class TypedDataError < StandardError; end
      function type_dependencies (line 34) | def type_dependencies(primary_type, types, result = [])
      function encode_type (line 68) | def encode_type(primary_type, types)
      function hash_type (line 100) | def hash_type(primary_type, types)
      function encode_data (line 111) | def encode_data(primary_type, data, types)
      function encode_value (line 139) | def encode_value(type, value, types)
      function encode_array (line 156) | def encode_array(type, value, types)
      function hash_data (line 180) | def hash_data(primary_type, data, types)
      function enforce_typed_data (line 191) | def enforce_typed_data(data)
      function hash (line 207) | def hash(data)

FILE: lib/eth/ens.rb
  type Eth (line 19) | module Eth
    type Ens (line 22) | module Ens

FILE: lib/eth/ens/coin_type.rb
  type Eth (line 16) | module Eth
    type Ens (line 19) | module Ens
      type CoinType (line 22) | module CoinType

FILE: lib/eth/ens/resolver.rb
  type Eth (line 18) | module Eth
    type Ens (line 22) | module Ens
      class Resolver (line 25) | class Resolver
        method initialize (line 37) | def initialize(client, address = DEFAULT_ADDRESS)
        method owner (line 50) | def owner(ens_name)
        method resolver (line 59) | def resolver(ens_name)
        method resolve (line 72) | def resolve(ens_name, coin_type = Ens::CoinType::ETHEREUM)
        method text (line 88) | def text(ens_name, key = "description")
        method namehash (line 97) | def namehash(ens_name)
        method normalize (line 111) | def normalize(input)

FILE: lib/eth/key.rb
  type Eth (line 22) | module Eth
    class Key (line 25) | class Key
      method initialize (line 43) | def initialize(priv: nil)
      method sign (line 72) | def sign(blob, chain_id = nil)
      method personal_sign (line 94) | def personal_sign(message, chain_id = nil)
      method sign_typed_data (line 109) | def sign_typed_data(typed_data, chain_id = nil)
      method private_hex (line 117) | def private_hex
      method private_bytes (line 125) | def private_bytes
      method public_hex (line 133) | def public_hex
      method public_hex_compressed (line 141) | def public_hex_compressed
      method public_bytes (line 149) | def public_bytes
      method public_bytes_compressed (line 156) | def public_bytes_compressed
      method address (line 163) | def address

FILE: lib/eth/key/decrypter.rb
  type Eth (line 16) | module Eth
    class Key::Decrypter (line 19) | class Key::Decrypter
      class DecrypterError (line 22) | class DecrypterError < StandardError; end
      method perform (line 30) | def self.perform(data, password)
      method initialize (line 40) | def initialize(data, password)
      method perform (line 49) | def perform
      method derive_key (line 62) | def derive_key(password)
      method check_macs (line 73) | def check_macs
      method decrypted_data (line 82) | def decrypted_data
      method crypto_data (line 86) | def crypto_data
      method ciphertext (line 90) | def ciphertext
      method cipher_name (line 94) | def cipher_name
      method cipher (line 98) | def cipher
      method iv (line 106) | def iv
      method salt (line 110) | def salt
      method iterations (line 114) | def iterations
      method kdf (line 118) | def kdf
      method key_length (line 122) | def key_length
      method n (line 126) | def n
      method r (line 130) | def r
      method p (line 134) | def p
      method digest (line 138) | def digest
      method digest_name (line 142) | def digest_name

FILE: lib/eth/key/encrypter.rb
  type Eth (line 16) | module Eth
    class Key::Encrypter (line 19) | class Key::Encrypter
      class EncrypterError (line 22) | class EncrypterError < StandardError; end
      method perform (line 37) | def self.perform(key, password, options = {})
      method initialize (line 54) | def initialize(key, options = {})
      method perform (line 70) | def perform(password)
      method data (line 80) | def data
      method cipher (line 119) | def cipher
      method digest (line 127) | def digest
      method derive_key (line 131) | def derive_key(password)
      method encrypt (line 139) | def encrypt
      method mac (line 143) | def mac
      method kdf (line 147) | def kdf
      method cipher_name (line 151) | def cipher_name
      method digest_name (line 155) | def digest_name
      method prf (line 159) | def prf
      method key_length (line 163) | def key_length
      method salt_length (line 167) | def salt_length
      method iv_length (line 171) | def iv_length
      method id (line 175) | def id
      method iterations (line 179) | def iterations
      method salt (line 183) | def salt
      method iv (line 191) | def iv
      method parallelization (line 199) | def parallelization
      method block_size (line 203) | def block_size

FILE: lib/eth/rlp.rb
  type Eth (line 23) | module Eth
    type Rlp (line 26) | module Rlp
      class RlpException (line 30) | class RlpException < StandardError; end
      class EncodingError (line 33) | class EncodingError < RlpException; end
      class DecodingError (line 36) | class DecodingError < RlpException; end
      class SerializationError (line 39) | class SerializationError < RlpException; end
      class DeserializationError (line 42) | class DeserializationError < RlpException; end
      class Data (line 45) | class Data < String; end
      function encode (line 51) | def encode(obj)
      function decode (line 59) | def decode(rlp)

FILE: lib/eth/rlp/decoder.rb
  type Eth (line 18) | module Eth
    type Rlp (line 21) | module Rlp
      type Decoder (line 24) | module Decoder
        function perform (line 33) | def perform(rlp)
        function consume_item (line 48) | def consume_item(rlp, start)
        function consume_length_prefix (line 54) | def consume_length_prefix(rlp, start)
        function enforce_no_zero_bytes (line 89) | def enforce_no_zero_bytes(rlp, start)
        function consume_payload (line 94) | def consume_payload(rlp, start, type, length)

FILE: lib/eth/rlp/encoder.rb
  type Eth (line 18) | module Eth
    type Rlp (line 21) | module Rlp
      type Encoder (line 24) | module Encoder
        function perform (line 34) | def perform(obj)
        function encode_raw (line 42) | def encode_raw(item)
        function encode_primitive (line 50) | def encode_primitive(item)
        function encode_list (line 58) | def encode_list(list)
        function length_prefix (line 65) | def length_prefix(length, offset)

FILE: lib/eth/rlp/sedes.rb
  type Eth (line 22) | module Eth
    type Rlp (line 25) | module Rlp
      type Sedes (line 28) | module Sedes
        function infer (line 41) | def infer(obj)
        function sedes? (line 53) | def sedes?(obj)
        function big_endian_int (line 61) | def big_endian_int
        function binary (line 68) | def binary

FILE: lib/eth/rlp/sedes/big_endian_int.rb
  type Eth (line 18) | module Eth
    type Rlp (line 21) | module Rlp
      type Sedes (line 24) | module Sedes
        class BigEndianInt (line 27) | class BigEndianInt
          method initialize (line 32) | def initialize(size = nil)
          method serialize (line 43) | def serialize(obj)
          method deserialize (line 57) | def deserialize(serial)

FILE: lib/eth/rlp/sedes/binary.rb
  type Eth (line 18) | module Eth
    type Rlp (line 21) | module Rlp
      type Sedes (line 24) | module Sedes
        class Binary (line 27) | class Binary
          method fixed_length (line 37) | def fixed_length(l, allow_empty: false)
          method valid_type? (line 45) | def valid_type?(obj)
          method initialize (line 55) | def initialize(min_length: 0, max_length: Constant::INFINITY, al...
          method serialize (line 67) | def serialize(obj)
          method deserialize (line 80) | def deserialize(serial)
          method valid_length? (line 91) | def valid_length?(length)

FILE: lib/eth/rlp/sedes/list.rb
  type Eth (line 18) | module Eth
    type Rlp (line 21) | module Rlp
      type Sedes (line 24) | module Sedes
        class List (line 27) | class List < Array
          method initialize (line 33) | def initialize(elements: [], strict: true)
          method serialize (line 53) | def serialize(obj)
          method deserialize (line 69) | def deserialize(serial)

FILE: lib/eth/signature.rb
  type Eth (line 18) | module Eth
    type Signature (line 21) | module Signature
      class SignatureError (line 25) | class SignatureError < StandardError; end
      function prefix_message (line 40) | def prefix_message(message)
      function dissect (line 50) | def dissect(signature)
      function recover (line 69) | def recover(blob, signature, chain_id = Chain::ETHEREUM)
      function personal_recover (line 92) | def personal_recover(message, signature, chain_id = Chain::ETHEREUM)
      function recover_typed_data (line 106) | def recover_typed_data(typed_data, signature, chain_id = Chain::ETHE...
      function verify (line 119) | def verify(blob, signature, public_key, chain_id = Chain::ETHEREUM)

FILE: lib/eth/solidity.rb
  type Eth (line 18) | module Eth
    class Solidity (line 21) | class Solidity
      class CompilerError (line 24) | class CompilerError < StandardError; end
      method initialize (line 33) | def initialize(path = nil)
      method compile (line 45) | def compile(contract)
      method get_compiler_path (line 68) | def get_compiler_path(name = "solc")

FILE: lib/eth/tx.rb
  type Eth (line 26) | module Eth
    type Tx (line 29) | module Tx
      class TransactionTypeError (line 33) | class TransactionTypeError < TypeError; end
      class DecoderError (line 36) | class DecoderError < StandardError; end
      class ParameterError (line 39) | class ParameterError < TypeError; end
      function new (line 103) | def new(params, chain_id = Chain::ETHEREUM)
      function decode (line 139) | def decode(hex)
      function unsigned_copy (line 176) | def unsigned_copy(tx)
      function estimate_intrinsic_gas (line 208) | def estimate_intrinsic_gas(data = "", list = [])
      function validate_params (line 250) | def validate_params(fields)
      function validate_eip1559_params (line 275) | def validate_eip1559_params(fields)
      function validate_eip4844_params (line 290) | def validate_eip4844_params(fields)
      function validate_eip7702_params (line 311) | def validate_eip7702_params(fields)
      function validate_legacy_params (line 323) | def validate_legacy_params(fields)
      function sanitize_chain (line 335) | def sanitize_chain(id)
      function sanitize_address (line 346) | def sanitize_address(addr)
      function sanitize_amount (line 360) | def sanitize_amount(val)
      function sanitize_data (line 370) | def sanitize_data(data)
      function sanitize_list (line 384) | def sanitize_list(list)
      function sanitize_hashes (line 406) | def sanitize_hashes(list)
      function signed? (line 419) | def signed?(tx)

FILE: lib/eth/tx/eip1559.rb
  type Eth (line 16) | module Eth
    type Tx (line 19) | module Tx
      class Eip1559 (line 24) | class Eip1559
        method initialize (line 86) | def initialize(params)
        method decode (line 139) | def decode(hex)
        method unsigned_copy (line 206) | def unsigned_copy(tx)
        method sign (line 238) | def sign(key)
        method sign_with (line 266) | def sign_with(signature)
        method encoded (line 290) | def encoded
        method hex (line 317) | def hex
        method hash (line 324) | def hash
        method unsigned_encoded (line 332) | def unsigned_encoded
        method unsigned_hash (line 353) | def unsigned_hash
        method _set_signature (line 360) | def _set_signature(recovery_id, r, s)

FILE: lib/eth/tx/eip2930.rb
  type Eth (line 16) | module Eth
    type Tx (line 19) | module Tx
      class Eip2930 (line 24) | class Eip2930
        method initialize (line 84) | def initialize(params)
        method decode (line 136) | def decode(hex)
        method unsigned_copy (line 201) | def unsigned_copy(tx)
        method sign (line 232) | def sign(key)
        method sign_with (line 260) | def sign_with(signature)
        method encoded (line 284) | def encoded
        method hex (line 310) | def hex
        method hash (line 317) | def hash
        method unsigned_encoded (line 325) | def unsigned_encoded
        method unsigned_hash (line 345) | def unsigned_hash
        method _set_signature (line 352) | def _set_signature(recovery_id, r, s)

FILE: lib/eth/tx/eip4844.rb
  type Eth (line 16) | module Eth
    type Tx (line 19) | module Tx
      class Eip4844 (line 24) | class Eip4844
        method initialize (line 106) | def initialize(params)
        method decode (line 163) | def decode(hex)
        method unsigned_copy (line 234) | def unsigned_copy(tx)
        method sign (line 268) | def sign(key)
        method sign_with (line 296) | def sign_with(signature)
        method encoded (line 320) | def encoded
        method hex (line 349) | def hex
        method hash (line 356) | def hash
        method unsigned_encoded (line 364) | def unsigned_encoded
        method unsigned_hash (line 387) | def unsigned_hash
        method _set_signature (line 394) | def _set_signature(recovery_id, r, s)

FILE: lib/eth/tx/eip7702.rb
  type Eth (line 16) | module Eth
    type Tx (line 19) | module Tx
      class Eip7702 (line 24) | class Eip7702
        class Authorization (line 28) | class Authorization
          method initialize (line 57) | def initialize(fields)
          method sign (line 72) | def sign(key)
          method unsigned_encoded (line 97) | def unsigned_encoded
          method unsigned_hash (line 108) | def unsigned_hash
          method raw (line 115) | def raw
          method == (line 130) | def ==(o)
          method state (line 136) | def state
        method initialize (line 205) | def initialize(params)
        method decode (line 260) | def decode(hex)
        method unsigned_copy (line 330) | def unsigned_copy(tx)
        method sign (line 370) | def sign(key)
        method sign_with (line 398) | def sign_with(signature)
        method encoded (line 422) | def encoded
        method hex (line 453) | def hex
        method hash (line 460) | def hash
        method unsigned_encoded (line 468) | def unsigned_encoded
        method unsigned_hash (line 494) | def unsigned_hash
        method deserialize_authorizations (line 500) | def deserialize_authorizations(authorization_list)
        method _set_signature (line 513) | def _set_signature(recovery_id, r, s)

FILE: lib/eth/tx/legacy.rb
  type Eth (line 16) | module Eth
    type Tx (line 19) | module Tx
      class Legacy (line 23) | class Legacy
        method initialize (line 76) | def initialize(params, chain_id = Chain::ETHEREUM)
        method decode (line 123) | def decode(hex)
        method unsigned_copy (line 175) | def unsigned_copy(tx)
        method sign (line 205) | def sign(key)
        method sign_with (line 232) | def sign_with(signature)
        method encoded (line 254) | def encoded
        method hex (line 274) | def hex
        method hash (line 281) | def hash
        method unsigned_encoded (line 288) | def unsigned_encoded
        method unsigned_hash (line 305) | def unsigned_hash
        method _set_signature (line 312) | def _set_signature(v, r, s)

FILE: lib/eth/unit.rb
  type Eth (line 18) | module Eth
    type Unit (line 21) | module Unit

FILE: lib/eth/util.rb
  type Eth (line 20) | module Eth
    type Util (line 23) | module Util
      function public_key_to_address (line 31) | def public_key_to_address(str)
      function keccak256 (line 42) | def keccak256(str)
      function bin_to_hex (line 51) | def bin_to_hex(bin)
      function hex_to_bin (line 62) | def hex_to_bin(hex)
      function prefix_hex (line 74) | def prefix_hex(hex)
      function remove_hex_prefix (line 82) | def remove_hex_prefix(hex)
      function bin_to_prefixed_hex (line 91) | def bin_to_prefixed_hex(bin)
      function hex? (line 99) | def hex?(str)
      function prefixed? (line 109) | def prefixed?(hex)
      function serialize_int_to_big_endian (line 118) | def serialize_int_to_big_endian(num)
      function int_to_big_endian (line 130) | def int_to_big_endian(num)
      function deserialize_big_endian_to_int (line 144) | def deserialize_big_endian_to_int(str)
      function deserialize_rlp_int (line 153) | def deserialize_rlp_int(str)
      function big_endian_to_int (line 161) | def big_endian_to_int(str)
      function str_to_bytes (line 169) | def str_to_bytes(str)
      function bytes_to_str (line 177) | def bytes_to_str(bin)
      function bytes? (line 185) | def bytes?(str)
      function primitive? (line 193) | def primitive?(item)
      function list? (line 201) | def list?(item)
      function ceil32 (line 209) | def ceil32(num)
      function lpad (line 219) | def lpad(str, sym, len)
      function zpad (line 229) | def zpad(str, len)
      function zpad_hex (line 238) | def zpad_hex(hex, len = 32)
      function zpad_int (line 247) | def zpad_int(num, len = 32)

FILE: lib/eth/version.rb
  type Eth (line 16) | module Eth

FILE: spec/eth/abi_spec.rb
  function assert (line 363) | def assert(data, types, args)

FILE: spec/eth/client/ws_spec.rb
  class DummyWebsocketServer (line 25) | class DummyWebsocketServer
    method initialize (line 30) | def initialize
    method start (line 45) | def start
    method stop (line 50) | def stop
    method serve (line 62) | def serve
    method handle_client (line 73) | def handle_client(socket)
    method perform_handshake (line 101) | def perform_handshake(socket)
    method rpc_response_for (line 125) | def rpc_response_for(message)
    method read_frame (line 156) | def read_frame(socket)
    method send_frame (line 180) | def send_frame(socket, payload, opcode = 0x1)
    method send_close (line 196) | def send_close(socket)
    method success (line 200) | def success(id, result)
    method error (line 208) | def error(id, message)
    method record_transaction (line 216) | def record_transaction(tx)
    method build_tx_hash (line 240) | def build_tx_hash(from, to, nonce, value)
    method normalize_address (line 245) | def normalize_address(address)
    method hex_to_int (line 250) | def hex_to_int(value)
    method to_hex (line 257) | def to_hex(number)

FILE: spec/eth/key/decrypter_spec.rb
  function read_key_fixture (line 4) | def read_key_fixture(path)