@dhedge/v2-sdk 1.1.0 → 1.2.1

package/dist/v2-sdk.esm.js

@@ -2,6 +2,14 @@ import { ethers, Contract } from 'ethers';
 export { ethers } from 'ethers';
 import { ChainId, Token, Pair, TokenAmount, Route, Trade, TradeType, Percent } from '@sushiswap/sdk';
 import axios from 'axios';
+import { flatten, chunk } from 'lodash-es';
+import { getAddress } from '@ethersproject/address';
+import 'lodash-es/set';
+import { Interface } from '@ethersproject/abi';
+import BigNumber from 'bignumber.js';
+import { hexToBytes, soliditySha3 } from 'web3-utils';
+import { keccak256, bufferToHex, keccakFromString } from 'ethereumjs-util';
+import { SwapTypes, SOR } from '@balancer-labs/sor';
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
@@ -39,6 +47,24 @@ function _asyncToGenerator(fn) {
   };
 }
 
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
 function createCommonjsModule(fn, module) {
 	return module = { exports: {} }, fn(module, module.exports), module.exports;
 }
@@ -3804,6 +3830,7 @@ var Dapp;
   Dapp["AAVE"] = "aave";
   Dapp["ONEINCH"] = "1inch";
   Dapp["QUICKSWAP"] = "quickswap";
+  Dapp["BALANCER"] = "balancer";
 })(Dapp || (Dapp = {}));
 
 var Transaction;
@@ -3813,19 +3840,25 @@ var Transaction;
   Transaction["ADD_LIQUIDITY"] = "addLiquidity";
   Transaction["DEPOSIT"] = "deposit";
   Transaction["HARVEST"] = "harvest";
-  Transaction["UNSTAKE"] = "withdrawAndHarvest";
+  Transaction["CLAIM_DISTRIBIUTIONS"] = "claimDistributions";
+  Transaction["CLAIM_REWARDS"] = "claimRewards";
   Transaction["REMOVE_LIQUIDITY"] = "removeLiquidity";
   Transaction["BORROW"] = "borrow";
   Transaction["REPAY"] = "repay";
   Transaction["WITHDRAW"] = "withdraw";
 })(Transaction || (Transaction = {}));
 
-var _factoryAddress, _Network$POLYGON, _routerAddress, _Network$POLYGON2, _dappFactoryAddress, _Network$POLYGON3, _stakingAddress, _networkChainIdMap;
-var factoryAddress = (_factoryAddress = {}, _factoryAddress[Network.POLYGON] = "0xfdc7b8bFe0DD3513Cc669bB8d601Cb83e2F69cB0", _factoryAddress);
-var routerAddress = (_routerAddress = {}, _routerAddress[Network.POLYGON] = (_Network$POLYGON = {}, _Network$POLYGON[Dapp.SUSHISWAP] = "0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506", _Network$POLYGON[Dapp.AAVE] = "0x8dFf5E27EA6b7AC08EbFdf9eB090F32ee9a30fcf", _Network$POLYGON[Dapp.ONEINCH] = "0x11111112542D85B3EF69AE05771c2dCCff4fAa26", _Network$POLYGON[Dapp.QUICKSWAP] = "0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff", _Network$POLYGON), _routerAddress);
+var _factoryAddress, _Network$POLYGON, _routerAddress, _Network$POLYGON2, _dappFactoryAddress, _Network$POLYGON3, _stakingAddress, _networkChainIdMap, _balancerSubgraph, _multiCallAddress;
+
+require("dotenv").config();
+
+var factoryAddress = (_factoryAddress = {}, _factoryAddress[Network.POLYGON] = process.env.STAGING_CONTRACTS ? "0xDd87eCdB10cFF7004276AAbAbd30e7a08F69bb53" : "0xfdc7b8bFe0DD3513Cc669bB8d601Cb83e2F69cB0", _factoryAddress);
+var routerAddress = (_routerAddress = {}, _routerAddress[Network.POLYGON] = (_Network$POLYGON = {}, _Network$POLYGON[Dapp.SUSHISWAP] = "0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506", _Network$POLYGON[Dapp.AAVE] = "0x8dFf5E27EA6b7AC08EbFdf9eB090F32ee9a30fcf", _Network$POLYGON[Dapp.ONEINCH] = "0x1111111254fb6c44bac0bed2854e76f90643097d", _Network$POLYGON[Dapp.QUICKSWAP] = "0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff", _Network$POLYGON[Dapp.BALANCER] = "0xBA12222222228d8Ba445958a75a0704d566BF2C8", _Network$POLYGON), _routerAddress);
 var dappFactoryAddress = (_dappFactoryAddress = {}, _dappFactoryAddress[Network.POLYGON] = (_Network$POLYGON2 = {}, _Network$POLYGON2[Dapp.SUSHISWAP] = "0xc35DADB65012eC5796536bD9864eD8773aBc74C4", _Network$POLYGON2[Dapp.QUICKSWAP] = "0x5757371414417b8C6CAad45bAeF941aBc7d3Ab32", _Network$POLYGON2), _dappFactoryAddress);
-var stakingAddress = (_stakingAddress = {}, _stakingAddress[Network.POLYGON] = (_Network$POLYGON3 = {}, _Network$POLYGON3[Dapp.SUSHISWAP] = "0x0769fd68dFb93167989C6f7254cd0D766Fb2841F", _Network$POLYGON3), _stakingAddress);
+var stakingAddress = (_stakingAddress = {}, _stakingAddress[Network.POLYGON] = (_Network$POLYGON3 = {}, _Network$POLYGON3[Dapp.SUSHISWAP] = "0x0769fd68dFb93167989C6f7254cd0D766Fb2841F", _Network$POLYGON3[Dapp.BALANCER] = "0x0F3e0c4218b7b0108a3643cFe9D3ec0d4F57c54e", _Network$POLYGON3[Dapp.AAVE] = "0x357D51124f59836DeD84c8a1730D72B749d8BC23", _Network$POLYGON3), _stakingAddress);
 var networkChainIdMap = (_networkChainIdMap = {}, _networkChainIdMap[Network.POLYGON] = ChainId.MATIC, _networkChainIdMap);
