├── .gitignore
├── hard.config.js
├── package.json
├── contracts
    └── MyToken.sol
├── scriptcodes
    ├── deploy.js
    ├── bloxroute.js
    └── abi.js
├── README.md
└── test-shell
    └── Lock.js


/.gitignore:
--------------------------------------------------------------------------------
 1 | node_modules
 2 | .env
 3 | 
 4 | # Hardhat files
 5 | /cache
 6 | /artifacts
 7 | 
 8 | # TypeChain files
 9 | /typechain
10 | /typechain-types
11 | 
12 | # solidity-coverage files
13 | /coverage
14 | /coverage.json
15 | 


--------------------------------------------------------------------------------
/hard.config.js:
--------------------------------------------------------------------------------
 1 | require("@nomicfoundation/hardhat-toolbox");
 2 | 
 3 | /** @type import('hardhat/config').HardhatUserConfig */
 4 | module.exports = {
 5 |   solidity: "0.8.19",
 6 |   networks: {
 7 |     hardhat: {
 8 |       forking: {
 9 |         url: "https://small-thrilling-county.bsc.quiknode.pro/5309cc3b81880102c3951f4132560fa48f13a448/", // Replace with your Alchemy Mainnet RPC URL
10 |         // blockNumber: 44716540, // Optional: specify a block number to fork from
11 |       },
12 |     },
13 |   },
14 | };
15 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "contract",
 3 |   "version": "1.0.0",
 4 |   "main": "index.js",
 5 |   "keywords": [],
 6 |   "author": "",
 7 |   "license": "ISC",
 8 |   "description": "",
 9 |   "devDependencies": {
10 |     "@nomicfoundation/hardhat-toolbox": "^4.0.0",
11 |     "@uniswap/v3-sdk": "^3.10.2",
12 |     "hardhat": "^2.19.5"
13 |   },
14 |   "dependencies": {
15 |     "@ethersproject/abi": "^5.7.0",
16 |     "@openzeppelin/contracts": "^4.9.6",
17 |     "dotenv": "^16.4.7"
18 |   },
19 |   "scripts": {
20 |     "sn": "npx hardhat node --network hardhat",
21 |     "t": "npx hardhat test --network localhost"
22 |   }
23 | }


--------------------------------------------------------------------------------
/contracts/MyToken.sol:
--------------------------------------------------------------------------------
 1 | // SPDX-License-Identifier: MIT
 2 | pragma solidity ^0.8.9;
 3 | 
 4 | import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 5 | 
 6 | 
 7 | // 1000000000000000000000
 8 | contract MyToken is ERC20 {
 9 |     /**
10 |      * @dev Constructor that gives msg.sender all of existing tokens.
11 |      * @param name The name of the token.
12 |      * @param symbol The symbol of the token.
13 |      * @param initialSupply The initial supply of tokens (in wei, taking decimals into account).
14 |      */
15 |     constructor(string memory name, string memory symbol, uint256 initialSupply) ERC20(name, symbol) {
16 |         _mint(msg.sender, initialSupply);
17 |     }
18 | }
19 | 
20 | 


--------------------------------------------------------------------------------
/scriptcodes/deploy.js:
--------------------------------------------------------------------------------
 1 | // We require the Hardhat Runtime Environment explicitly here. This is optional
 2 | // but useful for running the script in a standalone fashion through `node <script>`.
 3 | //
 4 | // You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
 5 | // will compile your contracts, add the Hardhat Runtime Environment's members to the
 6 | // global scope, and execute the script.
 7 | const hre = require("hardhat");
 8 | 
 9 | async function main() {
10 |   const currentTimestampInSeconds = Math.round(Date.now() / 1000);
11 |   const unlockTime = currentTimestampInSeconds + 60;
12 | 
13 |   const lockedAmount = hre.ethers.parseEther("0.001");
14 | 
15 |   const lock = await hre.ethers.deployContract("Lock", [unlockTime], {
16 |     value: lockedAmount,
17 |   });
18 | 
19 |   await lock.waitForDeployment();
20 | 
21 |   console.log(
22 |     `Lock with ${ethers.formatEther(
23 |       lockedAmount
24 |     )}ETH and unlock timestamp ${unlockTime} deployed to ${lock.target}`
25 |   );
26 | }
27 | 
28 | // We recommend this pattern to be able to use async/await everywhere
29 | // and properly handle errors.
30 | main().catch((error) => {
31 |   console.error(error);
32 |   process.exitCode = 1;
33 | });
34 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # 💹 Monad Chain Trading Bot (Volume + Bundler)
 2 | **Professional Sniper, Bundler & Volume Automation for Monad-based DEXs**
 3 | 
 4 | A high-performance trading bot infrastructure built for the **Monad blockchain**, offering automated token deployment, liquidity pool creation, and advanced trading strategies such as sniping, bundling, and volume generation.
 5 | 
 6 | ---
 7 | 
 8 | ## 🧠 Overview
 9 | The **Monad Chain Trading Bot** automates token operations and trading activities on **Uniswap V3-style DEXs operating on Monad**.  
10 | It covers everything from deploying tokens to adding liquidity, simulating volume, and executing atomic bundled transactions.
11 | 
12 | ---
13 | 
14 | ## 🚀 How It Works
15 | 
16 | ### **Sniper Bot**
17 | 1. Load target token  
18 | 2. Fetch swap quote  
19 | 3. Apply slippage  
20 | 4. Buy immediately using configured wallet  
21 | 5. Emit tx hash, save logs, and optionally notify via Telegram  
22 | 
23 | ### **Copy-Trader**
24 | - Monitors mempool  
25 | - Filters leader wallets  
26 | - Detects swaps  
27 | - Mirrors trades with your configurable position size  
28 | 
29 | ### **Bundler**
30 | - Reads custom sequence files  
31 | - Executes swaps/liquidity events atomically  
32 | - Fully configurable slippage, routes, per-step logic  
33 | 
34 | ### **Volume Bot**
35 | - Loops continuously  
36 | - Generates buy & sell pressure  
37 | - Randomized timing and amounts  
38 | - Good for testing liquidity behavior  
39 | 
40 | ---
41 | 
42 | ## ✨ Key Features
43 | 
44 | - 🚀 **Token Deployment** (ERC20 / custom supply / metadata)  
45 | - 💧 **Liquidity Management** using Uniswap-V3-compatible DEXs  
46 | - 🔗 **Atomic Bundling** using private relays or bundler APIs  
47 | - ⚡ **Sniper, Volume, and Bundler Strategies**  
48 | - 🧪 **Mainnet Fork Testing** (Monad testnet support)  
49 | - 🔐 **OpenZeppelin-secured contracts**  
50 | - 🪙 **Multi-Wallet Orchestration** for parallel trades  
51 | 
52 | ---
53 | 
54 | ## 🏗️ Architecture
55 | 
56 | | Component | Description |
57 | |----------|-------------|
58 | | Smart Contracts | ERC20 + liquidity helpers |
59 | | Bundler | Relay provider for MEV-safe atomic calls |
60 | | DEX Layer | Uniswap V3 SDK adapter for Monad DEXs |
61 | | Dev Environment | Hardhat compilation, testing, forking |
62 | 
63 | ---
64 | 
65 | ## 🧰 Technology Stack
66 | 
67 | | Component | Technology |
68 | |-----------|------------|
69 | | Smart Contracts | Solidity ^0.8.9 |
70 | | Framework | Hardhat |
71 | | Testing | Hardhat Toolbox |
72 | | DEX Integration | Uniswap V3 SDK |
73 | | Security | OpenZeppelin |
74 | | RPC Provider | Monad RPC (QuickNode / DRPC / custom) |
75 | | MEV Protection | Bundler / private relays |
76 | 
77 | ---
78 | 
79 | ## ⚙️ Core Modules
80 | 
81 | - **Wallet Factory** — HD wallets generated automatically  
82 | - **Native MON Distributor** — Fund multiple bots at once  
83 | - **Token Deployer** — Deploy ERC20 instantly  
84 | - **LP Creator** — Create pools + add liquidity  
85 | - **Auto-Buyer** — Parallel BUY execution from multiple wallets  
86 | - **Balance Monitor** — Tracks MON & token balances  
87 | - **JSON Exporter** — Saves wallets & TX details  
88 | 
89 | ---
90 | 
91 | 
92 | # 👨‍💻 Author
93 | DM me on telegram for full working version of this project
94 | ### 📞 Telegram: [d0sc4u](https://t.me/d0sc4u)   
95 | https://t.me/d0sc4u
96 | 
97 | 


