├── README.md
├── aave
    └── v3_supply_and_withdraw.py
├── beraswap
    └── bera_swap.py
├── flashbots
    ├── README.md
    ├── eth_send_bundle.py
    ├── eth_send_private.py
    ├── mev-sse
    │   ├── events.csv
    │   ├── simple_logger.py
    │   └── simple_streamer.py
    └── mev_send_bundle.py
├── general
    ├── bloom_filter.py
    ├── multi2.py
    ├── swap_topic.py
    └── transfer_override.py
├── misc
    ├── con
    │   └── net.py
    ├── makas_py_on_chain.png
    └── migrations.py
├── raw_calls
    ├── raw_approval.py
    ├── raw_deploy.py
    ├── raw_deposit.py
    └── raw_transfer.py
├── scrapbots
    ├── flash_bot.py
    ├── skym_bot
    │   ├── README.md
    │   ├── abi
    │   │   ├── erc20_abi.json
    │   │   ├── relay_abi.json
    │   │   └── slp_abi.json
    │   ├── caller.py
    │   └── relay.vy
    └── voly.py
├── signing
    ├── pysign.py
    ├── setMasterContractApproval.py
    ├── universal_permit2_abstract.py
    └── universal_permit2_extended.py
├── sushiswap
    ├── exact_input.py
    ├── get_kava_farms.py
    ├── get_rewards.py
    ├── graph_call.py
    ├── route_processor.md
    ├── route_processor.py
    ├── route_processor_multi.py
    ├── swap_volume_since_midnight.py
    ├── trident_help_sheet.md
    ├── trident_multicall.py
    └── xSwap.py
├── sync_swap
    ├── sync_swap.py
    └── sync_swap_with_permit.py
├── uni_router
    ├── universal_router_swap.md
    ├── universal_router_swap.py
    ├── universal_swap_from_token.py
    └── universal_v2_swap.py
├── uniswapv2
    ├── mempool_filter.py
    ├── scale4whale.py
    └── v2path_encode.md
├── uniswapv3
    ├── v3exactOutput.py
    ├── v3exactOutputSingle.py
    └── v3quoter_iterations.py
└── zk
    ├── check_balance.py
    └── transfer.py


