# Pectra Support

### Overview

OPN Chain fully supports Ethereum's Pectra upgrade, bringing cutting-edge features and optimizations to developers. Pectra represents a major milestone in Ethereum's evolution, and OPN Chain ensures you can leverage these improvements immediately.

### What is Pectra?

Pectra is Ethereum's latest upgrade that combines the Prague (execution layer) and Electra (consensus layer) improvements. OPN Chain implements all execution layer changes, providing developers with the most advanced EVM features available.

### Key Features

#### EIP-7702: Set EOA Account Code

The most significant addition in Pectra, EIP-7702 allows Externally Owned Accounts (EOAs) to temporarily set contract code, enabling account abstraction without deploying separate contracts.

**Benefits:**

* Transform regular wallets into smart wallets
* Enable batched transactions from EOAs
* Add custom validation logic to accounts
* Implement social recovery mechanisms

**Example Implementation:**

```solidity
// Account code that can be set on an EOA
contract SmartWalletLogic {
    address public owner;
    mapping(address => bool) public guardians;
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }
    
    function execute(
        address target,
        uint256 value,
        bytes calldata data
    ) external onlyOwner returns (bytes memory) {
        (bool success, bytes memory result) = target.call{value: value}(data);
        require(success, "Execution failed");
        return result;
    }
    
    function batchExecute(
        address[] calldata targets,
        uint256[] calldata values,
        bytes[] calldata datas
    ) external onlyOwner {
        require(
            targets.length == values.length && 
            values.length == datas.length,
            "Length mismatch"
        );
        
        for (uint256 i = 0; i < targets.length; i++) {
            (bool success,) = targets[i].call{value: values[i]}(datas[i]);
            require(success, "Batch execution failed");
        }
    }
    
    function addGuardian(address guardian) external onlyOwner {
        guardians[guardian] = true;
    }
    
    function recover(address newOwner) external {
        require(guardians[msg.sender], "Not a guardian");
        owner = newOwner;
    }
}
```

**Setting Code on EOA:**

```javascript
// Using EIP-7702 to set code on an EOA
async function enableSmartWallet(walletLogicAddress) {
    const setCodeTx = {
        type: '0x7702', // New transaction type for EIP-7702
        to: walletLogicAddress,
        authorization: {
            chainId: 984,
            address: walletLogicAddress,
            nonce: await getNonce(account),
            // Signature from the EOA owner
            v, r, s
        },
        gasLimit: 100000,
        gasPrice: web3.utils.toWei('7', 'gwei')
    };
    
    const receipt = await web3.eth.sendTransaction(setCodeTx);
    console.log('EOA upgraded to smart wallet!');
}
```

#### Enhanced Opcodes

Pectra introduces several opcode improvements for better performance and new capabilities:

**TLOAD/TSTORE (Transient Storage):**

```solidity
contract TransientStorageExample {
    // Uses transient storage (cleared after transaction)
    // Much cheaper than regular storage
    
    function reentrancyGuardExample() external {
        // TLOAD: Load from transient storage
        assembly {
            if tload(0) { revert(0, 0) }
            tstore(0, 1) // TSTORE: Store in transient storage
        }
        
        // Do work...
        externalCall();
        
        // Clear guard (happens automatically after tx)
        assembly {
            tstore(0, 0)
        }
    }
}
```

**MCOPY (Memory Copy):**

```solidity
contract MemoryOptimization {
    function efficientCopy(bytes memory data) public pure returns (bytes memory) {
        bytes memory result = new bytes(data.length);
        
        assembly {
            // MCOPY: Efficient memory copy
            mcopy(add(result, 0x20), add(data, 0x20), mload(data))
        }
        
        return result;
    }
}
```

#### Gas Optimizations

Pectra includes significant gas cost reductions:

| Operation        | Pre-Pectra | Post-Pectra | Reduction |
| ---------------- | ---------- | ----------- | --------- |
| SLOAD (warm)     | 100 gas    | 100 gas     | 0%        |
| SLOAD (cold)     | 2100 gas   | 1900 gas    | \~10%     |
| Call with value  | 9000 gas   | 7600 gas    | \~15%     |
| Memory expansion | Quadratic  | Sub-linear  | Up to 50% |

