FIP Implementation: Add support for EIP-7702 (Set Code for EOAs)

AGENTS.md

@@ -0,0 +1,15 @@
+# Agents Notes
+
+This repository inherits its agent workflow, conventions, and project guidance from the Lotus workstream.
+
+- For the canonical instructions, see `../lotus/AGENTS.md`.
+- Treat that document as the source of truth for coding style, review etiquette, CI expectations, and how agents should coordinate across repos in this workstream.
+
+Repo‑local quick notes:
+- Tests: `make test` (uses cargo-nextest across the workspace).
+- Lint: `make check` (clippy; warnings are errors).
+- Formatting: `make rustfmt`.
+- EIP‑7702 is always active in this bundle (no runtime NV gating).
+- EIP‑7702 design notes live at `../eip7702.md`.
+
+If there is any conflict between this file and `../lotus/AGENTS.md`, prefer the Lotus file.

Makefile

@@ -9,8 +9,10 @@ toolchain:
 	rustup show active-toolchain || rustup toolchain install
 .PHONY: toolchain
 
+NEXTEST_VERSION ?= 0.9.106
+
 install-nextest:
-	@command -v cargo-nextest >/dev/null 2>&1 || cargo install cargo-nextest --locked
+	@command -v cargo-nextest >/dev/null 2>&1 || cargo install cargo-nextest --version $(NEXTEST_VERSION) --locked
 .PHONY: install-nextest
 
 # Run cargo fmt
@@ -22,8 +24,8 @@ rustfmt: toolchain
 
 # Run cargo check
 check: toolchain
-	cargo clippy --all --all-targets -- -D warnings
-	cargo clippy --all -- -D warnings
+	SKIP_BUNDLE=1 cargo clippy --all --all-targets -- -D warnings
+	SKIP_BUNDLE=1 cargo clippy --all -- -D warnings
 
 # NOTE: nextest doesn't run doctests https://github.com/nextest-rs/nextest/issues/16,
 # enable once doc tests are added: `cargo test --doc`

actors/evm/Cargo.toml

@@ -29,6 +29,8 @@ fvm_ipld_encoding = { workspace = true }
 multihash-codetable = { workspace = true }
 frc42_dispatch = { workspace = true }
 fil_actors_evm_shared = { workspace = true }
+rlp = { workspace = true }
+fvm_ipld_hamt = { workspace = true }
 hex = { workspace = true }
 hex-literal = { workspace = true }
 substrate-bn = { workspace = true }

actors/evm/shared/src/eip7702.rs

@@ -0,0 +1,42 @@
+use crate::address::EthAddress;
+
+/// EIP-7702 bytecode magic prefix and version.
+pub const EIP7702_MAGIC: [u8; 2] = [0xEF, 0x01];
+pub const EIP7702_VERSION: u8 = 0x00;
+
+/// Returns true if code is an EIP-7702 delegation indicator: 0xEF 0x01 0x00 || 20-byte address.
+pub fn is_eip7702_code(code: &[u8]) -> bool {
+    code.len() == 23 && code[0..2] == EIP7702_MAGIC && code[2] == EIP7702_VERSION
+}
+
+/// Attempts to parse an EIP-7702 delegation indicator and return the embedded 20-byte address.
+pub fn eip7702_delegate_address(code: &[u8]) -> Option<EthAddress> {
+    if !is_eip7702_code(code) {
+        return None;
+    }
+    let mut addr = [0u8; 20];
+    addr.copy_from_slice(&code[3..23]);
+    Some(EthAddress(addr))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn detect_and_parse() {
+        let mut raw = vec![0u8; 23];
+        raw[0] = 0xEF;
+        raw[1] = 0x01;
+        raw[2] = 0x00;
+        for i in 0..20 {
+            raw[3 + i] = 0xAB;
+        }
+        assert!(is_eip7702_code(&raw));
+        let d = eip7702_delegate_address(&raw).unwrap();
+        assert_eq!(d, EthAddress([0xAB; 20]));
+        assert!(!is_eip7702_code(&raw[..10]));
+        let mut bad = raw.clone();
+        bad[1] = 0x00;
+        assert!(!is_eip7702_code(&bad));
+    }
+}

