@dhedge/v2-sdk 1.1.1 → 1.2.0

package/src/services/claim-balancer/claim.service.ts

@@ -0,0 +1,324 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import axios from "axios";
+import { chunk, flatten, groupBy } from "lodash";
+import merkleOrchardAbi from "../../abi/IBalancerMerkleOrchard.json";
+import { ethers, Wallet } from "ethers";
+
+import { getAddress } from "@ethersproject/address";
+
+import { multicall } from "../../utils/contract";
+import { bnum, loadTree, scale } from "../../utils";
+
+import { ipfsService } from "./ipfs.service";
+
+import MultiTokenClaim from "./MultiTokenClaim.json";
+
+import {
+  ClaimProofTuple,
+  ClaimStatus,
+  ComputeClaimProofPayload,
+  MultiTokenCurrentRewardsEstimate,
+  MultiTokenCurrentRewardsEstimateResponse,
+  MultiTokenPendingClaims,
+  Report,
+  Snapshot,
+  TokenClaimInfo
+} from "./types";
+
+import { Network } from "../../types";
+import { stakingAddress } from "../../config";
+import { soliditySha3 } from "web3-utils";
+import { Dapp } from "../..";
+
+export class ClaimService {
+  network: Network;
+  signer: ethers.Wallet;
+  public constructor(network: Network, signer: Wallet) {
+    this.network = network;
+    this.signer = signer;
+  }
+  public async getMultiTokensPendingClaims(
+    account: string
+  ): Promise<MultiTokenPendingClaims[]> {
+    const tokenClaimsInfo = this.getTokenClaimsInfo();
+    if (tokenClaimsInfo != null) {
+      const multiTokenPendingClaims = await Promise.all(
+        tokenClaimsInfo.map(tokenClaimInfo =>
+          this.getTokenPendingClaims(tokenClaimInfo, getAddress(account))
+        )
+      );
+
+      const multiTokenPendingClaimsWithRewards = multiTokenPendingClaims.filter(
+        pendingClaim => Number(pendingClaim.availableToClaim) > 0
+      );
+
+      return multiTokenPendingClaimsWithRewards;
+    }
+    return [];
+  }
+
+  public async getTokenPendingClaims(
+    tokenClaimInfo: TokenClaimInfo,
+    account: string
+  ): Promise<MultiTokenPendingClaims> {
+    const snapshot = await this.getSnapshot(tokenClaimInfo.manifest);
+    const weekStart = tokenClaimInfo.weekStart;
+    const claimStatus = await this.getClaimStatus(
+      Object.keys(snapshot).length,
+      account,
+      tokenClaimInfo
+    );
+
+    const pendingWeeks = claimStatus
+      .map((status, i) => [i + weekStart, status])
+      .filter(([, status]) => !status)
+      .map(([i]) => i) as number[];
+
+    const reports = await this.getReports(snapshot, pendingWeeks);
+
+    const claims = Object.entries(reports)
+      .filter((report: Report) => report[1][account])
+      .map((report: Report) => {
+        return {
+          id: report[0],
+          amount: report[1][account]
+        };
+      });
+
+    //console.log("claims", claims);
+
+    const availableToClaim = claims
+      .map(claim => parseFloat(claim.amount))
+      .reduce((total, amount) => total.plus(amount), bnum(0))
+      .toString();
+
+    return {
+      claims,
+      reports,
+      tokenClaimInfo,
+      availableToClaim
+    };
+  }
+
+  public async getMultiTokensCurrentRewardsEstimate(
+    account: string
+  ): Promise<{
+    data: MultiTokenCurrentRewardsEstimate[];
+    timestamp: string | null;
+  }> {
+    try {
+      const response = await axios.get<
+        MultiTokenCurrentRewardsEstimateResponse
+      >(
+        `https://api.balancer.finance/liquidity-mining/v1/liquidity-provider-multitoken/${account}`
+      );
+      if (response.data.success) {
+        const multiTokenLiquidityProviders = response.data.result[
+          "liquidity-providers"
+        ]
+          .filter(incentive => incentive.chain_id === 137)
+          .map(incentive => ({
+            ...incentive,
+            token_address: getAddress(incentive.token_address)
+          }));
+
+        const multiTokenCurrentRewardsEstimate: MultiTokenCurrentRewardsEstimate[] = [];
+
+        const multiTokenLiquidityProvidersByToken = Object.entries(
+          groupBy(multiTokenLiquidityProviders, "token_address")
+        );
+
+        for (const [
+          token,
+          liquidityProvider
+        ] of multiTokenLiquidityProvidersByToken) {
+          const rewards = liquidityProvider
+            .reduce(
+              (total, { current_estimate }) => total.plus(current_estimate),
+              bnum(0)
+            )
+            .toString();
+
+          const velocity =
+            liquidityProvider
+              .find(liquidityProvider => Number(liquidityProvider.velocity) > 0)
+              ?.velocity.toString() ?? "0";
+
+          if (Number(rewards) > 0) {
+            multiTokenCurrentRewardsEstimate.push({
+              rewards,
+              velocity,
+              token: getAddress(token)
+            });
+          }
+        }
+
+        return {
+          data: multiTokenCurrentRewardsEstimate,
+          timestamp: response.data.result.current_timestamp
+        };
+      }
+    } catch (e) {
+      console.log("[Claim] Current Rewards Estimate Error", e);
+    }
+    return {
+      data: [],
+      timestamp: null
+    };
+  }
+
+  public async multiTokenClaimRewards(
+    account: string,
+    multiTokenPendingClaims: MultiTokenPendingClaims[]
+  ): Promise<any> {
+    try {
+      const multiTokenClaims = await Promise.all(
+        multiTokenPendingClaims.map((tokenPendingClaims, tokenIndex) =>
+          this.computeClaimProofs(
+            tokenPendingClaims,
+            getAddress(account),
+            tokenIndex
+          )
+        )
+      );
+
+      return flatten(multiTokenClaims);
+    } catch (e) {
+      console.log("[Claim] Claim Rewards Error:", e);
+      return Promise.reject(e);
+    }
+  }
+
+  private async computeClaimProofs(
+    tokenPendingClaims: MultiTokenPendingClaims,
+    account: string,
+    tokenIndex: number
+  ): Promise<Promise<ClaimProofTuple[]>> {
+    return Promise.all(
+      tokenPendingClaims.claims.map(claim => {
+        const payload: ComputeClaimProofPayload = {
+          account,
+          distributor: tokenPendingClaims.tokenClaimInfo.distributor,
+          tokenIndex,
+          decimals: tokenPendingClaims.tokenClaimInfo.decimals,
+          // objects must be cloned
+          report: { ...tokenPendingClaims.reports[claim.id] },
+          claim: { ...claim }
+        };
+
+        return this.computeClaimProof(payload);
+      })
+    );
+  }
+
+  private computeClaimProof(
+    payload: ComputeClaimProofPayload
+  ): ClaimProofTuple {
+    const {
+      report,
+      account,
+      claim,
+      distributor,
+      tokenIndex,
+      decimals
+    } = payload;
+
+    const claimAmount = claim.amount;
+    const merkleTree = loadTree(report, decimals);
+
+    const scaledBalance = scale(claimAmount, decimals).toString(10);
+
+    const proof = merkleTree.getHexProof(
+      soliditySha3(
+        { t: "address", v: account },
+        { t: "uint", v: scaledBalance }
+      )
+    );
+    return [
+      parseInt(claim.id),
+      scaledBalance,
+      distributor,
+      tokenIndex,
+      proof
+    ] as ClaimProofTuple;
+  }
+
+  private getTokenClaimsInfo() {
+    const tokenClaims = MultiTokenClaim["137"];
+
+    if (tokenClaims != null) {
+      return (tokenClaims as TokenClaimInfo[]).map(tokenClaim => ({
+        ...tokenClaim,
+        token: getAddress(tokenClaim.token),
+        decimals: 18
+      }));
+    }
+
+    return null;
+  }
+
+  private async getSnapshot(manifest: string) {
+    try {
+      const response = await axios.get<Snapshot>(manifest);
+      return response.data || {};
+    } catch (error) {
+      return {};
+    }
+  }
+
+  private async getClaimStatus(
+    totalWeeks: number,
+    account: string,
+    tokenClaimInfo: TokenClaimInfo
+  ): Promise<ClaimStatus[]> {
+    const { token, distributor, weekStart } = tokenClaimInfo;
+
+    const claimStatusCalls = Array.from({ length: totalWeeks }).map((_, i) => [
+      stakingAddress[this.network][Dapp.BALANCER],
+      "isClaimed",
+      [token, distributor, weekStart + i, account]
+    ]);
+
+    const rootCalls = Array.from({ length: totalWeeks }).map((_, i) => [
+      stakingAddress[this.network][Dapp.BALANCER],
+      "getDistributionRoot",
+      [token, distributor, weekStart + i]
+    ]);
+
+    try {
+      const result = (await multicall<boolean | string>(
+        this.network,
+        this.signer,
+        merkleOrchardAbi.abi,
+        [...claimStatusCalls, ...rootCalls],
+        {},
+        true
+      )) as (boolean | string)[];
+
+      if (result.length > 0) {
+        const chunks = chunk(flatten(result), totalWeeks);
+
+        const claimedResult = chunks[0] as boolean[];
+        const distributionRootResult = chunks[1] as string[];
+
+        return claimedResult.filter(
+          (_, index) =>
+            distributionRootResult[index] !== ethers.constants.HashZero
+        );
+      }
+    } catch (e) {
+      console.log("[Claim] Claim Status Error:", e);
+    }
+
+    return [];
+  }
+
+  private async getReports(snapshot: Snapshot, weeks: number[]) {
+    const reports = await Promise.all<Report>(
+      weeks
+        .filter(week => snapshot[week] != null)
+        .map(week => ipfsService.get(snapshot[week]))
+    );
+    return Object.fromEntries(reports.map((report, i) => [weeks[i], report]));
+  }
+}

