++

Author: tac0turtle

crates/ev-precompiles/src/inspector_gate.rs

@@ -1,4 +1,7 @@
-use crate::config::MintConfig;
+use crate::{
+    config::MintConfig,
+    mint_precompile::{parse_operation, Operation},
+};
 use alloy_primitives::{Address, U256};
 use revm::{
     context_interface::{ContextTr, JournalTr},
@@ -13,6 +16,7 @@ pub struct MintInspector {
     per_call_cap: U256,
     per_block_cap: Option<U256>,
     minted_this_block: U256,
+    burned_this_block: U256,
 }
 
 impl MintInspector {
@@ -23,10 +27,12 @@ impl MintInspector {
             per_call_cap: config.per_call_cap,
             per_block_cap: config.per_block_cap,
             minted_this_block: U256::ZERO,
+            burned_this_block: U256::ZERO,
         }
     }
 
-    const MINT_CALLDATA_LEN: usize = 20 + 32;
+    const MINT_CALLDATA_LEN: usize = 4 + 20 + 32; // selector + address + amount
+    const BURN_CALLDATA_LEN: usize = 4 + 32; // selector + amount
 
     fn revert_outcome(message: &str, inputs: &CallInputs) -> CallOutcome {
         CallOutcome::new(
@@ -58,18 +64,42 @@ where
         }
 
         let calldata = inputs.input.bytes(context);
-        if calldata.len() != Self::MINT_CALLDATA_LEN {
-            return Some(Self::revert_outcome("invalid input length", inputs));
-        }
-
-        let amount = U256::from_be_slice(&calldata[20..Self::MINT_CALLDATA_LEN]);
-        if amount > self.per_call_cap {
-            return Some(Self::revert_outcome("over per-call cap", inputs));
-        }
 
-        if let Some(cap) = self.per_block_cap {
-            if self.minted_this_block + amount > cap {
-                return Some(Self::revert_outcome("over per-block cap", inputs));
+        // Parse operation type
+        let operation = match parse_operation(&calldata) {
+            Ok(op) => op,
+            Err(_) => return Some(Self::revert_outcome("invalid operation", inputs)),
+        };
+
+        // Validate length based on operation
+        match operation {
+            Operation::Mint => {
+                if calldata.len() != Self::MINT_CALLDATA_LEN {
+                    return Some(Self::revert_outcome("invalid mint input length", inputs));
+                }
+                let amount = U256::from_be_slice(&calldata[24..Self::MINT_CALLDATA_LEN]);
+                if amount > self.per_call_cap {
+                    return Some(Self::revert_outcome("over per-call cap", inputs));
+                }
+                if let Some(cap) = self.per_block_cap {
+                    if self.minted_this_block + amount > cap {
+                        return Some(Self::revert_outcome("over per-block cap", inputs));
+                    }
+                }
+            }
+            Operation::Burn => {
+                if calldata.len() != Self::BURN_CALLDATA_LEN {
+                    return Some(Self::revert_outcome("invalid burn input length", inputs));
+                }
+                let amount = U256::from_be_slice(&calldata[4..Self::BURN_CALLDATA_LEN]);
+                if amount > self.per_call_cap {
+                    return Some(Self::revert_outcome("over per-call cap", inputs));
+                }
+                if let Some(cap) = self.per_block_cap {
+                    if self.burned_this_block + amount > cap {
+                        return Some(Self::revert_outcome("over per-block cap", inputs));
+                    }
+                }
             }
         }
 
@@ -82,24 +112,63 @@ where
         }
 
         let calldata = inputs.input.bytes(context);
-        if calldata.len() != Self::MINT_CALLDATA_LEN {
-            outcome.result = Self::revert_result("invalid input length");
-            return;
-        }
-
-        let to = Address::from_slice(&calldata[..20]);
-        let amount = U256::from_be_slice(&calldata[20..Self::MINT_CALLDATA_LEN]);
 
-        match context.journal_mut().load_account(to) {
-            Ok(mut account_load) => {
-                account_load.info.balance += amount;
-            }
+        // Parse operation type
+        let operation = match parse_operation(&calldata) {
+            Ok(op) => op,
             Err(_) => {
-                outcome.result = Self::revert_result("account load failed");
+                outcome.result = Self::revert_result("invalid operation");
                 return;
             }
+        };
+
+        match operation {
+            Operation::Mint => {
+                if calldata.len() != Self::MINT_CALLDATA_LEN {
+                    outcome.result = Self::revert_result("invalid mint input length");
+                    return;
+                }
+
+                let to = Address::from_slice(&calldata[4..24]);
+                let amount = U256::from_be_slice(&calldata[24..Self::MINT_CALLDATA_LEN]);
+
+                match context.journal_mut().load_account(to) {
+                    Ok(mut account_load) => {
+                        account_load.info.balance += amount;
+                    }
+                    Err(_) => {
+                        outcome.result = Self::revert_result("account load failed");
+                        return;
+                    }
+                }
+
+                self.minted_this_block += amount;
+            }
+            Operation::Burn => {
+                if calldata.len() != Self::BURN_CALLDATA_LEN {
+                    outcome.result = Self::revert_result("invalid burn input length");
+                    return;
+                }
+
+                let amount = U256::from_be_slice(&calldata[4..Self::BURN_CALLDATA_LEN]);
+
+                // Burn from caller's balance
+                match context.journal_mut().load_account(inputs.caller) {
+                    Ok(mut account_load) => {
+                        if account_load.info.balance < amount {
+                            outcome.result = Self::revert_result("insufficient balance");
+                            return;
+                        }
+                        account_load.info.balance -= amount;
+                    }
+                    Err(_) => {
+                        outcome.result = Self::revert_result("account load failed");
+                        return;
+                    }
+                }
+
+                self.burned_this_block += amount;
+            }
         }
-
-        self.minted_this_block += amount;
     }
 }

crates/ev-precompiles/src/mint_precompile.rs

@@ -1,21 +1,87 @@
 use alloy_primitives::Bytes;
 use revm::precompile::{PrecompileError, PrecompileOutput, PrecompileResult};
 
-/// The gas cost for the native mint precompile.
-pub const NATIVE_MINT_PRECOMPILE_GAS_COST: u64 = 5_000;
+/// The gas cost for the native mint/burn precompile.
+pub const NATIVE_MINT_BURN_PRECOMPILE_GAS_COST: u64 = 5_000;
 
-/// A stateless precompile for minting the native token.
-pub fn native_mint(input: &[u8], gas_limit: u64) -> PrecompileResult {
-    if gas_limit < NATIVE_MINT_PRECOMPILE_GAS_COST {
+/// Function selectors (first 4 bytes of keccak256 hash)
+/// mint(address,uint256) -> 0x40c10f19
+const MINT_SELECTOR: [u8; 4] = [0x40, 0xc1, 0x0f, 0x19];
+/// burn(uint256) -> 0x42966c68
+const BURN_SELECTOR: [u8; 4] = [0x42, 0x96, 0x6c, 0x68];
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Operation {
+    Mint,
+    Burn,
+}
+
+/// A stateless precompile for minting and burning the native token.
+///
+/// Supports two operations via function selectors:
+///
+/// **mint(address,uint256)** - Mints tokens to a specified address
+/// - Selector: 0x40c10f19
+/// - Input: 4 bytes selector + 20 bytes address + 32 bytes amount (56 bytes total)
+/// - Effect: Increases balance of target address by amount
+///
+/// **burn(uint256)** - Burns tokens from the caller's balance
+/// - Selector: 0x42966c68
+/// - Input: 4 bytes selector + 32 bytes amount (36 bytes total)
+/// - Effect: Decreases caller's balance by amount
+pub fn native_mint_burn(input: &[u8], gas_limit: u64) -> PrecompileResult {
+    if gas_limit < NATIVE_MINT_BURN_PRECOMPILE_GAS_COST {
         return Err(PrecompileError::OutOfGas);
     }
 
-    if input.len() != 52 {
-        return Err(PrecompileError::Other("invalid input length".to_string()));
+    if input.len() < 4 {
+        return Err(PrecompileError::Other("input too short".to_string()));
+    }
+
+    let selector = &input[0..4];
+
+    match selector {
+        s if s == MINT_SELECTOR => {
+            // mint(address,uint256) - expects 56 bytes total
+            if input.len() != 56 {
+                return Err(PrecompileError::Other(
+                    "invalid mint input length".to_string(),
+                ));
+            }
+        }
+        s if s == BURN_SELECTOR => {
+            // burn(uint256) - expects 36 bytes total
+            if input.len() != 36 {
+                return Err(PrecompileError::Other(
+                    "invalid burn input length".to_string(),
+                ));
+            }
+        }
+        _ => {
+            return Err(PrecompileError::Other(
+                "unknown function selector".to_string(),
+            ));
+        }
     }
 
     Ok(PrecompileOutput::new(
-        NATIVE_MINT_PRECOMPILE_GAS_COST,
+        NATIVE_MINT_BURN_PRECOMPILE_GAS_COST,
         Bytes::new(),
     ))
 }
+
+/// Parse the operation type from input
+pub fn parse_operation(input: &[u8]) -> Result<Operation, PrecompileError> {
+    if input.len() < 4 {
+        return Err(PrecompileError::Other("input too short".to_string()));
+    }
+
+    let selector = &input[0..4];
+    match selector {
+        s if s == MINT_SELECTOR => Ok(Operation::Mint),
+        s if s == BURN_SELECTOR => Ok(Operation::Burn),
+        _ => Err(PrecompileError::Other(
+            "unknown function selector".to_string(),
+        )),
+    }
+}