On `deserialization error: invalid value: string "0x2d79dd80ff729c000"`

[0xOmarA]

When running transactions against kitchensink the flow (not the tx submission itself, but somewhere in the flow) fails with the following error:

2025-07-11T06:25:15.322799Z ERROR alloy_provider::blocks: failed to fetch block, number: 0, err: deserialization error: invalid value: string "0x2d79dd80ff729c000", expected a 8 byte hex string at line 1 column 1369
    at alloy-provider-1.0.9/src/blocks.rs:164 on tokio-runtime-worker ThreadId(81)
    in revive_dt_node::geth::Submitting transaction with transaction: TransactionRequest { from: Some(0x90f8bf6a479f320ead074411a4b0e7944ea8c9c1), to: Some(Create), gas_price: Some(5000000), max_fee_per_gas: None, max_priority_fee_per_gas: None, max_fee_per_blob_gas: None, gas: Some(5000000), value: None, input: TransactionInput { input: Some(0x36303830383036303430353233343630313435373562363065323930383136303139383233396633356235663830666466653630383036303034333631303135363030653537356235663830666435623566333536306530316336333039613331656134313436303231353735623566383066643562333436306138353735623630323036303033313933363031313236306134353735623336363032333132313536306130353735623630323038313031383138313130363766666666666666666666666666666666383231313137363038633537356236303430353238303930333636303234313136303838353735623630323039313630303439303562363032343832313036303739353735623530353035313630343035313930383135326633356238333830393138333335383135323031393130313930363036363536356235663830666435623633346534383762373136306530316235663532363034313630303435323630323435666664356235663830666435623566383066643562356638306664666561323634363937303636373335383232313232303736636533313630616337646137326631373331633936613464343965636136653263363663326464633866393436646338393239623430656666303265303636343733366636633633343330303038316430303333), data: None }, nonce: Some(0), chain_id: Some(420420420), access_list: None, transaction_type: None, blob_versioned_hashes: None, sidecar: None, authorization_list: None }

Digging a little bit more in the logs, we can see that this was the JSON response of the RPC when alloy was attempting to get information about a certain block, which we can see here:

2025-07-11T06:32:45.956011Z TRACE alloy_json_rpc::result: deserializing response, ty: core::option::Option<alloy_rpc_types_eth::block::Block>, json: {"baseFeePerGas":"0x3e8","difficulty":"0x0","extraData":"0x","gasLimit":"0x2d79dd80ff729c000","gasUsed":"0x0","hash":"0x3c2026eabebb20d6727479c2dbe522748566a2abdcba39e31fc5bb7a78da79f5","logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","miner":"0x0000000000000000000000000000000000000000","mixHash":"0x0000000000000000000000000000000000000000000000000000000000000000","nonce":"0x0000000000000000","number":"0x0","parentHash":"0x0000000000000000000000000000000000000000000000000000000000000000","receiptsRoot":"0x03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314","sha3Uncles":"0x0000000000000000000000000000000000000000000000000000000000000000","size":"0x0","stateRoot":"0xa6928950b301794fda56c470dd79d9e4869afb92a9ef8f868bab3d29a32fab05","timestamp":"0x0","transactions":[],"transactionsRoot":"0x03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314","uncles":[]}
    at alloy-json-rpc-1.0.9/src/result.rs:63 on tokio-runtime-worker ThreadId(92)
    in revive_dt_node::geth::Awaiting transaction receipt with transaction_hash: 0xce436093b27ecf1f1c6b65a0458dc8a9a059470b54e996b858ede8d1e344b932
    in revive_dt_node::geth::Submitting transaction with transaction: TransactionRequest { from: Some(0x90f8bf6a479f320ead074411a4b0e7944ea8c9c1), to: Some(Create), gas_price: Some(5000000), max_fee_per_gas: None, max_priority_fee_per_gas: None, max_fee_per_blob_gas: None, gas: Some(5000000), value: None, input: TransactionInput { input: Some(0x363038303830363034303532333436303136353735623631303133323930383136313030316238323339663335623566383066646665363038303830363034303532363030343336313031353630313235373562356638306664356235663335363065303163363364373364333666373134363032353537356235663830666435623334363066383537356236303430363030333139333630313132363066343537356233363630323431313630663035373562363032343335363030313830363061303162303338313136383039313134313536306563353735623831363032343831363032303933363330323638633761393630653231623832353238343630303438303834303133373561666138303135363065313537356235663930363038333537356236303230393036303430353139303831353266333562353036303230336436303230313136306462353735623630316631393630316638323031313638323031383238313130363766666666666666666666666666666666383231313137363063373537356236303230393138333931363034303532383130313033313236306333353735623630323039303531363037383536356235663830666435623633346534383762373136306530316235663532363034313630303435323630323435666664356235303364363038653536356236303430353133643566383233653364393066643562356638306664356235663830666435623566383066643562356638306664666561323634363937303636373335383232313232303630366562336238376335393562353166306664303736313861376661303735373233313936393135386666646264646564656237313164656666323930316536343733366636633633343330303038316430303333), data: None }, nonce: Some(1), chain_id: Some(420420420), access_list: None, transaction_type: None, blob_versioned_hashes: None, sidecar: None, authorization_list: None }

