@dhedge/v2-sdk 1.1.1 → 1.2.0

package/src/test/pool.test.ts

@@ -1,31 +1,15 @@
 import { Dhedge } from "..";
 import { Network } from "../types";
+import { TEST_POOL } from "./constants";
 
 import { wallet } from "./wallet";
 
-const myPool = "0x279ac4c05154fd72a636fce1bc25c50966141fd0";
-//const weth = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
-//const usdt = "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
-//const dai = "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063";
-//const usdc = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
-
-// const sushi = "0x0b3F868E0BE5597D5DB7fEB59E1CADBb0fdDa50a";
-// const wmatic = "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270";
-// const lpUsdcWeth = "0x34965ba0ac2451A34a0471F04CCa3F990b8dea27";
-//const lpUsdcDai = "0xCD578F016888B57F1b1e3f887f392F0159E26747";
-//const amusdc = "0x1a13F4Ca1d028320A707D99520AbFefca3998b7F";
-//const lpUsdcUsdt = "0x4b1f1e2435a9c96f7330faea190ef6a7c8d70001";
-// const tradeAmountUsdc = "1000000";
-// const liquidityAmountUsdt = "1000000";
-// const lpUsdcWETHAmount = "10951027354";
-// const depositAmountUsdc = "100000";
-
 let dhedge: Dhedge;
 
 jest.setTimeout(100000);
 
 // const options = {
-//   gasLimit: 1000000,
+//   gasLimit: 5000000,
 //   gasPrice: ethers.utils.parseUnits("35", "gwei")
 // };
 
@@ -35,123 +19,16 @@ describe("pool", () => {
   });
 
   it("checks fund composition", async () => {
-    const pool = await dhedge.loadPool(myPool);
+    const pool = await dhedge.loadPool(TEST_POOL);
     const result = await pool.getComposition();
+    console.log(result);
     expect(result.length).toBeGreaterThan(0);
   });
 
   // it("withdraws 1.00002975 fund tokens", async () => {
-  //   const pool = await dhedge.loadPool(myPool)
+  //   const pool = await dhedge.loadPool(myPool);
   //   const result = await pool.withdraw("1000029750000000000");
   //   expect(result).toBeGreaterThan(0);