/README.md:
--------------------------------------------------------------------------------
  1 | The previous repository structure can be found <a href="https://github.com/0xMaka/w3py/tree/archive">here</a>
  2 | 
  3 | ---
  4 | 
  5 | <img src="misc/makas_py_on_chain.png">
  6 | 
  7 | ---
  8 | 
  9 | Hi! Originally this repo started as a bunch of _scripts and examples,_ written for users while handling support queries as a contributor at Sushiswap. However the repository had grown to encompass many more protocols and areas of defi, as well as outgrowing its initial lack of structure.
 10 | 
 11 | To make it easier to find things that might be useful, as well to know which related scripts are worth skimming through. I have attempted to better organise into folders, adding an index with short descriptions.
 12 | 
 13 | Always love to hear which examples can been useful, and am often happy to take requests if you might be struggling with something.
 14 | Can find me in the ethereum python discord with any questions.
 15 | All the best on your journey. - Maka
 16 | 
 17 | - [Ethereum Python Community](https://discord.gg/J8XFujprRA)
 18 | 
 19 | ---
 20 | 
 21 | | folder                          | script                                                                         | description                                                  |
 22 | |---------------------------------|--------------------------------------------------------------------------------|--------------------------------------------------------------|
 23 | | > [ aave       ]( aave/      )  |                                                                                | **Aave lending protocol**                                    |
 24 | |                                 |  [ v3_supply_and_withdraw.py     ]( aave/v3_supply_and_withdraw.py           ) | Approve, supply and withdraw from a v3 aave pool.            |
 25 | | > [ beraswap   ]( beraswap/  )  |                                                                                | **Berachain DEX**                                            |
 26 | |                                 |  [ bera_swap.py                  ]( beraswap/bera_swap.py                    ) | Swap using `batchSwap` with their `ERC20_DEX`.               | 
 27 | | > [ flashbots  ]( flashbots/ )  |                                                                                | Call structures and direct calls to flashbots endpoints.     |
 28 | |                                 |  [ eth_send_bundle.py            ]( flashbots/eth_send_bundle.py             ) | Building and sending a classic bundle.                       |
 29 | |                                 |  [ eth_send_private.py           ]( flashbots/eth_send_private.py            ) | Using Flashbots endpoint to send a private transaction.      | 
 30 | |                                 |  [ mev_send_bundle.py            ]( flashbots/mev_send_bundle.py             ) | Building and sending a MevShare bundle.                      |     
 31 | | > [ general    ]( general    )  |                                                                                | **Overrides, bloom filters, log topics and wider EVM**       |
 32 | |                                 |  [ bloom_filter.py               ]( general/bloom_filter.py                  ) | Filtering the `logsBloom` for more efficient searches.       |
 33 | |                                 |  [ multi2.py                     ]( general/multi2.py                        ) | Using a popular mulicall contract, to batch static requests. |
 34 | |                                 |  [ swap_topic.py                 ]( general/swap_topic.py                    ) | How to encode and pull an `Event` topic.                     |
 35 | |                                 |  [ transfer_override.py          ]( general/transfer_override.py             ) | Overriding an accounts ERC20 balance, prior to an `eth_call`.|
 36 | | > [ raw_calls  ]( raw_calls/ )  |  [                               ](                                          ) | **Contract calls sending raw calldata**                      |
 37 | |                                 |  [ raw_approval.py               ]( raw_calls/raw_approval.py                ) | Send a token approval using pre prepared calldata.           |
 38 | |                                 |  [ raw_deploy.py                 ]( raw_calls/raw_deploy.py                  ) | Deploy a contract using pre prepared calldata.               |
 39 | |                                 |  [ raw_deposit.py                ]( raw_calls/raw_deposit.py                 ) | Deposit ETH to receive WETH using pre prepared calldata.     |
 40 | |                                 |  [ raw_transfer.py               ]( raw_calls/raw_transfer.py                ) | Make an ERC20 transfer using pre prepared calldata.          |
 41 | | > [ scrapbots ]( scrapbots/)    |                                                                                | **Basic bot flow**                                           |
 42 | |                                 |  [ skym_bot/                     ]( scrapbots/skym_bot/                      ) | Monitor a v2 pair for imbalance, skim with contract if so.   |
 43 | |                                 |  [ flash_bot.py                  ]( scrapbots/flash_bot.py                   ) | A basic flashbot script, using flashbots py library.         |
 44 | |                                 |  [ voly.py                       ]( scrapbots/voly.py                        ) | Polls a v2 pair for price, buys or sells, tracks if holding. |
 45 | | > [ signing    ]( signing/   )  |                                                                                | **Offchain signing, permits, EIP712**                        |
 46 | |                                 |  [ pysign.py                     ]( signing/pysign.py                        ) | Deprectated signing pattern.                                 |
 47 | |                                 |  [ setMasterContractApproval.py  ]( signing/setMasterContractApproval.py     ) | Building and signing an EIP712 digest.                       |
 48 | |                                 |  [ universal_permit2_extended.py ]( signing/universal_permit2_extended.py    ) | Offchain permit for Universal router (long way).             |
 49 | |                                 |  [ universal_permit2_abstract.py ]( signing/universal_permit2_abstract.py    ) | Offchain permit for Universal router (short way).            |
 50 | | > [ sushiswap  ]( sushiswap/ )  |                                                                                | **Sushi specific**                                           |
 51 | |                                 |  [ exact_input.py                ]( sushiswap/exact_input.py                 ) | Trident single hop swap.                                     |
 52 | |                                 |  [ get_kava_farms.py             ]( sushiswap/get_kava_farms.py              ) | Get a list of all farms from a chef.                         |
 53 | |                                 |  [ get_rewards.py                ]( sushiswap/get_rewards.py                 ) | Calculating rewards from a Minichef.                         |
 54 | |                                 |  [ graph_call.py                 ]( sushiswap/graph_call.py                  ) | Outdated: Exchange subgraph call (Pre needing a key).        |
 55 | |                                 |  [ route_processor.md            ]( sushiswap/route_processor.md             ) | Notes Sushi's router processor.                              |
 56 | |                                 |  [ route_processor.py            ]( sushiswap/route_processor.py             ) | Single hop swap using Sushi route processor.                 |
 57 | |                                 |  [ route_processor_multi.py      ]( sushiswap/route_processor_multi.py       ) | Multi hop swap using Sushi route processor.                  |
 58 | |                                 |  [ swap_volume_since_midnight.py ]( sushiswap/swap_volume_since_midnight.py  ) | Outdated: Use a subgraph to get volume day data.             |
 59 | |                                 |  [ trident_help_sheet.md         ]( sushiswap/trident_help_sheet.md          ) | Notes on Sushi Trident.                                      |
 60 | |                                 |  [ trident_multicall.py          ]( sushiswap/trident_multicall.py           ) | Trident multi hop swap.                                      |
 61 | |                                 |  [ xSwap.py                      ]( sushiswap/xSwap.py                       ) | Extensive cross chain swap, encoding, off chain signing etc. |
 62 | | > [ syncswap   ]( syncswap/  )  |                                                                                | **How to swap on Syncwap DEX.**                              |
 63 | |                                 |  [ sync_swap.py                  ]( syncswap/sync_swap.py                    ) | Basic Syncswap router interaction.                           |
 64 | |                                 |  [ sync_swap_with_permit.py      ]( syncswap/sync_swap_with_permit.py        ) | Basic Syncswap router interaction using a permit.            |
 65 | | > [ uniswapv2  ]( uniswapv2/ )  |                                                                                | **Examples for Uniswap v2 and clones**                       |
 66 | |                                 |  [ mempool_filter.py             ]( uniswapv2/mempool_filter.py              ) | IPC filter the tx pool for swaps and decode them.            |
 67 | |                                 |  [ scale4whale.py                ]( uniswapv2/scale4whale.py                 ) | Get an amount required to buy a tokens total supply.         |
 68 | |                                 |  [ v2path_encode.md              ]( uniswapv2/v2path_encode.md               ) | Step through of the ABI encoding.                            |
 69 | | > [ uniswapv3  ]( uniswapv3/ )  |                                                                                | **Examples for Uniswap v3 and clones**                       |
 70 | |                                 |  [ v3exactOutput.py              ]( uniswapv3/v3exactOutput.py               ) | Uniswap v3 swap, multihop.                                   |
 71 | |                                 |  [ v3exactOutputSingle.py        ]( uniswapv3/v3exactOutputSingle.py         ) | Uniswap v3 swap, single hop.                                 |
 72 | |                                 |  [ v3quoter_iterations.py        ]( uniswapv3/v3quoter_iterations.py         ) | Uniswap v3 quoter discrepancies, example calls to each.      |
 73 | | > [ uni_router ]( uni_router/)  |                                                                                | **Uniswaps Universal router**                                |
 74 | |                                 |  [ universal_router_swap.md      ]( uni_router/universal_router_swap.md      ) | Notes on Uniswaps Universal Router.                          |
 75 | |                                 |  [ universal_router_swap.py      ]( uni_router/universal_router_swap.py      ) | Wrap and swap from Eth using Universal router..              |
 76 | |                                 |  [ universal_swap_from_token.py  ]( uni_router/universal_swap_from_token.py  ) | Swap from token using Universal router (uses dual tx permit).|
 77 | |                                 |  [ universal_v2_swap.py          ]( uni_router/universal_v2_swap.py          ) | Swap on a v2 pool using Universal router (dual tx permit).   |
 78 | | > [ zk         ]( zk/        )  |                                                                                | **Anything ZK specific**                                     |
 79 | |                                 |  [ check_balance.py              ]( zk/check_balance.py                      ) | Simple balance check, using the sdk.                         |
 80 | |                                 |  [ transfer.py                   ]( zk/transfer.py                           ) | Simple eth transfer, using the sdk.                          |
 81 | |         <img width=145/>        |                                                                                |                     <img width=430/>                         |
 82 | 
 83 | <!--
 84 | <table class="fixed-align">
 85 |   <tbody>
 86 |    <tr>
 87 |   <th>
 88 |     🐍
 89 |   </th>
 90 |     </tr>  
 91 |     <tr>
 92 |   <td valign="top", valign="center">
 93 |      
 94 | ```python
 95 | # clone repo 
 96 | # ...
 97 | # instructions for using search tag tool
 98 | # ...
 99 | ``` 
100 | 
101 |   </td>
102 |     </tr>
103 |   <tr>
104 | <td>
105 |   <img width=800/>
106 | </td>
107 |   </tr>
108 | </table>
109 | 


--------------------------------------------------------------------------------
/beraswap/bera_swap.py:
--------------------------------------------------------------------------------
 1 | # example bera swap
 2 | 
 3 | RPC = 'https://artio.rpc.berachain.com'
 4 | CHAIN_ID = 80085
 5 | 
 6 | from web3 import Web3 as w, HTTPProvider as hp ; w3 = w(hp(RPC))
 7 | 
 8 | from os import getenv
 9 | from dotenv import load_dotenv
10 | load_dotenv()
11 | KEY = getenv('TKEY')
12 | EOA = getenv('TRON')
13 | #----------------------
14 | 
15 | ERC20_DEX = '0x0d5862FDbdd12490f9b4De54c236cff63B038074'
16 | NATIVE = '0x0000000000000000000000000000000000000000'
17 | USDC = '0x6581e59A1C8dA66eD0D313a0d4029DcE2F746Cc5'
18 | # WETH = '0x8239FBb3e3D0C2cDFd7888D8aF7701240Ac4DcA4'
19 | WBTC = '0x9DAD8A1F64692adeB74ACa26129e0F16897fF4BB'
20 | 
21 | DEX_ABI = '''
22 | [ { "type": "function", "name": "addLiquidity", "inputs": [ { "name": "pool", "type": "address", "internalType": "address" }, { "name": "receiver", "type": "address", "internalType": "address" }, { "name": "assetsIn", "type": "address[]", "internalType": "address[]" }, { "name": "amountsIn", "type": "uint256[]", "internalType": "uint256[]" } ], "outputs": [ { "name": "shares", "type": "address[]", "internalType": "address[]" }, { "name": "shareAmounts", "type": "uint256[]", "internalType": "uint256[]" }, { "name": "liquidity", "type": "address[]", "internalType": "address[]" }, { "name": "liquidityAmounts", "type": "uint256[]", "internalType": "uint256[]" } ], "stateMutability": "payable" }, { "type": "function", "name": "batchSwap", "inputs": [ { "name": "kind", "type": "uint8", "internalType": "enum IERC20DexModule.SwapKind" }, { "name": "swaps", "type": "tuple[]", "internalType": "struct IERC20DexModule.BatchSwapStep[]", "components": [ { "name": "poolId", "type": "address", "internalType": "address" }, { "name": "assetIn", "type": "address", "internalType": "address" }, { "name": "amountIn", "type": "uint256", "internalType": "uint256" }, { "name": "assetOut", "type": "address", "internalType": "address" }, { "name": "amountOut", "type": "uint256", "internalType": "uint256" }, { "name": "userData", "type": "bytes", "internalType": "bytes" } ] }, { "name": "deadline", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "assets", "type": "address[]", "internalType": "address[]" }, { "name": "amounts", "type": "uint256[]", "internalType": "uint256[]" } ], "stateMutability": "payable" }, { "type": "function", "name": "createPool", "inputs": [ { "name": "name", "type": "string", "internalType": "string" }, { "name": "assetsIn", "type": "address[]", "internalType": "address[]" }, { "name": "amountsIn", "type": "uint256[]", "internalType": "uint256[]" }, { "name": "poolType", "type": "string", "internalType": "string" }, { "name": "options", "type": "tuple", "internalType": "struct IERC20DexModule.PoolOptions", "components": [ { "name": "weights", "type": "tuple[]", "internalType": "struct IERC20DexModule.AssetWeight[]", "components": [ { "name": "asset", "type": "address", "internalType": "address" }, { "name": "weight", "type": "uint256", "internalType": "uint256" } ] }, { "name": "swapFee", "type": "uint256", "internalType": "uint256" } ] } ], "outputs": [ { "name": "", "type": "address", "internalType": "address" } ], "stateMutability": "payable" }, { "type": "function", "name": "getExchangeRate", "inputs": [ { "name": "pool", "type": "address", "internalType": "address" }, { "name": "baseAsset", "type": "address", "internalType": "address" }, { "name": "quoteAsset", "type": "address", "internalType": "address" } ], "outputs": [ { "name": "", "type": "uint256", "internalType": "uint256" } ], "stateMutability": "view" }, { "type": "function", "name": "getLiquidity", "inputs": [ { "name": "pool", "type": "address", "internalType": "address" } ], "outputs": [ { "name": "asset", "type": "address[]", "internalType": "address[]" }, { "name": "amounts", "type": "uint256[]", "internalType": "uint256[]" } ], "stateMutability": "view" }, { "type": "function", "name": "getPoolName", "inputs": [ { "name": "pool", "type": "address", "internalType": "address" } ], "outputs": [ { "name": "", "type": "string", "internalType": "string" } ], "stateMutability": "view" }, { "type": "function", "name": "getPoolOptions", "inputs": [ { "name": "pool", "type": "address", "internalType": "address" } ], "outputs": [ { "name": "", "type": "tuple", "internalType": "struct IERC20DexModule.PoolOptions", "components": [ { "name": "weights", "type": "tuple[]", "internalType": "struct IERC20DexModule.AssetWeight[]", "components": [ { "name": "asset", "type": "address", "internalType": "address" }, { "name": "weight", "type": "uint256", "internalType": "uint256" } ] }, { "name": "swapFee", "type": "uint256", "internalType": "uint256" } ] } ], "stateMutability": "view" }, { "type": "function", "name": "getPreviewAddLiquidityNoSwap", "inputs": [ { "name": "pool", "type": "address", "internalType": "address" }, { "name": "assets", "type": "address[]", "internalType": "address[]" }, { "name": "amounts", "type": "uint256[]", "internalType": "uint256[]" } ], "outputs": [ { "name": "shares", "type": "address[]", "internalType": "address[]" }, { "name": "shareAmounts", "type": "uint256[]", "internalType": "uint256[]" }, { "name": "liqOut", "type": "address[]", "internalType": "address[]" }, { "name": "liquidityAmounts", "type": "uint256[]", "internalType": "uint256[]" } ], "stateMutability": "view" }, { "type": "function", "name": "getPreviewAddLiquidityStaticPrice", "inputs": [ { "name": "pool", "type": "address", "internalType": "address" }, { "name": "liquidity", "type": "address[]", "internalType": "address[]" }, { "name": "amounts", "type": "uint256[]", "internalType": "uint256[]" } ], "outputs": [ { "name": "shares", "type": "address[]", "internalType": "address[]" }, { "name": "shareAmounts", "type": "uint256[]", "internalType": "uint256[]" }, { "name": "liqOut", "type": "address[]", "internalType": "address[]" }, { "name": "liquidityAmounts", "type": "uint256[]", "internalType": "uint256[]" } ], "stateMutability": "view" }, { "type": "function", "name": "getPreviewBatchSwap", "inputs": [ { "name": "kind", "type": "uint8", "internalType": "enum IERC20DexModule.SwapKind" }, { "name": "swaps", "type": "tuple[]", "internalType": "struct IERC20DexModule.BatchSwapStep[]", "components": [ { "name": "poolId", "type": "address", "internalType": "address" }, { "name": "assetIn", "type": "address", "internalType": "address" }, { "name": "amountIn", "type": "uint256", "internalType": "uint256" }, { "name": "assetOut", "type": "address", "internalType": "address" }, { "name": "amountOut", "type": "uint256", "internalType": "uint256" }, { "name": "userData", "type": "bytes", "internalType": "bytes" } ] } ], "outputs": [ { "name": "asset", "type": "address", "internalType": "address" }, { "name": "amount", "type": "uint256", "internalType": "uint256" } ], "stateMutability": "view" }, { "type": "function", "name": "getPreviewBurnShares", "inputs": [ { "name": "pool", "type": "address", "internalType": "address" }, { "name": "asset", "type": "address", "internalType": "address" }, { "name": "amount", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "assets", "type": "address[]", "internalType": "address[]" }, { "name": "amounts", "type": "uint256[]", "internalType": "uint256[]" } ], "stateMutability": "view" }, { "type": "function", "name": "getPreviewSharesForLiquidity", "inputs": [ { "name": "pool", "type": "address", "internalType": "address" }, { "name": "assets", "type": "address[]", "internalType": "address[]" }, { "name": "amounts", "type": "uint256[]", "internalType": "uint256[]" } ], "outputs": [ { "name": "shares", "type": "address[]", "internalType": "address[]" }, { "name": "shareAmounts", "type": "uint256[]", "internalType": "uint256[]" }, { "name": "liquidity", "type": "address[]", "internalType": "address[]" }, { "name": "liquidityAmounts", "type": "uint256[]", "internalType": "uint256[]" } ], "stateMutability": "view" }, { "type": "function", "name": "getPreviewSharesForSingleSidedLiquidityRequest", "inputs": [ { "name": "pool", "type": "address", "internalType": "address" }, { "name": "asset", "type": "address", "internalType": "address" }, { "name": "amount", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "assets", "type": "address[]", "internalType": "address[]" }, { "name": "amounts", "type": "uint256[]", "internalType": "uint256[]" } ], "stateMutability": "view" }, { "type": "function", "name": "getPreviewSwapExact", "inputs": [ { "name": "kind", "type": "uint8", "internalType": "enum IERC20DexModule.SwapKind" }, { "name": "pool", "type": "address", "internalType": "address" }, { "name": "baseAsset", "type": "address", "internalType": "address" }, { "name": "baseAssetAmount", "type": "uint256", "internalType": "uint256" }, { "name": "quoteAsset", "type": "address", "internalType": "address" } ], "outputs": [ { "name": "asset", "type": "address", "internalType": "address" }, { "name": "amount", "type": "uint256", "internalType": "uint256" } ], "stateMutability": "view" }, { "type": "function", "name": "getRemoveLiquidityExactAmountOut", "inputs": [ { "name": "pool", "type": "address", "internalType": "address" }, { "name": "assetIn", "type": "address", "internalType": "address" }, { "name": "assetAmount", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "assets", "type": "address[]", "internalType": "address[]" }, { "name": "amounts", "type": "uint256[]", "internalType": "uint256[]" } ], "stateMutability": "view" }, { "type": "function", "name": "getRemoveLiquidityOneSideOut", "inputs": [ { "name": "pool", "type": "address", "internalType": "address" }, { "name": "assetOut", "type": "address", "internalType": "address" }, { "name": "sharesIn", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "assets", "type": "address[]", "internalType": "address[]" }, { "name": "amounts", "type": "uint256[]", "internalType": "uint256[]" } ], "stateMutability": "view" }, { "type": "function", "name": "getTotalShares", "inputs": [ { "name": "pool", "type": "address", "internalType": "address" } ], "outputs": [ { "name": "assets", "type": "address[]", "internalType": "address[]" }, { "name": "amounts", "type": "uint256[]", "internalType": "uint256[]" } ], "stateMutability": "view" }, { "type": "function", "name": "removeLiquidityBurningShares", "inputs": [ { "name": "pool", "type": "address", "internalType": "address" }, { "name": "withdrawAddress", "type": "address", "internalType": "address" }, { "name": "assetIn", "type": "address", "internalType": "address" }, { "name": "amountIn", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "liquidity", "type": "address[]", "internalType": "address[]" }, { "name": "liquidityAmounts", "type": "uint256[]", "internalType": "uint256[]" } ], "stateMutability": "payable" }, { "type": "function", "name": "removeLiquidityExactAmount", "inputs": [ { "name": "pool", "type": "address", "internalType": "address" }, { "name": "withdrawAddress", "type": "address", "internalType": "address" }, { "name": "assetOut", "type": "address", "internalType": "address" }, { "name": "amountOut", "type": "uint256", "internalType": "uint256" }, { "name": "sharesIn", "type": "address", "internalType": "address" }, { "name": "maxSharesIn", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "shares", "type": "address[]", "internalType": "address[]" }, { "name": "shareAmounts", "type": "uint256[]", "internalType": "uint256[]" }, { "name": "liquidity", "type": "address[]", "internalType": "address[]" }, { "name": "liquidityAmounts", "type": "uint256[]", "internalType": "uint256[]" } ], "stateMutability": "payable" }, { "type": "function", "name": "swap", "inputs": [ { "name": "kind", "type": "uint8", "internalType": "enum IERC20DexModule.SwapKind" }, { "name": "poolId", "type": "address", "internalType": "address" }, { "name": "assetIn", "type": "address", "internalType": "address" }, { "name": "amountIn", "type": "uint256", "internalType": "uint256" }, { "name": "assetOut", "type": "address", "internalType": "address" }, { "name": "amountOut", "type": "uint256", "internalType": "uint256" }, { "name": "deadline", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "assets", "type": "address[]", "internalType": "address[]" }, { "name": "amounts", "type": "uint256[]", "internalType": "uint256[]" } ], "stateMutability": "payable" } ]
23 | '''
24 | 
25 | dex = w3.eth.contract(address=ERC20_DEX, abi=DEX_ABI)
26 | 
27 | swap = dex.functions.batchSwap(
28 |   0,
29 |   [
30 |     ('0x3F2090dc46629eeb36Db545f0e9E5084b67D11aE', NATIVE, 10000000000000, WBTC, 0, '0x'),
31 |     ('0xD316eC27FDc736B9f3e625644c98221469288Da6', WBTC, 0, USDC, 0, '0x')
32 |   ],
33 |   99999999
34 | ).build_transaction({
35 |   'value': 10000000000000000,
36 |   'from': EOA,
37 |   'chainId': CHAIN_ID,
38 |   'gas': 500000,
39 |   'maxFeePerGas': w3.eth.gas_price * 2,
40 |   'maxPriorityFeePerGas': w3.eth.max_priority_fee * 2,
41 |   'nonce': w3.eth.get_transaction_count(EOA)
42 | })
43 | 
44 | w3.eth.call(swap) # should throw if there is an issue
45 | 
46 | # helpers
47 | def sign_tx(tx, key):
48 |   return w3.eth.account.sign_transaction(tx, private_key=key)
49 | 
50 | def send_tx(signed_tx):
51 |   return w3.eth.send_raw_transaction(signed_tx.rawTransaction)
52 | 
53 | def main():
54 |   ('[-] Attempting swap...')
55 |   tx_hash = send_tx(sign_tx(swap, KEY))
56 |   receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
57 |   print (f'[>] Hash of attempt: {tx_hash}\n[>] {receipt}')
58 | 
59 | if __name__ == '__main__':
60 |   main()
61 | 


--------------------------------------------------------------------------------
/flashbots/README.md:
--------------------------------------------------------------------------------
  1 | # flashbots 🤖
  2 | Examples raw posting json rpc calls to flashbots endpoints, useful when features are added to protocol but not yet supprted by the python package.
  3 | 
  4 | - More information, along with which fields are optional can be found in the flashbots documentation: 
  5 | > https://docs.flashbots.net/flashbots-auction/searchers/advanced/rpc-endpoint
  6 | 
  7 | ## Calls as python dictionaries:
  8 | 
  9 | ### eth_sendPrivateTransaction 
 10 | - is used to send a single transaction to Flashbots. Flashbots will attempt to build a block including the transaction for the next 25 blocks.
 11 | ```python
 12 | eth_sendPrivateTransaction = {
 13 |     'jsonrpc': '2.0',   
 14 |     'id': str or int,   
 15 |     'method': 'eth_sendPrivateTransaction',
 16 |     'params': [{
 17 |     'tx': [str],
 18 |     'maxBlockNumber': str,     
 19 |     'preferences': {       
 20 |     'fast': bool,       
 21 |     'privacy': {            
 22 |       'hints': [             
 23 |         'contract_address',             
 24 |         'function_selector',             
 25 |         'calldata',             
 26 |         'logs',             
 27 |         'hash'         
 28 |       ],         
 29 |       'builders': [      
 30 |         'default',           
 31 |         'flashbots'         
 32 |       ],       
 33 |       }     
 34 |     }
 35 |   }]
 36 | }
 37 | ```
 38 | 
 39 | ### eth_sendBundle
 40 | - can be used to send bundles of two or more transactions to the Flashbots builder.
 41 | 
 42 | ```python
 43 | eth_sendBundle = {
 44 |   'jsonrpc': '2.0',
 45 |   'id': str or int,
 46 |   'method': 'eth_sendBundle',
 47 |   'params': [{
 48 |     'txs': [str],               # Array[String], A list of signed transactions to execute in an atomic bundle       
 49 |     'blockNumber': str,         # String, a hex encoded block number for which this bundle is valid on       
 50 |     'minTimestamp': int,        # (Optional) Number, the minimum timestamp for which this bundle is valid, in seconds since the unix epoch       
 51 |     'maxTimestamp': int,        # (Optional) Number, the maximum timestamp for which this bundle is valid, in seconds since the unix epoch       
 52 |     'revertingTxHashes': [str], # (Optional) Array[String], A list of tx hashes that are allowed to revert       
 53 |     'replacementUuid': str,     # (Optional) String, UUID that can be used to cancel/replace this bundle 
 54 |   }]
 55 | }
 56 | ```
 57 | 
 58 | ### eth_callBundle 
 59 | - can be used to simulate a bundle against a specific block number, including simulating a bundle at the top of the next block.
 60 | ```python
 61 | eth_callBundle = {   
 62 |   'jsonrpc': '2.0',   
 63 |   'id': 1,
 64 |   'method': 'eth_callBundle',   
 65 |   'params': [{       
 66 |     'txs': [str,str],       
 67 |     'blockNumber': str,
 68 |     'stateBlockNumber': str, 
 69 |     'timestamp': int  
 70 |   }] 
 71 | }
 72 | ```
 73 | 
 74 | ### mev_sendBundle
 75 | -  uses a new bundle format to send bundles to MEV-Share.
 76 | ```python
 77 | MevSendBundleParams = {}
 78 | mev_sendBundle = {
 79 |   'jsonrpc': '2.0',
 80 |   'id': str or int,
 81 |   'method': 'mev_sendBundle',
 82 |   'params': [{ # /* MevSendBundleParams */
 83 |   'version': '0' or 'beta-1.0',
 84 |     'inclusion': {
 85 |       'block': str,      # // hex-encoded number
 86 |       'maxBlock': str,  # // hex-encoded number
 87 |     },
 88 |     'body': [
 89 |       { 'hash': str },
 90 |       { 'tx': str, 'canRevert': bool },
 91 |       { 'bundle': MevSendBundleParams }
 92 |       ],
 93 |     'validity': {
 94 |       'refund': [{
 95 |         'bodyIdx': int,
 96 |         'percent': int,
 97 |       }],
 98 |       'refundConfig': [{
 99 |         'address': str,
100 |         'percent': int,
101 |       }],
102 |     },
103 |     'privacy': {
104 |       'hints': [
105 |         'calldata',
106 |         'contract_address',
107 |         'logs',
108 |         'function_selector',
109 |         'hash'
110 |         ],
111 |       'builders': [ str ],
112 |     },
113 |   }]
114 | }   
115 | ```
116 | 


--------------------------------------------------------------------------------
/flashbots/eth_send_bundle.py:
--------------------------------------------------------------------------------
 1 | # @author Maka
 2 | # @notice raw post flashbots bundle
 3 | 
 4 | from os import getenv 
 5 | from dotenv import load_dotenv 
 6 | from net import con  
 7 | 
 8 | w3 = con('GOERLI')  
 9 | 
10 | load_dotenv()   
11 | EOA = getenv('TRON')   
12 | KEY = getenv('TKEY')    
13 | FLA = getenv('FKEY')
14 | 
15 | 
16 | eth_sendBundle = {
17 |   'jsonrpc': "2.0",
18 |   'id': str or int,
19 |   'method': "eth_sendBundle",
20 |   'params': [{
21 |     'txs': [str],               # Array[String], A list of signed transactions to execute in an atomic bundle       
22 |     'blockNumber': str,         # String, a hex encoded block number for which this bundle is valid on       
23 |     'minTimestamp': int,        # (Optional) Number, the minimum timestamp for which this bundle is valid, in seconds since the unix epoch       
24 |     'maxTimestamp': int,        # (Optional) Number, the maximum timestamp for which this bundle is valid, in seconds since the unix epoch       
25 |     'revertingTxHashes': [str], # (Optional) Array[String], A list of tx hashes that are allowed to revert       
26 |     'replacementUuid': str,     # (Optional) String, UUID that can be used to cancel/replace this bundle 
27 |   }]
28 | }
29 | 
30 | eth_callBundle = {   
31 |   "jsonrpc": "2.0",   
32 |   "id": 1,
33 |   "method": "eth_callBundle",   
34 |   "params": [{       
35 |     "txs": [str,str],       
36 |     "blockNumber": str,
37 |     "stateBlockNumber": str, 
38 |     "timestamp": int  
39 |   }] 
40 | }
41 | 
42 | 
43 | def sign_tx(tx, key):   
44 |   return w3.eth.account.sign_transaction(tx, private_key=key)    
45 | 
46 | from eth_account import messages, Account
47 | def sign_flash(_tx_body: str) -> str:
48 |   message = messages.encode_defunct(text=w3.keccak(text=_tx_body).hex()) 
49 |   signature = f'{Account.from_key(FLA).address}:{w3.eth.account.sign_message(message, FLA).signature.hex()}'
50 |   return signature
51 | 
52 | from requests import post
53 | from json import dumps
54 | def send_flash(_request: dict) -> bytes:
55 |   request = dumps(_request)
56 |   headers = { 'Content-Type': 'application/json', 'X-Flashbots-Signature': sign_flash(request) }
57 |   return post('https://relay-goerli.flashbots.net', data=request, headers=headers).content
58 | 
59 | 
60 | WASTE_GAS = '0x8e63F02d5fB3bCCD2939e0ba6Fe3Bf2635718F49'
61 | SIG = '0x1e0bd6fa'
62 | 
63 | tx1 = { 'from': EOA, 'to': EOA, 'value': 0, 'chainId': 5, 'gas': 25000, 'maxFeePerGas': w3.to_wei(60, 'gwei'), 'maxPriorityFeePerGas': w3.to_wei(20, 'gwei'), 'data': '0x', 'nonce': w3.eth.get_transaction_count(EOA) }
64 | tx2 = { 'data': SIG, 'to': WASTE_GAS, 'from': EOA,'value': 0,'chainId': 5,'gas': 50000,'maxFeePerGas': w3.to_wei(60, 'gwei'), 'maxPriorityFeePerGas': w3.to_wei(20, 'gwei'),'nonce': w3.eth.get_transaction_count(EOA) + 1}
65 | 
66 | signed_tx1 = sign_tx(tx1, KEY).rawTransaction.hex()
67 | signed_tx2 = sign_tx(tx2, KEY).rawTransaction.hex()
68 | 
69 | 
70 | TARGET_BLOCK = w3.eth.block_number
71 | 
72 | sim = eth_callBundle; sim.update({'params': [{'txs': [signed_tx1, signed_tx2], 'blockNumber': hex(w3.eth.block_number), 'stateBlockNumber': 'latest'}]})
73 | print(send_flash(sim))
74 | 
75 | from time import time
76 | bundle = eth_sendBundle
77 | _id = 0
78 | for block_num in range(TARGET_BLOCK, TARGET_BLOCK + 5):
79 |   bundle.update({"id": _id, 'params': [{"txs": [signed_tx1, signed_tx2], "blockNumber": hex(block_num), "minTimestamp": 0, "maxTimestamp": round(time() + 420)}]})
80 |   print(send_flash(bundle))
81 |   _id += 1
82 | 


--------------------------------------------------------------------------------
/flashbots/eth_send_private.py:
--------------------------------------------------------------------------------
 1 | # @author Maka
 2 | # @notice raw post flashbots private transaction
 3 | 
 4 | from os import getenv 
 5 | from dotenv import load_dotenv 
 6 | from net import con  
 7 | 
 8 | w3 = con('GOERLI')  
 9 | 
10 | load_dotenv()   
11 | EOA = getenv('TRON')   
12 | KEY = getenv('TKEY')    
13 | FLA = getenv('FKEY')
14 | 
15 | def sign_tx(_tx, _key) -> str: 
16 |   return w3.eth.account.sign_transaction(_tx, private_key=_key)
17 | 
18 | from eth_account import messages, Account
19 | def sign_flash(_tx_body: str) -> str:
20 |   message = messages.encode_defunct(text=w3.keccak(text=_tx_body).hex()) 
21 |   signature = f'{Account.from_key(FLA).address}:{w3.eth.account.sign_message(message, FLA).signature.hex()}'
22 |   return signature
23 | 
24 | from requests import post
25 | from json import dumps
26 | def send_flash(_request: dict) -> bytes:
27 |   request = dumps(_request)
28 |   headers = { 'Content-Type': 'application/json', 'X-Flashbots-Signature': sign_flash(request) }
29 |   return post('https://relay-goerli.flashbots.net', data=request, headers=headers).content
30 | 
31 | eth_sendPrivateTransaction = {
32 |     'jsonrpc': '2.0',   
33 |     'id': str or int,   
34 |     'method': 'eth_sendPrivateTransaction',
35 |     'params': [{
36 |     'tx': [str],
37 |     'maxBlockNumber': str,     
38 |     'preferences': {       
39 |     'fast': bool,       
40 |     'privacy': {            
41 |       'hints': [             
42 |         'contract_address',             
43 |         'function_selector',             
44 |         'calldata',             
45 |         'logs',             
46 |         'hash'         
47 |       ],         
48 |       'builders': [      
49 |         'default',           
50 |         'flashbots'         
51 |       ],       
52 |       }     
53 |     }
54 |   }]
55 | }
56 | 
57 | TARGET_BLOCK = w3.eth.block_number
58 | 
59 | WASTE_GAS = '0x8e63F02d5fB3bCCD2939e0ba6Fe3Bf2635718F49'
60 | SIG = '0x1e0bd6fa'
61 | tx = { 'data': SIG, 'to': WASTE_GAS, 'from': EOA,'value':0,'chainId': 5,'gas': 50000,'maxFeePerGas': w3.to_wei('60', 'gwei'), 'maxPriorityFeePerGas': w3.to_wei('20', 'gwei'),'nonce': w3.eth.get_transaction_count(EOA)}
62 | signed_private = sign_tx(tx, KEY).rawTransaction.hex()
63 | 
64 | private = eth_sendPrivateTransaction
65 | private.update({
66 |   'id': 0,
67 |   'params': [{
68 |     'tx': signed_private, 
69 |     'maxBlockNumber': hex(TARGET_BLOCK + 10),
70 |     'preferences': {       
71 |       'fast': False,       
72 |       'privacy': {            
73 |         'hints': [             
74 |           'contract_address',             
75 |           'function_selector',             
76 |           'calldata',             
77 |           'logs',             
78 |           'hash'         
79 |         ],         
80 |         'builders': [      
81 |           'default',           
82 |           'flashbots'         
83 |         ],       
84 |       }
85 |     }
86 |   }]
87 | })
88 | 
89 | print(send_flash(private))
90 |  
91 | 


--------------------------------------------------------------------------------
/flashbots/mev-sse/simple_logger.py:
--------------------------------------------------------------------------------
 1 | # scrap logger
 2 | 
 3 | from simple_streamer import stream
 4 | from time import time
 5 | def log(_stream: object, to_console=False, filename='events.csv'):
 6 |   while 1:
 7 |     event = _stream()
 8 |     if event:
 9 |       with open(filename, 'a') as csv_file:
10 |         csv_file.write(f'{round(time())}; {event["hash"]}; {event["logs"]}; {event["txs"]}\n')
11 |       if to_console:
12 |         print(event)
13 | 
14 | if __name__ == '__main__':
15 |   log(stream, to_console=1)
16 | 


--------------------------------------------------------------------------------
/flashbots/mev-sse/simple_streamer.py:
--------------------------------------------------------------------------------
 1 | # simple streamer
 2 | from requests import get
 3 | def _stream(url: str) -> object:
 4 |   return get(url, stream=True).raw.stream() 
 5 | 
 6 | def stream_events(url: str) -> bytes:
 7 |   for chunks in _stream(url):
 8 |     chunk = chunks.split(b'\n\n')
 9 |     for event in chunk:
10 |       if event[:4] == b'data':
11 |         yield event[6:] 
12 | 
13 | # keep it up
14 | from json import loads
15 | from requests.exceptions import ChunkedEncodingError
16 | from logging import basicConfig, error, ERROR, debug
17 | from time import time
18 | basicConfig(level=ERROR)
19 | def parse(event: bytes) -> dict:
20 |   buff = ''
21 |   try:
22 |     buff = loads(event)
23 |   except (TypeError, ValueError, ChunkedEncodingError):
24 |     error(f'[-] Garbage chunk.. discarding\n[>] {event}')
25 |   finally: 
26 |     if not buff:
27 |       buff = loads(b'{"hash": "0x0000000000000000000000000000000000000000000000000000000000000000", "logs": null, "txs": null}')
28 |     return buff
29 | 
30 | from urllib3.exceptions import ProtocolError
31 | def stream(goerli=False): 
32 |   url = 'https://mev-share-goerli.flashbots.net' if goerli == True else 'https://mev-share.flashbots.net'
33 |   last_timestamp = 0
34 |   try:
35 |     return parse(next(stream_events(url)))
36 |   except (StopIteration, ConnectionError, ProtocolError):
37 |     current_timestamp = round(time())
38 |     if current_timestamp > last_timestamp + 5:
39 |       debug(f'[-] A break in stream has been logged at {time()}')
40 |       last_timestamp = current_timestamp
41 |     pass
42 |   except KeyboardInterrupt:     
43 |     from sys import exit as end_process     
44 |     end_process()
45 | 
46 | if __name__ == '__main__': 
47 |   while 1:
48 |     print(stream(goerli=0))
49 | 


--------------------------------------------------------------------------------
/flashbots/mev_send_bundle.py:
--------------------------------------------------------------------------------
  1 | # @author Maka
  2 | # @notice raw post flashbots mevshare bundle
  3 | 
  4 | from os import getenv 
  5 | from dotenv import load_dotenv 
  6 | from net import con  
  7 | 
  8 | w3 = con('GOERLI')  
  9 | 
 10 | load_dotenv()   
 11 | EOA = getenv('TRON')   
 12 | KEY = getenv('TKEY')    
 13 | FLA = getenv('FKEY')
 14 | 
 15 | def sign_tx(_tx, _key) -> str: 
 16 |   return w3.eth.account.sign_transaction(_tx, private_key=_key)
 17 | 
 18 | from eth_account import messages, Account
 19 | def sign_flash(_tx_body: str) -> str:
 20 |   message = messages.encode_defunct(text=w3.keccak(text=_tx_body).hex()) 
 21 |   signature = f'{Account.from_key(FLA).address}:{w3.eth.account.sign_message(message, FLA).signature.hex()}'
 22 |   return signature
 23 | 
 24 | from requests import post
 25 | from json import dumps
 26 | def send_flash(_request: dict) -> bytes:
 27 |   request = dumps(_request)
 28 |   headers = { 'Content-Type': 'application/json', 'X-Flashbots-Signature': sign_flash(request) }
 29 |   return post('https://relay-goerli.flashbots.net', data=request, headers=headers).content
 30 | 
 31 | 
 32 | MevSendBundleParams = {}
 33 | mev_sendBundle = {
 34 |   'jsonrpc': "2.0",
 35 |   'id': str or int,
 36 |   'method': "mev_sendBundle",
 37 |   'params': [{ # /* MevSendBundleParams */
 38 |               'version': "0" or "beta-1.0",
 39 |     'inclusion': {
 40 |       'block': str,      # // hex-encoded number
 41 |       'maxBlock': str,  # // hex-encoded number
 42 |     },
 43 |     'body': [
 44 |       { 'hash': str },
 45 |       { 'tx': str, 'canRevert': bool },
 46 |       { 'bundle': MevSendBundleParams }
 47 |       ],
 48 |     'validity': {
 49 |       'refund': [{
 50 |         'bodyIdx': int,
 51 |         'percent': int,
 52 |       }],
 53 |       'refundConfig': [{
 54 |         'address': str,
 55 |         'percent': int,
 56 |       }],
 57 |     },
 58 |     'privacy': {
 59 |       'hints': [
 60 |         "calldata",
 61 |         "contract_address",
 62 |         "logs",
 63 |         "function_selector",
 64 |         "hash"
 65 |         ],
 66 |       'builders': [ str ],
 67 |     },
 68 |   }]
 69 | }
 70 | 
 71 | eth_callBundle = {   
 72 |   'jsonrpc': '2.0',   
 73 |   'id': 1,
 74 |   'method': 'eth_callBundle',   
 75 |   'params': [{       
 76 |     'txs': [str,str],       
 77 |     'blockNumber': str,
 78 |     'stateBlockNumber': str, 
 79 |     'timestamp': int  
 80 |   }] 
 81 | }
 82 | 
 83 | eth_sendPrivateTransaction = {
 84 |     'jsonrpc': '2.0',   
 85 |     'id': str or int,   
 86 |     'method': 'eth_sendPrivateTransaction',
 87 |     'params': [{
 88 |     'tx': [str],
 89 |     'maxBlockNumber': str,     
 90 |     'preferences': {       
 91 |     'fast': 'false',       
 92 |     'privacy': {            
 93 |       'hints': [             
 94 |         'contract_address',             
 95 |         'function_selector',             
 96 |         'calldata',             
 97 |         'logs',             
 98 |         'hash'         
 99 |       ],         
100 |       'builders': [      
101 |         'default',           
102 |         'flashbots'         
103 |       ],       
104 |       }     
105 |     }
106 |   }]
107 | }
108 | 
109 | FREE = '0x9F4D93A220c23C786243a1406Dc69FCd8f4DAC35'
110 | TOGGLE = '0x47194a85'
111 | TAKE = '0xe0f6be56'
112 | 
113 | TARGET_BLOCK = w3.eth.block_number
114 | 
115 | tx1 = { 'data': TOGGLE, 'to': FREE, 'from': EOA,'value': 0,'chainId': 5,'gas': 40000,'maxFeePerGas': w3.to_wei('60', 'gwei'),'maxPriorityFeePerGas': w3.to_wei('20', 'gwei'),'nonce': w3.eth.get_transaction_count(EOA)}
116 | tx2 = { 'data': TAKE, 'to': FREE, 'from': EOA,'value':0,'chainId': 5,'gas': 50000,'maxFeePerGas': w3.to_wei('60', 'gwei'), 'maxPriorityFeePerGas': w3.to_wei('20', 'gwei'),'nonce': w3.eth.get_transaction_count(EOA) + 1}
117 | 
118 | signed_private = sign_tx(tx1, KEY).rawTransaction.hex()
119 | signed_backrun = sign_tx(tx2, KEY).rawTransaction.hex()
120 | 
121 | private = eth_sendPrivateTransaction
122 | private.update({
123 |   'id': 420,
124 |   'params': [{
125 |     'tx': signed_private, 
126 |     'maxBlockNumber': hex(TARGET_BLOCK + 10),
127 |     'preferences': {       
128 |       'fast': False,       
129 |       'privacy': {            
130 |         'hints': [             
131 |           'contract_address',             
132 |           'function_selector',             
133 |           'calldata',             
134 |           'logs',             
135 |           'hash'         
136 |         ],         
137 |         'builders': [      
138 |           'default',           
139 |           'flashbots'         
140 |         ],       
141 |       }
142 |     }
143 |   }]
144 | })
145 | 
146 | bundle = mev_sendBundle 
147 | bundle.update ({
148 |   'method': 'mev_sendBundle',
149 |   'id': 0,
150 |   'params': [{
151 |     'version': 'v0.1',
152 |     'inclusion': {
153 |       'block': hex(TARGET_BLOCK),
154 |       'maxBlock': hex(TARGET_BLOCK + 25)
155 |     },
156 |     'body': [{'tx': signed_private, 'canRevert': False}, {'tx': signed_backrun, 'canRevert': False}],
157 | #    'validity': {'refund': [{ 'bodyIdx': 1, 'percent': 90}]}
158 |   }]
159 | })
160 | 
161 | # send private tx
162 | print(send_flash(private))
163 | 
164 | # simulate bundle
165 | sim = eth_callBundle; sim.update({'params': [{'txs': [signed_private, signed_backrun], 'blockNumber': hex(w3.eth.block_number), 'stateBlockNumber': 'latest'}]})
166 | print(send_flash(sim))
167 | 
168 | # target next few blocks
169 | _id = 0
170 | _target = TARGET_BLOCK
171 | for block_num in range(TARGET_BLOCK, TARGET_BLOCK + 5):
172 |   bundle.update({"id": _id}), 
173 |   bundle['params'][0]['inclusion'] = {'block': hex(_target), 'maxBlock': hex(_target + 5)}
174 |   print(send_flash(bundle))
175 |   _id += 1
176 |   _target += 1
177 | 
178 | 
179 | # see if bundle was matched
180 | bundle['method'] =  'mev_simBundle'
181 | _id = 0
182 | _target = TARGET_BLOCK
183 | for block_num in range(TARGET_BLOCK, TARGET_BLOCK + 5):
184 |   bundle.update({"id": _id}), 
185 |   bundle['params'][0]['inclusion'] = {'block': hex(_target), 'maxBlock': hex(_target + 5)}
186 |   response = send_flash(bundle)
187 |   if b'success' in response:
188 |     print(response)
189 |     break
190 |   _id += 1
191 |   _target += 1
192 |  
193 | 


--------------------------------------------------------------------------------
/general/bloom_filter.py:
--------------------------------------------------------------------------------
 1 | # py port of an example I found here: https://ethereum.stackexchange.com/questions/142703/how-can-i-parse-an-ethereum-block-level-logsbloom
 2 | from net import con; w3 = con('MAINNET')
 3 | from hexbytes import HexBytes
 4 | keccak256 = w3.solidity_keccak
 5 | 
 6 | def get_num(hex_str: str, index: int, bytes_count: int = 1) -> int:
 7 |   hex_str = HexBytes(hex_str).hex()[2:]
 8 |   ost = index * 2
 9 |   return int(hex_str[ost:ost + 2 * bytes_count], 16)
10 | 
11 | def fetch_mask(topic: str) -> list:
12 |   buf = keccak256(['bytes'], [topic])
13 |   mask_1 = 1 << (get_num(buf, 1) & 0x7)
14 |   mask_2 = 1 << (get_num(buf, 3) & 0x7)
15 |   mask_3 = 1 << (get_num(buf, 5) & 0x7)
16 | 
17 |   bloom_len = 256
18 |   pos_1 = bloom_len - ((get_num(buf, 0, 2) & 0x7FF) >> 3) - 1
19 |   pos_2 = bloom_len - ((get_num(buf, 2, 2) & 0x7FF) >> 3) - 1
20 |   pos_3 = bloom_len - ((get_num(buf, 4, 2) & 0x7FF) >> 3) - 1
21 | 
22 |   return [
23 |     { 'index': pos_1, 'mask': mask_1 },
24 |     { 'index': pos_2, 'mask': mask_2 },
25 |     { 'index': pos_3, 'mask': mask_3 },
26 |   ]
27 | 
28 | def maybe_topic(bloom: str, masks: list) -> bool:
29 | 
30 |   def aux(x) -> bool:
31 |     b = get_num(bloom, x['index'])
32 |     return (b | x['mask'] == b)
33 | 
34 |   bits_set = list(filter(lambda b : b == True, map(lambda x: aux(x), masks) ))
35 |   return len(bits_set) == 3
36 | 
37 | if __name__ == '__main__' :
38 |   topic = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
39 |   logsBloom = '0x0100000000000004000000000000100000000000000000000000000000200000000000000000000000000000000001000000000000000000080008000000000040000000002000000000040800000000000000000000200000000000004800000040000002000000000000000000081000000000000040000000001080020000200001000000000000000000040000004000000000000000000000000010000000008000000000000800008000000800000000008000000200000800000000000000200a000000200000000000100002004000000000000000000000000020000000000080000020000000800000000000004000000000000000080000004000'
40 | 
41 |   print(maybe_topic(logsBloom, fetch_mask(topic)))
42 | 


--------------------------------------------------------------------------------
/general/multi2.py:
--------------------------------------------------------------------------------
 1 | # https://goerli.etherscan.io/address/0x77dca2c955b15e9de4dbbcf1246b4b85b651e50e
 2 | # ex. multicall
 3 | 
 4 | from net import con; w3 = con('GOERLI') # use your set up
 5 | from os import getenv; from dotenv import load_dotenv; load_dotenv(); EOA = getenv('TRON')
 6 | from eth_abi import encode, decode
 7 | 
 8 | add = '0x5BA1e12693Dc8F9c48aAD8770482f4739bEeD696'
 9 | abi = '''
10 | [{"inputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Multicall2.Call[]","name":"calls","type":"tuple[]"}],"name":"aggregate","outputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"},{"internalType":"bytes[]","name":"returnData","type":"bytes[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Multicall2.Call[]","name":"calls","type":"tuple[]"}],"name":"blockAndAggregate","outputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"},{"internalType":"bytes32","name":"blockHash","type":"bytes32"},{"components":[{"internalType":"bool","name":"success","type":"bool"},{"internalType":"bytes","name":"returnData","type":"bytes"}],"internalType":"struct Multicall2.Result[]","name":"returnData","type":"tuple[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getBlockHash","outputs":[{"internalType":"bytes32","name":"blockHash","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBlockNumber","outputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentBlockCoinbase","outputs":[{"internalType":"address","name":"coinbase","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentBlockDifficulty","outputs":[{"internalType":"uint256","name":"difficulty","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentBlockGasLimit","outputs":[{"internalType":"uint256","name":"gaslimit","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentBlockTimestamp","outputs":[{"internalType":"uint256","name":"timestamp","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"getEthBalance","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLastBlockHash","outputs":[{"internalType":"bytes32","name":"blockHash","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"requireSuccess","type":"bool"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Multicall2.Call[]","name":"calls","type":"tuple[]"}],"name":"tryAggregate","outputs":[{"components":[{"internalType":"bool","name":"success","type":"bool"},{"internalType":"bytes","name":"returnData","type":"bytes"}],"internalType":"struct Multicall2.Result[]","name":"returnData","type":"tuple[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"requireSuccess","type":"bool"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Multicall2.Call[]","name":"calls","type":"tuple[]"}],"name":"tryBlockAndAggregate","outputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"},{"internalType":"bytes32","name":"blockHash","type":"bytes32"},{"components":[{"internalType":"bool","name":"success","type":"bool"},{"internalType":"bytes","name":"returnData","type":"bytes"}],"internalType":"struct Multicall2.Result[]","name":"returnData","type":"tuple[]"}],"stateMutability":"nonpayable","type":"function"}]
11 | '''
12 | 
13 | multi = w3.eth.contract(address=add,abi=abi)
14 | 
15 | # contract Multicall2 {
16 | #  struct Call {
17 | #     address target;
18 | #     bytes callData;
19 | # }
20 | 
21 | targets = ['0x00cace976Dd3D81E001F8406Cd292919a3E86FC3','0x7E3B630298555c159b34dB3Db9365a54487f1881']
22 | 
23 | sig = w3.solidity_keccak(['string'],['balanceOf(address)'])[:4]
24 | data = sig + encode(['address'],[EOA])
25 | 
26 | datas = [(targets[0],data), (targets[1],data)]
27 | calls = multi.functions.aggregate(datas).build_transaction({})
28 | 
29 | print(decode(['uint256','bytes[]'], w3.eth.call(calls)))
30 | # 1 love
31 | 


--------------------------------------------------------------------------------
/general/transfer_override.py:
--------------------------------------------------------------------------------
 1 | from net import con; w3 = con('MAINNET') # your set up
 2 | from eth_abi import encode
 3 | 
 4 | dai = '0x6B175474E89094C44Da98b954EedeAC495271d0F'
 5 | spendee = '0x8c14ed4F602ac4d2Be8Ed9c4716307c73e9A83A8'
 6 | 
 7 | num = lambda x : int(x,16)
 8 | u256 = lambda x : '0x'+encode(['uint256'],[x]).hex()
 9 | 
10 | # mapping (address => uint) public balanceOf;
11 | slot = 2
12 | index = w3.solidity_keccak(['uint256', 'uint256'],[num(spendee), slot]).hex()
13 | 
14 | diff = { dai: { 'stateDiff': { index: u256(10000*10**18) } } }
15 | 
16 | data = '0xa9059cbb000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005a6d66291495590000'
17 | 
18 | print(
19 |   'With override: \n',
20 |   w3.eth.call({'from': spendee, 'to': dai, 'data': data}, 'latest', diff)
21 | )
22 | print(
23 |   'Without override: \n',
24 |   w3.eth.call({'from': spendee, 'to': dai, 'data': data}, 'latest')
25 | )
26 | 


--------------------------------------------------------------------------------
/misc/con/net.py:
--------------------------------------------------------------------------------
 1 | from os import getenv
 2 | from dotenv import load_dotenv
 3 | from web3 import Web3, HTTPProvider
 4 | from web3.middleware import geth_poa_middleware
 5 | POA_LIST = ['GOERLI', 'POLYGON', 'BSC', 'METIS']
 6 | def con(_node: str) -> object:
 7 |   load_dotenv()
 8 |   w3 = Web3(HTTPProvider(getenv(_node)))
 9 |   if _node in POA_LIST:
10 |     w3.middleware_onion.inject(
11 |       geth_poa_middleware,
12 |       layer=0
13 |     )
14 |   return w3
15 | 


--------------------------------------------------------------------------------
/misc/makas_py_on_chain.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/0xMaka/w3py/ac4c666ac8ed656a5afc8b9b0cf68fa394018bab/misc/makas_py_on_chain.png


--------------------------------------------------------------------------------
/misc/migrations.py:
--------------------------------------------------------------------------------
 1 | # for updating old code (likely not exhaustative)
 2 | # - https://github.com/ethereum/web3.py/blob/ebf7203f63b2c801873c5bc2cb6d360f8a57fa17/docs/release_notes.rst#L15
 3 | 
 4 | snake_cased = {
 5 |   'processReceipt' : 'process_receipt', 
 6 |   'processLog' : 'process_log', 
 7 |   'createFilter' : 'create_filter',
 8 |   'getLogs' : 'getlogs',
 9 |   'clientVersion' : 'client_version',
10 |   'solidityKeccak' : 'solidity_keccak',
11 |   'fromWeb3' : 'from_web3',
12 |   'toBytes' : 'to_bytes', 
13 |   'toHex' : 'to_hex', 
14 |   'toInt' : 'to_int', 
15 |   'toJSON' : 'to_json', 
16 |   'toText' : 'to_text',
17 |   'toAddress' : 'to_address', 
18 |   'isChecksumAddress' : 'is_checksum_address', 
19 |   'toChecksumAddress' : 'to_checksum_address',
20 |   'isConnected' : 'is_connected',
21 |   'toWei' : 'to_wei',
22 |   'fromWei' : 'from_wei',
23 |   'estimateGas' : 'estimate_gas',
24 |   'getBlock ' : 'get_block',
25 |   'getTransaction' : 'get_transaction',
26 |   'PeerCount' : 'peer_count',
27 |   'startAutoDAG' : 'start_auto_dag',
28 |   'stopAutoDAG' : 'stop_auto_dag',
29 |   'setExtra' : 'set_extra',
30 |   'setEtherbase' : 'set_etherbase',
31 |   'setGasPrice' : 'set_gas_price',
32 |   'listAccounts' : 'list_accounts',
33 |   'newAccount' : 'new_account',
34 |   'lockAccount' : 'lock_account',
35 |   'unlockAccount' : 'unlock_account',
36 |   'sendTransaction' : 'send_transaction',
37 |   'importRawKey' : 'import_raw_key'
38 | }
39 | 
40 | # w3/eth
41 | # - https://github.com/ethereum/web3.py/pull/2709
42 | # - https://github.com/ethereum/web3.py/pull/2686
43 | # - https://github.com/ethereum/web3.py/pull/2702
44 | # - https://github.com/ethereum/web3.py/pull/2703
45 | # - https://github.com/ethereum/web3.py/pull/2707
46 | # - https://github.com/ethereum/web3.py/pull/2708
47 | # - https://github.com/ethereum/web3.py/pull/2643
48 | # - https://github.com/ethereum/web3.py/pull/2647
49 | # - https://github.com/ethereum/web3.py/pull/1232
50 | # net
51 | # - https://github.com/ethereum/web3.py/pull/1581/commits
52 | # miner
53 | # - https://github.com/ethereum/web3.py/pull/1579/commits
54 | # personal
55 | # - https://github.com/ethereum/web3.py/pull/1589/commits/61212720fc9ad52a4fda36fd946725100c257e45
56 | 


--------------------------------------------------------------------------------
/raw_calls/raw_approval.py:
--------------------------------------------------------------------------------
 1 | from os import getenv                                                                                                                                    
 2 | from dotenv import load_dotenv                                                                                                                           
 3 | from net import con                                                                                                                                      
 4 |                                                                                                                                                          
 5 | w3 = con()                                                                                                                                               
 6 |                                                                                                                                                          
 7 | def return_account():                                                                                                                                    
 8 |   load_dotenv()                                                                                                                                          
 9 |   return { 'addr': getenv('tron'), 'key': getenv('key') }                                                                                                
10 |                                                                                                                                                          
11 | def sign_tx(tx, key):                                                                                                                                    
12 |   return w3.eth.account.sign_transaction(tx, private_key=key)                                                                                                                        
13 |                                                                                                                                                          
14 | def send_tx(signed_tx):                                                                                                                                  
15 |   return w3.eth.send_raw_transaction(signed_tx.rawTransaction)                                                                                                  
16 |                                                                                                                                                          
17 | def main():                                                                                                                                              
18 |   account   = return_account()                                                                                                                             
19 |   nonce     = w3.eth.get_transaction_count(account['addr'])                                                                                                  
20 |   
21 |   function  = '095ea7b3'
22 |   address   = '0000000000000000000000001b02da8cb0d097eb8d57a175b88c7d8b47997506'
23 |   amount    = '0000000000000000000000000000000000000000000000000000000000989680' 
24 |   data      = '0x' + function + address + amount
25 | 
26 |   tx = {                                                                                                                                                 
27 |     'from'   : account['addr'],                                                                                                                             
28 |     'to'     : '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270',                                                                                                  
29 |     'value'  : 0,                                                                                                                                           
30 |     'chainId': 137,                                                                                                                                      
31 |     'gas'    : 250000,                                                                                                                                       
32 |     'maxFeePerGas': w3.eth.gas_price * 2,
33 |     'maxPriorityFeePerGas': w3.eth.max_priority_fee * 2,
34 |     'nonce'  : nonce,                                                                                                                                      
35 |     'data'   : data 
36 |   }                                                                                                                                                      
37 |                                                                                                                                                          
38 |   sent = send_tx(sign_tx(tx, account['key']))                                                                                                            
39 |   print (f'hash: {sent}')                                                                                                                                
40 |                                                                                                                                                          
41 | if __name__ == '__main__':                                                                                                                               
42 |   main()                                                                                                                                                 
43 | 


--------------------------------------------------------------------------------
/raw_calls/raw_deploy.py:
--------------------------------------------------------------------------------
 1 | from os import getenv
 2 | from dotenv import load_dotenv
 3 | from net import con
 4 | 
 5 | w3 = con()
 6 | 
 7 | def return_account():
 8 |   load_dotenv()
 9 |   return { 'addr': getenv('tron'), 'key': getenv('key') }
10 | 
11 | def sign_tx(tx, key):
12 |   sig = w3.eth.account.sign_transaction
13 |   return sig(tx, private_key=key)
14 | 
15 | def send_tx(signed_tx):
16 |   w3.eth.send_raw_transaction(signed_tx.rawTransaction)
17 |   return w3.toHex(w3.keccak(signed_tx.rawTransaction))
18 | 
19 | def main():
20 | 
21 |   account = return_account() 
22 |   nonce = w3.eth.get_transaction_count(account['addr'])
23 |   tx = {
24 |         'from': account['addr'],
25 |         'value':0,
26 |         'chainId': 42,
27 |         'gas': 500000,
28 |         'maxFeePerGas': w3.toWei('50', 'gwei'),
29 |         'maxPriorityFeePerGas': w3.toWei('40', 'gwei'),
30 |         'nonce': nonce
31 |         }
32 |   
33 |   data = ''
34 |   with open('vy/test.bin', 'r') as f:
35 |     data = f.read()
36 |     
37 |   tx.update({'data': data.strip()})
38 |   
39 |   sent = send_tx(sign_tx(tx, account['key']))
40 |   print (f'sent: {sent}') 
41 | 
42 | if __name__ == '__main__':
43 |   main()
44 | 


--------------------------------------------------------------------------------
/raw_calls/raw_deposit.py:
--------------------------------------------------------------------------------
 1 | from os import getenv                                              
 2 | from dotenv import load_dotenv                                     
 3 | from net import con                                                
 4 |                                                                    
 5 | w3 = con()                                                         
 6 |                                                                    
 7 | def return_account():                                              
 8 |   load_dotenv()                                                    
 9 |   return { 'addr': getenv('tron'), 'key': getenv('key') }          
10 |                                                                    
11 | def sign_tx(tx, key):                                              
12 |   sig = w3.eth.account.sign_transaction                            
13 |   return sig(tx, private_key=key)                                  
14 |                                                                    
15 | def send_tx(signed_tx):                                            
16 |   w3.eth.send_raw_transaction(signed_tx.rawTransaction)            
17 |   return w3.to_hex(w3.keccak(signed_tx.rawTransaction))            
18 |                                                                    
19 | def main():                                                        
20 |   account = return_account()                                       
21 |   nonce = w3.eth.get_transaction_count(account['addr'])            
22 |                                                                    
23 |   tx = {                                                           
24 |     'from': account['addr'],                                       
25 |     'to': '0x6BEbC4925716945D46F0Ec336D5C2564F419682C',            
26 |     'value': 100000000000000000,                                   
27 |     'chainId': 5,                                                  
28 |     'gas': 250000,                                                 
29 |     'maxFeePerGas': w3.to_wei('200', 'gwei'),                      
30 |     'maxPriorityFeePerGas': w3.to_wei('160', 'gwei'),              
31 |     'nonce': nonce,                                                
32 |     'data': '0x439370b1'                                           
33 |   }                                                                
34 |                                                                    
35 |   print (f'sent: {send_tx(sign_tx(tx, account["key"]))}')          
36 |                                                                    
37 | if __name__ == '__main__':                                         
38 |   main()                                                           


--------------------------------------------------------------------------------
/raw_calls/raw_transfer.py:
--------------------------------------------------------------------------------
 1 | from os import getenv
 2 | from dotenv import load_dotenv
 3 | from net import con
 4 | 
 5 | w3 = con()
 6 | 
 7 | def return_account():
 8 |   load_dotenv()
 9 |   return { 'addr': getenv('tron'), 'key': getenv('key') }
10 | 
11 | def sign_tx(tx, key):
12 |   sig = w3.eth.account.sign_transaction
13 |   return sig(tx, private_key=key)
14 | 
15 | def send_tx(signed_tx):
16 |   w3.eth.send_raw_transaction(signed_tx.rawTransaction)
17 |   return w3.toHex(w3.keccak(signed_tx.rawTransaction))
18 | 
19 | def main():
20 |   account = return_account()
21 |   nonce = w3.eth.get_transaction_count(account['addr'])
22 | 
23 |   tx = {
24 |     'from': account['addr'],
25 |     'to': '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270',
26 |     'value':0,
27 |     'chainId': 137,
28 |     'gas': 250000,
29 |     'maxFeePerGas': w3.toWei('500', 'gwei'),
30 |     'maxPriorityFeePerGas': w3.toWei('400', 'gwei'),
31 |     'nonce': nonce,
32 |     'data': '0xa9059cbb0000000000000000000000008c14ed4f602ac4d2be8ed9c4716307c73e9a83a800000000000000000000000000000000000000000000000000000000191387e1'
33 |   }
34 | 
35 |   sent = send_tx(sign_tx(tx, account['key']))
36 |   print (f'sent: {sent}')
37 | 
38 | if __name__ == '__main__':
39 |   main()


--------------------------------------------------------------------------------
/scrapbots/flash_bot.py:
--------------------------------------------------------------------------------
  1 | from os import getenv
  2 | 
  3 | import json
  4 | 
  5 | from eth_account.account import Account
  6 | from eth_account.signers.local import LocalAccount
  7 | from flashbots import flashbot
  8 | from web3 import Web3, HTTPProvider
  9 | from web3.exceptions import TransactionNotFound
 10 | from web3.types import TxParams
 11 | 
 12 | from dotenv import load_dotenv
 13 | load_dotenv()
 14 | from web3.middleware import geth_poa_middleware 
 15 | 
 16 | 
 17 | def main(sol_file, contract):
 18 |     sender: LocalAccount = Account.from_key(getenv('TKEY'))
 19 |     receiver: LocalAccount = Account.from_key(getenv('PKEY'))
 20 |     signature: LocalAccount = Account.from_key(getenv('FLASH'))
 21 | 
 22 |     w3 = Web3(HTTPProvider(getenv('NODE')))
 23 |     w3.middleware_onion.inject(geth_poa_middleware, layer=0) 
 24 |     flashbot(w3, signature)
 25 | 
 26 | 
 27 | 
 28 |     print(f'[*] Sender account balance: {Web3.fromWei(w3.eth.get_balance(sender.address), "ether")} ETH')
 29 |     
 30 |     print(f'[*] Compiling contract ->')
 31 |     from compiler import compile_contract
 32 |     abi, bytecode = compile_contract(sol_file, contract)
 33 |    
 34 | 
 35 | 
 36 |     def stack(j):
 37 |       with open ('contracts.json', 'a') as f:
 38 |         json.dump(j, f, indent=2)  
 39 |         f.close()
 40 |     
 41 |     jdict = {'abi':f'{str(abi)}'} 
 42 |     stack(jdict)
 43 | 
 44 |     print(f'[+] ABI written to contracts.json')
 45 |     print(f'[*] Attempting to deploy contract ->')
 46 |     
 47 | 
 48 |     # build message
 49 |     message = 'TESTRELAY: TEST2'.encode('utf-8')
 50 | 
 51 |     from padding import pad
 52 |     data = pad(message.hex(), 0, 32) 
 53 | 
 54 | 
 55 | 
 56 |     # build and sign transactions
 57 |     nonce = w3.eth.get_transaction_count(sender.address)
 58 | 
 59 |     tx1: TxParams = {
 60 |         'to': '',
 61 |         'value': w3.toWei(0, 'ether'),
 62 |         'gas': 600000,
 63 |         'maxFeePerGas': Web3.toWei(50, 'gwei'),
 64 |         'maxPriorityFeePerGas': Web3.toWei(40, 'gwei'),
 65 |         'nonce': nonce,
 66 |         'chainId': 5,
 67 |         'type': 2,
 68 | 
 69 |         'data': '0x' + bytecode
 70 |     }
 71 |     tx1_signed = sender.sign_transaction(tx1)
 72 |     
 73 |     tx2: TxParams = {
 74 |         'to': receiver.address,
 75 |         'value': w3.toWei(0.004200071000, 'ether'),
 76 |         'gas': 25000,
 77 |         'maxFeePerGas': Web3.toWei(30, 'gwei'),
 78 |         'maxPriorityFeePerGas': Web3.toWei(20, 'gwei'),
 79 |         'nonce': nonce + 1,
 80 |         'chainId': 5,
 81 |         'type': 2,
 82 |         'data': '0x' + data
 83 |     }
 84 |     tx2_signed = sender.sign_transaction(tx2)
 85 | 
 86 | 
 87 |     bundle = [
 88 |         {'signed_transaction': tx1_signed.rawTransaction},
 89 |         {'signed_transaction': tx2_signed.rawTransaction},
 90 |     ]
 91 | 
 92 | 
 93 | 
 94 |     # send bundle to be executed in the next 5 blocks
 95 |     block = w3.eth.block_number
 96 | 
 97 |     try:
 98 |         sim_result = w3.flashbots.simulate(bundle, block)
 99 |         print('[!] Dumping results of simulation:\n', sim_result)
100 |     except Exception as e:
101 |         print('[-] There was a error with your simulation', e)
102 | 
103 |     results = []
104 |     for target_block in [block + k for k in [1, 2, 3, 4, 5]]:
105 |         results.append(w3.flashbots.send_bundle(bundle, target_block_number=target_block))
106 |         print(f'[*] Bundle sent to miners block: {target_block}')
107 | 
108 |     # wait for all results
109 |     results[-1].wait()
110 |     try:
111 |         receipt = results[-1].receipts()
112 |         print(f'[+] Bundle was executed block {receipt[0].blockNumber}')
113 |     except TransactionNotFound:
114 |         print('[-] Bundle was not executed')
115 |         return
116 | 
117 |     print(f'[*] Sender account balance: {Web3.fromWei(w3.eth.get_balance(sender.address), "ether")} ETH')
118 |     print(f'[*] Contract deployed at: {receipt[0].contractAddress}')
119 |     
120 |     jdict = {'Contract_address':f'{receipt[0].contractAddress}'} 
121 |     stack(jdict)
122 | 
123 |     print('[+] Address written to contracts.json')  
124 |     print('[+] Mission successful. o>')  
125 | 
126 | if __name__ == '__main__':
127 |     main('MultiCall.sol', 'TestRelay')
128 | 


--------------------------------------------------------------------------------
/scrapbots/skym_bot/README.md:
--------------------------------------------------------------------------------
 1 | # skym
 2 | basic bot example
 3 | 
 4 |         NOTE: Bot makes no check for profitability, only difference. Bot scans a single pool. 
 5 |         Bot makes no attempt to optimise cycles and would not be competative.
 6 |         To make competative bots consider writing computationally expensive modules in c,
 7 |         or rust, and using python as the glue language.
 8 |         Consider strategies for gas, and pool analysis.
 9 |         Consider running an own node or looking into a service such as block native,
10 |         so to back run the mem pool as opposed to on chain balance changes.
11 |         1love
12 | 


--------------------------------------------------------------------------------
/scrapbots/skym_bot/abi/erc20_abi.json:
--------------------------------------------------------------------------------
1 | [{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"guy","type":"address"},{"name":"wad","type":"uint256"}],"name":"approve","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"src","type":"address"},{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"wad","type":"uint256"}],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"deposit","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":true,"name":"guy","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":true,"name":"dst","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"dst","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Withdrawal","type":"event"}]
2 | 


