First Commit

Author: albertisaac12

.gitmodules

@@ -1,3 +1,9 @@
 [submodule "lib/forge-std"]
 	path = lib/forge-std
 	url = https://github.com/foundry-rs/forge-std
+[submodule "lib/account-abstraction"]
+	path = lib/account-abstraction
+	url = https://github.com/eth-infinitism/account-abstraction
+[submodule "lib/openzeppelin-contracts"]
+	path = lib/openzeppelin-contracts
+	url = https://github.com/openzeppelin/openzeppelin-contracts

README.md

@@ -1,66 +0,0 @@
-## Foundry
-
-**Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.**
-
-Foundry consists of:
-
--   **Forge**: Ethereum testing framework (like Truffle, Hardhat and DappTools).
--   **Cast**: Swiss army knife for interacting with EVM smart contracts, sending transactions and getting chain data.
--   **Anvil**: Local Ethereum node, akin to Ganache, Hardhat Network.
--   **Chisel**: Fast, utilitarian, and verbose solidity REPL.
-
-## Documentation
-
-https://book.getfoundry.sh/
-
-## Usage
-
-### Build
-
-```shell
-$ forge build
-```
-
-### Test
-
-```shell
-$ forge test
-```
-
-### Format
-
-```shell
-$ forge fmt
-```
-
-### Gas Snapshots
-
-```shell
-$ forge snapshot
-```
-
-### Anvil
-
-```shell
-$ anvil
-```
-
-### Deploy
-
-```shell
-$ forge script script/Counter.s.sol:CounterScript --rpc-url <your_rpc_url> --private-key <your_private_key>
-```
-
-### Cast
-
-```shell
-$ cast <subcommand>
-```
-
-### Help
-
-```shell
-$ forge --help
-$ anvil --help
-$ cast --help
-```

foundry.toml

@@ -2,5 +2,5 @@
 src = "src"
 out = "out"
 libs = ["lib"]
-
+remappings=["@openzeppelin/contracts=lib/openzeppelin-contracts/contracts"]
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options

lib/account-abstraction

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.28;
+
+import {Script, console} from "forge-std/Script.sol";
+import {MinimalAccount} from "./../src/Ethereum/Minimal-Account.sol";
+import {HelperConfig} from "./HelperConfig.s.sol";
+
+contract DeployMinimal is Script {
+    function run() public {}
+
+    function deployMinimalAccount()
+        public
+        returns (HelperConfig, MinimalAccount)
+    {
+        HelperConfig helperConfig = new HelperConfig();
+        HelperConfig.NetworkConfig memory config = helperConfig.getConfig();
+
+        // console.log("This is the fucking cause: ", config.account);
+
+        vm.startBroadcast(config.account);
+
+        MinimalAccount minimalAccount = new MinimalAccount(config.entryPoint);
+
+        // console.log("This is the msg.sender", msg.sender);
+        minimalAccount.transferOwnership(config.account);
+
+        vm.stopBroadcast();
+
+        return (helperConfig, minimalAccount);
+    }
+}

lib/openzeppelin-contracts

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.28;
+
+import {Script, console, console2} from "forge-std/Script.sol";
+import {EntryPoint} from "lib/account-abstraction/contracts/core/EntryPoint.sol";
+
+contract HelperConfig is Script {
+    error HelperConfig__InvalidChainId();
+
+    struct NetworkConfig {
+        address entryPoint;
+        address account;
+    }
+
+    uint256 constant AMOY = 80002;
+    uint256 constant ZK = 300;
+    uint256 constant LOCAL = 31337;
+
+    address constant BURNER_WALLET = 0x4910A3E9f7d9A04eEed15093F33f9Ec26d480F2D;
+    // address constant FOUNDRY_DEFAULT_WALLET =
+    //     0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;
+
+    address constant ANVIL_DEFAULT_ACCOUNT =
+        0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266;
+
+    NetworkConfig public localNetworkConfig;
+    mapping(uint256 chainId => NetworkConfig) public networkConfigs;
+
+    constructor() {
+        networkConfigs[AMOY] = getAMOYConfig();
+    }
+
+    function getConfig() public returns (NetworkConfig memory) {
+        return getConfigByChainId(block.chainid);
+    }
+
+    function getConfigByChainId(
+        uint256 chainId
+    ) public returns (NetworkConfig memory) {
+        if (chainId == LOCAL) {
+            return getOrCreateAnvilEthConfig();
+        } else if (networkConfigs[chainId].account != address(0)) {
+            return networkConfigs[chainId];
+        } else {
+            revert HelperConfig__InvalidChainId();
+        }
+    }
+
+    function getAMOYConfig() public pure returns (NetworkConfig memory) {
+        return
+            NetworkConfig({
+                entryPoint: 0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789,
+                account: BURNER_WALLET
+            });
+    }
+
+    function ZKConfig() public pure returns (NetworkConfig memory) {
+        return NetworkConfig({entryPoint: address(0), account: BURNER_WALLET});
+    }
+
+    function getOrCreateAnvilEthConfig() public returns (NetworkConfig memory) {
+        if (localNetworkConfig.account == address(0)) {
+            console2.log("Deploying Mocks...");
+
+            // vm.startBroadcast(FOUNDRY_DEFAULT_WALLET);
+            vm.startBroadcast(ANVIL_DEFAULT_ACCOUNT);
+            EntryPoint entryPoint = new EntryPoint();
+            vm.stopBroadcast();
+
+            localNetworkConfig = NetworkConfig({
+                entryPoint: address(entryPoint),
+                // account: FOUNDRY_DEFAULT_WALLET
+                account: ANVIL_DEFAULT_ACCOUNT
+            });
+
+            console2.log(localNetworkConfig.entryPoint);
+        }
+
+        return localNetworkConfig;
+    }
+}

script/Counter.s.sol

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {Script} from "forge-std/Script.sol";
+import {MinimalAccount} from "./../src/Ethereum/Minimal-Account.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";
+
+contract SendPackedUserOp is Script {
+    using MessageHashUtils for bytes32;
+
+    function run() public {}
+
+    function generateSignedUserOperation(
+        bytes memory callData,
+        HelperConfig.NetworkConfig memory config
+    ) public view returns (PackedUserOperation memory, bytes32) {
+        // 1 . Generate the unsigned data
+        uint256 nonce = vm.getNonce(config.account);
+        PackedUserOperation memory userOp = _generateUnsignedUserOperation(
+            callData,
+            config.account,
+            nonce
+        );
+        // 2. Get the userOpHash
+        bytes32 userOpHash = IEntryPoint(config.entryPoint).getUserOpHash(
+            userOp
+        );
+
+        bytes32 digest = userOpHash.toEthSignedMessageHash();
+
+        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 {
+            // 3. Sign it and return it
+            (v, r, s) = vm.sign(config.account, digest);
+            userOp.signature = abi.encodePacked(r, s, v); // Note the order
+        }
+
+        return (userOp, digest);
+    }
+
+    /*
+        struct PackedUserOperation {
+            address sender;
+            uint256 nonce;
+            bytes initCode;
+            bytes callData;
+            bytes32 accountGasLimits;
+            uint256 preVerificationGas;
+            bytes32 gasFees;
+            bytes paymasterAndData; // if paymaster is setUp we will send
+            bytes signature;
+        }
+    */
+
+    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""
+            });
+    }
+}