-  // })
-
-  // it("approves unlimited USDC on 1Inch", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.approve(
-  //       Dapp.ONEINCH,
-  //       usdc,
-  //       ethers.constants.MaxInt256,
-  //       options
-  //     );
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("trades 1 USDC into WETH on 1Inch", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.trade(
-  //       Dapp.ONEINCH,
-  //       usdc,
-  //       weth,
-  //       "1000000",
-  //       0.5,
-  //       options
-  //     );
-  //     console.log("1inch trade", result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("lends 1 USDC into Aave lending pool", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.lend(Dapp.AAVE, weth, "86567951006165", options);
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("withdraws 1 USDC from Aave lending pool", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.withdrawDeposit(
-  //       Dapp.AAVE,
-  //       weth,
-  //       "86567951006165",
-  //       options
-  //     );
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("borrows 0.0001 WETH from Aave lending pool", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.borrow(Dapp.AAVE, weth, "100000000000000");
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("reapys 0.0001 WETH to Aave lending pool", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.repay(Dapp.AAVE, weth, "100000000000000", options);
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("trades 1 FRAX into WETH on quickswap", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.trade(
-  //       Dapp.ONEINCH,
-  //       usdc,
-  //       weth,
-  //       "300000",
-  //       0.5,
-  //       options
-  //     );
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
   // });
 
   // it("approve USDC balance of User for Deposit", async () => {
@@ -211,114 +88,6 @@ describe("pool", () => {
   //   expect(result).not.toBe(null);
   // });
 
-  // it("adds Liquidity into a WETH/USDT pool on sushi", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   const liquidityAmountWETH = await dhedge.utils.getLpAmount(
-  //     Dapp.SUSHISWAP,
-  //     usdt,
-  //     weth,
-  //     liquidityAmountUsdt
-  //   );
-  //   try {
-  //     result = await pool.addLiquidity(
-  //       Dapp.SUSHISWAP,
-  //       usdt,
-  //       weth,
-  //       liquidityAmountUsdt,
-  //       liquidityAmountWETH
-  //     );
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("approves unlimited LP USDC/WETH on sushiswap for staking", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.approveStaking(
-  //       Dapp.SUSHISWAP,
-  //       lpUsdcDai,
-  //       ethers.constants.MaxUint256
-  //     );
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("deposit 0.1 USDC into Pool", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.deposit(usdc, depositAmountUsdc);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("adds LpUSDCWETH to enabled assets", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   const newAssets: AssetEnabled[] = [
-  //     { asset: usdc, isDeposit: true },
-  //     { asset: weth, isDeposit: true },
-  //     { asset: usdt, isDeposit: true },
-  //     { asset: lpUsdcWeth, isDeposit: false }
-  //   ];
-  //   try {
-  //     result = await pool.changeAssets(newAssets);
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("unStakes USDC/DAI LP on sushi", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   const balance = "11013356749811";
-  //   try {
-  //     result = await pool.unStake(Dapp.SUSHISWAP, lpUsdcDai, balance);
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("trades entire sushi balance into usdc", async () => {
-  //   let result: FundComposition[] = [];
-  //   let tx;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.getComposition();
-  //     const sushiBalance = result.find(e => e.asset === sushi)?.balance;
-  //     if (sushiBalance) {
-  //       tx = await pool.trade(Dapp.SUSHISWAP, sushi, usdc, sushiBalance);
-  //       console.log(tx);
-  //     }
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result.length).toBeGreaterThan(0);
-  // });
-
-  // it("harvests USDC/DAI LP Farm on sushi", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.harvestRewards(Dapp.SUSHISWAP, lpUsdcdai);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
   // it("sets a trader account", async () => {
   //   let result;
   //   const newTrader = "0xC52D9a9D9b05a01887871216fF02bA4235e8503d";
@@ -331,17 +100,4 @@ describe("pool", () => {
   //   }
   //   expect(result).not.toBe(null);
   // });
-
-  // it("removes liquidity from  USDC/DAI LP on sushi", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   const balance = "11013356749811";
-  //   try {
-  //     result = await pool.removeLiquidity(Dapp.SUSHISWAP, usdc, dai, balance);
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
 });

package/src/test/sushi.test.ts

@@ -0,0 +1,173 @@
+import { Dhedge } from "..";
+import { Dapp, Network } from "../types";
+
+import { wallet } from "./wallet";
+
+import { BAL, TEST_POOL, USDT } from "./constants";
+
+const myPool = "0x3e5f7e9e7dc3bc3086ccebd5eb59a0a4a29d881b";
+// const weth = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
+// //const usdt = "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
+// //const dai = "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063";
+// const usdc = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+// const wbtc = "0x1bfd67037b42cf73acf2047067bd4f2c47d9bfd6";
+//const sushi = "0x0b3F868E0BE5597D5DB7fEB59E1CADBb0fdDa50a";
+// const wmatic = "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270";
+// const lpUsdcWeth = "0x34965ba0ac2451A34a0471F04CCa3F990b8dea27";
+//const lpUsdcDai = "0xCD578F016888B57F1b1e3f887f392F0159E26747";
+//const amusdc = "0x1a13F4Ca1d028320A707D99520AbFefca3998b7F";
+//const lpUsdcUsdt = "0x4b1f1e2435a9c96f7330faea190ef6a7c8d70001";
+// const tradeAmountUsdc = "1000000";
+// const liquidityAmountUsdt = "1000000";
+// const lpUsdcWETHAmount = "10951027354";
+// const depositAmountUsdc = "100000";
+
+let dhedge: Dhedge;
+
+jest.setTimeout(100000);
+
+// const options = {
+//   gasLimit: 5000000,
+//   gasPrice: ethers.utils.parseUnits("35", "gwei")
+// };
+
+describe("pool", () => {
+  beforeAll(() => {
+    dhedge = new Dhedge(wallet, Network.POLYGON);
+  });
+
+  it("adds Liquidity into a WETH/USDT pool on sushi", async () => {
+    let result;
+    const pool = await dhedge.loadPool(myPool);
+    const liquidityAmountWETH = await dhedge.utils.getLpAmount(
+      Dapp.SUSHISWAP,
+      USDT,
+      WETH,
+      liquidityAmountUsdt
+    );
+    try {
+      result = await pool.addLiquidity(
+        Dapp.SUSHISWAP,
+        usdt,
+        weth,
+        liquidityAmountUsdt,
+        liquidityAmountWETH
+      );
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+
+  // it("approves unlimited LP USDC/WETH on sushiswap for staking", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   try {
+  //     result = await pool.approveStaking(
+  //       Dapp.SUSHISWAP,
+  //       lpUsdcDai,
+  //       ethers.constants.MaxUint256
+  //     );
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("deposit 0.1 USDC into Pool", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   try {
+  //     result = await pool.deposit(usdc, depositAmountUsdc);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("adds LpUSDCWETH to enabled assets", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   const newAssets: AssetEnabled[] = [
+  //     { asset: usdc, isDeposit: true },
+  //     { asset: weth, isDeposit: true },
+  //     { asset: usdt, isDeposit: true },
+  //     { asset: lpUsdcWeth, isDeposit: false }
+  //   ];
+  //   try {
+  //     result = await pool.changeAssets(newAssets);
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("unStakes USDC/DAI LP on sushi", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   const balance = "11013356749811";
+  //   try {
+  //     result = await pool.unStake(Dapp.SUSHISWAP, lpUsdcDai, balance);
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("trades entire sushi balance into usdc", async () => {
+  //   let result: FundComposition[] = [];
+  //   let tx;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   try {
+  //     result = await pool.getComposition();
+  //     const sushiBalance = result.find(e => e.asset === sushi)?.balance;
+  //     if (sushiBalance) {
+  //       tx = await pool.trade(Dapp.SUSHISWAP, sushi, usdc, sushiBalance);
+  //       console.log(tx);
+  //     }
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result.length).toBeGreaterThan(0);
+  // });
+
+  // it("harvests USDC/DAI LP Farm on sushi", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   try {
+  //     result = await pool.harvestRewards(Dapp.SUSHISWAP, lpUsdcdai);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("sets a trader account", async () => {
+  //   let result;
+  //   const newTrader = "0xC52D9a9D9b05a01887871216fF02bA4235e8503d";
+  //   const pool = await dhedge.loadPool(myPool);
+  //   try {
+  //     result = await pool.setTrader(newTrader);
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("removes liquidity from  USDC/DAI LP on sushi", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   const balance = "11013356749811";
+  //   try {
+  //     result = await pool.removeLiquidity(Dapp.SUSHISWAP, usdc, dai, balance);
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+});

package/src/test/utils.test.ts

@@ -1,14 +1,16 @@
+//import { ethers } from "ethers";
 import { Dhedge } from "..";
-import { Dapp, Network } from "../types";
+import { Network } from "../types";
 
 import { wallet } from "./wallet";
 
-const myPool = "0x279ac4c05154fd72a636fce1bc25c50966141fd0";
+const myPool = "0xe3528a438b94e64669def9b875c381c46ef713bf";
 
-const usdt = "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
+// const usdt = "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
 const usdc = "0x2791bca1f2de4661ed88a30c99a7a9449aa84174";
 const weth = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
-const lpUsdcWeth = "0x34965ba0ac2451A34a0471F04CCa3F990b8dea27";
+const wbtc = "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6";
+// const lpUsdcWeth = "0x34965ba0ac2451A34a0471F04CCa3F990b8dea27";
 
 let dhedge: Dhedge;
 
@@ -19,28 +21,41 @@ describe("utils", () => {
     dhedge = new Dhedge(wallet, Network.POLYGON);
   });
 
-  it("gets lp ratio of the USDT/USDC pool", async () => {
-    const result = await dhedge.utils.getLpReserves(Dapp.SUSHISWAP, usdc, usdt);
-    expect(Number(result.assetA) / Number(result.assetB)).toBeGreaterThan(0.9);
-  });
-
-  it("gets pool id of sushi LP pool for USDC/WETH", async () => {
-    const result = await dhedge.utils.getLpPoolId(Dapp.SUSHISWAP, lpUsdcWeth);
-    expect(result).toBe(1);
-  });
-
-  it("gets USDC balance of a pool", async () => {
-    const result = await dhedge.utils.getBalance(usdc, myPool);
-    expect(result.gt(0));
-  });
-  it("gets minumum amount out of WETH for 1 USDC", async () => {
-    const result = await dhedge.utils.getMinAmountOut(
-      Dapp.SUSHISWAP,
-      usdc,
-      weth,
-      "1000000",
-      0.5
+  // it("gets lp ratio of the USDT/USDC pool", async () => {
+  //   const result = await dhedge.utils.getLpReserves(Dapp.SUSHISWAP, usdc, usdt);
+  //   expect(Number(result.assetA) / Number(result.assetB)).toBeGreaterThan(0.9);
+  // });
+
+  // it("gets pool id of sushi LP pool for USDC/WETH", async () => {
+  //   const result = await dhedge.utils.getLpPoolId(Dapp.SUSHISWAP, lpUsdcWeth);
+  //   expect(result).toBe(1);
+  // });
+
+  // it("gets USDC balance of a pool", async () => {
+  //   const result = await dhedge.utils.getBalance(usdc, myPool);
+  //   expect(result.gt(0));
+  // });
+  // it("gets minumum amount out of WETH for 1 USDC", async () => {
+  //   const result = await dhedge.utils.getMinAmountOut(
+  //     Dapp.SUSHISWAP,
+  //     usdc,
+  //     weth,
+  //     "1000000",
+  //     0.5
+  //   );
+  //   expect(result.gt(0));
+  // });
+
+  it("gets Balancer pool tx data", async () => {
+    const pool = await dhedge.loadPool(myPool);
+    const assets = [wbtc, usdc, weth];
+    const amounts = ["0", "1000000", "0"];
+    const result = await dhedge.utils.getBalancerJoinPoolTx(
+      pool,
+      "0x03cd191f589d12b0582a99808cf19851e468e6b500010000000000000000000a",
+      assets,
+      amounts
     );
-    expect(result.gt(0));
+    expect(result);
   });
 });

package/src/types.ts

@@ -2,7 +2,7 @@ import { ChainId } from "@sushiswap/sdk";
 import { BigNumber } from "ethers";
 
 export enum Network {
-  POLYGON = "polygon",
+  POLYGON = "polygon"
 }
 
 export enum Dapp {
@@ -10,6 +10,7 @@ export enum Dapp {
   AAVE = "aave",
   ONEINCH = "1inch",
   QUICKSWAP = "quickswap",
+  BALANCER = "balancer"
 }
 
 export enum Transaction {
@@ -17,11 +18,12 @@ export enum Transaction {
   ADD_LIQUIDITY = "addLiquidity",
   DEPOSIT = "deposit",
   HARVEST = "harvest",
-  UNSTAKE = "withdrawAndHarvest",
+  CLAIM_DISTRIBIUTIONS = "claimDistributions",
+  CLAIM_REWARDS = "claimRewards",
   REMOVE_LIQUIDITY = "removeLiquidity",
   BORROW = "borrow",
   REPAY = "repay",
-  WITHDRAW = "withdraw",
+  WITHDRAW = "withdraw"
 }
 
 export type AddressNetworkMap = Readonly<Record<Network, string>>;
@@ -31,6 +33,7 @@ export type AddressDappMap = {
   [Dapp.AAVE]?: string;
   [Dapp.ONEINCH]?: string;
   [Dapp.QUICKSWAP]?: string;
+  [Dapp.BALANCER]?: string;
 };
 
 export type AddressDappNetworkMap = Readonly<Record<Network, AddressDappMap>>;

package/src/utils/contract.ts

@@ -0,0 +1,95 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import set from "lodash/set";
+import { Interface } from "@ethersproject/abi";
+import { multiCallAddress } from "../config";
+import { ethers, Network } from "..";
+
+export async function call(
+  provider: ethers.Signer,
+  abi: any[],
+  call: any[],
+  options?: any
+) {
+  const contract = new ethers.Contract(call[0], abi, provider);
+  try {
+    const params = call[2] || [];
+    return await contract[call[1]](...params, options || {});
+  } catch (e) {
+    return Promise.reject(e);
+  }
+}
+
+export async function multicall<T>(
+  network: Network,
+  provider: ethers.Signer,
+  abi: any[],
+  calls: any[],
+  options: any = {},
+  requireSuccess = false
+): Promise<(T | null)[]> {
+  const multi = new ethers.Contract(
+    multiCallAddress[network],
+    [
+      "function tryAggregate(bool requireSuccess, tuple(address, bytes)[] memory calls) public view returns (tuple(bool, bytes)[] memory returnData)"
+    ],
+    provider
+  );
+  const itf = new Interface(abi);
+  try {
+    const res: [boolean, string][] = await multi.tryAggregate(
+      // if false, allows individual calls to fail without causing entire multicall to fail
+      requireSuccess,
+      calls.map(call => [
+        call[0].toLowerCase(),
+        itf.encodeFunctionData(call[1], call[2])
+      ]),
+      options
+    );
+
+    return res.map(([success, returnData], i) => {
+      if (!success) return null;
+      const decodedResult = itf.decodeFunctionResult(calls[i][1], returnData);
+      // Automatically unwrap any simple return values
+      return decodedResult.length > 1 ? decodedResult : decodedResult[0];
+    });
+  } catch (e) {
+    return Promise.reject(e);
+  }
+}
+
+export class Multicaller {
+  public network: Network;
+  public provider: ethers.Signer;
+  public abi: any[];
+  public options: any = {};
+  public calls: any[] = [];
+  public paths: any[] = [];
+
+  constructor(network: Network, provider: ethers.Signer, abi: any[]) {
+    this.network = network;
+    this.provider = provider;
+    this.abi = abi;
+  }
+
+  call(path: any, address: any, fn: any, params?: any): Multicaller {
+    this.calls.push([address, fn, params]);
+    this.paths.push(path);
+    return this;
+  }
+
+  async execute(from?: any): Promise<any> {
+    const obj = from || {};
+    const result = await multicall(
+      this.network,
+      this.provider,
+      this.abi,
+      this.calls,
+      this.options
+    );
+    result.forEach((r, i) => set(obj, this.paths[i], r));
+    this.calls = [];
+    this.paths = [];
+    return obj;
+  }
+}