+var balancerSubgraph = (_balancerSubgraph = {}, _balancerSubgraph[Network.POLYGON] = "https://api.thegraph.com/subgraphs/name/balancer-labs/balancer-polygon-v2", _balancerSubgraph);
+var multiCallAddress = (_multiCallAddress = {}, _multiCallAddress[Network.POLYGON] = "0x275617327c958bD06b5D6b871E7f491D76113dd8", _multiCallAddress);
 
 var abi$3 = [
 	{
@@ -5563,251 +5596,1465 @@ var IUniswapV2Router = {
 	abi: abi$6
 };
 
-var Pool = /*#__PURE__*/function () {
-  function Pool(network, signer, poolLogic, mangerLogic, utils) {
-    this.network = network;
-    this.poolLogic = poolLogic;
-    this.address = poolLogic.address;
-    this.managerLogic = mangerLogic;
-    this.signer = signer;
-    this.utils = utils;
-  }
-  /**
-   * Return the assets with balances and deposit info of a pool
-   * @returns {Promise<FundComposition[]>} Composition of assets with balance, deposit info
-   */
-
-
-  var _proto = Pool.prototype;
-
-  _proto.getComposition =
-  /*#__PURE__*/
-  function () {
-    var _getComposition = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee() {
-      var result, fundComposition;
-      return runtime_1.wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              _context.next = 2;
-              return this.managerLogic.getFundComposition();
-
-            case 2:
-              result = _context.sent;
-              fundComposition = result[0].map(function (item, index) {
-                var asset = item.asset,
-                    isDeposit = item.isDeposit;
-                return {
-                  asset: asset,
-                  isDeposit: isDeposit,
-                  balance: result[1][index],
-                  rate: result[2][index]
-                };
-              });
-              return _context.abrupt("return", fundComposition);
-
-            case 5:
-            case "end":
-              return _context.stop();
-          }
-        }
-      }, _callee, this);
-    }));
-
-    function getComposition() {
-      return _getComposition.apply(this, arguments);
-    }
-
-    return getComposition;
-  }() //Invest functions
-
-  /**
-   * Approve the asset that can be deposited into a pool
-   * @param {string} nasset Address of deposit asset
-   * @param {BigNumber | string} amount Amount to be approved
-   * @param {any} options Transaction options
-   * @returns {Promise<any>} Transaction
-   */
-  ;
-
-  _proto.approveDeposit =
-  /*#__PURE__*/
-  function () {
-    var _approveDeposit = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(asset, amount, options) {
-      var iERC20, tx;
-      return runtime_1.wrap(function _callee2$(_context2) {
-        while (1) {
-          switch (_context2.prev = _context2.next) {
-            case 0:
-              if (options === void 0) {
-                options = null;
-              }
-
-              iERC20 = new ethers.Contract(asset, IERC20.abi, this.signer);
-              _context2.next = 4;
-              return iERC20.approve(this.address, amount, options);
-
-            case 4:
-              tx = _context2.sent;
-              return _context2.abrupt("return", tx);
-
-            case 6:
-            case "end":
-              return _context2.stop();
-          }
-        }
-      }, _callee2, this);
-    }));
-
-    function approveDeposit(_x, _x2, _x3) {
-      return _approveDeposit.apply(this, arguments);
-    }
-
-    return approveDeposit;
-  }()
-  /**
-   * Deposit  asset into a pool
-   * @param {string} asset Address of asset
-   * @param {BigNumber | string} amount Amount to be deposited
-   * @param {any} options Transaction options
-   * @returns {Promise<any>} Transaction
-   */
-  ;
-
-  _proto.deposit =
-  /*#__PURE__*/
-  function () {
-    var _deposit = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(asset, amount, options) {
-      var tx;
-      return runtime_1.wrap(function _callee3$(_context3) {
-        while (1) {
-          switch (_context3.prev = _context3.next) {
-            case 0:
-              if (options === void 0) {
-                options = null;
-              }
-
-              _context3.next = 3;
-              return this.poolLogic.deposit(asset, amount, options);
-
-            case 3:
-              tx = _context3.sent;
-              return _context3.abrupt("return", tx);
-
-            case 5:
-            case "end":
-              return _context3.stop();
-          }
-        }
-      }, _callee3, this);
-    }));
-
-    function deposit(_x4, _x5, _x6) {
-      return _deposit.apply(this, arguments);
-    }
-
-    return deposit;
-  }()
-  /**
-   * Withdraw  assets from a pool
-   * @param fundTokenAmount Amount of pool tokens to be withdrawn
-   * @param {any} options Transaction options
-   * @returns {Promise<any>} Transaction
-   */
-  ;
-
-  _proto.withdraw =
-  /*#__PURE__*/
-  function () {
-    var _withdraw = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(fundTokenAmount, options) {
-      var tx;
-      return runtime_1.wrap(function _callee4$(_context4) {
-        while (1) {
-          switch (_context4.prev = _context4.next) {
-            case 0:
-              if (options === void 0) {
-                options = null;
-              }
-
-              _context4.next = 3;
-              return this.poolLogic.withdraw(fundTokenAmount, options);
-
-            case 3:
-              tx = _context4.sent;
-              return _context4.abrupt("return", tx);
-
-            case 5:
-            case "end":
-              return _context4.stop();
-          }
-        }
-      }, _callee4, this);
-    }));
-
-    function withdraw(_x7, _x8) {
-      return _withdraw.apply(this, arguments);
-    }
-
-    return withdraw;
-  }() //Manager functions
-
-  /**
-   * Approve the asset for trading and providing liquidity
-   * @param {Dapp} dapp Platform like Sushiswap or Uniswap
-   * @param {string} asset Address of asset
-   * @param @param {BigNumber | string} Amount to be approved
-   * @param {any} options Transaction options
-   * @returns {Promise<any>} Transaction
-   */
-  ;
-
-  _proto.approve =
-  /*#__PURE__*/
-  function () {
-    var _approve = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(dapp, asset, amount, options) {
-      var iERC20, approveTxData, tx;
-      return runtime_1.wrap(function _callee5$(_context5) {
-        while (1) {
-          switch (_context5.prev = _context5.next) {
-            case 0:
-              if (options === void 0) {
-                options = null;
-              }
-
-              iERC20 = new ethers.utils.Interface(IERC20.abi);
-              approveTxData = iERC20.encodeFunctionData("approve", [routerAddress[this.network][dapp], amount]);
-              _context5.next = 5;
-              return this.poolLogic.execTransaction(asset, approveTxData, options);
-
-            case 5:
-              tx = _context5.sent;
-              return _context5.abrupt("return", tx);
-
-            case 7:
-            case "end":
-              return _context5.stop();
-          }
-        }
-      }, _callee5, this);
-    }));
-
-    function approve(_x9, _x10, _x11, _x12) {
-      return _approve.apply(this, arguments);
-    }
-
-    return approve;
-  }()
-  /**
-   * Approve the liquidity pool token for staking
-   * @param {Dapp} dapp Platform like Sushiswap or Uniswap
-   * @param {string} asset Address of liquidity pool token
-   * @param {BigNumber | string} amount Aamount to be approved
-   * @param {any} options Transaction options
-   * @returns {Promise<any>} Transaction
-   */
-  ;
-
-  _proto.approveStaking =
+var abi$7 = [
+	{
+		inputs: [
+			{
+				internalType: "contract IVault",
+				name: "vault",
+				type: "address"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "constructor"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "distributor",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "contract IERC20",
+				name: "token",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "distributionId",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "merkleRoot",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			}
+		],
+		name: "DistributionAdded",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "distributor",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "contract IERC20",
+				name: "token",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "distributionId",
+				type: "uint256"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "claimer",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			}
+		],
+		name: "DistributionClaimed",
+		type: "event"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "claimer",
+				type: "address"
+			},
+			{
+				components: [
+					{
+						internalType: "uint256",
+						name: "distributionId",
+						type: "uint256"
+					},
+					{
+						internalType: "uint256",
+						name: "balance",
+						type: "uint256"
+					},
+					{
+						internalType: "address",
+						name: "distributor",
+						type: "address"
+					},
+					{
+						internalType: "uint256",
+						name: "tokenIndex",
+						type: "uint256"
+					},
+					{
+						internalType: "bytes32[]",
+						name: "merkleProof",
+						type: "bytes32[]"
+					}
+				],
+				internalType: "struct MerkleOrchard.Claim[]",
+				name: "claims",
+				type: "tuple[]"
+			},
+			{
+				internalType: "contract IERC20[]",
+				name: "tokens",
+				type: "address[]"
+			}
+		],
+		name: "claimDistributions",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "claimer",
+				type: "address"
+			},
+			{
+				components: [
+					{
+						internalType: "uint256",
+						name: "distributionId",
+						type: "uint256"
+					},
+					{
+						internalType: "uint256",
+						name: "balance",
+						type: "uint256"
+					},
+					{
+						internalType: "address",
+						name: "distributor",
+						type: "address"
+					},
+					{
+						internalType: "uint256",
+						name: "tokenIndex",
+						type: "uint256"
+					},
+					{
+						internalType: "bytes32[]",
+						name: "merkleProof",
+						type: "bytes32[]"
+					}
+				],
+				internalType: "struct MerkleOrchard.Claim[]",
+				name: "claims",
+				type: "tuple[]"
+			},
+			{
+				internalType: "contract IERC20[]",
+				name: "tokens",
+				type: "address[]"
+			}
+		],
+		name: "claimDistributionsToInternalBalance",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "claimer",
+				type: "address"
+			},
+			{
+				components: [
+					{
+						internalType: "uint256",
+						name: "distributionId",
+						type: "uint256"
+					},
+					{
+						internalType: "uint256",
+						name: "balance",
+						type: "uint256"
+					},
+					{
+						internalType: "address",
+						name: "distributor",
+						type: "address"
+					},
+					{
+						internalType: "uint256",
+						name: "tokenIndex",
+						type: "uint256"
+					},
+					{
+						internalType: "bytes32[]",
+						name: "merkleProof",
+						type: "bytes32[]"
+					}
+				],
+				internalType: "struct MerkleOrchard.Claim[]",
+				name: "claims",
+				type: "tuple[]"
+			},
+			{
+				internalType: "contract IERC20[]",
+				name: "tokens",
+				type: "address[]"
+			},
+			{
+				internalType: "contract IDistributorCallback",
+				name: "callbackContract",
+				type: "address"
+			},
+			{
+				internalType: "bytes",
+				name: "callbackData",
+				type: "bytes"
+			}
+		],
+		name: "claimDistributionsWithCallback",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "contract IERC20",
+				name: "token",
+				type: "address"
+			},
+			{
+				internalType: "bytes32",
+				name: "merkleRoot",
+				type: "bytes32"
+			},
+			{
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "distributionId",
+				type: "uint256"
+			}
+		],
+		name: "createDistribution",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "contract IERC20",
+				name: "token",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "distributor",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "distributionId",
+				type: "uint256"
+			}
+		],
+		name: "getDistributionRoot",
+		outputs: [
+			{
+				internalType: "bytes32",
+				name: "",
+				type: "bytes32"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "contract IERC20",
+				name: "token",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "distributor",
+				type: "address"
+			}
+		],
+		name: "getNextDistributionId",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "contract IERC20",
+				name: "token",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "distributor",
+				type: "address"
+			}
+		],
+		name: "getRemainingBalance",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "getVault",
+		outputs: [
+			{
+				internalType: "contract IVault",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "contract IERC20",
+				name: "token",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "distributor",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "distributionId",
+				type: "uint256"
+			},
+			{
+				internalType: "address",
+				name: "claimer",
+				type: "address"
+			}
+		],
+		name: "isClaimed",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "contract IERC20",
+				name: "token",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "distributor",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "distributionId",
+				type: "uint256"
+			},
+			{
+				internalType: "address",
+				name: "claimer",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "claimedBalance",
+				type: "uint256"
+			},
+			{
+				internalType: "bytes32[]",
+				name: "merkleProof",
+				type: "bytes32[]"
+			}
+		],
+		name: "verifyClaim",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	}
+];
+var IBalancerMerkleOrchard = {
+	abi: abi$7
+};
+
+var abi$8 = [
+	{
+		inputs: [
+			{
+				internalType: "address[]",
+				name: "assets",
+				type: "address[]"
+			},
+			{
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			},
+			{
+				internalType: "address",
+				name: "to",
+				type: "address"
+			}
+		],
+		name: "claimRewards",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "user",
+				type: "address"
+			}
+		],
+		name: "getUserUnclaimedRewards",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "rewards",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	}
+];
+var bytecode = "0x";
+var deployedBytecode = "0x";
+var linkReferences = {
+};
+var deployedLinkReferences = {
+};
+var IAaveIncentivesController = {
+	abi: abi$8,
+	bytecode: bytecode,
+	deployedBytecode: deployedBytecode,
+	linkReferences: linkReferences,
+	deployedLinkReferences: deployedLinkReferences
+};
+
+function multicall(_x5, _x6, _x7, _x8, _x9, _x10) {
+  return _multicall.apply(this, arguments);
+}
+
+function _multicall() {
+  _multicall = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(network, provider, abi, calls, options, requireSuccess) {
+    var multi, itf, res;
+    return runtime_1.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            if (options === void 0) {
+              options = {};
+            }
+
+            if (requireSuccess === void 0) {
+              requireSuccess = false;
+            }
+
+            multi = new ethers.Contract(multiCallAddress[network], ["function tryAggregate(bool requireSuccess, tuple(address, bytes)[] memory calls) public view returns (tuple(bool, bytes)[] memory returnData)"], provider);
+            itf = new Interface(abi);
+            _context3.prev = 4;
+            _context3.next = 7;
+            return multi.tryAggregate( // if false, allows individual calls to fail without causing entire multicall to fail
+            requireSuccess, calls.map(function (call) {
+              return [call[0].toLowerCase(), itf.encodeFunctionData(call[1], call[2])];
+            }), options);
+
+          case 7:
+            res = _context3.sent;
+            return _context3.abrupt("return", res.map(function (_ref, i) {
+              var success = _ref[0],
+                  returnData = _ref[1];
+              if (!success) return null;
+              var decodedResult = itf.decodeFunctionResult(calls[i][1], returnData); // Automatically unwrap any simple return values
+
+              // Automatically unwrap any simple return values
+              return decodedResult.length > 1 ? decodedResult : decodedResult[0];
+            }));
+
+          case 11:
+            _context3.prev = 11;
+            _context3.t0 = _context3["catch"](4);
+            return _context3.abrupt("return", Promise.reject(_context3.t0));
+
+          case 14:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3, null, [[4, 11]]);
+  }));
+  return _multicall.apply(this, arguments);
+}
+
+var MerkleTree = /*#__PURE__*/function () {
+  function MerkleTree(elements) {
+    this.elements = elements.filter(function (el) {
+      return el;
+    }).map(function (el) {
+      return Buffer.from(hexToBytes(el));
+    }); // Sort elements
+
+    this.elements.sort(Buffer.compare); // Deduplicate elements
+
+    this.elements = this.bufDedup(this.elements); // Create layers
+
+    this.layers = this.getLayers(this.elements);
+  }
+
+  var _proto = MerkleTree.prototype;
+
+  _proto.getLayers = function getLayers(elements) {
+    if (elements.length === 0) {
+      return [[""]];
+    }
+
+    var layers = [];
+    layers.push(elements); // Get next layer until we reach the root=
+
+    while (layers[layers.length - 1].length > 1) {
+      // @ts-ignore
+      layers.push(this.getNextLayer(layers[layers.length - 1]));
+    }
+
+    return layers;
+  };
+
+  _proto.getNextLayer = function getNextLayer(elements) {
+    var _this = this;
+
+    return elements.reduce(function (layer, el, idx, arr) {
+      if (idx % 2 === 0) {
+        // Hash the current element with its pair element
+        layer.push(_this.combinedHash(el, arr[idx + 1]));
+      }
+
+      return layer;
+    }, []);
+  };
+
+  _proto.combinedHash = function combinedHash(first, second) {
+    if (!first) {
+      return second;
+    }
+
+    if (!second) {
+      return first;
+    }
+
+    return keccak256(this.sortAndConcat(first, second));
+  };
+
+  _proto.getRoot = function getRoot() {
+    return this.layers[this.layers.length - 1][0];
+  };
+
+  _proto.getHexRoot = function getHexRoot() {
+    return bufferToHex(this.getRoot());
+  };
+
+  _proto.getProof = function getProof(el) {
+    var _this2 = this;
+
+    var idx = this.bufIndexOf(el, this.elements);
+
+    if (idx === -1) {
+      throw new Error("Element does not exist in Merkle tree");
+    }
+
+    return this.layers.reduce(function (proof, layer) {
+      var pairElement = _this2.getPairElement(idx, layer);
+
+      if (pairElement) {
+        proof.push(pairElement);
+      }
+
+      idx = Math.floor(idx / 2);
+      return proof;
+    }, []);
+  } // external call - convert to buffer
+  ;
+
+  _proto.getHexProof = function getHexProof(_el) {
+    var el = Buffer.from(hexToBytes(_el));
+    var proof = this.getProof(el);
+    return this.bufArrToHexArr(proof);
+  };
+
+  _proto.getPairElement = function getPairElement(idx, layer) {
+    var pairIdx = idx % 2 === 0 ? idx + 1 : idx - 1;
+
+    if (pairIdx < layer.length) {
+      return layer[pairIdx];
+    } else {
+      return null;
+    }
+  };
+
+  _proto.bufIndexOf = function bufIndexOf(el, arr) {
+    var hash; // Convert element to 32 byte hash if it is not one already
+
+    if (el.length !== 32 || !Buffer.isBuffer(el)) {
+      hash = keccakFromString(el);
+    } else {
+      hash = el;
+    }
+
+    for (var i = 0; i < arr.length; i++) {
+      if (hash.equals(arr[i])) {
+        return i;
+      }
+    }
+
+    return -1;
+  };
+
+  _proto.bufDedup = function bufDedup(elements) {
+    return elements.filter(function (el, idx) {
+      return idx === 0 || !elements[idx - 1].equals(el);
+    });
+  };
+
+  _proto.bufArrToHexArr = function bufArrToHexArr(arr) {
+    if (arr.some(function (el) {
+      return !Buffer.isBuffer(el);
+    })) {
+      throw new Error("Array is not an array of buffers");
+    }
+
+    return arr.map(function (el) {
+      return "0x" + el.toString("hex");
+    });
+  };
+
+  _proto.sortAndConcat = function sortAndConcat() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return Buffer.concat([].concat(args).sort(Buffer.compare));
+  };
+
+  return MerkleTree;
+}();
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function scale(input, decimalPlaces) {
+  var unscaled = typeof input === "string" ? new BigNumber(input) : input;
+  var scalePow = new BigNumber(decimalPlaces.toString());
+  var scaleMul = new BigNumber(10).pow(scalePow);
+  return unscaled.times(scaleMul);
+}
+function loadTree(balances, decimals) {
+  if (decimals === void 0) {
+    decimals = 18;
+  }
+
+  var elements = [];
+  Object.keys(balances).forEach(function (address) {
+    var balance = scale(balances[address], decimals).toString(10);
+    var leaf = soliditySha3({
+      t: "address",
+      v: address
+    }, {
+      t: "uint",
+      v: balance
+    }); // @ts-ignore
+
+    elements.push(leaf);
+  });
+  return new MerkleTree(elements);
+}
+function bnum(val) {
+  var number = typeof val === "string" ? val : val ? val.toString() : "0";
+  return new BigNumber(number);
+}
+
+var IpfsService = /*#__PURE__*/function () {
+  function IpfsService() {}
+
+  var _proto = IpfsService.prototype;
+
+  _proto.get = /*#__PURE__*/function () {
+    var _get = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(hash, protocol) {
+      var _yield$axios$get, data;
+
+      return runtime_1.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              if (protocol === void 0) {
+                protocol = "ipfs";
+              }
+
+              _context.next = 3;
+              return axios.get("https://cloudflare-ipfs.com/" + protocol + "/" + hash);
+
+            case 3:
+              _yield$axios$get = _context.sent;
+              data = _yield$axios$get.data;
+              return _context.abrupt("return", data);
+
+            case 6:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    function get(_x, _x2) {
+      return _get.apply(this, arguments);
+    }
+
+    return get;
+  }();
+
+  return IpfsService;
+}();
+var ipfsService = /*#__PURE__*/new IpfsService();
+
+var ClaimService = /*#__PURE__*/function () {
+  function ClaimService(network, signer) {
+    this.network = network;
+    this.signer = signer;
+  }
+
+  var _proto = ClaimService.prototype;
+
+  _proto.getMultiTokensPendingClaims = /*#__PURE__*/function () {
+    var _getMultiTokensPendingClaims = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(account) {
+      var _this = this;
+
+      var tokenClaimsInfo, multiTokenPendingClaims, multiTokenPendingClaimsWithRewards;
+      return runtime_1.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return this.getTokenClaimsInfo();
+
+            case 2:
+              tokenClaimsInfo = _context.sent;
+
+              if (!(tokenClaimsInfo != null)) {
+                _context.next = 9;
+                break;
+              }
+
+              _context.next = 6;
+              return Promise.all(tokenClaimsInfo.map(function (tokenClaimInfo) {
+                return _this.getTokenPendingClaims(tokenClaimInfo, getAddress(account));
+              }));
+
+            case 6:
+              multiTokenPendingClaims = _context.sent;
+              multiTokenPendingClaimsWithRewards = multiTokenPendingClaims.filter(function (pendingClaim) {
+                return Number(pendingClaim.availableToClaim) > 0;
+              });
+              return _context.abrupt("return", multiTokenPendingClaimsWithRewards);
+
+            case 9:
+              return _context.abrupt("return", []);
+
+            case 10:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    }));
+
+    function getMultiTokensPendingClaims(_x) {
+      return _getMultiTokensPendingClaims.apply(this, arguments);
+    }
+
+    return getMultiTokensPendingClaims;
+  }();
+
+  _proto.getTokenPendingClaims = /*#__PURE__*/function () {
+    var _getTokenPendingClaims = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(tokenClaimInfo, account) {
+      var snapshot, weekStart, claimStatus, pendingWeeks, reports, claims, availableToClaim;
+      return runtime_1.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return this.getSnapshot(tokenClaimInfo.manifest);
+
+            case 2:
+              snapshot = _context2.sent;
+              weekStart = tokenClaimInfo.weekStart;
+              _context2.next = 6;
+              return this.getClaimStatus(Object.keys(snapshot).length, account, tokenClaimInfo);
+
+            case 6:
+              claimStatus = _context2.sent;
+              pendingWeeks = claimStatus.map(function (status, i) {
+                return [i + weekStart, status];
+              }).filter(function (_ref) {
+                var status = _ref[1];
+                return !status;
+              }).map(function (_ref2) {
+                var i = _ref2[0];
+                return i;
+              });
+              _context2.next = 10;
+              return this.getReports(snapshot, pendingWeeks);
+
+            case 10:
+              reports = _context2.sent;
+              claims = Object.entries(reports).filter(function (report) {
+                return report[1][account];
+              }).map(function (report) {
+                return {
+                  id: report[0],
+                  amount: report[1][account]
+                };
+              }); //console.log("claims", claims);
+
+              availableToClaim = claims.map(function (claim) {
+                return parseFloat(claim.amount);
+              }).reduce(function (total, amount) {
+                return total.plus(amount);
+              }, bnum(0)).toString();
+              return _context2.abrupt("return", {
+                claims: claims,
+                reports: reports,
+                tokenClaimInfo: tokenClaimInfo,
+                availableToClaim: availableToClaim
+              });
+
+            case 14:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, this);
+    }));
+
+    function getTokenPendingClaims(_x2, _x3) {
+      return _getTokenPendingClaims.apply(this, arguments);
+    }
+
+    return getTokenPendingClaims;
+  }();
+
+  _proto.multiTokenClaimRewards = /*#__PURE__*/function () {
+    var _multiTokenClaimRewards = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(account, multiTokenPendingClaims) {
+      var _this2 = this;
+
+      var multiTokenClaims;
+      return runtime_1.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.prev = 0;
+              _context3.next = 3;
+              return Promise.all(multiTokenPendingClaims.map(function (tokenPendingClaims, tokenIndex) {
+                return _this2.computeClaimProofs(tokenPendingClaims, getAddress(account), tokenIndex);
+              }));
+
+            case 3:
+              multiTokenClaims = _context3.sent;
+              return _context3.abrupt("return", flatten(multiTokenClaims));
+
+            case 7:
+              _context3.prev = 7;
+              _context3.t0 = _context3["catch"](0);
+              console.log("[Claim] Claim Rewards Error:", _context3.t0);
+              return _context3.abrupt("return", Promise.reject(_context3.t0));
+
+            case 11:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3, null, [[0, 7]]);
+    }));
+
+    function multiTokenClaimRewards(_x4, _x5) {
+      return _multiTokenClaimRewards.apply(this, arguments);
+    }
+
+    return multiTokenClaimRewards;
+  }();
+
+  _proto.computeClaimProofs = /*#__PURE__*/function () {
+    var _computeClaimProofs = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(tokenPendingClaims, account, tokenIndex) {
+      var _this3 = this;
+
+      return runtime_1.wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              return _context4.abrupt("return", Promise.all(tokenPendingClaims.claims.map(function (claim) {
+                var payload = {
+                  account: account,
+                  distributor: tokenPendingClaims.tokenClaimInfo.distributor,
+                  tokenIndex: tokenIndex,
+                  decimals: tokenPendingClaims.tokenClaimInfo.decimals,
+                  // objects must be cloned
+                  report: _extends({}, tokenPendingClaims.reports[claim.id]),
+                  claim: _extends({}, claim)
+                };
+                return _this3.computeClaimProof(payload);
+              })));
+
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4);
+    }));
+
+    function computeClaimProofs(_x6, _x7, _x8) {
+      return _computeClaimProofs.apply(this, arguments);
+    }
+
+    return computeClaimProofs;
+  }();
+
+  _proto.computeClaimProof = function computeClaimProof(payload) {
+    var report = payload.report,
+        account = payload.account,
+        claim = payload.claim,
+        distributor = payload.distributor,
+        tokenIndex = payload.tokenIndex,
+        decimals = payload.decimals;
+    var claimAmount = claim.amount;
+    var merkleTree = loadTree(report, decimals);
+    var scaledBalance = scale(claimAmount, decimals).toString(10);
+    var proof = merkleTree.getHexProof(soliditySha3({
+      t: "address",
+      v: account
+    }, {
+      t: "uint",
+      v: scaledBalance
+    }));
+    return [parseInt(claim.id), scaledBalance, distributor, tokenIndex, proof];
+  };
+
+  _proto.getTokenClaimsInfo = /*#__PURE__*/function () {
+    var _getTokenClaimsInfo = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5() {
+      var tokenClaims, multiTokenClaim, chainId;
+      return runtime_1.wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.prev = 0;
+              _context5.next = 3;
+              return axios.get("https://raw.githubusercontent.com/balancer-labs/frontend-v2/develop/src/services/claim/MultiTokenClaim.json");
+
+            case 3:
+              multiTokenClaim = _context5.sent;
+              chainId = networkChainIdMap[this.network];
+              tokenClaims = multiTokenClaim.data[chainId];
+              _context5.next = 11;
+              break;
+
+            case 8:
+              _context5.prev = 8;
+              _context5.t0 = _context5["catch"](0);
+              console.log("balancer multi token info error", _context5.t0);
+
+            case 11:
+              if (!(tokenClaims != null)) {
+                _context5.next = 13;
+                break;
+              }
+
+              return _context5.abrupt("return", tokenClaims.map(function (tokenClaim) {
+                return _extends({}, tokenClaim, {
+                  token: getAddress(tokenClaim.token),
+                  decimals: 18
+                });
+              }));
+
+            case 13:
+              return _context5.abrupt("return", null);
+
+            case 14:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5, this, [[0, 8]]);
+    }));
+
+    function getTokenClaimsInfo() {
+      return _getTokenClaimsInfo.apply(this, arguments);
+    }
+
+    return getTokenClaimsInfo;
+  }();
+
+  _proto.getSnapshot = /*#__PURE__*/function () {
+    var _getSnapshot = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(manifest) {
+      var response;
+      return runtime_1.wrap(function _callee6$(_context6) {
+        while (1) {
+          switch (_context6.prev = _context6.next) {
+            case 0:
+              _context6.prev = 0;
+              _context6.next = 3;
+              return axios.get(manifest);
+
+            case 3:
+              response = _context6.sent;
+              return _context6.abrupt("return", response.data || {});
+
+            case 7:
+              _context6.prev = 7;
+              _context6.t0 = _context6["catch"](0);
+              return _context6.abrupt("return", {});
+
+            case 10:
+            case "end":
+              return _context6.stop();
+          }
+        }
+      }, _callee6, null, [[0, 7]]);
+    }));
+
+    function getSnapshot(_x9) {
+      return _getSnapshot.apply(this, arguments);
+    }
+
+    return getSnapshot;
+  }();
+
+  _proto.getClaimStatus = /*#__PURE__*/function () {
+    var _getClaimStatus = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(totalWeeks, account, tokenClaimInfo) {
+      var _this4 = this;
+
+      var token, distributor, weekStart, claimStatusCalls, rootCalls, result, chunks, claimedResult, distributionRootResult;
+      return runtime_1.wrap(function _callee7$(_context7) {
+        while (1) {
+          switch (_context7.prev = _context7.next) {
+            case 0:
+              token = tokenClaimInfo.token, distributor = tokenClaimInfo.distributor, weekStart = tokenClaimInfo.weekStart;
+              claimStatusCalls = Array.from({
+                length: totalWeeks
+              }).map(function (_, i) {
+                return [stakingAddress[_this4.network][Dapp.BALANCER], "isClaimed", [token, distributor, weekStart + i, account]];
+              });
+              rootCalls = Array.from({
+                length: totalWeeks
+              }).map(function (_, i) {
+                return [stakingAddress[_this4.network][Dapp.BALANCER], "getDistributionRoot", [token, distributor, weekStart + i]];
+              });
+              _context7.prev = 3;
+              _context7.next = 6;
+              return multicall(this.network, this.signer, IBalancerMerkleOrchard.abi, [].concat(claimStatusCalls, rootCalls), {}, true);
+
+            case 6:
+              result = _context7.sent;
+
+              if (!(result.length > 0)) {
+                _context7.next = 12;
+                break;
+              }
+
+              chunks = chunk(flatten(result), totalWeeks);
+              claimedResult = chunks[0];
+              distributionRootResult = chunks[1];
+              return _context7.abrupt("return", claimedResult.filter(function (_, index) {
+                return distributionRootResult[index] !== ethers.constants.HashZero;
+              }));
+
+            case 12:
+              _context7.next = 17;
+              break;
+
+            case 14:
+              _context7.prev = 14;
+              _context7.t0 = _context7["catch"](3);
+              console.log("[Claim] Claim Status Error:", _context7.t0);
+
+            case 17:
+              return _context7.abrupt("return", []);
+
+            case 18:
+            case "end":
+              return _context7.stop();
+          }
+        }
+      }, _callee7, this, [[3, 14]]);
+    }));
+
+    function getClaimStatus(_x10, _x11, _x12) {
+      return _getClaimStatus.apply(this, arguments);
+    }
+
+    return getClaimStatus;
+  }();
+
+  _proto.getReports = /*#__PURE__*/function () {
+    var _getReports = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(snapshot, weeks) {
+      var reports;
+      return runtime_1.wrap(function _callee8$(_context8) {
+        while (1) {
+          switch (_context8.prev = _context8.next) {
+            case 0:
+              _context8.next = 2;
+              return Promise.all(weeks.filter(function (week) {
+                return snapshot[week] != null;
+              }).map(function (week) {
+                return ipfsService.get(snapshot[week]);
+              }));
+
+            case 2:
+              reports = _context8.sent;
+              return _context8.abrupt("return", Object.fromEntries(reports.map(function (report, i) {
+                return [weeks[i], report];
+              })));
+
+            case 4:
+            case "end":
+              return _context8.stop();
+          }
+        }
+      }, _callee8);
+    }));
+
+    function getReports(_x13, _x14) {
+      return _getReports.apply(this, arguments);
+    }
+
+    return getReports;
+  }();
+
+  return ClaimService;
+}();
+
+var Pool = /*#__PURE__*/function () {
+  function Pool(network, signer, poolLogic, mangerLogic, utils) {
+    this.network = network;
+    this.poolLogic = poolLogic;
+    this.address = poolLogic.address;
+    this.managerLogic = mangerLogic;
+    this.signer = signer;
+    this.utils = utils;
+  }
+  /**
+   * Return the assets with balances and deposit info of a pool
+   * @returns {Promise<FundComposition[]>} Composition of assets with balance, deposit info
+   */
+
+
+  var _proto = Pool.prototype;
+
+  _proto.getComposition =
+  /*#__PURE__*/
+  function () {
+    var _getComposition = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee() {
+      var result, fundComposition;
+      return runtime_1.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return this.managerLogic.getFundComposition();
+
+            case 2:
+              result = _context.sent;
+              fundComposition = result[0].map(function (item, index) {
+                var asset = item.asset,
+                    isDeposit = item.isDeposit;
+                return {
+                  asset: asset,
+                  isDeposit: isDeposit,
+                  balance: result[1][index],
+                  rate: result[2][index]
+                };
+              });
+              return _context.abrupt("return", fundComposition);
+
+            case 5:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    }));
+
+    function getComposition() {
+      return _getComposition.apply(this, arguments);
+    }
+
+    return getComposition;
+  }() //Invest functions
+
+  /**
+   * Approve the asset that can be deposited into a pool
+   * @param {string} nasset Address of deposit asset
+   * @param {BigNumber | string} amount Amount to be approved
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  ;
+
+  _proto.approveDeposit =
+  /*#__PURE__*/
+  function () {
+    var _approveDeposit = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(asset, amount, options) {
+      var iERC20, tx;
+      return runtime_1.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              if (options === void 0) {
+                options = null;
+              }
+
+              iERC20 = new ethers.Contract(asset, IERC20.abi, this.signer);
+              _context2.next = 4;
+              return iERC20.approve(this.address, amount, options);
+
+            case 4:
+              tx = _context2.sent;
+              return _context2.abrupt("return", tx);
+
+            case 6:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, this);
+    }));
+
+    function approveDeposit(_x, _x2, _x3) {
+      return _approveDeposit.apply(this, arguments);
+    }
+
+    return approveDeposit;
+  }()
+  /**
+   * Deposit  asset into a pool
+   * @param {string} asset Address of asset
+   * @param {BigNumber | string} amount Amount to be deposited
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  ;
+
+  _proto.deposit =
+  /*#__PURE__*/
+  function () {
+    var _deposit = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(asset, amount, options) {
+      var tx;
+      return runtime_1.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              if (options === void 0) {
+                options = null;
+              }
+
+              _context3.next = 3;
+              return this.poolLogic.deposit(asset, amount, options);
+
+            case 3:
+              tx = _context3.sent;
+              return _context3.abrupt("return", tx);
+
+            case 5:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3, this);
+    }));
+
+    function deposit(_x4, _x5, _x6) {
+      return _deposit.apply(this, arguments);
+    }
+
+    return deposit;
+  }()
+  /**
+   * Withdraw  assets from a pool
+   * @param fundTokenAmount Amount of pool tokens to be withdrawn
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  ;
+
+  _proto.withdraw =
+  /*#__PURE__*/
+  function () {
+    var _withdraw = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(fundTokenAmount, options) {
+      var tx;
+      return runtime_1.wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              if (options === void 0) {
+                options = null;
+              }
+
+              _context4.next = 3;
+              return this.poolLogic.withdraw(fundTokenAmount, options);
+
+            case 3:
+              tx = _context4.sent;
+              return _context4.abrupt("return", tx);
+
+            case 5:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4, this);
+    }));
+
+    function withdraw(_x7, _x8) {
+      return _withdraw.apply(this, arguments);
+    }
+
+    return withdraw;
+  }() //Manager functions
+
+  /**
+   * Approve the asset for trading and providing liquidity
+   * @param {Dapp} dapp Platform like Sushiswap or Uniswap
+   * @param {string} asset Address of asset
+   * @param @param {BigNumber | string} Amount to be approved
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  ;
+
+  _proto.approve =
+  /*#__PURE__*/
+  function () {
+    var _approve = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(dapp, asset, amount, options) {
+      var iERC20, approveTxData, tx;
+      return runtime_1.wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              if (options === void 0) {
+                options = null;
+              }
+
+              iERC20 = new ethers.utils.Interface(IERC20.abi);
+              approveTxData = iERC20.encodeFunctionData("approve", [routerAddress[this.network][dapp], amount]);
+              _context5.next = 5;
+              return this.poolLogic.execTransaction(asset, approveTxData, options);
+
+            case 5:
+              tx = _context5.sent;
+              return _context5.abrupt("return", tx);
+
+            case 7:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5, this);
+    }));
+
+    function approve(_x9, _x10, _x11, _x12) {
+      return _approve.apply(this, arguments);
+    }
+
+    return approve;
+  }()
+  /**
+   * Approve the liquidity pool token for staking
+   * @param {Dapp} dapp Platform like Sushiswap or Uniswap
+   * @param {string} asset Address of liquidity pool token
+   * @param {BigNumber | string} amount Aamount to be approved
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  ;
+
+  _proto.approveStaking =
   /*#__PURE__*/
   function () {
     var _approveStaking = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(dapp, asset, amount, options) {
@@ -5877,35 +7124,49 @@ var Pool = /*#__PURE__*/function () {
                 break;
               }
 
-              apiUrl = "https://api.1inch.exchange/v3.0/137/swap?fromTokenAddress=" + assetFrom + "&toTokenAddress=" + assetTo + "&amount=" + amountIn.toString() + "&fromAddress=" + this.address + "&destReceiver=" + this.address + "&slippage=" + slippage.toString() + "&disableEstimate=true";
+              apiUrl = "https://api.1inch.exchange/v4.0/137/swap?fromTokenAddress=" + assetFrom + "&toTokenAddress=" + assetTo + "&amount=" + amountIn.toString() + "&fromAddress=" + this.address + "&destReceiver=" + this.address + "&slippage=" + slippage.toString() + "&disableEstimate=true";
               _context7.next = 6;
               return axios.get(apiUrl);
 
             case 6:
               response = _context7.sent;
               swapTxData = response.data.tx.data;
-              _context7.next = 15;
+              _context7.next = 21;
               break;
 
             case 10:
-              iUniswapV2Router = new ethers.utils.Interface(IUniswapV2Router.abi);
+              if (!(dapp === Dapp.BALANCER)) {
+                _context7.next = 16;
+                break;
+              }
+
               _context7.next = 13;
-              return this.utils.getMinAmountOut(dapp, assetFrom, assetTo, amountIn, slippage);
+              return this.utils.getBalancerSwapTx(this, assetFrom, assetTo, amountIn, slippage);
 
             case 13:
+              swapTxData = _context7.sent;
+              _context7.next = 21;
+              break;
+
+            case 16:
+              iUniswapV2Router = new ethers.utils.Interface(IUniswapV2Router.abi);
+              _context7.next = 19;
+              return this.utils.getMinAmountOut(dapp, assetFrom, assetTo, amountIn, slippage);
+
+            case 19:
               minAmountOut = _context7.sent;
               swapTxData = iUniswapV2Router.encodeFunctionData(Transaction.SWAP, [amountIn, minAmountOut, [assetFrom, assetTo], this.address, Math.floor(Date.now() / 1000) + 60 * 20 // 20 minutes from the current Unix time
               ]);
 
-            case 15:
-              _context7.next = 17;
+            case 21:
+              _context7.next = 23;
               return this.poolLogic.execTransaction(routerAddress[this.network][dapp], swapTxData, options);
 
-            case 17:
+            case 23:
               tx = _context7.sent;
               return _context7.abrupt("return", tx);
 
-            case 19:
+            case 25:
             case "end":
               return _context7.stop();
           }
@@ -6096,7 +7357,7 @@ var Pool = /*#__PURE__*/function () {
 
             case 4:
               poolId = _context11.sent;
-              unStakeTxData = iMiniChefV2.encodeFunctionData(Transaction.UNSTAKE, [poolId, amount, this.address]);
+              unStakeTxData = iMiniChefV2.encodeFunctionData(Transaction.WITHDRAW, [poolId, amount, this.address]);
               _context11.next = 8;
               return this.poolLogic.execTransaction(stakingAddress[this.network][dapp], unStakeTxData, options);
 
@@ -6122,7 +7383,8 @@ var Pool = /*#__PURE__*/function () {
    * Lend asset to a lending pool
    * @param {Dapp} dapp Platform like Aave
    * @param {string} asset Asset
-   * @param  {BigNumber | string} amount Amount of asset to lend
+   * @param {BigNumber | string} amount Amount of asset to lend
+   * @param {number} referrralCode Code from Aave referral program
    * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
@@ -6131,26 +7393,30 @@ var Pool = /*#__PURE__*/function () {
   _proto.lend =
   /*#__PURE__*/
   function () {
-    var _lend = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee12(dapp, asset, amount, options) {
+    var _lend = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee12(dapp, asset, amount, referrralCode, options) {
       var iLendingPool, depositTxData, tx;
       return runtime_1.wrap(function _callee12$(_context12) {
         while (1) {
           switch (_context12.prev = _context12.next) {
             case 0:
+              if (referrralCode === void 0) {
+                referrralCode = 0;
+              }
+
               if (options === void 0) {
                 options = null;
               }
 
               iLendingPool = new ethers.utils.Interface(ILendingPool.abi);
-              depositTxData = iLendingPool.encodeFunctionData(Transaction.DEPOSIT, [asset, amount, this.address, 0]);
-              _context12.next = 5;
+              depositTxData = iLendingPool.encodeFunctionData(Transaction.DEPOSIT, [asset, amount, this.address, referrralCode]);
+              _context12.next = 6;
               return this.poolLogic.execTransaction(routerAddress[this.network][dapp], depositTxData, options);
 
-            case 5:
+            case 6:
               tx = _context12.sent;
               return _context12.abrupt("return", tx);
 
-            case 7:
+            case 8:
             case "end":
               return _context12.stop();
           }
@@ -6158,7 +7424,7 @@ var Pool = /*#__PURE__*/function () {
       }, _callee12, this);
     }));
 
-    function lend(_x42, _x43, _x44, _x45) {
+    function lend(_x42, _x43, _x44, _x45, _x46) {
       return _lend.apply(this, arguments);
     }
 
@@ -6204,7 +7470,7 @@ var Pool = /*#__PURE__*/function () {
       }, _callee13, this);
     }));
 
-    function withdrawDeposit(_x46, _x47, _x48, _x49) {
+    function withdrawDeposit(_x47, _x48, _x49, _x50) {
       return _withdrawDeposit.apply(this, arguments);
     }
 
@@ -6215,6 +7481,7 @@ var Pool = /*#__PURE__*/function () {
    * @param {Dapp} dapp Platform like Aave
    * @param {string} asset Asset
    * @param  {BigNumber | string} amount Amount of asset to lend
+   * @param {number} referrralCode Code from Aave referral program
    * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
@@ -6223,26 +7490,30 @@ var Pool = /*#__PURE__*/function () {
   _proto.borrow =
   /*#__PURE__*/
   function () {
-    var _borrow = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee14(dapp, asset, amount, options) {
+    var _borrow = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee14(dapp, asset, amount, referrralCode, options) {
       var iLendingPool, borrowTxData, tx;
       return runtime_1.wrap(function _callee14$(_context14) {
         while (1) {
           switch (_context14.prev = _context14.next) {
             case 0:
+              if (referrralCode === void 0) {
+                referrralCode = 0;
+              }
+
               if (options === void 0) {
                 options = null;
               }
 
               iLendingPool = new ethers.utils.Interface(ILendingPool.abi);
-              borrowTxData = iLendingPool.encodeFunctionData(Transaction.BORROW, [asset, amount, 2, 0, this.address]);
-              _context14.next = 5;
+              borrowTxData = iLendingPool.encodeFunctionData(Transaction.BORROW, [asset, amount, 2, referrralCode, this.address]);
+              _context14.next = 6;
               return this.poolLogic.execTransaction(routerAddress[this.network][dapp], borrowTxData, options);
 
-            case 5:
+            case 6:
               tx = _context14.sent;
               return _context14.abrupt("return", tx);
 
-            case 7:
+            case 8:
             case "end":
               return _context14.stop();
           }
@@ -6250,7 +7521,7 @@ var Pool = /*#__PURE__*/function () {
       }, _callee14, this);
     }));
 
-    function borrow(_x50, _x51, _x52, _x53) {
+    function borrow(_x51, _x52, _x53, _x54, _x55) {
       return _borrow.apply(this, arguments);
     }
 
@@ -6296,7 +7567,7 @@ var Pool = /*#__PURE__*/function () {
       }, _callee15, this);
     }));
 
-    function repay(_x54, _x55, _x56, _x57) {
+    function repay(_x56, _x57, _x58, _x59) {
       return _repay.apply(this, arguments);
     }
 
@@ -6346,7 +7617,7 @@ var Pool = /*#__PURE__*/function () {
       }, _callee16, this);
     }));
 
-    function harvestRewards(_x58, _x59, _x60) {
+    function harvestRewards(_x60, _x61, _x62) {
       return _harvestRewards.apply(this, arguments);
     }
 
@@ -6405,7 +7676,7 @@ var Pool = /*#__PURE__*/function () {
       }, _callee17, this);
     }));
 
