@dhedge/v2-sdk 1.0.0 → 1.2.0

package/README.md

@@ -117,6 +117,15 @@ const usdcDepositAmount = "100000"
 const tx = await pool.deposit("USDC_TOKEN_ADDRESS", usdcDepositAmount);
 ```
 
+### Withdraw from pool
+
+Withdraw 1.00002975 pool tokens. Note that this cannot be called if set as Trader account
+
+```
+const poolTokensWithdrawAmount = "1000029750000000000"
+const tx = await pool.withdraw(poolTokensWithdrawAmount);
+```
+
 ### Approve pool asset for trading & staking
 
 Before trading an asset on platforms like Sushiswap it needs to be approved.
@@ -133,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
 )
 ```
 
@@ -175,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
@@ -217,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

@@ -1,5 +1,9 @@
 import { AddressNetworkMap, AddressDappNetworkMap } from "./types";
+import { NetworkChainIdMap } from ".";
 export declare const factoryAddress: AddressNetworkMap;
 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/dhedge.d.ts

@@ -16,9 +16,10 @@ export declare class Dhedge {
      * @param {string} symbol Token symbol
      * @param {tuple[]} supportedAssets Enabled assets to trade
      * @param {number|BigNumber} managerFeeNumerator Manger fee in percent
+     * @param {any} options Transaction options
      * @returns {Pool} Created Pool
      */
-    createPool(managerName: string, poolName: string, symbol: string, supportedAssets: SupportedAsset[], managerFeeNumerator?: number): Promise<Pool>;
+    createPool(managerName: string, poolName: string, symbol: string, supportedAssets: SupportedAsset[], managerFeeNumerator?: number, options?: any): Promise<Pool>;
     /**
      * Load a pool based on the provided address
      * @param {string} address Pool address

package/dist/entities/pool.d.ts

@@ -18,38 +18,43 @@ export declare class Pool {
      * Approve the asset that can be deposited into a pool
      * @param {string} nasset Address of deposit asset
      * @param {BigNumber | string} amount Amount to be approved
+     * @param {any} options Transaction options
      * @returns {Promise<any>} Transaction
      */
-    approveDeposit(asset: string, amount: BigNumber | string): Promise<any>;
+    approveDeposit(asset: string, amount: BigNumber | string, options?: any): Promise<any>;
     /**
      * Deposit  asset into a pool
      * @param {string} asset Address of asset
      * @param {BigNumber | string} amount Amount to be deposited
+     * @param {any} options Transaction options
      * @returns {Promise<any>} Transaction
      */
-    deposit(asset: string, amount: string | BigNumber): Promise<any>;
+    deposit(asset: string, amount: string | BigNumber, options?: any): Promise<any>;
     /**
      * Withdraw  assets from a pool
      * @param fundTokenAmount Amount of pool tokens to be withdrawn
+     * @param {any} options Transaction options
      * @returns {Promise<any>} Transaction
      */
-    withdraw(fundTokenAmount: string | BigNumber): Promise<any>;
+    withdraw(fundTokenAmount: string | BigNumber, options?: any): Promise<any>;
     /**
      * Approve the asset for trading and providing liquidity
      * @param {Dapp} dapp Platform like Sushiswap or Uniswap
      * @param {string} asset Address of asset
      * @param @param {BigNumber | string} Amount to be approved
+     * @param {any} options Transaction options
      * @returns {Promise<any>} Transaction
      */
-    approve(dapp: Dapp, asset: string, amount: BigNumber | string): Promise<any>;
+    approve(dapp: Dapp, asset: string, amount: BigNumber | string, options?: any): Promise<any>;
     /**
      * Approve the liquidity pool token for staking
      * @param {Dapp} dapp Platform like Sushiswap or Uniswap
      * @param {string} asset Address of liquidity pool token
      * @param {BigNumber | string} amount Aamount to be approved
+     * @param {any} options Transaction options
      * @returns {Promise<any>} Transaction
      */
-    approveStaking(dapp: Dapp, asset: string, amount: BigNumber | string): Promise<any>;
+    approveStaking(dapp: Dapp, asset: string, amount: BigNumber | string, options?: any): Promise<any>;
     /**
      * Trade an asset into another asset
      * @param {Dapp} dapp Platform like Sushiswap or Uniswap
@@ -57,9 +62,10 @@ export declare class Pool {
      * @param {string} assetTo Asset to trade into
      * @param {BigNumber | string} amountIn Amount
      * @param {BigNumber | string} minAmountOut Minumum amount to receive
+     * @param {any} options Transaction options
      * @returns {Promise<any>} Transaction
      */
-    trade(dapp: Dapp, assetFrom: string, assetTo: string, amountIn: BigNumber | string, minAmountOut: BigNumber | string): Promise<any>;
+    trade(dapp: Dapp, assetFrom: string, assetTo: string, amountIn: BigNumber | string, slippage?: number, options?: any): Promise<any>;
     /**
      * Add liquidity to a liquidity pool
      * @param {Dapp} dapp Platform like Sushiswap or Uniswap
@@ -67,51 +73,126 @@ export declare class Pool {
      * @param {string} assetB Second asset
      * @param {BigNumber | string} amountA Amount first asset
      * @param {BigNumber | string} amountB Amount second asset
+     * @param {any} options Transaction options
      * @returns {Promise<any>} Transaction
      */
-    addLiquidity(dapp: Dapp, assetA: string, assetB: string, amountA: BigNumber | string, amountB: BigNumber | string): Promise<any>;
+    addLiquidity(dapp: Dapp, assetA: string, assetB: string, amountA: BigNumber | string, amountB: BigNumber | string, options?: any): Promise<any>;
     /**
      * Remove liquidity from a liquidity pool
      * @param {Dapp} dapp Platform like Sushiswap or Uniswap
      * @param {string} assetA First asset
      * @param {string} assetB Second asset
      * @param {BigNumber | string} amount Amount of liquidity pool tokens
+     * @param {any} options Transaction options
      * @returns {Promise<any>} Transaction
      */
-    removeLiquidity(dapp: Dapp, assetA: string, assetB: string, amount: string | BigNumber): Promise<any>;
+    removeLiquidity(dapp: Dapp, assetA: string, assetB: string, amount: string | BigNumber, options?: any): Promise<any>;
     /**
      * Stake liquidity pool tokens in a yield farm
      * @param {Dapp} dapp Platform like Sushiswap or Uniswap
      * @param {string} asset Liquidity pool token
      * @param {BigNumber | string} amount Amount of liquidity pool tokens
+     * @param {any} options Transaction options
      * @returns {Promise<any>} Transaction
      */
-    stake(dapp: Dapp, asset: string, amount: BigNumber | string): Promise<any>;
+    stake(dapp: Dapp, asset: string, amount: BigNumber | string, options?: any): Promise<any>;
     /**
      * Unstake liquidity pool tokens from a yield farm
      * @param {Dapp} dapp Platform like Sushiswap or Uniswap
      * @param {string} asset Liquidity pool token
      * @param  {BigNumber | string} amount Amount of liquidity pool tokens
+     * @param {any} options Transaction options
      * @returns {Promise<any>} Transaction
      */
-    unStake(dapp: Dapp, asset: string, amount: BigNumber | string): Promise<any>;
+    unStake(dapp: Dapp, asset: string, amount: BigNumber | string, options?: any): Promise<any>;
+    /**
+     * Lend asset to a lending pool
+     * @param {Dapp} dapp Platform like Aave
+     * @param {string} asset Asset
+     * @param  {BigNumber | string} amount Amount of asset to lend
+     * @param {any} options Transaction options
+     * @returns {Promise<any>} Transaction
+     */
+    lend(dapp: Dapp, asset: string, amount: BigNumber | string, options?: any): Promise<any>;
+    /**
+     * Witdraw asset from a lending pool
+     * @param {Dapp} dapp Platform like Aave
+     * @param {string} asset Asset
+     * @param  {BigNumber | string} amount Amount of asset to lend
+     * @param {any} options Transaction options
+     * @returns {Promise<any>} Transaction
+     */
+    withdrawDeposit(dapp: Dapp, asset: string, amount: BigNumber | string, options?: any): Promise<any>;
+    /**
+     * Borrow asset from a lending pool
+     * @param {Dapp} dapp Platform like Aave
+     * @param {string} asset Asset
+     * @param  {BigNumber | string} amount Amount of asset to lend
+     * @param {any} options Transaction options
+     * @returns {Promise<any>} Transaction
+     */
+    borrow(dapp: Dapp, asset: string, amount: BigNumber | string, options?: any): Promise<any>;
+    /**
+     * Repays borrowed asset to a lending pool
+     * @param {Dapp} dapp Platform like Aave
+     * @param {string} asset Asset
+     * @param  {BigNumber | string} amount Amount of asset to lend
+     * @param {any} options Transaction options
+     * @returns {Promise<any>} Transaction
+     */
+    repay(dapp: Dapp, asset: string, amount: BigNumber | string, options?: any): Promise<any>;
     /**
      * Claim rewards of staked liquidity pool tokens
      * @param {Dapp} dapp Platform like Sushiswap or Uniswap
      * @param {string} asset Liquidity pool token
+     * @param {any} options Transaction options
      * @returns {Promise<any>} Transaction
      */
-    harvestRewards(dapp: Dapp, asset: string): Promise<any>;
+    harvestRewards(dapp: Dapp, asset: string, options?: any): Promise<any>;
     /**
      * Change enabled pool assets
      * @param {AssetEnabled[]} assets New pool assets
+     * @param {any} options Transaction options
      * @returns {Promise<any>} Transaction
      */
-    changeAssets(assets: AssetEnabled[]): Promise<any>;
+    changeAssets(assets: AssetEnabled[], options?: any): Promise<any>;
     /**
      * Set a new trader with trading permissions
      * @param {string} trader Address trader account
+     * @param {any} options Transaction options
+     * @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
      */
-    setTrader(trader: string): Promise<any>;
+    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;
@@ -29,4 +30,18 @@ export declare class Utils {
      * @returns { BigNumber } Balance of asset
      */
     getBalance(asset: string, owner: string): Promise<ethers.BigNumber>;
+    /**
+     * 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
+     */
+    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

@@ -1,21 +1,34 @@
+import { ChainId } from "@sushiswap/sdk";
 import { BigNumber } from "ethers";
 export declare enum Network {
     POLYGON = "polygon"
 }
 export declare enum Dapp {
-    SUSHISWAP = "sushiswap"
+    SUSHISWAP = "sushiswap",
+    AAVE = "aave",
+    ONEINCH = "1inch",
+    QUICKSWAP = "quickswap",
+    BALANCER = "balancer"
 }
 export declare enum Transaction {
     SWAP = "swapExactTokensForTokens",
     ADD_LIQUIDITY = "addLiquidity",
     DEPOSIT = "deposit",
     HARVEST = "harvest",
-    UNSTAKE = "withdrawAndHarvest",
-    REMOVE_LIQUIDITY = "removeLiquidity"
+    CLAIM_DISTRIBIUTIONS = "claimDistributions",
+    CLAIM_REWARDS = "claimRewards",
+    REMOVE_LIQUIDITY = "removeLiquidity",
+    BORROW = "borrow",
+    REPAY = "repay",
+    WITHDRAW = "withdraw"
 }
 export declare type AddressNetworkMap = Readonly<Record<Network, string>>;
 export declare type AddressDappMap = {
     [Dapp.SUSHISWAP]?: string;
+    [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];
@@ -33,3 +46,4 @@ export declare type Reserves = {
     assetA: BigNumber;
     assetB: BigNumber;
 };
+export declare type NetworkChainIdMap = Readonly<Record<Network, ChainId>>;

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;