native rust implementation also added for comparison out of interest

Author: bengtlofgren

svm/Cargo.lock

@@ -0,0 +1,23 @@
+[package]
+name = "executor-quoter-native"
+version = "0.1.0"
+description = "Executor Quoter Native - solana_program version for CU comparison"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "executor_quoter_native"
+
+[features]
+default = []
+no-entrypoint = []
+custom-heap = []
+custom-panic = []
+
+[dependencies]
+solana-program = "1.18"
+bytemuck = { version = "1.14", features = ["derive"] }
+
+[dev-dependencies]
+solana-program-test = "1.18"
+solana-sdk = "1.18"

svm/programs/executor-quoter-native/Cargo.toml

@@ -0,0 +1,37 @@
+use solana_program::program_error::ProgramError;
+
+/// Custom error codes for ExecutorQuoter program.
+/// Error codes start at 0x1000 to avoid collision with built-in errors.
+#[repr(u32)]
+pub enum ExecutorQuoterError {
+    /// Caller is not the authorized updater
+    InvalidUpdater = 0x1000,
+    /// Destination chain is not enabled
+    ChainDisabled = 0x1001,
+    /// Unsupported relay instruction type
+    UnsupportedInstruction = 0x1002,
+    /// Only one drop-off instruction is allowed
+    MoreThanOneDropOff = 0x1003,
+    /// Arithmetic overflow in quote calculation
+    MathOverflow = 0x1004,
+    /// Invalid relay instruction data
+    InvalidRelayInstructions = 0x1005,
+    /// Invalid PDA derivation
+    InvalidPda = 0x1006,
+    /// Account already initialized
+    AlreadyInitialized = 0x1007,
+    /// Account not initialized
+    NotInitialized = 0x1008,
+    /// Invalid account owner
+    InvalidOwner = 0x1009,
+    /// Invalid instruction data
+    InvalidInstructionData = 0x100A,
+    /// Invalid account discriminator
+    InvalidDiscriminator = 0x100B,
+}
+
+impl From<ExecutorQuoterError> for ProgramError {
+    fn from(e: ExecutorQuoterError) -> Self {
+        ProgramError::Custom(e as u32)
+    }
+}

svm/programs/executor-quoter-native/src/error.rs