-    function changeAssets(_x61, _x62) {
+    function changeAssets(_x63, _x64) {
       return _changeAssets.apply(this, arguments);
     }
 
@@ -6447,82 +7718,900 @@ var Pool = /*#__PURE__*/function () {
       }, _callee18, this);
     }));
 
-    function setTrader(_x63, _x64) {
+    function setTrader(_x65, _x66) {
       return _setTrader.apply(this, arguments);
     }
 
     return setTrader;
+  }()
+  /**
+   * Invest into a Balancer pool
+   * @param {string} poolId Balancer pool id
+   * @param {string[] | } assetsIn Array of balancer pool assets
+   * @param {BigNumber[] | string[]} amountsIn Array of maximum amounts to provide to pool
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  ;
+
+  _proto.joinBalancerPool =
+  /*#__PURE__*/
+  function () {
+    var _joinBalancerPool = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee19(poolId, assets, amountsIn, options) {
+      var joinPoolTxData, tx;
+      return runtime_1.wrap(function _callee19$(_context19) {
+        while (1) {
+          switch (_context19.prev = _context19.next) {
+            case 0:
+              if (options === void 0) {
+                options = null;
+              }
+
+              joinPoolTxData = this.utils.getBalancerJoinPoolTx(this, poolId, assets, amountsIn);
+              _context19.next = 4;
+              return this.poolLogic.execTransaction(routerAddress[this.network][Dapp.BALANCER], joinPoolTxData, options);
+
+            case 4:
+              tx = _context19.sent;
+              return _context19.abrupt("return", tx);
+
+            case 6:
+            case "end":
+              return _context19.stop();
+          }
+        }
+      }, _callee19, this);
+    }));
+
+    function joinBalancerPool(_x67, _x68, _x69, _x70) {
+      return _joinBalancerPool.apply(this, arguments);
+    }
+
+    return joinBalancerPool;
+  }()
+  /**
+   * Invest into a Balancer pool
+   * @param {string} poolId Balancer pool id
+   * @param {string[] | } assets Array of balancer pool assets
+   * @param {BigNumber | string } amount Amount of pool tokens to withdraw
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  ;
+
+  _proto.exitBalancerPool =
+  /*#__PURE__*/
+  function () {
+    var _exitBalancerPool = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee20(poolId, assets, amount, options) {
+      var exitPoolTxData, tx;
+      return runtime_1.wrap(function _callee20$(_context20) {
+        while (1) {
+          switch (_context20.prev = _context20.next) {
+            case 0:
+              if (options === void 0) {
+                options = null;
+              }
+
+              exitPoolTxData = this.utils.getBalancerExitPoolTx(this, poolId, assets, amount);
+              _context20.next = 4;
+              return this.poolLogic.execTransaction(routerAddress[this.network][Dapp.BALANCER], exitPoolTxData, options);
+
+            case 4:
+              tx = _context20.sent;
+              return _context20.abrupt("return", tx);
+
+            case 6:
+            case "end":
+              return _context20.stop();
+          }
+        }
+      }, _callee20, this);
+    }));
+
+    function exitBalancerPool(_x71, _x72, _x73, _x74) {
+      return _exitBalancerPool.apply(this, arguments);
+    }
+
+    return exitBalancerPool;
+  }()
+  /**
+   * Claim rewards from Balancer pools
+   * @param {string[]} assets Array of tokens being claimed
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  ;
+
+  _proto.harvestBalancerRewards =
+  /*#__PURE__*/
+  function () {
+    var _harvestBalancerRewards = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee21(options) {
+      var claimService, multiTokenPendingClaims, tokens, claims, iBalancerMerkleOrchard, harvestTxData, tx;
+      return runtime_1.wrap(function _callee21$(_context21) {
+        while (1) {
+          switch (_context21.prev = _context21.next) {
+            case 0:
+              if (options === void 0) {
+                options = null;
+              }
+
+              claimService = new ClaimService(this.network, this.signer);
+              _context21.next = 4;
+              return claimService.getMultiTokensPendingClaims(this.address);
+
+            case 4:
+              multiTokenPendingClaims = _context21.sent;
+              tokens = multiTokenPendingClaims.map(function (tokenPendingClaims) {
+                return tokenPendingClaims.tokenClaimInfo.token;
+              });
+              _context21.next = 8;
+              return claimService.multiTokenClaimRewards(this.address, multiTokenPendingClaims);
+
+            case 8:
+              claims = _context21.sent;
+              iBalancerMerkleOrchard = new ethers.utils.Interface(IBalancerMerkleOrchard.abi);
+              harvestTxData = iBalancerMerkleOrchard.encodeFunctionData(Transaction.CLAIM_DISTRIBIUTIONS, [this.address, claims, tokens]);
+              _context21.next = 13;
+              return this.poolLogic.execTransaction(stakingAddress[this.network][Dapp.BALANCER], harvestTxData, options);
+
+            case 13:
+              tx = _context21.sent;
+              return _context21.abrupt("return", tx);
+
+            case 15:
+            case "end":
+              return _context21.stop();
+          }
+        }
+      }, _callee21, this);
+    }));
+
+    function harvestBalancerRewards(_x75) {
+      return _harvestBalancerRewards.apply(this, arguments);
+    }
+
+    return harvestBalancerRewards;
+  }()
+  /**
+   * Claim rewards from Aave platform
+   * @param {string[]} assets Aave tokens (deposit/debt) hold by pool
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  ;
+
+  _proto.harvestAaveRewards =
+  /*#__PURE__*/
+  function () {
+    var _harvestAaveRewards = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee22(assets, options) {
+      var aaveIncentivesAddress, iAaveIncentivesController, aaveIncentivesController, amount, claimTxData, tx;
+      return runtime_1.wrap(function _callee22$(_context22) {
+        while (1) {
+          switch (_context22.prev = _context22.next) {
+            case 0:
+              if (options === void 0) {
+                options = null;
+              }
+
+              aaveIncentivesAddress = stakingAddress[this.network][Dapp.AAVE];
+              iAaveIncentivesController = new ethers.utils.Interface(IAaveIncentivesController.abi);
+              aaveIncentivesController = new ethers.Contract(aaveIncentivesAddress, iAaveIncentivesController, this.signer);
+              _context22.next = 6;
+              return aaveIncentivesController.getUserUnclaimedRewards(this.address);
+
+            case 6:
+              amount = _context22.sent;
+              claimTxData = iAaveIncentivesController.encodeFunctionData(Transaction.CLAIM_REWARDS, [assets, amount, this.address]);
+              _context22.next = 10;
+              return this.poolLogic.execTransaction(aaveIncentivesAddress, claimTxData, options);
+
+            case 10:
+              tx = _context22.sent;
+              return _context22.abrupt("return", tx);
+
+            case 12:
+            case "end":
+              return _context22.stop();
+          }
+        }
+      }, _callee22, this);
+    }));
+
+    function harvestAaveRewards(_x76, _x77) {
+      return _harvestAaveRewards.apply(this, arguments);
+    }
+
+    return harvestAaveRewards;
   }();
 
   return Pool;
 }();
 