--------------------------------------------------------------------------------
/scrapbots/skym_bot/abi/relay_abi.json:
--------------------------------------------------------------------------------
1 | [{"stateMutability": "payable", "type": "function", "name": "fn_relay", "inputs": [{"name": "_dest", "type": "address"}, {"name": "_data", "type": "bytes"}], "outputs": [{"name": "", "type": "bytes"}]}]
2 | 


--------------------------------------------------------------------------------
/scrapbots/skym_bot/abi/slp_abi.json:
--------------------------------------------------------------------------------
1 | [{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount0In","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1In","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount0Out","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1Out","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"Swap","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint112","name":"reserve0","type":"uint112"},{"indexed":false,"internalType":"uint112","name":"reserve1","type":"uint112"}],"name":"Sync","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINIMUM_LIQUIDITY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"burn","outputs":[{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"amount1","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getReserves","outputs":[{"internalType":"uint112","name":"_reserve0","type":"uint112"},{"internalType":"uint112","name":"_reserve1","type":"uint112"},{"internalType":"uint32","name":"_blockTimestampLast","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token0","type":"address"},{"internalType":"address","name":"_token1","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"kLast","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"liquidity","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","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":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"price0CumulativeLast","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price1CumulativeLast","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"skim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount0Out","type":"uint256"},{"internalType":"uint256","name":"amount1Out","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"swap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sync","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token0","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token1","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]
2 | 


