Function send_protocol_params_transaction

node/src/bin/protocol_params.rs:312–384

(
    provider: &P,
    protocol_params_contract_address: Address,
    param_id: u8,
    param_value: Vec<u8>,
    nonce: u64,
)

            assert_eq!(epoch_length, new_epoch_length, "Epoch length should be {}", new_epoch_length);
            println!("Epoch length successfully updated to {}!", new_epoch_length);

            println!("Protocol parameter change test completed successfully!");

            Ok::<(), Box<dyn std::error::Error>>(())
        }
    })?;
    std::process::exit(0);
}

async fn send_protocol_params_transaction<P>(
    provider: &P,
    protocol_params_contract_address: Address,
    param_id: u8,
    param_value: Vec<u8>,
    nonce: u64,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
where
    P: Provider + WalletProvider,
{
    use alloy_primitives::keccak256;

    // ABI encode the function call: set_param(uint8 param_id, bytes calldata param)
    // Function selector is first 4 bytes of keccak256("set_param(uint8,bytes)")
    let function_selector = &keccak256("set_param(uint8,bytes)")[0..4];

    // ABI encoding:
    // - 4 bytes: function selector
    // - 32 bytes: param_id (uint8 left-padded to 32 bytes)
    // - 32 bytes: offset to bytes data (always 0x40 = 64 bytes from start of params)
    // - 32 bytes: length of bytes data
    // - N bytes: actual bytes data (padded to 32-byte boundary)

    let mut call_data = Vec::new();

    // Add function selector
    call_data.extend_from_slice(function_selector);

    // Add param_id (uint8 left-padded to 32 bytes)
    let mut param_id_bytes = [0u8; 32];
    param_id_bytes[31] = param_id;
    call_data.extend_from_slice(&param_id_bytes);

    // Add offset to bytes data (0x40 = 64 bytes from start of parameter encoding)
    let mut offset_bytes = [0u8; 32];
    offset_bytes[28..32].copy_from_slice(&64u32.to_be_bytes());
    call_data.extend_from_slice(&offset_bytes);

    // Add length of bytes data
    let mut length_bytes = [0u8; 32];
    length_bytes[28..32].copy_from_slice(&(param_value.len() as u32).to_be_bytes());
    call_data.extend_from_slice(&length_bytes);

    // Add the actual bytes data
    call_data.extend_from_slice(&param_value);

    // Pad to 32-byte boundary if needed
    let padding_needed = (32 - (param_value.len() % 32)) % 32;