-var abi$7 = [
+var abi$9 = [
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "_feeToSetter",
+				type: "address"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "constructor"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "token0",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "token1",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "pair",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		name: "PairCreated",
+		type: "event"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		name: "allPairs",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "allPairsLength",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "tokenA",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "tokenB",
+				type: "address"
+			}
+		],
+		name: "createPair",
+		outputs: [
+			{
+				internalType: "address",
+				name: "pair",
+				type: "address"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "feeTo",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "feeToSetter",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		name: "getPair",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "migrator",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "pairCodeHash",
+		outputs: [
+			{
+				internalType: "bytes32",
+				name: "",
+				type: "bytes32"
+			}
+		],
+		stateMutability: "pure",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "_feeTo",
+				type: "address"
+			}
+		],
+		name: "setFeeTo",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "_feeToSetter",
+				type: "address"
+			}
+		],
+		name: "setFeeToSetter",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "_migrator",
+				type: "address"
+			}
+		],
+		name: "setMigrator",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	}
+];
+var UniswapV2Factory = {
+	abi: abi$9
+};
+
+var abi$a = [
+	{
+		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"
+	},
+	{
+		constant: true,
+		inputs: [
+		],
+		name: "DOMAIN_SEPARATOR",
+		outputs: [
+			{
+				internalType: "bytes32",
+				name: "",
+				type: "bytes32"
+			}
+		],
+		payable: false,
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		constant: true,
+		inputs: [
+		],
+		name: "MINIMUM_LIQUIDITY",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		payable: false,
+		stateMutability: "pure",
+		type: "function"
+	},
+	{
+		constant: true,
+		inputs: [
+		],
+		name: "PERMIT_TYPEHASH",
+		outputs: [
+			{
+				internalType: "bytes32",
+				name: "",
+				type: "bytes32"
+			}
+		],
+		payable: false,
+		stateMutability: "pure",
+		type: "function"
+	},
+	{
+		constant: true,
+		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			}
+		],
+		name: "allowance",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		payable: false,
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		constant: false,
+		inputs: [
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "approve",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		payable: false,
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		constant: true,
+		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			}
+		],
+		name: "balanceOf",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		payable: false,
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		constant: false,
+		inputs: [
+			{
+				internalType: "address",
+				name: "to",
+				type: "address"
+			}
+		],
+		name: "burn",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "amount0",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "amount1",
+				type: "uint256"
+			}
+		],
+		payable: false,
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		constant: true,
+		inputs: [
+		],
+		name: "decimals",
+		outputs: [
+			{
+				internalType: "uint8",
+				name: "",
+				type: "uint8"
+			}
+		],
+		payable: false,
+		stateMutability: "pure",
+		type: "function"
+	},
 	{
+		constant: true,
 		inputs: [
+		],
+		name: "factory",
+		outputs: [
 			{
 				internalType: "address",
-				name: "_feeToSetter",
+				name: "",
 				type: "address"
 			}
 		],
-		stateMutability: "nonpayable",
-		type: "constructor"
+		payable: false,
+		stateMutability: "view",
+		type: "function"
 	},
 	{
-		anonymous: false,
+		constant: true,
 		inputs: [
+		],
+		name: "getReserves",
+		outputs: [
 			{
-				indexed: true,
-				internalType: "address",
-				name: "token0",
-				type: "address"
+				internalType: "uint112",
+				name: "reserve0",
+				type: "uint112"
 			},
 			{
-				indexed: true,
+				internalType: "uint112",
+				name: "reserve1",
+				type: "uint112"
+			},
+			{
+				internalType: "uint32",
+				name: "blockTimestampLast",
+				type: "uint32"
+			}
+		],
+		payable: false,
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		constant: false,
+		inputs: [
+			{
 				internalType: "address",
-				name: "token1",
+				name: "",
 				type: "address"
 			},
 			{
-				indexed: false,
 				internalType: "address",
-				name: "pair",
+				name: "",
 				type: "address"
-			},
+			}
+		],
+		name: "initialize",
+		outputs: [
+		],
+		payable: false,
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		constant: true,
+		inputs: [
+		],
+		name: "kLast",
+		outputs: [
 			{
-				indexed: false,
 				internalType: "uint256",
 				name: "",
 				type: "uint256"
 			}
 		],