Sadly, alloy attempts to decode the gasLimit into a u64, which in this case fails since our gasLimit has 9 bytes, which is one more than the 8 bytes that can be represented by a u64. This is despite the EIP mentioning nothing about how many bytes should be in a Quantity.

One way that we can fix this is by adding a custom kitchensink network, which alloy already has support for. We would use identical types for everything except for the gas_limit field of the block, it would use a u128 instead of a u64. I believe that if we did that then this issue of invalid value: string "0x2d79dd80ff729c000", expected a 8 byte hex string would be solved.

Note

I opened this issue just to have a written understanding of the issue, it's causes, and what we can potentially do in order to fix it so that it's not forgotten. Discussion is welcome.

[0xOmarA]

I think that I've been able to resolve this issue indeed with a custom network definition for Kitchensink that uses u128 for the gas limit:

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
struct KitchenSinkNetwork;

impl Network for KitchenSinkNetwork {
    type TxType = <Ethereum as Network>::TxType;

    type TxEnvelope = <Ethereum as Network>::TxEnvelope;

    type UnsignedTx = <Ethereum as Network>::UnsignedTx;

    type ReceiptEnvelope = <Ethereum as Network>::ReceiptEnvelope;

    type Header = KitchenSinkHeader;

    type TransactionRequest = <Ethereum as Network>::TransactionRequest;

    type TransactionResponse = <Ethereum as Network>::TransactionResponse;

    type ReceiptResponse = <Ethereum as Network>::ReceiptResponse;

    type HeaderResponse = Header<KitchenSinkHeader>;

    type BlockResponse = Block<Transaction<TxEnvelope>, Header<KitchenSinkHeader>>;
}

impl TransactionBuilder<KitchenSinkNetwork> for <Ethereum as Network>::TransactionRequest {
    fn chain_id(&self) -> Option<alloy::primitives::ChainId> {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::chain_id(self)
    }

    fn set_chain_id(&mut self, chain_id: alloy::primitives::ChainId) {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_chain_id(
            self, chain_id,
        )
    }

    fn nonce(&self) -> Option<u64> {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::nonce(self)
    }

    fn set_nonce(&mut self, nonce: u64) {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_nonce(
            self, nonce,
        )
    }

    fn input(&self) -> Option<&alloy::primitives::Bytes> {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::input(self)
    }

    fn set_input<T: Into<alloy::primitives::Bytes>>(&mut self, input: T) {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_input(
            self, input,
        )
    }

    fn from(&self) -> Option<Address> {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::from(
            self,
        )
    }

    fn set_from(&mut self, from: Address) {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_from(
            self, from
        )
    }

    fn kind(&self) -> Option<alloy::primitives::TxKind> {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::kind(
            self,
        )
    }

    fn clear_kind(&mut self) {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::clear_kind(
            self,
        )
    }

    fn set_kind(&mut self, kind: alloy::primitives::TxKind) {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_kind(
            self, kind
        )
    }

    fn value(&self) -> Option<alloy::primitives::U256> {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::value(
            self
        )
    }

    fn set_value(&mut self, value: alloy::primitives::U256) {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_value(
            self, value
        )
    }

    fn gas_price(&self) -> Option<u128> {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::gas_price(
            self,
        )
    }

    fn set_gas_price(&mut self, gas_price: u128) {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_gas_price(
            self, gas_price
        )
    }

    fn max_fee_per_gas(&self) -> Option<u128> {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::max_fee_per_gas(
            self, 
        )
    }

    fn set_max_fee_per_gas(&mut self, max_fee_per_gas: u128) {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_max_fee_per_gas(
            self, max_fee_per_gas
        )
    }

    fn max_priority_fee_per_gas(&self) -> Option<u128> {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::max_priority_fee_per_gas(
            self, 
        )
    }

    fn set_max_priority_fee_per_gas(&mut self, max_priority_fee_per_gas: u128) {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_max_priority_fee_per_gas(
            self, max_priority_fee_per_gas
        )
    }

    // Sadly this can't be changed since it's a trait that we need to implement and therefore we're stuck to u64s here.
    fn gas_limit(&self) -> Option<u64> {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::gas_limit(
            self, 
        )
    }

    // Sadly this can't be changed since it's a trait that we need to implement and therefore we're stuck to u64s here.
    fn set_gas_limit(&mut self, gas_limit: u64) {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_gas_limit(
            self, gas_limit
        )
    }

