chore: run rufo, add docs (#332)

* gem: run rufo

* spec: add tests for event spec

* eth/tx: add docs for eip7702

* eth/chain: add hoodi testnet

* eth: add more docs

* eth/tx: fix tests for 7702

* gem: run rufo

Author: q9f

lib/eth/abi/event.rb

@@ -44,6 +44,10 @@ def signature(interface)
         "#{name}(#{types.join(",")})"
       end
 
+      # Gets the input type for events.
+      #
+      # @param input [Hash] events input.
+      # @return [String] input type.
       def type(input)
         if input["type"] == "tuple"
           "(#{input["components"].map { |c| type(c) }.join(",")})"

lib/eth/address.rb

@@ -17,6 +17,8 @@ module Eth
 
   # The {Eth::Address} class to handle checksummed Ethereum addresses.
   class Address
+
+    # The literal zero address 0x0.
     ZERO = "0x0000000000000000000000000000000000000000"
 
     # Provides a special checksum error if EIP-55 is violated.

lib/eth/chain.rb

@@ -149,11 +149,16 @@ class ReplayProtectionError < StandardError; end
     # Chain ID for Arbitrum Goerli testnet.
     GOERLI_ARBITRUM = 421613.freeze
 
+    # Chain ID for Hoodi testnet.
+    HOODI = 560048.freeze
+
     # Chain ID for Sepolia testnet.
     SEPOLIA = 11155111.freeze
 
     # Chain ID for Holesovice testnet.
     HOLESOVICE = 11166111.freeze
+
+    # Chain ID for Holesovice testnet.
     HOLESKY = HOLESOVICE
 
     # Chain ID for the geth private network preset.

lib/eth/contract/event.rb

@@ -14,6 +14,7 @@
 
 # -*- encoding : ascii-8bit -*-
 
+# Provides the {Eth} module.
 module Eth
   # Provide classes for contract event.
   class Contract::Event
@@ -73,7 +74,6 @@ def set_address(address)
       @address = address ? Eth::Address.new(address).address : nil
     end
 
-
     # Decodes event parameters from logs.
     #
     # @param topics [Array<String>] The list of log topics, including the event selector.
@@ -90,8 +90,8 @@ def decode_params(topics, data = "0x")
           result
         end,
         **Hash[non_indexed_inputs.map { _1["name"] }.zip(
-          Eth::Abi.decode(non_indexed_inputs.map { |i| i["type"] }, data)
-        )],
+                 Eth::Abi.decode(non_indexed_inputs.map { |i| i["type"] }, data)
+               )],
       }
     end
 
@@ -107,4 +107,3 @@ def type_name(x)
     end
   end
 end
-# Provides the {Eth} module.

lib/eth/tx.rb

@@ -73,6 +73,9 @@ class ParameterError < TypeError; end
     # The EIP-1559 transaction type is 2.
     TYPE_1559 = 0x02.freeze
 
+    # The EIP-4844 transaction type is 3.
+    TYPE_4844 = 0x03.freeze
+
     # The EIP-7702 transaction type is 4.
     TYPE_7702 = 0x04.freeze
 
@@ -84,18 +87,23 @@ class ParameterError < TypeError; end
 
     # Creates a new transaction of any type for given parameters and chain ID.
     # Required parameters are (optional in brackets):
-    # - EIP-7702: chain_id, nonce, priority_fee, max_gas_fee, gas_limit, authorizations(, from, to,
-    #   value, data, access_list)
     # - EIP-1559: chain_id, nonce, priority_fee, max_gas_fee, gas_limit(, from, to,
     #   value, data, access_list)
     # - EIP-2930: chain_id, nonce, gas_price, gas_limit, access_list(, from, to,
     #   value, data)
+    # - EIP-7702: chain_id, nonce, priority_fee, max_gas_fee, gas_limit, authorizations(, from, to,
+    #   value, data, access_list)
     # - Legacy: nonce, gas_price, gas_limit(, from, to, value, data)
     #
     # @param params [Hash] all necessary transaction fields.
     # @param chain_id [Integer] the EIP-155 Chain ID (legacy transactions only).
     def new(params, chain_id = Chain::ETHEREUM)
 
+      # if we deal with blobs, attempt EIP-4844 (not implemented)
+      unless params[:max_fee_per_blob_gas].nil?
+        raise NotimplementedError, "EIP-4844 blob transactions are not implemented"
+      end
+
       # if we deal with authorizations, attempt EIP-7702
       unless params[:authorization_list].nil?
         params[:chain_id] = chain_id if params[:chain_id].nil?
@@ -129,10 +137,6 @@ def decode(hex)
       type = hex[0, 2].to_i(16)
 
       case type
-      when TYPE_7702
-
-        # EIP-1559 transaction (type 2)
-        return Tx::Eip7702.decode hex
       when TYPE_1559
 
         # EIP-1559 transaction (type 2)
@@ -141,6 +145,14 @@ def decode(hex)
 
         # EIP-2930 transaction (type 1)
         return Tx::Eip2930.decode hex
+      when TYPE_4844
+
+        # EIP-4844 transaction (type 3)
+        raise NotimplementedError, "EIP-4844 blob transactions are not implemented"
+      when TYPE_7702
+
+        # EIP-7702 transaction (type 4)
+        return Tx::Eip7702.decode hex
       else
 
         # Legacy transaction if first byte is RLP (>= 192)