-		name: "PairCreated",
-		type: "event"
+		payable: false,
+		stateMutability: "view",
+		type: "function"
 	},
 	{
+		constant: false,
 		inputs: [
+			{
+				internalType: "address",
+				name: "to",
+				type: "address"
+			}
+		],
+		name: "mint",
+		outputs: [
 			{
 				internalType: "uint256",
-				name: "",
+				name: "liquidity",
 				type: "uint256"
 			}
 		],
-		name: "allPairs",
+		payable: false,
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		constant: true,
+		inputs: [
+		],
+		name: "name",
 		outputs: [
 			{
-				internalType: "address",
+				internalType: "string",
 				name: "",
-				type: "address"
+				type: "string"
 			}
 		],
-		stateMutability: "view",
+		payable: false,
+		stateMutability: "pure",
 		type: "function"
 	},
 	{
+		constant: true,
 		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			}
 		],
-		name: "allPairsLength",
+		name: "nonces",
 		outputs: [
 			{
 				internalType: "uint256",
@@ -6530,75 +8619,167 @@ var abi$7 = [
 				type: "uint256"
 			}
 		],
+		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
+		constant: false,
 		inputs: [
 			{
 				internalType: "address",
-				name: "tokenA",
+				name: "owner",
 				type: "address"
 			},
 			{
 				internalType: "address",
-				name: "tokenB",
+				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: "createPair",
+		name: "permit",
 		outputs: [
-			{
-				internalType: "address",
-				name: "pair",
-				type: "address"
-			}
 		],
+		payable: false,
 		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
+		constant: true,
 		inputs: [
 		],
-		name: "feeTo",
+		name: "price0CumulativeLast",
 		outputs: [
 			{
-				internalType: "address",
+				internalType: "uint256",
 				name: "",
-				type: "address"
+				type: "uint256"
 			}
 		],
+		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
+		constant: true,
 		inputs: [
 		],
-		name: "feeToSetter",
+		name: "price1CumulativeLast",
 		outputs: [
 			{
-				internalType: "address",
+				internalType: "uint256",
 				name: "",
-				type: "address"
+				type: "uint256"
 			}
 		],
+		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
+		constant: false,
 		inputs: [
 			{
 				internalType: "address",
-				name: "",
+				name: "to",
 				type: "address"
+			}
+		],
+		name: "skim",
+		outputs: [
+		],
+		payable: false,
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		constant: false,
+		inputs: [
+			{
+				internalType: "uint256",
+				name: "amount0Out",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "amount1Out",
+				type: "uint256"
 			},
 			{
 				internalType: "address",
-				name: "",
+				name: "to",
 				type: "address"
+			},
+			{
+				internalType: "bytes",
+				name: "data",
+				type: "bytes"
 			}
 		],
-		name: "getPair",
+		name: "swap",
+		outputs: [
+		],
+		payable: false,
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		constant: true,
+		inputs: [
+		],
+		name: "symbol",
+		outputs: [
+			{
+				internalType: "string",
+				name: "",
+				type: "string"
+			}
+		],
+		payable: false,
+		stateMutability: "pure",
+		type: "function"
+	},
+	{
+		constant: false,
+		inputs: [
+		],
+		name: "sync",
+		outputs: [
+		],
+		payable: false,
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		constant: true,
+		inputs: [
+		],
+		name: "token0",
 		outputs: [
 			{
 				internalType: "address",
@@ -6606,13 +8787,15 @@ var abi$7 = [
 				type: "address"
 			}
 		],
+		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
+		constant: true,
 		inputs: [
 		],
-		name: "migrator",
+		name: "token1",
 		outputs: [
 			{
 				internalType: "address",
@@ -6620,71 +8803,104 @@ var abi$7 = [
 				type: "address"
 			}
 		],
+		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
+		constant: true,
 		inputs: [
 		],
-		name: "pairCodeHash",
+		name: "totalSupply",
 		outputs: [
 			{
-				internalType: "bytes32",
+				internalType: "uint256",
 				name: "",
-				type: "bytes32"
+				type: "uint256"
 			}
 		],
-		stateMutability: "pure",
+		payable: false,
+		stateMutability: "view",
 		type: "function"
 	},
 	{
+		constant: false,
 		inputs: [
 			{
 				internalType: "address",
-				name: "_feeTo",
+				name: "to",
 				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
 			}
 		],
-		name: "setFeeTo",
+		name: "transfer",
 		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
 		],
+		payable: false,
 		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
+		constant: false,
 		inputs: [
 			{
 				internalType: "address",
-				name: "_feeToSetter",
+				name: "from",
 				type: "address"
-			}
-		],
-		name: "setFeeToSetter",
-		outputs: [
-		],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		inputs: [
+			},
 			{
 				internalType: "address",
-				name: "_migrator",
+				name: "to",
 				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
 			}
 		],
-		name: "setMigrator",
+		name: "transferFrom",
 		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
 		],
+		payable: false,
 		stateMutability: "nonpayable",
 		type: "function"
 	}
 ];
