@drift-labs/sdk 0.2.0-master.11 → 0.2.0-master.12

package/lib/orders.js

@@ -1,85 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = void 0;
+exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = void 0;
 const types_1 = require("./types");
 const _1 = require(".");
-const market_1 = require("./math/market");
 const numericConstants_1 = require("./constants/numericConstants");
 const amm_1 = require("./math/amm");
-const position_1 = require("./math/position");
-function calculateNewStateAfterOrder(userAccount, userPosition, market, order) {
-    if ((0, types_1.isVariant)(order.status, 'init')) {
-        return null;
-    }
-    const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(market, order);
-    if (baseAssetAmountToTrade.lt(market.amm.baseAssetAmountStepSize)) {
-        return null;
-    }
-    const userAccountAfter = Object.assign({}, userAccount);
-    const userPositionAfter = Object.assign({}, userPosition);
-    const currentPositionDirection = (0, position_1.positionCurrentDirection)(userPosition);
-    const increasePosition = userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) ||
-        isSameDirection(order.direction, currentPositionDirection);
-    if (increasePosition) {
-        const marketAfter = (0, market_1.calculateNewMarketAfterTrade)(baseAssetAmountToTrade, order.direction, market);
-        const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(market, marketAfter);
-        userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(baseAssetAmountSwapped);
-        userPositionAfter.quoteAssetAmount = userPositionAfter.quoteAssetAmount.add(quoteAssetAmountSwapped);
-        return [userAccountAfter, userPositionAfter, marketAfter];
-    }
-    else {
-        const reversePosition = baseAssetAmountToTrade.gt(userPosition.baseAssetAmount.abs());
-        if (reversePosition) {
-            const intermediateMarket = (0, market_1.calculateNewMarketAfterTrade)(userPosition.baseAssetAmount, (0, position_1.findDirectionToClose)(userPosition), market);
-            const { quoteAssetAmountSwapped: baseAssetValue } = calculateAmountSwapped(market, intermediateMarket);
-            let pnl;
-            if ((0, types_1.isVariant)(currentPositionDirection, 'long')) {
-                pnl = baseAssetValue.sub(userPosition.quoteAssetAmount);
-            }
-            else {
-                pnl = userPosition.quoteAssetAmount.sub(baseAssetValue);
-            }
-            userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
-            const baseAssetAmountLeft = baseAssetAmountToTrade.sub(userPosition.baseAssetAmount.abs());
-            const marketAfter = (0, market_1.calculateNewMarketAfterTrade)(baseAssetAmountLeft, order.direction, intermediateMarket);
-            const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(intermediateMarket, marketAfter);
-            userPositionAfter.quoteAssetAmount = quoteAssetAmountSwapped;
-            userPositionAfter.baseAssetAmount = baseAssetAmountSwapped;
-            return [userAccountAfter, userPositionAfter, marketAfter];
-        }
-        else {
-            const marketAfter = (0, market_1.calculateNewMarketAfterTrade)(baseAssetAmountToTrade, order.direction, market);
-            const { quoteAssetAmountSwapped: baseAssetValue, baseAssetAmountSwapped, } = calculateAmountSwapped(market, marketAfter);
-            const costBasisRealized = userPosition.quoteAssetAmount
-                .mul(baseAssetAmountSwapped.abs())
-                .div(userPosition.baseAssetAmount.abs());
-            let pnl;
-            if ((0, types_1.isVariant)(currentPositionDirection, 'long')) {
-                pnl = baseAssetValue.sub(costBasisRealized);
-            }
-            else {
-                pnl = costBasisRealized.sub(baseAssetValue);
-            }
-            userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
-            userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(baseAssetAmountSwapped);
-            userPositionAfter.quoteAssetAmount =
-                userPositionAfter.quoteAssetAmount.sub(costBasisRealized);
-            return [userAccountAfter, userPositionAfter, marketAfter];
-        }
-    }
-}
-exports.calculateNewStateAfterOrder = calculateNewStateAfterOrder;
-function calculateAmountSwapped(marketBefore, marketAfter) {
-    return {
-        quoteAssetAmountSwapped: marketBefore.amm.quoteAssetReserve
-            .sub(marketAfter.amm.quoteAssetReserve)
-            .abs()
-            .mul(marketBefore.amm.pegMultiplier)
-            .div(numericConstants_1.PEG_PRECISION)
-            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO),
-        baseAssetAmountSwapped: marketBefore.amm.baseAssetReserve.sub(marketAfter.amm.baseAssetReserve),
-    };
-}
 function calculateBaseAssetAmountMarketCanExecute(market, order, oraclePriceData) {
     if ((0, types_1.isVariant)(order.orderType, 'limit')) {
         return calculateAmountToTradeForLimit(market, order, oraclePriceData);
@@ -103,7 +28,7 @@ function calculateAmountToTradeForLimit(market, order, oraclePriceData) {
         }
         limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
     }
-    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction);
+    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction, oraclePriceData);
     const baseAssetAmount = (0, _1.standardizeBaseAssetAmount)(maxAmountToTrade, market.amm.baseAssetAmountStepSize);
     // Check that directions are the same
     const sameDirection = isSameDirection(direction, order.direction);