**Optimized Contract Example:**

```solidity
contract GasOptimized {
    mapping(address => uint256) public balances;
    
    // Benefits from cheaper SLOAD costs
    function getBalances(address[] calldata users) 
        external 
        view 
        returns (uint256[] memory) 
    {
        uint256[] memory result = new uint256[](users.length);
        
        for (uint256 i = 0; i < users.length; i++) {
            result[i] = balances[users[i]]; // Cheaper cold SLOAD
        }
        
        return result;
    }
    
    // Benefits from memory optimization
    function processLargeData(bytes calldata input) 
        external 
        pure 
        returns (bytes32) 
    {
        bytes memory processed = new bytes(input.length * 2);
        
        // Memory operations are now cheaper
        for (uint256 i = 0; i < input.length; i++) {
            processed[i * 2] = input[i];
            processed[i * 2 + 1] = input[i];
        }
        
        return keccak256(processed);
    }
}
```

#### EVM Improvements

**Better Error Handling:**

```solidity
contract ImprovedErrors {
    error InsufficientBalance(uint256 available, uint256 required);
    error UnauthorizedAccess(address caller, address required);
    
    mapping(address => uint256) balances;
    address owner;
    
    function withdraw(uint256 amount) external {
        uint256 balance = balances[msg.sender];
        
        // Pectra provides better error data propagation
        if (balance < amount) {
            revert InsufficientBalance(balance, amount);
        }
        
        balances[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
    }
    
    function adminFunction() external {
        if (msg.sender != owner) {
            revert UnauthorizedAccess(msg.sender, owner);
        }
        // Admin logic...
    }
}
```

**Stack Depth Improvements:**

```solidity
contract DeeperCalls {
    // Pectra allows deeper call stacks
    function deepRecursion(uint256 depth) external view returns (uint256) {
        if (depth == 0) return 1;
        
        // Can now safely go deeper than before
        return depth * this.deepRecursion(depth - 1);
    }
}
```

### Account Abstraction Features

#### Native AA Support

With EIP-7702, OPN Chain provides native account abstraction:

```solidity
contract AAWallet {
    struct UserOperation {
        address sender;
        uint256 nonce;
        bytes initCode;
        bytes callData;
        uint256 callGasLimit;
        uint256 verificationGasLimit;
        uint256 preVerificationGas;
        uint256 maxFeePerGas;
        uint256 maxPriorityFeePerGas;
        bytes paymasterAndData;
        bytes signature;
    }
    
    function validateUserOp(
        UserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 missingAccountFunds
    ) external returns (uint256 validationData) {
        // Custom validation logic
        require(verifySignature(userOpHash, userOp.signature), "Invalid signature");
        
        if (missingAccountFunds > 0) {
            payable(msg.sender).transfer(missingAccountFunds);
        }
        
        return 0; // Validation successful
    }
    
    function executeUserOp(
        address dest,
        uint256 value,
        bytes calldata func
    ) external {
        (bool success, bytes memory result) = dest.call{value: value}(func);
        require(success, string(result));
    }
}
```

#### Session Keys

Implement session keys for better UX:

```solidity
contract SessionKeyWallet {
    mapping(address => SessionKey) public sessionKeys;
    
    struct SessionKey {
        uint256 validUntil;
        uint256 spendingLimit;
        uint256 spent;
        bool active;
    }
    
    function addSessionKey(
        address key,
        uint256 duration,
        uint256 limit
    ) external onlyOwner {
        sessionKeys[key] = SessionKey({
            validUntil: block.timestamp + duration,
            spendingLimit: limit,
            spent: 0,
            active: true
        });
    }
    
    function executeWithSessionKey(
        address target,
        uint256 value,
        bytes calldata data
    ) external {
        SessionKey storage session = sessionKeys[msg.sender];
        
        require(session.active, "Session key not active");
        require(block.timestamp <= session.validUntil, "Session expired");
        require(session.spent + value <= session.spendingLimit, "Limit exceeded");
        
        session.spent += value;
        
        (bool success,) = target.call{value: value}(data);
        require(success, "Execution failed");
    }
}
```