    fn access_list(&self) -> Option<&alloy::rpc::types::AccessList> {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::access_list(
            self, 
        )
    }

    fn set_access_list(&mut self, access_list: alloy::rpc::types::AccessList) {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_access_list(
            self, access_list
        )
    }

    fn complete_type(
        &self,
        ty: <KitchenSinkNetwork as Network>::TxType,
    ) -> Result<(), Vec<&'static str>> {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::complete_type(
            self, ty
        )
    }

    fn can_submit(&self) -> bool {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::can_submit(
            self, 
        )
    }

    fn can_build(&self) -> bool {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::can_build(
            self, 
        )
    }

    fn output_tx_type(&self) -> <KitchenSinkNetwork as Network>::TxType {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::output_tx_type(
            self, 
        )
    }

    fn output_tx_type_checked(&self) -> Option<<KitchenSinkNetwork as Network>::TxType> {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::output_tx_type_checked(
            self, 
        )
    }

    fn prep_for_submission(&mut self) {
        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::prep_for_submission(
            self, 
        )
    }

    fn build_unsigned(
        self,
    ) -> alloy::network::BuildResult<<KitchenSinkNetwork as Network>::UnsignedTx, KitchenSinkNetwork>
    {
        let result = <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::build_unsigned(
            self,
        );
        match result {
            Ok(unsigned_tx) => Ok(unsigned_tx),
            Err(UnbuiltTransactionError { request, error }) => {
                Err(UnbuiltTransactionError::<KitchenSinkNetwork> {
                    request: request,
                    error: match error {
                        TransactionBuilderError::InvalidTransactionRequest(tx_type, items) => {
                            TransactionBuilderError::InvalidTransactionRequest(tx_type, items)
                        }
                        TransactionBuilderError::UnsupportedSignatureType => {
                            TransactionBuilderError::UnsupportedSignatureType
                        }
                        TransactionBuilderError::Signer(error) => {
                            TransactionBuilderError::Signer(error)
                        }
                        TransactionBuilderError::Custom(error) => {
                            TransactionBuilderError::Custom(error)
                        }
                    },
                })
            }
        }
    }

    async fn build<W: alloy::network::NetworkWallet<KitchenSinkNetwork>>(
        self,
        wallet: &W,
    ) -> Result<
        <KitchenSinkNetwork as Network>::TxEnvelope,
        TransactionBuilderError<KitchenSinkNetwork>,
    > {
        Ok(wallet.sign_request(self).await?)
    }
}