--------------------------------------------------------------------------------
/scrapbots/skym_bot/caller.py:
--------------------------------------------------------------------------------
  1 | # @title caller.py - skym_bot
  2 | # @notice simple skim bot example flow, with py and vy.
  3 | 
  4 | #  NOTE: Bot makes no check for profitability, only difference. Bot scans a single pool. 
  5 | #        Bot makes no attempt to optimise cycles and would not be competative.
  6 | #        To make competative bots consider writing computationally expensive modules in c,
  7 | #        or rust, and using python as the glue language.
  8 | #        Consider strategies for gas, and pool analysis.
  9 | #        Consider running an own node or looking into a service such as block native,
 10 | #        so to back run the mem pool as opposed to on chain balance changes.
 11 | #
 12 | #        1love
 13 | #
 14 | 
 15 | # @author Maka
 16 | 
 17 | # imports
 18 | from os import getenv
 19 | 
 20 | from web3 import Web3, HTTPProvider
 21 | from web3.middleware import geth_poa_middleware
 22 | from dotenv import load_dotenv
 23 | 
 24 | import asyncio
 25 | 
 26 | # initializations & declerations
 27 | load_dotenv()
 28 | w3 = Web3(HTTPProvider(getenv('NODE')))
 29 | w3.middleware_onion.inject(geth_poa_middleware, layer=0)
 30 | 
 31 | acc = getenv('ACC')
 32 | key = getenv('KEY')
 33 | 
 34 | fn_hash = '0xbc25cf77'
 35 | fn_call = '{:0>64}'.format(acc[2:])
 36 | SKIM = f'{fn_hash}{fn_call}'
 37 | RELAY ='0x19FDA656Ffb0C51420832A42ed319a0fEDD6477f' # relay contract address
 38 | 
 39 | # helper - fetches abi from file located in 'abi/'
 40 | def from_json(file: str) -> str:
 41 |   with open(file) as f:
 42 |     return f.read().strip()
 43 | 
 44 | SLP_ABI = from_json('abi/slp_abi.json')
 45 | ERC20_ABI = from_json('abi/erc20_abi.json')
 46 | RELAY_ABI = from_json('abi/relay_abi.json')
 47 | 
 48 | # helper - returns a w3 contract object
 49 | def conify(add: str, abi: str) -> object:
 50 |   return w3.eth.contract(address=add, abi=abi)
 51 | 
 52 | eth_usdc = '0x19DA2E185dB2842710FDed575E9da96c66cc4025' # sushi on goerli
 53 | slp = conify(eth_usdc, SLP_ABI)
 54 | relay = conify(RELAY, RELAY_ABI)
 55 | 
 56 | # core functions
 57 | def get_reserves(slp: object) -> list:
 58 |   reserve0, reserve1, timestamp = slp.functions.getReserves().call()
 59 |   del(timestamp)
 60 |   return [reserve0, reserve1]
 61 | 
 62 | def sort_tokens(slp: object) -> list:
 63 |   token0 = slp.functions.token0().call()
 64 |   token1 = slp.functions.token1().call()
 65 |   return [token0, token1]
 66 | 
 67 | def get_balances(slp: object) -> list:
 68 |   tokens = []
 69 |   for i in sort_tokens(slp):
 70 |     tokens.append(conify(i, ERC20_ABI))
 71 |   token0_bal = tokens[0].functions.balanceOf(slp.address).call()
 72 |   token1_bal = tokens[1].functions.balanceOf(slp.address).call()
 73 |   return [token0_bal, token1_bal]
 74 | 
 75 | def fetch_amounts(slp: object) -> dict:
 76 |   r0, r1 = get_reserves(slp)
 77 |   b0, b1 = get_balances(slp)
 78 |   return {
 79 |     'reserve0': r0,
 80 |     'balance0': b0,
 81 | 
 82 |     'reserve1': r1,
 83 |     'balance1': b1,
 84 |   }
 85 | 
 86 | # @params [reserve0, balance0, reserve1, balance1]
 87 | def sort_gt(vals: list) -> str:
 88 |   return 'token0' if vals[1] > vals[0] else 'token1'
 89 | 
 90 | def sign_tx(tx, key) -> str:
 91 |   sig = w3.eth.account.sign_transaction
 92 |   return sig(tx, private_key=key)
 93 | 
 94 | def send_tx(signed_tx) -> str:
 95 |   w3.eth.send_raw_transaction(signed_tx.rawTransaction)
 96 |   return w3.toHex(w3.keccak(signed_tx.rawTransaction))
 97 | 
 98 | def confirm_tx(tx_hash) -> (dict, bool):
 99 |   try:
100 |     receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=120, poll_latency=0.1)
101 |     return (receipt, 1)
102 |   except: return ({'Status': 'Failed'}, 0)
103 | 
104 | def get_tx() -> dict:
105 |   return {
106 |         'from': acc,
107 |         'value':0,
108 |         'chainId': 5,
109 |         'gas': 500000,
110 |         'maxFeePerGas': w3.toWei('50', 'gwei'),
111 |         'maxPriorityFeePerGas': w3.toWei('40', 'gwei'),
112 |         'nonce': w3.eth.get_transaction_count(acc)
113 |         }
114 | 
115 | def pj(d: dict) -> str:
116 |   for key, value in d.items():
117 |     print(f'{key}: {value}')
118 | 
119 | def go_skim(pool: str, tx: dict) -> str:
120 |   rtx = relay.functions.fn_relay(pool, SKIM).build_transaction(tx)
121 |   return send_tx(sign_tx(rtx, key))
122 | 
123 | async def main():
124 |   token0, token1 = sort_tokens(slp)
125 |   success = False
126 | 
127 |   print('--- [+] Incoming data --------------------------------------#')
128 | 
129 |   while(1): # run forever
130 |     res0, bal0, res1, bal1 = fetch_amounts(slp).values()
131 |     vals = [res0, bal0, res1, bal1]
132 |     diff = [vals[1] - vals[0], vals[3] - vals[2]]
133 |     print(
134 |       f'''\nToken0: {token0} \n  res0: {vals[0]}\n  bal0: {vals[1]}\n  diff: {diff[0]}  
135 |           \nToken1: {token1} \n  res1: {vals[2]}\n  bal1: {vals[3]}\n  diff: {diff[1]}'''
136 |     )
137 | 
138 |     if diff[0] >= 5*10**14 or diff[1] >= 1*10**6: # if difference gte roughly '$1'
139 |       tx = get_tx()
140 |       #....
141 |       gt = sort_gt(vals)
142 |       address = token0 if gt == 'token0' else token1
143 |       print('\n------------------------------------------------------------#\n')
144 |       print(f'[+] {gt}:\n    {address}\n    Shows diff: {diff[int(gt[-1:])]}') # 0|1
145 | 
146 |       tx_hash = go_skim(slp.address, tx)
147 |       print(f'[+] Tx launched: {tx_hash}')
148 | 
149 |       print(f'[+] Awaiting receipt...')
150 |       receipt, success = confirm_tx(tx_hash) 
151 | 
152 |       if success:
153 |         print(f'[+] Tx receipt: ')
154 |         pj(vars(receipt))
155 |       elif not success:
156 |         tx.update({
157 |           'maxFeePerGas': w3.toWei('60', 'gwei'),
158 |           'maxPriorityFeePerGas': w3.toWei('50', 'gwei')
159 |         })
160 |         tx_hash = go_skim(slp.address, tx)
161 |         print(f'[+] Replacement tx launched: {tx_hash}')
162 |         print(f'[+] Awaiting receipt...')
163 |         print(confirm_tx(tx_hash)) 
164 |       else: 
165 |         print('Some error')
166 |     
167 |     print('\n------------------------------------------------------------#')
168 |     await asyncio.sleep(3)
169 | 
170 | asyncio.run(main())
171 | 


--------------------------------------------------------------------------------
/scrapbots/skym_bot/relay.vy:
--------------------------------------------------------------------------------
 1 | # @version ^0.3.6
 2 | # @title    Relay
 3 | # @author   Maka
 4 | 
 5 | ops: address
 6 | MAX: constant(uint256) = 1024
 7 | 
 8 | @external
 9 | def __init__():
10 |   self.ops = msg.sender
11 | 
12 | @external
13 | @payable
14 | def fn_relay(_dest: address, _data: Bytes[MAX]) -> Bytes[128]:
15 |   assert msg.sender == self.ops
16 |   success: bool = False
17 |   response: Bytes[128] = b''
18 |   success, response = raw_call(
19 |     _dest,
20 |     _data, 
21 |     value=msg.value, 
22 |     max_outsize=128, 
23 |     revert_on_failure=False
24 |   )
25 |   assert success
26 |   return response
27 | 
28 |  # 1 love
29 | 


--------------------------------------------------------------------------------
/scrapbots/voly.py:
--------------------------------------------------------------------------------
  1 | # __ Imports and initialisations ______________________________________________
  2 | from x import con
  3 | import asyncio
  4 | from os import getenv
  5 | from dotenv import load_dotenv
  6 | from time import time
  7 | 
  8 | load_dotenv()
  9 | w3 = con('POLYGON')
 10 | 
 11 | # __ Configuration ____________________________________________________________
 12 | # @notice where to store receipts
 13 | LOGS = 'logs/receipts.log'
 14 | # @notice import account
 15 | EOA = '<INSERTADDRESS>'
 16 | KEY = getenv('RANGE_KEY')
 17 | # @notice hardcode decimals
 18 | RES0_DEC = 18
 19 | RES1_DEC = 6
 20 | # @notice target pool (WMATIC -> USDC)
 21 | PAIR_ADDRESS = '0x6e7a5FAFcec6BB1e78bAE2A1F0B612012BF14827'
 22 | WMATIC = '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270'
 23 | USDC = '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174'
 24 | # @notice for now: Quickswap router
 25 | ROUTER_ADDRESS = '0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff'
 26 | # @dev if there is a delay, how long.
 27 | POLL_DELAY = 2
 28 | # @notice position size in USDC
 29 | SIZE = 20000000
 30 | # @notice buy n sell ranges
 31 | supply_zone = 0.79
 32 | demand_zone = 0.74
 33 | stop_loss = 0.697
 34 | # @notice volatile settings
 35 | cached_nonce = w3.eth.get_transaction_count(EOA)
 36 |   
 37 | # __ Helpers __________________________________________________________________
 38 | def fetch_abi(_file: str) -> str:
 39 |   with open(f'abi/{_file}') as f:
 40 |     abi = f.read().strip()
 41 |   return abi
 42 | 
 43 | def c_init(_addr: str, _abi: str) -> object:
 44 |   return w3.eth.contract(address=_addr, abi=_abi)
 45 | 
 46 | def get_reserves(_pair: object) -> (int, int, int):
 47 |   return _pair.functions.getReserves().call()
 48 | 
 49 | async def poll_reserves(_pair: object) -> list:
 50 |   await asyncio.sleep(POLL_DELAY)
 51 |   res0, res1, stamp = get_reserves(_pair)
 52 |   return [res0, res1, stamp]
 53 | 
 54 | # __ Filler functions _________________________________________________________
 55 | def from_wei(_n: int, _dec: int) -> float:
 56 |   return _n / 10 ** _dec
 57 | 
 58 | def to_wei(_n: int, _dec: int) -> int:
 59 |   return int(_n * 10 ** _dec)
 60 | 
 61 | def calcSlippage(_slippage: float, _amount: int) -> int:
 62 |   return int(_slippage / 100 * _amount)
 63 | 
 64 | def dline() -> int:
 65 |   return round(time()) + (60 * 5)
 66 | 
 67 | def getAmountOut(amountIn: int, reserveIn: int, reserveOut: int) -> int:
 68 |   amountInWithFee = amountIn * 997
 69 |   numerator = amountInWithFee * reserveOut
 70 |   denominator = (reserveIn * 1000) + amountInWithFee
 71 |   amountOut = numerator / denominator
 72 |   return int(amountOut)
 73 | 
 74 | def getAmountIn(amountOut: int, reserveIn: int, reserveOut: int) -> int:
 75 |   numerator = (reserveIn * amountOut) * 1000
 76 |   denominator = (reserveOut - amountOut) * 997
 77 |   amountIn = (numerator / denominator) + 1
 78 |   return int(amountIn)  
 79 | 
 80 | tx = {        
 81 |         'chainId': 137,
 82 |         'type': '0x2',  
 83 |         'from': EOA, 
 84 |         'value': 0, 
 85 |         'gas': 200000,
 86 |         'maxFeePerGas': 35000000000, 
 87 |         'maxPriorityFeePerGas': 35000000000, 
 88 |         'nonce': cached_nonce
 89 | }
 90 | 
 91 | def from_exact(
 92 |   _router: object, 
 93 |   _amount_in: int, 
 94 |   _amount_out_min: int,
 95 |   _token_in: str,
 96 |   _token_out: str
 97 | ):
 98 |   return _router.functions.swapExactTokensForTokens(
 99 |     _amount_in,
100 |     _amount_out_min,
101 |     [_token_in, _token_out],
102 |     EOA,
103 |     dline(),
104 |   ).buildTransaction(tx)
105 | 
106 | def to_exact(
107 |   _router: object,
108 |   _amount_out: int,
109 |   _amount_in_max: int,
110 |   _token_in: str,
111 |   _token_out: str
112 | ):
113 |   return _router.functions.swapTokensForExactTokens(
114 |     _amount_out,
115 |     _amount_in_max,
116 |     [_token_in, _token_out],
117 |     EOA,
118 |     dline(),
119 |   ).buildTransaction(tx)
120 | 
121 | def sign_tx(tx: object, key: str) -> str:
122 |   sig = w3.eth.account.sign_transaction
123 |   return sig(tx, private_key=key)
124 | 
125 | def send_tx(signed_tx: object) -> str:
126 |   w3.eth.send_raw_transaction(signed_tx.rawTransaction)
127 |   return w3.toHex(w3.keccak(signed_tx.rawTransaction))
128 | 
129 | def log(tx_hash: str):
130 |   r = w3.eth.wait_for_transaction_receipt(tx_hash)
131 |   s = str({ tx_hash: r})
132 |   with open(LOGS, 'w') as f:
133 |     f.write(s)
134 |     f.close()
135 |     
136 | def buy(tx: object):
137 |   tx_hash = send_tx(sign_tx(tx, KEY))
138 |   print(f'[+] loaded: {tx_hash})')
139 |   log(tx_hash)
140 | 
141 | def sell(tx: object):
142 |   tx_hash = send_tx(sign_tx(tx, KEY))
143 |   print(f'[-] unload: {tx_hash})')
144 |   log(tx_hash)
145 | 
146 | # __ SAFETY ___________________________________________________________________
147 | 
148 | def halt():
149 |   should_buy = 0
150 |   should_sell = 0
151 |   amount_out = getAmountIn(SIZE, res0, res1)
152 |   amount_out += calcSlippage(1, amount_out)
153 |   at_loss = to_exact(router, amount_out, SIZE, WMATIC, USDC)
154 |   sell(at_loss)
155 |   quit()
156 | 
157 | def safety(_price: int):
158 |   if _price < stop_loss:
159 |     halt()
160 | 
161 | # __ Main _____________________________________________________________________
162 | 
163 | async def main():
164 |   pair = c_init(PAIR_ADDRESS, fetch_abi('pair.json'))
165 |   router = c_init(ROUTER_ADDRESS, fetch_abi('router.json'))
166 | 
167 |   should_buy = True
168 |   should_sell = False
169 |   
170 |   cached_stamp = 0
171 |   print('running...')
172 | 
173 |   while(1):
174 |     res0, res1, stamp = await poll_reserves(pair)
175 |     if stamp > cached_stamp:
176 |       matic_reserve = res0 / 10 ** RES0_DEC
177 |       usdc_reserve = res1 / 10 ** RES1_DEC
178 |       matic_price = usdc_reserve / matic_reserve
179 | 
180 |       safety(matic_price)
181 | 
182 |       if matic_price <= demand_zone and should_buy:
183 |         amount_in = getAmountOut(SIZE, res1, res0) 
184 |         amount_in -= calcSlippage(0.5, amount_in)
185 |         at_discount = from_exact(router, SIZE, amount_in, USDC, WMATIC)
186 |         buy(at_discount)
187 | 
188 |         cached_nonce = w3.eth.get_transaction_count(EOA)
189 |         
190 |         should_buy = False 
191 |         should_sell = True
192 | 
193 |       elif matic_price >= supply_zone and should_sell:
194 |         amount_out = getAmountIn(SIZE, res0, res1)
195 |         amount_out += calcSlippage(0.5, amount_out)
196 |         at_premium = to_exact(router, amount_out, SIZE, WMATIC, USDC)
197 |         sell(at_premium)
198 | 
199 |         cached_nonce = w3.eth.get_transaction_count(EOA)
200 | 
201 |         should_buy = True
202 |         should_sell = False
203 | 
204 |     cached_stamp = stamp
205 | 
206 | if __name__ == '__main__':
207 |   asyncio.run(main())
208 | 


