@drift-labs/sdk 0.1.23-master.2 → 0.1.24

package/src/idl/clearing_house.json

@@ -211,6 +211,18 @@
         {
           "name": "ammPegMultiplier",
           "type": "u128"
+        },
+        {
+          "name": "marginRatioInitial",
+          "type": "u32"
+        },
+        {
+          "name": "marginRatioPartial",
+          "type": "u32"
+        },
+        {
+          "name": "marginRatioMaintenance",
+          "type": "u32"
         }
       ]
     },
@@ -1526,22 +1538,31 @@
         },
         {
           "name": "state",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "markets",
           "isMut": true,
           "isSigner": false
         }
       ],
       "args": [
+        {
+          "name": "marketIndex",
+          "type": "u64"
+        },
         {
           "name": "marginRatioInitial",
-          "type": "u128"
+          "type": "u32"
         },
         {
           "name": "marginRatioPartial",
-          "type": "u128"
+          "type": "u32"
         },
         {
           "name": "marginRatioMaintenance",
-          "type": "u128"
+          "type": "u32"
         }
       ]
     },
@@ -3028,9 +3049,21 @@
               "defined": "AMM"
             }
           },
+          {
+            "name": "marginRatioInitial",
+            "type": "u32"
+          },
+          {
+            "name": "marginRatioPartial",
+            "type": "u32"
+          },
+          {
+            "name": "marginRatioMaintenance",
+            "type": "u32"
+          },
           {
             "name": "padding0",
-            "type": "u128"
+            "type": "u32"
           },
           {
             "name": "padding1",
@@ -4132,6 +4165,11 @@
       "code": 6056,
       "name": "NoPositionsLiquidatable",
       "msg": "No positions liquidatable"
+    },
+    {
+      "code": 6057,
+      "name": "InvalidMarginRatio",
+      "msg": "Invalid Margin Ratio"
     }
   ]
 }

package/src/math/orders.ts

@@ -42,3 +42,64 @@ export function isOrderRiskIncreasing(
 
 	return false;
 }
+
+export function isOrderRiskIncreasingInSameDirection(
+	user: ClearingHouseUser,
+	order: Order
+): boolean {
+	if (isVariant(order.status, 'init')) {
+		return false;
+	}
+
+	const position =
+		user.getUserPosition(order.marketIndex) ||
+		user.getEmptyPosition(order.marketIndex);
+
+	// if no position exists, it's risk increasing
+	if (position.baseAssetAmount.eq(ZERO)) {
+		return true;
+	}
+
+	// if position is long and order is long
+	if (position.baseAssetAmount.gt(ZERO) && isVariant(order.direction, 'long')) {
+		return true;
+	}
+
+	// if position is short and order is short
+	if (
+		position.baseAssetAmount.lt(ZERO) &&
+		isVariant(order.direction, 'short')
+	) {
+		return true;
+	}
+
+	return false;
+}
+
+export function isOrderReduceOnly(
+	user: ClearingHouseUser,
+	order: Order
+): boolean {
+	if (isVariant(order.status, 'init')) {
+		return false;
+	}
+
+	const position =
+		user.getUserPosition(order.marketIndex) ||
+		user.getEmptyPosition(order.marketIndex);
+
+	// if position is long and order is long
+	if (position.baseAssetAmount.gt(ZERO) && isVariant(order.direction, 'long')) {
+		return false;
+	}
+
+	// if position is short and order is short
+	if (
+		position.baseAssetAmount.lt(ZERO) &&
+		isVariant(order.direction, 'short')
+	) {
+		return false;
+	}
+
+	return order.baseAssetAmount.abs().lte(position.baseAssetAmount.abs());
+}

package/src/mockUSDCFaucet.js

