@dhedge/v2-sdk 1.1.1 → 1.3.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

@@ -4,4 +4,11 @@ export declare const factoryAddress: AddressNetworkMap;
 export declare const routerAddress: AddressDappNetworkMap;
 export declare const dappFactoryAddress: AddressDappNetworkMap;
 export declare const stakingAddress: AddressDappNetworkMap;
+export declare const nonfungiblePositionManagerAddress: AddressNetworkMap;
 export declare const networkChainIdMap: NetworkChainIdMap;
+export declare const balancerSubgraph: AddressNetworkMap;
+export declare const multiCallAddress: AddressNetworkMap;
+export declare const deadline: number;
+export declare const MaxUint128 = "0xffffffffffffffffffffffffffffffff";
+export declare const UNISWAPV3_QUOTER_ADDRESS = "0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6";
+export declare const SYNTHETIX_TRACKING_CODE = "0x4448454447450000000000000000000000000000000000000000000000000000";

package/dist/entities/pool.d.ts

@@ -1,14 +1,16 @@
 import { Contract, Wallet, BigNumber } from "ethers";
 import { Dapp, FundComposition, AssetEnabled, Network } from "../types";
 import { Utils } from "./utils";
+import { FeeAmount } from "@uniswap/v3-sdk";
 export declare class Pool {
     readonly poolLogic: Contract;
     readonly managerLogic: Contract;
+    readonly factory: Contract;
     readonly signer: Wallet;
     readonly address: string;
     readonly utils: Utils;
     readonly network: Network;
-    constructor(network: Network, signer: Wallet, poolLogic: Contract, mangerLogic: Contract, utils: Utils);
+    constructor(network: Network, signer: Wallet, poolLogic: Contract, mangerLogic: Contract, utils: Utils, factory: Contract);
     /**
      * Return the assets with balances and deposit info of a pool
      * @returns {Promise<FundComposition[]>} Composition of assets with balance, deposit info
@@ -55,13 +57,22 @@ export declare class Pool {
      * @returns {Promise<any>} Transaction
      */
     approveStaking(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
+     */
+    approveUniswapV3Liquidity(asset: string, amount: BigNumber | string, options?: any): Promise<any>;
     /**
      * Trade an asset into another asset
      * @param {Dapp} dapp Platform like Sushiswap or Uniswap
      * @param {string} assetFrom Asset to trade from
      * @param {string} assetTo Asset to trade into
      * @param {BigNumber | string} amountIn Amount
-     * @param {BigNumber | string} minAmountOut Minumum amount to receive
+     * @param {number} slippage Slippage tolerance in %
      * @param {any} options Transaction options
      * @returns {Promise<any>} Transaction
      */
@@ -109,11 +120,12 @@ export declare class Pool {
      * 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 {BigNumber | string} amount Amount of asset to lend
+     * @param {number} referrralCode Code from Aave referral program
      * @param {any} options Transaction options
      * @returns {Promise<any>} Transaction
      */
-    lend(dapp: Dapp, asset: string, amount: BigNumber | string, options?: any): Promise<any>;
+    lend(dapp: Dapp, asset: string, amount: BigNumber | string, referrralCode?: number, options?: any): Promise<any>;
     /**
      * Witdraw asset from a lending pool
      * @param {Dapp} dapp Platform like Aave
@@ -128,10 +140,11 @@ export declare class Pool {
      * @param {Dapp} dapp Platform like Aave
      * @param {string} asset Asset
      * @param  {BigNumber | string} amount Amount of asset to lend
+     * @param {number} referrralCode Code from Aave referral program
      * @param {any} options Transaction options
      * @returns {Promise<any>} Transaction
      */
-    borrow(dapp: Dapp, asset: string, amount: BigNumber | string, options?: any): Promise<any>;
+    borrow(dapp: Dapp, asset: string, amount: BigNumber | string, referrralCode?: number, options?: any): Promise<any>;
     /**
      * Repays borrowed asset to a lending pool
      * @param {Dapp} dapp Platform like Aave
@@ -163,4 +176,87 @@ 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>;
+    /**
+     * Create UniswapV3 liquidity pool
+     * @param {string} assetA First asset
+     * @param {string} assetB Second asset
+     * @param {BigNumber | string} amountA Amount first asset
+     * @param {BigNumber | string} amountB Amount second asset
+     * @param { number } minPrice Lower price range (assetB per assetA)
+     * @param { number } maxPrice Upper price range (assetB per assetA)
+     * @param { number } minTick Lower tick range
+     * @param { number } maxTick Upper tick range
+     * @param { FeeAmount } feeAmount Fee tier (Low 0.05%, Medium 0.3%, High 1%)
+     * @param {any} options Transaction options
+     * @returns {Promise<any>} Transaction
+     */
+    addLiquidityUniswapV3(assetA: string, assetB: string, amountA: BigNumber | string, amountB: BigNumber | string, minPrice: number | null, maxPrice: number | null, minTick: number | null, maxTick: number | null, feeAmount: FeeAmount, options?: any): Promise<any>;
+    /**
+     * Remove liquidity from an UniswapV3 liquidity pool
+     * @param {string} tokenId Token Id of UniswapV3 position
+     * @param {number} amount Amount in percent of assets to be removed
+     * @param {any} options Transaction options
+     * @returns {Promise<any>} Transaction
+     */
+    removeLiquidityUniswapV3(tokenId: string, amount?: number, options?: any): Promise<any>;
+    /**
+     * Increase liquidity of an UniswapV3 liquidity pool
+     * @param {string} tokenId Token Id of UniswapV3 position
+     * @param {BigNumber | string} amountA Amount first asset
+     * @param {BigNumber | string} amountB Amount second asset
+     * @param {any} options Transaction options
+     * @returns {Promise<any>} Transaction
+     */
+    increaseLiquidityUniswapV3(tokenId: string, amountA: BigNumber | string, amountB: BigNumber | string, options?: any): Promise<any>;
+    /**
+     * Claim fees of an UniswapV3 liquidity pool
+     * @param {string} tokenId Token Id of UniswapV3 position
+     * @param {any} options Transaction options
+     * @returns {Promise<any>} Transaction
+     */
+    claimFeesUniswapV3(tokenId: string, options?: any): Promise<any>;
+    /**
+     * Trade an asset into another asset
+     * @param {Dapp} dapp Platform like Sushiswap or Uniswap
+     * @param {string} assetFrom Asset to trade from
+     * @param {string} assetTo Asset to trade into
+     * @param {BigNumber | string} amountIn Amount
+     * @param { FeeAmount } feeAmount Fee tier (Low 0.05%, Medium 0.3%, High 1%)
+     * @param {number} slippage Slippage tolerance in %
+     * @param {any} options Transaction options
+     * @returns {Promise<any>} Transaction
+     */
+    tradeUniswapV3(assetFrom: string, assetTo: string, amountIn: BigNumber | string, feeAmount: FeeAmount, slippage?: number, 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,6 +30,12 @@ export declare class Utils {
      * @returns { BigNumber } Balance of asset
      */
     getBalance(asset: string, owner: string): Promise<ethers.BigNumber>;
+    /**
+     * Returns the decimals of an asset (ERC20) token
+     * @param {string} asset string token address
+     * @returns { number } Balance of asset
+     */
+    getDecimals(asset: string): Promise<number>;
     /**
      * Return the minimum amount out for a trade between two assets
      * given the trade amount and slippage
@@ -40,4 +47,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,17 @@
+import { ethers, Wallet } from "ethers";
+import { 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>;
+    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/services/uniswap/V3Liquidity.d.ts

@@ -0,0 +1,9 @@
+import { Price, Token } from "@uniswap/sdk-core";
+import { FeeAmount } from "@uniswap/v3-sdk";
+import { ethers } from "ethers";
+import { Pool } from "../..";
+import { UniswapV3MintParams } from "./types";
+export declare function tryParsePrice(baseToken: Token, quoteToken: Token, value: string): Price<Token, Token>;
+export declare function tryParseTick(baseToken: Token, quoteToken: Token, feeAmount: FeeAmount, value: string): number;
+export declare function getUniswapV3MintParams(pool: Pool, assetA: string, assetB: string, amountA: string | ethers.BigNumber, amountB: string | ethers.BigNumber, minPrice: number | null, maxPrice: number | null, minTick: number | null, maxTick: number | null, feeAmount: FeeAmount): Promise<UniswapV3MintParams>;
+export declare function getUniswapV3Liquidity(tokenId: string, pool: Pool): Promise<ethers.BigNumber>;

package/dist/services/uniswap/V3Trade.d.ts

@@ -0,0 +1,4 @@
+import { FeeAmount } from "@uniswap/v3-sdk";
+import { ethers } from "ethers";
+import { Pool } from "../..";
+export declare function getUniswapV3SwapTxData(pool: Pool, assetA: string, assetB: string, amountIn: string | ethers.BigNumber, slippage: number, feeAmount: FeeAmount): Promise<any>;

package/dist/services/uniswap/types.d.ts

@@ -0,0 +1,3 @@
+import { FeeAmount } from "@uniswap/v3-sdk";
+import { ethers } from "ethers";
+export declare type UniswapV3MintParams = [string, string, FeeAmount, number, number, ethers.BigNumber | string, ethers.BigNumber | string, ethers.BigNumber | string, ethers.BigNumber | string, string, number];

package/dist/test/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const USDC = "0x7F5c764cBc14f9669B88837ca1490cCa17c31607";
+export declare const USDT = "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
+export declare const DAI = "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063";
+export declare const TUSD = "0x2e1ad108ff1d8c782fcbbb89aad783ac49586756";
+export declare const WETH = "0x4200000000000000000000000000000000000006";
+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 = "0xf36f550907872faaa02477f791df3ce33fe38854";

package/dist/test/txOptions.d.ts

@@ -0,0 +1 @@
+export declare const getTxOptions: () => Promise<any>;

package/dist/types.d.ts

@@ -1,24 +1,35 @@
-import { ChainId } from "@sushiswap/sdk";
 import { BigNumber } from "ethers";
 export declare enum Network {
-    POLYGON = "polygon"
+    POLYGON = "polygon",
+    OPTIMISM = "optimism"
 }
 export declare enum Dapp {
     SUSHISWAP = "sushiswap",
     AAVE = "aave",
     ONEINCH = "1inch",
-    QUICKSWAP = "quickswap"
+    QUICKSWAP = "quickswap",
+    BALANCER = "balancer",
+    UNISWAPV3 = "uniswapV3",
+    SYNTHETIX = "synthetix"
 }
 export declare enum Transaction {
     SWAP = "swapExactTokensForTokens",
     ADD_LIQUIDITY = "addLiquidity",
     DEPOSIT = "deposit",
     HARVEST = "harvest",
-    UNSTAKE = "withdrawAndHarvest",
+    CLAIM_DISTRIBIUTIONS = "claimDistributions",
+    CLAIM_REWARDS = "claimRewards",
     REMOVE_LIQUIDITY = "removeLiquidity",
+    DECREASE_LIQUIDITY = "decreaseLiquidity",
+    INCREASE_LIQUIDITY = "increaseLiquidity",
+    COLLECT = "collect",
+    MULTI_CALL = "multicall",
     BORROW = "borrow",
     REPAY = "repay",
-    WITHDRAW = "withdraw"
+    WITHDRAW = "withdraw",
+    MINT = "mint",
+    BURN = "burn",
+    SWAP_SYNTHS = "exchangeWithTracking"
 }
 export declare type AddressNetworkMap = Readonly<Record<Network, string>>;
 export declare type AddressDappMap = {
@@ -26,6 +37,9 @@ export declare type AddressDappMap = {
     [Dapp.AAVE]?: string;
     [Dapp.ONEINCH]?: string;
     [Dapp.QUICKSWAP]?: string;
+    [Dapp.BALANCER]?: string;
+    [Dapp.UNISWAPV3]?: string;
+    [Dapp.SYNTHETIX]?: string;
 };
 export declare type AddressDappNetworkMap = Readonly<Record<Network, AddressDappMap>>;
 export declare type SupportedAsset = [string, boolean];
@@ -43,4 +57,4 @@ export declare type Reserves = {
     assetA: BigNumber;
     assetB: BigNumber;
 };
-export declare type NetworkChainIdMap = Readonly<Record<Network, ChainId>>;
+export declare type NetworkChainIdMap = Readonly<Record<Network, number>>;

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;