package/src/services/claim-balancer/claim.worker.ts

@@ -0,0 +1,32 @@
+// Shamelessly adapted from OpenZeppelin-contracts test utils
+import { soliditySha3 } from "web3-utils";
+import { loadTree, scale } from "../../utils";
+
+import { ComputeClaimProofPayload } from "./types";
+
+export class ClaimWorker {
+  public calcClaimProof(payload: ComputeClaimProofPayload): any {
+    const {
+      report,
+      account,
+      claim,
+      distributor,
+      tokenIndex,
+      decimals
+    } = payload;
+
+    const claimAmount = claim.amount;
+    const merkleTree = loadTree(report, decimals);
+
+    const scaledBalance = scale(claimAmount, decimals).toString(10);
+
+    const proof = merkleTree.getHexProof(
+      soliditySha3(
+        { t: "address", v: account },
+        { t: "uint", v: scaledBalance }
+      )
+    );
+
+    return [parseInt(claim.id), scaledBalance, distributor, tokenIndex, proof];
+  }
+}

package/src/services/claim-balancer/ipfs.service.ts

@@ -0,0 +1,12 @@
+import axios from "axios";
+
+export default class IpfsService {
+  async get<T>(hash: string, protocol = "ipfs"): Promise<T> {
+    const { data } = await axios.get(
+      `https://cloudflare-ipfs.com/${protocol}/${hash}`
+    );
+    return data;
+  }
+}
+
+export const ipfsService = new IpfsService();

