EvmError: OutOfFunds #2971

serena0323 · 2024-12-04T02:50:53Z

serena0323
Dec 4, 2024

I am doing according the Account abstraction class code, when I run "forge test --mt testValidationOfUserOps -vvv", it got "EvmError: OutOfFunds"

Here is my code:
MinimalAccountTest.t.sol

,,,
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {Test} from "forge-std/Test.sol";
import {MinimalAccount} from "../src/ethereum/MinimalAccount.sol";
import {DeployMinimal} from "../script/DeployMinmal.s.sol";
import {HelperConfig} from "../script/HelperConfig.s.sol";
import {ERC20Mock} from "@openzeppelin/contracts/mocks/token/ERC20Mock.sol";
import {SendPackedUserOp, PackedUserOperation, IEntryPoint} from "../script/SendPackedUserOp.s.sol";
import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";

contract MinimalAccountTest is Test {
using MessageHashUtils for bytes32;

MinimalAccount miniAccount;
HelperConfig helperConfig;
ERC20Mock usdc;
uint256 public constant AMOUNT = 1e18;
address randomUser = makeAddr("randomUser");
SendPackedUserOp sendPackedUserOp;

function setUp() public {
    DeployMinimal deployer = new DeployMinimal();
   (helperConfig, miniAccount) = deployer.run();
   usdc = new ERC20Mock();
   sendPackedUserOp = new SendPackedUserOp();

}

// USDC Approval
// msg.sender should be MinimalAccount
// approve some amount
// USDC contract
// come from the entrypoint
function testOwnerCanExecute() public {
    //Arrange
    assertEq(usdc.balanceOf(address(miniAccount)), 0);
    address dest = address(usdc);
    uint256 value = 0;
    bytes memory functionData = abi.encodeWithSelector(ERC20Mock.mint.selector, address(miniAccount), AMOUNT);
    //Act
    vm.prank(miniAccount.owner());
    miniAccount.execute(dest, value, functionData);
    //Assert
    assertEq(usdc.balanceOf(address(miniAccount)), AMOUNT);

}

function testNonOwnerCannotExecute() public {
    //Arrange
    assertEq(usdc.balanceOf(address(miniAccount)), 0);
    address dest = address(usdc);
    uint256 value = 0;
    bytes memory functionData = abi.encodeWithSelector(ERC20Mock.mint.selector, address(miniAccount), AMOUNT);
    //Act
    vm.prank(randomUser);
    vm.expectRevert(MinimalAccount.MinimalAccount__NotFromEntryPointOrOwner.selector);
    miniAccount.execute(dest, value, functionData);   

}

function testRecoverSignedOp() public {
    //Arrange
    assertEq(usdc.balanceOf(address(miniAccount)), 0);
    address dest = address(usdc);
    uint256 value = 0;
    bytes memory functionData = abi.encodeWithSelector(ERC20Mock.mint.selector, address(miniAccount), AMOUNT);
    bytes memory executeCallData = abi.encodeWithSelector(MinimalAccount.execute.selector, dest, value, functionData);
    PackedUserOperation memory packedUserOp = sendPackedUserOp.generateSignedUserOperation(
        executeCallData, helperConfig.getConfig(), address(miniAccount)
    );
    bytes32 userOperationHash = IEntryPoint(helperConfig.getConfig().entryPoint).getUserOpHash(packedUserOp);

    //Act
    address actualSigner = ECDSA.recover(userOperationHash.toEthSignedMessageHash(), packedUserOp.signature);

    //Assert
    assertEq(actualSigner, miniAccount.owner());

}

// 1. Sign userOps
// 2. Call validata userOps
// 3. Assert the return is correct
function testValidationOfUserOps() public {
    //Arrange
    assertEq(usdc.balanceOf(address(miniAccount)), 0);
    address dest = address(usdc);
    uint256 value = 0;
    bytes memory functionData = abi.encodeWithSelector(ERC20Mock.mint.selector, address(miniAccount), AMOUNT);
    bytes memory executeCallData = abi.encodeWithSelector(MinimalAccount.execute.selector, dest, value, functionData);
    PackedUserOperation memory packedUserOp = sendPackedUserOp.generateSignedUserOperation(
        executeCallData, helperConfig.getConfig(), address(miniAccount)
    );
    bytes32 userOperationHash = IEntryPoint(helperConfig.getConfig().entryPoint).getUserOpHash(packedUserOp);
    uint256 missingAccountFunds = 1e18;

    //Act
    vm.prank(helperConfig.getConfig().entryPoint);
    uint256 validationData = miniAccount.validateUserOp(packedUserOp, userOperationHash, missingAccountFunds);
    assertEq(validationData, 0);

}

function testEntryPointCanExecuteCommands() public {
    // Arrange
    assertEq(usdc.balanceOf(address(miniAccount)), 0);
    address dest = address(usdc);
    uint256 value = 0;
    bytes memory functionData = abi.encodeWithSelector(ERC20Mock.mint.selector, address(miniAccount), AMOUNT);
    bytes memory executeCallData = abi.encodeWithSelector(MinimalAccount.execute.selector, dest, value, functionData);
    PackedUserOperation memory packedUserOp = sendPackedUserOp.generateSignedUserOperation(
        executeCallData, helperConfig.getConfig(), address(miniAccount)
    );
    //bytes32 userOperationHash = IEntryPoint(helperConfig.getConfig().entryPoint).getUserOpHash(packedUserOp);
    vm.deal(address(miniAccount), 1e18);

    PackedUserOperation[] memory ops = new PackedUserOperation[](1);
    ops[0] = packedUserOp;

    // Act
    vm.prank(randomUser);
    IEntryPoint(helperConfig.getConfig().entryPoint).handleOps(ops, payable(randomUser));

    // Assert
    assertEq(usdc.balanceOf(address(miniAccount)), AMOUNT);

}

}
,,,