actors/evm/shared/src/lib.rs

@@ -1,2 +1,3 @@
 pub mod address;
+pub mod eip7702;
 pub mod uints;

actors/evm/src/interpreter/instructions/call.rs

@@ -4,6 +4,7 @@ use fil_actors_evm_shared::{address::EthAddress, uints::U256};
 use fvm_ipld_encoding::BytesDe;
 use fvm_ipld_encoding::ipld_block::IpldBlock;
 use fvm_shared::{IPLD_RAW, MethodNum, address::Address, sys::SendFlags};
+use num_traits::Zero;
 
 use crate::interpreter::{
     CallKind,
@@ -200,6 +201,171 @@ pub fn call_generic<RT: Runtime>(
                         // We provide enough gas for the transfer to succeed in all case.
                         gas = TRANSFER_GAS_LIMIT;
                     }
+                    // EIP-7702: If destination is an EOA (Account/NotFound), consult internal mapping.
+                    if matches!(
+                        get_contract_type(system.rt, &dst),
+                        ContractType::Account | ContractType::NotFound
+                    )
+                        // Depth limit: do not follow delegation when already in authority context.
+                        && !system.in_authority_context
+                    {
+                        // EVM-only: consult internal mapping for 7702 delegation
+                        if let Some(delegate) = system.get_delegate(&dst) {
+                            // Delegate is expected to be an EVM contract. Resolve its code.
+                            match get_contract_type(system.rt, &delegate) {
+                                ContractType::EVM(delegate_addr) => {
+                                    if let Some(code_cid) =
+                                        get_evm_bytecode_cid(system, &delegate_addr)?
+                                    {
+                                        // Transfer any value to the EOA account first (unless readonly/static).
+                                        if !system.readonly && kind != CallKind::StaticCall {
+                                            let v = TokenAmount::from(&value);
+                                            if !v.is_zero() {
+                                                if let Err(e) = system.transfer(&dst_addr, v) {
+                                                    log::warn!(
+                                                        "value transfer to EOA {:?} failed: {}",
+                                                        dst_addr,
+                                                        e
+                                                    );
+                                                    return Ok(U256::from(0));
+                                                }
+                                            }
+                                        }
+
+                                        // Execute delegate bytecode with receiver bound to the EOA.
+                                        let params = crate::EoaInvokeParams {
+                                            code: code_cid,
+                                            input: input_data.into(),
+                                            caller: state.caller,
+                                            receiver: dst,
+                                            value: TokenAmount::from(&value),
+                                        };
+                                        let res = system.send(
+                                            &system.rt.message().receiver(),
+                                            crate::Method::InvokeAsEoa as u64,
+                                            IpldBlock::serialize_dag_cbor(&params)?,
+                                            TokenAmount::zero(),
+                                            Some(system.call_gas_limit(gas)),
+                                            SendFlags::default(),
+                                        );
+                                        match res {
+                                            Ok(Some(r)) => {
+                                                // Decode InvokeContractReturn { output_data } from InvokeAsEoa
+                                                #[derive(fvm_ipld_encoding::serde::Deserialize)]
+                                                struct InvokeContractReturn {
+                                                    output_data: Vec<u8>,
+                                                }
+                                                let data = r
+                                                    .deserialize::<InvokeContractReturn>()
+                                                    .map(|x| x.output_data)
+                                                    .unwrap_or_else(|_| r.data);
+                                                state.return_data = data;
+                                                // Emit an ETH-style log indicating delegated execution occurred.
+                                                use fvm_ipld_encoding::IPLD_RAW;
+                                                use fvm_shared::crypto::hash::SupportedHashes;
+                                                use fvm_shared::event::{Entry, Flags};
+                                                let topic = system.rt.hash(
+                                                    SupportedHashes::Keccak256,
+                                                    crate::DELEGATED_EVENT_TOPIC,
+                                                );
+                                                if topic.len() == 32 && !system.readonly {
+                                                    let entries: Vec<Entry> = vec![
+                                                        Entry {
+                                                            flags: Flags::FLAG_INDEXED_ALL,
+                                                            key: "t1".to_owned(),
+                                                            codec: IPLD_RAW,
+                                                            value: topic,
+                                                        },
+                                                        Entry {
+                                                            flags: Flags::FLAG_INDEXED_ALL,
+                                                            key: "d".to_owned(),
+                                                            codec: IPLD_RAW,
+                                                            // Emit the authority (EOA) address, not the delegate.
+                                                            value: dst.as_ref().to_vec(),
+                                                        },
+                                                    ];
+                                                    let _ = system.rt.emit_event(&entries.into());
+                                                }
+                                                copy_to_memory(
+                                                    memory,
+                                                    output_offset,
+                                                    output_size,
+                                                    U256::zero(),
+                                                    &state.return_data,
+                                                    false,
+                                                )?;
+                                                return Ok(U256::from(1));
+                                            }
+                                            Ok(None) => {
+                                                // No return.
+                                                state.return_data = Vec::new();
+                                                // Emit delegated execution event without return data.
+                                                use fvm_ipld_encoding::IPLD_RAW;
+                                                use fvm_shared::crypto::hash::SupportedHashes;
+                                                use fvm_shared::event::{Entry, Flags};
+                                                let topic = system.rt.hash(
+                                                    SupportedHashes::Keccak256,
+                                                    crate::DELEGATED_EVENT_TOPIC,
+                                                );
+                                                if topic.len() == 32 && !system.readonly {
+                                                    let entries: Vec<Entry> = vec![
+                                                        Entry {
+                                                            flags: Flags::FLAG_INDEXED_ALL,
+                                                            key: "t1".to_owned(),
+                                                            codec: IPLD_RAW,
+                                                            value: topic,
+                                                        },
+                                                        Entry {
+                                                            flags: Flags::FLAG_INDEXED_ALL,
+                                                            key: "d".to_owned(),
+                                                            codec: IPLD_RAW,
+                                                            // Emit the authority (EOA) address, not the delegate.
+                                                            value: dst.as_ref().to_vec(),
+                                                        },
+                                                    ];
+                                                    let _ = system.rt.emit_event(&entries.into());
+                                                }
+                                                copy_to_memory(
+                                                    memory,
+                                                    output_offset,
+                                                    output_size,
+                                                    U256::zero(),
+                                                    &state.return_data,
+                                                    false,
+                                                )?;
+                                                return Ok(U256::from(1));
+                                            }
+                                            Err(mut ae) => {
+                                                // Reverted or error; map to 0 and propagate revert data to memory.
+                                                log::debug!("InvokeAsEoa failed (delegated CALL)");
+                                                state.return_data = ae
+                                                    .take_data()
+                                                    .map(|b| b.data)
+                                                    .unwrap_or_default();
+                                                copy_to_memory(
+                                                    memory,
+                                                    output_offset,
+                                                    output_size,
+                                                    U256::zero(),
+                                                    &state.return_data,
+                                                    false,
+                                                )?;
+                                                return Ok(U256::from(0));
+                                            }
+                                        }
+                                    } else {
+                                        // No code at delegate; treat as success with no-op.
+                                        return Ok(U256::from(1));
+                                    }
+                                }
+                                _ => {
+                                    // Delegate not an EVM contract; treat as no-op success.
+                                    return Ok(U256::from(1));
+                                }
+                            }
+                        }
+                        // Fallthrough: no delegation mapping
+                    }
                     let params = if input_data.is_empty() {
                         None
                     } else {
@@ -839,4 +1005,9 @@ mod tests {
             assert_eq!(&m.state.memory[0..4], &output_data);
         };
     }
+
+    // Depth limit functional test is implemented in ApplyAndCall-driven tests.
+
+    // Note: Depth limit is enforced in code by System.in_authority_context.
+    // A dedicated integration test can be added when a stable harness for nested delegation flows is available.
 }