--------------------------------------------------------------------------------
/test-shell/Lock.js:
--------------------------------------------------------------------------------
  1 | const {
  2 |   time,
  3 |   loadFixture,
  4 | } = require("@nomicfoundation/hardhat-toolbox/network-helpers");
  5 | const { anyValue } = require("@nomicfoundation/hardhat-chai-matchers/withArgs");
  6 | const { expect } = require("chai");
  7 | const { ethers } = require("hardhat");
  8 | 
  9 | const { defaultAbiCoder } = require("@ethersproject/abi");
 10 | const { abi: UniswapV3FactoryABI } = require('@uniswap/v3-core/artifacts/contracts/UniswapV3Factory.sol/UniswapV3Factory.json');
 11 | const { encodeSqrtRatioX96, Pool, Position, TickMath, NonfungiblePositionManager, nearestUsableTick } = require("@uniswap/v3-sdk");
 12 | const { Token, Percent, Price } = require("@uniswap/sdk-core");
 13 | const { default: JSBI } = require("jsbi");
 14 | const { UNISWAP_V3_POOL_ABI, SwapRouterAbi, UNISWAP_FACTOR_ABI } = require("../scripts/abi");
 15 | 
 16 | 
 17 | function getContractAddress(deployerAddress, deployerNonce) {
 18 |   // Convert nonce to hexadecimal string
 19 |   const nonceHex = deployerNonce === 0 ? '0x' : ethers.toBeHex(deployerNonce);
 20 | 
 21 |   // RLP encode the address and nonce
 22 |   const rlpEncoded = ethers.encodeRlp([deployerAddress, nonceHex]);
 23 | 
 24 |   // Compute keccak256 hash of the RLP encoded data
 25 |   const hash = ethers.keccak256(rlpEncoded);
 26 | 
 27 |   // Take the last 40 characters (20 bytes) of the hash
 28 |   const contractAddress = '0x' + hash.slice(-40);
 29 | 
 30 |   return ethers.getAddress(contractAddress); // Ensure checksum address
 31 | }
 32 | 
 33 | 
 34 | 
 35 | // Addresses
 36 | const nfpmAddress = "0x46A15B0b27311cedF172AB29E4f4766fbE7F4364"
 37 | const v3FactoryAddress = "0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865"
 38 | const v3RouterAddr = "0x1b81D678ffb9C0263b24A97847620C99d213eB14"
 39 | 
 40 | describe("Lock", function () {
 41 |   // We define a fixture to reuse the same setup in every test.
 42 |   // We use loadFixture to run this setup once, snapshot that state,
 43 |   // and reset Hardhat Network to that snapshot in every test.
 44 |   async function deployOneYearLockFixture() {
 45 |     // Contracts are deployed using the first signer/account by default
 46 |     const [owner, otherAccount] = await ethers.getSigners();
 47 | 
 48 |     let nonce = await ethers.provider.getTransactionCount(owner.address);
 49 | 
 50 |     let T0 = (getContractAddress(owner.address, nonce)).toLowerCase();
 51 | 
 52 |     console.log("Contract address exepected : ", T0)
 53 | 
 54 | 
 55 |     const Lock = await ethers.getContractFactory("MyToken");
 56 |     const token = await Lock.deploy("t1", "r1", 1000n * 10n ** 18n);
 57 | 
 58 |     const wbnb = "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"
 59 |     const wbnbAbi = [
 60 |       "function deposit() payable",
 61 |       "function withdraw(uint256)",
 62 |       "function balanceOf(address) view returns (uint256)",
 63 |       "function transfer(address to, uint256 amount) returns (bool)",
 64 |       "function approve(address spender, uint256 amount) returns (bool)",
 65 |       "function allowance(address owner, address spender) view returns (uint256)"
 66 |     ];
 67 | 
 68 |     const wbnbContract = new ethers.Contract(wbnb, wbnbAbi, owner);
 69 | 
 70 |     let tx = await wbnbContract.deposit({ value: ethers.parseEther("2") })
 71 |     await tx.wait()
 72 | 
 73 |     return { token, owner, otherAccount, wbnbContract };
 74 |   }
 75 | 
 76 | 
 77 |   async function createPool(uniswapFactory_contract, token1Address, token2Address, fee) {
 78 |     var txs;
 79 |     txs = await uniswapFactory_contract.createPool(
 80 |       token1Address.toLowerCase(),
 81 |       token2Address.toLowerCase(),
 82 |       fee,
 83 |       {
 84 |         gasLimit: 10000000,
 85 |       }
 86 |     );
 87 |     await txs.wait();
 88 | 
 89 |     const poolAdd = await uniswapFactory_contract.getPool(token1Address, token2Address, fee, {
 90 |       gasLimit: 3000000,
 91 |     });
 92 |     console.log('Pool address', poolAdd);
 93 |     return poolAdd;
 94 |   }
 95 | 
 96 |   function encodePriceSqrt(token1Price, token0Price) {
 97 |     return encodeSqrtRatioX96(token1Price, token0Price);
 98 |   }
 99 | 
100 |   async function initializePool(poolAdd, price, signer) {
101 |     const poolContract = new ethers.Contract(poolAdd, UNISWAP_V3_POOL_ABI, signer);
102 | 
103 |     var txs = await poolContract.initialize(price.toString(), {
104 |       gasLimit: 3000000,
105 |     });
106 |     await txs.wait();
107 |     console.log('Pool Initialized');
108 |   }
109 | 
110 | 
111 |   async function getPoolState(poolContract) {
112 |     const liquidity = await poolContract.liquidity();
113 |     const slot = await poolContract.slot0();
114 | 
115 |     const PoolState = {
116 |       liquidity,
117 |       sqrtPriceX96: slot[0],
118 |       tick: slot[1],
119 |       observationIndex: slot[2],
120 |       observationCardinality: slot[3],
121 |       observationCardinalityNext: slot[4],
122 |       feeProtocol: slot[5],
123 |       unlocked: slot[6],
124 |     };
125 | 
126 |     return PoolState;
127 |   }
128 | 
129 | 
130 | 
131 | 
132 |   async function addLiquidityToPool(
133 |     poolAdd,
134 |     deployer,
135 |     chainId,
136 |     Token1_decimals,
137 |     Token2_decimals,
138 |     token_contract1,
139 |     token_contract2,
140 |     amount0, amount1,
141 |     fee,
142 |     npmca
143 |   ) {
144 |     const poolContract = new ethers.Contract(poolAdd, UNISWAP_V3_POOL_ABI, deployer);
145 |     var state = await getPoolState(poolContract);
146 | 
147 | 
148 |     const Token1 = new Token(chainId, token_contract1.target, Token1_decimals);
149 |     const Token2 = new Token(chainId, token_contract2.target, Token2_decimals);
150 | 
151 |     const configuredPool = new Pool(
152 |       Token1,
153 |       Token2,
154 |       fee,
155 |       state.sqrtPriceX96.toString(),
156 |       state.liquidity.toString(),
157 |       Number(state.tick)
158 |     );
159 | 
160 |     const position = Position.fromAmounts({
161 |       pool: configuredPool,
162 |       tickLower:
163 |         nearestUsableTick(configuredPool.tickCurrent, configuredPool.tickSpacing) -
164 |         configuredPool.tickSpacing * 2,
165 |       tickUpper:
166 |         nearestUsableTick(configuredPool.tickCurrent, configuredPool.tickSpacing) +
167 |         configuredPool.tickSpacing * 2,
168 |       amount0: amount0.toString(),
169 |       amount1: amount1.toString(),
170 |       useFullPrecision: false,
171 |     });
172 | 
173 |     const mintOptions = {
174 |       recipient: deployer.address,
175 |       deadline: Math.floor(Date.now() / 1000) + 60 * 20,
176 |       slippageTolerance: new Percent(50, 10_000),
177 |     };
178 | 
179 |     const { calldata, value } = NonfungiblePositionManager.addCallParameters(position, mintOptions);
180 | 
181 |     const transaction = {
182 |       data: calldata,
183 |       to: npmca,
184 |       value: value,
185 |       from: deployer.address,
186 |       gasLimit: 10000000
187 |     };
188 |     console.log('Transacting');
189 |     const txRes = await deployer.sendTransaction(transaction);
190 |     await txRes.wait();
191 |     console.log('Added liquidity');
192 |   }
193 | 
194 |   async function swapExactInputSingle(
195 |     tokenIn,
196 |     tokenOut,
197 |     fee,                // e.g. 3000 for a 0.3% pool fee
198 |     amountIn,           // the amount of tokenIn to swap
199 |     signer,
200 |   ) {
201 |   
202 |     const swapRouterAbi = [
203 |       {
204 |         "inputs": [
205 |           {
206 |             "components": [
207 |               { "internalType": "address", "name": "tokenIn", "type": "address" },
208 |               { "internalType": "address", "name": "tokenOut", "type": "address" },
209 |               { "internalType": "uint24", "name": "fee", "type": "uint24" },
210 |               { "internalType": "address", "name": "recipient", "type": "address" },
211 |               { "internalType": "uint256", "name": "deadline", "type": "uint256" },
212 |               { "internalType": "uint256", "name": "amountIn", "type": "uint256" },
213 |               { "internalType": "uint256", "name": "amountOutMinimum", "type": "uint256" },
214 |               { "internalType": "uint160", "name": "sqrtPriceLimitX96", "type": "uint160" }
215 |             ],
216 |             "internalType": "struct ISwapRouter.ExactInputSingleParams",
217 |             "name": "params",
218 |             "type": "tuple"
219 |           }
220 |         ],
221 |         "name": "exactInputSingle",
222 |         "outputs": [
223 |           { "internalType": "uint256", "name": "amountOut", "type": "uint256" }
224 |         ],
225 |         "stateMutability": "payable",
226 |         "type": "function"
227 |       }
228 |     ]
229 | 
230 |     // Connect to the router contract with a signer
231 |     const swapRouter = new ethers.Contract(v3RouterAddr, swapRouterAbi, signer);
232 | 
233 | 
234 |     // Prepare the parameters for the swap
235 |     const params = {
236 |       tokenIn: tokenIn,              // address of the token you're selling
237 |       tokenOut: tokenOut,            // address of the token you're buying
238 |       fee: fee,                      // pool fee, e.g., 3000 for 0.3%
239 |       recipient: signer.address,          // where to send the output tokens
240 |       deadline: Math.floor(Date.now() / 1000) + 600, // 10 minutes from now
241 |       amountIn: amountIn,            // exact input amount
242 |       amountOutMinimum: "0", // minimum output to accept
243 |       sqrtPriceLimitX96: 0,          // set to 0 to ignore price limit
244 |     };
245 | 
246 |     // Execute the swap
247 |     const tx = await swapRouter.exactInputSingle(params);
248 |     console.log("Swap transaction sent:", tx.hash);
249 |     const receipt = await tx.wait();
250 | 
251 | 
252 |   }
253 | 
254 | 
255 |   describe("BSC", function () {
256 |     describe("BSC Bundle", function () {
257 |       it("Chalo budnle do", async function () {
258 | 
259 |         // create token 
260 |         const { token, owner, wbnbContract } = await loadFixture(deployOneYearLockFixture);
261 |         var fee = 100;
262 |         var token0Decimals = 18;
263 |         var token1Decimals = 18;
264 |         var amount0 = ethers.parseUnits('1', 18);
265 |         var amount1 = ethers.parseUnits('1', 18);
266 | 
267 |         let token0Address = wbnbContract.target
268 |         let token1Address = token.target
269 | 
270 |         var price = encodePriceSqrt(1, 1);
271 | 
272 |         let tx = await token.approve(nfpmAddress, amount0);
273 |         await tx.wait()
274 | 
275 |         tx = await wbnbContract.approve(nfpmAddress, amount1);
276 |         await tx.wait()
277 | 
278 |         tx = await wbnbContract.approve(v3RouterAddr, amount0);
279 |         await tx.wait()
280 | 
281 |         const uniswapFactoryContract = new ethers.Contract(v3FactoryAddress, UNISWAP_FACTOR_ABI, owner);
282 | 
283 | 
284 | 
285 |         var poolAddress = await uniswapFactoryContract.getPool(token0Address, token1Address, fee);
286 |         console.log({ poolAddress: poolAddress })
287 | 
288 |         if (poolAddress === '0x0000000000000000000000000000000000000000') {
289 |           console.log("Creating pool");
290 |           poolAddress = await createPool(uniswapFactoryContract, token0Address, token1Address, fee);
291 | 
292 |           await initializePool(poolAddress, price, owner);
293 |         }
294 | 
295 |         await addLiquidityToPool(poolAddress, owner, 56, token0Decimals, token1Decimals, wbnbContract, token, amount0, amount1, fee, nfpmAddress);
296 | 
297 |         await swapExactInputSingle(token0Address, token1Address, fee, ethers.parseEther("0.1"), owner)
298 | 
299 | 
300 | 
301 |       });
302 | 
303 | 
304 |     });
305 | 
306 |   });
307 | });
308 | 