--------------------------------------------------------------------------------
/signing/pysign.py:
--------------------------------------------------------------------------------
  1 | # deprecated signing examples 
  2 | 
  3 | from web3 import Web3, HTTPProvider
  4 | # generally don't share your endpoints
  5 | w3 = Web3(HTTPProvider('https://eth-goerli.g.alchemy.com/v2/...'))
  6 | # NEVER SHARE PRIVATE KEYS
  7 | example_key = b"\xb2\\}\xb3\x1f\xee\xd9\x12''\xbf\t9\xdcv\x9a\x96VK-\xe4\xc4rm\x03[6\xec\xf1\xe5\xb3d".hex()
  8 | keys_address = '0x5ce9454909639d2d17a3f753ce7d93fa0b9ab12e'
  9 | 
 10 | print(f'''[x] Deprecated signing example:
 11 | [>] PRIVATE KEY: {example_key} [NOTE: THIS KEY IS FROM DOCUMENTATION, FOR EXAMPLE ONLY. NEVER SHARE YOUR PRIVATE KEYS!!]
 12 | [>] EOA (keys address): {keys_address}
 13 | ''')
 14 | 
 15 | # From the web3.py docs..
 16 | # There is no single message format that is broadly adopted with community consensus.
 17 | # Keep an eye on several options, like EIP-683, EIP-712, and EIP-719. 
 18 | # Consider the w3.eth.sign() approach be deprecated. 
 19 | 
 20 | # deprecated method
 21 | from eth_account.messages import encode_defunct
 22 | msg = 'if it requires trust it\'s sus'
 23 | encoded_msg = encode_defunct(text=msg)
 24 | 
 25 | signed_message = w3.eth.account.sign_message(encoded_msg, private_key=example_key)
 26 | print(f'[+] signed_message: \n{signed_message}\n')
 27 | print(f'[>] v: {signed_message.v}')
 28 | print(f'[>] r: {signed_message.r}')
 29 | print(f'[>] s: {signed_message.s}')
 30 | print(f'[>] signature: {signed_message.signature.hex()}\n')
 31 | 
 32 | # verifying the sender in python, with deprecated method.
 33 | result = w3.eth.account.recover_message(encoded_msg, signature=signed_message.signature)
 34 | print(f'[+] Result of recovery: {result}')
 35 | print(f'[+] Matches address\n') if result.lower() == keys_address.lower() else print('[!] Mismatch\n')
 36 | 
 37 | # simple vyper contract for testing
 38 | verify_sig_source = '''
 39 | # @version 0.3.7
 40 | # @title verify_sig.vy
 41 | 
 42 | @external 
 43 | @view
 44 | def get_hash(_str: String[80]) -> bytes32:     
 45 |   return keccak256(_str)  
 46 | 
 47 | @external
 48 | @view 
 49 | def get_signed_hash(_hash: bytes32) -> bytes32:     
 50 | # The initial 0x19 byte is intended to ensure that the signed_data is not valid RLP.
 51 | # 32 is the length of appended data in bytes.
 52 |   return keccak256(         
 53 |     concat(             
 54 |       b'\\x19Ethereum Signed Message:\\n32', # double backslash not needed in a native vy file            
 55 |       _hash         
 56 |     )     
 57 |   )   
 58 | 
 59 | @external 
 60 | @view 
 61 | def verify(_signed_hash: bytes32, _sig: Bytes[65]) -> address:     
 62 |   r: uint256 = convert(slice(_sig, 0, 32), uint256)     
 63 |   s: uint256 = convert(slice(_sig, 32, 32), uint256)     
 64 |   v: uint256 = convert(slice(_sig, 64, 1), uint256)     
 65 |   return ecrecover(_signed_hash, v, r, s)
 66 | 
 67 | '''
 68 | # compiling the contract
 69 | from vyper import compiler
 70 | out = compiler.compile_code(verify_sig_source,['abi', 'bytecode'])
 71 | 
 72 | # is already deployed on goerli for easy testing so can create an instance using the address, and abi
 73 | ## Verify Sig Contract
 74 | vsc = w3.eth.contract(address='0x0A4089a64A88D0317ac2E683696Fa9C69b2C7092', abi=out['abi']).functions
 75 | 
 76 | msg_from_contract = vsc.get_hash('if it requires trust it\'s sus').call()
 77 | print(f'[<] msg_from_contract: {msg_from_contract.hex()}')
 78 | 
 79 | signed_msg_from_contract = vsc.get_signed_hash(msg_from_contract).call()
 80 | print(f'[<] signed_msg_from_contract: {signed_msg_from_contract.hex()}\n')
 81 | 
 82 | # using the depreciated method to sign for a contract
 83 | from eth_account.messages import _hash_eip191_message
 84 | 
 85 | #encode
 86 | msg_for_contract = encode_defunct(hexstr=msg_from_contract.hex()) # same as signed_message_from_contract
 87 | print(f'[>] msg_for_contract: { msg_for_contract}\n')
 88 | 
 89 | # hash explicitely
 90 | signed_msg_for_contract = _hash_eip191_message(msg_for_contract)
 91 | print(f'[>] signed_msg_for_contract: { signed_msg_for_contract.hex()}')
 92 | 
 93 | print('[+] Matches signed_msg_from_contract\n') if signed_msg_for_contract.hex() == signed_msg_from_contract.hex() else print('[!] Mismatch\n')
 94 | 
 95 | signed_for_contract = w3.eth.account.sign_message(msg_for_contract, private_key=example_key)
 96 | print(f'[+] signed_for_contract: {signed_for_contract}\n')
 97 | 
 98 | print(f'[>] signed_for_contract.messageHash: {signed_for_contract.messageHash.hex()}')
 99 | print(f'[>] signed_for_contract.signature: {signed_for_contract.signature.hex()}\n')
100 | 
101 | result_from_contract = vsc.verify(signed_for_contract.messageHash, signed_for_contract.signature).call()
102 | print(f'[+] result_from_contract: {result_from_contract}')
103 | print(f'[+] Matches address\n') if result_from_contract.lower() == keys_address.lower() else print('[!] Mismatch\n')
104 | 


--------------------------------------------------------------------------------
/sushiswap/exact_input.py:
--------------------------------------------------------------------------------
 1 | from os import getenv
 2 | from dotenv import load_dotenv
 3 | from net import con
 4 | 
 5 | w3 = con() # replace with your set up
 6 | 
 7 | def return_account():
 8 |   load_dotenv()
 9 |   return { 'addr': getenv('tron'), 'key': getenv('key') }
10 | 
11 | def sign_tx(tx, key):
12 |   return w3.eth.account.sign_transaction(tx, private_key=key)
13 | 
14 | def send_tx(signed_tx):
15 |   return w3.eth.send_raw_transaction(signed_tx.rawTransaction)
16 | 
17 | def main():
18 |   account  = return_account() 
19 |   nonce    = w3.eth.get_transaction_count(account['addr'])
20 | 
21 |   usdt     = '0xc2132D05D31c914a87C6611C10748AEb04B58e8F'
22 |   wmatic   = '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270'
23 |   amountIn = 10000
24 |   amountOutMin = 0
25 |   
26 |   pool0    = '0xDAE0a6835Fb1c5c09C325F418Be081A9130D818c' # usdt/wmatic
27 |   pool1    = '0x42d9B05962ab52b17f5F1854DA7d3eC89ad4081A' # wmatic/sushi 
28 |   
29 |   # pad data
30 |   data0    = ''
31 |   for i in [usdt[2:], pool1[2:], 0]:
32 |     data0 += '{:0>64}'.format(i) # pad left to 64 bits
33 |   data0    = f'0x{data0}'
34 |   
35 |   data1 = ''
36 |   for i in [wmatic[2:], account['addr'][2:], 0]:
37 |     data1 += '{:0>64}'.format(i) # pad left to 64 bits
38 |   data1   = f'0x{data1}'
39 | 
40 |   from call_trident import init # grabbing trident instance for encoding
41 |   trident = init()
42 |   encoded = trident.encodeABI(fn_name='exactInput', args=[(usdt, amountIn, amountOutMin, [[pool0, data0], [pool1, data1]])])
43 | 
44 |   tx = {
45 |     'from': account['addr'],
46 |     'value':0,
47 |     'chainId': 137,
48 |     'gas': 250000,
49 |     'maxFeePerGas': w3.eth.gas_price * 2,
50 |     'maxPriorityFeePerGas': w3.eth.max_priority_fee * 2,
51 |     'nonce': nonce,
52 |     'data': encoded
53 |   }
54 |   
55 |   trident = '0xc5017BE80b4446988e8686168396289a9A62668E'
56 |   tx.update({'to': trident})
57 |   
58 |   sent = send_tx(sign_tx(tx, account['key']))
59 |   print (f'hash: {sent}') 
60 | 
61 | if __name__ == '__main__':
62 |   main()
63 | 


--------------------------------------------------------------------------------
/sushiswap/get_rewards.py:
--------------------------------------------------------------------------------
 1 | import net
 2 | w3 = net.con()
 3 | 
 4 | user = '...'
 5 | chef = '0xc2EdaD668740f1aA35E4D8f227fB8E17dcA888Cd'
 6 | 
 7 | import snatch
 8 | chef_abi = snatch.abi(chef)
 9 | contract = w3.eth.contract(address=chef, abi=chef_abi)
10 | 
11 | pid = 117
12 | 
13 | start_block = 14997600
14 | end_block = 14997630
15 | 
16 | def fetch(start_block, end_block):
17 |   for i in range(start_block, end_block):
18 |     rewards_at_block = contract.functions.pendingSushi(pid, user).call(block_identifier=i)
19 |     print(f'reward at block {i}: {rewards_at_block}')
20 | 
21 | def main(s, n):
22 |   fetch(s, n)
23 | 
24 | if __name__ == '__main__':
25 |   main(start_block, end_block)


--------------------------------------------------------------------------------
/sushiswap/graph_call.py:
--------------------------------------------------------------------------------
 1 | import requests
 2 | 
 3 | def run_query(q):
 4 |     request = requests.post('https://api.thegraph.com/subgraphs/name/sushiswap/exchange', json={'query': q})
 5 |     if request.status_code == 200:
 6 |       return request.json()
 7 |     else:
 8 |       raise Exception(f'Call failed. Return code: {request.status_code}. \n{query}')
 9 | 
10 | query = '''
11 | {
12 | pair(id: "0xc3d03e4f041fd4cd388c549ee2a29a9e5075882f",
13 |   block: {number:14914285}) {
14 |   token0 {
15 |     symbol
16 |     id
17 |     decimals
18 |   }
19 |   token1{
20 |     symbol
21 |     id
22 |     decimals
23 |   }
24 |   token0Price
25 |   token1Price
26 |   volumeUSD
27 |   }
28 | }
29 | '''
30 | 
31 | response = run_query(query)
32 | 
33 | print(f'[+] Result: {response}')
34 | 


--------------------------------------------------------------------------------
/sushiswap/route_processor.py:
--------------------------------------------------------------------------------
  1 | # imports and initialisations (replace with your own set up)
  2 | from net import con; w3 = con('POLYGON') # i.e from web3 import Web3; w3 = Web3(Provider(Endpoint))
  3 | # account
  4 | from os import getenv
  5 | from dotenv import load_dotenv
  6 | load_dotenv()
  7 | KEY = getenv('TKEY')
  8 | EOA = getenv('TRON')
  9 | #----------------------
 10 | 
 11 | 
 12 | #---
 13 | USDC_ADDRESS = '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174'
 14 | WMATIC_ADDRESS = '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270'
 15 | WMATIC_USDC_ADDRESS = '0xcd353F79d9FADe311fC3119B841e1f456b54e858'
 16 | 
 17 | ROUTER_ADDRESS = '0x0a6e511Fe663827b9cA7e2D2542b20B37fC217A6'
 18 | 
 19 | ROUTER_ABI = '''[{"inputs":[{"internalType":"address","name":"_bentoBox","type":"address"},{"internalType":"address[]","name":"priviledgedUserList","type":"address[]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"address","name":"tokenIn","type":"address"},{"indexed":true,"internalType":"address","name":"tokenOut","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOut","type":"uint256"}],"name":"Route","type":"event"},{"inputs":[],"name":"bentoBox","outputs":[{"internalType":"contract IBentoBoxMinimal","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"bytes","name":"route","type":"bytes"}],"name":"processRoute","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"resume","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"bool","name":"priviledge","type":"bool"}],"name":"setPriviledge","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"transferValueTo","type":"address"},{"internalType":"uint256","name":"amountValueTransfer","type":"uint256"},{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"bytes","name":"route","type":"bytes"}],"name":"transferValueAndprocessRoute","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"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"},{"stateMutability":"payable","type":"receive"}]'''
 20 | ERC20_ABI = ''' [{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"guy","type":"address"},{"name":"wad","type":"uint256"}],"name":"approve","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"src","type":"address"},{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"wad","type":"uint256"}],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"deposit","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":true,"name":"guy","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":true,"name":"dst","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"dst","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Withdrawal","type":"event"}] '''
 21 | 
 22 | router = w3.eth.contract(address=ROUTER_ADDRESS, abi=ROUTER_ABI)
 23 | wmatic = w3.eth.contract(address=WMATIC_ADDRESS, abi=ERC20_ABI)
 24 | 
 25 | 
 26 | # ----
 27 | 
 28 | # A minimum viable path is:
 29 | # - source (command byte): most likely your wallet or the router.
 30 | # - token_in: token to swap from 
 31 | # - num: number of pool routes to calls swap on
 32 | # - share: amount of totalAmount per swap
 33 | # - pool_type: v2 or v3, or to weth etc, check the list above or the function in the contract
 34 | # - pair: pool to swap on
 35 | # - direction token0 to token1 or vice versa 
 36 | # - to: destination ie router if another hop, or unwrap, and your address if done
 37 | 
 38 | # We want to use pre wrapped matic from wallet and swap for usdc, so let's look for those stages:
 39 | 
 40 | # The token is coming from our wallet so we select 2 'processUserERC20'
 41 | # if (commandCode == 2) processUserERC20(stream, amountIn);
 42 | source = 0x02
 43 | 
 44 | # Following this through the contract, we can see it pulls an address from the stream
 45 | # and as this our token in, lets assign it the wmatic address
 46 | # function processUserERC20(uint256 stream, uint256 amountTotal) private {
 47 | #   address token = stream.readAddress();
 48 | token_in = WMATIC_ADDRESS
 49 | 
 50 | # It then wants the number of 'routes' to call swap on, and how the total amount swapped will be split across them
 51 | # Think of ffff as 100%, if you want to split routes you can use for example 60% in the first route and then use 100% in the next and it will just use what's left
 52 | # For simplicity (and as I have not played around with this much) we will set 1 pool route, full amount from pool
 53 | # 
 54 | # uint8 num = stream.readUint8();
 55 | # ..uint16 share = stream.readUint16();
 56 | num = 0x01 # 1 pool route
 57 | share = 0xffff # full amount from pool route
 58 | 
 59 | # Now we prepare the pool bytes, followed by values the called command will consume from the stream
 60 | # v2 has the liquidty for this swap so we put 0
 61 | #   if (poolType == 0) swapUniV2(stream, from, tokenIn, amountIn);
 62 | pool_type = 0x00
 63 | 
 64 | # This function takes the address of pool, 0 or 1 for direction, and an address for destination
 65 | # We know the pool, direction we can get from pool, and as this is a single hop the destination will be the externally owned accounts address
 66 | # function swapUniV2(uint256 stream, address from, address tokenIn, uint256 amountIn) private {
 67 | #   address pool = stream.readAddress();
 68 | #   uint8 direction = stream.readUint8();
 69 | #   address to = stream.readAddress();
 70 | pair = WMATIC_USDC_ADDRESS
 71 | direction = 0x01 # token 1 to 0 or 0 to 1 (check pool or call it and sort them)
 72 | to = EOA
 73 | 
 74 | # Encode them
 75 | from eth_abi.packed import encode_packed
 76 | route = encode_packed(['uint8', 'address', 'uint8', 'uint16', 'uint8', 'address', 'uint8', 'address'], [source, token_in, num, share, pool_type, pair, direction, to])
 77 | 
 78 | PROCESSED_ROUTE = f'0x{route.hex()}'
 79 | print(PROCESSED_ROUTE)
 80 | 
 81 | 
 82 | # --------------------------------------------------------------------------------------------------------------------------------------------------------------------
 83 | 
 84 | 
 85 | # driver
 86 | tx = {
 87 |         'from': EOA,
 88 |         'value':0,
 89 |         'chainId': 137,
 90 |         'gas': 250000,
 91 |         'maxFeePerGas': w3.eth.gas_price * 2,
 92 |         'maxPriorityFeePerGas': w3.to_wei('40', 'gwei'),
 93 |         'nonce': w3.eth.get_transaction_count(EOA)
 94 | }
 95 | 
 96 | def sign_tx(tx, key):
 97 |   sig = w3.eth.account.sign_transaction
 98 |   signed_tx = sig(tx, private_key=key)
 99 |   return signed_tx
100 | 
101 | def send_tx(signed_tx):
102 |   w3.eth.send_raw_transaction(signed_tx.rawTransaction)
103 |   tx_hash = w3.to_hex(w3.keccak(signed_tx.rawTransaction))
104 |   return tx_hash
105 | 
106 | def main():
107 |   approve = wmatic.functions.approve(ROUTER_ADDRESS, 500000000000000000).build_transaction(tx)
108 |   print ('[-] Approving... ')
109 |   tx_hash = send_tx(sign_tx(approve, KEY))
110 |   receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
111 |   print (f'[+] Approved: {tx_hash}\n[>] {receipt}')
112 | 
113 |   tx.update({'nonce': w3.eth.get_transaction_count(EOA)})
114 |   swap = router.functions.processRoute(
115 |     WMATIC_ADDRESS,
116 |     500000000000000000,
117 |     USDC_ADDRESS,
118 |     0,
119 |     EOA,
120 |     PROCESSED_ROUTE
121 |   ).build_transaction(tx)
122 |   print('[-] Simulating swap...')
123 |   w3.eth.call(swap)
124 |   print('[-] Attempting swap...')
125 |   tx_hash = send_tx(sign_tx(swap, KEY))
126 |   receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
127 |   print (f'[>] Hash of swap: {tx_hash}\n[>] {receipt}')
128 | 
129 | if __name__ == '__main__':
130 |   main()
131 | 


--------------------------------------------------------------------------------
/sushiswap/route_processor_multi.py:
--------------------------------------------------------------------------------
  1 | from net import con; w3 = con('POLYGON') # i.e from web3 import Web3; w3 = Web3(Provider(Endpoint))
  2 | from os import getenv
  3 | from dotenv import load_dotenv
  4 | load_dotenv()
  5 | KEY = getenv('TKEY')
  6 | EOA = getenv('TRON')
  7 | #----------------------
  8 | 
  9 | #---
 10 | USDC_ADDRESS = '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174'
 11 | WMATIC_ADDRESS = '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270'
 12 | WETH_ADDRESS= '0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619'
 13 | WMATIC_USDC_ADDRESS = '0xcd353F79d9FADe311fC3119B841e1f456b54e858'
 14 | USDC_WETH_ADDRESS = '0x34965ba0ac2451A34a0471F04CCa3F990b8dea27'
 15 | ROUTER_ADDRESS = '0x0a6e511Fe663827b9cA7e2D2542b20B37fC217A6'
 16 | 
 17 | ROUTER_ABI = '''
 18 | [{"inputs":[{"internalType":"address","name":"_bentoBox","type":"address"},{"internalType":"address[]","name":"priviledgedUserList","type":"address[]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"address","name":"tokenIn","type":"address"},{"indexed":true,"internalType":"address","name":"tokenOut","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOut","type":"uint256"}],"name":"Route","type":"event"},{"inputs":[],"name":"bentoBox","outputs":[{"internalType":"contract IBentoBoxMinimal","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"bytes","name":"route","type":"bytes"}],"name":"processRoute","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"resume","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"bool","name":"priviledge","type":"bool"}],"name":"setPriviledge","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"transferValueTo","type":"address"},{"internalType":"uint256","name":"amountValueTransfer","type":"uint256"},{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"bytes","name":"route","type":"bytes"}],"name":"transferValueAndprocessRoute","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"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"},{"stateMutability":"payable","type":"receive"}]
 19 | '''
 20 | 
 21 | ERC20_ABI = '''
 22 | [{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"guy","type":"address"},{"name":"wad","type":"uint256"}],"name":"approve","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"src","type":"address"},{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"wad","type":"uint256"}],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"deposit","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":true,"name":"guy","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":true,"name":"dst","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"dst","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Withdrawal","type":"event"}]
 23 | '''
 24 | router = w3.eth.contract(address=ROUTER_ADDRESS, abi=ROUTER_ABI)
 25 | wmatic = w3.eth.contract(address=WMATIC_ADDRESS, abi=ERC20_ABI)
 26 | 
 27 | # ----
 28 | source0 = 0x02
 29 | token_in0 = WMATIC_ADDRESS
 30 | num0 = 0x01
 31 | share0 = 0xffff
 32 | pool_type0 = 0x00
 33 | pair0 = WMATIC_USDC_ADDRESS
 34 | direction0 = 0x01
 35 | to0 = ROUTER_ADDRESS
 36 | 
 37 | source1 = 0x01
 38 | token_in1 = USDC_ADDRESS
 39 | num1 = 0x01
 40 | share1 = 0xffff
 41 | pool_type1 = 0x00
 42 | pair1 = USDC_WETH_ADDRESS
 43 | direction1 = 0x01
 44 | to1 = EOA
 45 | 
 46 | from eth_abi.packed import encode_packed
 47 | route0 = encode_packed(['uint8', 'address', 'uint8', 'uint16', 'uint8', 'address', 'uint8', 'address'], [source0, token_in0, num0, share0, pool_type0, pair0, direction0, to0])
 48 | route1 = encode_packed(['uint8', 'address', 'uint8', 'uint16', 'uint8', 'address', 'uint8', 'address'], [source1, token_in1, num1, share1, pool_type1, pair1, direction1, to1])
 49 | 
 50 | PROCESSED_ROUTE = f'0x{route0.hex()}{route1.hex()}'
 51 | print(PROCESSED_ROUTE)
 52 | 
 53 | # --------------------------------------------------------------------------------------------------------------------------------------------------------------------
 54 | 
 55 | tx = {
 56 |         'from': EOA,
 57 |         'value':0,
 58 |         'chainId': 137,
 59 |         'gas': 250000,
 60 |         'maxFeePerGas': w3.eth.gas_price * 2,
 61 |         'maxPriorityFeePerGas': w3.eth.max_priority_fee*2,
 62 |         'nonce': w3.eth.get_transaction_count(EOA)
 63 | }
 64 | 
 65 | def sign_tx(tx, key):
 66 |   sig = w3.eth.account.sign_transaction
 67 |   signed_tx = sig(tx, private_key=key)
 68 |   return signed_tx
 69 | 
 70 | def send_tx(signed_tx):
 71 |   w3.eth.send_raw_transaction(signed_tx.rawTransaction)
 72 |   tx_hash = w3.to_hex(w3.keccak(signed_tx.rawTransaction))
 73 |   return tx_hash
 74 | 
 75 | def main():
 76 |   approve = wmatic.functions.approve(ROUTER_ADDRESS, 5*10**17).build_transaction(tx)
 77 |   print ('[-] Approving... ')
 78 |   tx_hash = send_tx(sign_tx(approve, KEY))
 79 |   receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
 80 |   print (f'[+] Approved: {tx_hash}\n[>] {receipt}')
 81 | 
 82 |   tx.update({'nonce': w3.eth.get_transaction_count(EOA)})
 83 |   swap = router.functions.processRoute(
 84 |     WMATIC_ADDRESS,
 85 |     5*10**17,
 86 |     WETH_ADDRESS,
 87 |     0,
 88 |     EOA,
 89 |     PROCESSED_ROUTE
 90 |   ).build_transaction(tx)
 91 |   print(swap)
 92 |   print('[-] Simulating swap...')
 93 |   w3.eth.call(swap)
 94 |   print('[-] Attempting swap...')
 95 |   tx_hash = send_tx(sign_tx(swap, KEY))
 96 |   receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
 97 |   print (f'[>] Hash of swap: {tx_hash}\n[>] {receipt}')
 98 | 
 99 | if __name__ == '__main__':