package/src/services/claim-balancer/types.ts

@@ -0,0 +1,66 @@
+export interface Claim {
+  id: string;
+  amount: string;
+}
+
+export type Snapshot = Record<number, string>;
+
+export type TokenClaimInfo = {
+  label: string;
+  distributor: string;
+  token: string;
+  decimals: number;
+  manifest: string;
+  weekStart: number;
+};
+
+export type MultiTokenPendingClaims = {
+  claims: Claim[];
+  reports: Report;
+  tokenClaimInfo: TokenClaimInfo;
+  availableToClaim: string;
+};
+
+export type ClaimStatus = boolean;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Report = Record<string, any>;
+
+export type MultiTokenCurrentRewardsEstimateResponse = {
+  success: boolean;
+  result: {
+    current_timestamp: string;
+    "liquidity-providers": Array<{
+      snapshot_timestamp: string;
+      address: string;
+      token_address: string;
+      chain_id: number;
+      current_estimate: string;
+      velocity: string;
+      week: number;
+    }>;
+  };
+};
+
+export type MultiTokenCurrentRewardsEstimate = {
+  rewards: string;
+  velocity: string;
+  token: string;
+};
+
+export type ClaimProofTuple = [number, string, string, number, string[]]; // claimId, claimAmount, distributor, tokenIndex, proof
+
+export type ComputeClaimProofPayload = {
+  report: Report;
+  account: string;
+  claim: Claim;
+  distributor: string;
+  tokenIndex: number;
+  decimals: number;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type ClaimWorkerMessage<P = any> = {
+  type: "computeClaimProof";
+  payload: P;
+};

package/src/test/aave.test.ts

@@ -0,0 +1,73 @@
+import { Dhedge, ethers } from "..";
+import { Network } from "../types";
+import { AMUSDC, TEST_POOL, VDEBTWETH } from "./constants";
+
+import { wallet } from "./wallet";
+
+let dhedge: Dhedge;
+
+jest.setTimeout(100000);
+
+const options = {
+  gasLimit: 5000000,
+  gasPrice: ethers.utils.parseUnits("100", "gwei")
+};
+
+describe("pool", () => {
+  beforeAll(() => {
+    dhedge = new Dhedge(wallet, Network.POLYGON);
+  });
+
+  // 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("claims rewards from Aave", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.harvestAaveRewards([AMUSDC, VDEBTWETH], options);
+      console.log(result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+});

package/src/test/balancer.test.ts

@@ -0,0 +1,109 @@
+import { Dhedge, ethers } from "..";
+import { Network } from "../types";
+import { TEST_POOL } from "./constants";
+
+import { wallet } from "./wallet";
+
+let dhedge: Dhedge;
+
+jest.setTimeout(100000);
+
+const options = {
+  gasLimit: 2000000,
+  gasPrice: ethers.utils.parseUnits("1000", "gwei")
+};
+
+describe("pool", () => {
+  beforeAll(() => {
+    dhedge = new Dhedge(wallet, Network.POLYGON);
+  });
+
+  // it("approves unlimited USDC on Balancer", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.approve(
+  //       Dapp.BALANCER,
+  //       USDC,
+  //       ethers.constants.MaxInt256,
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("trades 2 USDC into SUSHI on Balancer", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   try {
+  //     result = await pool.trade(
+  //       Dapp.BALANCER,
+  //       usdc,
+  //       sushi,
+  //       "2000000",
+  //       0.5,
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("adds 1 USDC to a USDC/TUSD/DAI/USDT balancer pool", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   const assets = [USDC, TUSD, DAI, USDT];
+  //   const amounts = ["1000000", "0", "0", "0"];
+  //   try {
+  //     result = await pool.joinBalancerPool(
+  //       "0x0d34e5dd4d8f043557145598e4e2dc286b35fd4f000000000000000000000068",
+  //       assets,
+  //       amounts,
+  //       options
+  //     );
+  //     console.log("result", result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("exits entire balance of WBTC/USDC/WETH balancer pool", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   const assets = [wbtc, usdc, weth];
+  //   const amount = await dhedge.utils.getBalance(
+  //     "0x03cd191f589d12b0582a99808cf19851e468e6b5",
+  //     pool.address
+  //   );
+  //   try {
+  //     result = await pool.exitBalancerPool(
+  //       "0x03cd191f589d12b0582a99808cf19851e468e6b500010000000000000000000a",
+  //       assets,
+  //       amount,
+  //       options
+  //     );
+  //     console.log("result", result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  it("claims balancer rewards", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.harvestBalancerRewards(options);
+      console.log("result", result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+});

package/src/test/constants.ts

@@ -0,0 +1,13 @@
+export const USDC = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+export const USDT = "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
+export const DAI = "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063";
+export const TUSD = "0x2e1ad108ff1d8c782fcbbb89aad783ac49586756";
+export const WETH = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
+export const WBTC = "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6";
+export const SUSHI = "0x0b3f868e0be5597d5db7feb59e1cadbb0fdda50a";
+export const WMATIC = "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270";
+export const BAL = "0x9a71012B13CA4d3D0Cdc72A177DF3ef03b0E76A3";
+export const AMUSDC = "0x1a13f4ca1d028320a707d99520abfefca3998b7f";
+export const VDEBTWETH = "0xede17e9d79fc6f9ff9250d9eefbdb88cc18038b5";
+
+export const TEST_POOL = "0x3deeba9ca29e2dd98d32eed8dd559dac55014615";

package/src/test/oneInch.test.ts

@@ -0,0 +1,56 @@
+import { Dhedge, ethers } from "..";
+import { Dapp, Network } from "../types";
+import { TEST_POOL, USDC, WETH } from "./constants";
+
+import { wallet } from "./wallet";
+
+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("approves unlimited USDC on 1Inch", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   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(TEST_POOL);
+    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);
+  });
+});