@dhedge/v2-sdk 1.8.1 → 1.8.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhedge/v2-sdk",
-  "version": "1.8.1",
+  "version": "1.8.3",
   "license": "MIT",
   "description": "🛠 An SDK for building applications on top of dHEDGE V2",
   "main": "dist/index.js",

package/src/abi/IArrakisV1RouterStaking.json

@@ -27,6 +27,11 @@
           "name": "amount1Min",
           "type": "uint256"
         },
+        {
+          "internalType": "uint256",
+          "name": "amountSharesMin",
+          "type": "uint256"
+        },
         {
           "internalType": "address",
           "name": "receiver",

package/src/config.ts

@@ -27,7 +27,7 @@ export const routerAddress: AddressDappNetworkMap = {
     [Dapp.QUICKSWAP]: "0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff",
     [Dapp.BALANCER]: "0xBA12222222228d8Ba445958a75a0704d566BF2C8",
     [Dapp.UNISWAPV3]: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
-    [Dapp.ARRAKIS]: "0xbc91a120cCD8F80b819EAF32F0996daC3Fa76a6C",
+    [Dapp.ARRAKIS]: "0xc73fb100a995b33f9fa181d420f4c8d74506df66",
     [Dapp.TOROS]: "0xB2F1498983bf9c9442c35F772e6C1AdE66a8DeDE"
   },
   [Network.OPTIMISM]: {
@@ -38,7 +38,7 @@ export const routerAddress: AddressDappNetworkMap = {
     [Dapp.TOROS]: "0x3988513793bCE39f0167064A9F7fC3617FaF35AB",
     [Dapp.VELODROME]: "0x9c12939390052919aF3155f41Bf4160Fd3666A6f",
     [Dapp.LYRA]: "0xCCE7819d65f348c64B7Beb205BA367b3fE33763B",
-    [Dapp.ARRAKIS]: "0x86d62a8ad19998e315e6242b63eb73f391d4674b"
+    [Dapp.ARRAKIS]: "0x9ce88a56d120300061593eF7AD074A1B710094d5"
   }
 };
 

package/src/entities/pool.ts

@@ -998,6 +998,7 @@ export class Pool {
         amountB,
         0,
         0,
+        0,
         this.address
       ]);
     } else {
@@ -1242,11 +1243,12 @@ export class Pool {
     changeAmount: BigNumber | string,
     options: any = null
   ): Promise<any> {
-    const tx = await this.poolLogic.execTransaction(
+    const txData = await getFuturesChangePositionTxData(
+      changeAmount,
       market,
-      getFuturesChangePositionTxData(changeAmount),
-      options
+      this
     );
+    const tx = await this.poolLogic.execTransaction(market, txData, options);
     return tx;
   }
 }

package/src/services/futures/constants.ts

@@ -1,4 +1 @@
-import { BigNumber } from "ethers";
-
-export const PRICE_IMPACT_DELTA = BigNumber.from("500000000000000000");
 export const FUTURES_TRACKING = "DHEDGE";

package/src/services/futures/trade.ts

@@ -1,15 +1,26 @@
-import { ethers } from "../..";
-import { FUTURES_TRACKING, PRICE_IMPACT_DELTA } from "./constants";
+import { Pool, ethers } from "../..";
+import { FUTURES_TRACKING } from "./constants";
 import ISynthetixFuturesMarketV2 from "../../abi/ISynthetixFuturesMarketV2.json";
 
-export function getFuturesChangePositionTxData(
-  amount: ethers.BigNumber | string
-): string {
+export async function getFuturesChangePositionTxData(
+  amount: ethers.BigNumber | string,
+  market: string,
+  pool: Pool
+): Promise<string> {
+  const futuresMarket = new ethers.Contract(
+    market,
+    ISynthetixFuturesMarketV2.abi,
+    pool.signer
+  );
+  const fillPrice = await futuresMarket.fillPrice(amount);
+  //Allows for +-0.5% price movements on the desired fill price
+  const adjustmentFactor = ethers.BigNumber.from(amount).lt(0) ? 995 : 1005;
+  const desiredFillPrice = fillPrice.price.mul(adjustmentFactor).div(1000);
   return new ethers.utils.Interface(
     ISynthetixFuturesMarketV2.abi
   ).encodeFunctionData("submitOffchainDelayedOrderWithTracking", [
     amount,
-    PRICE_IMPACT_DELTA,
+    desiredFillPrice,
     ethers.utils.formatBytes32String(FUTURES_TRACKING)
   ]);
 }

package/src/test/arrakis.test.ts

@@ -1,102 +1,95 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Dhedge, ethers } from "..";
+import { Dhedge, Pool } from "..";
+import { routerAddress } from "../config";
 import { Dapp, Network } from "../types";
-import { ARRAKIS_USDC_WETH_GAUGE, TEST_POOL, USDC, WETH } from "./constants";
-import { getTxOptions } from "./txOptions";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import { allowanceDelta, balanceDelta } from "./utils/token";
 
 import { wallet } from "./wallet";
 
+//const network = Network.OPTIMISM;
+const network = Network.POLYGON;
+const USDC = CONTRACT_ADDRESS[network].USDC;
+const WETH = CONTRACT_ADDRESS[network].WETH;
+
 let dhedge: Dhedge;
-let options: any;
+let pool: Pool;
 jest.setTimeout(100000);
 
 describe("pool", () => {
   beforeAll(async () => {
-    dhedge = new Dhedge(wallet, Network.OPTIMISM);
-    options = await getTxOptions(Network.OPTIMISM);
+    dhedge = new Dhedge(wallet, network);
+    pool = await dhedge.loadPool(TEST_POOL[network]);
+    await pool.approve(Dapp.ONEINCH, USDC, MAX_AMOUNT);
+    await pool.trade(Dapp.ONEINCH, USDC, WETH, "1000000", 0.5);
   });
 
   it("approves unlimited USDC on Arrakis", async () => {
-    const pool = await dhedge.loadPool(TEST_POOL);
-    const result = await pool.approve(
-      Dapp.ARRAKIS,
+    await pool.approve(Dapp.ARRAKIS, USDC, MAX_AMOUNT);
+    const usdcAllowanceDelta = await allowanceDelta(
+      pool.address,
       USDC,
-      ethers.constants.MaxInt256,
-      options
+      routerAddress[network].arrakis!,
+      pool.signer
     );
-    expect(result).not.toBe(null);
+    await expect(usdcAllowanceDelta.gt(0));
   });
 
   it("approves unlimited WETH on Arrakis", async () => {
-    const pool = await dhedge.loadPool(TEST_POOL);
-    const result = await pool.approve(
-      Dapp.ARRAKIS,
-      WETH,
-      ethers.constants.MaxInt256,
-      options
+    await pool.approve(Dapp.ARRAKIS, WETH, MAX_AMOUNT);
+    const wethAllowanceDelta = await allowanceDelta(
+      pool.address,
+      USDC,
+      routerAddress[network].arrakis!,
+      pool.signer
     );
-    console.log(result);
-    expect(result).not.toBe(null);
+    await expect(wethAllowanceDelta.gt(0));
   });
 
   it("should add liquidity and stake in an WETH/USDC Arrakis pool", async () => {
-    const pool = await dhedge.loadPool(TEST_POOL);
+    const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
     const wethBalance = await pool.utils.getBalance(WETH, pool.address);
-    const uasdBalance = await pool.utils.getBalance(USDC, pool.address);
-    const lpBalance = await pool.utils.getBalance(
-      ARRAKIS_USDC_WETH_GAUGE,
-      pool.address
-    );
-    const result = await pool.increaseLiquidity(
+    await pool.increaseLiquidity(
       Dapp.ARRAKIS,
-      ARRAKIS_USDC_WETH_GAUGE,
-      uasdBalance,
-      wethBalance,
-      options
+      CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
+      usdcBalance,
+      wethBalance
     );
-    result.wait(1);
-    const lpBalanceAfter = await pool.utils.getBalance(
-      ARRAKIS_USDC_WETH_GAUGE,
-      pool.address
+    const lpBalanceDelta = await balanceDelta(
+      pool.address,
+      CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_LP,
+      pool.signer
     );
-    expect(lpBalanceAfter.gt(lpBalance));
+    expect(lpBalanceDelta.gt(0));
   });
 
-  it("approves unlimited LP staking Token before on  Arrakis", async () => {
-    const pool = await dhedge.loadPool(TEST_POOL);
-    const result = await pool.approve(
+  it("approves unlimited LP staking Token before on Arrakis", async () => {
+    await pool.approve(
       Dapp.ARRAKIS,
-      ARRAKIS_USDC_WETH_GAUGE,
-      ethers.constants.MaxInt256,
-      options
+      CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
+      MAX_AMOUNT
+    );
+    const gaugeAllowanceDelta = await allowanceDelta(
+      pool.address,
+      CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
+      routerAddress[network].arrakis!,
+      pool.signer
     );
-    expect(result).not.toBe(null);
+    await expect(gaugeAllowanceDelta.gt(0));
   });
 
   it("should remove liquidity from an existing pool ", async () => {
-    const pool = await dhedge.loadPool(TEST_POOL);
-    const result = await pool.decreaseLiquidity(
+    await pool.decreaseLiquidity(
       Dapp.ARRAKIS,
-      ARRAKIS_USDC_WETH_GAUGE,
-      100,
-      options
+      CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
+      100
     );
-    result.wait(1);
-    const lpBalanceAfter = await pool.utils.getBalance(
-      ARRAKIS_USDC_WETH_GAUGE,
-      pool.address
+    const wethBalanceDelta = await balanceDelta(
+      pool.address,
+      CONTRACT_ADDRESS[network].WETH,
+      pool.signer
     );
-    expect(lpBalanceAfter.eq(0));
+    expect(wethBalanceDelta.gt(0));
   });
-
-  // it("should claim fees an existing pool", async () => {
-  //   const pool = await dhedge.loadPool(TEST_POOL);
-  //   const result = await pool.claimFees(
-  //     Dapp.ARRAKIS,
-  //     ARRAKIS_USDC_WETH_GAUGE,
-  //     options
-  //   );
-  //   console.log("result", result);
-  //   expect(result).not.toBe(null);
-  // });
 });

package/src/test/constants.ts

@@ -47,13 +47,17 @@ export const CONTRACT_ADDRESS = {
   [Network.POLYGON]: {
     USDC: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
     WETH: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619",
-    WBTC: "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6"
+    WBTC: "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6",
+    ARRAKIS_USDC_WETH_GAUGE: "0x33d1ad9Cd88A509397CD924C2d7613C285602C20",
+    ARRAKIS_USDC_WETH_LP: "0xa173340f1e942c2845bcbce8ebd411022e18eb13"
   },
   [Network.OPTIMISM]: {
     USDC: "0x7F5c764cBc14f9669B88837ca1490cCa17c31607",
     SUSD: "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9",
     WETH: "0x4200000000000000000000000000000000000006",
-    KWENTA_ETH_PERP_V2: "0x2b3bb4c683bfc5239b029131eef3b1d214478d93"
+    KWENTA_ETH_PERP_V2: "0x2b3bb4c683bfc5239b029131eef3b1d214478d93",
+    ARRAKIS_USDC_WETH_GAUGE: "0xd3a3fbae792c4ed0aa909ec032d3f14c999b2402",
+    ARRAKIS_USDC_WETH_LP: "0xc59d8fbc3d9a92d24a923722f0244a50daa2ea33"
   }
 };
 

package/src/test/futures.test.ts

@@ -29,9 +29,9 @@ describe("pool", () => {
     expect(sUSDBalanceDelta.abs().toString()).toBe(depositAmount);
   });
 
-  it("goes long ETH-PERP about 3x leverage", async () => {
-    //size 50*3/1600 (margin * leverage  / price)
-    const size = (0.09 * 1e18).toString();
+  it("goes long ETH-PERP about 2x leverage", async () => {
+    //size 50*2/2000 (margin * leverage  / price)
+    const size = (0.05 * 1e18).toString();
     const tx = await pool.changeFuturesPosition(perp, size);
     expect(tx).not.toBe(null);
   });