100 |   main()
101 | 


--------------------------------------------------------------------------------
/sushiswap/swap_volume_since_midnight.py:
--------------------------------------------------------------------------------
 1 | import requests                                                                          
 2 |                                                                                          
 3 | def run_query(q):                                                                        
 4 |   request = requests.post(                                                               
 5 |           'https://api.thegraph.com/subgraphs/name/sushiswap/exchange'                   
 6 |           '',                                                                            
 7 |           json={'query': query})                                                         
 8 |   if request.status_code == 200:                                                         
 9 |     return request.json()                                                                
10 |   else:                                                                                  
11 |     raise Exception(f'Query failed. return code is {request.status_code}. {query}') 
12 |                                                                                          
13 | query = '''{                                                                             
14 |   swaps(                                                                                 
15 |     where: {                                                                             
16 |       pair: "0x055475920a8c93cffb64d039a8205f7acc7722d3",                                
17 |       timestamp_gte: 1661130000                                                          
18 |     }                                                                                    
19 |     orderBy: timestamp,                                                                  
20 |     orderDirection: desc                                                                 
21 |   ) {                                                                                    
22 |     amountUSD                                                                            
23 |     transaction {                                                                        
24 |       timestamp                                                                          
25 |     }                                                                                    
26 |   }                                                                                      
27 | }'''                                                                                     
28 |                                                                                          
29 | result = run_query(query)                                                                
30 | n = 0                                                                                    
31 |                                                                                          
32 | for i in result['data']['swaps']:                                                        
33 |   n += float(i['amountUSD'])                                                             
34 |                                                                                          
35 | print(n)        
36 | 


--------------------------------------------------------------------------------
/sushiswap/trident_help_sheet.md:
--------------------------------------------------------------------------------
 1 | # Trident help sheet
 2 | ---
 3 | Enough to work out the rest
 4 | 
 5 | ### Keyword: Native
 6 |  - Means from the users wallet here, rather than the gas token.
 7 | 
 8 | So exactInputSingle(), swaps on a single pool, from a token already in the EOA's (**Externally Owned** wallet's), Bentobox **Account**.
 9 | exactInputSingleNative() swaps on a single pool, but takes the token from the EOA's wallet. Approvals will be needed.