@@ -0,0 +1,171 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockUSDCFaucet = void 0;
+const anchor = __importStar(require("@project-serum/anchor"));
+const anchor_1 = require("@project-serum/anchor");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const mock_usdc_faucet_json_1 = __importDefault(require("./idl/mock_usdc_faucet.json"));
+class MockUSDCFaucet {
+    constructor(connection, wallet, programId, opts) {
+        this.connection = connection;
+        this.wallet = wallet;
+        this.opts = opts || anchor_1.Provider.defaultOptions();
+        const provider = new anchor_1.Provider(connection, wallet, this.opts);
+        this.provider = provider;
+        this.program = new anchor_1.Program(mock_usdc_faucet_json_1.default, programId, provider);
+    }
+    getMockUSDCFaucetStatePublicKeyAndNonce() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return anchor.web3.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('mock_usdc_faucet'))], this.program.programId);
+        });
+    }
+    getMockUSDCFaucetStatePublicKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.mockUSDCFaucetStatePublicKey) {
+                return this.mockUSDCFaucetStatePublicKey;
+            }
+            this.mockUSDCFaucetStatePublicKey = (yield this.getMockUSDCFaucetStatePublicKeyAndNonce())[0];
+            return this.mockUSDCFaucetStatePublicKey;
+        });
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stateAccountRPCResponse = yield this.connection.getParsedAccountInfo(yield this.getMockUSDCFaucetStatePublicKey());
+            if (stateAccountRPCResponse.value !== null) {
+                throw new Error('Faucet already initialized');
+            }
+            const fakeUSDCMint = anchor.web3.Keypair.generate();
+            const createUSDCMintAccountIx = web3_js_1.SystemProgram.createAccount({
+                fromPubkey: this.wallet.publicKey,
+                newAccountPubkey: fakeUSDCMint.publicKey,
+                lamports: yield spl_token_1.Token.getMinBalanceRentForExemptMint(this.connection),
+                space: spl_token_1.MintLayout.span,
+                programId: spl_token_1.TOKEN_PROGRAM_ID,
+            });
+            const [mintAuthority, _mintAuthorityNonce] = yield web3_js_1.PublicKey.findProgramAddress([fakeUSDCMint.publicKey.toBuffer()], this.program.programId);
+            const initUSDCMintIx = spl_token_1.Token.createInitMintInstruction(spl_token_1.TOKEN_PROGRAM_ID, fakeUSDCMint.publicKey, 6, mintAuthority, null);
+            const [mockUSDCFaucetStatePublicKey, mockUSDCFaucetStateNonce] = yield this.getMockUSDCFaucetStatePublicKeyAndNonce();
+            return yield this.program.rpc.initialize(mockUSDCFaucetStateNonce, {
+                accounts: {
+                    mockUsdcFaucetState: mockUSDCFaucetStatePublicKey,
+                    admin: this.wallet.publicKey,
+                    mintAccount: fakeUSDCMint.publicKey,
+                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                    systemProgram: anchor.web3.SystemProgram.programId,
+                },
+                instructions: [createUSDCMintAccountIx, initUSDCMintIx],
+                signers: [fakeUSDCMint],
+            });
+        });
+    }
+    fetchState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.account.mockUsdcFaucetState.fetch(yield this.getMockUSDCFaucetStatePublicKey());
+        });
+    }
+    mintToUser(userTokenAccount, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = yield this.fetchState();
+            return yield this.program.rpc.mintToUser(amount, {
+                accounts: {
+                    mockUsdcFaucetState: yield this.getMockUSDCFaucetStatePublicKey(),
+                    mintAccount: state.mint,
+                    userTokenAccount,
+                    mintAuthority: state.mintAuthority,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+            });
+        });
+    }
+    createAssociatedTokenAccountAndMintTo(userPublicKey, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [associatedTokenPublicKey, createAssociatedAccountIx, mintToTx] = yield this.createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount);
+            const tx = new web3_js_1.Transaction().add(createAssociatedAccountIx).add(mintToTx);
+            const txSig = yield this.program.provider.send(tx, [], this.opts);
+            return [associatedTokenPublicKey, txSig];
+        });
+    }
+    createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = yield this.fetchState();
+            const associateTokenPublicKey = yield this.getAssosciatedMockUSDMintAddress({ userPubKey: userPublicKey });
+            const createAssociatedAccountIx = spl_token_1.Token.createAssociatedTokenAccountInstruction(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, state.mint, associateTokenPublicKey, userPublicKey, this.wallet.publicKey);
+            const mintToIx = yield this.program.instruction.mintToUser(amount, {
+                accounts: {
+                    mockUsdcFaucetState: yield this.getMockUSDCFaucetStatePublicKey(),
+                    mintAccount: state.mint,
+                    userTokenAccount: associateTokenPublicKey,
+                    mintAuthority: state.mintAuthority,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+            });
+            return [associateTokenPublicKey, createAssociatedAccountIx, mintToIx];
+        });
+    }
+    getAssosciatedMockUSDMintAddress(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = yield this.fetchState();
+            return spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, state.mint, props.userPubKey);
+        });
+    }
+    getTokenAccountInfo(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assosciatedKey = yield this.getAssosciatedMockUSDMintAddress(props);
+            const state = yield this.fetchState();
+            const token = new spl_token_1.Token(this.connection, state.mint, spl_token_1.TOKEN_PROGRAM_ID, 
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            this.provider.payer);
+            return yield token.getAccountInfo(assosciatedKey);
+        });
+    }
+    subscribeToTokenAccount(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const tokenAccountKey = yield this.getAssosciatedMockUSDMintAddress(props);
+                props.callback(yield this.getTokenAccountInfo(props));
+                // Couldn't find a way to do it using anchor framework subscription, someone on serum discord recommended this way
+                this.connection.onAccountChange(tokenAccountKey, (_accountInfo /* accountInfo is a buffer which we don't know how to deserialize */) => __awaiter(this, void 0, void 0, function* () {
+                    props.callback(yield this.getTokenAccountInfo(props));
+                }));
+                return true;
+            }
+            catch (e) {
+                return false;
+            }
+        });
+    }
+}
+exports.MockUSDCFaucet = MockUSDCFaucet;