package/lib/tokenFaucet.d.ts

@@ -21,6 +21,7 @@ export declare class TokenFaucet {
     getFaucetConfigPublicKey(): Promise<PublicKey>;
     initialize(): Promise<TransactionSignature>;
     fetchState(): Promise<any>;
+    private mintToUserIx;
     mintToUser(userTokenAccount: PublicKey, amount: BN): Promise<TransactionSignature>;
     transferMintAuthority(): Promise<TransactionSignature>;
     createAssociatedTokenAccountAndMintTo(userPublicKey: PublicKey, amount: BN): Promise<[PublicKey, TransactionSignature]>;

package/lib/tokenFaucet.js

@@ -73,8 +73,8 @@ class TokenFaucet {
     async fetchState() {
         return await this.program.account.faucetConfig.fetch(await this.getFaucetConfigPublicKey());
     }
-    async mintToUser(userTokenAccount, amount) {
-        return await this.program.rpc.mintToUser(amount, {
+    async mintToUserIx(userTokenAccount, amount) {
+        return this.program.instruction.mintToUser(amount, {
             accounts: {
                 faucetConfig: await this.getFaucetConfigPublicKey(),
                 mintAccount: this.mint,
@@ -84,6 +84,12 @@ class TokenFaucet {
             },
         });
     }
+    async mintToUser(userTokenAccount, amount) {
+        const mintIx = await this.mintToUserIx(userTokenAccount, amount);
+        const tx = new web3_js_1.Transaction().add(mintIx);
+        const txSig = await this.program.provider.sendAndConfirm(tx, [], this.opts);
+        return txSig;
+    }
     async transferMintAuthority() {
         return await this.program.rpc.transferMintAuthority({
             accounts: {
@@ -96,8 +102,21 @@ class TokenFaucet {
         });
     }
     async createAssociatedTokenAccountAndMintTo(userPublicKey, amount) {
+        const tx = new web3_js_1.Transaction();
         const [associatedTokenPublicKey, createAssociatedAccountIx, mintToTx] = await this.createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount);
-        const tx = new web3_js_1.Transaction().add(createAssociatedAccountIx).add(mintToTx);
+        let associatedTokenAccountExists = false;
+        try {
+            const assosciatedTokenAccount = await this.connection.getAccountInfo(associatedTokenPublicKey);
+            associatedTokenAccountExists = !!assosciatedTokenAccount;
+        }
+        catch (e) {
+            // token account doesn't exist
+            associatedTokenAccountExists = false;
+        }
+        const skipAccountCreation = associatedTokenAccountExists;
+        if (!skipAccountCreation)
+            tx.add(createAssociatedAccountIx);
+        tx.add(mintToTx);
         const txSig = await this.program.provider.sendAndConfirm(tx, [], this.opts);
         return [associatedTokenPublicKey, txSig];
     }
@@ -105,15 +124,7 @@ class TokenFaucet {
         const state = await this.fetchState();
         const associateTokenPublicKey = await 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 = await this.program.instruction.mintToUser(amount, {
-            accounts: {
-                faucetConfig: await this.getFaucetConfigPublicKey(),
-                mintAccount: state.mint,
-                userTokenAccount: associateTokenPublicKey,
-                mintAuthority: state.mintAuthority,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            },
-        });
+        const mintToIx = await this.mintToUserIx(associateTokenPublicKey, amount);
         return [associateTokenPublicKey, createAssociatedAccountIx, mintToIx];
     }
     async getAssosciatedMockUSDMintAddress(props) {

package/lib/tx/retryTxSender.js

@@ -25,8 +25,15 @@ class RetryTxSender {
         await this.prepareTx(tx, additionalSigners, opts);
         const rawTransaction = tx.serialize();
         const startTime = this.getTimestamp();
-        const txid = await this.provider.connection.sendRawTransaction(rawTransaction, opts);
-        this.sendToAdditionalConnections(rawTransaction, opts);
+        let txid;
+        try {
+            txid = await this.provider.connection.sendRawTransaction(rawTransaction, opts);
+            this.sendToAdditionalConnections(rawTransaction, opts);
+        }
+        catch (e) {
+            console.error(e);
+            throw e;
+        }
         let done = false;
         const resolveReference = {
             resolve: undefined,

package/lib/types.d.ts

@@ -113,6 +113,12 @@ export declare class OrderActionExplanation {
     static readonly MARKET_ORDER_FILLED_TO_LIMIT_PRICE: {
         marketOrderFilledToLimitPrice: {};
     };
+    static readonly CANCELED_FOR_LIQUIDATION: {
+        canceledForLiquidation: {};
+    };
+    static readonly MARKET_ORDER_AUCTION_EXPIRED: {
+        marketOrderAuctionExpired: {};
+    };
 }
 export declare class OrderTriggerCondition {
     static readonly ABOVE: {
@@ -192,6 +198,7 @@ export declare type LiquidationRecord = {
     liquidationType: LiquidationType;
     marginRequirement: BN;
     totalCollateral: BN;
+    liquidationId: number;
     liquidatePerp: LiquidatePerpRecord;
     liquidateBorrow: LiquidateBorrowRecord;
     liquidateBorrowForPerpPnl: LiquidateBorrowForPerpPnlRecord;
@@ -248,14 +255,23 @@ export declare type LiquidatePerpPnlForDepositRecord = {
     assetPrice: BN;
     assetTransfer: BN;
 };
+export declare type SettlePnlRecord = {
+    ts: BN;
+    marketIndex: BN;
+    pnl: BN;
+    baseAssetAmount: BN;
+    quoteAssetAmountAfter: BN;
+    quoteEntryamount: BN;
+    oraclePrice: BN;
+};
 export declare type OrderRecord = {
     ts: BN;
     taker: PublicKey;
     maker: PublicKey;
     takerOrder: Order;
     makerOrder: Order;
-    takerUnsettledPnl: BN;
-    makerUnsettledPnl: BN;
+    takerPnl: BN;
+    makerPnl: BN;
     action: OrderAction;
     actionExplanation: OrderActionExplanation;
     filler: PublicKey;
@@ -313,6 +329,10 @@ export declare type MarketAccount = {
     nextFillRecordId: BN;
     pnlPool: PoolBalance;
     liquidationFee: BN;
+    imfFactor: BN;
+    unsettledImfFactor: BN;
+    unsettledInitialAssetWeight: number;
+    unsettledMaintenanceAssetWeight: number;
 };
 export declare type BankAccount = {
     bankIndex: BN;
@@ -336,6 +356,7 @@ export declare type BankAccount = {
     initialLiabilityWeight: BN;
     maintenanceLiabilityWeight: BN;
     liquidationFee: BN;
+    imfFactor: BN;
 };
 export declare type PoolBalance = {
     balance: BN;
@@ -393,7 +414,6 @@ export declare type UserPosition = {
     quoteAssetAmount: BN;
     quoteEntryAmount: BN;
     openOrders: BN;
-    unsettledPnl: BN;
     openBids: BN;
     openAsks: BN;
 };
@@ -414,6 +434,7 @@ export declare type UserAccount = {
     positions: UserPosition[];
     orders: Order[];
     beingLiquidated: boolean;
+    nextLiquidationId: number;
 };
 export declare type UserBankBalance = {
     bankIndex: BN;

package/lib/types.js

@@ -70,6 +70,12 @@ OrderActionExplanation.ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
 OrderActionExplanation.MARKET_ORDER_FILLED_TO_LIMIT_PRICE = {
     marketOrderFilledToLimitPrice: {},
 };
+OrderActionExplanation.CANCELED_FOR_LIQUIDATION = {
+    canceledForLiquidation: {},
+};
+OrderActionExplanation.MARKET_ORDER_AUCTION_EXPIRED = {
+    marketOrderAuctionExpired: {},
+};
 class OrderTriggerCondition {
 }
 exports.OrderTriggerCondition = OrderTriggerCondition;

package/lib/util/getTokenAddress.d.ts

@@ -0,0 +1,2 @@
+import { PublicKey } from '@solana/web3.js';
+export declare const getTokenAddress: (mintAddress: string, userPubKey: string) => Promise<PublicKey>;

package/lib/util/getTokenAddress.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenAddress = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const getTokenAddress = (mintAddress, userPubKey) => {
+    return spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, new web3_js_1.PublicKey(mintAddress), new web3_js_1.PublicKey(userPubKey));
+};
+exports.getTokenAddress = getTokenAddress;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.2.0-master.11",
+	"version": "0.2.0-master.12",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",