@drift-labs/sdk 0.1.2 → 0.1.8

package/README.md

@@ -5,7 +5,7 @@
 
   <p>
     <a href="https://www.npmjs.com/package/@drift-labs/sdk"><img alt="SDK npm package" src="https://img.shields.io/npm/v/@drift-labs/sdk" /></a>
-    <a href="https://docs.drift.trade/drift-sdk-documentation"><img alt="Docs" src="https://img.shields.io/badge/docs-tutorials-blueviolet" /></a>
+    <a href="https://drift-labs.github.io/protocol-v1/sdk/"><img alt="Docs" src="https://img.shields.io/badge/docs-tutorials-blueviolet" /></a>
     <a href="https://discord.com/channels/849494028176588802/878700556904980500"><img alt="Discord Chat" src="https://img.shields.io/discord/889577356681945098?color=blueviolet" /></a>
     <a href="https://opensource.org/licenses/Apache-2.0"><img alt="License" src="https://img.shields.io/github/license/project-serum/anchor?color=blueviolet" /></a>
   </p>
@@ -17,7 +17,7 @@ This repository provides open source access to Drift's Typescript SDK, Solana Pr
 
 # SDK Guide
 
-More of the SDK docs can be found on Drift's dedicated Docs hosted [here](https://docs.drift.trade/drift-sdk-documentation), and technical documentation of the SDK's code can be found [here](https://drift-labs.github.io/sdk/).
+The technical documentation for the SDK can be found [here](https://drift-labs.github.io/protocol-v1/sdk/), and you can visit Drift's general purpose documentation [here](https://docs.drift.trade/drift-sdk-documentation).
 
 ## Installation
 
@@ -38,7 +38,7 @@ solana address
 
 # Put the private key into your .env to be used by your bot
 cd {projectLocation}
-echo BOT_PRIVATE_KEY=`cat /Users/lukesteyn/.config/solana/id.json` >> .env
+echo BOT_PRIVATE_KEY=`cat ~/.config/solana/id.json` >> .env
 ```
 
 ## Concepts
@@ -64,16 +64,19 @@ The Drift SDK uses some common precisions, which are available as constants to i
 
 **Important Note for BigNum division**
 
-Because BN only supports integers, you need to be conscious of the numbers you are using when dividing. BN will always take the floor of the division, if you want to get the exact divison, you need to add the modulus of the two numbers as well. There is a helper function `convertToNumber` in the SDK which will do this for you.
+Because BN only supports integers, you need to be conscious of the numbers you are using when dividing. BN will return the floor when using the regular division function; if you want to get the exact divison, you need to add the modulus of the two numbers as well. There is a helper function `convertToNumber` in the SDK which will do this for you.
 
-```
-Example:
+```typescript
+import {convertToNumber} from @drift-labs/sdk
 
 // Gets the floor value
 new BN(10500).div(new BN(1000)).toNumber(); // = 10
 
 // Gets the exact value
 new BN(10500).div(new BN(1000)).toNumber() + BN(10500).mod(new BN(1000)).toNumber(); // = 10.5
+
+// Also gets the exact value
+convertToNumber(new BN(10500), new BN(1000)); // = 10.5
 ```
 
 ## Examples

package/lib/admin.d.ts

@@ -6,7 +6,7 @@ import { ClearingHouse } from './clearingHouse';
 export declare class Admin extends ClearingHouse {
     static from(connection: Connection, wallet: IWallet, clearingHouseProgramId: PublicKey, opts?: ConfirmOptions): Admin;
     initialize(usdcMint: PublicKey, adminControlsPrices: boolean): Promise<[TransactionSignature, TransactionSignature]>;
-    initializeMarket(marketIndex: BN, priceOracle: PublicKey, baseAmount: BN, quoteAmount: BN, periodicity: BN, pegMultiplier?: BN): Promise<TransactionSignature>;
+    initializeMarket(marketIndex: BN, priceOracle: PublicKey, baseAssetReserve: BN, quoteAssetReserve: BN, periodicity: BN, pegMultiplier?: BN): Promise<TransactionSignature>;
     moveAmmPrice(baseAssetReserve: BN, quoteAssetReserve: BN, marketIndex: BN): Promise<TransactionSignature>;
     updateK(sqrtK: BN, marketIndex: BN): Promise<TransactionSignature>;
     moveAmmToPrice(marketIndex: BN, targetPrice: BN): Promise<TransactionSignature>;

package/lib/admin.js

@@ -122,12 +122,12 @@ class Admin extends clearingHouse_1.ClearingHouse {
             return [initializeTxSig, initializeHistoryTxSig];
         });
     }
-    initializeMarket(marketIndex, priceOracle, baseAmount, quoteAmount, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION) {
+    initializeMarket(marketIndex, priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.getMarketsAccount().markets[marketIndex.toNumber()].initialized) {
                 throw Error(`MarketIndex ${marketIndex.toNumber()} already initialized`);
             }
-            const initializeMarketTx = yield this.program.transaction.initializeMarket(marketIndex, baseAmount, quoteAmount, periodicity, pegMultiplier, {
+            const initializeMarketTx = yield this.program.transaction.initializeMarket(marketIndex, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, {
                 accounts: {
                     state: yield this.getStatePublicKey(),
                     admin: this.wallet.publicKey,

package/lib/clearingHouseUser.d.ts

@@ -72,7 +72,7 @@ export declare class ClearingHouseUser {
      * calculates average exit price for closing 100% of position
      * @returns : Precision MARK_PRICE_PRECISION
      */
-    getPositionEstimatedExitPrice(position: UserPosition): BN;
+    getPositionEstimatedExitPrice(position: UserPosition, amountToClose?: BN): BN;
     /**
      * calculates current user leverage across all positions
      * @returns : Precision TEN_THOUSAND

package/lib/clearingHouseUser.js

@@ -60,7 +60,13 @@ class ClearingHouseUser {
      * @returns userPosition
      */
     getUserPosition(marketIndex) {
-        return this.getUserPositionsAccount().positions.find((position) => position.marketIndex.eq(marketIndex));
+        var _a;
+        return ((_a = this.getUserPositionsAccount().positions.find((position) => position.marketIndex.eq(marketIndex))) !== null && _a !== void 0 ? _a : {
+            baseAssetAmount: numericConstants_1.ZERO,
+            lastCumulativeFundingRate: numericConstants_1.ZERO,
+            marketIndex,
+            quoteAssetAmount: numericConstants_1.ZERO,
+        });
     }
     getUserAccountPublicKey() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -158,8 +164,19 @@ class ClearingHouseUser {
      * calculates average exit price for closing 100% of position
      * @returns : Precision MARK_PRICE_PRECISION
      */
-    getPositionEstimatedExitPrice(position) {
+    getPositionEstimatedExitPrice(position, amountToClose) {
         const market = this.clearingHouse.getMarket(position.marketIndex);
+        if (amountToClose) {
+            if (amountToClose.eq(numericConstants_1.ZERO)) {
+                return _1.calculateMarkPrice(market);
+            }
+            position = {
+                baseAssetAmount: amountToClose,
+                lastCumulativeFundingRate: position.lastCumulativeFundingRate,
+                marketIndex: position.marketIndex,
+                quoteAssetAmount: position.quoteAssetAmount,
+            };
+        }
         const baseAssetValue = _1.calculateBaseAssetValue(market, position);
         if (position.baseAssetAmount.eq(numericConstants_1.ZERO)) {
             return numericConstants_1.ZERO;

package/lib/config.js

@@ -5,7 +5,7 @@ exports.configs = {
     devnet: {
         ENV: 'devnet',
         PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
-        CLEARING_HOUSE_PROGRAM_ID: 'tCyWBVHtN4iGtZWs2dkefWk38SyN4RGtED14KzUopK9',
+        CLEARING_HOUSE_PROGRAM_ID: 'AsW7LnXB9UA1uec9wi9MctYTgTz7YH9snhxd16GsFaGX',
         USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
     },
     'mainnet-beta': {

package/lib/constants/markets.js

@@ -13,20 +13,20 @@ exports.Markets = [
         devnetPythOracle: 'J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix',
         mainnetPythOracle: 'H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG',
     },
-    // {
-    // 	symbol: 'BTC-PERP',
-    // 	baseAssetSymbol: 'BTC',
-    // 	marketIndex: new BN(1),
-    // 	devnetPythOracle: 'HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J',
-    // 	mainnetPythOracle: 'GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU',
-    // },
-    // {
-    // 	symbol: 'ETH-PERP',
-    // 	baseAssetSymbol: 'ETH',
-    // 	marketIndex: new BN(2),
-    // 	devnetPythOracle: 'EdVCmQ9FSPcVe5YySXDPCRmc8aDQLKJ9xvYBMZPie1Vw',
-    // 	mainnetPythOracle: 'JBu1AL4obBcCMqKBBxhpWCNUt136ijcuMZLFvTP7iWdB',
-    // },
+    {
+        symbol: 'BTC-PERP',
+        baseAssetSymbol: 'BTC',
+        marketIndex: new bn_js_1.default(1),
+        devnetPythOracle: 'HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J',
+        mainnetPythOracle: 'GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU',
+    },
+    {
+        symbol: 'ETH-PERP',
+        baseAssetSymbol: 'ETH',
+        marketIndex: new bn_js_1.default(2),
+        devnetPythOracle: 'EdVCmQ9FSPcVe5YySXDPCRmc8aDQLKJ9xvYBMZPie1Vw',
+        mainnetPythOracle: 'JBu1AL4obBcCMqKBBxhpWCNUt136ijcuMZLFvTP7iWdB',
+    },
     // {
     // 	symbol: 'COPE-PERP',
     // 	baseAssetSymbol: 'COPE',

package/lib/idl/clearing_house.json

@@ -1724,6 +1724,34 @@
         }
     ],
     "types": [
+        {
+            "name": "InitializeUserOptionalAccounts",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "whitelistToken",
+                        "type": "bool"
+                    }
+                ]
+            }
+        },
+        {
+            "name": "ManagePositionOptionalAccounts",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "discountToken",
+                        "type": "bool"
+                    },
+                    {
+                        "name": "referrer",
+                        "type": "bool"
+                    }
+                ]
+            }
+        },
         {
             "name": "CurveRecord",
             "type": {
@@ -1938,34 +1966,6 @@
                 ]
             }
         },
-        {
-            "name": "InitializeUserOptionalAccounts",
-            "type": {
-                "kind": "struct",
-                "fields": [
-                    {
-                        "name": "whitelistToken",
-                        "type": "bool"
-                    }
-                ]
-            }
-        },
-        {
-            "name": "ManagePositionOptionalAccounts",
-            "type": {
-                "kind": "struct",
-                "fields": [
-                    {
-                        "name": "discountToken",
-                        "type": "bool"
-                    },
-                    {
-                        "name": "referrer",
-                        "type": "bool"
-                    }
-                ]
-            }
-        },
         {
             "name": "LiquidationRecord",
             "type": {
@@ -2757,6 +2757,11 @@
             "code": 337,
             "name": "InvalidFundingProfitability",
             "msg": "AMM funding out of bounds pnl"
+        },
+        {
+            "code": 338,
+            "name": "CastingFailure",
+            "msg": "Casting Failure"
         }
     ]
 }

package/lib/math/funding.d.ts

@@ -2,6 +2,14 @@
 import { BN } from '@project-serum/anchor';
 import { PythClient } from '../pythClient';
 import { Market } from '../types';
+/**
+ *
+ * @param market
+ * @param pythClient
+ * @param periodAdjustment
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+export declare function calculateAllEstimatedFundingRate(market: Market, pythClient: PythClient, periodAdjustment?: BN): Promise<[BN, BN, BN]>;
 /**
  *
  * @param market
@@ -10,4 +18,19 @@ import { Market } from '../types';
  * @param estimationMethod
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
-export declare function calculateEstimatedFundingRate(market: Market, pythClient: PythClient, periodAdjustment: BN, estimationMethod: 'interpolated' | 'lowerbound'): Promise<BN>;
+export declare function calculateEstimatedFundingRate(market: Market, pythClient: PythClient, periodAdjustment: BN, estimationMethod: 'interpolated' | 'lowerbound' | 'capped'): Promise<BN>;
+/**
+ *
+ * @param market
+ * @param pythClient
+ * @param periodAdjustment
+ * @param estimationMethod
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+export declare function calculateLongShortFundingRate(market: Market, pythClient: PythClient, periodAdjustment?: BN): Promise<[BN, BN]>;
+/**
+ *
+ * @param market
+ * @returns Estimated fee pool size
+ */
+export declare function calculateFundingPool(market: Market): BN;

package/lib/math/funding.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateEstimatedFundingRate = void 0;
+exports.calculateFundingPool = exports.calculateLongShortFundingRate = exports.calculateEstimatedFundingRate = exports.calculateAllEstimatedFundingRate = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
 const market_1 = require("./market");
@@ -18,10 +18,9 @@ const market_1 = require("./market");
  * @param market
  * @param pythClient
  * @param periodAdjustment
- * @param estimationMethod
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
-function calculateEstimatedFundingRate(market, pythClient, periodAdjustment = new anchor_1.BN(1), estimationMethod) {
+function calculateAllEstimatedFundingRate(market, pythClient, periodAdjustment = new anchor_1.BN(1)) {
     return __awaiter(this, void 0, void 0, function* () {
         // periodAdjustment
         // 	1: hourly
@@ -30,7 +29,7 @@ function calculateEstimatedFundingRate(market, pythClient, periodAdjustment = ne
         const secondsInHour = new anchor_1.BN(3600);
         const hoursInDay = new anchor_1.BN(24);
         if (!market.initialized) {
-            return new anchor_1.BN(0);
+            return [new anchor_1.BN(0), new anchor_1.BN(0), new anchor_1.BN(0)];
         }
         const payFreq = new anchor_1.BN(market.amm.fundingPeriod);
         const oraclePriceData = yield pythClient.getPriceData(market.amm.oracle);
@@ -51,19 +50,116 @@ function calculateEstimatedFundingRate(market, pythClient, periodAdjustment = ne
             .mul(numericConstants_1.MARK_PRICE_PRECISION)
             .mul(new anchor_1.BN(100))
             .div(oracleTwapWithMantissa);
+        const lowerboundEst = twapSpreadPct
+            .mul(payFreq)
+            .mul(anchor_1.BN.min(secondsInHour, timeSinceLastUpdate))
+            .mul(periodAdjustment)
+            .div(secondsInHour)
+            .div(secondsInHour)
+            .div(hoursInDay);
+        const interpEst = twapSpreadPct.mul(periodAdjustment).div(hoursInDay);
+        const interpRateQuote = twapSpreadPct.mul(periodAdjustment).div(hoursInDay)
+            .div(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.QUOTE_PRECISION));
+        let feePoolSize = calculateFundingPool(market);
+        if (interpRateQuote.lt(new anchor_1.BN(0))) {
+            feePoolSize = feePoolSize.mul(new anchor_1.BN(-1));
+        }
+        let cappedAltEst;
+        let largerSide;
+        let smallerSide;
+        if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort)) {
+            largerSide = market.baseAssetAmountLong.abs();
+            smallerSide = market.baseAssetAmountShort.abs();
+            if (twapSpread.gt(new anchor_1.BN(0))) {
+                return [lowerboundEst, interpEst, interpEst];
+            }
+        }
+        else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort)) {
+            largerSide = market.baseAssetAmountShort.abs();
+            smallerSide = market.baseAssetAmountLong.abs();
+            if (twapSpread.lt(new anchor_1.BN(0))) {
+                return [lowerboundEst, interpEst, interpEst];
+            }
+        }
+        else {
+            return [lowerboundEst, interpEst, interpEst];
+        }
+        if (largerSide.gt(numericConstants_1.ZERO)) {
+            cappedAltEst = smallerSide.mul(twapSpread).div(largerSide);
+            const feePoolTopOff = feePoolSize.mul(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.QUOTE_PRECISION))
+                .mul(numericConstants_1.AMM_RESERVE_PRECISION).div(largerSide);
+            cappedAltEst = cappedAltEst.add(feePoolTopOff);
+            cappedAltEst = cappedAltEst.mul(numericConstants_1.MARK_PRICE_PRECISION)
+                .mul(new anchor_1.BN(100))
+                .div(oracleTwapWithMantissa)
+                .mul(periodAdjustment).div(hoursInDay);
+            if (cappedAltEst.abs().gt(interpEst.abs())) {
+                cappedAltEst = interpEst;
+            }
+        }
+        else {
+            cappedAltEst = interpEst;
+        }
+        return [lowerboundEst, cappedAltEst, interpEst];
+    });
+}
+exports.calculateAllEstimatedFundingRate = calculateAllEstimatedFundingRate;
+/**
+ *
+ * @param market
+ * @param pythClient
+ * @param periodAdjustment
+ * @param estimationMethod
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+function calculateEstimatedFundingRate(market, pythClient, periodAdjustment = new anchor_1.BN(1), estimationMethod) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [lowerboundEst, cappedAltEst, interpEst] = yield calculateAllEstimatedFundingRate(market, pythClient, periodAdjustment);
         if (estimationMethod == 'lowerbound') {
             //assuming remaining funding period has no gap
-            return twapSpreadPct
-                .mul(payFreq)
-                .mul(anchor_1.BN.min(secondsInHour, timeSinceLastUpdate))
-                .mul(periodAdjustment)
-                .div(secondsInHour)
-                .div(secondsInHour)
-                .div(hoursInDay);
+            return lowerboundEst;
+        }
+        else if (estimationMethod == 'capped') {
+            return cappedAltEst;
         }
         else {
-            return twapSpreadPct.mul(periodAdjustment).div(hoursInDay);
+            return interpEst;
         }
     });
 }
 exports.calculateEstimatedFundingRate = calculateEstimatedFundingRate;
+/**
+ *
+ * @param market
+ * @param pythClient
+ * @param periodAdjustment
+ * @param estimationMethod
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+function calculateLongShortFundingRate(market, pythClient, periodAdjustment = new anchor_1.BN(1)) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [_, cappedAltEst, interpEst] = yield calculateAllEstimatedFundingRate(market, pythClient, periodAdjustment);
+        if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort)) {
+            return [cappedAltEst, interpEst];
+        }
+        else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort)) {
+            return [interpEst, cappedAltEst];
+        }
+        else {
+            return [interpEst, interpEst];
+        }
+    });
+}
+exports.calculateLongShortFundingRate = calculateLongShortFundingRate;
+/**
+ *
+ * @param market
+ * @returns Estimated fee pool size
+ */
+function calculateFundingPool(market) {
+    const totalFeeLB = market.amm.totalFee.div(new anchor_1.BN(2));
+    const feePool = market.amm.totalFeeMinusDistributions.sub(totalFeeLB);
+    // return new BN(QUOTE_PRECISION.mul(new BN(2400)));
+    return feePool;
+}
+exports.calculateFundingPool = calculateFundingPool;

package/lib/math/trade.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="bn.js" />
 import { Market, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
+import { AssetType } from './amm';
 export declare type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' | 'priceDeltaAsNumber' | 'pctAvg' | 'pctMax' | 'quoteAssetAmount' | 'quoteAssetAmountPeg' | 'acquiredBaseAssetAmount' | 'acquiredQuoteAssetAmount';
 /**
  * Calculates avg/max slippage (price impact) for candidate trade
@@ -17,7 +18,7 @@ export declare type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' |
  *
  * 'newPrice' => the price of the asset after the trade : Precision MARK_PRICE_PRECISION
  */
-export declare function calculateTradeSlippage(direction: PositionDirection, amount: BN, market: Market): [BN, BN, BN, BN];
+export declare function calculateTradeSlippage(direction: PositionDirection, amount: BN, market: Market, inputAssetType?: AssetType): [BN, BN, BN, BN];
 /**
  * Calculates acquired amounts for trade executed
  * @param direction
@@ -27,7 +28,7 @@ export declare function calculateTradeSlippage(direction: PositionDirection, amo
  * 	| 'acquiredBase' =>  positive/negative change in user's base : BN TODO-PRECISION
  * 	| 'acquiredQuote' => positive/negative change in user's quote : BN TODO-PRECISION
  */
-export declare function calculateTradeAcquiredAmounts(direction: PositionDirection, amount: BN, market: Market): [BN, BN];
+export declare function calculateTradeAcquiredAmounts(direction: PositionDirection, amount: BN, market: Market, inputAssetType?: AssetType): [BN, BN];
 /**
  * calculateTargetPriceTrade
  * simple function for finding arbitraging trades

package/lib/math/trade.js

@@ -24,12 +24,12 @@ const MAXPCT = new anchor_1.BN(1000); //percentage units are [0,1000] => [0,1]
  *
  * 'newPrice' => the price of the asset after the trade : Precision MARK_PRICE_PRECISION
  */
-function calculateTradeSlippage(direction, amount, market) {
+function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quote') {
     const oldPrice = market_1.calculateMarkPrice(market);
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO, oldPrice, oldPrice];
     }
-    const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(direction, amount, market);
+    const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType);
     const entryPrice = amm_1.calculatePrice(acquiredBase, acquiredQuote, market.amm.pegMultiplier).mul(new anchor_1.BN(-1));
     const newPrice = amm_1.calculatePrice(market.amm.baseAssetReserve.sub(acquiredBase), market.amm.quoteAssetReserve.sub(acquiredQuote), market.amm.pegMultiplier);
     if (direction == types_1.PositionDirection.SHORT) {
@@ -60,11 +60,11 @@ exports.calculateTradeSlippage = calculateTradeSlippage;
  * 	| 'acquiredBase' =>  positive/negative change in user's base : BN TODO-PRECISION
  * 	| 'acquiredQuote' => positive/negative change in user's quote : BN TODO-PRECISION
  */
-function calculateTradeAcquiredAmounts(direction, amount, market) {
+function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType = 'quote') {
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO];
     }
-    const [newQuoteAssetReserve, newBaseAssetReserve] = amm_1.calculateAmmReservesAfterSwap(market.amm, 'quote', amount, amm_1.getSwapDirection('quote', direction));
+    const [newQuoteAssetReserve, newBaseAssetReserve] = amm_1.calculateAmmReservesAfterSwap(market.amm, inputAssetType, amount, amm_1.getSwapDirection(inputAssetType, direction));
     const acquiredBase = market.amm.baseAssetReserve.sub(newBaseAssetReserve);
     const acquiredQuote = market.amm.quoteAssetReserve.sub(newQuoteAssetReserve);
     return [acquiredBase, acquiredQuote];
@@ -158,6 +158,7 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT) {
     }
     const entryPrice = tradeSize
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
         .div(baseSize.abs());
     assert_1.assert(tp1.sub(tp2).lte(originalDiff), 'Target Price Calculation incorrect');
     assert_1.assert(tp2.lte(tp1) || tp2.sub(tp1).abs() < 100000, 'Target Price Calculation incorrect' +

package/lib/types.d.ts

@@ -241,6 +241,7 @@ export interface Trade {
     side: TradeSide;
     size: number;
     ts: number;
+    fee: number;
     marketIndex: number;
     chainTs: number;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.1.2",
+	"version": "0.1.8",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -11,10 +11,13 @@
 	},
 	"scripts": {
 		"build": "yarn clean && tsc",
-		"clean": "rm -rf lib"
+		"clean": "rm -rf lib",
+		"patch-and-pub": "npm version patch --force && npm publish"
 	},
 	"keywords": [
-		"drift-labs", "drift", "perps"
+		"drift-labs",
+		"drift",
+		"perps"
 	],
 	"license": "Apache-2.0",
 	"directories": {

package/src/admin.ts

@@ -178,8 +178,8 @@ export class Admin extends ClearingHouse {
 	public async initializeMarket(
 		marketIndex: BN,
 		priceOracle: PublicKey,
-		baseAmount: BN,
-		quoteAmount: BN,
+		baseAssetReserve: BN,
+		quoteAssetReserve: BN,
 		periodicity: BN,
 		pegMultiplier: BN = PEG_PRECISION
 	): Promise<TransactionSignature> {
@@ -189,8 +189,8 @@ export class Admin extends ClearingHouse {
 
 		const initializeMarketTx = await this.program.transaction.initializeMarket(
 			marketIndex,
-			baseAmount,
-			quoteAmount,
+			baseAssetReserve,
+			quoteAssetReserve,
 			periodicity,
 			pegMultiplier,
 			{

package/src/clearingHouse.ts

@@ -52,10 +52,10 @@ import { wrapInTx } from './tx/utils';
 
 /**
  * # ClearingHouse
- * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more. 
- * 
+ * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
+ *
  * The default way to construct a ClearingHouse instance is using the {@link from} method. This will create an instance using the static {@link DefaultClearingHouseAccountSubscriber}, which will use a websocket for each state account subscription.
- * Alternatively, if you want to implement your own method of subscribing to the state accounts on the blockchain, you can implement a {@link ClearingHouseAccountSubscriber} and use it in the {@link ClearingHouse.constructor} 
+ * Alternatively, if you want to implement your own method of subscribing to the state accounts on the blockchain, you can implement a {@link ClearingHouseAccountSubscriber} and use it in the {@link ClearingHouse.constructor}
  */
 export class ClearingHouse {
 	connection: Connection;
@@ -200,7 +200,7 @@ export class ClearingHouse {
 
 	/**
 	 * Update the wallet to use for clearing house transactions and linked user account
-	 * @param newWallet 
+	 * @param newWallet
 	 */
 	public updateWallet(newWallet: IWallet): void {
 		const newProvider = new Provider(this.connection, newWallet, this.opts);
@@ -290,7 +290,7 @@ export class ClearingHouse {
 	userAccountPublicKey?: PublicKey;
 	/**
 	 * Get the address for the Clearing House User's account. NOT the user's wallet address.
-	 * @returns 
+	 * @returns
 	 */
 	public async getUserAccountPublicKey(): Promise<PublicKey> {
 		if (this.userAccountPublicKey) {
@@ -361,9 +361,9 @@ export class ClearingHouse {
 
 	/**
 	 * Creates the Clearing House User account for a user, and deposits some initial collateral
-	 * @param amount 
-	 * @param collateralAccountPublicKey 
-	 * @returns 
+	 * @param amount
+	 * @param collateralAccountPublicKey
+	 * @returns
 	 */
 	public async initializeUserAccountAndDepositCollateral(
 		amount: BN,
@@ -568,10 +568,10 @@ export class ClearingHouse {
 
 	/**
 	 * Close an entire position. If you want to reduce a position, use the {@link openPosition} method in the opposite direction of the current position.
-	 * @param marketIndex 
-	 * @param discountToken 
-	 * @param referrer 
-	 * @returns 
+	 * @param marketIndex
+	 * @param discountToken
+	 * @param referrer
+	 * @returns
 	 */
 	public async closePosition(
 		marketIndex: BN,

package/src/clearingHouseUser.ts

@@ -86,8 +86,15 @@ export class ClearingHouseUser {
 	 * @returns userPosition
 	 */
 	public getUserPosition(marketIndex: BN): UserPosition {
-		return this.getUserPositionsAccount().positions.find((position) =>
-			position.marketIndex.eq(marketIndex)
+		return (
+			this.getUserPositionsAccount().positions.find((position) =>
+				position.marketIndex.eq(marketIndex)
+			) ?? {
+				baseAssetAmount: ZERO,
+				lastCumulativeFundingRate: ZERO,
+				marketIndex,
+				quoteAssetAmount: ZERO,
+			}
 		);
 	}
 
@@ -217,8 +224,21 @@ export class ClearingHouseUser {
 	 * calculates average exit price for closing 100% of position
 	 * @returns : Precision MARK_PRICE_PRECISION
 	 */
-	public getPositionEstimatedExitPrice(position: UserPosition): BN {
+	public getPositionEstimatedExitPrice(position: UserPosition, amountToClose?: BN): BN {
 		const market = this.clearingHouse.getMarket(position.marketIndex);
+
+		if(amountToClose){
+			if(amountToClose.eq(ZERO)){
+				return calculateMarkPrice(market);
+			}
+			position = {
+				baseAssetAmount: amountToClose,
+				lastCumulativeFundingRate: position.lastCumulativeFundingRate,
+				marketIndex: position.marketIndex,
+				quoteAssetAmount: position.quoteAssetAmount,
+			} as UserPosition;
+		}
+
 		const baseAssetValue = calculateBaseAssetValue(market, position);
 		if (position.baseAssetAmount.eq(ZERO)) {
 			return ZERO;

package/src/config.ts

@@ -11,7 +11,7 @@ export const configs: { [key in DriftEnv]: DriftConfig } = {
 	devnet: {
 		ENV: 'devnet',
 		PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
-		CLEARING_HOUSE_PROGRAM_ID: 'tCyWBVHtN4iGtZWs2dkefWk38SyN4RGtED14KzUopK9',
+		CLEARING_HOUSE_PROGRAM_ID: 'AsW7LnXB9UA1uec9wi9MctYTgTz7YH9snhxd16GsFaGX',
 		USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
 	},
 	'mainnet-beta': {
@@ -37,7 +37,6 @@ export const initialize = (props: {
 	env: DriftEnv;
 	overrideEnv?: Partial<DriftConfig>;
 }): DriftConfig => {
-
 	//@ts-ignore
 	if (props.env === 'master')
 		return { ...configs['devnet'], ...(props.overrideEnv ?? {}) };

package/src/constants/markets.ts

@@ -16,20 +16,20 @@ export const Markets: Market[] = [
 		devnetPythOracle: 'J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix',
 		mainnetPythOracle: 'H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG',
 	},
-	// {
-	// 	symbol: 'BTC-PERP',
-	// 	baseAssetSymbol: 'BTC',
-	// 	marketIndex: new BN(1),
-	// 	devnetPythOracle: 'HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J',
-	// 	mainnetPythOracle: 'GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU',
-	// },
-	// {
-	// 	symbol: 'ETH-PERP',
-	// 	baseAssetSymbol: 'ETH',
-	// 	marketIndex: new BN(2),
-	// 	devnetPythOracle: 'EdVCmQ9FSPcVe5YySXDPCRmc8aDQLKJ9xvYBMZPie1Vw',
-	// 	mainnetPythOracle: 'JBu1AL4obBcCMqKBBxhpWCNUt136ijcuMZLFvTP7iWdB',
-	// },
+	{
+		symbol: 'BTC-PERP',
+		baseAssetSymbol: 'BTC',
+		marketIndex: new BN(1),
+		devnetPythOracle: 'HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J',
+		mainnetPythOracle: 'GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU',
+	},
+	{
+		symbol: 'ETH-PERP',
+		baseAssetSymbol: 'ETH',
+		marketIndex: new BN(2),
+		devnetPythOracle: 'EdVCmQ9FSPcVe5YySXDPCRmc8aDQLKJ9xvYBMZPie1Vw',
+		mainnetPythOracle: 'JBu1AL4obBcCMqKBBxhpWCNUt136ijcuMZLFvTP7iWdB',
+	},
 	// {
 	// 	symbol: 'COPE-PERP',
 	// 	baseAssetSymbol: 'COPE',

package/src/idl/clearing_house.json

@@ -1724,6 +1724,34 @@
     }
   ],
   "types": [
+    {
+      "name": "InitializeUserOptionalAccounts",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "whitelistToken",
+            "type": "bool"
+          }
+        ]
+      }
+    },
+    {
+      "name": "ManagePositionOptionalAccounts",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "discountToken",
+            "type": "bool"
+          },
+          {
+            "name": "referrer",
+            "type": "bool"
+          }
+        ]
+      }
+    },
     {
       "name": "CurveRecord",
       "type": {
@@ -1938,34 +1966,6 @@
         ]
       }
     },
-    {
-      "name": "InitializeUserOptionalAccounts",
-      "type": {
-        "kind": "struct",
-        "fields": [
-          {
-            "name": "whitelistToken",
-            "type": "bool"
-          }
-        ]
-      }
-    },
-    {
-      "name": "ManagePositionOptionalAccounts",
-      "type": {
-        "kind": "struct",
-        "fields": [
-          {
-            "name": "discountToken",
-            "type": "bool"
-          },
-          {
-            "name": "referrer",
-            "type": "bool"
-          }
-        ]
-      }
-    },
     {
       "name": "LiquidationRecord",
       "type": {
@@ -2757,6 +2757,11 @@
       "code": 337,
       "name": "InvalidFundingProfitability",
       "msg": "AMM funding out of bounds pnl"
+    },
+    {
+      "code": 338,
+      "name": "CastingFailure",
+      "msg": "Casting Failure"
     }
   ]
 }

package/src/math/funding.ts

@@ -1,6 +1,8 @@
 import { BN } from '@project-serum/anchor';
+import {
+	AMM_RESERVE_PRECISION, MARK_PRICE_PRECISION, QUOTE_PRECISION, ZERO
+} from '../constants/numericConstants';
 import { PythClient } from '../pythClient';
-import { MARK_PRICE_PRECISION } from '../constants/numericConstants';
 import { Market } from '../types';
 import { calculateMarkPrice } from './market';
 
@@ -9,15 +11,13 @@ import { calculateMarkPrice } from './market';
  * @param market 
  * @param pythClient 
  * @param periodAdjustment 
- * @param estimationMethod 
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
-export async function calculateEstimatedFundingRate(
+ export async function calculateAllEstimatedFundingRate(
 	market: Market,
 	pythClient: PythClient,
 	periodAdjustment: BN = new BN(1),
-	estimationMethod: 'interpolated' | 'lowerbound'
-): Promise<BN> {
+): Promise<[BN, BN, BN]> {
 	// periodAdjustment
 	// 	1: hourly
 	//  24: daily
@@ -26,7 +26,7 @@ export async function calculateEstimatedFundingRate(
 	const hoursInDay = new BN(24);
 
 	if (!market.initialized) {
-		return new BN(0);
+		return [new BN(0), new BN(0), new BN(0)];
 	}
 
 	const payFreq = new BN(market.amm.fundingPeriod);
@@ -61,16 +61,129 @@ export async function calculateEstimatedFundingRate(
 		.mul(new BN(100))
 		.div(oracleTwapWithMantissa);
 
+
+	const lowerboundEst = twapSpreadPct
+		.mul(payFreq)
+		.mul(BN.min(secondsInHour, timeSinceLastUpdate))
+		.mul(periodAdjustment)
+		.div(secondsInHour)
+		.div(secondsInHour)
+		.div(hoursInDay);
+
+	const interpEst = twapSpreadPct.mul(periodAdjustment).div(hoursInDay);
+
+	
+	const interpRateQuote = twapSpreadPct.mul(periodAdjustment).div(hoursInDay)
+	.div(MARK_PRICE_PRECISION.div(QUOTE_PRECISION));
+	let feePoolSize = calculateFundingPool(market);
+	if(interpRateQuote.lt(new BN(0))){
+		feePoolSize = feePoolSize.mul(new BN(-1));
+	}
+
+	let cappedAltEst: BN;
+	let largerSide: BN;
+	let smallerSide: BN;
+
+	if(market.baseAssetAmountLong.gt(market.baseAssetAmountShort)){
+		largerSide = market.baseAssetAmountLong.abs();
+		smallerSide = market.baseAssetAmountShort.abs();
+		if(twapSpread.gt(new BN(0))){
+			return [lowerboundEst, interpEst, interpEst];
+		}
+	} else if(market.baseAssetAmountLong.lt(market.baseAssetAmountShort)){
+		largerSide = market.baseAssetAmountShort.abs();
+		smallerSide = market.baseAssetAmountLong.abs();
+		if(twapSpread.lt(new BN(0))){
+			return [lowerboundEst, interpEst, interpEst];
+		}
+	} else{
+		return [lowerboundEst, interpEst, interpEst];
+	}
+
+	if(largerSide.gt(ZERO)){
+		cappedAltEst = smallerSide.mul(twapSpread).div(largerSide);
+		const feePoolTopOff = feePoolSize.mul(MARK_PRICE_PRECISION.div(QUOTE_PRECISION))
+		.mul(AMM_RESERVE_PRECISION).div(largerSide);
+		cappedAltEst = cappedAltEst.add(feePoolTopOff);
+	
+		cappedAltEst = cappedAltEst.mul(MARK_PRICE_PRECISION)
+		.mul(new BN(100))
+		.div(oracleTwapWithMantissa)
+		.mul(periodAdjustment).div(hoursInDay);
+	
+		if(cappedAltEst.abs().gt(interpEst.abs())){
+			cappedAltEst = interpEst;
+		}
+	} else{
+		cappedAltEst = interpEst;
+	}
+
+
+	return [lowerboundEst, cappedAltEst, interpEst];
+}
+
+/**
+ *
+ * @param market
+ * @param pythClient
+ * @param periodAdjustment
+ * @param estimationMethod
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+export async function calculateEstimatedFundingRate(
+	market: Market,
+	pythClient: PythClient,
+	periodAdjustment: BN = new BN(1),
+	estimationMethod: 'interpolated' | 'lowerbound' | 'capped'
+): Promise<BN> {
+	const [lowerboundEst, cappedAltEst, interpEst] = 
+		await calculateAllEstimatedFundingRate(market, pythClient, periodAdjustment);
+
 	if (estimationMethod == 'lowerbound') {
 		//assuming remaining funding period has no gap
-		return twapSpreadPct
-			.mul(payFreq)
-			.mul(BN.min(secondsInHour, timeSinceLastUpdate))
-			.mul(periodAdjustment)
-			.div(secondsInHour)
-			.div(secondsInHour)
-			.div(hoursInDay);
+		return lowerboundEst;
+	} else if (estimationMethod == 'capped') {
+		return cappedAltEst;
 	} else {
-		return twapSpreadPct.mul(periodAdjustment).div(hoursInDay);
+		return interpEst;
 	}
 }
+
+
+/**
+ * 
+ * @param market 
+ * @param pythClient 
+ * @param periodAdjustment 
+ * @param estimationMethod 
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+ export async function calculateLongShortFundingRate(
+	market: Market,
+	pythClient: PythClient,
+	periodAdjustment: BN = new BN(1),
+): Promise<[BN, BN]> {
+	const [_, cappedAltEst, interpEst] = 
+		await calculateAllEstimatedFundingRate(market, pythClient, periodAdjustment);
+
+	if(market.baseAssetAmountLong.gt(market.baseAssetAmountShort)){
+		return [cappedAltEst, interpEst];
+	} else if(market.baseAssetAmountLong.lt(market.baseAssetAmountShort)){
+		return [interpEst, cappedAltEst];
+	} else{
+		return [interpEst, interpEst];
+	}
+
+}
+
+/**
+ *
+ * @param market
+ * @returns Estimated fee pool size
+ */
+export function calculateFundingPool(market: Market): BN {
+	const totalFeeLB = market.amm.totalFee.div(new BN(2));
+	const feePool = market.amm.totalFeeMinusDistributions.sub(totalFeeLB);
+	// return new BN(QUOTE_PRECISION.mul(new BN(2400)));
+	return feePool;
+}

package/src/math/position.ts

@@ -102,9 +102,9 @@ export function calculatePositionPNL(
 }
 
 /**
- * 
- * @param market 
- * @param marketPosition 
+ *
+ * @param market
+ * @param marketPosition
  * @returns // TODO-PRECISION
  */
 export function calculatePositionFundingPNL(

package/src/math/trade.ts

@@ -12,6 +12,7 @@ import {
 	calculateAmmReservesAfterSwap,
 	calculatePrice,
 	getSwapDirection,
+	AssetType,
 } from './amm';
 import { squareRootBN } from './utils';
 
@@ -47,7 +48,8 @@ export type PriceImpactUnit =
 export function calculateTradeSlippage(
 	direction: PositionDirection,
 	amount: BN,
-	market: Market
+	market: Market,
+	inputAssetType: AssetType = 'quote',
 ): [BN, BN, BN, BN] {
 	const oldPrice = calculateMarkPrice(market);
 	if (amount.eq(ZERO)) {
@@ -56,7 +58,8 @@ export function calculateTradeSlippage(
 	const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(
 		direction,
 		amount,
-		market
+		market,
+		inputAssetType
 	);
 
 	const entryPrice = calculatePrice(
@@ -103,7 +106,8 @@ export function calculateTradeSlippage(
 export function calculateTradeAcquiredAmounts(
 	direction: PositionDirection,
 	amount: BN,
-	market: Market
+	market: Market,
+	inputAssetType: AssetType = 'quote',
 ): [BN, BN] {
 	if (amount.eq(ZERO)) {
 		return [ZERO, ZERO];
@@ -112,9 +116,9 @@ export function calculateTradeAcquiredAmounts(
 	const [newQuoteAssetReserve, newBaseAssetReserve] =
 		calculateAmmReservesAfterSwap(
 			market.amm,
-			'quote',
+			inputAssetType,
 			amount,
-			getSwapDirection('quote', direction)
+			getSwapDirection(inputAssetType, direction)
 		);
 
 	const acquiredBase = market.amm.baseAssetReserve.sub(newBaseAssetReserve);
@@ -129,8 +133,8 @@ export function calculateTradeAcquiredAmounts(
  * @param market
  * @param targetPrice
  * @param pct optional default is 100% gap filling, can set smaller.
- * @returns trade direction/size in order to push price to a targetPrice, 
- * 
+ * @returns trade direction/size in order to push price to a targetPrice,
+ *
  * [
  *   direction => direction of trade required, TODO-PRECISION
  *   tradeSize => size of trade required, TODO-PRECISION
@@ -236,6 +240,7 @@ export function calculateTargetPriceTrade(
 
 	const entryPrice = tradeSize
 		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
+		.mul(MARK_PRICE_PRECISION)
 		.div(baseSize.abs());
 
 	assert(tp1.sub(tp2).lte(originalDiff), 'Target Price Calculation incorrect');

package/src/types.ts

@@ -265,6 +265,7 @@ export interface Trade {
 	side: TradeSide;
 	size: number;
 	ts: number;
+	fee: number;
 	marketIndex: number;
 	chainTs: number;
 }