@dhedge/v2-sdk 1.1.1 → 1.3.0

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/test/wallet.ts

@@ -4,9 +4,13 @@ import { ethers } from "ethers";
 require("dotenv").config();
 
 const provider = new ethers.providers.JsonRpcProvider(
-  `https://polygon-mainnet.infura.io/v3/${process.env.INFURA_PROJECT_ID}`
+  `https://opt-mainnet.g.alchemy.com/v2/${process.env.ALCHEMY_PROJECT_ID}`
 );
 
+// const provider = new ethers.providers.JsonRpcProvider(
+//   `https://polygon-mainnet.infura.io/v3/${process.env.INFURA_PROJECT_ID}`
+// );
+
 export const wallet = new ethers.Wallet(
   process.env.PRIVATE_KEY as string,
   provider

package/src/types.ts

@@ -1,8 +1,8 @@
-import { ChainId } from "@sushiswap/sdk";
 import { BigNumber } from "ethers";
 
 export enum Network {
   POLYGON = "polygon",
+  OPTIMISM = "optimism"
 }
 
 export enum Dapp {
@@ -10,6 +10,9 @@ export enum Dapp {
   AAVE = "aave",
   ONEINCH = "1inch",
   QUICKSWAP = "quickswap",
+  BALANCER = "balancer",
+  UNISWAPV3 = "uniswapV3",
+  SYNTHETIX = "synthetix"
 }
 
 export enum Transaction {
@@ -17,11 +20,19 @@ export enum Transaction {
   ADD_LIQUIDITY = "addLiquidity",
   DEPOSIT = "deposit",
   HARVEST = "harvest",
-  UNSTAKE = "withdrawAndHarvest",
+  CLAIM_DISTRIBIUTIONS = "claimDistributions",
+  CLAIM_REWARDS = "claimRewards",
   REMOVE_LIQUIDITY = "removeLiquidity",
+  DECREASE_LIQUIDITY = "decreaseLiquidity",
+  INCREASE_LIQUIDITY = "increaseLiquidity",
+  COLLECT = "collect",
+  MULTI_CALL = "multicall",
   BORROW = "borrow",
   REPAY = "repay",
   WITHDRAW = "withdraw",
+  MINT = "mint",
+  BURN = "burn",
+  SWAP_SYNTHS = "exchangeWithTracking"
 }
 
 export type AddressNetworkMap = Readonly<Record<Network, string>>;
@@ -31,6 +42,9 @@ export type AddressDappMap = {
   [Dapp.AAVE]?: string;
   [Dapp.ONEINCH]?: string;
   [Dapp.QUICKSWAP]?: string;
+  [Dapp.BALANCER]?: string;
+  [Dapp.UNISWAPV3]?: string;
+  [Dapp.SYNTHETIX]?: string;
 };
 
 export type AddressDappNetworkMap = Readonly<Record<Network, AddressDappMap>>;
@@ -54,4 +68,4 @@ export type Reserves = {
   assetB: BigNumber;
 };
 
-export type NetworkChainIdMap = Readonly<Record<Network, ChainId>>;
+export type NetworkChainIdMap = Readonly<Record<Network, number>>;

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;
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,38 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import BigNumber from "bignumber.js";
+import { soliditySha3 } from "web3-utils";
+import { MerkleTree } from "./merkle";
+
+export function scale(
+  input: BigNumber | string,
+  decimalPlaces: number
+): BigNumber {
+  const unscaled = typeof input === "string" ? new BigNumber(input) : input;
+  const scalePow = new BigNumber(decimalPlaces.toString());
+  const scaleMul = new BigNumber(10).pow(scalePow);
+  return unscaled.times(scaleMul);
+}
+
+export function loadTree(
+  balances: { [x: string]: string | BigNumber },
+  decimals = 18
+) {
+  const elements: any[] = [];
+  Object.keys(balances).forEach(address => {
+    const balance: string = scale(balances[address], decimals).toString(10);
+    const leaf = soliditySha3(
+      { t: "address", v: address },
+      { t: "uint", v: balance }
+    );
+    // @ts-ignore
+    elements.push(leaf);
+  });
+  return new MerkleTree(elements);
+}
+
+export function bnum(val: string | number | BigNumber): BigNumber {
+  const number = typeof val === "string" ? val : val ? val.toString() : "0";
+  return new BigNumber(number);
+}

package/src/utils/merkle.ts

@@ -0,0 +1,172 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Shamelessly adapted from OpenZeppelin-contracts test utils
+import BigNumber from "bignumber.js";
+import { keccak256, keccakFromString, bufferToHex } from "ethereumjs-util";
+import { hexToBytes, soliditySha3 } from "web3-utils";
+import { scale } from "./index";
+
+// Merkle tree called with 32 byte hex values
+export class MerkleTree {
+  public elements: any;
+  public layers: any;
+
+  constructor(elements: any[]) {
+    this.elements = elements
+      .filter((el: any) => el)
+      .map(el => 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);
+  }
+
+  getLayers(elements: string | any[]) {
+    if (elements.length === 0) {
+      return [[""]];
+    }
+
+    const 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;
+  }
+
+  getNextLayer(elements: any[]) {
+    return elements.reduce(
+      (layer: any[], el: any, idx: number, arr: { [x: string]: any }) => {
+        if (idx % 2 === 0) {
+          // Hash the current element with its pair element
+          layer.push(this.combinedHash(el, arr[idx + 1]));
+        }
+
+        return layer;
+      },
+      []
+    );
+  }
+
+  combinedHash(first: any, second: any) {
+    if (!first) {
+      return second;
+    }
+    if (!second) {
+      return first;
+    }
+
+    return keccak256(this.sortAndConcat(first, second));
+  }
+
+  getRoot() {
+    return this.layers[this.layers.length - 1][0];
+  }
+
+  getHexRoot() {
+    return bufferToHex(this.getRoot());
+  }
+
+  getProof(el: any) {
+    let idx = this.bufIndexOf(el, this.elements);
+
+    if (idx === -1) {
+      throw new Error("Element does not exist in Merkle tree");
+    }
+
+    return this.layers.reduce((proof: any[], layer: any) => {
+      const pairElement = this.getPairElement(idx, layer);
+
+      if (pairElement) {
+        proof.push(pairElement);
+      }
+
+      idx = Math.floor(idx / 2);
+
+      return proof;
+    }, []);
+  }
+
+  // external call - convert to buffer
+  getHexProof(_el: any) {
+    const el = Buffer.from(hexToBytes(_el));
+
+    const proof = this.getProof(el);
+
+    return this.bufArrToHexArr(proof);
+  }
+
+  getPairElement(idx: number, layer: string | any[]) {
+    const pairIdx = idx % 2 === 0 ? idx + 1 : idx - 1;
+
+    if (pairIdx < layer.length) {
+      return layer[pairIdx];
+    } else {
+      return null;
+    }
+  }
+
+  bufIndexOf(el: string | any[], arr: string | any[]) {
+    let hash;
+
+    // Convert element to 32 byte hash if it is not one already
+    if (el.length !== 32 || !Buffer.isBuffer(el)) {
+      hash = keccakFromString(el as string);
+    } else {
+      hash = el;
+    }
+
+    for (let i = 0; i < arr.length; i++) {
+      if (hash.equals(arr[i])) {
+        return i;
+      }
+    }
+
+    return -1;
+  }
+
+  bufDedup(elements: any[]) {
+    return elements.filter((el: any, idx: number) => {
+      return idx === 0 || !elements[idx - 1].equals(el);
+    });
+  }
+
+  bufArrToHexArr(arr: any[]) {
+    if (arr.some((el: any) => !Buffer.isBuffer(el))) {
+      throw new Error("Array is not an array of buffers");
+    }
+
+    return arr.map(
+      (el: { toString: (arg0: string) => string }) => "0x" + el.toString("hex")
+    );
+  }
+
+  sortAndConcat(...args: any[]) {
+    return Buffer.concat([...args].sort(Buffer.compare));
+  }
+}
+
+export function loadTree(
+  balances: { [x: string]: string | BigNumber },
+  decimals = 18
+) {
+  const elements: (string | null)[] = [];
+  Object.keys(balances).forEach(address => {
+    const balance: string = scale(balances[address], decimals).toString(10);
+    const leaf = soliditySha3(
+      { t: "address", v: address },
+      { t: "uint", v: balance }
+    );
+    elements.push(leaf);
+  });
+  return new MerkleTree(elements);
+}