package/src/orders.ts

@@ -3,16 +3,25 @@ import {
 	Market,
 	Order,
 	PositionDirection,
+	SwapDirection,
 	UserAccount,
 	UserPosition,
 } from './types';
-import { BN } from '.';
+import {
+	BN,
+	calculateAmmReservesAfterSwap,
+	calculateBaseAssetValue,
+	ClearingHouseUser,
+	isOrderRiskIncreasingInSameDirection,
+	TEN_THOUSAND,
+} from '.';
 import {
 	calculateMarkPrice,
 	calculateNewMarketAfterTrade,
 } from './math/market';
 import {
 	AMM_TO_QUOTE_PRECISION_RATIO,
+	TWO,
 	PEG_PRECISION,
 	ZERO,
 } from './constants/numericConstants';
@@ -32,7 +41,10 @@ export function calculateNewStateAfterOrder(
 		return null;
 	}
 
-	const baseAssetAmountToTrade = calculateAmountToTrade(market, order);
+	const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(
+		market,
+		order
+	);
 	if (baseAssetAmountToTrade.lt(market.amm.minimumBaseAssetTradeSize)) {
 		return null;
 	}
@@ -157,7 +169,10 @@ function calculateAmountSwapped(
 	};
 }
 
-function calculateAmountToTrade(market: Market, order: Order): BN {
+export function calculateBaseAssetAmountMarketCanExecute(
+	market: Market,
+	order: Order
+): BN {
 	if (isVariant(order.orderType, 'limit')) {
 		return calculateAmountToTradeForLimit(market, order);
 	} else if (isVariant(order.orderType, 'triggerLimit')) {
@@ -234,3 +249,41 @@ function isTriggerConditionSatisfied(market: Market, order: Order): boolean {
 		return markPrice.lt(order.triggerPrice);
 	}
 }
+
+export function calculateBaseAssetAmountUserCanExecute(
+	market: Market,
+	order: Order,
+	user: ClearingHouseUser
+): BN {
+	const maxLeverage = user.getMaxLeverage(order.marketIndex, 'Initial');
+	const freeCollateral = user.getFreeCollateral();
+	let quoteAssetAmount: BN;
+	if (isOrderRiskIncreasingInSameDirection(user, order)) {
+		quoteAssetAmount = freeCollateral.mul(maxLeverage).div(TEN_THOUSAND);
+	} else {
+		const position =
+			user.getUserPosition(order.marketIndex) ||
+			user.getEmptyPosition(order.marketIndex);
+		const positionValue = calculateBaseAssetValue(market, position);
+		quoteAssetAmount = freeCollateral
+			.mul(maxLeverage)
+			.div(TEN_THOUSAND)
+			.add(positionValue.mul(TWO));
+	}
+
+	if (quoteAssetAmount.lte(ZERO)) {
+		return ZERO;
+	}
+
+	const baseAssetReservesBefore = market.amm.baseAssetReserve;
+	const [_, baseAssetReservesAfter] = calculateAmmReservesAfterSwap(
+		market.amm,
+		'quote',
+		quoteAssetAmount,
+		isVariant(order.direction, 'long')
+			? SwapDirection.ADD
+			: SwapDirection.REMOVE
+	);
+
+	return baseAssetReservesBefore.sub(baseAssetReservesAfter).abs();
+}

package/src/types.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradeSide = exports.isVariant = exports.OrderTriggerCondition = exports.OrderAction = exports.OrderDiscountTier = exports.OrderStatus = exports.OrderType = exports.OracleSource = exports.PositionDirection = exports.SwapDirection = void 0;
+// # Utility Types / Enums / Constants
+class SwapDirection {
+}
+exports.SwapDirection = SwapDirection;
+SwapDirection.ADD = { add: {} };
+SwapDirection.REMOVE = { remove: {} };
+class PositionDirection {
+}
+exports.PositionDirection = PositionDirection;
+PositionDirection.LONG = { long: {} };
+PositionDirection.SHORT = { short: {} };
+class OracleSource {
+}
+exports.OracleSource = OracleSource;
+OracleSource.PYTH = { pyth: {} };
+OracleSource.SWITCHBOARD = { switchboard: {} };
+class OrderType {
+}
+exports.OrderType = OrderType;
+OrderType.LIMIT = { limit: {} };
+OrderType.TRIGGER_MARKET = { triggerMarket: {} };
+OrderType.TRIGGER_LIMIT = { triggerLimit: {} };
+OrderType.MARKET = { market: {} };
+class OrderStatus {
+}
+exports.OrderStatus = OrderStatus;
+OrderStatus.INIT = { init: {} };
+OrderStatus.OPEN = { open: {} };
+class OrderDiscountTier {
+}
+exports.OrderDiscountTier = OrderDiscountTier;
+OrderDiscountTier.NONE = { none: {} };
+OrderDiscountTier.FIRST = { first: {} };
+OrderDiscountTier.SECOND = { second: {} };
+OrderDiscountTier.THIRD = { third: {} };
+OrderDiscountTier.FOURTH = { fourth: {} };
+class OrderAction {
+}
+exports.OrderAction = OrderAction;
+OrderAction.PLACE = { place: {} };
+OrderAction.CANCEL = { cancel: {} };
+OrderAction.FILL = { fill: {} };
+class OrderTriggerCondition {
+}
+exports.OrderTriggerCondition = OrderTriggerCondition;
+OrderTriggerCondition.ABOVE = { above: {} };
+OrderTriggerCondition.BELOW = { below: {} };
+function isVariant(object, type) {
+    return object.hasOwnProperty(type);
+}
+exports.isVariant = isVariant;
+var TradeSide;
+(function (TradeSide) {
+    TradeSide[TradeSide["None"] = 0] = "None";
+    TradeSide[TradeSide["Buy"] = 1] = "Buy";
+    TradeSide[TradeSide["Sell"] = 2] = "Sell";
+})(TradeSide = exports.TradeSide || (exports.TradeSide = {}));

package/src/types.ts

@@ -267,7 +267,6 @@ export type OrderStateAccount = {
 };
 
 export type MarketsAccount = {
-	accountIndex: BN;
 	markets: Market[];
 };
 
@@ -278,6 +277,9 @@ export type Market = {
 	baseAssetAmountShort: BN;
 	initialized: boolean;
 	openInterest: BN;
+	marginRatioInitial: number;
+	marginRatioMaintenance: number;
+	marginRatioPartial: number;
 };
 
 export type AMM = {
@@ -443,3 +445,5 @@ export type OrderFillerRewardStructure = {
 	rewardDenominator: BN;
 	timeBasedRewardLowerBound: BN;
 };
+
+export type MarginCategory = 'Initial' | 'Partial' | 'Maintenance';