--------------------------------------------------------------------------------
/scriptcodes/bloxroute.js:
--------------------------------------------------------------------------------
  1 | require("dotenv").config();
  2 | 
  3 | const { ethers: hardhatEther } = require("hardhat");
  4 | const { ethers, keccak256, getCreate2Address } = require("ethers");
  5 | const axios = require("axios");
  6 | 
  7 | 
  8 | const { Token, Percent } = require("@uniswap/sdk-core");
  9 | const { abi: UniswapV3FactoryABI } = require('@uniswap/v3-core/artifacts/contracts/UniswapV3Factory.sol/UniswapV3Factory.json');
 10 | 
 11 | const { encodeSqrtRatioX96, Pool, Position, TickMath, NonfungiblePositionManager, nearestUsableTick } = require("@uniswap/v3-sdk");
 12 | const JSBI = require('jsbi');
 13 | const { SwapRouterAbi } = require("./abi");
 14 | const { defaultAbiCoder } = require("@ethersproject/abi");
 15 | 
 16 | // ----- CONFIGURATION ----- //
 17 | const API_ENDPOINT = "https://api.blxrbdn.com";
 18 | const AUTHORIZATION_HEADER = process.env.AUTHORIZATION_HEADER; // Replace with your auth token
 19 | const privateKey = process.env.PRIVATE_KEY;
 20 | if (!privateKey || !AUTHORIZATION_HEADER) {
 21 |     throw new Error("Private key or AUTHORIZATION_HEADER is missing in .env file!");
 22 | }
 23 | 
 24 | 
 25 | const provider = ethers.getDefaultProvider("https://small-thrilling-county.bsc.quiknode.pro/5309cc3b81880102c3951f4132560fa48f13a448/");
 26 | const wallet = new ethers.Wallet(privateKey, provider).connect(provider);
 27 | console.log("Wallet : ", wallet.address)
 28 | 
 29 | function getContractAddress(deployerAddress, deployerNonce) {
 30 |     // Convert nonce to hexadecimal string
 31 |     const nonceHex = deployerNonce === 0 ? '0x' : ethers.toBeHex(deployerNonce);
 32 | 
 33 |     // RLP encode the address and nonce
 34 |     const rlpEncoded = ethers.encodeRlp([deployerAddress, nonceHex]);
 35 | 
 36 |     // Compute keccak256 hash of the RLP encoded data
 37 |     const hash = ethers.keccak256(rlpEncoded);
 38 | 
 39 |     // Take the last 40 characters (20 bytes) of the hash
 40 |     const contractAddress = '0x' + hash.slice(-40);
 41 | 
 42 |     return ethers.getAddress(contractAddress); // Ensure checksum address
 43 | }
 44 | 
 45 | async function getRawTx(tx) {
 46 |     const rawTx1 = await wallet.signTransaction(tx);
 47 |     const rawTx1NoPrefix = rawTx1.startsWith("0x") ? rawTx1.slice(2) : rawTx1;
 48 |     return rawTx1NoPrefix
 49 | 
 50 | }
 51 | 
 52 | async function createDeploymentTx(deployParams, nonce, gasPrice) {
 53 |     const factory = await hardhatEther.getContractFactory("MyToken")
 54 |     const deployTx = await factory.getDeployTransaction(
 55 |         ...deployParams
 56 |     );
 57 |     const gasLimit = (await wallet.estimateGas(deployTx)) + 50000n;
 58 | 
 59 |     const tx1 = {
 60 |         to: null,
 61 |         nonce: nonce,
 62 |         gasPrice: gasPrice,
 63 |         gasLimit: gasLimit,
 64 |         data: deployTx.data,
 65 |         value: 0,
 66 |         chainId: 56 // BSC Mainnet chain ID
 67 |     };
 68 |     // console.log(tx1)
 69 | 
 70 |     const rawTx = await getRawTx(tx1)
 71 |     return rawTx
 72 | 
 73 | }
 74 | 
 75 | async function createApproveTransaction(tokenAddress, spenderAddress, nonce, gasPrice) {
 76 |     const tokenContract = new ethers.Contract(tokenAddress, [
 77 |         "function approve(address spender, uint256 amount) returns (bool)"
 78 |     ], wallet);
 79 | 
 80 |     const maxAmount = ethers.MaxUint256;
 81 |     const txData = tokenContract.interface.encodeFunctionData("approve", [spenderAddress, maxAmount]);
 82 | 
 83 |     const tx1 = {
 84 |         to: tokenAddress,
 85 |         nonce: nonce,
 86 |         gasPrice: gasPrice,
 87 |         gasLimit: 100000,
 88 |         data: txData,
 89 |         value: 0,
 90 |         chainId: 56 // BSC Mainnet chain ID
 91 |     };
 92 |     // console.log(tx1)
 93 | 
 94 |     const rawTx = await getRawTx(tx1)
 95 | 
 96 |     // console.log("raw tx : ", rawTx)
 97 | 
 98 |     return rawTx
 99 | 
100 |     // return approveTransaction
101 | }
102 | 
103 | 
104 | // Addresses
105 | const nfpmAddress = "0x46A15B0b27311cedF172AB29E4f4766fbE7F4364"
106 | const v3FactoryAddress = "0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865"
107 | const v3RouterAddr = "0x1b81D678ffb9C0263b24A97847620C99d213eB14"
108 | 
109 | // contracts
110 | 
111 | const uniswapFactoryContract = new ethers.Contract(
112 |     v3FactoryAddress,
113 |     UniswapV3FactoryABI,
114 |     wallet
115 | )
116 | 
117 | function computePoolAddress(tokenA, tokenB, fee) {
118 |     // Sort token addresses so token0 is always the lower one.
119 |     const [token0, token1] = [tokenA, tokenB].sort((a, b) => (BigInt(a) < BigInt(b) ? -1 : 1));
120 | 
121 |     // Encode the sorted tokens and fee into a salt.
122 |     const salt = keccak256(
123 |         defaultAbiCoder.encode(['address', 'address', 'uint24'], [token0, token1, fee])
124 |     );
125 | 
126 |     // Compute and return the create2 address.
127 |     return getCreate2Address("0x41ff9AA7e16B8B1a8a8dc4f0eFacd93D02d071c9", salt, "0x6ce8eb472fa82df5469c6ab6d485f17c3ad13c8cd7af59b3d4a8026c5ce0f7e2");
128 | }
129 | 
130 | 
131 | async function createPool(token1Address, token2Address, fee, price, nonce, gasPrice) {
132 |     // const createPoolTxData = uniswapFactoryContract.interface.encodeFunctionData('initialize', [token1Address.toLowerCase(), token2Address.toLowerCase(), fee]);
133 | 
134 | 
135 |     const NFPM_ABI = [
136 |         "function mint((address token0, address token1, uint24 fee, int24 tickLower, int24 tickUpper, uint256 amount0Desired, uint256 amount1Desired, uint256 amount0Min, uint256 amount1Min, address recipient, uint256 deadline)) external returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1)",
137 |         "function createAndInitializePoolIfNecessary(address token0,address token1,uint24 fee,uint160 sqrtPriceX96) external payable override returns (address pool)"
138 |     ];
139 |     const nfpmContract = new ethers.Contract(nfpmAddress, NFPM_ABI, wallet);
140 | 
141 |     const txData = nfpmContract.interface.encodeFunctionData("createAndInitializePoolIfNecessary",
142 |         [
143 |             token1Address.toLowerCase(),
144 |             token2Address.toLowerCase(),
145 |             fee,
146 |             price
147 |         ]
148 |     );
149 | 
150 | 
151 |     const createPoolTx = {
152 |         to: nfpmAddress,
153 |         nonce: nonce,
154 |         gasPrice: gasPrice,
155 |         gasLimit: 5000000,
156 |         data: txData,
157 |         value: 0,
158 |         chainId: 56 // BSC Mainnet chain ID
159 |     }
160 | 
161 |     const rawTx = await getRawTx(createPoolTx)
162 | 
163 |     return rawTx
164 | }
165 | 
166 | async function addLiquidityToPool(
167 |     T0,
168 |     T1,
169 |     amount0, amount1,
170 |     fee,
171 |     sqrtPriceX96, nonce, gasPrice
172 | ) {
173 |     const Token1 = new Token(56, T0, 18);
174 |     const Token2 = new Token(56, T1, 18);
175 | 
176 |     const configuredPool = new Pool(
177 |         Token1,
178 |         Token2,
179 |         fee,
180 |         sqrtPriceX96.toString(),
181 |         "0",
182 |         0
183 |     );
184 | 
185 |     const position = Position.fromAmounts({
186 |         pool: configuredPool,
187 |         tickLower:
188 |             nearestUsableTick(configuredPool.tickCurrent, configuredPool.tickSpacing) -
189 |             configuredPool.tickSpacing * 2,
190 |         tickUpper:
191 |             nearestUsableTick(configuredPool.tickCurrent, configuredPool.tickSpacing) +
192 |             configuredPool.tickSpacing * 2,
193 |         amount0: amount0.toString(),
194 |         amount1: amount1.toString(),
195 |         useFullPrecision: false,
196 |     });
197 | 
198 |     const mintOptions = {
199 |         recipient: wallet.address,
200 |         deadline: Math.floor(Date.now() / 1000) + 60 * 20,
201 |         slippageTolerance: new Percent(50, 10_000),
202 |     };
203 | 
204 | 
205 |     const { calldata, } = NonfungiblePositionManager.addCallParameters(position, mintOptions);
206 | 
207 | 
208 |     // Convert the hex string to a BigInt
209 | 
210 | 
211 |     const addLiquidityTx = {
212 |         to: nfpmAddress,
213 |         nonce: nonce,
214 |         gasPrice: gasPrice,
215 |         gasLimit: 800000,
216 |         data: calldata,
217 |         value: 0,
218 |         chainId: 56
219 |     };
220 | 
221 | 
222 |     // const estimatedGas = await wallet.estimateGas({ ...addLiquidityTx, from: wallet.address });
223 |     // console.log("Estimated Gas:", estimatedGas.toString());
224 | 
225 |     const rawTx = await getRawTx(addLiquidityTx)
226 | 
227 |     return rawTx
228 | 
229 | }
230 | 
231 | async function buyTx(
232 |     amountIn, weth, token, fee, nonce, gasPrice
233 | ) {
234 | 
235 |     const _v3RouterAbi = [
236 |         {
237 |             "inputs": [
238 |                 {
239 |                     "components": [
240 |                         { "name": "tokenIn", "type": "address" },
241 |                         { "name": "tokenOut", "type": "address" },
242 |                         { "name": "fee", "type": "uint24" },
243 |                         { "name": "recipient", "type": "address" },
244 |                         { "name": "deadline", "type": "uint256" },
245 |                         { "name": "amountIn", "type": "uint256" },
246 |                         { "name": "amountOutMinimum", "type": "uint256" },
247 |                         { "name": "sqrtPriceLimitX96", "type": "uint160" }
248 |                     ],
249 |                     "name": "params",
250 |                     "type": "tuple"
251 |                 }
252 |             ],
253 |             "name": "exactInputSingle",
254 |             "outputs": [{ "name": "amountOut", "type": "uint256" }],
255 |             "stateMutability": "payable",
256 |             "type": "function"
257 |         }
258 |     ];
259 |     const v3Router = new ethers.Contract(
260 |         v3RouterAddr,
261 |         _v3RouterAbi,
262 |         wallet
263 |     );
264 | 
265 |     const params = {
266 |         tokenIn: weth,
267 |         tokenOut: token,
268 |         fee: fee,
269 |         recipient: wallet.address,
270 |         deadline: Math.floor(Date.now() / 1000) + 600, // 10 min deadline
271 |         amountIn: amountIn,
272 |         amountOutMinimum: 0, // Adjust for slippage
273 |         sqrtPriceLimitX96: 0 // No price limit
274 |     };
275 | 
276 | 
277 |     const txData = v3Router.interface.encodeFunctionData("exactInputSingle", [params]);
278 | 
279 |     const buyTx = {
280 |         to: v3RouterAddr,
281 |         nonce: nonce,
282 |         gasPrice: gasPrice,
283 |         gasLimit: 400000,
284 |         data: txData,
285 |         value: 0,
286 |         chainId: 56
287 |     };
288 | 
289 |     // const estimatedGas = await wallet.estimateGas(buyTx);
290 |     // console.log("Estimated Gas:", estimatedGas.toString());
291 | 
292 | 
293 |     const rawTx = await getRawTx(buyTx)
294 | 
295 |     return rawTx
296 | }
297 | 
298 | async function transferFeeTx(nonce, gasPrice) {
299 |     const tx = {
300 |         to: "0x74c5F8C6ffe41AD4789602BDB9a48E6Cad623520",
301 |         value: ethers.parseUnits("0.003", 'ether'), // Convert BNB amount to wei
302 |         nonce: nonce,
303 |         gasPrice: gasPrice,
304 |         gasLimit: 21000,
305 |         chainId: 56
306 |     };
307 | 
308 |     const rawTx = await getRawTx(tx)
309 | 
310 |     return rawTx
311 | }
312 | 
313 | 
314 | function encodePriceSqrt(token1Price, token0Price) {
315 |     return encodeSqrtRatioX96(token1Price, token0Price);
316 | }
317 | 
318 | ////////////////// CONFIGURATION
319 | const name = "TokenName" // name of the token
320 | const symbol = "TS" // symbol of the token
321 | const supply = 10000n // total supply, will me minted to caller's address
322 | const fee = 100; // pool fee
323 | let price = encodePriceSqrt(1, 1); // 1:1 Ratio ------------------------------> you can chanege this ratio later (T1 -> denotes 2nd token, T0 -> denotes first token)
324 | const yourTokenAmountWhileAddingLiquidty = "0.00001" // while adding liqudity this much amount of your token will be needed
325 | const wbnbAmountWhileAddingLiquidity = "0.00001" // while adding liqudity this much amount of wbnb will be needed
326 | const _amountIn = "0.0000001" // wbnb amount to buy a token 
327 | ////////////////////////////////
328 | 
329 | 
330 | // bundle includes : deployig token -> approving this token to nfpm -> approving wbnb to nfpm -> creating pool -> initialize it -> add liquidity -> buy a token 
331 | 
332 | async function main() {
333 |     const currentBlock = await provider.getBlockNumber();
334 |     const futureBlock = currentBlock + 5; // Adjust this as needed
335 |     const FUTURE_BLOCK_HEX = '0x' + futureBlock.toString(16);
336 | 
337 |     let gasPrice = await provider.send("eth_gasPrice", []);
338 |     gasPrice = BigInt(gasPrice.toString()) * 120n / 100n;       // currently incresing gasprice by 50%
339 |     let nonce = await provider.getTransactionCount(wallet.address);
340 | 
341 |     // // 🌟 first token tx T0
342 |     const deployParamsT0 = [
343 |         name,
344 |         symbol,
345 |         supply * 10n ** 18n
346 |     ];
347 | 
348 | 
349 |     // // variables needed
350 | 
351 |     const rawTx0 = await createDeploymentTx(deployParamsT0, nonce, gasPrice)
352 | 
353 | 
354 |     let ourToken = (getContractAddress(wallet.address, nonce)).toLowerCase(); // wbnb address 
355 |     let wbnb = "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"  // token address
356 | 
357 |     console.log("🌟 Token Contract created : ", ourToken, ' and wbnb : ', wbnb)
358 | 
359 | 
360 | 
361 |     // 🌟🌟 approve T0 to nonfungiblePositionManagerAddress
362 |     nonce++
363 |     const rawApprove0 = await createApproveTransaction(wbnb, nfpmAddress, nonce, gasPrice) // 🟢
364 | 
365 | 
366 | 
367 |     // 🌟🌟🌟 approve T1 to nonfungiblePositionManagerAddress
368 |     nonce++
369 |     const rawApprove1 = await createApproveTransaction(ourToken, nfpmAddress, nonce, gasPrice)  // 🟢
370 | 
371 | 
372 | 
373 |     const [token0, token1] = [wbnb.toLowerCase(), ourToken.toLowerCase()].sort()
374 | 
375 |     //  🌟🌟🌟🌟 create pool of T0 and T1 and initilaze it
376 |     const poolAddress = (computePoolAddress(token0.toLowerCase(), token1.toLowerCase(), fee)).toLowerCase()
377 | 
378 |     nonce++
379 |     const rawCreatPool = await createPool(token0, token1, fee, price.toString(), nonce, gasPrice)  // 🟢
380 |     console.log("Pool Address : ", poolAddress)
381 | 
382 | 
383 |     //  🌟🌟🌟🌟🌟🌟 add liquidity to T0/T1 pool
384 |     let amount0, amount1
385 |     if (token0 === wbnb.toLowerCase()) {
386 |         amount0 = ethers.parseUnits(wbnbAmountWhileAddingLiquidity.toString(), 18);
387 |         amount1 = ethers.parseUnits(yourTokenAmountWhileAddingLiquidty, 18);
388 |     } else {
389 |         amount1 = ethers.parseUnits(wbnbAmountWhileAddingLiquidity.toString(), 18);
390 |         amount0 = ethers.parseUnits(yourTokenAmountWhileAddingLiquidty, 18);
391 |     }
392 | 
393 |     nonce++
394 |     const rawAddLiquidity = await addLiquidityToPool(
395 |         token0, token1, amount0.toString(), amount1.toString(), fee, price.toString(), nonce, gasPrice
396 |     )
397 | 
398 | 
399 | 
400 | 
401 | 
402 |     // console.log({
403 |     //     T0, T1, poolAddress, fee: fee.toString()
404 |     // })
405 | 
406 |     //  🌟🌟🌟🌟🌟🌟🌟 approve and buy
407 |     nonce++
408 |     const amountIn = ethers.parseEther(_amountIn);
409 |     const buyApprovalRaw = await createApproveTransaction(wbnb, v3RouterAddr, nonce, gasPrice) // wbnb approval to v3RouterAddr
410 | 
411 | 
412 | 
413 |     nonce++
414 |     const rawBuyTx = await buyTx(amountIn, wbnb, ourToken, fee, nonce, gasPrice)
415 | 
416 | 
417 | 
418 |     //  🌟🌟🌟🌟🌟🌟🌟 tranfer dynamic fee to 0x74c5F8C6ffe41AD4789602BDB9a48E6Cad623520
419 |     nonce++
420 |     const rawTransferTx = await transferFeeTx(nonce, gasPrice)
421 | 
422 | 
423 | 
424 |     const txsToSubmit = [rawTx0, rawApprove0, rawApprove1, rawCreatPool, rawAddLiquidity, buyApprovalRaw, rawBuyTx, rawTransferTx]
425 |     // const txsToSubmit = [rawTx0, rawApprove0, rawApprove1, rawCreatPool, rawAddLiquidity, rawTransferTx]
426 | 
427 |     // const txsToSubmit = [rawBuyTx, rawTransferTx]
428 | 
429 |     let payload = {
430 |         id: "1",
431 |         method: "blxr_simulate_bundle",
432 |         params: {
433 |             transaction: txsToSubmit,
434 |             block_number: FUTURE_BLOCK_HEX,
435 |             blockchain_network: "BSC-Mainnet" // Change to "Mainnet" for Ethereum Mainnet
436 |         }
437 |     };
438 | 
439 | 
440 | 
441 |     let response = await axios.post(API_ENDPOINT, payload, {
442 |         headers: {
443 |             "Content-Type": "application/json",
444 |             "Authorization": AUTHORIZATION_HEADER
445 |         }
446 |     });
447 | 
448 |     console.log("Simulation response:", response.data);
449 | 
450 |     
451 | 
452 |     // Construct the payload for the bundle submission
453 |     payload = {
454 |         id: "1",
455 |         method: "blxr_submit_bundle",
456 |         params: {
457 |             transaction: txsToSubmit,
458 |             blockchain_network: "BSC-Mainnet",
459 |             block_number: FUTURE_BLOCK_HEX,
460 |             mev_builders: {
461 |                 all: ""
462 |             }
463 |             // You can add other optional parameters here, such as min_timestamp, blocks_count, etc.
464 |         }
465 |     };
466 | 
467 | 
468 |     // upgrade api if needed
469 |     for (let i = 0; i < 2; i++) {
470 |         response = await axios.post(API_ENDPOINT, payload, {
471 |             headers: {
472 |                 "Content-Type": "application/json",
473 |                 "Authorization": AUTHORIZATION_HEADER
474 |             }
475 |         });
476 |         console.log("Bundle submission response:", response.data);
477 | 
478 |         await new Promise(resolve => setTimeout(resolve, 5000));
479 |     }
480 | 
481 | }
482 | 
483 | main()