MinimalAccount.sol
'''
/SPDX-License-Identifier:MIT

pragma solidity 0.8.24;

import {IAccount} from "lib/account-abstraction/contracts/interfaces/IAccount.sol";
import {PackedUserOperation} from "lib/account-abstraction/contracts/interfaces/PackedUserOperation.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {SIG_VALIDATION_FAILED, SIG_VALIDATION_SUCCESS} from "lib/account-abstraction/contracts/core/Helpers.sol";
import {IEntryPoint} from "lib/account-abstraction/contracts/interfaces/IEntryPoint.sol";

contract MinimalAccount is IAccount, Ownable{

/*//////////////////////////////////////////////////////////////
                             ERRORS
//////////////////////////////////////////////////////////////*/
error MinimalAccount__NotFromEntryPoint();
error MinimalAccount__CallFailed(bytes);
error MinimalAccount__NotFromEntryPointOrOwner();

/*//////////////////////////////////////////////////////////////
                        STATE VARIABLES
//////////////////////////////////////////////////////////////*/
IEntryPoint private immutable i_entryPoint;


/*//////////////////////////////////////////////////////////////
                        MODIFIERS
//////////////////////////////////////////////////////////////*/

modifier requireFromEntryPoint(){
    if (msg.sender != address(i_entryPoint)){
        revert MinimalAccount__NotFromEntryPoint();
    }
    _;
}

modifier requireFromEntryPointOrOwner(){
    if (msg.sender != owner() && msg.sender != address(i_entryPoint)){
        revert MinimalAccount__NotFromEntryPointOrOwner();
    }
    _;
}

/*//////////////////////////////////////////////////////////////
                        Functions
//////////////////////////////////////////////////////////////*/
constructor(address entryPoint) Ownable(msg.sender){ 
    i_entryPoint = IEntryPoint(entryPoint);
} 

receive() external payable{}

/*//////////////////////////////////////////////////////////////
                        External Functions
//////////////////////////////////////////////////////////////*/
function execute(address dest, uint256 value, bytes calldata functionData) external requireFromEntryPointOrOwner{
    (bool success, bytes memory result) = dest.call{value: value}(functionData);
    if (!success){
        revert MinimalAccount__CallFailed(result);
    }
}

function validateUserOp(
    PackedUserOperation calldata userOp,
    bytes32 userOpHash,
    uint256 missingAccountFunds 
) external returns (uint256 validationData){
    validationData = _validateSignature(userOp, userOpHash);
    //_validNonce();
    _payPrefund(missingAccountFunds);

}

/*//////////////////////////////////////////////////////////////
                        Internal Functions
//////////////////////////////////////////////////////////////*/

function _payPrefund(uint256 missingAccountFunds) internal {
    if (missingAccountFunds != 0){
        (bool success,) = payable(msg.sender).call{value: missingAccountFunds, gas: type(uint256).max}("");
        require(success, "Pay prefund failed");

    }
    
}

// EIP-191 version of the signed hash
function _validateSignature(PackedUserOperation calldata userOp, bytes32 userOpHash) 
        internal 
        view 
        returns (uint256 validationData)
    {
        // A signature is valid if it's the MinimalAccount owner.
        bytes32 ethSignedMessageHash = MessageHashUtils.toEthSignedMessageHash(userOpHash); 
        address signer = ECDSA.recover(ethSignedMessageHash, userOp.signature); 
        if (signer != owner()) {
            return SIG_VALIDATION_FAILED;
        }
        return SIG_VALIDATION_SUCCESS;
    }

/*//////////////////////////////////////////////////////////////
                            GETTERS
//////////////////////////////////////////////////////////////*/

function getEntryPoint() external view returns (address) {
    return address(i_entryPoint);
}

}
'''

SendPackedUserOps.s.sol:
,,,
// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