10 | 
11 | For these single pool swaps the data we pass is the following:
12 | 
13 | ![](https://i.imgur.com/i2ppYFI.png)
14 | 
15 | 
16 | token A:
17 | 
18 | ![](https://i.imgur.com/vzOZU4s.png)
19 | 
20 | amount  of token A to swap:
21 | 
22 | ![](https://i.imgur.com/mPncrkl.png)
23 | 
24 | minimum amount of token B after the swap:
25 | 
26 | ![](https://i.imgur.com/GTAl556.png)
27 | 
28 | 
29 | Though what's the data, required by the pool for the swap?
30 | Let's check ITridentRouter:
31 | 
32 | ![](https://i.imgur.com/Kd3NUMH.png)
33 | 
34 | We know we need to pass the pool:
35 | 
36 | ![](https://i.imgur.com/mKpaA1a.png)
37 | 
38 | We know the order of parameters, is just which "data" to hex encode?
39 | 
40 | ![image](https://user-images.githubusercontent.com/12489182/225366857-e165164a-481a-42e8-acec-f3e5ccd09b62.png)
41 | 
42 | Let's check a pool contract for a swap function:
43 | 
44 | ![](https://i.imgur.com/TUAaHPf.png)
45 | 
46 | ### Keyword: unwrapBento
47 | 
48 | ![](https://i.imgur.com/JlMP5jj.png)
49 | ![](https://i.imgur.com/bJbXjtl.png)
50 | 
51 | - if True (1) call Bento's withdraw function (pull token to an external address)
52 | - else if False (0), call transfer to move tokens within Bento, such as to another Trident pool, or Bento account.
53 | 
54 | ---
55 | 
56 | So now we know what to pass in the pool data:
57 | 
58 | - The token in, is fairly clear.
59 | - The recipient, will either be the next pool in the swap, the account in Bentobox (your address), or could be the Trident address if needing to unwrap the gas token after. 
60 | - unwrapBento, we just went through but as an example, if to another pool or your account in Bento, will be 0:
61 | 
62 | ![](https://i.imgur.com/2KdluZb.png)
63 | 
64 | If to Trident to be unwrapped, from bento, then a 1:
65 | 
66 | ![](https://i.imgur.com/K80Nvl1.png)
67 | 
68 | In our latter example we are pulling to Trident so we can unwrap some wmatic to matic, or "ETH" as universily used for the gas coin, so as not to change contracts across deployments.
69 | 
70 | ![](https://i.imgur.com/5UQcBbb.png)
71 | 
72 | To make a batch call we use the multicall feature, but let's look first at the second encoded data we will need to pass it.
73 | 
74 | ![](https://i.imgur.com/zzsffEk.png)
75 | 
76 | In this example I can use 0, but in order to be safe you should work out a number you are happy with. 
77 | Might be the exact amount out if called from a contract and that can be known, or the amount from getAmountOut minus a percent slippage, so the same as final amountOutMin value. Is up to you.
78 | 
79 | ![](https://i.imgur.com/vSSSInY.png)
80 | 
81 | So we encode our swap, unwrap, and then finally a list or array of the swap and unwrap calls, with a multicall.
82 | 
83 | ![](https://i.imgur.com/WvhF57E.png)
84 | ![](https://i.imgur.com/x53Eog6.png)
85 | 
86 | ![](https://i.imgur.com/Un5PfSL.png)
87 | 


--------------------------------------------------------------------------------
/sushiswap/trident_multicall.py:
--------------------------------------------------------------------------------
 1 | from os import getenv
 2 | from dotenv import load_dotenv
 3 | from net import con
 4 | from web3 import Web3
 5 | from hexbytes import HexBytes
 6 | 
 7 | w3 = con()
 8 | 
 9 | def return_account():
10 |   load_dotenv()
11 |   account = {
12 |     'addr': getenv('tron'),
13 |     'key': getenv('key')
14 |   }
15 |   return account
16 | 
17 | def sign_tx(tx, key):
18 |   sig = w3.eth.account.sign_transaction
19 |   signed_tx = sig(tx, private_key=key)
20 | 
21 |   return signed_tx
22 | 
23 | def send_tx(signed_tx):
24 |   w3.eth.send_raw_transaction(signed_tx.rawTransaction)
25 |   tx_hash = w3.toHex(w3.keccak(signed_tx.rawTransaction))
26 | 
27 |   return tx_hash
28 | 
29 | 
30 | def main():
31 | 
32 |   account = return_account()
33 |   nonce = w3.eth.get_transaction_count(account['addr'])
34 | 
35 |   usdt = '0xc2132D05D31c914a87C6611C10748AEb04B58e8F'
36 |   wmatic = '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270'
37 |   amountIn = 10000
38 |   amountOutMin = 0
39 | 
40 |   trident_address = '0xc5017BE80b4446988e8686168396289a9A62668E'
41 |   pool0 = '0xDAE0a6835Fb1c5c09C325F418Be081A9130D818c' # usdt/wmatic
42 | 
43 |   # pad data
44 |   data0 = ''
45 |   for i in [usdt[2:], trident_address[2:], 1]:
46 |     data0 += '{:0>64}'.format(i) # pad left to 64 bits
47 |   data0 = f'0x{data0}'
48 | 
49 |   from call_trident import init # grabbing trident instance for encoding
50 |   trident = init()
51 |   swap = trident.encodeABI(fn_name='exactInputSingle', args=[(amountIn, amountOutMin, pool0, usdt, data0)])
52 |   unwrap = trident.encodeABI(fn_name='unwrapWETH', args=[0, account['addr']])
53 |   multicall = trident.encodeABI(fn_name='multicall', args=[[swap,unwrap]])
54 | 
55 |   tx = {
56 |         'from': account['addr'],
57 |         'to': trident_address,
58 |         'value':0,
59 |         'chainId': 137,
60 |         'gas': 250000,
61 |         'maxFeePerGas': w3.toWei('500', 'gwei'),
62 |         'maxPriorityFeePerGas': w3.toWei('400', 'gwei'),
63 |         'nonce': nonce,
64 |         'data': multicall
65 |         }
66 | 
67 |   sent = send_tx(sign_tx(tx, account['key']))
68 |   print (f'sent: {sent}')
69 | 
70 | if __name__ == '__main__':
71 |   main()
72 | 


--------------------------------------------------------------------------------
/uni_router/universal_router_swap.md:
--------------------------------------------------------------------------------
  1 | We can look at the `commands` contract to get the list of steps we want to take, then encode the calldata for each of those steps.
  2 | 
  3 | In this example we wrap the native coin and then perform a swap on v3.
  4 | 
  5 | `commands = '0x0b00'`
  6 | ```python
  7 | 0b : #    uint256 constant WRAP_ETH = 0x0b; 
  8 | 00 : #    uint256 constant V3_SWAP_EXACT_IN = 0x00;
  9 | ```
 10 | 
 11 | We can look at the `dispatcher` contract to see what is being decoded on those calls:
 12 | 
 13 | ```js
 14 | if (command == Commands.WRAP_ETH) {
 15 |  // equivalent: abi.decode(inputs, (address, uint256))
 16 |  address recipient;
 17 |  uint256 amountMin;
 18 | ```
 19 | For wrapping eth we can see it takes a destination address and amount.
 20 | The amount will be the `msg.value` we send with the transaction, the address should be the router as we want to perform a swap after.
 21 | 
 22 | For the swap we need:
 23 | 
 24 | ```js
 25 | #        address recipient,
 26 | #        uint256 amountIn,
 27 | #        uint256 amountOutMinimum,
 28 | #        bytes calldata path,
 29 | #        bool payer
 30 | ```
 31 | A `path` unlike the other values needs "packed encoding", this is the values concatenated without the zero padding.
 32 | 
 33 | ```python
 34 | # (address tokenIn, uint24 fee, address tokenOut)
 35 | path = encode_packed(['address','uint24','address'], [WMATIC_ADDRESS, FEE, USDC_ADDRESS])
 36 | ```
 37 | Can think about `payer` as *if from eoa* (your wallet) or the router:
 38 | ```
 39 | False == the router
 40 | True  == msg.sender
 41 | ```
 42 | 
 43 | The encoding of the resulting calldata looks like this:
 44 | ```python
 45 | wrap_calldata = encode(['address', 'uint256'], [router.address, amount])
 46 | v3_calldata = encode(['address', 'uint256', 'uint256', 'bytes', 'bool'], [to, amount, slippage, path, from_eoa])
 47 | ```
 48 | Finally, we can either encode (not packed) the args together, concatonate with the function sig and use as the calldata in a 
 49 |  raw transaction, or simply pass to the `execute` function of a contract instance:
 50 | ```python
 51 | swap = router.functions.execute(commands, [wrap_calldata, v3_calldata], deadline).build_transaction(tx)
 52 | ```
 53 | 
 54 | Complete example:
 55 | ```python
 56 | from net import con; w3 = con('POLYGON') # i.e from web3 import Web3; w3 = Web3(Provider(Endpoint))
 57 | from os import getenv
 58 | from dotenv import load_dotenv
 59 | load_dotenv()
 60 | KEY = getenv('your_key')
 61 | EOA = getenv('your_address')
 62 | #----------------------
 63 | 
 64 | #---
 65 | USDC_ADDRESS = '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174'
 66 | WMATIC_ADDRESS = '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270'
 67 | WETH_ADDRESS= '0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619'
 68 | WMATIC_USDC_ADDRESS = '0xcd353F79d9FADe311fC3119B841e1f456b54e858'
 69 | USDC_WETH_ADDRESS = '0x34965ba0ac2451A34a0471F04CCa3F990b8dea27'
 70 | ROUTER_ADDRESS = '0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD'
 71 | 
 72 | ROUTER_ABI = '''
 73 | [{"inputs":[{"components":[{"internalType":"address","name":"permit2","type":"address"},{"internalType":"address","name":"weth9","type":"address"},{"internalType":"address","name":"seaportV1_5","type":"address"},{"internalType":"address","name":"seaportV1_4","type":"address"},{"internalType":"address","name":"openseaConduit","type":"address"},{"internalType":"address","name":"nftxZap","type":"address"},{"internalType":"address","name":"x2y2","type":"address"},{"internalType":"address","name":"foundation","type":"address"},{"internalType":"address","name":"sudoswap","type":"address"},{"internalType":"address","name":"elementMarket","type":"address"},{"internalType":"address","name":"nft20Zap","type":"address"},{"internalType":"address","name":"cryptopunks","type":"address"},{"internalType":"address","name":"looksRareV2","type":"address"},{"internalType":"address","name":"routerRewardsDistributor","type":"address"},{"internalType":"address","name":"looksRareRewardsDistributor","type":"address"},{"internalType":"address","name":"looksRareToken","type":"address"},{"internalType":"address","name":"v2Factory","type":"address"},{"internalType":"address","name":"v3Factory","type":"address"},{"internalType":"bytes32","name":"pairInitCodeHash","type":"bytes32"},{"internalType":"bytes32","name":"poolInitCodeHash","type":"bytes32"}],"internalType":"struct RouterParameters","name":"params","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"BalanceTooLow","type":"error"},{"inputs":[],"name":"BuyPunkFailed","type":"error"},{"inputs":[],"name":"ContractLocked","type":"error"},{"inputs":[],"name":"ETHNotAccepted","type":"error"},{"inputs":[{"internalType":"uint256","name":"commandIndex","type":"uint256"},{"internalType":"bytes","name":"message","type":"bytes"}],"name":"ExecutionFailed","type":"error"},{"inputs":[],"name":"FromAddressIsNotOwner","type":"error"},{"inputs":[],"name":"InsufficientETH","type":"error"},{"inputs":[],"name":"InsufficientToken","type":"error"},{"inputs":[],"name":"InvalidBips","type":"error"},{"inputs":[{"internalType":"uint256","name":"commandType","type":"uint256"}],"name":"InvalidCommandType","type":"error"},{"inputs":[],"name":"InvalidOwnerERC1155","type":"error"},{"inputs":[],"name":"InvalidOwnerERC721","type":"error"},{"inputs":[],"name":"InvalidPath","type":"error"},{"inputs":[],"name":"InvalidReserves","type":"error"},{"inputs":[],"name":"InvalidSpender","type":"error"},{"inputs":[],"name":"LengthMismatch","type":"error"},{"inputs":[],"name":"SliceOutOfBounds","type":"error"},{"inputs":[],"name":"TransactionDeadlinePassed","type":"error"},{"inputs":[],"name":"UnableToClaim","type":"error"},{"inputs":[],"name":"UnsafeCast","type":"error"},{"inputs":[],"name":"V2InvalidPath","type":"error"},{"inputs":[],"name":"V2TooLittleReceived","type":"error"},{"inputs":[],"name":"V2TooMuchRequested","type":"error"},{"inputs":[],"name":"V3InvalidAmountOut","type":"error"},{"inputs":[],"name":"V3InvalidCaller","type":"error"},{"inputs":[],"name":"V3InvalidSwap","type":"error"},{"inputs":[],"name":"V3TooLittleReceived","type":"error"},{"inputs":[],"name":"V3TooMuchRequested","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardsSent","type":"event"},{"inputs":[{"internalType":"bytes","name":"looksRareClaim","type":"bytes"}],"name":"collectRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"commands","type":"bytes"},{"internalType":"bytes[]","name":"inputs","type":"bytes[]"}],"name":"execute","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes","name":"commands","type":"bytes"},{"internalType":"bytes[]","name":"inputs","type":"bytes[]"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"execute","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","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"},{"stateMutability":"payable","type":"receive"}]
 74 | '''
 75 | 
 76 | router = w3.eth.contract(address=ROUTER_ADDRESS, abi=ROUTER_ABI)
 77 | 
 78 | #  https://github.com/Uniswap/universal-router/blob/main/contracts/libraries/Commands.sol
 79 | #
 80 | #    // Command Types where value<0x08, executed in the first nested-if block
 81 | #    uint256 constant V3_SWAP_EXACT_IN = 0x00;
 82 | #    uint256 constant V3_SWAP_EXACT_OUT = 0x01;
 83 | #    uint256 constant PERMIT2_TRANSFER_FROM = 0x02;
 84 | #    uint256 constant PERMIT2_PERMIT_BATCH = 0x03;
 85 | #    uint256 constant SWEEP = 0x04;
 86 | #    uint256 constant TRANSFER = 0x05;
 87 | #    uint256 constant PAY_PORTION = 0x06;
 88 | #    // COMMAND_PLACEHOLDER = 0x07;
 89 | #
 90 | #....
 91 | #    // Command Types where 0x08<=value<=0x0f, executed in the second nested-if block
 92 | #    uint256 constant V2_SWAP_EXACT_IN = 0x08;
 93 | #    uint256 constant V2_SWAP_EXACT_OUT = 0x09;
 94 | #    uint256 constant PERMIT2_PERMIT = 0x0a;
 95 | #    uint256 constant WRAP_ETH = 0x0b;
 96 | #    uint256 constant UNWRAP_WETH = 0x0c;
 97 | #
 98 | # ----
 99 | 
100 | # we will wrap the native coin, then swap on v3
101 | 
102 | commands = '0x0b00'
103 | 
104 | # https://github.com/Uniswap/universal-router/blob/main/contracts/base/Dispatcher.sol
105 | #
106 | #                    if (command == Commands.V3_SWAP_EXACT_IN) {
107 | #                        // equivalent: abi.decode(inputs, (address, uint256, uint256, bytes, bool))
108 | #                        address recipient;
109 | #                        uint256 amountIn;
110 | #                        uint256 amountOutMin;
111 | #                        bool payerIsUser
112 | #....
113 | #
114 | #
115 | # https://github.com/Uniswap/universal-router/blob/228f2d151a5fc99836d72ae00f81db92cdb44bd3/contracts/modules/uniswap/v3/V3SwapRouter.sol
116 | #
117 | #    /// @notice Performs a Uniswap v3 exact input swap
118 | #    /// @param recipient The recipient of the output tokens
119 | #    /// @param amountIn The amount of input tokens for the trade
120 | #    /// @param amountOutMinimum The minimum desired amount of output tokens
121 | #    /// @param path The path of the trade as a bytes string
122 | #    /// @param payer The address that will be paying the input
123 | #    function v3SwapExactInput(
124 | #        address recipient,
125 | #        uint256 amountIn,
126 | #        uint256 amountOutMinimum,
127 | #        bytes calldata path,
128 | #        address payer
129 | 
130 | from eth_abi import encode
131 | from eth_abi.packed import encode_packed
132 | # some sane inputs (sane doesn't mean safe in this case, always use a good slippage value unless protected some other way)
133 | to = EOA
134 | amount = 1 * 10 ** 17
135 | slippage = 0
136 | FEE = 500
137 | # (address tokenIn, uint24 fee, address tokenOut)
138 | path = encode_packed(['address','uint24','address'], [WMATIC_ADDRESS, FEE, USDC_ADDRESS])
139 | from_eoa = False # the router or user? router after wrapping
140 | 
141 | wrap_calldata = encode(['address', 'uint256'], [router.address, amount])
142 | v3_calldata = encode(['address', 'uint256', 'uint256', 'bytes', 'bool'], [to, amount, slippage, path, from_eoa])
143 | 
144 | deadline = 2*10**10
145 | 
146 | print(commands)
147 | print(wrap_calldata.hex())
148 | print(v3_calldata.hex())
149 | print(deadline)
150 | # --------------------------------------------------------------------------------------------------------------------------------------------------------------------
151 | 
152 | tx = {
153 |         'from': EOA,
154 |         'value': amount,
155 |         'chainId': 137,
156 |         'gas': 250000,
157 |         'maxFeePerGas': w3.eth.gas_price * 2,
158 |         'maxPriorityFeePerGas': w3.eth.max_priority_fee * 2,
159 |         'nonce': w3.eth.get_transaction_count(EOA)
160 | }
161 | 
162 | def sign_tx(tx, key):
163 |   sig = w3.eth.account.sign_transaction
164 |   signed_tx = sig(tx, private_key=key)
165 |   return signed_tx
166 | 
167 | def send_tx(signed_tx):
168 |   w3.eth.send_raw_transaction(signed_tx.rawTransaction)
169 |   tx_hash = w3.to_hex(w3.keccak(signed_tx.rawTransaction))
170 |   return tx_hash
171 | 
172 | def main():
173 |   swap = router.functions.execute(commands, [wrap_calldata, v3_calldata], deadline).build_transaction(tx)
174 |   print(swap)
175 |   print('[-] Simulating swap...')
176 |   w3.eth.call(swap)
177 |   print('[-] Attempting swap...')
178 |   tx_hash = send_tx(sign_tx(swap, KEY))
179 |   receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
180 |   print (f'[>] Hash of swap: {tx_hash}\n[>] {receipt}')
181 | 
182 | if __name__ == '__main__':
183 |   main()
184 | ```
185 | 


--------------------------------------------------------------------------------
/uni_router/universal_router_swap.py:
--------------------------------------------------------------------------------
  1 | # uni's universal router is similar to sushi's route processor, if not a little simpler so can be worth looking at the walk through of those transactions
  2 | # as it covers the same considerations and steps in trying to understand the universal router.
  3 | 
  4 | from net import con; w3 = con('POLYGON') # i.e from web3 import Web3; w3 = Web3(Provider(Endpoint))
  5 | from os import getenv
  6 | from dotenv import load_dotenv
  7 | load_dotenv()
  8 | KEY = getenv('your_key')
  9 | EOA = getenv('your_address')
 10 | #----------------------
 11 | 
 12 | #---
 13 | USDC_ADDRESS = '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174'
 14 | WMATIC_ADDRESS = '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270'
 15 | WETH_ADDRESS= '0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619'
 16 | WMATIC_USDC_ADDRESS = '0xcd353F79d9FADe311fC3119B841e1f456b54e858'
 17 | USDC_WETH_ADDRESS = '0x34965ba0ac2451A34a0471F04CCa3F990b8dea27'
 18 | ROUTER_ADDRESS = '0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD'
 19 | 
 20 | ROUTER_ABI = '''
 21 | [{"inputs":[{"components":[{"internalType":"address","name":"permit2","type":"address"},{"internalType":"address","name":"weth9","type":"address"},{"internalType":"address","name":"seaportV1_5","type":"address"},{"internalType":"address","name":"seaportV1_4","type":"address"},{"internalType":"address","name":"openseaConduit","type":"address"},{"internalType":"address","name":"nftxZap","type":"address"},{"internalType":"address","name":"x2y2","type":"address"},{"internalType":"address","name":"foundation","type":"address"},{"internalType":"address","name":"sudoswap","type":"address"},{"internalType":"address","name":"elementMarket","type":"address"},{"internalType":"address","name":"nft20Zap","type":"address"},{"internalType":"address","name":"cryptopunks","type":"address"},{"internalType":"address","name":"looksRareV2","type":"address"},{"internalType":"address","name":"routerRewardsDistributor","type":"address"},{"internalType":"address","name":"looksRareRewardsDistributor","type":"address"},{"internalType":"address","name":"looksRareToken","type":"address"},{"internalType":"address","name":"v2Factory","type":"address"},{"internalType":"address","name":"v3Factory","type":"address"},{"internalType":"bytes32","name":"pairInitCodeHash","type":"bytes32"},{"internalType":"bytes32","name":"poolInitCodeHash","type":"bytes32"}],"internalType":"struct RouterParameters","name":"params","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"BalanceTooLow","type":"error"},{"inputs":[],"name":"BuyPunkFailed","type":"error"},{"inputs":[],"name":"ContractLocked","type":"error"},{"inputs":[],"name":"ETHNotAccepted","type":"error"},{"inputs":[{"internalType":"uint256","name":"commandIndex","type":"uint256"},{"internalType":"bytes","name":"message","type":"bytes"}],"name":"ExecutionFailed","type":"error"},{"inputs":[],"name":"FromAddressIsNotOwner","type":"error"},{"inputs":[],"name":"InsufficientETH","type":"error"},{"inputs":[],"name":"InsufficientToken","type":"error"},{"inputs":[],"name":"InvalidBips","type":"error"},{"inputs":[{"internalType":"uint256","name":"commandType","type":"uint256"}],"name":"InvalidCommandType","type":"error"},{"inputs":[],"name":"InvalidOwnerERC1155","type":"error"},{"inputs":[],"name":"InvalidOwnerERC721","type":"error"},{"inputs":[],"name":"InvalidPath","type":"error"},{"inputs":[],"name":"InvalidReserves","type":"error"},{"inputs":[],"name":"InvalidSpender","type":"error"},{"inputs":[],"name":"LengthMismatch","type":"error"},{"inputs":[],"name":"SliceOutOfBounds","type":"error"},{"inputs":[],"name":"TransactionDeadlinePassed","type":"error"},{"inputs":[],"name":"UnableToClaim","type":"error"},{"inputs":[],"name":"UnsafeCast","type":"error"},{"inputs":[],"name":"V2InvalidPath","type":"error"},{"inputs":[],"name":"V2TooLittleReceived","type":"error"},{"inputs":[],"name":"V2TooMuchRequested","type":"error"},{"inputs":[],"name":"V3InvalidAmountOut","type":"error"},{"inputs":[],"name":"V3InvalidCaller","type":"error"},{"inputs":[],"name":"V3InvalidSwap","type":"error"},{"inputs":[],"name":"V3TooLittleReceived","type":"error"},{"inputs":[],"name":"V3TooMuchRequested","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardsSent","type":"event"},{"inputs":[{"internalType":"bytes","name":"looksRareClaim","type":"bytes"}],"name":"collectRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"commands","type":"bytes"},{"internalType":"bytes[]","name":"inputs","type":"bytes[]"}],"name":"execute","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes","name":"commands","type":"bytes"},{"internalType":"bytes[]","name":"inputs","type":"bytes[]"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"execute","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","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"},{"stateMutability":"payable","type":"receive"}]
 22 | '''
 23 | 
 24 | router = w3.eth.contract(address=ROUTER_ADDRESS, abi=ROUTER_ABI)
 25 | 
 26 | #  https://github.com/Uniswap/universal-router/blob/main/contracts/libraries/Commands.sol
 27 | #
 28 | #    // Command Types where value<0x08, executed in the first nested-if block
 29 | #    uint256 constant V3_SWAP_EXACT_IN = 0x00;
 30 | #    uint256 constant V3_SWAP_EXACT_OUT = 0x01;
 31 | #    uint256 constant PERMIT2_TRANSFER_FROM = 0x02;
 32 | #    uint256 constant PERMIT2_PERMIT_BATCH = 0x03;
 33 | #    uint256 constant SWEEP = 0x04;
 34 | #    uint256 constant TRANSFER = 0x05;
 35 | #    uint256 constant PAY_PORTION = 0x06;
 36 | #    // COMMAND_PLACEHOLDER = 0x07;
 37 | #
 38 | #....
 39 | #    // Command Types where 0x08<=value<=0x0f, executed in the second nested-if block
 40 | #    uint256 constant V2_SWAP_EXACT_IN = 0x08;
 41 | #    uint256 constant V2_SWAP_EXACT_OUT = 0x09;
 42 | #    uint256 constant PERMIT2_PERMIT = 0x0a;
 43 | #    uint256 constant WRAP_ETH = 0x0b;
 44 | #    uint256 constant UNWRAP_WETH = 0x0c;
 45 | #
 46 | # ----
 47 | 
 48 | # we will wrap the native coin, then swap on v3
 49 | 
 50 | commands = '0x0b00'
 51 | 
 52 | # https://github.com/Uniswap/universal-router/blob/main/contracts/base/Dispatcher.sol
 53 | #
 54 | #  if (command == Commands.V3_SWAP_EXACT_IN) {
 55 | #      // equivalent: abi.decode(inputs, (address, uint256, uint256, bytes, bool))
 56 | #      address recipient;
 57 | #      uint256 amountIn;
 58 | #      uint256 amountOutMin;
 59 | #      bool payerIsUser
 60 | #....
 61 | #
 62 | # https://github.com/Uniswap/universal-router/blob/228f2d151a5fc99836d72ae00f81db92cdb44bd3/contracts/modules/uniswap/v3/V3SwapRouter.sol
 63 | #
 64 | #    /// @notice Performs a Uniswap v3 exact input swap
 65 | #    /// @param recipient The recipient of the output tokens
 66 | #    /// @param amountIn The amount of input tokens for the trade
 67 | #    /// @param amountOutMinimum The minimum desired amount of output tokens
 68 | #    /// @param path The path of the trade as a bytes string
 69 | #    /// @param payer The address that will be paying the input
 70 | #    function v3SwapExactInput(
 71 | #        address recipient,
 72 | #        uint256 amountIn,
 73 | #        uint256 amountOutMinimum,
 74 | #        bytes calldata path,
 75 | #        address payer
 76 | 
 77 | from eth_abi import encode
 78 | from eth_abi.packed import encode_packed
 79 | # some sane inputs (sane doesn't mean safe in this case, always use a good slippage value unless protected some other way)
 80 | to = EOA
 81 | amount = 1 * 10 ** 17
 82 | slippage = 0
 83 | FEE = 500
 84 | # (address tokenIn, uint24 fee, address tokenOut)
 85 | path = encode_packed(['address','uint24','address'], [WMATIC_ADDRESS, FEE, USDC_ADDRESS])
 86 | from_eoa = False # the router or user? router after wrapping
 87 | 
 88 | wrap_calldata = encode(['address', 'uint256'], [router.address, amount])
 89 | v3_calldata = encode(['address', 'uint256', 'uint256', 'bytes', 'bool'], [to, amount, slippage, path, from_eoa])
 90 | 
 91 | deadline = 2*10**10
 92 | 
 93 | print(commands)
 94 | print(wrap_calldata.hex())
 95 | print(v3_calldata.hex())
 96 | print(deadline)
 97 | # --------------------------------------------------------------------------------------------------------------------------------------------------------------------
 98 | 
 99 | tx = {
100 |         'from': EOA,
101 |         'value': amount,
102 |         'chainId': 137,
103 |         'gas': 250000,
104 |         'maxFeePerGas': w3.eth.gas_price * 2,
105 |         'maxPriorityFeePerGas': w3.eth.max_priority_fee*2,
106 |         'nonce': w3.eth.get_transaction_count(EOA)
107 | }
108 | 
109 | def sign_tx(tx, key):
110 |   sig = w3.eth.account.sign_transaction
111 |   signed_tx = sig(tx, private_key=key)
112 |   return signed_tx
113 | 
114 | def send_tx(signed_tx):
115 |   w3.eth.send_raw_transaction(signed_tx.rawTransaction)
116 |   tx_hash = w3.to_hex(w3.keccak(signed_tx.rawTransaction))
117 |   return tx_hash
118 | 
119 | def main():
120 |   swap = router.functions.execute(commands, [wrap_calldata, v3_calldata], deadline).build_transaction(tx)
121 |   print(swap)
122 |   print('[-] Simulating swap...')
123 |   w3.eth.call(swap)
124 |   print('[-] Attempting swap...')
125 |   tx_hash = send_tx(sign_tx(swap, KEY))
126 |   receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
127 |   print (f'[>] Hash of swap: {tx_hash}\n[>] {receipt}')
128 | 
129 | if __name__ == '__main__':
130 |   main()
131 | 


--------------------------------------------------------------------------------
/uni_router/universal_v2_swap.py:
--------------------------------------------------------------------------------
  1 | #------------------------------------------------------------------------------------------------------------------------------------------#
  2 | # UNISWAP UNIVERSAL ROUTER V2 SWAP WITH ONCHAIN PERMIT2 APPROVAL
  3 | #------------------------------------------------------------------------------------------------------------------------------------------#
  4 | 
  5 | #------------------------------------------------------------------------------------------------------------------------------------------#
  6 | # --- FOREWORD ---
  7 | #------------------------------------------------------------------------------------------------------------------------------------------#
  8 | # This is a variant of the swap from token example targetting a Uniswap v2 pool (as opposed to v3). 
  9 | # It was a requested variant, if have similar requests feel free to reach out.
 10 | 
 11 | from web3 import Web3; w3 = Web3(Web3.HTTPProvider('https://polygon-rpc.com'))
 12 | from os import getenv
 13 | from dotenv import load_dotenv
 14 | load_dotenv()
 15 | eoa = w3.eth.account.from_key(getenv('TKEY'))
 16 | 
 17 | #------------------------------------------------------------------------------------------------------------------------------------------#
 18 | 
 19 | PERMIT_ADDRESS  = '0x000000000022D473030F116dDEE9F6B43aC78BA3'
 20 | TOKEN_ADDRESS   = '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174'
 21 | WETH_ADDRESS    = '0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619'
 22 | ROUTER_ADDRESS  = '0xec7BE89e9d109e7e3Fec59c222CF297125FEFda2'
 23 | 
 24 | # replace with abi in `universal_swap_from_token.py`
 25 | ROUTER_ABI = ''
 26 | PERMIT_ABI = ''
 27 | ERC20_ABI  = ''
 28 | 
 29 | router = w3.eth.contract(address=ROUTER_ADDRESS, abi=ROUTER_ABI)
 30 | permit = w3.eth.contract(address=PERMIT_ADDRESS, abi=PERMIT_ABI)
 31 | token  = w3.eth.contract(address=TOKEN_ADDRESS,  abi=ERC20_ABI )
 32 | 
 33 | tx = {
 34 |         'from': eoa.address,
 35 |         'value': 0,
 36 |         'chainId': w3.eth.chain_id,
 37 |         'gas': 250000,
 38 |         'maxFeePerGas': w3.eth.gas_price,
 39 |         'maxPriorityFeePerGas': w3.eth.max_priority_fee * 2,
 40 |         'nonce': w3.eth.get_transaction_count(eoa.address)
 41 | }
 42 | 
 43 | # we will swap on v2 then unwrap wrap the native token
 44 | 
 45 | commands = '0x080c'
 46 | 
 47 | from eth_abi import encode
 48 | from eth_abi.packed import encode_packed
 49 | # some sane inputs (sane doesn't mean safe in this case, always use a good slippage value unless protected some other way)
 50 | to = router.address  # router here, eoa address in unwrap
 51 | amount = 1 * 10 ** 4
 52 | slippage = 0
 53 | FEE = 10000
 54 | path = [TOKEN_ADDRESS, WETH_ADDRESS]
 55 | from_eoa = True
 56 | unwrap_calldata = encode(['address', 'uint256'], [eoa.address, slippage])
 57 | v2_calldata = encode(['address', 'uint256', 'uint256', 'address[]', 'bool'], [to, amount, slippage, path, from_eoa])
 58 | deadline = 2*10**10
 59 | 
 60 | approve_permit = token.functions.approve(PERMIT_ADDRESS, amount)
 61 | approve_router = permit.functions.approve(TOKEN_ADDRESS, ROUTER_ADDRESS, amount, deadline)
 62 | 
 63 | #------------------------------------------------------------------------------------------------------------------------------------------#
 64 | 
 65 | swap = router.functions.execute(commands, [v2_calldata,unwrap_calldata], deadline).build_transaction(tx)
 66 | 
 67 | def sign_tx(tx, key):
 68 |   sig = w3.eth.account.sign_transaction
 69 |   signed_tx = sig(tx, private_key=key)
 70 |   return signed_tx
 71 | 
 72 | def send_tx(signed_tx):
 73 |   w3.eth.send_raw_transaction(signed_tx.raw_transaction)
 74 |   tx_hash = w3.to_hex(w3.keccak(signed_tx.raw_transaction))
 75 |   return tx_hash
 76 | 
 77 | def main():
 78 | 
 79 |   approve1 = approve_permit.build_transaction(tx)
 80 |   print ('[-] Approving permit... ')
 81 |   tx_hash = send_tx(sign_tx(approve1, eoa.key))
 82 |   receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
 83 |   print (f'[+] Approved PERMIT2 at TOKEN contract: {tx_hash}\n[>] {receipt}')
 84 | 
 85 |   tx.update({'nonce': w3.eth.get_transaction_count(eoa.address)})
 86 | 
 87 |   # See signing section of this repo for how to bundle a signature  with the swap
 88 |   approve2 = approve_router.build_transaction(tx)
 89 |   print ('[-] Approving router... ')
 90 |   tx_hash = send_tx(sign_tx(approve2, eoa.key))
 91 |   receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
 92 |   print (f'[+] Approved ROUTER at PERMIT contract: {tx_hash}\n[>] {receipt}')
 93 | 
 94 |   tx.update({'nonce': w3.eth.get_transaction_count(eoa.address)})
 95 | 
 96 |   swap = router.functions.execute(commands, [v2_calldata,unwrap_calldata], deadline).build_transaction(tx)
 97 |   print(swap)
 98 |   print('[-] Simulating swap...')
 99 |   w3.eth.call(swap)
100 |   print('[-] Attempting swap...')
101 |   tx_hash = send_tx(sign_tx(swap, eoa.key))
102 |   receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
103 |   print (f'[>] Hash of swap: {tx_hash}\n[>] {receipt}')
104 | 
105 | if __name__ == '__main__':
106 |   main()
107 | 
108 | #------------------------------------------------------------------------------------------------------------------------------------------#
109 | 


--------------------------------------------------------------------------------
/uniswapv2/mempool_filter.py:
--------------------------------------------------------------------------------
 1 | # This is the example from the web3py documentation, with the added 'to' filter from crypto market pool's example. 
 2 | # Included a decoding example for input data as well as updated to set loop and use run(), so as to remove the deprecation warnings.
 3 | 
 4 | # Script that scans mem pool for transactions to a Uniswap v2 router
 5 | from web3 import Web3
 6 | import asyncio
 7 | import json
 8 | 
 9 | endpoint = '~/.ethereum/geth/geth.ipc'
10 | w3 = Web3(Web3.IPCProvider(endpoint))
11 | 
12 | UNISWAP_ADDRESS = '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D'
13 | 
14 | UNISWAP_ABI = '''
15 | [{"inputs":[{"internalType":"address","name":"_factory","type":"address"},{"internalType":"address","name":"_WETH","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenA","type":"address"},{"internalType":"address","name":"tokenB","type":"address"},{"internalType":"uint256","name":"amountADesired","type":"uint256"},{"internalType":"uint256","name":"amountBDesired","type":"uint256"},{"internalType":"uint256","name":"amountAMin","type":"uint256"},{"internalType":"uint256","name":"amountBMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"addLiquidity","outputs":[{"internalType":"uint256","name":"amountA","type":"uint256"},{"internalType":"uint256","name":"amountB","type":"uint256"},{"internalType":"uint256","name":"liquidity","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountTokenDesired","type":"uint256"},{"internalType":"uint256","name":"amountTokenMin","type":"uint256"},{"internalType":"uint256","name":"amountETHMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"addLiquidityETH","outputs":[{"internalType":"uint256","name":"amountToken","type":"uint256"},{"internalType":"uint256","name":"amountETH","type":"uint256"},{"internalType":"uint256","name":"liquidity","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"reserveIn","type":"uint256"},{"internalType":"uint256","name":"reserveOut","type":"uint256"}],"name":"getAmountIn","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"reserveIn","type":"uint256"},{"internalType":"uint256","name":"reserveOut","type":"uint256"}],"name":"getAmountOut","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"address[]","name":"path","type":"address[]"}],"name":"getAmountsIn","outputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"address[]","name":"path","type":"address[]"}],"name":"getAmountsOut","outputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountA","type":"uint256"},{"internalType":"uint256","name":"reserveA","type":"uint256"},{"internalType":"uint256","name":"reserveB","type":"uint256"}],"name":"quote","outputs":[{"internalType":"uint256","name":"amountB","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"tokenA","type":"address"},{"internalType":"address","name":"tokenB","type":"address"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"amountAMin","type":"uint256"},{"internalType":"uint256","name":"amountBMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"removeLiquidity","outputs":[{"internalType":"uint256","name":"amountA","type":"uint256"},{"internalType":"uint256","name":"amountB","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"amountTokenMin","type":"uint256"},{"internalType":"uint256","name":"amountETHMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"removeLiquidityETH","outputs":[{"internalType":"uint256","name":"amountToken","type":"uint256"},{"internalType":"uint256","name":"amountETH","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"amountTokenMin","type":"uint256"},{"internalType":"uint256","name":"amountETHMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"removeLiquidityETHSupportingFeeOnTransferTokens","outputs":[{"internalType":"uint256","name":"amountETH","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"amountTokenMin","type":"uint256"},{"internalType":"uint256","name":"amountETHMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bool","name":"approveMax","type":"bool"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"removeLiquidityETHWithPermit","outputs":[{"internalType":"uint256","name":"amountToken","type":"uint256"},{"internalType":"uint256","name":"amountETH","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"amountTokenMin","type":"uint256"},{"internalType":"uint256","name":"amountETHMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bool","name":"approveMax","type":"bool"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"removeLiquidityETHWithPermitSupportingFeeOnTransferTokens","outputs":[{"internalType":"uint256","name":"amountETH","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenA","type":"address"},{"internalType":"address","name":"tokenB","type":"address"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"amountAMin","type":"uint256"},{"internalType":"uint256","name":"amountBMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bool","name":"approveMax","type":"bool"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"removeLiquidityWithPermit","outputs":[{"internalType":"uint256","name":"amountA","type":"uint256"},{"internalType":"uint256","name":"amountB","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"address[]","name":"path","type":"address[]"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"swapETHForExactTokens","outputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"address[]","name":"path","type":"address[]"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"swapExactETHForTokens","outputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"address[]","name":"path","type":"address[]"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"swapExactETHForTokensSupportingFeeOnTransferTokens","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"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"swapExactTokensForETH","outputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"nonpayable","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"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"swapExactTokensForETHSupportingFeeOnTransferTokens","outputs":[],"stateMutability":"nonpayable","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"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"swapExactTokensForTokens","outputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"nonpayable","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"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"swapExactTokensForTokensSupportingFeeOnTransferTokens","outputs":[],"stateMutability":"nonpayable","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"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"swapTokensForExactETH","outputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"nonpayable","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"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"swapTokensForExactTokens","outputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
16 | '''.strip()
17 | uniswap = w3.eth.contract(address=UNISWAP_ADDRESS, abi=UNISWAP_ABI)
18 | 
19 | def handle_event(event):
20 |   try:
21 |     tx = w3.toJSON(event).strip('"')
22 |     tx = w3.eth.get_transaction(tx)
23 |     if tx['to'] == UNISWAP_ADDRESS:
24 |       print('[x] ----------------------------------------------------------------------------------------- -  -  -')
25 |       for key, value in tx.items():
26 |         if key == 'input':
27 |           print(f'[+] {key}: {uniswap.decode_function_input(value)}')
28 |         elif key in ['v', 'r', 'hash']:
29 |           print(f'[+] {key}: {value.hex()}')
30 |         else:
31 |           print(f'[+] {key}: {value}')
32 |   except Exception:
33 |         del(tx)
34 | 
35 | async def log_loop(event_filter, poll_interval):
36 |   while True:
37 |     for event in event_filter.get_new_entries():
38 |       handle_event(event)
39 |     await asyncio.sleep(poll_interval)
40 | 
41 | def filter_pool(filter_type):
42 |   tx_filter = w3.eth.filter(filter_type)
43 |   loop = asyncio.new_event_loop()
44 |   asyncio.set_event_loop(loop)
45 |   try:
46 |     asyncio.run(log_loop(tx_filter, 2))
47 |   finally:
48 |     loop.close()
49 |     asyncio.set_event_loop(None)
50 | 
51 | def main():
52 |   filter_pool('pending')
53 | 
54 | if __name__ == '__main__':
55 |   main()
56 | 


--------------------------------------------------------------------------------
/uniswapv2/scale4whale.py:
--------------------------------------------------------------------------------
 1 | # return minimum amount in for a given amount out
 2 | def getAmountIn(amountOut: int, reserveIn: int, reserveOut: int) -> int:
 3 |   if not amountOut > 0 or not reserveIn * reserveOut > 0:
 4 |     print('[!] getAmountIn() err: Insufficient quantity')
 5 |     return 0
 6 |   else:
 7 |     numerator = (reserveIn * amountOut) * 1000
 8 |     denominator = (reserveOut - amountOut) * 997
 9 |     amountIn = (numerator / denominator) + 1
10 |     return int(amountIn)
11 | 
12 | # return float multiplier for a given int between 0-100
13 | def _get_multiplier(percent: float) -> float:
14 |   if percent < 0 or percent > 100:
15 |     print('[!] _get_multiplier() err: Percentage out of range:', percent)
16 |     return 0
17 |   else:
18 |     return float(percent / 100)
19 | 
20 | # return a percent amount of 'supply'
21 | def get_percent(percent: int, supply: int) -> int:
22 |   return round(_get_multiplier(percent) * supply)
23 | 
24 | # return eth needed to buy percent of a tokens supply
25 | def quote(
26 |   percent: int,
27 |   supply: int,
28 |   eth_reserve: int,
29 |   token_reserve: int
30 | ) -> int:
31 |   amount = get_percent(percent, supply)
32 |   if amount > token_reserve:
33 |     print('[!] quote() err: AmountOut exceeds pool reserve, try an aggregator')
34 |     return 0
35 |   else:
36 |     return getAmountIn(amount, eth_reserve, token_reserve)
37 | 


--------------------------------------------------------------------------------
/uniswapv2/v2path_encode.md:
--------------------------------------------------------------------------------
 1 | #### Run through of v2 path encoding for manual building of calldata
 2 | ---
 3 | ```
 4 | 0x791ac94700000000000000000000000000000000000000000000000000000000004c3f88000000000000000000000000000000000000000000000000000ac2d7237640f900000000000000000000000000000000000000000000000000000000000000a000000000000000000000000013a48c3e0a403b6cf1a59fbd600e284e620b37ed0000000000000000000000000000000000000000000000000000000065211d050000000000000000000000000000000000000000000000000000000000000002000000000000000000000000ff970a61a04b1ca14834a43f5de4533ebddb5cc800000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1
 5 | ```
 6 | ```
 7 | Function: swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline)
 8 | 
 9 | MethodID: 0x791ac947
10 | [0]:  00000000000000000000000000000000000000000000000000000000004c3f88
11 | [1]:  000000000000000000000000000000000000000000000000000ac2d7237640f9
12 | [2]:  00000000000000000000000000000000000000000000000000000000000000a0
13 | [3]:  00000000000000000000000013a48c3e0a403b6cf1a59fbd600e284e620b37ed
14 | [4]:  0000000000000000000000000000000000000000000000000000000065211d05
15 | [5]:  0000000000000000000000000000000000000000000000000000000000000002
16 | [6]:  000000000000000000000000ff970a61a04b1ca14834a43f5de4533ebddb5cc8
17 | [7]:  00000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1
18 | ```
19 | 
20 | | # | Name         | Type     |         Data        |
21 | | - | --------     | -------- |--------             |
22 | | 0 | amountIn     | uint256  | 4997000             |
23 | | 1 | amountOutMin | uint256  | 3028979035816185    |
24 | | 2 | path         | address[]| 0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8, 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1          |
25 | | 3 | to           | address  | 0x13A48c3E0A403B6CF1a59FBd600E284E620b37ED          |
26 | | 4 | deadline     | uint256  | 1696668933          |
27 | 
28 | - Offset  to array: `[2]:  00000000000000000000000000000000000000000000000000000000000000a0`
29 | ```python
30 | >>> round(int(0xa0)/32)
31 | 5
32 | ```
33 | 
34 | - Length of array: `[5]:  0000000000000000000000000000000000000000000000000000000000000002
35 | `
36 | ```python
37 | >>> int(0x02)  # for completeness
38 | 2
39 | ```
40 | 
41 | - Elements of array: 
42 | - - `[6]:  000000000000000000000000ff970a61a04b1ca14834a43f5de4533ebddb5cc8`
43 | - - `[7]:  00000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1`
44 | 


--------------------------------------------------------------------------------
/uniswapv3/v3exactOutput.py:
--------------------------------------------------------------------------------
 1 | ROUTER_ADDRESS = '0xE592427A0AEce92De3Edee1F18E0157C05861564'
 2 | QUOTER_ADDRESS = '0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6'
 3 | 
 4 | USDC_ADDRESS = '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174'
 5 | STG_ADDRESS = '0x2F6F07CDcf3588944Bf4C42aC74ff24bF56e7590'
 6 | WMATIC_ADDRESS = '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270'
 7 |  
 8 | ROUTER_ABI = '''
 9 | [{"inputs":[{"internalType":"address","name":"_factory","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":[{"components":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMinimum","type":"uint256"}],"internalType":"struct ISwapRouter.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":"deadline","type":"uint256"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMinimum","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"internalType":"struct ISwapRouter.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":"deadline","type":"uint256"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"}],"internalType":"struct ISwapRouter.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":"deadline","type":"uint256"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"internalType":"struct ISwapRouter.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":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"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":"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"},{"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"},{"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"},{"stateMutability":"payable","type":"receive"}]
10 | '''
11 | QUOTER_ABI = '''
12 | [{"inputs":[{"internalType":"address","name":"_factory","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":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"uint256","name":"amountIn","type":"uint256"}],"name":"quoteExactInput","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"name":"quoteExactInputSingle","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"uint256","name":"amountOut","type":"uint256"}],"name":"quoteExactOutput","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"name":"quoteExactOutputSingle","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"path","type":"bytes"}],"name":"uniswapV3SwapCallback","outputs":[],"stateMutability":"view","type":"function"}]
13 | '''
14 | ERC20_ABI = ''' 
15 | [{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"guy","type":"address"},{"name":"wad","type":"uint256"}],"name":"approve","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"src","type":"address"},{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"wad","type":"uint256"}],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"deposit","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":true,"name":"guy","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":true,"name":"dst","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"dst","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Withdrawal","type":"event"}]
16 | '''
17 | 
18 | from net import con
19 | w3 = con('POLYGON')
20 | 
21 | router = w3.eth.contract(address=ROUTER_ADDRESS, abi=ROUTER_ABI)
22 | quoter = w3.eth.contract(address=QUOTER_ADDRESS, abi=QUOTER_ABI)
23 | usdc = w3.eth.contract(address=USDC_ADDRESS, abi=ERC20_ABI)
24 | stg = w3.eth.contract(address=STG_ADDRESS, abi=ERC20_ABI)
25 | wmatic = w3.eth.contract(address=WMATIC_ADDRESS, abi=ERC20_ABI)
26 | 
27 | ONE_ETH = 1*10**18
28 | ONE_USDC = 1*10**6
29 | AMOUNT_OUT = ONE_ETH
30 | SQRT_PRICE_LIMIT = 0
31 | 
32 | STG_MATIC_FEE = 10000
33 | MATIC_USDC_FEE = 500
34 | 
35 | from eth_abi.packed import encode_packed
36 | # The fee changes which pool for the address-pair will be traded on, if having issues check the pool(s) being routed through make sure they have the liquidty you think
37 | # TokenOut,Fee,TokenIn/TokenOut,Fee,TokenIn
38 | path = encode_packed(['address', 'uint24', 'address', 'uint24', 'address'], [STG_ADDRESS, STG_MATIC_FEE, WMATIC_ADDRESS, MATIC_USDC_FEE, USDC_ADDRESS])
39 | PROCESSED_PATH = f'0x{path.hex()}'
40 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
41 | amount_in = quoter.functions.quoteExactOutput(PROCESSED_PATH, AMOUNT_OUT).call()
42 | multiplier = 0.01 # 1% slippage
43 | AMOUNT_IN_WITH_SLIPPAGE = amount_in + round(multiplier * amount_in)
44 | DEADLINE = 2000000000
45 | 
46 | # account
47 | from os import getenv
48 | from dotenv import load_dotenv
49 | load_dotenv()
50 | KEY = getenv('TKEY')
51 | EOA = getenv('TRON')
52 | #----------------------
53 | 
54 | params = (PROCESSED_PATH, EOA, DEADLINE, AMOUNT_OUT, AMOUNT_IN_WITH_SLIPPAGE)
55 | 
56 | tx = {
57 |         'from': EOA,
58 |         'value':0,
59 |         'chainId': 137,
60 |         'gas': 250000,
61 |         'maxFeePerGas': w3.eth.gas_price * 2,
62 |         'maxPriorityFeePerGas': w3.to_wei('40', 'gwei'),
63 |         'nonce': w3.eth.get_transaction_count(EOA)
64 | }
65 | 
66 | # helpers
67 | def sign_tx(tx, key):
68 |   sig = w3.eth.account.sign_transaction
69 |   signed_tx = sig(tx, private_key=key)
70 |   return signed_tx
71 | 
72 | def send_tx(signed_tx):
73 |   w3.eth.send_raw_transaction(signed_tx.rawTransaction)
74 |   tx_hash = w3.to_hex(w3.keccak(signed_tx.rawTransaction))
75 |   return tx_hash
76 | 
77 | # driver 
78 | def main():
79 |   approve = wmatic.functions.approve(ROUTER_ADDRESS, AMOUNT_IN_WITH_SLIPPAGE).build_transaction(tx)
80 |   print ('[-] Approving... ')
81 |   tx_hash = send_tx(sign_tx(approve, KEY))
82 |   receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
83 |   print (f'[+] approved: {tx_hash}\n[>] {receipt}')
84 |   
85 |   tx.update({'nonce': w3.eth.get_transaction_count(EOA)})
86 |   swap = router.functions.exactOutput(params).build_transaction(tx)
87 |   print('[-] Attempting swap...')
88 |   tx_hash = send_tx(sign_tx(swap, KEY))
89 |   receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
90 |   print (f'[>] Hash of attempt: {tx_hash}\n[>] {receipt}')
91 | 
92 | if __name__ == '__main__':
93 |   main()
94 | 


--------------------------------------------------------------------------------
/uniswapv3/v3exactOutputSingle.py:
--------------------------------------------------------------------------------
 1 | ROUTER_ADDRESS = '0xE592427A0AEce92De3Edee1F18E0157C05861564'
 2 | QUOTER_ADDRESS = '0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6'
 3 | 
 4 | USDC_ADDRESS = '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174'
 5 | WMATIC_ADDRESS = '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270'
 6 | 
 7 | ROUTER_ABI = '''
 8 | [{"inputs":[{"internalType":"address","name":"_factory","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":[{"components":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMinimum","type":"uint256"}],"internalType":"struct ISwapRouter.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":"deadline","type":"uint256"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMinimum","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"internalType":"struct ISwapRouter.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":"deadline","type":"uint256"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"}],"internalType":"struct ISwapRouter.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":"deadline","type":"uint256"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"internalType":"struct ISwapRouter.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":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"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":"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"},{"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"},{"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"},{"stateMutability":"payable","type":"receive"}]
 9 | '''
10 | QUOTER_ABI = '''
11 | [{"inputs":[{"internalType":"address","name":"_factory","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":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"uint256","name":"amountIn","type":"uint256"}],"name":"quoteExactInput","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"name":"quoteExactInputSingle","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"uint256","name":"amountOut","type":"uint256"}],"name":"quoteExactOutput","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"name":"quoteExactOutputSingle","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"path","type":"bytes"}],"name":"uniswapV3SwapCallback","outputs":[],"stateMutability":"view","type":"function"}]
12 | '''
13 | ERC20_ABI = '''
14 | [{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"guy","type":"address"},{"name":"wad","type":"uint256"}],"name":"approve","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"src","type":"address"},{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"wad","type":"uint256"}],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"deposit","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":true,"name":"guy","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":true,"name":"dst","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"dst","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Withdrawal","type":"event"}]
15 | '''
16 | 
17 | from net import con
18 | w3 = con('POLYGON')
19 | 
20 | router = w3.eth.contract(address=ROUTER_ADDRESS, abi=ROUTER_ABI)
21 | quoter = w3.eth.contract(address=QUOTER_ADDRESS, abi=QUOTER_ABI)
22 | usdc = w3.eth.contract(address=USDC_ADDRESS, abi=ERC20_ABI)
23 | wmatic = w3.eth.contract(address=WMATIC_ADDRESS, abi=ERC20_ABI)
24 | 
25 | from eth_abi.packed import encode_packed
26 | # 0x0d500b1d8e8ef31e21c99d1db9a6444d3adf12700001f42791bca1f2de4661ed88a30c99a7a9449aa84174
27 | # tokenOut,Fee,TokenIn
28 | #path = encode_packed(['address', 'uint24', 'address'], [WMATIC_ADDRESS, FEE, USDC_ADDRESS])
29 | #PROCESSED_PATH = f'0x{path.hex()}'
30 | 
31 | AMOUNT_OUT = 1*10**18
32 | SQRT_PRICE_LIMIT = 0
33 | FEE = 500
34 | 
35 | amount_in = quoter.functions.quoteExactOutputSingle(USDC_ADDRESS, WMATIC_ADDRESS, FEE, AMOUNT_OUT, SQRT_PRICE_LIMIT).call()
36 | multiplier = 0.01 # 1% slippage
37 | AMOUNT_IN_WITH_SLIPPAGE = amount_in + round(multiplier * amount_in)
38 | 
39 | DEADLINE = 2000000000
40 | 
41 | # account
42 | from os import getenv
43 | from dotenv import load_dotenv
44 | load_dotenv()
45 | KEY = getenv('TKEY')
46 | EOA = getenv('TRON')
47 | #----------------------
48 | 
49 | params = (USDC_ADDRESS, WMATIC_ADDRESS, FEE, EOA, DEADLINE, AMOUNT_OUT, AMOUNT_IN_WITH_SLIPPAGE, SQRT_PRICE_LIMIT)
50 | 
51 | tx = {
52 |         'from': EOA,
53 |         'value':0,
54 |         'chainId': 137,
55 |         'gas': 250000,
56 |         'maxFeePerGas': w3.eth.gas_price * 2,
57 |         'maxPriorityFeePerGas': w3.to_wei('40', 'gwei'),
58 |         'nonce': w3.eth.get_transaction_count(EOA)
59 | 
60 | }
61 | 
62 | # helpers
63 | def sign_tx(tx, key):
64 |   sig = w3.eth.account.sign_transaction
65 |   signed_tx = sig(tx, private_key=key)
66 |   return signed_tx
67 | 
68 | def send_tx(signed_tx):
69 |   w3.eth.send_raw_transaction(signed_tx.rawTransaction)
70 |   tx_hash = w3.to_hex(w3.keccak(signed_tx.rawTransaction))
71 |   return tx_hash
72 | 
73 | # driver
74 | def main():
75 |   approve = usdc.functions.approve(ROUTER_ADDRESS, AMOUNT_IN_WITH_SLIPPAGE).build_transaction(tx)
76 |   print ('[-] Approving... ')
77 |   tx_hash = send_tx(sign_tx(approve, KEY))
78 |   receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
79 |   print (f'[+] Approved: {tx_hash}\n[>] {receipt}')
80 | 
81 |   tx.update({'nonce': w3.eth.get_transaction_count(EOA)})
82 |   swap = router.functions.exactOutputSingle(params).build_transaction(tx)
83 |   print('[-] Attempting swap...')
84 |   tx_hash = send_tx(sign_tx(swap, KEY))
85 |   receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
86 |   print (f'[>] Hash of attempt: {tx_hash}\n[>] {receipt}')
87 | 
88 | if __name__ == '__main__':
89 |   main()
90 | 


--------------------------------------------------------------------------------
/uniswapv3/v3quoter_iterations.py:
--------------------------------------------------------------------------------
 1 | # short script to highlight the diffences between the v1/v2 iterations of the quoter for uni v3 pools, as appears to be tripping many up.
 2 | 
 3 | # The updated quoter takes a tuple with the arguments in, and switches positions of two of the values, amountIn and fee.
 4 | # Here are examples calling each with their respective ABI.
 5 | 
 6 | QUOTER_ADDRESS = '0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6'
 7 | QUOTERv2_ADDRESS = '0x61fFE014bA17989E743c5F6cB21bF9697530B21e'
 8 | 
 9 | USDC_ADDRESS = '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174'
10 | WMATIC_ADDRESS = '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270'
11 | 
12 | QUOTER_ABI = '''
13 | [{"inputs":[{"internalType":"address","name":"_factory","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":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"uint256","name":"amountIn","type":"uint256"}],"name":"quoteExactInput","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"name":"quoteExactInputSingle","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"uint256","name":"amountOut","type":"uint256"}],"name":"quoteExactOutput","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"name":"quoteExactOutputSingle","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"path","type":"bytes"}],"name":"uniswapV3SwapCallback","outputs":[],"stateMutability":"view","type":"function"}]
14 | '''
15 | QUOTERv2_ABI = '''
16 | [{"inputs":[{"internalType":"address","name":"_factory","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":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"uint256","name":"amountIn","type":"uint256"}],"name":"quoteExactInput","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint160[]","name":"sqrtPriceX96AfterList","type":"uint160[]"},{"internalType":"uint32[]","name":"initializedTicksCrossedList","type":"uint32[]"},{"internalType":"uint256","name":"gasEstimate","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"internalType":"struct IQuoterV2.QuoteExactInputSingleParams","name":"params","type":"tuple"}],"name":"quoteExactInputSingle","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceX96After","type":"uint160"},{"internalType":"uint32","name":"initializedTicksCrossed","type":"uint32"},{"internalType":"uint256","name":"gasEstimate","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"uint256","name":"amountOut","type":"uint256"}],"name":"quoteExactOutput","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint160[]","name":"sqrtPriceX96AfterList","type":"uint160[]"},{"internalType":"uint32[]","name":"initializedTicksCrossedList","type":"uint32[]"},{"internalType":"uint256","name":"gasEstimate","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"internalType":"struct IQuoterV2.QuoteExactOutputSingleParams","name":"params","type":"tuple"}],"name":"quoteExactOutputSingle","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceX96After","type":"uint160"},{"internalType":"uint32","name":"initializedTicksCrossed","type":"uint32"},{"internalType":"uint256","name":"gasEstimate","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"path","type":"bytes"}],"name":"uniswapV3SwapCallback","outputs":[],"stateMutability":"view","type":"function"}]
17 | '''
18 | 
19 | from net import con
20 | w3 = con('POLYGON')
21 | 
22 | quoter = w3.eth.contract(address=QUOTER_ADDRESS, abi=QUOTER_ABI)
23 | quoterv2 = w3.eth.contract(address=QUOTERv2_ADDRESS, abi=QUOTERv2_ABI)
24 | 
25 | AMOUNT_IN = 1*10**18
26 | SQRT_PRICE_LIMIT = 0
27 | FEE = 500
28 | 
29 | amount_out  = quoter.functions.quoteExactInputSingle(WMATIC_ADDRESS, USDC_ADDRESS, FEE, AMOUNT_IN, SQRT_PRICE_LIMIT).call()
30 | amount_outv2 = quoterv2.functions.quoteExactInputSingle((WMATIC_ADDRESS, USDC_ADDRESS, AMOUNT_IN, FEE, SQRT_PRICE_LIMIT)).call()
31 | 
32 | def main():
33 |   print(amount_out)
34 | 


--------------------------------------------------------------------------------
/zk/check_balance.py:
--------------------------------------------------------------------------------
 1 | from eth_account import Account
 2 | from eth_account.signers.local import LocalAccount
 3 | from zksync2.module.module_builder import ZkSyncBuilder
 4 | 
 5 | from zksync2.module.module_builder import ZkSyncBuilder
 6 | from zksync2.core.types import EthBlockParams
 7 | 
 8 | endpoint = 'https://mainnet.era.zksync.io'
 9 | 
10 | zk3 = ZkSyncBuilder.build(endpoint) 
11 | 
12 | def get_bal(add: str) -> int:
13 |   return zk3.zksync.get_balance(add, EthBlockParams.LATEST.value)
14 | 
15 | print(get_bal('0x8c14ed4F602ac4d2Be8Ed9c4716307c73e9A83A8'))
16 | 


--------------------------------------------------------------------------------
/zk/transfer.py:
--------------------------------------------------------------------------------
 1 | from eth_typing import HexStr
 2 | from web3 import Web3
 3 | from zksync2.module.module_builder import ZkSyncBuilder
 4 | from zksync2.core.types import ZkBlockParams
 5 | from eth_account import Account
 6 | from eth_account.signers.local import LocalAccount
 7 | from zksync2.signer.eth_signer import PrivateKeyEthSigner
 8 | from zksync2.transaction.transaction_builders import TxFunctionCall
 9 | 
10 | from os import getenv
11 | from dotenv import load_dotenv
12 | load_dotenv()
13 | 
14 | def transfer_to_self():
15 |     amount = 0.0001
16 |     account: LocalAccount = Account.from_key(getenv('TKEY'))
17 |     zksync_web3 = ZkSyncBuilder.build(getenv('ZKNODE'))
18 |     chain_id = zksync_web3.zksync.chain_id
19 |     signer = PrivateKeyEthSigner(account, chain_id)
20 | 
21 |     nonce = zksync_web3.zksync.get_transaction_count(account.address, ZkBlockParams.COMMITTED.value)
22 |     gas_price = zksync_web3.zksync.gas_price
23 | 
24 |     tx_func_call = TxFunctionCall(chain_id=chain_id,
25 |       nonce=nonce,
26 |       from_=account.address,
27 |       to=account.address,
28 |       value=Web3.to_wei(amount, 'ether'),
29 |       data=HexStr("0x"),
30 |       gas_limit=0,  # unknown at this state, will be replaced by estimate_gas
31 |       gas_price=gas_price,
32 |       max_priority_fee_per_gas=100000000)
33 |     estimate_gas = zksync_web3.zksync.eth_estimate_gas(tx_func_call.tx)
34 |     print(f"Fee for transaction is: {estimate_gas * gas_price}")
35 | 
36 |     tx_712 = tx_func_call.tx712(estimate_gas)
37 | 
38 |     singed_message = signer.sign_typed_data(tx_712.to_eip712_struct())
39 |     msg = tx_712.encode(singed_message)
40 |     tx_hash = zksync_web3.zksync.send_raw_transaction(msg)
41 |     tx_receipt = zksync_web3.zksync.wait_for_transaction_receipt(tx_hash, timeout=240, poll_latency=0.5)
42 |     print(f"tx_hash : {tx_hash.hex()}, status: {tx_receipt['status']}")
43 | 
44 | 
45 | if __name__ == "__main__":
46 |     transfer_to_self()
47 | 


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