@dhedge/v2-sdk 1.1.1 → 1.2.0

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 { groupBy, 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,22 @@ 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, _Network$POLYGON, _routerAddress, _Network$POLYGON2, _dappFactoryAddress, _Network$POLYGON3, _stakingAddress, _networkChainIdMap, _balancerSubgraph, _multiCallAddress;
 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] = "0x1111111254fb6c44bAC0beD2854e76F90643097d", _Network$POLYGON[Dapp.QUICKSWAP] = "0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff", _Network$POLYGON), _routerAddress);
+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,253 +5593,1624 @@ 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 =
-  /*#__PURE__*/
-  function () {
+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 MultiTokenClaim = {
+	"1": [
+	{
+		label: "BAL",
+		distributor: "0xd2EB7Bd802A7CA68d9AcD209bEc4E664A9abDD7b",
+		token: "0xba100000625a3754423978a60c9317c58a424e3d",
+		manifest: "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current.json",
+		weekStart: 52
+	},
+	{
+		label: "UNN",
+		distributor: "0xBfbd6e720ffdF0497f69C95E5C03a4861C65A6E7",
+		token: "0x226f7b842E0F0120b7E194D05432b3fd14773a9D",
+		manifest: "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-union.json",
+		weekStart: 1
+	},
+	{
+		label: "BANK",
+		distributor: "0x9d20FE66eC5Dd15a3D3213556534C77cA20318bE",
+		token: "0x2d94AA3e47d9D5024503Ca8491fcE9A2fB4DA198",
+		manifest: "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-bankless.json",
+		weekStart: 1
+	},
+	{
+		label: "NOTE",
+		distributor: "0xF1C2dD9bD863f2444086B739383F1043E6b88F69",
+		token: "0xcfeaead4947f0705a14ec42ac3d44129e1ef3ed5",
+		manifest: "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-note.json",
+		weekStart: 1
+	},
+	{
+		label: "NEXO",
+		distributor: "0x0000000000000000000000000000000000000000",
+		token: "0xB62132e35a6c13ee1EE0f84dC5d40bad8d815206",
+		manifest: "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-nexo.json",
+		weekStart: 1
+	}
+],
+	"42": [
+	{
+		label: "BAL",
+		distributor: "0x95FaE1C936B4Cd6c5099d7A705D792ee6aC9FEc3",
+		token: "0x41286Bb1D3E870f3F750eB7E1C25d7E48c8A1Ac7",
+		manifest: "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/sample-tree/reports-kovan/_current.json",
+		weekStart: 52
+	},
+	{
+		label: "DAI",
+		distributor: "0x95FaE1C936B4Cd6c5099d7A705D792ee6aC9FEc3",
+		token: "0x04DF6e4121c27713ED22341E7c7Df330F56f289B",
+		manifest: "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/sample-tree/reports-kovan/_current-dai.json",
+		weekStart: 1
+	}
+],
+	"137": [
+	{
+		label: "BAL",
+		distributor: "0xd2EB7Bd802A7CA68d9AcD209bEc4E664A9abDD7b",
+		token: "0x9a71012b13ca4d3d0cdc72a177df3ef03b0e76a3",
+		manifest: "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-polygon.json",
+		weekStart: 1
+	},
+	{
+		label: "WMATIC",
+		distributor: "0x087A7AFB6975A2837453BE685EB6272576c0bC06",
+		token: "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
+		manifest: "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-wmatic-polygon.json",
+		weekStart: 1
+	},
+	{
+		label: "WMATIC",
+		distributor: "0xBd44C01EC7d623372B4572247afB6231eDD8486F",
+		token: "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
+		manifest: "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-wmatic-polygon.json",
+		weekStart: 4
+	},
+	{
+		label: "WMATIC",
+		distributor: "0x632208491602Dd205da8Cb9C0BA98620fc19854A",
+		token: "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
+		manifest: "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-wmatic-polygon.json",
+		weekStart: 5
+	},
+	{
+		label: "TUSD",
+		distributor: "0x09f3010ec0f6d72ef8ff2008f8e756d60482c9a8",
+		token: "0x2e1ad108ff1d8c782fcbbb89aad783ac49586756",
+		manifest: "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-tusd-polygon.json",
+		weekStart: 1
+	}
+],
+	"42161": [
+	{
+		label: "BAL",
+		distributor: "0xd2EB7Bd802A7CA68d9AcD209bEc4E664A9abDD7b",
+		token: "0x040d1EdC9569d4Bab2D15287Dc5A4F10F56a56B8",
+		manifest: "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-arbitrum.json",
+		weekStart: 6
+	},
+	{
+		label: "MCB",
+		distributor: "0x25c646adf184051b35a405b9aaeba321e8d5342a",
+		token: "0x4e352cf164e64adcbad318c3a1e222e9eba4ce42",
+		manifest: "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-mcdex-arbitrum.json",
+		weekStart: 4
+	},
+	{
+		label: "PICKLE",
+		distributor: "0xf02CeB58d549E4b403e8F85FBBaEe4c5dfA47c01",
+		token: "0x965772e0e9c84b6f359c8597c891108dcf1c5b1a",
+		manifest: "https://raw.githubusercontent.com/balancer-labs/bal-mining-scripts/master/reports/_current-pickle-arbitrum.json",
+		weekStart: 4
+	}
+]
+};
+
+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:
+              tokenClaimsInfo = this.getTokenClaimsInfo();
+
+              if (!(tokenClaimsInfo != null)) {
+                _context.next = 7;
+                break;
+              }
+
+              _context.next = 4;
+              return Promise.all(tokenClaimsInfo.map(function (tokenClaimInfo) {
+                return _this.getTokenPendingClaims(tokenClaimInfo, getAddress(account));
+              }));
+
+            case 4:
+              multiTokenPendingClaims = _context.sent;
+              multiTokenPendingClaimsWithRewards = multiTokenPendingClaims.filter(function (pendingClaim) {
+                return Number(pendingClaim.availableToClaim) > 0;
+              });
+              return _context.abrupt("return", multiTokenPendingClaimsWithRewards);
+
+            case 7:
+              return _context.abrupt("return", []);
+
+            case 8:
+            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.getMultiTokensCurrentRewardsEstimate = /*#__PURE__*/function () {
+    var _getMultiTokensCurrentRewardsEstimate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(account) {
+      var response, multiTokenLiquidityProviders, multiTokenCurrentRewardsEstimate, multiTokenLiquidityProvidersByToken, _i, _multiTokenLiquidityP, _liquidityProvider$fi, _liquidityProvider$fi2, _multiTokenLiquidityP2, token, liquidityProvider, rewards, velocity;
+
+      return runtime_1.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.prev = 0;
+              _context3.next = 3;
+              return axios.get("https://api.balancer.finance/liquidity-mining/v1/liquidity-provider-multitoken/" + account);
+
+            case 3:
+              response = _context3.sent;
+
+              if (!response.data.success) {
+                _context3.next = 10;
+                break;
+              }
+
+              multiTokenLiquidityProviders = response.data.result["liquidity-providers"].filter(function (incentive) {
+                return incentive.chain_id === 137;
+              }).map(function (incentive) {
+                return _extends({}, incentive, {
+                  token_address: getAddress(incentive.token_address)
+                });
+              });
+              multiTokenCurrentRewardsEstimate = [];
+              multiTokenLiquidityProvidersByToken = Object.entries(groupBy(multiTokenLiquidityProviders, "token_address"));
+
+              for (_i = 0, _multiTokenLiquidityP = multiTokenLiquidityProvidersByToken; _i < _multiTokenLiquidityP.length; _i++) {
+                _multiTokenLiquidityP2 = _multiTokenLiquidityP[_i], token = _multiTokenLiquidityP2[0], liquidityProvider = _multiTokenLiquidityP2[1];
+                rewards = liquidityProvider.reduce(function (total, _ref3) {
+                  var current_estimate = _ref3.current_estimate;
+                  return total.plus(current_estimate);
+                }, bnum(0)).toString();
+                velocity = (_liquidityProvider$fi = (_liquidityProvider$fi2 = liquidityProvider.find(function (liquidityProvider) {
+                  return Number(liquidityProvider.velocity) > 0;
+                })) == null ? void 0 : _liquidityProvider$fi2.velocity.toString()) != null ? _liquidityProvider$fi : "0";
+
+                if (Number(rewards) > 0) {
+                  multiTokenCurrentRewardsEstimate.push({
+                    rewards: rewards,
+                    velocity: velocity,
+                    token: getAddress(token)
+                  });
+                }
+              }
+
+              return _context3.abrupt("return", {
+                data: multiTokenCurrentRewardsEstimate,
+                timestamp: response.data.result.current_timestamp
+              });
+
+            case 10:
+              _context3.next = 15;
+              break;
+
+            case 12:
+              _context3.prev = 12;
+              _context3.t0 = _context3["catch"](0);
+              console.log("[Claim] Current Rewards Estimate Error", _context3.t0);
+
+            case 15:
+              return _context3.abrupt("return", {
+                data: [],
+                timestamp: null
+              });
+
+            case 16:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3, null, [[0, 12]]);
+    }));
+
+    function getMultiTokensCurrentRewardsEstimate(_x4) {
+      return _getMultiTokensCurrentRewardsEstimate.apply(this, arguments);
+    }
+
+    return getMultiTokensCurrentRewardsEstimate;
+  }();
+
+  _proto.multiTokenClaimRewards = /*#__PURE__*/function () {
+    var _multiTokenClaimRewards = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(account, multiTokenPendingClaims) {
+      var _this2 = this;
+
+      var multiTokenClaims;
+      return runtime_1.wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.prev = 0;
+              _context4.next = 3;
+              return Promise.all(multiTokenPendingClaims.map(function (tokenPendingClaims, tokenIndex) {
+                return _this2.computeClaimProofs(tokenPendingClaims, getAddress(account), tokenIndex);
+              }));
+
+            case 3:
+              multiTokenClaims = _context4.sent;
+              return _context4.abrupt("return", flatten(multiTokenClaims));
+
+            case 7:
+              _context4.prev = 7;
+              _context4.t0 = _context4["catch"](0);
+              console.log("[Claim] Claim Rewards Error:", _context4.t0);
+              return _context4.abrupt("return", Promise.reject(_context4.t0));
+
+            case 11:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4, null, [[0, 7]]);
+    }));
+
+    function multiTokenClaimRewards(_x5, _x6) {
+      return _multiTokenClaimRewards.apply(this, arguments);
+    }
+
+    return multiTokenClaimRewards;
+  }();
+
+  _proto.computeClaimProofs = /*#__PURE__*/function () {
+    var _computeClaimProofs = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(tokenPendingClaims, account, tokenIndex) {
+      var _this3 = this;
+
+      return runtime_1.wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              return _context5.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 _context5.stop();
+          }
+        }
+      }, _callee5);
+    }));
+
+    function computeClaimProofs(_x7, _x8, _x9) {
+      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 = function getTokenClaimsInfo() {
+    var tokenClaims = MultiTokenClaim["137"];
+
+    if (tokenClaims != null) {
+      return tokenClaims.map(function (tokenClaim) {
+        return _extends({}, tokenClaim, {
+          token: getAddress(tokenClaim.token),
+          decimals: 18
+        });
+      });
+    }
+
+    return null;
+  };
+
+  _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(_x10) {
+      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(_x11, _x12, _x13) {
+      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(_x14, _x15) {
+      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) {
       var iERC20, approveTxData, tx;
       return runtime_1.wrap(function _callee6$(_context6) {
@@ -5884,28 +7285,42 @@ var Pool = /*#__PURE__*/function () {
             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 +7511,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);
 
@@ -6452,77 +7867,895 @@ var Pool = /*#__PURE__*/function () {
     }
 
     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(_x65, _x66, _x67, _x68) {
+      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(_x69, _x70, _x71, _x72) {
+      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(_x73) {
+      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(_x74, _x75) {
+      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 +8763,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 +8931,15 @@ var abi$7 = [
 				type: "address"
 			}
 		],
+		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
+		constant: true,
 		inputs: [
 		],
-		name: "migrator",
+		name: "token1",
 		outputs: [
 			{
 				internalType: "address",
@@ -6620,71 +8947,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 +9770,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 +9849,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 +10042,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 +10078,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 +10098,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 +11202,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;
 }();