@dhedge/v2-sdk 1.1.1 → 1.2.0

package/README.md

@@ -142,17 +142,17 @@ const tx = await pool.approve(
 
 ### Trade pool assets
 
-Trade 1 USDC into DAI on Sushiswap
+Trade 1 USDC into DAI on Sushiswap (other options: QUICKSWAP, BALANCER, or ONEINCH)
 
 ```
 const amountIn = "1000000"
-const minAmountOut = "997085"
+const slippage = 0.5
 const tx = await pool.trade(
   Dapp.SUSHISWAP,
   "USDC_TOKEN_ADDRESS",
   "DAI_TOKEN_ADDRESS",
   amountIn,
-  minAmountOut
+  slippage
 )
 ```
 
@@ -184,6 +184,28 @@ const tx = await pool.removeLiquidity(
 )
 ```
 
+Add 0.00002 WBTC, 1 USDC and 0.0002 WETH to a WBTC/USDC/WETH Balancer pool
+
+```
+const balancerPoolId = "0x03cd191f589d12b0582a99808cf19851e468e6b500010000000000000000000a"
+const assets = [WBTC_TOKEN_ADDRESS, USDC_TOKEN_ADDRESS, WETH_TOKEN_ADDRESS];
+const amounts = ["2000", "1000000", "200000000000000"];
+const tx = await pool.joinBalancerPool(balancerPoolId, assets, amounts)
+```
+
+Remove all tokens from WBTC/USDC/WETH Balancer pool
+
+```
+const amount = await dhedge.utils.getBalance(BALANCER_LP_TOKEN_ADDRESS, pool.address)
+const tx = await pool.exitBalancerPool(balancerPoolId, assets, amount)
+```
+
+Harvest rewards from Balancer
+
+```
+const tx = await pool.harvestBalancerRewards()
+```
+
 ### Staking
 
 Approve unlimited amound of SLP USDC-DAI token for staking on Sushiswap
@@ -226,3 +248,38 @@ const tx = await pool.harvestRewards(
   "SLP_USDC_DAI_TOKEN_ADDRESS"
 )
 ```
+
+### Lending/Borrowing Aave
+
+Deposit 1 USDC into Aave lending pool
+
+```
+const tx = await pool.lend(Dapp.AAVE, USDC_TOKEN_ADDRESS, "1000000")
+```
+
+Withdraw 1 USDC from Aave lending pool
+
+```
+const tx = await pool.withdrawDeposit(Dapp.AAVE, USDC_TOKEN_ADDRESS, "1000000")
+```
+
+Borrow 0.0001 WETH from Aave lending pool
+
+```
+const tx = await pool.borrow(Dapp.AAVE, WETH_TOKEN_ADDRESS, "100000000000000");
+```
+
+Repay 0.0001 WETH to Aave lending pool
+
+```
+const tx = await pool.repay(Dapp.AAVE, WETH_TOKEN_ADDRESS, "100000000000000");
+```
+
+Harvest rewards from Aave
+
+```
+const tx = await pool.harvestAaveRewards([
+    AAVE_USDC_ADDRESS,
+    AAVE_WETH_DEBT_ADDRESS
+  ]);
+```

package/dist/config.d.ts

@@ -5,3 +5,5 @@ export declare const routerAddress: AddressDappNetworkMap;
 export declare const dappFactoryAddress: AddressDappNetworkMap;
 export declare const stakingAddress: AddressDappNetworkMap;
 export declare const networkChainIdMap: NetworkChainIdMap;
+export declare const balancerSubgraph: AddressNetworkMap;
+export declare const multiCallAddress: AddressNetworkMap;

package/dist/entities/pool.d.ts

@@ -163,4 +163,36 @@ export declare class Pool {
      * @returns {Promise<any>} Transaction
      */
     setTrader(trader: string, options?: any): Promise<any>;
+    /**
+     * Invest into a Balancer pool
+     * @param {string} poolId Balancer pool id
+     * @param {string[] | } assetsIn Array of balancer pool assets
+     * @param {BigNumber[] | string[]} amountsIn Array of maximum amounts to provide to pool
+     * @param {any} options Transaction options
+     * @returns {Promise<any>} Transaction
+     */
+    joinBalancerPool(poolId: string, assets: string[], amountsIn: string[] | BigNumber[], options?: any): Promise<any>;
+    /**
+     * Invest into a Balancer pool
+     * @param {string} poolId Balancer pool id
+     * @param {string[] | } assets Array of balancer pool assets
+     * @param {BigNumber | string } amount Amount of pool tokens to withdraw
+     * @param {any} options Transaction options
+     * @returns {Promise<any>} Transaction
+     */
+    exitBalancerPool(poolId: string, assets: string[], amount: string | BigNumber, options?: any): Promise<any>;
+    /**
+     * Claim rewards from Balancer pools
+     * @param {string[]} assets Array of tokens being claimed
+     * @param {any} options Transaction options
+     * @returns {Promise<any>} Transaction
+     */
+    harvestBalancerRewards(options?: any): Promise<any>;
+    /**
+     * Claim rewards from Aave platform
+     * @param {string[]} assets Aave tokens (deposit/debt) hold by pool
+     * @param {any} options Transaction options
+     * @returns {Promise<any>} Transaction
+     */
+    harvestAaveRewards(assets: string[], options?: any): Promise<any>;
 }

package/dist/entities/utils.d.ts

@@ -1,5 +1,6 @@
 import { ethers, Wallet } from "ethers";
 import { Dapp, Network, Reserves } from "../types";
+import { Pool } from ".";
 export declare class Utils {
     network: Network;
     signer: Wallet;
@@ -40,4 +41,7 @@ export declare class Utils {
      * @returns {Promise<ethers.BigNumber>} Reserves of the assets in BigNumber
      */
     getMinAmountOut(dapp: Dapp, assetFrom: string, assetTo: string, amountIn: string | ethers.BigNumber, slippage: number): Promise<ethers.BigNumber>;
+    getBalancerSwapTx(pool: Pool, assetFrom: string, assetTo: string, amountIn: ethers.BigNumber | string, slippage: number): Promise<any>;
+    getBalancerJoinPoolTx(pool: Pool, balancerPoolId: string, assets: string[], amountsIn: string[] | ethers.BigNumber[]): Promise<any>;
+    getBalancerExitPoolTx(pool: Pool, balancerPoolId: string, assets: string[], amount: string | ethers.BigNumber): Promise<any>;
 }

package/dist/services/claim-balancer/claim.service.d.ts

@@ -0,0 +1,21 @@
+import { ethers, Wallet } from "ethers";
+import { MultiTokenCurrentRewardsEstimate, MultiTokenPendingClaims, TokenClaimInfo } from "./types";
+import { Network } from "../../types";
+export declare class ClaimService {
+    network: Network;
+    signer: ethers.Wallet;
+    constructor(network: Network, signer: Wallet);
+    getMultiTokensPendingClaims(account: string): Promise<MultiTokenPendingClaims[]>;
+    getTokenPendingClaims(tokenClaimInfo: TokenClaimInfo, account: string): Promise<MultiTokenPendingClaims>;
+    getMultiTokensCurrentRewardsEstimate(account: string): Promise<{
+        data: MultiTokenCurrentRewardsEstimate[];
+        timestamp: string | null;
+    }>;
+    multiTokenClaimRewards(account: string, multiTokenPendingClaims: MultiTokenPendingClaims[]): Promise<any>;
+    private computeClaimProofs;
+    private computeClaimProof;
+    private getTokenClaimsInfo;
+    private getSnapshot;
+    private getClaimStatus;
+    private getReports;
+}

package/dist/services/claim-balancer/claim.worker.d.ts

@@ -0,0 +1,4 @@
+import { ComputeClaimProofPayload } from "./types";
+export declare class ClaimWorker {
+    calcClaimProof(payload: ComputeClaimProofPayload): any;
+}

package/dist/services/claim-balancer/ipfs.service.d.ts

@@ -0,0 +1,4 @@
+export default class IpfsService {
+    get<T>(hash: string, protocol?: string): Promise<T>;
+}
+export declare const ipfsService: IpfsService;

package/dist/services/claim-balancer/types.d.ts

@@ -0,0 +1,54 @@
+export interface Claim {
+    id: string;
+    amount: string;
+}
+export declare type Snapshot = Record<number, string>;
+export declare type TokenClaimInfo = {
+    label: string;
+    distributor: string;
+    token: string;
+    decimals: number;
+    manifest: string;
+    weekStart: number;
+};
+export declare type MultiTokenPendingClaims = {
+    claims: Claim[];
+    reports: Report;
+    tokenClaimInfo: TokenClaimInfo;
+    availableToClaim: string;
+};
+export declare type ClaimStatus = boolean;
+export declare type Report = Record<string, any>;
+export declare 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 declare type MultiTokenCurrentRewardsEstimate = {
+    rewards: string;
+    velocity: string;
+    token: string;
+};
+export declare type ClaimProofTuple = [number, string, string, number, string[]];
+export declare type ComputeClaimProofPayload = {
+    report: Report;
+    account: string;
+    claim: Claim;
+    distributor: string;
+    tokenIndex: number;
+    decimals: number;
+};
+export declare type ClaimWorkerMessage<P = any> = {
+    type: "computeClaimProof";
+    payload: P;
+};

package/dist/test/constants.d.ts

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

package/dist/types.d.ts

@@ -7,14 +7,16 @@ export declare enum Dapp {
     SUSHISWAP = "sushiswap",
     AAVE = "aave",
     ONEINCH = "1inch",
-    QUICKSWAP = "quickswap"
+    QUICKSWAP = "quickswap",
+    BALANCER = "balancer"
 }
 export declare enum Transaction {
     SWAP = "swapExactTokensForTokens",
     ADD_LIQUIDITY = "addLiquidity",
     DEPOSIT = "deposit",
     HARVEST = "harvest",
-    UNSTAKE = "withdrawAndHarvest",
+    CLAIM_DISTRIBIUTIONS = "claimDistributions",
+    CLAIM_REWARDS = "claimRewards",
     REMOVE_LIQUIDITY = "removeLiquidity",
     BORROW = "borrow",
     REPAY = "repay",
@@ -26,6 +28,7 @@ export declare type AddressDappMap = {
     [Dapp.AAVE]?: string;
     [Dapp.ONEINCH]?: string;
     [Dapp.QUICKSWAP]?: string;
+    [Dapp.BALANCER]?: string;
 };
 export declare type AddressDappNetworkMap = Readonly<Record<Network, AddressDappMap>>;
 export declare type SupportedAsset = [string, boolean];

package/dist/utils/contract.d.ts

@@ -0,0 +1,14 @@
+import { ethers, Network } from "..";
+export declare function call(provider: ethers.Signer, abi: any[], call: any[], options?: any): Promise<any>;
+export declare function multicall<T>(network: Network, provider: ethers.Signer, abi: any[], calls: any[], options?: any, requireSuccess?: boolean): Promise<(T | null)[]>;
+export declare class Multicaller {
+    network: Network;
+    provider: ethers.Signer;
+    abi: any[];
+    options: any;
+    calls: any[];
+    paths: any[];
+    constructor(network: Network, provider: ethers.Signer, abi: any[]);
+    call(path: any, address: any, fn: any, params?: any): Multicaller;
+    execute(from?: any): Promise<any>;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+import BigNumber from "bignumber.js";
+import { MerkleTree } from "./merkle";
+export declare function scale(input: BigNumber | string, decimalPlaces: number): BigNumber;
+export declare function loadTree(balances: {
+    [x: string]: string | BigNumber;
+}, decimals?: number): MerkleTree;
+export declare function bnum(val: string | number | BigNumber): BigNumber;

package/dist/utils/merkle.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import BigNumber from "bignumber.js";
+export declare class MerkleTree {
+    elements: any;
+    layers: any;
+    constructor(elements: any[]);
+    getLayers(elements: string | any[]): (string | any[])[];
+    getNextLayer(elements: any[]): any[];
+    combinedHash(first: any, second: any): any;
+    getRoot(): any;
+    getHexRoot(): string;
+    getProof(el: any): any;
+    getHexProof(_el: any): string[];
+    getPairElement(idx: number, layer: string | any[]): any;
+    bufIndexOf(el: string | any[], arr: string | any[]): number;
+    bufDedup(elements: any[]): any[];
+    bufArrToHexArr(arr: any[]): string[];
+    sortAndConcat(...args: any[]): Buffer;
+}
+export declare function loadTree(balances: {
+    [x: string]: string | BigNumber;
+}, decimals?: number): MerkleTree;