### Developer Tools

#### Pectra-Aware Development

**Updated Solidity Configuration:**

```javascript
// hardhat.config.js
module.exports = {
    solidity: {
        version: "0.8.30",
        settings: {
            optimizer: {
                enabled: true,
                runs: 200
            },
            evmVersion: "pectra" // Enable Pectra features
        }
    }
};
```

**Foundry Configuration:**

```toml
# foundry.toml
[profile.default]
solc_version = "0.8.30"
evm_version = "pectra"
optimizer = true
optimizer_runs = 200
```

#### Testing Pectra Features

```javascript
// Test EIP-7702 functionality
describe("EIP-7702 Tests", function() {
    it("should set code on EOA", async function() {
        const [owner] = await ethers.getSigners();
        const walletLogic = await WalletLogic.deploy();
        
        // Create EIP-7702 transaction
        const setCodeTx = {
            type: 0x7702,
            to: walletLogic.address,
            authorization: await createAuthorization(
                owner.address,
                walletLogic.address
            ),
            gasLimit: 100000
        };
        
        await owner.sendTransaction(setCodeTx);
        
        // EOA now has code!
        const code = await ethers.provider.getCode(owner.address);
        expect(code).to.not.equal("0x");
    });
});
```

### Migration Guide

#### Updating Existing Contracts

**Before (Pre-Pectra):**

```solidity
contract OldPattern {
    bool locked;
    
    modifier nonReentrant() {
        require(!locked, "Reentrant call");
        locked = true;
        _;
        locked = false;
    }
}
```

**After (With Pectra):**

```solidity
contract NewPattern {
    // Use transient storage for reentrancy guard
    modifier nonReentrant() {
        assembly {
            if tload(0) { revert(0, 0) }
            tstore(0, 1)
        }
        _;
        assembly {
            tstore(0, 0)
        }
    }
}
```

#### Leveraging Gas Optimizations

```solidity
contract OptimizedContract {
    // Take advantage of cheaper operations
    function batchProcess(address[] calldata accounts) external {
        // Cold SLOAD is now cheaper
        for (uint256 i = 0; i < accounts.length; i++) {
            uint256 balance = balances[accounts[i]];
            // Process...
        }
    }
    
    // Use new opcodes for efficiency
    function copyData(bytes calldata input) external pure returns (bytes memory) {
        bytes memory output = new bytes(input.length);
        assembly {
            mcopy(add(output, 0x20), add(input, 0x20), mload(input))
        }
        return output;
    }
}
```

### Security Considerations

#### EIP-7702 Security

When using EIP-7702, consider:

1. **Code Authorization**: Only authorize trusted contracts
2. **Validation Logic**: Implement proper checks in wallet logic
3. **Upgrade Mechanisms**: Plan for code updates
4. **Recovery Options**: Include social recovery

```solidity
contract SecureWalletLogic {
    address immutable EXPECTED_OWNER;
    
    constructor(address owner) {
        EXPECTED_OWNER = owner;
    }
    
    function validateAuthorization() external view {
        // Ensure this code is only used by intended owner
        require(address(this) == EXPECTED_OWNER, "Unauthorized usage");
    }
}
```

#### Transient Storage Security

```solidity
contract TransientSecure {
    // Transient storage slots for different purposes
    uint256 constant REENTRANCY_SLOT = 0;
    uint256 constant AUTH_SLOT = 1;
    
    modifier authenticated() {
        assembly {
            if iszero(tload(AUTH_SLOT)) { revert(0, 0) }
        }
        _;
    }
    
    function authenticate() external {
        // Perform authentication
        assembly {
            tstore(AUTH_SLOT, 1)
        }
    }
}
```

### Future Compatibility

OPN Chain commits to staying current with Ethereum upgrades:

* Continuous monitoring of Ethereum EIPs
* Rapid implementation of accepted proposals
* Backward compatibility maintenance
* Developer tool updates

### Resources

#### Documentation

* [EIP-7702 Specification](https://eips.ethereum.org/EIPS/eip-7702)
* [Pectra Upgrade Overview](https://ethereum.org/pectra)

***