-var UniswapV2Factory = {
-	abi: abi$7
+var evm = {
+	bytecode: {
+		linkReferences: {
+		},
+		object: "",
+		opcodes: "",
+		sourceMap: ""
+	},
+	deployedBytecode: {
+		linkReferences: {
+		},
+		object: "",
+		opcodes: "",
+		sourceMap: ""
+	}
 };
-
-var abi$8 = [
+var UniswapV2Pair = {
+	abi: abi$a,
+	evm: evm,
+	"interface": [
 	{
 		anonymous: false,
 		inputs: [
@@ -7410,50 +9626,78 @@ var abi$8 = [
 		stateMutability: "nonpayable",
 		type: "function"
 	}
-];
-var evm = {
-	bytecode: {
-		linkReferences: {
-		},
-		object: "",
-		opcodes: "",
-		sourceMap: ""
-	},
-	deployedBytecode: {
-		linkReferences: {
-		},
-		object: "",
-		opcodes: "",
-		sourceMap: ""
-	}
+]
 };
-var UniswapV2Pair = {
-	abi: abi$8,
-	evm: evm,
-	"interface": [
+
+var abi$b = [
+	{
+		inputs: [
+			{
+				internalType: "contract IAuthorizer",
+				name: "authorizer",
+				type: "address"
+			},
+			{
+				internalType: "contract IWETH",
+				name: "weth",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "pauseWindowDuration",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "bufferPeriodDuration",
+				type: "uint256"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "constructor"
+	},
 	{
 		anonymous: false,
 		inputs: [
 			{
 				indexed: true,
-				internalType: "address",
-				name: "owner",
+				internalType: "contract IAuthorizer",
+				name: "newAuthorizer",
+				type: "address"
+			}
+		],
+		name: "AuthorizerChanged",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "contract IERC20",
+				name: "token",
 				type: "address"
 			},
 			{
 				indexed: true,
 				internalType: "address",
-				name: "spender",
+				name: "sender",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "recipient",
 				type: "address"
 			},
 			{
 				indexed: false,
 				internalType: "uint256",
-				name: "value",
+				name: "amount",
 				type: "uint256"
 			}
 		],
-		name: "Approval",
+		name: "ExternalBalanceTransfer",
 		type: "event"
 	},
 	{
@@ -7461,55 +9705,192 @@ var UniswapV2Pair = {
 		inputs: [
 			{
 				indexed: true,
-				internalType: "address",
-				name: "sender",
+				internalType: "contract IFlashLoanRecipient",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "contract IERC20",
+				name: "token",
 				type: "address"
 			},
 			{
 				indexed: false,
 				internalType: "uint256",
-				name: "amount0",
+				name: "amount",
 				type: "uint256"
 			},
 			{
 				indexed: false,
 				internalType: "uint256",
-				name: "amount1",
+				name: "feeAmount",
 				type: "uint256"
+			}
+		],
+		name: "FlashLoan",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "user",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "contract IERC20",
+				name: "token",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "int256",
+				name: "delta",
+				type: "int256"
+			}
+		],
+		name: "InternalBalanceChanged",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: false,
+				internalType: "bool",
+				name: "paused",
+				type: "bool"
+			}
+		],
+		name: "PausedStateChanged",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "bytes32",
+				name: "poolId",
+				type: "bytes32"
 			},
 			{
 				indexed: true,
 				internalType: "address",
-				name: "to",
+				name: "liquidityProvider",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "contract IERC20[]",
+				name: "tokens",
+				type: "address[]"
+			},
+			{
+				indexed: false,
+				internalType: "int256[]",
+				name: "deltas",
+				type: "int256[]"
+			},
+			{
+				indexed: false,
+				internalType: "uint256[]",
+				name: "protocolFeeAmounts",
+				type: "uint256[]"
+			}
+		],
+		name: "PoolBalanceChanged",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "bytes32",
+				name: "poolId",
+				type: "bytes32"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "assetManager",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "contract IERC20",
+				name: "token",
 				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "int256",
+				name: "cashDelta",
+				type: "int256"
+			},
+			{
+				indexed: false,
+				internalType: "int256",
+				name: "managedDelta",
+				type: "int256"
 			}
 		],
-		name: "Burn",
+		name: "PoolBalanceManaged",
 		type: "event"
 	},
 	{
 		anonymous: false,
 		inputs: [
+			{
+				indexed: true,
+				internalType: "bytes32",
+				name: "poolId",
+				type: "bytes32"
+			},
 			{
 				indexed: true,
 				internalType: "address",
-				name: "sender",
+				name: "poolAddress",
 				type: "address"
 			},
 			{
 				indexed: false,
-				internalType: "uint256",
-				name: "amount0",
-				type: "uint256"
+				internalType: "enum IVault.PoolSpecialization",
+				name: "specialization",
+				type: "uint8"
+			}
+		],
+		name: "PoolRegistered",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "relayer",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "sender",
+				type: "address"
 			},
 			{
 				indexed: false,
-				internalType: "uint256",
-				name: "amount1",
-				type: "uint256"
+				internalType: "bool",
+				name: "approved",
+				type: "bool"
 			}
 		],