@@ -0,0 +1,249 @@
+use solana_program::{
+    account_info::AccountInfo, entrypoint::ProgramResult, program::set_return_data,
+    program_error::ProgramError, pubkey::Pubkey,
+};
+
+use crate::{
+    error::ExecutorQuoterError,
+    math,
+    state::{load_account, ChainInfo, Config, QuoteBody},
+};
+
+/// Relay instruction type constants (matching EVM)
+const IX_TYPE_GAS: u8 = 1;
+const IX_TYPE_DROP_OFF: u8 = 2;
+
+/// Parses relay instructions to extract total gas limit and msg value.
+/// Instruction format:
+/// - Type 1 (Gas): 1 byte type + 16 bytes gas_limit + 16 bytes msg_value
+/// - Type 2 (DropOff): 1 byte type + 48 bytes (16 msg_value + 32 recipient)
+fn parse_relay_instructions(relay_instructions: &[u8]) -> Result<(u128, u128), ProgramError> {
+    let mut offset = 0;
+    let mut gas_limit: u128 = 0;
+    let mut msg_value: u128 = 0;
+    let mut has_drop_off = false;
+
+    while offset < relay_instructions.len() {
+        if offset >= relay_instructions.len() {
+            return Err(ExecutorQuoterError::InvalidRelayInstructions.into());
+        }
+
+        let ix_type = relay_instructions[offset];
+        offset += 1;
+
+        match ix_type {
+            IX_TYPE_GAS => {
+                // Gas instruction: 16 bytes gas_limit + 16 bytes msg_value
+                if offset + 32 > relay_instructions.len() {
+                    return Err(ExecutorQuoterError::InvalidRelayInstructions.into());
+                }
+
+                let mut ix_gas_bytes = [0u8; 16];
+                ix_gas_bytes.copy_from_slice(&relay_instructions[offset..offset + 16]);
+                let ix_gas_limit = u128::from_be_bytes(ix_gas_bytes);
+                offset += 16;
+
+                let mut ix_val_bytes = [0u8; 16];
+                ix_val_bytes.copy_from_slice(&relay_instructions[offset..offset + 16]);
+                let ix_msg_value = u128::from_be_bytes(ix_val_bytes);
+                offset += 16;
+
+                gas_limit = gas_limit
+                    .checked_add(ix_gas_limit)
+                    .ok_or(ExecutorQuoterError::MathOverflow)?;
+                msg_value = msg_value
+                    .checked_add(ix_msg_value)
+                    .ok_or(ExecutorQuoterError::MathOverflow)?;
+            }
+            IX_TYPE_DROP_OFF => {
+                if has_drop_off {
+                    return Err(ExecutorQuoterError::MoreThanOneDropOff.into());
+                }
+                has_drop_off = true;
+
+                // DropOff instruction: 16 bytes msg_value + 32 bytes recipient
+                if offset + 48 > relay_instructions.len() {
+                    return Err(ExecutorQuoterError::InvalidRelayInstructions.into());
+                }
+
+                let mut ix_val_bytes = [0u8; 16];
+                ix_val_bytes.copy_from_slice(&relay_instructions[offset..offset + 16]);
+                let ix_msg_value = u128::from_be_bytes(ix_val_bytes);
+                offset += 48; // Skip msg_value (16) + recipient (32)
+
+                msg_value = msg_value
+                    .checked_add(ix_msg_value)
+                    .ok_or(ExecutorQuoterError::MathOverflow)?;
+            }
+            _ => {
+                return Err(ExecutorQuoterError::UnsupportedInstruction.into());
+            }
+        }
+    }
+
+    Ok((gas_limit, msg_value))
+}
+
+/// Process RequestQuote instruction.
+/// Returns the required payment amount for cross-chain execution.
+///
+/// Accounts:
+/// 0. `[]` config - Config PDA
+/// 1. `[]` chain_info - ChainInfo PDA for destination chain
+/// 2. `[]` quote_body - QuoteBody PDA for destination chain
+///
+/// Instruction data layout:
+/// - dst_chain: u16 (offset 0)
+/// - dst_addr: [u8; 32] (offset 2)
+/// - refund_addr: [u8; 32] (offset 34)
+/// - request_bytes_len: u32 (offset 66)
+/// - request_bytes: [u8; request_bytes_len] (offset 70)
+/// - relay_instructions_len: u32 (offset 70 + request_bytes_len)
+/// - relay_instructions: [u8; relay_instructions_len]
+pub fn process_request_quote(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    data: &[u8],
+) -> ProgramResult {
+    // Parse accounts
+    let [config_account, chain_info_account, quote_body_account] = accounts else {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    };
+
+    // Load accounts (discriminator checked inside load_account)
+    // Config is validated but not used in requestQuote (only in requestExecutionQuote)
+    let _config = load_account::<Config>(config_account, program_id)?;
+
+    let chain_info = load_account::<ChainInfo>(chain_info_account, program_id)?;
+    if !chain_info.is_enabled() {
+        return Err(ExecutorQuoterError::ChainDisabled.into());
+    }
+
+    let quote_body = load_account::<QuoteBody>(quote_body_account, program_id)?;
+
+    // Parse instruction data to get relay_instructions
+    // Skip: dst_chain (2) + dst_addr (32) + refund_addr (32) = 66 bytes
+    if data.len() < 70 {
+        return Err(ExecutorQuoterError::InvalidInstructionData.into());
+    }
+
+    // Skip request_bytes
+    let mut len_bytes = [0u8; 4];
+    len_bytes.copy_from_slice(&data[66..70]);
+    let request_bytes_len = u32::from_le_bytes(len_bytes) as usize;
+    let relay_start = 70 + request_bytes_len;
+
+    if data.len() < relay_start + 4 {
+        return Err(ExecutorQuoterError::InvalidInstructionData.into());
+    }
+
+    let mut relay_len_bytes = [0u8; 4];
+    relay_len_bytes.copy_from_slice(&data[relay_start..relay_start + 4]);
+    let relay_instructions_len = u32::from_le_bytes(relay_len_bytes) as usize;
+
+    let relay_data_start = relay_start + 4;
+    if data.len() < relay_data_start + relay_instructions_len {
+        return Err(ExecutorQuoterError::InvalidInstructionData.into());
+    }
+
+    let relay_instructions = &data[relay_data_start..relay_data_start + relay_instructions_len];
+
+    // Parse relay instructions
+    let (gas_limit, msg_value) = parse_relay_instructions(relay_instructions)?;
+
+    // Calculate quote using U256 math
+    let required_payment = math::estimate_quote(
+        quote_body.base_fee,
+        quote_body.src_price,
+        quote_body.dst_price,
+        quote_body.dst_gas_price,
+        chain_info.gas_price_decimals,
+        chain_info.native_decimals,
+        gas_limit,
+        msg_value,
+    )?;
+
+    // Return the quote as big-endian U256 (32 bytes) via set_return_data.
+    // Clients can read this via simulateTransaction or CPI callers via get_return_data.
+    set_return_data(&required_payment.to_be_bytes());
+
+    Ok(())
+}
+
+/// Process RequestExecutionQuote instruction.
+/// Returns the required payment, payee address, and quote body.
+///
+/// Accounts: Same as RequestQuote
+pub fn process_request_execution_quote(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    data: &[u8],
+) -> ProgramResult {
+    // Parse accounts
+    let [config_account, chain_info_account, quote_body_account] = accounts else {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    };
+
+    // Load accounts (discriminator checked inside load_account)
+    let config = load_account::<Config>(config_account, program_id)?;
+
+    let chain_info = load_account::<ChainInfo>(chain_info_account, program_id)?;
+    if !chain_info.is_enabled() {
+        return Err(ExecutorQuoterError::ChainDisabled.into());
+    }
+
+    let quote_body = load_account::<QuoteBody>(quote_body_account, program_id)?;
+
+    // Parse instruction data to get relay_instructions
+    if data.len() < 70 {
+        return Err(ExecutorQuoterError::InvalidInstructionData.into());
+    }
+
+    let mut len_bytes = [0u8; 4];
+    len_bytes.copy_from_slice(&data[66..70]);
+    let request_bytes_len = u32::from_le_bytes(len_bytes) as usize;
+    let relay_start = 70 + request_bytes_len;
+
+    if data.len() < relay_start + 4 {
+        return Err(ExecutorQuoterError::InvalidInstructionData.into());
+    }
+
+    let mut relay_len_bytes = [0u8; 4];
+    relay_len_bytes.copy_from_slice(&data[relay_start..relay_start + 4]);
+    let relay_instructions_len = u32::from_le_bytes(relay_len_bytes) as usize;
+
+    let relay_data_start = relay_start + 4;
+    if data.len() < relay_data_start + relay_instructions_len {
+        return Err(ExecutorQuoterError::InvalidInstructionData.into());
+    }
+
+    let relay_instructions = &data[relay_data_start..relay_data_start + relay_instructions_len];
+
+    // Parse relay instructions
+    let (gas_limit, msg_value) = parse_relay_instructions(relay_instructions)?;
+
+    // Calculate quote using U256 math
+    let required_payment = math::estimate_quote(
+        quote_body.base_fee,
+        quote_body.src_price,
+        quote_body.dst_price,
+        quote_body.dst_gas_price,
+        chain_info.gas_price_decimals,
+        chain_info.native_decimals,
+        gas_limit,
+        msg_value,
+    )?;
+
+    // Return data layout (96 bytes, matching EVM return values):
+    // - bytes 0-31: required_payment (U256, big-endian)
+    // - bytes 32-63: payee_address (32 bytes)
+    // - bytes 64-95: quote_body (32 bytes, EQ01 format)
+    let mut return_data = [0u8; 96];
+    return_data[0..32].copy_from_slice(&required_payment.to_be_bytes());
+    return_data[32..64].copy_from_slice(&config.payee_address);
+    return_data[64..96].copy_from_slice(&quote_body.to_bytes32());
+
+    set_return_data(&return_data);
+
+    Ok(())
+}