@dhedge/v2-sdk 1.0.0 → 1.2.0

package/src/entities/utils.ts

@@ -1,11 +1,29 @@
 import { Contract, ethers, Wallet } from "ethers";
+import {
+  Token,
+  TokenAmount,
+  Pair,
+  TradeType,
+  Route,
+  Trade,
+  Percent
+} from "@sushiswap/sdk";
+import { SOR, SwapTypes } from "@balancer-labs/sor";
+import { BaseProvider } from "@ethersproject/providers";
 
 import IERC20 from "../abi/IERC20.json";
 import IMiniChefV2 from "../abi/IMiniChefV2.json";
 import UniswapV2Factory from "../abi/IUniswapV2Factory.json";
 import UniswapV2Pair from "../abi/IUniswapV2Pair.json";
-import { dappFactoryAddress, stakingAddress } from "../config";
+import IBalancerV2Vault from "../abi/IBalancertV2Vault.json";
+import {
+  balancerSubgraph,
+  dappFactoryAddress,
+  networkChainIdMap,
+  stakingAddress
+} from "../config";
 import { Dapp, Network, Reserves } from "../types";
+import { Pool } from ".";
 
 export class Utils {
   network: Network;
@@ -106,4 +124,186 @@ export class Utils {
     const balance = await iERC20.balanceOf(owner);
     return balance;
   }
+
+  /**
+   * Return the minimum amount out for a trade between two assets
+   * given the trade amount and slippage
+   * @param {Dapp} dApp DApp like Uniswap or Sushiswap
+   * @param {string} assetFrom Asset to trade from
+   * @param {string} assetTo Asset to trade into
+   * @param {string | ethers.BigNumber} amountIn Trade amount
+   * @param { number} slippage Maximum slippage allowed
+   * @returns {Promise<ethers.BigNumber>} Reserves of the assets in BigNumber
+   */
+  async getMinAmountOut(
+    dapp: Dapp,
+    assetFrom: string,
+    assetTo: string,
+    amountIn: string | ethers.BigNumber,
+    slippage: number
+  ): Promise<ethers.BigNumber> {
+    const assetFromChecked = ethers.utils.getAddress(assetFrom);
+    const assetToChecked = ethers.utils.getAddress(assetTo);
+    const reserves = await this.getLpReserves(
+      dapp,
+      assetFromChecked,
+      assetToChecked
+    );
+    const tokenA = new Token(
+      networkChainIdMap[this.network],
+      assetFromChecked,
+      18
+    );
+    const tokenB = new Token(
+      networkChainIdMap[this.network],
+      assetToChecked,
+      18
+    );
+    const pair = new Pair(
+      new TokenAmount(tokenA, reserves.assetA.toString()),
+      new TokenAmount(tokenB, reserves.assetB.toString())
+    );
+    const route = new Route([pair], tokenA, tokenB);
+
+    const trade = new Trade(
+      route,
+      new TokenAmount(tokenA, amountIn.toString()),
+      TradeType.EXACT_INPUT
+    );
+    return ethers.BigNumber.from(
+      trade
+        .minimumAmountOut(new Percent((slippage * 100).toFixed(), "10000"))
+        .raw.toString()
+    );
+  }
+
+  async getBalancerSwapTx(
+    pool: Pool,
+    assetFrom: string,
+    assetTo: string,
+    amountIn: ethers.BigNumber | string,
+    slippage: number
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ): Promise<any> {
+    const sor = new SOR(
+      this.signer.provider as BaseProvider,
+      networkChainIdMap[this.network],
+      balancerSubgraph[this.network]
+    );
+    // isFetched will be true on success
+    const isFetched = await sor.fetchPools();
+
+    if (!isFetched) throw new Error("Error fetching balancer pools");
+
+    const swapType = SwapTypes.SwapExactIn;
+    const { swaps, tokenAddresses, returnAmount } = await sor.getSwaps(
+      assetFrom,
+      assetTo,
+      swapType,
+      ethers.BigNumber.from(amountIn)
+    );
+
+    const minimumAmountOut = returnAmount
+      .mul(10000 - slippage * 100)
+      .div(10000);
+
+    const iBalancerV2Vault = new ethers.utils.Interface(IBalancerV2Vault.abi);
+
+    if (swaps.length === 1) {
+      const swap = swaps[0];
+      //do single swap
+      const 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 swapTx;
+    } else {
+      // Limits:
+      // +ve means max to send
+      // -ve mean min to receive
+      // For a multihop the intermediate tokens should be 0
+      const limits: string[] = [];
+      tokenAddresses.forEach((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";
+        }
+      });
+      const 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 swapTx;
+    }
+  }
+
+  async getBalancerJoinPoolTx(
+    pool: Pool,
+    balancerPoolId: string,
+    assets: string[],
+    amountsIn: string[] | ethers.BigNumber[]
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ): Promise<any> {
+    const iBalancerV2Vault = new ethers.utils.Interface(IBalancerV2Vault.abi);
+    const txData = [
+      balancerPoolId,
+      pool.address,
+      pool.address,
+      [
+        assets,
+        amountsIn,
+        ethers.utils.defaultAbiCoder.encode(
+          ["uint256", "uint256[]", "uint256"],
+          [1, amountsIn, 0]
+        ),
+        false
+      ]
+    ];
+    const joinPoolTx = iBalancerV2Vault.encodeFunctionData("joinPool", txData);
+    return joinPoolTx;
+  }
+
+  async getBalancerExitPoolTx(
+    pool: Pool,
+    balancerPoolId: string,
+    assets: string[],
+    amount: string | ethers.BigNumber
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ): Promise<any> {
+    const minimumAmountOut = new Array(assets.length).fill(0);
+    const iBalancerV2Vault = new ethers.utils.Interface(IBalancerV2Vault.abi);
+    const txData = [
+      balancerPoolId,
+      pool.address,
+      pool.address,
+      [
+        assets,
+        minimumAmountOut,
+        ethers.utils.defaultAbiCoder.encode(
+          ["uint256", "uint256"],
+          [1, amount]
+        ),
+        false
+      ]
+    ];
+    const exitPoolTx = iBalancerV2Vault.encodeFunctionData("exitPool", txData);
+    return exitPoolTx;
+  }
 }

package/src/services/claim-balancer/MultiTokenClaim.json

@@ -0,0 +1,115 @@
+{
+    "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
+        }
+    ]
+  }

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();