-		name: "Mint",
+		name: "RelayerApprovalChanged",
 		type: "event"
 	},
 	{
@@ -7517,39 +9898,33 @@ var UniswapV2Pair = {
 		inputs: [
 			{
 				indexed: true,
-				internalType: "address",
-				name: "sender",
-				type: "address"
+				internalType: "bytes32",
+				name: "poolId",
+				type: "bytes32"
 			},
 			{
-				indexed: false,
-				internalType: "uint256",
-				name: "amount0In",
-				type: "uint256"
+				indexed: true,
+				internalType: "contract IERC20",
+				name: "tokenIn",
+				type: "address"
 			},
 			{
-				indexed: false,
-				internalType: "uint256",
-				name: "amount1In",
-				type: "uint256"
+				indexed: true,
+				internalType: "contract IERC20",
+				name: "tokenOut",
+				type: "address"
 			},
 			{
 				indexed: false,
 				internalType: "uint256",
-				name: "amount0Out",
+				name: "amountIn",
 				type: "uint256"
 			},
 			{
 				indexed: false,
 				internalType: "uint256",
-				name: "amount1Out",
+				name: "amountOut",
 				type: "uint256"
-			},
-			{
-				indexed: true,
-				internalType: "address",
-				name: "to",
-				type: "address"
 			}
 		],
 		name: "Swap",
@@ -7559,19 +9934,19 @@ var UniswapV2Pair = {
 		anonymous: false,
 		inputs: [
 			{
-				indexed: false,
-				internalType: "uint112",
-				name: "reserve0",
-				type: "uint112"
+				indexed: true,
+				internalType: "bytes32",
+				name: "poolId",
+				type: "bytes32"
 			},
 			{
 				indexed: false,
-				internalType: "uint112",
-				name: "reserve1",
-				type: "uint112"
+				internalType: "contract IERC20[]",
+				name: "tokens",
+				type: "address[]"
 			}
 		],
-		name: "Sync",
+		name: "TokensDeregistered",
 		type: "event"
 	},
 	{
@@ -7579,584 +9954,877 @@ var UniswapV2Pair = {
 		inputs: [
 			{
 				indexed: true,
-				internalType: "address",
-				name: "from",
-				type: "address"
+				internalType: "bytes32",
+				name: "poolId",
+				type: "bytes32"
 			},
 			{
-				indexed: true,
-				internalType: "address",
-				name: "to",
-				type: "address"
+				indexed: false,
+				internalType: "contract IERC20[]",
+				name: "tokens",
+				type: "address[]"
 			},
 			{
 				indexed: false,
-				internalType: "uint256",
-				name: "value",
-				type: "uint256"
+				internalType: "address[]",
+				name: "assetManagers",
+				type: "address[]"
 			}
 		],
-		name: "Transfer",
+		name: "TokensRegistered",
 		type: "event"
 	},
 	{
-		constant: true,
 		inputs: [
 		],
-		name: "DOMAIN_SEPARATOR",
+		name: "WETH",
 		outputs: [
 			{
-				internalType: "bytes32",
+				internalType: "contract IWETH",
 				name: "",
-				type: "bytes32"
+				type: "address"
 			}
 		],
-		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
-		],
-		name: "MINIMUM_LIQUIDITY",
-		outputs: [
+			{
+				internalType: "enum IVault.SwapKind",
+				name: "kind",
+				type: "uint8"
+			},
+			{
+				components: [
+					{
+						internalType: "bytes32",
+						name: "poolId",
+						type: "bytes32"
+					},
+					{
+						internalType: "uint256",
+						name: "assetInIndex",
+						type: "uint256"
+					},
+					{
+						internalType: "uint256",
+						name: "assetOutIndex",
+						type: "uint256"
+					},
+					{
+						internalType: "uint256",
+						name: "amount",
+						type: "uint256"
+					},
+					{
+						internalType: "bytes",
+						name: "userData",
+						type: "bytes"
+					}
+				],
+				internalType: "struct IVault.BatchSwapStep[]",
+				name: "swaps",
+				type: "tuple[]"
+			},
+			{
+				internalType: "contract IAsset[]",
+				name: "assets",
+				type: "address[]"
+			},
+			{
+				components: [
+					{
+						internalType: "address",
+						name: "sender",
+						type: "address"
+					},
+					{
+						internalType: "bool",
+						name: "fromInternalBalance",
+						type: "bool"
+					},
+					{
+						internalType: "address payable",
+						name: "recipient",
+						type: "address"
+					},
+					{
+						internalType: "bool",
+						name: "toInternalBalance",
+						type: "bool"
+					}
+				],
+				internalType: "struct IVault.FundManagement",
+				name: "funds",
+				type: "tuple"
+			},
+			{
+				internalType: "int256[]",
+				name: "limits",
+				type: "int256[]"
+			},
 			{
 				internalType: "uint256",
-				name: "",
+				name: "deadline",
 				type: "uint256"
 			}
 		],
-		payable: false,
-		stateMutability: "pure",
+		name: "batchSwap",
+		outputs: [
+			{
+				internalType: "int256[]",
+				name: "assetDeltas",
+				type: "int256[]"
+			}
+		],
+		stateMutability: "payable",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
-		],
-		name: "PERMIT_TYPEHASH",
-		outputs: [
 			{
 				internalType: "bytes32",
-				name: "",
+				name: "poolId",
 				type: "bytes32"
+			},
+			{
+				internalType: "contract IERC20[]",
+				name: "tokens",
+				type: "address[]"
 			}
 		],
-		payable: false,
-		stateMutability: "pure",
+		name: "deregisterTokens",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
+			{
+				internalType: "bytes32",
+				name: "poolId",
+				type: "bytes32"
+			},
 			{
 				internalType: "address",
-				name: "owner",
+				name: "sender",
 				type: "address"
 			},
 			{
-				internalType: "address",
-				name: "spender",
+				internalType: "address payable",
+				name: "recipient",
 				type: "address"
+			},
+			{
+				components: [
+					{
+						internalType: "contract IAsset[]",
+						name: "assets",
+						type: "address[]"
+					},
+					{
+						internalType: "uint256[]",
+						name: "minAmountsOut",
+						type: "uint256[]"
+					},
+					{
+						internalType: "bytes",
+						name: "userData",
+						type: "bytes"
+					},
+					{
+						internalType: "bool",
+						name: "toInternalBalance",
+						type: "bool"
+					}
+				],
+				internalType: "struct IVault.ExitPoolRequest",
+				name: "request",
+				type: "tuple"
 			}
 		],
-		name: "allowance",
+		name: "exitPool",
 		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
 		],
-		payable: false,
-		stateMutability: "view",
+		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
 			{
-				internalType: "address",
-				name: "spender",
+				internalType: "contract IFlashLoanRecipient",
+				name: "recipient",
 				type: "address"
 			},
 			{
-				internalType: "uint256",
-				name: "value",
-				type: "uint256"
+				internalType: "contract IERC20[]",
+				name: "tokens",
+				type: "address[]"
+			},
+			{
+				internalType: "uint256[]",
+				name: "amounts",
+				type: "uint256[]"
+			},
+			{
+				internalType: "bytes",
+				name: "userData",
+				type: "bytes"
 			}
 		],
-		name: "approve",
+		name: "flashLoan",
 		outputs: [
-			{
-				internalType: "bool",
-				name: "",
-				type: "bool"
-			}
 		],
-		payable: false,
 		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
 			{
-				internalType: "address",
-				name: "owner",
-				type: "address"
+				internalType: "bytes4",
+				name: "selector",
+				type: "bytes4"
 			}
 		],
-		name: "balanceOf",
+		name: "getActionId",
 		outputs: [
 			{
-				internalType: "uint256",
+				internalType: "bytes32",
 				name: "",
-				type: "uint256"
+				type: "bytes32"
 			}
 		],
-		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
+		],
+		name: "getAuthorizer",
+		outputs: [
 			{
-				internalType: "address",
-				name: "to",
+				internalType: "contract IAuthorizer",
+				name: "",
 				type: "address"
 			}
 		],
-		name: "burn",
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "getDomainSeparator",
 		outputs: [
 			{
-				internalType: "uint256",
-				name: "amount0",
-				type: "uint256"
-			},
-			{
-				internalType: "uint256",
-				name: "amount1",
-				type: "uint256"
+				internalType: "bytes32",
+				name: "",
+				type: "bytes32"
 			}
 		],
-		payable: false,
-		stateMutability: "nonpayable",
+		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
+			{
+				internalType: "address",
+				name: "user",
+				type: "address"
+			},
+			{
+				internalType: "contract IERC20[]",
+				name: "tokens",
+				type: "address[]"
+			}
 		],
-		name: "decimals",
+		name: "getInternalBalance",
 		outputs: [
 			{
-				internalType: "uint8",
-				name: "",
-				type: "uint8"
+				internalType: "uint256[]",
+				name: "balances",
+				type: "uint256[]"
 			}
 		],
-		payable: false,
-		stateMutability: "pure",
+		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
+			{
+				internalType: "address",
+				name: "user",
+				type: "address"
+			}
 		],
-		name: "factory",
+		name: "getNextNonce",
 		outputs: [
 			{
-				internalType: "address",
+				internalType: "uint256",
 				name: "",
-				type: "address"
+				type: "uint256"
 			}
 		],
-		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
 		],
-		name: "getReserves",
+		name: "getPausedState",
 		outputs: [
 			{
-				internalType: "uint112",
-				name: "reserve0",
-				type: "uint112"
+				internalType: "bool",
+				name: "paused",
+				type: "bool"
 			},
 			{
-				internalType: "uint112",
-				name: "reserve1",
-				type: "uint112"
+				internalType: "uint256",
+				name: "pauseWindowEndTime",
+				type: "uint256"
 			},
 			{
-				internalType: "uint32",
-				name: "blockTimestampLast",
-				type: "uint32"
+				internalType: "uint256",
+				name: "bufferPeriodEndTime",
+				type: "uint256"
 			}
 		],
-		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
+			{
+				internalType: "bytes32",
+				name: "poolId",
+				type: "bytes32"
+			}
+		],
+		name: "getPool",
+		outputs: [
 			{
 				internalType: "address",
 				name: "",
 				type: "address"
 			},
 			{
-				internalType: "address",
+				internalType: "enum IVault.PoolSpecialization",
 				name: "",
-				type: "address"
+				type: "uint8"
 			}
 		],
-		name: "initialize",
-		outputs: [
-		],
-		payable: false,
-		stateMutability: "nonpayable",
+		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
+			{
+				internalType: "bytes32",
+				name: "poolId",
+				type: "bytes32"
+			},
+			{
+				internalType: "contract IERC20",
+				name: "token",
+				type: "address"
+			}
 		],
-		name: "kLast",
+		name: "getPoolTokenInfo",
 		outputs: [
 			{
 				internalType: "uint256",
-				name: "",
+				name: "cash",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "managed",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "lastChangeBlock",
 				type: "uint256"
+			},
+			{
+				internalType: "address",
+				name: "assetManager",
+				type: "address"
 			}
 		],
-		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
 			{
-				internalType: "address",
-				name: "to",
-				type: "address"
+				internalType: "bytes32",
+				name: "poolId",
+				type: "bytes32"
 			}
 		],
-		name: "mint",
+		name: "getPoolTokens",
 		outputs: [
+			{
+				internalType: "contract IERC20[]",
+				name: "tokens",
+				type: "address[]"
+			},
+			{
+				internalType: "uint256[]",
+				name: "balances",
+				type: "uint256[]"
+			},
 			{
 				internalType: "uint256",
-				name: "liquidity",
+				name: "lastChangeBlock",
 				type: "uint256"
 			}
 		],
-		payable: false,
-		stateMutability: "nonpayable",
+		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
 		],
-		name: "name",
+		name: "getProtocolFeesCollector",
 		outputs: [
 			{
-				internalType: "string",
+				internalType: "contract ProtocolFeesCollector",
 				name: "",
-				type: "string"
+				type: "address"
 			}
 		],
-		payable: false,
-		stateMutability: "pure",
+		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
 			{
 				internalType: "address",
-				name: "owner",
+				name: "user",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "relayer",
 				type: "address"
 			}
 		],
-		name: "nonces",
+		name: "hasApprovedRelayer",
 		outputs: [
 			{
-				internalType: "uint256",
+				internalType: "bool",
 				name: "",
-				type: "uint256"
+				type: "bool"
 			}
 		],
-		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
 			{
-				internalType: "address",
-				name: "owner",
-				type: "address"
+				internalType: "bytes32",
+				name: "poolId",
+				type: "bytes32"
 			},
 			{
 				internalType: "address",
-				name: "spender",
+				name: "sender",
 				type: "address"
 			},
 			{
-				internalType: "uint256",
-				name: "value",
-				type: "uint256"
-			},
-			{
-				internalType: "uint256",
-				name: "deadline",
-				type: "uint256"
-			},
-			{
-				internalType: "uint8",
-				name: "v",
-				type: "uint8"
+				internalType: "address",
+				name: "recipient",
+				type: "address"
 			},
 			{
-				internalType: "bytes32",
-				name: "r",
-				type: "bytes32"
-			},
+				components: [
+					{
+						internalType: "contract IAsset[]",
+						name: "assets",
+						type: "address[]"
+					},
+					{
+						internalType: "uint256[]",
+						name: "maxAmountsIn",
+						type: "uint256[]"
+					},
+					{
+						internalType: "bytes",
+						name: "userData",
+						type: "bytes"
+					},
+					{
+						internalType: "bool",
+						name: "fromInternalBalance",
+						type: "bool"
+					}
+				],
+				internalType: "struct IVault.JoinPoolRequest",
+				name: "request",
+				type: "tuple"
+			}
+		],
+		name: "joinPool",
+		outputs: [
+		],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [
 			{
-				internalType: "bytes32",
-				name: "s",
-				type: "bytes32"
+				components: [
+					{
+						internalType: "enum IVault.PoolBalanceOpKind",
+						name: "kind",
+						type: "uint8"
+					},
+					{
+						internalType: "bytes32",
+						name: "poolId",
+						type: "bytes32"
+					},
+					{
+						internalType: "contract IERC20",
+						name: "token",
+						type: "address"
+					},
+					{
+						internalType: "uint256",
+						name: "amount",
+						type: "uint256"
+					}
+				],
+				internalType: "struct IVault.PoolBalanceOp[]",
+				name: "ops",
+				type: "tuple[]"
 			}
 		],
-		name: "permit",
+		name: "managePoolBalance",
 		outputs: [
 		],
-		payable: false,
 		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
+			{
+				components: [
+					{
+						internalType: "enum IVault.UserBalanceOpKind",
+						name: "kind",
+						type: "uint8"
+					},
+					{
+						internalType: "contract IAsset",
+						name: "asset",
+						type: "address"
+					},
+					{
+						internalType: "uint256",
+						name: "amount",
+						type: "uint256"
+					},
+					{
+						internalType: "address",
+						name: "sender",
+						type: "address"
+					},
+					{
+						internalType: "address payable",
+						name: "recipient",
+						type: "address"
+					}
+				],
+				internalType: "struct IVault.UserBalanceOp[]",
+				name: "ops",
+				type: "tuple[]"
+			}
 		],