#[derive(Clone, Debug, PartialEq, Eq, Hash)]
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct KitchenSinkHeader {
    /// The Keccak 256-bit hash of the parent
    /// block’s header, in its entirety; formally Hp.
    pub parent_hash: B256,
    /// The Keccak 256-bit hash of the ommers list portion of this block; formally Ho.
    #[serde(rename = "sha3Uncles", alias = "ommersHash")]
    pub ommers_hash: B256,
    /// The 160-bit address to which all fees collected from the successful mining of this block
    /// be transferred; formally Hc.
    #[serde(rename = "miner", alias = "beneficiary")]
    pub beneficiary: Address,
    /// The Keccak 256-bit hash of the root node of the state trie, after all transactions are
    /// executed and finalisations applied; formally Hr.
    pub state_root: B256,
    /// The Keccak 256-bit hash of the root node of the trie structure populated with each
    /// transaction in the transactions list portion of the block; formally Ht.
    pub transactions_root: B256,
    /// The Keccak 256-bit hash of the root node of the trie structure populated with the receipts
    /// of each transaction in the transactions list portion of the block; formally He.
    pub receipts_root: B256,
    /// The Bloom filter composed from indexable information (logger address and log topics)
    /// contained in each log entry from the receipt of each transaction in the transactions list;
    /// formally Hb.
    pub logs_bloom: Bloom,
    /// A scalar value corresponding to the difficulty level of this block. This can be calculated
    /// from the previous block’s difficulty level and the timestamp; formally Hd.
    pub difficulty: U256,
    /// A scalar value equal to the number of ancestor blocks. The genesis block has a number of
    /// zero; formally Hi.
    #[serde(with = "alloy::serde::quantity")]
    pub number: BlockNumber,
    /// A scalar value equal to the current limit of gas expenditure per block; formally Hl.
    // This is the change that makes alloy work with kitchensink
    #[serde(with = "alloy::serde::quantity")]
    pub gas_limit: u128,
    /// A scalar value equal to the total gas used in transactions in this block; formally Hg.
    #[serde(with = "alloy::serde::quantity")]
    pub gas_used: u64,
    /// A scalar value equal to the reasonable output of Unix’s time() at this block’s inception;
    /// formally Hs.
    #[serde(with = "alloy::serde::quantity")]
    pub timestamp: u64,
    /// An arbitrary byte array containing data relevant to this block. This must be 32 bytes or
    /// fewer; formally Hx.
    pub extra_data: Bytes,
    /// A 256-bit hash which, combined with the
    /// nonce, proves that a sufficient amount of computation has been carried out on this block;
    /// formally Hm.
    pub mix_hash: B256,
    /// A 64-bit value which, combined with the mixhash, proves that a sufficient amount of
    /// computation has been carried out on this block; formally Hn.
    pub nonce: B64,
    /// A scalar representing EIP1559 base fee which can move up or down each block according
    /// to a formula which is a function of gas used in parent block and gas target
    /// (block gas limit divided by elasticity multiplier) of parent block.
    /// The algorithm results in the base fee per gas increasing when blocks are
    /// above the gas target, and decreasing when blocks are below the gas target. The base fee per
    /// gas is burned.
    #[serde(
        default,
        with = "alloy::serde::quantity::opt",
        skip_serializing_if = "Option::is_none"
    )]
    pub base_fee_per_gas: Option<u64>,
    /// The Keccak 256-bit hash of the withdrawals list portion of this block.
    /// <https://eips.ethereum.org/EIPS/eip-4895>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub withdrawals_root: Option<B256>,
    /// The total amount of blob gas consumed by the transactions within the block, added in
    /// EIP-4844.
    #[serde(
        default,
        with = "alloy::serde::quantity::opt",
        skip_serializing_if = "Option::is_none"
    )]
    pub blob_gas_used: Option<u64>,
    /// A running total of blob gas consumed in excess of the target, prior to the block. Blocks
    /// with above-target blob gas consumption increase this value, blocks with below-target blob
    /// gas consumption decrease it (bounded at 0). This was added in EIP-4844.
    #[serde(
        default,
        with = "alloy::serde::quantity::opt",
        skip_serializing_if = "Option::is_none"
    )]
    pub excess_blob_gas: Option<u64>,
    /// The hash of the parent beacon block's root is included in execution blocks, as proposed by
    /// EIP-4788.
    ///
    /// This enables trust-minimized access to consensus state, supporting staking pools, bridges,
    /// and more.
    ///
    /// The beacon roots contract handles root storage, enhancing Ethereum's functionalities.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_beacon_block_root: Option<B256>,
    /// The Keccak 256-bit hash of the an RLP encoded list with each
    /// [EIP-7685] request in the block body.
    ///
    /// [EIP-7685]: https://eips.ethereum.org/EIPS/eip-7685
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requests_hash: Option<B256>,
}

impl BlockHeader for KitchenSinkHeader {
    fn parent_hash(&self) -> B256 {
        self.parent_hash
    }

    fn ommers_hash(&self) -> B256 {
        self.ommers_hash
    }

    fn beneficiary(&self) -> Address {
        self.beneficiary
    }

    fn state_root(&self) -> B256 {
        self.state_root
    }

    fn transactions_root(&self) -> B256 {
        self.transactions_root
    }

    fn receipts_root(&self) -> B256 {
        self.receipts_root
    }

    fn withdrawals_root(&self) -> Option<B256> {
        self.withdrawals_root
    }

    fn logs_bloom(&self) -> Bloom {
        self.logs_bloom
    }

    fn difficulty(&self) -> U256 {
        self.difficulty
    }

    fn number(&self) -> BlockNumber {
        self.number
    }

    fn gas_limit(&self) -> u64 {
        self.gas_limit.try_into().unwrap_or(u64::MAX)
    }

    fn gas_used(&self) -> u64 {
        self.gas_used
    }

    fn timestamp(&self) -> u64 {
        self.timestamp
    }

    fn mix_hash(&self) -> Option<B256> {
        Some(self.mix_hash)
    }

    fn nonce(&self) -> Option<B64> {
        Some(self.nonce)
    }

    fn base_fee_per_gas(&self) -> Option<u64> {
        self.base_fee_per_gas
    }

    fn blob_gas_used(&self) -> Option<u64> {
        self.blob_gas_used
    }

    fn excess_blob_gas(&self) -> Option<u64> {
        self.excess_blob_gas
    }

    fn parent_beacon_block_root(&self) -> Option<B256> {
        self.parent_beacon_block_root
    }

    fn requests_hash(&self) -> Option<B256> {
        self.requests_hash
    }

    fn extra_data(&self) -> &Bytes {
        &self.extra_data
    }
}

I should note that if we faced this issue when it's likely that other people in the ecosystem will also face this issue. So, it would be good for us to somehow make a library that includes our network definition so that users in the ecosystem can use alloy with our stack.

[0xOmarA]

This is fixed in #34. Will close this issue once #34 is merged.