actors/evm/src/interpreter/instructions/ext.rs

@@ -5,9 +5,11 @@ use cid::Cid;
 use fil_actors_evm_shared::address::EthAddress;
 use fil_actors_evm_shared::uints::U256;
 use fil_actors_runtime::ActorError;
+// Delegator removed; 7702 mapping is internal to EVM state.
 use fil_actors_runtime::runtime::builtins::Type;
 use fil_actors_runtime::{AsActorError, deserialize_block};
 use fvm_ipld_blockstore::Blockstore;
+use fvm_shared::crypto::hash::SupportedHashes;
 use fvm_shared::error::ExitCode;
 use fvm_shared::sys::SendFlags;
 use fvm_shared::{address::Address, econ::TokenAmount};
@@ -30,6 +32,13 @@ pub fn extcodesize(
             get_evm_bytecode(system, &addr).map(|bytecode| bytecode.len())?
         }
         ContractType::Native(_) => 1,
+        ContractType::Account => {
+            let authority = EthAddress::from(addr);
+            if system.get_delegate(&authority).is_some() {
+                return Ok(U256::from(23));
+            }
+            0
+        }
         // account, not found, and precompiles are 0 size
         _ => 0,
     };
@@ -52,7 +61,23 @@ pub fn extcodehash(
         //      The FVM does not have chain state cleanup so contracts will never end up "empty" and be removed, they will either exist (in any state in the contract lifecycle)
         //      and return keccak(""), or not exist (where nothing has ever been deployed at that address) and return 0.
         // TODO: With account abstraction, this may be something other than an empty hash!
-        ContractType::Account => return Ok(BytecodeHash::EMPTY.into()),
+        ContractType::Account => {
+            let authority = EthAddress::from(addr);
+            if let Some(d) = system.get_delegate(&authority) {
+                let mut bytecode = Vec::with_capacity(23);
+                bytecode.extend_from_slice(&fil_actors_evm_shared::eip7702::EIP7702_MAGIC);
+                bytecode.push(fil_actors_evm_shared::eip7702::EIP7702_VERSION);
+                bytecode.extend_from_slice(d.as_ref());
+                let hash_bytes = system.rt.hash(SupportedHashes::Keccak256, &bytecode);
+                let hash = BytecodeHash::try_from(hash_bytes.as_slice()).map_err(|_| {
+                    ActorError::illegal_state(
+                        "extcodehash: failed to convert keccak256 to BytecodeHash".into(),
+                    )
+                })?;
+                return Ok(hash.into());
+            }
+            return Ok(BytecodeHash::EMPTY.into());
+        }
         // Not found
         ContractType::NotFound => return Ok(U256::zero()),
     };
@@ -79,7 +104,19 @@ pub fn extcodecopy(
 ) -> Result<(), ActorError> {
     let bytecode = match get_contract_type(system.rt, &addr.into()) {
         ContractType::EVM(addr) => get_evm_bytecode(system, &addr)?,
-        ContractType::NotFound | ContractType::Account | ContractType::Precompile => Vec::new(),
+        ContractType::Account => {
+            let authority = EthAddress::from(addr);
+            if let Some(d) = system.get_delegate(&authority) {
+                let mut b = Vec::with_capacity(23);
+                b.extend_from_slice(&fil_actors_evm_shared::eip7702::EIP7702_MAGIC);
+                b.push(fil_actors_evm_shared::eip7702::EIP7702_VERSION);
+                b.extend_from_slice(d.as_ref());
+                b
+            } else {
+                Vec::new()
+            }
+        }
+        ContractType::NotFound | ContractType::Precompile => Vec::new(),
         // calling EXTCODECOPY on native actors results with a single byte 0xFE which solidtiy uses for its `assert`/`throw` methods
         // and in general invalid EVM bytecode
         _ => vec![0xFE],