-		name: "price0CumulativeLast",
+		name: "manageUserBalance",
 		outputs: [
+		],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [
 			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
+				internalType: "enum IVault.SwapKind",
+				name: "kind",
+				type: "uint8"
+			},
+			{
+				components: [
+					{
+						internalType: "bytes32",
+						name: "poolId",
+						type: "bytes32"
+					},
+					{
+						internalType: "uint256",
+						name: "assetInIndex",
+						type: "uint256"
+					},
+					{
+						internalType: "uint256",
+						name: "assetOutIndex",
+						type: "uint256"
+					},
+					{
+						internalType: "uint256",
+						name: "amount",
+						type: "uint256"
+					},
+					{
+						internalType: "bytes",
+						name: "userData",
+						type: "bytes"
+					}
+				],
+				internalType: "struct IVault.BatchSwapStep[]",
+				name: "swaps",
+				type: "tuple[]"
+			},
+			{
+				internalType: "contract IAsset[]",
+				name: "assets",
+				type: "address[]"
+			},
+			{
+				components: [
+					{
+						internalType: "address",
+						name: "sender",
+						type: "address"
+					},
+					{
+						internalType: "bool",
+						name: "fromInternalBalance",
+						type: "bool"
+					},
+					{
+						internalType: "address payable",
+						name: "recipient",
+						type: "address"
+					},
+					{
+						internalType: "bool",
+						name: "toInternalBalance",
+						type: "bool"
+					}
+				],
+				internalType: "struct IVault.FundManagement",
+				name: "funds",
+				type: "tuple"
 			}
 		],
-		payable: false,
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		constant: true,
-		inputs: [
-		],
-		name: "price1CumulativeLast",
+		name: "queryBatchSwap",
 		outputs: [
 			{
-				internalType: "uint256",
+				internalType: "int256[]",
 				name: "",
-				type: "uint256"
+				type: "int256[]"
 			}
 		],
-		payable: false,
-		stateMutability: "view",
+		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
 			{
-				internalType: "address",
-				name: "to",
-				type: "address"
+				internalType: "enum IVault.PoolSpecialization",
+				name: "specialization",
+				type: "uint8"
 			}
 		],
-		name: "skim",
+		name: "registerPool",
 		outputs: [
+			{
+				internalType: "bytes32",
+				name: "",
+				type: "bytes32"
+			}
 		],
-		payable: false,
 		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
 			{
-				internalType: "uint256",
-				name: "amount0Out",
-				type: "uint256"
-			},
-			{
-				internalType: "uint256",
-				name: "amount1Out",
-				type: "uint256"
+				internalType: "bytes32",
+				name: "poolId",
+				type: "bytes32"
 			},
 			{
-				internalType: "address",
-				name: "to",
-				type: "address"
+				internalType: "contract IERC20[]",
+				name: "tokens",
+				type: "address[]"
 			},
 			{
-				internalType: "bytes",
-				name: "data",
-				type: "bytes"
+				internalType: "address[]",
+				name: "assetManagers",
+				type: "address[]"
 			}
 		],
-		name: "swap",
+		name: "registerTokens",
 		outputs: [
 		],
-		payable: false,
 		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
-		],
-		name: "symbol",
-		outputs: [
 			{
-				internalType: "string",
-				name: "",
-				type: "string"
+				internalType: "contract IAuthorizer",
+				name: "newAuthorizer",
+				type: "address"
 			}
 		],
-		payable: false,
-		stateMutability: "pure",
-		type: "function"
-	},
-	{
-		constant: false,
-		inputs: [
-		],
-		name: "sync",
+		name: "setAuthorizer",
 		outputs: [
 		],
-		payable: false,
 		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: true,
-		inputs: [
-		],
-		name: "token0",
-		outputs: [
-			{
-				internalType: "address",
-				name: "",
-				type: "address"
-			}
-		],
-		payable: false,
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		constant: true,
 		inputs: [
-		],
-		name: "token1",
-		outputs: [
 			{
-				internalType: "address",
-				name: "",
-				type: "address"
+				internalType: "bool",
+				name: "paused",
+				type: "bool"
 			}
 		],
-		payable: false,
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		constant: true,
-		inputs: [
-		],
-		name: "totalSupply",
+		name: "setPaused",
 		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
 		],
-		payable: false,
-		stateMutability: "view",
+		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
 			{
 				internalType: "address",
-				name: "to",
+				name: "sender",
 				type: "address"
 			},
 			{
-				internalType: "uint256",
-				name: "value",
-				type: "uint256"
-			}
-		],
-		name: "transfer",
-		outputs: [
+				internalType: "address",
+				name: "relayer",
+				type: "address"
+			},
 			{
 				internalType: "bool",
-				name: "",
+				name: "approved",
 				type: "bool"
 			}
 		],
-		payable: false,
+		name: "setRelayerApproval",
+		outputs: [
+		],
 		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
 			{
-				internalType: "address",
-				name: "from",
-				type: "address"
+				components: [
+					{
+						internalType: "bytes32",
+						name: "poolId",
+						type: "bytes32"
+					},
+					{
+						internalType: "enum IVault.SwapKind",
+						name: "kind",
+						type: "uint8"
+					},
+					{
+						internalType: "contract IAsset",
+						name: "assetIn",
+						type: "address"
+					},
+					{
+						internalType: "contract IAsset",
+						name: "assetOut",
+						type: "address"
+					},
+					{
+						internalType: "uint256",
+						name: "amount",
+						type: "uint256"
+					},
+					{
+						internalType: "bytes",
+						name: "userData",
+						type: "bytes"
+					}
+				],
+				internalType: "struct IVault.SingleSwap",
+				name: "singleSwap",
+				type: "tuple"
 			},
 			{
-				internalType: "address",
-				name: "to",
-				type: "address"
+				components: [
+					{
+						internalType: "address",
+						name: "sender",
+						type: "address"
+					},
+					{
+						internalType: "bool",
+						name: "fromInternalBalance",
+						type: "bool"
+					},
+					{
+						internalType: "address payable",
+						name: "recipient",
+						type: "address"
+					},
+					{
+						internalType: "bool",
+						name: "toInternalBalance",
+						type: "bool"
+					}
+				],
+				internalType: "struct IVault.FundManagement",
+				name: "funds",
+				type: "tuple"
 			},
 			{
 				internalType: "uint256",
-				name: "value",
+				name: "limit",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "deadline",
 				type: "uint256"
 			}
 		],
-		name: "transferFrom",
+		name: "swap",
 		outputs: [
 			{
-				internalType: "bool",
-				name: "",
-				type: "bool"
+				internalType: "uint256",
+				name: "amountCalculated",
+				type: "uint256"
 			}
 		],
-		payable: false,
-		stateMutability: "nonpayable",
+		stateMutability: "payable",
 		type: "function"
+	},
+	{
+		stateMutability: "payable",
+		type: "receive"
 	}
-]
+];
+var IBalancerV2Vault = {
+	abi: abi$b
 };
 
 var Utils = /*#__PURE__*/function () {
@@ -8390,6 +11058,145 @@ var Utils = /*#__PURE__*/function () {
     return getMinAmountOut;
   }();
 
+  _proto.getBalancerSwapTx = /*#__PURE__*/function () {
+    var _getBalancerSwapTx = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(pool, assetFrom, assetTo, amountIn, slippage // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+      var sor, isFetched, swapType, _yield$sor$getSwaps, swaps, tokenAddresses, returnAmount, minimumAmountOut, iBalancerV2Vault, swap, swapTx, limits, _swapTx;
+
+      return runtime_1.wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              sor = new SOR(this.signer.provider, networkChainIdMap[this.network], balancerSubgraph[this.network]); // isFetched will be true on success
+
+              _context5.next = 3;
+              return sor.fetchPools();
+
+            case 3:
+              isFetched = _context5.sent;
+
+              if (isFetched) {
+                _context5.next = 6;
+                break;
+              }
+
+              throw new Error("Error fetching balancer pools");
+
+            case 6:
+              swapType = SwapTypes.SwapExactIn;
+              _context5.next = 9;
+              return sor.getSwaps(assetFrom, assetTo, swapType, ethers.BigNumber.from(amountIn));
+
+            case 9:
+              _yield$sor$getSwaps = _context5.sent;
+              swaps = _yield$sor$getSwaps.swaps;
+              tokenAddresses = _yield$sor$getSwaps.tokenAddresses;
+              returnAmount = _yield$sor$getSwaps.returnAmount;
+              minimumAmountOut = returnAmount.mul(10000 - slippage * 100).div(10000);
+              iBalancerV2Vault = new ethers.utils.Interface(IBalancerV2Vault.abi);
+
+              if (!(swaps.length === 1)) {
+                _context5.next = 21;
+                break;
+              }
+
+              swap = swaps[0]; //do single swap
+
+              swapTx = iBalancerV2Vault.encodeFunctionData("swap", [[swap.poolId, SwapTypes.SwapExactIn, tokenAddresses[swap.assetInIndex], tokenAddresses[swap.assetOutIndex], swap.amount, swap.userData], [pool.address, false, pool.address, false], minimumAmountOut, Math.floor(Date.now() / 1000) + 60 * 20 // 20 minutes from the current Unix time
+              ]);
+              return _context5.abrupt("return", swapTx);
+
+            case 21:
+              // Limits:
+              // +ve means max to send
+              // -ve mean min to receive
+              // For a multihop the intermediate tokens should be 0
+              limits = [];
+              tokenAddresses.forEach(function (token, i) {
+                if (token.toLowerCase() === assetFrom.toLowerCase()) {
+                  limits[i] = amountIn.toString();
+                } else if (token.toLowerCase() === assetTo.toLowerCase()) {
+                  limits[i] = minimumAmountOut.mul(-1).toString();
+                } else {
+                  limits[i] = "0";
+                }
+              });
+              _swapTx = iBalancerV2Vault.encodeFunctionData("batchSwap", [SwapTypes.SwapExactIn, swaps, tokenAddresses, [pool.address, false, pool.address, false], limits, Math.floor(Date.now() / 1000) + 60 * 20 // 20 minutes from the current Unix time
+              ]);
+              return _context5.abrupt("return", _swapTx);
+
+            case 25:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5, this);
+    }));
+
+    function getBalancerSwapTx(_x13, _x14, _x15, _x16, _x17) {
+      return _getBalancerSwapTx.apply(this, arguments);
+    }
+
+    return getBalancerSwapTx;
+  }();
+
+  _proto.getBalancerJoinPoolTx = /*#__PURE__*/function () {
+    var _getBalancerJoinPoolTx = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(pool, balancerPoolId, assets, amountsIn // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+      var iBalancerV2Vault, txData, joinPoolTx;
+      return runtime_1.wrap(function _callee6$(_context6) {
+        while (1) {
+          switch (_context6.prev = _context6.next) {
+            case 0:
+              iBalancerV2Vault = new ethers.utils.Interface(IBalancerV2Vault.abi);
+              txData = [balancerPoolId, pool.address, pool.address, [assets, amountsIn, ethers.utils.defaultAbiCoder.encode(["uint256", "uint256[]", "uint256"], [1, amountsIn, 0]), false]];
+              joinPoolTx = iBalancerV2Vault.encodeFunctionData("joinPool", txData);
+              return _context6.abrupt("return", joinPoolTx);
+
+            case 4:
+            case "end":
+              return _context6.stop();
+          }
+        }
+      }, _callee6);
+    }));
+
+    function getBalancerJoinPoolTx(_x18, _x19, _x20, _x21) {
+      return _getBalancerJoinPoolTx.apply(this, arguments);
+    }
+
+    return getBalancerJoinPoolTx;
+  }();
+
+  _proto.getBalancerExitPoolTx = /*#__PURE__*/function () {
+    var _getBalancerExitPoolTx = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(pool, balancerPoolId, assets, amount // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+      var minimumAmountOut, iBalancerV2Vault, txData, exitPoolTx;
+      return runtime_1.wrap(function _callee7$(_context7) {
+        while (1) {
+          switch (_context7.prev = _context7.next) {
+            case 0:
+              minimumAmountOut = new Array(assets.length).fill(0);
+              iBalancerV2Vault = new ethers.utils.Interface(IBalancerV2Vault.abi);
+              txData = [balancerPoolId, pool.address, pool.address, [assets, minimumAmountOut, ethers.utils.defaultAbiCoder.encode(["uint256", "uint256"], [1, amount]), false]];
+              exitPoolTx = iBalancerV2Vault.encodeFunctionData("exitPool", txData);
+              return _context7.abrupt("return", exitPoolTx);
+
+            case 5:
+            case "end":
+              return _context7.stop();
+          }
+        }
+      }, _callee7);
+    }));
+
+    function getBalancerExitPoolTx(_x22, _x23, _x24, _x25) {
+      return _getBalancerExitPoolTx.apply(this, arguments);
+    }
+
+    return getBalancerExitPoolTx;
+  }();
+
   return Utils;
 }();