@dhedge/v2-sdk 1.7.2 → 1.8.1

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

@@ -1,262 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import axios from "axios";
-import { chunk, flatten } 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 {
-  ClaimProofTuple,
-  ClaimStatus,
-  ComputeClaimProofPayload,
-  MultiTokenPendingClaims,
-  Report,
-  Snapshot,
-  TokenClaimInfo
-} from "./types";
-
-import { Network } from "../../types";
-import { networkChainIdMap, 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 = await 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 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 async getTokenClaimsInfo() {
-    let tokenClaims;
-    try {
-      const multiTokenClaim = await axios.get(
-        "https://raw.githubusercontent.com/balancer-labs/frontend-v2/develop/src/services/claim/MultiTokenClaim.json"
-      );
-      const chainId = networkChainIdMap[this.network];
-      tokenClaims = multiTokenClaim.data[chainId];
-    } catch (e) {
-      console.log("balancer multi token info error", e);
-    }
-
-    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

@@ -1,32 +0,0 @@
-// 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

@@ -1,12 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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/1inch.test.ts

@@ -1,54 +0,0 @@
-import { Dhedge } from "..";
-import { Dapp, Network } from "../types";
-import { TEST_POOL, USDC, WBTC } from "./constants";
-import { getTxOptions } from "./txOptions";
-
-import { wallet } from "./wallet";
-
-let dhedge: Dhedge;
-let options: any;
-
-jest.setTimeout(100000);
-
-describe("pool", () => {
-  beforeAll(async () => {
-    dhedge = new Dhedge(wallet, Network.OPTIMISM);
-    options = await getTxOptions(Network.OPTIMISM);
-  });
-
-  //   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 WBTC on 1Inch", async () => {
-    let result;
-    const pool = await dhedge.loadPool(TEST_POOL);
-    try {
-      result = await pool.trade(
-        Dapp.ONEINCH,
-        USDC,
-        WBTC,
-        "1000000",
-        0.5,
-        options
-      );
-      console.log(result);
-    } catch (e) {
-      console.log(e);
-    }
-    expect(result).not.toBe(null);
-  });
-});