@@ -159,8 +171,6 @@ def decode(hex)
     # @raise [TransactionTypeError] if the transaction type is unknown.
     def unsigned_copy(tx)
       case tx.type
-      when TYPE_7702
-        return Tx::Eip7702.unsigned_copy tx
       when TYPE_1559
 
         # EIP-1559 transaction (type 2)
@@ -169,6 +179,14 @@ def unsigned_copy(tx)
 
         # EIP-2930 transaction (type 1)
         return Tx::Eip2930.unsigned_copy tx
+      when TYPE_4844
+
+        # EIP-4844 transaction (type 3)
+        raise NotimplementedError, "EIP-4844 blob transactions are not implemented"
+      when TYPE_7702
+
+        # EIP-7702 transaction (type 4)
+        return Tx::Eip7702.unsigned_copy tx
       when TYPE_LEGACY
 
         # Legacy transaction ("type 0")

lib/eth/tx/eip7702.rb

@@ -22,11 +22,19 @@ module Tx
     # types and envelopes.
     # Ref: https://eips.ethereum.org/EIPS/eip-7702
     class Eip7702
+
+      # Provides an EIP-7702 authorization that store the address to
+      # code which the signer desires to execute in the context of their EOA.
       class Authorization
+
+        # The EIP-155 Chain ID.
+        # Ref: https://eips.ethereum.org/EIPS/eip-155
         attr_reader :chain_id
 
+        # The authority addess.
         attr_reader :address
 
+        # The transaction nonce.
         attr_reader :nonce
 
         # The signature's y-parity byte (not v).
@@ -38,6 +46,14 @@ class Authorization
         # The signature `s` value.
         attr_reader :signature_s
 
+        # Create a type-4 (EIP-7702) authorization object that
+        # can be prepared for type-4 transactions.
+        # Ref: https://eips.ethereum.org/EIPS/eip-7702
+        #
+        # @param fields [Hash] all necessary transaction fields.
+        # @option fields [Integer] :chain_id the chain ID.
+        # @option fields [Eth::Address] :address the authority address.
+        # @option fields [Integer] :nonce the transaction nonce.
         def initialize(fields)
           @chain_id = fields[:chain_id].to_i
           @address = fields[:address].to_s
@@ -75,6 +91,9 @@ def sign(key)
           return hash
         end
 
+        # Encodes the unsigned authorization payload required for signing.
+        #
+        # @return [String] an RLP-encoded, unsigned, enveloped EIP-7702 transaction.
         def unsigned_encoded
           authorization_data = []
           authorization_data.push Util.serialize_int_to_big_endian @chain_id
@@ -83,10 +102,16 @@ def unsigned_encoded
           Rlp.encode authorization_data
         end
 
+        # Gets the sign-hash required to sign.
+        #
+        # @return [String] a Keccak-256 hash.
         def unsigned_hash
           Util.keccak256 unsigned_encoded
         end
 
+        # Gets the raw serialized authorization data.
+        #
+        # @return [Bytes] raw serialized authorization data.
         def raw
           authorization_data = []
           authorization_data.push Util.serialize_int_to_big_endian @chain_id
@@ -99,6 +124,9 @@ def raw
           authorization_data
         end
 
+        # Compares two authorization data objects.
+        #
+        # @return [Bool] true if objects are same and share same state.
         def ==(o)
           o.class == self.class && o.state == state
         end
@@ -139,7 +167,7 @@ def state
       # Ref: https://eips.ethereum.org/EIPS/eip-2930
       attr_reader :access_list
 
-      # The list of authorizations (a list of Eth::Tx::Eip7702::Authorization instances)
+      # The list of of {Authorization} instances
       attr_reader :authorization_list
 
       # The signature's y-parity byte (not v).

spec/eth/chain_spec.rb

@@ -48,6 +48,7 @@
       expect(Chain::MUMBAI).to eq 80001
       expect(Chain::RINKEBY_ARBITRUM).to eq 421611
       expect(Chain::GOERLI_ARBITRUM).to eq 421613
+      expect(Chain::HOODI).to eq 560048
       expect(Chain::SEPOLIA).to eq 11155111
       expect(Chain::HOLESOVICE).to eq 11166111
       expect(Chain::HOLESKY).to eq 11166111

spec/eth/contract/event_spec.rb

@@ -103,8 +103,9 @@
           { "indexed" => true, "name" => "collection", "type" => "address" },
           { "indexed" => true, "name" => "tokenId", "type" => "uint256" },
           { "indexed" => true, "name" => "ipfsHash", "type" => "bytes32" },
-          { "indexed" => false, "name" => "to", "type" => "address" }
-        ]
+          { "indexed" => false, "name" => "to", "type" => "address" },
+        ],
+        "type" => "tuple",
       })
     end
 
@@ -126,6 +127,15 @@
       "0x000000000000000000000000f0d00750656f12ab7550bf5039d74691f9e461f0"
     end
 
+    it "correctly serves accessors" do
+      expect(event.name).to eq "TokenMint"
+      expect(event.input_types).to eq ["address", "uint256", "bytes32", "address"]
+      expect(event.inputs).to eq ["collection", "tokenId", "ipfsHash", "to"]
+      expect(event.event_string).to eq "TokenMint(address,uint256,bytes32,address)"
+      expect(event.signature).to eq Util.remove_hex_prefix topics.first
+      expect(event.address).to be_nil
+    end
+
     it "correctly decodes the event parameters" do
       decoded = event.decode_params(
         topics,