import {Script} from "forge-std/Script.sol";
import {PackedUserOperation} from "lib/account-abstraction/contracts/interfaces/PackedUserOperation.sol";
import { HelperConfig} from "../script/HelperConfig.s.sol";
import { IEntryPoint } from "lib/account-abstraction/contracts/interfaces/IEntryPoint.sol";
import { MessageHashUtils } from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import { MinimalAccount } from "../src/ethereum/MinimalAccount.sol";
import { DevOpsTools } from "lib/foundry-devops/src/DevOpsTools.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract SendPackedUserOp is Script {
using MessageHashUtils for bytes32;

// Make sure you trust this user - don't run this on Mainnet!
address constant RANDOM_APPROVER = 0x9EA9b0cc1919def1A3CfAEF4F7A66eE3c36F86fC;

function run() public{ }

function generateSignedUserOperation(
        bytes memory callData, 
        HelperConfig.NetworkConfig memory config,
        address minimalAccount
    ) public view returns (PackedUserOperation memory){
    //Step 1. Generate the unsigned data
    uint256 nonce = vm.getNonce(minimalAccount)-1;
    PackedUserOperation memory userOp = _generateUnsignedUserOperation(callData, minimalAccount, nonce);
    
    //Step 2. Get the userOp Hash
    bytes32 userOpHash = IEntryPoint(config.entryPoint).getUserOpHash(userOp);
    bytes32 digest = userOpHash.toEthSignedMessageHash();
    
    //Step 3. Sign and return it
    uint8 v;
    bytes32 r;
    bytes32 s;
    uint256 ANVIL_DEFAULT_KEY = 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80;
    if (block.chainid == 31337){
        (v, r, s) = vm.sign(ANVIL_DEFAULT_KEY, digest);
    }else {
        (v, r, s) = vm.sign(config.account, digest);
    }
    userOp.signature = abi.encodePacked(r, s, v); // note the order
    return userOp;

}

function _generateUnsignedUserOperation(bytes memory callData, address sender, uint256 nonce)
    internal pure returns (PackedUserOperation memory) {
        uint128 verificationGasLimit = 16777216;
        uint128 callGasLimit = verificationGasLimit;
        uint128 maxPriorityFeePerGas = 256;
        uint128 maxFeePerGas = maxPriorityFeePerGas;

        return PackedUserOperation({
            sender: sender,
            nonce: nonce,
            initCode: hex"",
            callData: callData,
            accountGasLimits: bytes32(uint256(verificationGasLimit) << 128 | callGasLimit),
            preVerificationGas: verificationGasLimit,
            gasFees: bytes32(uint256(maxPriorityFeePerGas) << 128 | maxFeePerGas),
            paymasterAndData: hex"",
            signature: hex""

        });
    }

}
,,,

Answered by EngrPips

Dec 4, 2024

Hello @serena0323, The image below shows Patrick's codebase for the MinimalAccount contract. I want to draw your attention specifically to the _payPreFund internal function. You will see that Patrick didn't revert in the function. Here is the link https://github.com/Cyfrin/minimal-account-abstraction/blob/main/src/ethereum/MinimalAccount.sol to the codebase

The below is your MinimalAccount _payPreFund internal function. So why are you reverting inside your _payPreFund depending on whether the call to fund the msg.sender succeeds or not?

function _payPrefund(uint256 missingAccountFunds) internal {
    if (missingAccountFunds != 0){
        (bool success,) = payable(msg.sender).call{value: m…

View full answer

EngrPips · 2024-12-04T07:54:50Z

EngrPips
Dec 4, 2024

Hello @serena0323, The image below shows Patrick's codebase for the MinimalAccount contract. I want to draw your attention specifically to the _payPreFund internal function. You will see that Patrick didn't revert in the function. Here is the link https://github.com/Cyfrin/minimal-account-abstraction/blob/main/src/ethereum/MinimalAccount.sol to the codebase

The below is your MinimalAccount _payPreFund internal function. So why are you reverting inside your _payPreFund depending on whether the call to fund the msg.sender succeeds or not?

function _payPrefund(uint256 missingAccountFunds) internal {
    if (missingAccountFunds != 0){
        (bool success,) = payable(msg.sender).call{value: missingAccountFunds, gas: type(uint256).max}("");
        require(success, "Pay prefund failed");

    }
    
}

0 replies

serena0323 · 2024-12-04T13:25:00Z

serena0323
Dec 4, 2024
Author

Thanks @EngrPips so much! You have a sharp eye! I notice the different, but I thought it should be correct. I changed it the same as Patrick's code, it works now. so seems this call not really succeed, right?

1 reply

EngrPips Dec 4, 2024

Yeah, But we at least are able to verify that the transaction is properly validated.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

EvmError: OutOfFunds #2971

{{title}}

Replies: 2 comments 1 reply

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

Select a reply

EvmError: OutOfFunds #2971

serena0323 Dec 4, 2024

Replies: 2 comments · 1 reply

EngrPips Dec 4, 2024

serena0323 Dec 4, 2024 Author

EngrPips Dec 4, 2024

serena0323
Dec 4, 2024

Replies: 2 comments 1 reply

EngrPips
Dec 4, 2024

serena0323
Dec 4, 2024
Author