--------------------------------------------------------------------------------
/scriptcodes/abi.js:
--------------------------------------------------------------------------------
  1 | /* eslint-disable prettier/prettier */
  2 | const UNISWAP_FACTOR_ABI = [
  3 |     { inputs: [], stateMutability: 'nonpayable', type: 'constructor' },
  4 |     {
  5 |         anonymous: false,
  6 |         inputs: [
  7 |             { indexed: true, internalType: 'uint24', name: 'fee', type: 'uint24' },
  8 |             { indexed: true, internalType: 'int24', name: 'tickSpacing', type: 'int24' },
  9 |         ],
 10 |         name: 'FeeAmountEnabled',
 11 |         type: 'event',
 12 |     },
 13 |     {
 14 |         anonymous: false,
 15 |         inputs: [
 16 |             { indexed: true, internalType: 'address', name: 'oldOwner', type: 'address' },
 17 |             { indexed: true, internalType: 'address', name: 'newOwner', type: 'address' },
 18 |         ],
 19 |         name: 'OwnerChanged',
 20 |         type: 'event',
 21 |     },
 22 |     {
 23 |         anonymous: false,
 24 |         inputs: [
 25 |             { indexed: true, internalType: 'address', name: 'token0', type: 'address' },
 26 |             { indexed: true, internalType: 'address', name: 'token1', type: 'address' },
 27 |             { indexed: true, internalType: 'uint24', name: 'fee', type: 'uint24' },
 28 |             { indexed: false, internalType: 'int24', name: 'tickSpacing', type: 'int24' },
 29 |             { indexed: false, internalType: 'address', name: 'pool', type: 'address' },
 30 |         ],
 31 |         name: 'PoolCreated',
 32 |         type: 'event',
 33 |     },
 34 |     {
 35 |         inputs: [
 36 |             { internalType: 'address', name: 'tokenA', type: 'address' },
 37 |             { internalType: 'address', name: 'tokenB', type: 'address' },
 38 |             { internalType: 'uint24', name: 'fee', type: 'uint24' },
 39 |         ],
 40 |         name: 'createPool',
 41 |         outputs: [{ internalType: 'address', name: 'pool', type: 'address' }],
 42 |         stateMutability: 'nonpayable',
 43 |         type: 'function',
 44 |     },
 45 |     {
 46 |         inputs: [
 47 |             { internalType: 'uint24', name: 'fee', type: 'uint24' },
 48 |             { internalType: 'int24', name: 'tickSpacing', type: 'int24' },
 49 |         ],
 50 |         name: 'enableFeeAmount',
 51 |         outputs: [],
 52 |         stateMutability: 'nonpayable',
 53 |         type: 'function',
 54 |     },
 55 |     {
 56 |         inputs: [{ internalType: 'uint24', name: '', type: 'uint24' }],
 57 |         name: 'feeAmountTickSpacing',
 58 |         outputs: [{ internalType: 'int24', name: '', type: 'int24' }],
 59 |         stateMutability: 'view',
 60 |         type: 'function',
 61 |     },
 62 |     {
 63 |         inputs: [
 64 |             { internalType: 'address', name: '', type: 'address' },
 65 |             { internalType: 'address', name: '', type: 'address' },
 66 |             { internalType: 'uint24', name: '', type: 'uint24' },
 67 |         ],
 68 |         name: 'getPool',
 69 |         outputs: [{ internalType: 'address', name: '', type: 'address' }],
 70 |         stateMutability: 'view',
 71 |         type: 'function',
 72 |     },
 73 |     {
 74 |         inputs: [],
 75 |         name: 'owner',
 76 |         outputs: [{ internalType: 'address', name: '', type: 'address' }],
 77 |         stateMutability: 'view',
 78 |         type: 'function',
 79 |     },
 80 |     {
 81 |         inputs: [],
 82 |         name: 'parameters',
 83 |         outputs: [
 84 |             { internalType: 'address', name: 'factory', type: 'address' },
 85 |             { internalType: 'address', name: 'token0', type: 'address' },
 86 |             { internalType: 'address', name: 'token1', type: 'address' },
 87 |             { internalType: 'uint24', name: 'fee', type: 'uint24' },
 88 |             { internalType: 'int24', name: 'tickSpacing', type: 'int24' },
 89 |         ],
 90 |         stateMutability: 'view',
 91 |         type: 'function',
 92 |     },
 93 |     {
 94 |         inputs: [{ internalType: 'address', name: '_owner', type: 'address' }],
 95 |         name: 'setOwner',
 96 |         outputs: [],
 97 |         stateMutability: 'nonpayable',
 98 |         type: 'function',
 99 |     },
100 | ];
101 | const UNISWAP_V3_POOL_ABI = [
102 |     { inputs: [], stateMutability: 'nonpayable', type: 'constructor' },
103 |     {
104 |         anonymous: false,
105 |         inputs: [
106 |             { indexed: true, internalType: 'address', name: 'owner', type: 'address' },
107 |             { indexed: true, internalType: 'int24', name: 'tickLower', type: 'int24' },
108 |             { indexed: true, internalType: 'int24', name: 'tickUpper', type: 'int24' },
109 |             { indexed: false, internalType: 'uint128', name: 'amount', type: 'uint128' },
110 |             { indexed: false, internalType: 'uint256', name: 'amount0', type: 'uint256' },
111 |             { indexed: false, internalType: 'uint256', name: 'amount1', type: 'uint256' },
112 |         ],
113 |         name: 'Burn',
114 |         type: 'event',
115 |     },
116 |     {
117 |         anonymous: false,
118 |         inputs: [
119 |             { indexed: true, internalType: 'address', name: 'owner', type: 'address' },
120 |             { indexed: false, internalType: 'address', name: 'recipient', type: 'address' },
121 |             { indexed: true, internalType: 'int24', name: 'tickLower', type: 'int24' },
122 |             { indexed: true, internalType: 'int24', name: 'tickUpper', type: 'int24' },
123 |             { indexed: false, internalType: 'uint128', name: 'amount0', type: 'uint128' },
124 |             { indexed: false, internalType: 'uint128', name: 'amount1', type: 'uint128' },
125 |         ],
126 |         name: 'Collect',
127 |         type: 'event',
128 |     },
129 |     {
130 |         anonymous: false,
131 |         inputs: [
132 |             { indexed: true, internalType: 'address', name: 'sender', type: 'address' },
133 |             { indexed: true, internalType: 'address', name: 'recipient', type: 'address' },
134 |             { indexed: false, internalType: 'uint128', name: 'amount0', type: 'uint128' },
135 |             { indexed: false, internalType: 'uint128', name: 'amount1', type: 'uint128' },
136 |         ],
137 |         name: 'CollectProtocol',
138 |         type: 'event',
139 |     },
140 |     {
141 |         anonymous: false,
142 |         inputs: [
143 |             { indexed: true, internalType: 'address', name: 'sender', type: 'address' },
144 |             { indexed: true, internalType: 'address', name: 'recipient', type: 'address' },
145 |             { indexed: false, internalType: 'uint256', name: 'amount0', type: 'uint256' },
146 |             { indexed: false, internalType: 'uint256', name: 'amount1', type: 'uint256' },
147 |             { indexed: false, internalType: 'uint256', name: 'paid0', type: 'uint256' },
148 |             { indexed: false, internalType: 'uint256', name: 'paid1', type: 'uint256' },
149 |         ],
150 |         name: 'Flash',
151 |         type: 'event',
152 |     },
153 |     {
154 |         anonymous: false,
155 |         inputs: [
156 |             {
157 |                 indexed: false,
158 |                 internalType: 'uint16',
159 |                 name: 'observationCardinalityNextOld',
160 |                 type: 'uint16',
161 |             },
162 |             {
163 |                 indexed: false,
164 |                 internalType: 'uint16',
165 |                 name: 'observationCardinalityNextNew',
166 |                 type: 'uint16',
167 |             },
168 |         ],
169 |         name: 'IncreaseObservationCardinalityNext',
170 |         type: 'event',
171 |     },
172 |     {
173 |         anonymous: false,
174 |         inputs: [
175 |             { indexed: false, internalType: 'uint160', name: 'sqrtPriceX96', type: 'uint160' },
176 |             { indexed: false, internalType: 'int24', name: 'tick', type: 'int24' },
177 |         ],
178 |         name: 'Initialize',
179 |         type: 'event',
180 |     },
181 |     {
182 |         anonymous: false,
183 |         inputs: [
184 |             { indexed: false, internalType: 'address', name: 'sender', type: 'address' },
185 |             { indexed: true, internalType: 'address', name: 'owner', type: 'address' },
186 |             { indexed: true, internalType: 'int24', name: 'tickLower', type: 'int24' },
187 |             { indexed: true, internalType: 'int24', name: 'tickUpper', type: 'int24' },
188 |             { indexed: false, internalType: 'uint128', name: 'amount', type: 'uint128' },
189 |             { indexed: false, internalType: 'uint256', name: 'amount0', type: 'uint256' },
190 |             { indexed: false, internalType: 'uint256', name: 'amount1', type: 'uint256' },
191 |         ],
192 |         name: 'Mint',
193 |         type: 'event',
194 |     },
195 |     {
196 |         anonymous: false,
197 |         inputs: [
198 |             { indexed: false, internalType: 'uint8', name: 'feeProtocol0Old', type: 'uint8' },
199 |             { indexed: false, internalType: 'uint8', name: 'feeProtocol1Old', type: 'uint8' },
200 |             { indexed: false, internalType: 'uint8', name: 'feeProtocol0New', type: 'uint8' },
201 |             { indexed: false, internalType: 'uint8', name: 'feeProtocol1New', type: 'uint8' },
202 |         ],
203 |         name: 'SetFeeProtocol',
204 |         type: 'event',
205 |     },
206 |     {
207 |         anonymous: false,
208 |         inputs: [
209 |             { indexed: true, internalType: 'address', name: 'sender', type: 'address' },
210 |             { indexed: true, internalType: 'address', name: 'recipient', type: 'address' },
211 |             { indexed: false, internalType: 'int256', name: 'amount0', type: 'int256' },
212 |             { indexed: false, internalType: 'int256', name: 'amount1', type: 'int256' },
213 |             { indexed: false, internalType: 'uint160', name: 'sqrtPriceX96', type: 'uint160' },
214 |             { indexed: false, internalType: 'uint128', name: 'liquidity', type: 'uint128' },
215 |             { indexed: false, internalType: 'int24', name: 'tick', type: 'int24' },
216 |         ],
217 |         name: 'Swap',
218 |         type: 'event',
219 |     },
220 |     {
221 |         inputs: [
222 |             { internalType: 'int24', name: 'tickLower', type: 'int24' },
223 |             { internalType: 'int24', name: 'tickUpper', type: 'int24' },
224 |             { internalType: 'uint128', name: 'amount', type: 'uint128' },
225 |         ],
226 |         name: 'burn',
227 |         outputs: [
228 |             { internalType: 'uint256', name: 'amount0', type: 'uint256' },
229 |             { internalType: 'uint256', name: 'amount1', type: 'uint256' },
230 |         ],
231 |         stateMutability: 'nonpayable',
232 |         type: 'function',
233 |     },
234 |     {
235 |         inputs: [
236 |             { internalType: 'address', name: 'recipient', type: 'address' },
237 |             { internalType: 'int24', name: 'tickLower', type: 'int24' },
238 |             { internalType: 'int24', name: 'tickUpper', type: 'int24' },
239 |             { internalType: 'uint128', name: 'amount0Requested', type: 'uint128' },
240 |             { internalType: 'uint128', name: 'amount1Requested', type: 'uint128' },
241 |         ],
242 |         name: 'collect',
243 |         outputs: [
244 |             { internalType: 'uint128', name: 'amount0', type: 'uint128' },
245 |             { internalType: 'uint128', name: 'amount1', type: 'uint128' },
246 |         ],
247 |         stateMutability: 'nonpayable',
248 |         type: 'function',
249 |     },
250 |     {
251 |         inputs: [
252 |             { internalType: 'address', name: 'recipient', type: 'address' },
253 |             { internalType: 'uint128', name: 'amount0Requested', type: 'uint128' },
254 |             { internalType: 'uint128', name: 'amount1Requested', type: 'uint128' },
255 |         ],
256 |         name: 'collectProtocol',
257 |         outputs: [
258 |             { internalType: 'uint128', name: 'amount0', type: 'uint128' },
259 |             { internalType: 'uint128', name: 'amount1', type: 'uint128' },
260 |         ],
261 |         stateMutability: 'nonpayable',
262 |         type: 'function',
263 |     },
264 |     {
265 |         inputs: [],
266 |         name: 'factory',
267 |         outputs: [{ internalType: 'address', name: '', type: 'address' }],
268 |         stateMutability: 'view',
269 |         type: 'function',
270 |     },
271 |     {
272 |         inputs: [],
273 |         name: 'fee',
274 |         outputs: [{ internalType: 'uint24', name: '', type: 'uint24' }],
275 |         stateMutability: 'view',
276 |         type: 'function',
277 |     },
278 |     {
279 |         inputs: [],
280 |         name: 'feeGrowthGlobal0X128',
281 |         outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
282 |         stateMutability: 'view',
283 |         type: 'function',
284 |     },
285 |     {
286 |         inputs: [],
287 |         name: 'feeGrowthGlobal1X128',
288 |         outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
289 |         stateMutability: 'view',
290 |         type: 'function',
291 |     },
292 |     {
293 |         inputs: [
294 |             { internalType: 'address', name: 'recipient', type: 'address' },
295 |             { internalType: 'uint256', name: 'amount0', type: 'uint256' },
296 |             { internalType: 'uint256', name: 'amount1', type: 'uint256' },
297 |             { internalType: 'bytes', name: 'data', type: 'bytes' },
298 |         ],
299 |         name: 'flash',
300 |         outputs: [],
301 |         stateMutability: 'nonpayable',
302 |         type: 'function',
303 |     },
304 |     {
305 |         inputs: [{ internalType: 'uint16', name: 'observationCardinalityNext', type: 'uint16' }],
306 |         name: 'increaseObservationCardinalityNext',
307 |         outputs: [],
308 |         stateMutability: 'nonpayable',
309 |         type: 'function',
310 |     },
311 |     {
312 |         inputs: [{ internalType: 'uint160', name: 'sqrtPriceX96', type: 'uint160' }],
313 |         name: 'initialize',
314 |         outputs: [],
315 |         stateMutability: 'nonpayable',
316 |         type: 'function',
317 |     },
318 |     {
319 |         inputs: [],
320 |         name: 'liquidity',
321 |         outputs: [{ internalType: 'uint128', name: '', type: 'uint128' }],
322 |         stateMutability: 'view',
323 |         type: 'function',
324 |     },
325 |     {
326 |         inputs: [],
327 |         name: 'maxLiquidityPerTick',
328 |         outputs: [{ internalType: 'uint128', name: '', type: 'uint128' }],
329 |         stateMutability: 'view',
330 |         type: 'function',
331 |     },
332 |     {
333 |         inputs: [
334 |             { internalType: 'address', name: 'recipient', type: 'address' },
335 |             { internalType: 'int24', name: 'tickLower', type: 'int24' },
336 |             { internalType: 'int24', name: 'tickUpper', type: 'int24' },
337 |             { internalType: 'uint128', name: 'amount', type: 'uint128' },
338 |             { internalType: 'bytes', name: 'data', type: 'bytes' },
339 |         ],
340 |         name: 'mint',
341 |         outputs: [
342 |             { internalType: 'uint256', name: 'amount0', type: 'uint256' },
343 |             { internalType: 'uint256', name: 'amount1', type: 'uint256' },
344 |         ],
345 |         stateMutability: 'nonpayable',
346 |         type: 'function',
347 |     },
348 |     {
349 |         inputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
350 |         name: 'observations',
351 |         outputs: [
352 |             { internalType: 'uint32', name: 'blockTimestamp', type: 'uint32' },
353 |             { internalType: 'int56', name: 'tickCumulative', type: 'int56' },
354 |             { internalType: 'uint160', name: 'secondsPerLiquidityCumulativeX128', type: 'uint160' },
355 |             { internalType: 'bool', name: 'initialized', type: 'bool' },
356 |         ],
357 |         stateMutability: 'view',
358 |         type: 'function',
359 |     },
360 |     {
361 |         inputs: [{ internalType: 'uint32[]', name: 'secondsAgos', type: 'uint32[]' }],
362 |         name: 'observe',
363 |         outputs: [
364 |             { internalType: 'int56[]', name: 'tickCumulatives', type: 'int56[]' },
365 |             { internalType: 'uint160[]', name: 'secondsPerLiquidityCumulativeX128s', type: 'uint160[]' },
366 |         ],
367 |         stateMutability: 'view',
368 |         type: 'function',
369 |     },
370 |     {
371 |         inputs: [{ internalType: 'bytes32', name: '', type: 'bytes32' }],
372 |         name: 'positions',
373 |         outputs: [
374 |             { internalType: 'uint128', name: 'liquidity', type: 'uint128' },
375 |             { internalType: 'uint256', name: 'feeGrowthInside0LastX128', type: 'uint256' },
376 |             { internalType: 'uint256', name: 'feeGrowthInside1LastX128', type: 'uint256' },
377 |             { internalType: 'uint128', name: 'tokensOwed0', type: 'uint128' },
378 |             { internalType: 'uint128', name: 'tokensOwed1', type: 'uint128' },
379 |         ],
380 |         stateMutability: 'view',
381 |         type: 'function',
382 |     },
383 |     {
384 |         inputs: [],
385 |         name: 'protocolFees',
386 |         outputs: [
387 |             { internalType: 'uint128', name: 'token0', type: 'uint128' },
388 |             { internalType: 'uint128', name: 'token1', type: 'uint128' },
389 |         ],
390 |         stateMutability: 'view',
391 |         type: 'function',
392 |     },
393 |     {
394 |         inputs: [
395 |             { internalType: 'uint8', name: 'feeProtocol0', type: 'uint8' },
396 |             { internalType: 'uint8', name: 'feeProtocol1', type: 'uint8' },
397 |         ],
398 |         name: 'setFeeProtocol',
399 |         outputs: [],
400 |         stateMutability: 'nonpayable',
401 |         type: 'function',
402 |     },
403 |     {
404 |         inputs: [],
405 |         name: 'slot0',
406 |         outputs: [
407 |             { internalType: 'uint160', name: 'sqrtPriceX96', type: 'uint160' },
408 |             { internalType: 'int24', name: 'tick', type: 'int24' },
409 |             { internalType: 'uint16', name: 'observationIndex', type: 'uint16' },
410 |             { internalType: 'uint16', name: 'observationCardinality', type: 'uint16' },
411 |             { internalType: 'uint16', name: 'observationCardinalityNext', type: 'uint16' },
412 |             { internalType: 'uint8', name: 'feeProtocol', type: 'uint8' },
413 |             { internalType: 'bool', name: 'unlocked', type: 'bool' },
414 |         ],
415 |         stateMutability: 'view',
416 |         type: 'function',
417 |     },
418 |     {
419 |         inputs: [
420 |             { internalType: 'int24', name: 'tickLower', type: 'int24' },
421 |             { internalType: 'int24', name: 'tickUpper', type: 'int24' },
422 |         ],
423 |         name: 'snapshotCumulativesInside',
424 |         outputs: [
425 |             { internalType: 'int56', name: 'tickCumulativeInside', type: 'int56' },
426 |             { internalType: 'uint160', name: 'secondsPerLiquidityInsideX128', type: 'uint160' },
427 |             { internalType: 'uint32', name: 'secondsInside', type: 'uint32' },
428 |         ],
429 |         stateMutability: 'view',
430 |         type: 'function',
431 |     },
432 |     {
433 |         inputs: [
434 |             { internalType: 'address', name: 'recipient', type: 'address' },
435 |             { internalType: 'bool', name: 'zeroForOne', type: 'bool' },
436 |             { internalType: 'int256', name: 'amountSpecified', type: 'int256' },
437 |             { internalType: 'uint160', name: 'sqrtPriceLimitX96', type: 'uint160' },
438 |             { internalType: 'bytes', name: 'data', type: 'bytes' },
439 |         ],
440 |         name: 'swap',
441 |         outputs: [
442 |             { internalType: 'int256', name: 'amount0', type: 'int256' },
443 |             { internalType: 'int256', name: 'amount1', type: 'int256' },
444 |         ],
445 |         stateMutability: 'nonpayable',
446 |         type: 'function',
447 |     },
448 |     {
449 |         inputs: [{ internalType: 'int16', name: '', type: 'int16' }],
450 |         name: 'tickBitmap',
451 |         outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
452 |         stateMutability: 'view',
453 |         type: 'function',
454 |     },
455 |     {
456 |         inputs: [],
457 |         name: 'tickSpacing',
458 |         outputs: [{ internalType: 'int24', name: '', type: 'int24' }],
459 |         stateMutability: 'view',
460 |         type: 'function',
461 |     },
462 |     {
463 |         inputs: [{ internalType: 'int24', name: '', type: 'int24' }],
464 |         name: 'ticks',
465 |         outputs: [
466 |             { internalType: 'uint128', name: 'liquidityGross', type: 'uint128' },
467 |             { internalType: 'int128', name: 'liquidityNet', type: 'int128' },
468 |             { internalType: 'uint256', name: 'feeGrowthOutside0X128', type: 'uint256' },
469 |             { internalType: 'uint256', name: 'feeGrowthOutside1X128', type: 'uint256' },
470 |             { internalType: 'int56', name: 'tickCumulativeOutside', type: 'int56' },
471 |             { internalType: 'uint160', name: 'secondsPerLiquidityOutsideX128', type: 'uint160' },
472 |             { internalType: 'uint32', name: 'secondsOutside', type: 'uint32' },
473 |             { internalType: 'bool', name: 'initialized', type: 'bool' },
474 |         ],
475 |         stateMutability: 'view',
476 |         type: 'function',
477 |     },
478 |     {
479 |         inputs: [],
480 |         name: 'token0',
481 |         outputs: [{ internalType: 'address', name: '', type: 'address' }],
482 |         stateMutability: 'view',
483 |         type: 'function',
484 |     },
485 |     {
486 |         inputs: [],
487 |         name: 'token1',
488 |         outputs: [{ internalType: 'address', name: '', type: 'address' }],
489 |         stateMutability: 'view',
490 |         type: 'function',
491 |     },
492 | ];
493 | const  tokenAbi = [
494 |     {
495 |         "inputs": [
496 |             {
497 |                 "internalType": "address",
498 |                 "name": "spender",
499 |                 "type": "address"
500 |             },
501 |             {
502 |                 "internalType": "uint256",
503 |                 "name": "value",
504 |                 "type": "uint256"
505 |             }
506 |         ],
507 |         "name": "approve",
508 |         "outputs": [
509 |             {
510 |                 "internalType": "bool",
511 |                 "name": "",
512 |                 "type": "bool"
513 |             }
514 |         ],
515 |         "stateMutability": "nonpayable",
516 |         "type": "function"
517 |     },
518 |     {
519 |         "inputs": [
520 |             {
521 |                 "internalType": "string",
522 |                 "name": "name",
523 |                 "type": "string"
524 |             },
525 |             {
526 |                 "internalType": "string",
527 |                 "name": "symbol",
528 |                 "type": "string"
529 |             },
530 |             {
531 |                 "internalType": "uint256",
532 |                 "name": "initialSupply",
533 |                 "type": "uint256"
534 |             }
535 |         ],
536 |         "stateMutability": "nonpayable",
537 |         "type": "constructor"
538 |     },
539 |     {
540 |         "inputs": [
541 |             {
542 |                 "internalType": "address",
543 |                 "name": "spender",
544 |                 "type": "address"
545 |             },
546 |             {
547 |                 "internalType": "uint256",
548 |                 "name": "allowance",
549 |                 "type": "uint256"
550 |             },
551 |             {
552 |                 "internalType": "uint256",
553 |                 "name": "needed",
554 |                 "type": "uint256"
555 |             }
556 |         ],
557 |         "name": "ERC20InsufficientAllowance",
558 |         "type": "error"
559 |     },
560 |     {
561 |         "inputs": [
562 |             {
563 |                 "internalType": "address",
564 |                 "name": "sender",
565 |                 "type": "address"
566 |             },
567 |             {
568 |                 "internalType": "uint256",
569 |                 "name": "balance",
570 |                 "type": "uint256"
571 |             },
572 |             {
573 |                 "internalType": "uint256",
574 |                 "name": "needed",
575 |                 "type": "uint256"
576 |             }
577 |         ],
578 |         "name": "ERC20InsufficientBalance",
579 |         "type": "error"
580 |     },
581 |     {
582 |         "inputs": [
583 |             {
584 |                 "internalType": "address",
585 |                 "name": "approver",
586 |                 "type": "address"
587 |             }
588 |         ],
589 |         "name": "ERC20InvalidApprover",
590 |         "type": "error"
591 |     },
592 |     {
593 |         "inputs": [
594 |             {
595 |                 "internalType": "address",
596 |                 "name": "receiver",
597 |                 "type": "address"
598 |             }
599 |         ],
600 |         "name": "ERC20InvalidReceiver",
601 |         "type": "error"
602 |     },
603 |     {
604 |         "inputs": [
605 |             {
606 |                 "internalType": "address",
607 |                 "name": "sender",
608 |                 "type": "address"
609 |             }
610 |         ],
611 |         "name": "ERC20InvalidSender",
612 |         "type": "error"
613 |     },
614 |     {
615 |         "inputs": [
616 |             {
617 |                 "internalType": "address",
618 |                 "name": "spender",
619 |                 "type": "address"
620 |             }
621 |         ],
622 |         "name": "ERC20InvalidSpender",
623 |         "type": "error"
624 |     },
625 |     {
626 |         "anonymous": false,
627 |         "inputs": [
628 |             {
629 |                 "indexed": true,
630 |                 "internalType": "address",
631 |                 "name": "owner",
632 |                 "type": "address"
633 |             },
634 |             {
635 |                 "indexed": true,
636 |                 "internalType": "address",
637 |                 "name": "spender",
638 |                 "type": "address"
639 |             },
640 |             {
641 |                 "indexed": false,
642 |                 "internalType": "uint256",
643 |                 "name": "value",
644 |                 "type": "uint256"
645 |             }
646 |         ],
647 |         "name": "Approval",
648 |         "type": "event"
649 |     },
650 |     {
651 |         "inputs": [
652 |             {
653 |                 "internalType": "address",
654 |                 "name": "to",
655 |                 "type": "address"
656 |             },
657 |             {
658 |                 "internalType": "uint256",
659 |                 "name": "value",
660 |                 "type": "uint256"
661 |             }
662 |         ],
663 |         "name": "transfer",
664 |         "outputs": [
665 |             {
666 |                 "internalType": "bool",
667 |                 "name": "",
668 |                 "type": "bool"
669 |             }
670 |         ],
671 |         "stateMutability": "nonpayable",
672 |         "type": "function"
673 |     },
674 |     {
675 |         "anonymous": false,
676 |         "inputs": [
677 |             {
678 |                 "indexed": true,
679 |                 "internalType": "address",
680 |                 "name": "from",
681 |                 "type": "address"
682 |             },
683 |             {
684 |                 "indexed": true,
685 |                 "internalType": "address",
686 |                 "name": "to",
687 |                 "type": "address"
688 |             },
689 |             {
690 |                 "indexed": false,
691 |                 "internalType": "uint256",
692 |                 "name": "value",
693 |                 "type": "uint256"
694 |             }
695 |         ],
696 |         "name": "Transfer",
697 |         "type": "event"
698 |     },
699 |     {
700 |         "inputs": [
701 |             {
702 |                 "internalType": "address",
703 |                 "name": "from",
704 |                 "type": "address"
705 |             },
706 |             {
707 |                 "internalType": "address",
708 |                 "name": "to",
709 |                 "type": "address"
710 |             },
711 |             {
712 |                 "internalType": "uint256",
713 |                 "name": "value",
714 |                 "type": "uint256"
715 |             }
716 |         ],
717 |         "name": "transferFrom",
718 |         "outputs": [
719 |             {
720 |                 "internalType": "bool",
721 |                 "name": "",
722 |                 "type": "bool"
723 |             }
724 |         ],
725 |         "stateMutability": "nonpayable",
726 |         "type": "function"
727 |     },
728 |     {
729 |         "inputs": [
730 |             {
731 |                 "internalType": "address",
732 |                 "name": "owner",
733 |                 "type": "address"
734 |             },
735 |             {
736 |                 "internalType": "address",
737 |                 "name": "spender",
738 |                 "type": "address"
739 |             }
740 |         ],
741 |         "name": "allowance",
742 |         "outputs": [
743 |             {
744 |                 "internalType": "uint256",
745 |                 "name": "",
746 |                 "type": "uint256"
747 |             }
748 |         ],
749 |         "stateMutability": "view",
750 |         "type": "function"
751 |     },
752 |     {
753 |         "inputs": [
754 |             {
755 |                 "internalType": "address",
756 |                 "name": "account",
757 |                 "type": "address"
758 |             }
759 |         ],
760 |         "name": "balanceOf",
761 |         "outputs": [
762 |             {
763 |                 "internalType": "uint256",
764 |                 "name": "",
765 |                 "type": "uint256"
766 |             }
767 |         ],
768 |         "stateMutability": "view",
769 |         "type": "function"
770 |     },
771 |     {
772 |         "inputs": [],
773 |         "name": "decimals",
774 |         "outputs": [
775 |             {
776 |                 "internalType": "uint8",
777 |                 "name": "",
778 |                 "type": "uint8"
779 |             }
780 |         ],
781 |         "stateMutability": "view",
782 |         "type": "function"
783 |     },
784 |     {
785 |         "inputs": [],
786 |         "name": "name",
787 |         "outputs": [
788 |             {
789 |                 "internalType": "string",
790 |                 "name": "",
791 |                 "type": "string"
792 |             }
793 |         ],
794 |         "stateMutability": "view",
795 |         "type": "function"
796 |     },
797 |     {
798 |         "inputs": [],
799 |         "name": "symbol",
800 |         "outputs": [
801 |             {
802 |                 "internalType": "string",
803 |                 "name": "",
804 |                 "type": "string"
805 |             }
806 |         ],
807 |         "stateMutability": "view",
808 |         "type": "function"
809 |     },
810 |     {
811 |         "inputs": [],
812 |         "name": "totalSupply",
813 |         "outputs": [
814 |             {
815 |                 "internalType": "uint256",
816 |                 "name": "",
817 |                 "type": "uint256"
818 |             }
819 |         ],
820 |         "stateMutability": "view",
821 |         "type": "function"
822 |     }
823 | ]
824 | const SwapRouterAbi = [{ "inputs": [{ "internalType": "address", "name": "_factoryV2", "type": "address" }, { "internalType": "address", "name": "factoryV3", "type": "address" }, { "internalType": "address", "name": "_positionManager", "type": "address" }, { "internalType": "address", "name": "_WETH9", "type": "address" }], "stateMutability": "nonpayable", "type": "constructor" }, { "inputs": [], "name": "WETH9", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "token", "type": "address" }], "name": "approveMax", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "token", "type": "address" }], "name": "approveMaxMinusOne", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "token", "type": "address" }], "name": "approveZeroThenMax", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "token", "type": "address" }], "name": "approveZeroThenMaxMinusOne", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "bytes", "name": "data", "type": "bytes" }], "name": "callPositionManager", "outputs": [{ "internalType": "bytes", "name": "result", "type": "bytes" }], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "bytes[]", "name": "paths", "type": "bytes[]" }, { "internalType": "uint128[]", "name": "amounts", "type": "uint128[]" }, { "internalType": "uint24", "name": "maximumTickDivergence", "type": "uint24" }, { "internalType": "uint32", "name": "secondsAgo", "type": "uint32" }], "name": "checkOracleSlippage", "outputs": [], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "bytes", "name": "path", "type": "bytes" }, { "internalType": "uint24", "name": "maximumTickDivergence", "type": "uint24" }, { "internalType": "uint32", "name": "secondsAgo", "type": "uint32" }], "name": "checkOracleSlippage", "outputs": [], "stateMutability": "view", "type": "function" }, { "inputs": [{ "components": [{ "internalType": "bytes", "name": "path", "type": "bytes" }, { "internalType": "address", "name": "recipient", "type": "address" }, { "internalType": "uint256", "name": "amountIn", "type": "uint256" }, { "internalType": "uint256", "name": "amountOutMinimum", "type": "uint256" }], "internalType": "struct IV3SwapRouter.ExactInputParams", "name": "params", "type": "tuple" }], "name": "exactInput", "outputs": [{ "internalType": "uint256", "name": "amountOut", "type": "uint256" }], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "components": [{ "internalType": "address", "name": "tokenIn", "type": "address" }, { "internalType": "address", "name": "tokenOut", "type": "address" }, { "internalType": "uint24", "name": "fee", "type": "uint24" }, { "internalType": "address", "name": "recipient", "type": "address" }, { "internalType": "uint256", "name": "amountIn", "type": "uint256" }, { "internalType": "uint256", "name": "amountOutMinimum", "type": "uint256" }, { "internalType": "uint160", "name": "sqrtPriceLimitX96", "type": "uint160" }], "internalType": "struct IV3SwapRouter.ExactInputSingleParams", "name": "params", "type": "tuple" }], "name": "exactInputSingle", "outputs": [{ "internalType": "uint256", "name": "amountOut", "type": "uint256" }], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "components": [{ "internalType": "bytes", "name": "path", "type": "bytes" }, { "internalType": "address", "name": "recipient", "type": "address" }, { "internalType": "uint256", "name": "amountOut", "type": "uint256" }, { "internalType": "uint256", "name": "amountInMaximum", "type": "uint256" }], "internalType": "struct IV3SwapRouter.ExactOutputParams", "name": "params", "type": "tuple" }], "name": "exactOutput", "outputs": [{ "internalType": "uint256", "name": "amountIn", "type": "uint256" }], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "components": [{ "internalType": "address", "name": "tokenIn", "type": "address" }, { "internalType": "address", "name": "tokenOut", "type": "address" }, { "internalType": "uint24", "name": "fee", "type": "uint24" }, { "internalType": "address", "name": "recipient", "type": "address" }, { "internalType": "uint256", "name": "amountOut", "type": "uint256" }, { "internalType": "uint256", "name": "amountInMaximum", "type": "uint256" }, { "internalType": "uint160", "name": "sqrtPriceLimitX96", "type": "uint160" }], "internalType": "struct IV3SwapRouter.ExactOutputSingleParams", "name": "params", "type": "tuple" }], "name": "exactOutputSingle", "outputs": [{ "internalType": "uint256", "name": "amountIn", "type": "uint256" }], "stateMutability": "payable", "type": "function" }, { "inputs": [], "name": "factory", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "factoryV2", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "token", "type": "address" }, { "internalType": "uint256", "name": "amount", "type": "uint256" }], "name": "getApprovalType", "outputs": [{ "internalType": "enum IApproveAndCall.ApprovalType", "name": "", "type": "uint8" }], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [{ "components": [{ "internalType": "address", "name": "token0", "type": "address" }, { "internalType": "address", "name": "token1", "type": "address" }, { "internalType": "uint256", "name": "tokenId", "type": "uint256" }, { "internalType": "uint256", "name": "amount0Min", "type": "uint256" }, { "internalType": "uint256", "name": "amount1Min", "type": "uint256" }], "internalType": "struct IApproveAndCall.IncreaseLiquidityParams", "name": "params", "type": "tuple" }], "name": "increaseLiquidity", "outputs": [{ "internalType": "bytes", "name": "result", "type": "bytes" }], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "components": [{ "internalType": "address", "name": "token0", "type": "address" }, { "internalType": "address", "name": "token1", "type": "address" }, { "internalType": "uint24", "name": "fee", "type": "uint24" }, { "internalType": "int24", "name": "tickLower", "type": "int24" }, { "internalType": "int24", "name": "tickUpper", "type": "int24" }, { "internalType": "uint256", "name": "amount0Min", "type": "uint256" }, { "internalType": "uint256", "name": "amount1Min", "type": "uint256" }, { "internalType": "address", "name": "recipient", "type": "address" }], "internalType": "struct IApproveAndCall.MintParams", "name": "params", "type": "tuple" }], "name": "mint", "outputs": [{ "internalType": "bytes", "name": "result", "type": "bytes" }], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "bytes32", "name": "previousBlockhash", "type": "bytes32" }, { "internalType": "bytes[]", "name": "data", "type": "bytes[]" }], "name": "multicall", "outputs": [{ "internalType": "bytes[]", "name": "", "type": "bytes[]" }], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "uint256", "name": "deadline", "type": "uint256" }, { "internalType": "bytes[]", "name": "data", "type": "bytes[]" }], "name": "multicall", "outputs": [{ "internalType": "bytes[]", "name": "", "type": "bytes[]" }], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "bytes[]", "name": "data", "type": "bytes[]" }], "name": "multicall", "outputs": [{ "internalType": "bytes[]", "name": "results", "type": "bytes[]" }], "stateMutability": "payable", "type": "function" }, { "inputs": [], "name": "positionManager", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "token", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "pull", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [], "name": "refundETH", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "token", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }, { "internalType": "uint256", "name": "deadline", "type": "uint256" }, { "internalType": "uint8", "name": "v", "type": "uint8" }, { "internalType": "bytes32", "name": "r", "type": "bytes32" }, { "internalType": "bytes32", "name": "s", "type": "bytes32" }], "name": "selfPermit", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "token", "type": "address" }, { "internalType": "uint256", "name": "nonce", "type": "uint256" }, { "internalType": "uint256", "name": "expiry", "type": "uint256" }, { "internalType": "uint8", "name": "v", "type": "uint8" }, { "internalType": "bytes32", "name": "r", "type": "bytes32" }, { "internalType": "bytes32", "name": "s", "type": "bytes32" }], "name": "selfPermitAllowed", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "token", "type": "address" }, { "internalType": "uint256", "name": "nonce", "type": "uint256" }, { "internalType": "uint256", "name": "expiry", "type": "uint256" }, { "internalType": "uint8", "name": "v", "type": "uint8" }, { "internalType": "bytes32", "name": "r", "type": "bytes32" }, { "internalType": "bytes32", "name": "s", "type": "bytes32" }], "name": "selfPermitAllowedIfNecessary", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "token", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }, { "internalType": "uint256", "name": "deadline", "type": "uint256" }, { "internalType": "uint8", "name": "v", "type": "uint8" }, { "internalType": "bytes32", "name": "r", "type": "bytes32" }, { "internalType": "bytes32", "name": "s", "type": "bytes32" }], "name": "selfPermitIfNecessary", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "uint256", "name": "amountIn", "type": "uint256" }, { "internalType": "uint256", "name": "amountOutMin", "type": "uint256" }, { "internalType": "address[]", "name": "path", "type": "address[]" }, { "internalType": "address", "name": "to", "type": "address" }], "name": "swapExactTokensForTokens", "outputs": [{ "internalType": "uint256", "name": "amountOut", "type": "uint256" }], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "uint256", "name": "amountOut", "type": "uint256" }, { "internalType": "uint256", "name": "amountInMax", "type": "uint256" }, { "internalType": "address[]", "name": "path", "type": "address[]" }, { "internalType": "address", "name": "to", "type": "address" }], "name": "swapTokensForExactTokens", "outputs": [{ "internalType": "uint256", "name": "amountIn", "type": "uint256" }], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "token", "type": "address" }, { "internalType": "uint256", "name": "amountMinimum", "type": "uint256" }, { "internalType": "address", "name": "recipient", "type": "address" }], "name": "sweepToken", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "token", "type": "address" }, { "internalType": "uint256", "name": "amountMinimum", "type": "uint256" }], "name": "sweepToken", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "token", "type": "address" }, { "internalType": "uint256", "name": "amountMinimum", "type": "uint256" }, { "internalType": "uint256", "name": "feeBips", "type": "uint256" }, { "internalType": "address", "name": "feeRecipient", "type": "address" }], "name": "sweepTokenWithFee", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "token", "type": "address" }, { "internalType": "uint256", "name": "amountMinimum", "type": "uint256" }, { "internalType": "address", "name": "recipient", "type": "address" }, { "internalType": "uint256", "name": "feeBips", "type": "uint256" }, { "internalType": "address", "name": "feeRecipient", "type": "address" }], "name": "sweepTokenWithFee", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "int256", "name": "amount0Delta", "type": "int256" }, { "internalType": "int256", "name": "amount1Delta", "type": "int256" }, { "internalType": "bytes", "name": "_data", "type": "bytes" }], "name": "uniswapV3SwapCallback", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [{ "internalType": "uint256", "name": "amountMinimum", "type": "uint256" }, { "internalType": "address", "name": "recipient", "type": "address" }], "name": "unwrapWETH9", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "uint256", "name": "amountMinimum", "type": "uint256" }], "name": "unwrapWETH9", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "uint256", "name": "amountMinimum", "type": "uint256" }, { "internalType": "address", "name": "recipient", "type": "address" }, { "internalType": "uint256", "name": "feeBips", "type": "uint256" }, { "internalType": "address", "name": "feeRecipient", "type": "address" }], "name": "unwrapWETH9WithFee", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "uint256", "name": "amountMinimum", "type": "uint256" }, { "internalType": "uint256", "name": "feeBips", "type": "uint256" }, { "internalType": "address", "name": "feeRecipient", "type": "address" }], "name": "unwrapWETH9WithFee", "outputs": [], "stateMutability": "payable", "type": "function" }, { "inputs": [{ "internalType": "uint256", "name": "value", "type": "uint256" }], "name": "wrapETH", "outputs": [], "stateMutability": "payable", "type": "function" }, { "stateMutability": "payable", "type": "receive" }]
825 | 
826 | 
827 | module.exports = { UNISWAP_FACTOR_ABI, UNISWAP_V3_POOL_ABI, tokenAbi, SwapRouterAbi };


--------------------------------------------------------------------------------