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

package/lib/orderParams.js

@@ -2,107 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMarketOrderParams = exports.getTriggerLimitOrderParams = exports.getTriggerMarketOrderParams = exports.getLimitOrderParams = void 0;
 const types_1 = require("./types");
-const numericConstants_1 = require("./constants/numericConstants");
-function getLimitOrderParams(marketIndex, direction, baseAssetAmount, price, reduceOnly, discountToken = false, referrer = false, userOrderId = 0, postOnly = false, oraclePriceOffset = numericConstants_1.ZERO, immediateOrCancel = false) {
-    return {
-        orderType: types_1.OrderType.LIMIT,
-        userOrderId,
-        marketIndex,
-        direction,
-        quoteAssetAmount: numericConstants_1.ZERO,
-        baseAssetAmount,
-        price,
-        reduceOnly,
-        postOnly,
-        immediateOrCancel,
-        positionLimit: numericConstants_1.ZERO,
-        padding0: true,
-        padding1: numericConstants_1.ZERO,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition: types_1.OrderTriggerCondition.ABOVE,
-        triggerPrice: numericConstants_1.ZERO,
-        oraclePriceOffset,
-    };
+function getLimitOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.LIMIT });
 }
 exports.getLimitOrderParams = getLimitOrderParams;
-function getTriggerMarketOrderParams(marketIndex, direction, baseAssetAmount, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
-    return {
-        orderType: types_1.OrderType.TRIGGER_MARKET,
-        userOrderId,
-        marketIndex,
-        direction,
-        quoteAssetAmount: numericConstants_1.ZERO,
-        baseAssetAmount,
-        price: numericConstants_1.ZERO,
-        reduceOnly,
-        postOnly: false,
-        immediateOrCancel: false,
-        positionLimit: numericConstants_1.ZERO,
-        padding0: true,
-        padding1: numericConstants_1.ZERO,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition,
-        triggerPrice,
-        oraclePriceOffset: numericConstants_1.ZERO,
-    };
+function getTriggerMarketOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_MARKET });
 }
 exports.getTriggerMarketOrderParams = getTriggerMarketOrderParams;
-function getTriggerLimitOrderParams(marketIndex, direction, baseAssetAmount, price, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
-    return {
-        orderType: types_1.OrderType.TRIGGER_LIMIT,
-        userOrderId,
-        marketIndex,
-        direction,
-        quoteAssetAmount: numericConstants_1.ZERO,
-        baseAssetAmount,
-        price,
-        reduceOnly,
-        postOnly: false,
-        immediateOrCancel: false,
-        positionLimit: numericConstants_1.ZERO,
-        padding0: true,
-        padding1: numericConstants_1.ZERO,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition,
-        triggerPrice,
-        oraclePriceOffset: numericConstants_1.ZERO,
-    };
+function getTriggerLimitOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_LIMIT });
 }
 exports.getTriggerLimitOrderParams = getTriggerLimitOrderParams;
-function getMarketOrderParams(marketIndex, direction, quoteAssetAmount, baseAssetAmount, reduceOnly, price = numericConstants_1.ZERO, discountToken = false, referrer = false) {
-    if (baseAssetAmount.eq(numericConstants_1.ZERO) && quoteAssetAmount.eq(numericConstants_1.ZERO)) {
-        throw Error('baseAssetAmount or quoteAssetAmount must be zero');
-    }
-    return {
-        orderType: types_1.OrderType.MARKET,
-        userOrderId: 0,
-        marketIndex,
-        direction,
-        quoteAssetAmount,
-        baseAssetAmount,
-        price,
-        reduceOnly,
-        postOnly: false,
-        immediateOrCancel: false,
-        positionLimit: numericConstants_1.ZERO,
-        padding0: true,
-        padding1: numericConstants_1.ZERO,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition: types_1.OrderTriggerCondition.ABOVE,
-        triggerPrice: numericConstants_1.ZERO,
-        oraclePriceOffset: numericConstants_1.ZERO,
-    };
+function getMarketOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.MARKET });
 }
 exports.getMarketOrderParams = getMarketOrderParams;

package/lib/orders.d.ts

@@ -1,9 +1,8 @@
 /// <reference types="bn.js" />
 import { MarketAccount, Order, UserAccount, UserPosition } from './types';
-import { BN, ClearingHouseUser } from '.';
+import { BN } from '.';
 import { OraclePriceData } from '.';
 export declare function calculateNewStateAfterOrder(userAccount: UserAccount, userPosition: UserPosition, market: MarketAccount, order: Order): [UserAccount, UserPosition, MarketAccount] | null;
 export declare function calculateBaseAssetAmountMarketCanExecute(market: MarketAccount, order: Order, oraclePriceData?: OraclePriceData): BN;
 export declare function calculateAmountToTradeForLimit(market: MarketAccount, order: Order, oraclePriceData?: OraclePriceData): BN;
 export declare function calculateAmountToTradeForTriggerLimit(market: MarketAccount, order: Order): BN;
-export declare function calculateBaseAssetAmountUserCanExecute(market: MarketAccount, order: Order, user: ClearingHouseUser, oraclePriceData?: OraclePriceData): BN;

package/lib/orders.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateBaseAssetAmountUserCanExecute = exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = void 0;
+exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = void 0;
 const types_1 = require("./types");
 const _1 = require(".");
 const market_1 = require("./math/market");
@@ -88,7 +88,6 @@ function calculateBaseAssetAmountMarketCanExecute(market, order, oraclePriceData
         return calculateAmountToTradeForTriggerLimit(market, order);
     }
     else if ((0, types_1.isVariant)(order.orderType, 'market')) {
-        // should never be a market order queued
         return numericConstants_1.ZERO;
     }
     else {
@@ -102,15 +101,7 @@ function calculateAmountToTradeForLimit(market, order, oraclePriceData) {
         if (!oraclePriceData) {
             throw Error('Cant calculate limit price for oracle offset oracle without OraclePriceData');
         }
-        const floatingPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-        if (order.postOnly) {
-            limitPrice = (0, types_1.isVariant)(order.direction, 'long')
-                ? _1.BN.min(order.price, floatingPrice)
-                : _1.BN.max(order.price, floatingPrice);
-        }
-        else {
-            limitPrice = floatingPrice;
-        }
+        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
     }
     const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction);
     const baseAssetAmount = (0, _1.standardizeBaseAssetAmount)(maxAmountToTrade, market.amm.baseAssetAmountStepSize);
@@ -125,11 +116,8 @@ function calculateAmountToTradeForLimit(market, order, oraclePriceData) {
 }
 exports.calculateAmountToTradeForLimit = calculateAmountToTradeForLimit;
 function calculateAmountToTradeForTriggerLimit(market, order) {
-    if (order.baseAssetAmountFilled.eq(numericConstants_1.ZERO)) {
-        const baseAssetAmount = calculateAmountToTradeForTriggerMarket(market, order);
-        if (baseAssetAmount.eq(numericConstants_1.ZERO)) {
-            return numericConstants_1.ZERO;
-        }
+    if (!order.triggered) {
+        return numericConstants_1.ZERO;
     }
     return calculateAmountToTradeForLimit(market, order);
 }
@@ -139,75 +127,8 @@ function isSameDirection(firstDirection, secondDirection) {
         ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
 }
 function calculateAmountToTradeForTriggerMarket(market, order) {
-    return isTriggerConditionSatisfied(market, order)
-        ? order.baseAssetAmount
-        : numericConstants_1.ZERO;
-}
-function isTriggerConditionSatisfied(market, order, oraclePriceData) {
-    const markPrice = (0, market_1.calculateMarkPrice)(market, oraclePriceData);
-    if ((0, types_1.isVariant)(order.triggerCondition, 'above')) {
-        return markPrice.gt(order.triggerPrice);
-    }
-    else {
-        return markPrice.lt(order.triggerPrice);
-    }
-}
-function calculateBaseAssetAmountUserCanExecute(market, order, user, oraclePriceData) {
-    const maxLeverage = user.getMaxLeverage(order.marketIndex, 'Initial');
-    const freeCollateral = user.getFreeCollateral();
-    let quoteAssetAmount;
-    if ((0, _1.isOrderRiskIncreasingInSameDirection)(user, order)) {
-        quoteAssetAmount = freeCollateral.mul(maxLeverage).div(_1.TEN_THOUSAND);
-    }
-    else {
-        const position = user.getUserPosition(order.marketIndex) ||
-            user.getEmptyPosition(order.marketIndex);
-        const positionValue = (0, _1.calculateBaseAssetValue)(market, position, oraclePriceData);
-        quoteAssetAmount = freeCollateral
-            .mul(maxLeverage)
-            .div(_1.TEN_THOUSAND)
-            .add(positionValue.mul(numericConstants_1.TWO));
-    }
-    if (quoteAssetAmount.lte(numericConstants_1.ZERO)) {
+    if (!order.triggered) {
         return numericConstants_1.ZERO;
     }
-    const swapDirection = (0, types_1.isVariant)(order.direction, 'long')
-        ? types_1.SwapDirection.ADD
-        : types_1.SwapDirection.REMOVE;
-    const useSpread = !order.postOnly;
-    let amm;
-    if (useSpread) {
-        const { baseAssetReserve, quoteAssetReserve } = (0, _1.calculateSpreadReserves)(market.amm, order.direction, oraclePriceData);
-        amm = {
-            baseAssetReserve,
-            quoteAssetReserve,
-            sqrtK: market.amm.sqrtK,
-            pegMultiplier: market.amm.pegMultiplier,
-        };
-    }
-    else {
-        amm = market.amm;
-    }
-    const baseAssetReservesBefore = amm.baseAssetReserve;
-    const [_, baseAssetReservesAfter] = (0, _1.calculateAmmReservesAfterSwap)(amm, 'quote', quoteAssetAmount, swapDirection);
-    let baseAssetAmount = baseAssetReservesBefore
-        .sub(baseAssetReservesAfter)
-        .abs();
-    if (order.reduceOnly) {
-        const position = user.getUserPosition(order.marketIndex) ||
-            user.getEmptyPosition(order.marketIndex);
-        if ((0, types_1.isVariant)(order.direction, 'long') &&
-            position.baseAssetAmount.gte(numericConstants_1.ZERO)) {
-            baseAssetAmount = numericConstants_1.ZERO;
-        }
-        else if ((0, types_1.isVariant)(order.direction, 'short') &&
-            position.baseAssetAmount.lte(numericConstants_1.ZERO)) {
-            baseAssetAmount = numericConstants_1.ZERO;
-        }
-        else {
-            _1.BN.min(baseAssetAmount, position.baseAssetAmount.abs());
-        }
-    }
-    return baseAssetAmount;
+    return order.baseAssetAmount;
 }
-exports.calculateBaseAssetAmountUserCanExecute = calculateBaseAssetAmountUserCanExecute;

package/lib/slot/SlotSubscriber.d.ts

@@ -1,9 +1,16 @@
+/// <reference types="node" />
 import { Connection } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types/types/src';
 declare type SlotSubscriberConfig = {};
+export interface SlotSubscriberEvents {
+    newSlot: (newSlot: number) => void;
+}
 export declare class SlotSubscriber {
     private connection;
     currentSlot: number;
     subscriptionId: number;
+    eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
     constructor(connection: Connection, _config?: SlotSubscriberConfig);
     subscribe(): Promise<void>;
     getSlot(): number;

package/lib/slot/SlotSubscriber.js

@@ -1,14 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SlotSubscriber = void 0;
+const events_1 = require("events");
 class SlotSubscriber {
     constructor(connection, _config) {
         this.connection = connection;
+        this.eventEmitter = new events_1.EventEmitter();
     }
     async subscribe() {
         this.currentSlot = await this.connection.getSlot('confirmed');
         this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
             this.currentSlot = slotInfo.slot;
+            this.eventEmitter.emit('newSlot', slotInfo.slot);
         });
     }
     getSlot() {

package/lib/{mockUSDCFaucet.d.ts → tokenFaucet.d.ts}

@@ -5,22 +5,24 @@ import { AccountInfo } from '@solana/spl-token';
 import { ConfirmOptions, Connection, PublicKey, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
 import { BN } from '.';
 import { IWallet } from './types';
-export declare class MockUSDCFaucet {
+export declare class TokenFaucet {
     connection: Connection;
     wallet: IWallet;
     program: Program;
     provider: AnchorProvider;
+    mint: PublicKey;
     opts?: ConfirmOptions;
-    constructor(connection: Connection, wallet: IWallet, programId: PublicKey, opts?: ConfirmOptions);
-    getMockUSDCFaucetStatePublicKeyAndNonce(): Promise<[
+    constructor(connection: Connection, wallet: IWallet, programId: PublicKey, mint: PublicKey, opts?: ConfirmOptions);
+    getFaucetConfigPublicKeyAndNonce(): Promise<[
         PublicKey,
         number
     ]>;
-    mockUSDCFaucetStatePublicKey?: PublicKey;
-    getMockUSDCFaucetStatePublicKey(): Promise<PublicKey>;
+    getMintAuthority(): Promise<PublicKey>;
+    getFaucetConfigPublicKey(): Promise<PublicKey>;
     initialize(): Promise<TransactionSignature>;
     fetchState(): Promise<any>;
     mintToUser(userTokenAccount: PublicKey, amount: BN): Promise<TransactionSignature>;
+    transferMintAuthority(): Promise<TransactionSignature>;
     createAssociatedTokenAccountAndMintTo(userPublicKey: PublicKey, amount: BN): Promise<[PublicKey, TransactionSignature]>;
     createAssociatedTokenAccountAndMintToInstructions(userPublicKey: PublicKey, amount: BN): Promise<[PublicKey, TransactionInstruction, TransactionInstruction]>;
     getAssosciatedMockUSDMintAddress(props: {

package/lib/{mockUSDCFaucet.js → tokenFaucet.js}

@@ -26,74 +26,75 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockUSDCFaucet = void 0;
+exports.TokenFaucet = 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) {
+const token_faucet_json_1 = __importDefault(require("./idl/token_faucet.json"));
+class TokenFaucet {
+    constructor(connection, wallet, programId, mint, opts) {
         this.connection = connection;
         this.wallet = wallet;
         this.opts = opts || anchor_1.AnchorProvider.defaultOptions();
         const provider = new anchor_1.AnchorProvider(connection, wallet, this.opts);
         this.provider = provider;
-        this.program = new anchor_1.Program(mock_usdc_faucet_json_1.default, programId, provider);
+        this.program = new anchor_1.Program(token_faucet_json_1.default, programId, provider);
+        this.mint = mint;
     }
-    async getMockUSDCFaucetStatePublicKeyAndNonce() {
-        return anchor.web3.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('mock_usdc_faucet'))], this.program.programId);
+    async getFaucetConfigPublicKeyAndNonce() {
+        return anchor.web3.PublicKey.findProgramAddress([
+            Buffer.from(anchor.utils.bytes.utf8.encode('faucet_config')),
+            this.mint.toBuffer(),
+        ], this.program.programId);
     }
-    async getMockUSDCFaucetStatePublicKey() {
-        if (this.mockUSDCFaucetStatePublicKey) {
-            return this.mockUSDCFaucetStatePublicKey;
-        }
-        this.mockUSDCFaucetStatePublicKey = (await this.getMockUSDCFaucetStatePublicKeyAndNonce())[0];
-        return this.mockUSDCFaucetStatePublicKey;
+    async getMintAuthority() {
+        return (await anchor.web3.PublicKey.findProgramAddress([
+            Buffer.from(anchor.utils.bytes.utf8.encode('mint_authority')),
+            this.mint.toBuffer(),
+        ], this.program.programId))[0];
+    }
+    async getFaucetConfigPublicKey() {
+        return (await this.getFaucetConfigPublicKeyAndNonce())[0];
     }
     async initialize() {
-        const stateAccountRPCResponse = await this.connection.getParsedAccountInfo(await 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: await spl_token_1.Token.getMinBalanceRentForExemptMint(this.connection),
-            space: spl_token_1.MintLayout.span,
-            programId: spl_token_1.TOKEN_PROGRAM_ID,
-        });
-        const [mintAuthority, _mintAuthorityNonce] = await 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] = await this.getMockUSDCFaucetStatePublicKeyAndNonce();
-        return await this.program.rpc.initialize(mockUSDCFaucetStateNonce, {
+        const [faucetConfigPublicKey] = await this.getFaucetConfigPublicKeyAndNonce();
+        return await this.program.rpc.initialize({
             accounts: {
-                mockUsdcFaucetState: mockUSDCFaucetStatePublicKey,
+                faucetConfig: faucetConfigPublicKey,
                 admin: this.wallet.publicKey,
-                mintAccount: fakeUSDCMint.publicKey,
+                mintAccount: this.mint,
                 rent: web3_js_1.SYSVAR_RENT_PUBKEY,
                 systemProgram: anchor.web3.SystemProgram.programId,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
-            instructions: [createUSDCMintAccountIx, initUSDCMintIx],
-            signers: [fakeUSDCMint],
         });
     }
     async fetchState() {
-        return await this.program.account.mockUsdcFaucetState.fetch(await this.getMockUSDCFaucetStatePublicKey());
+        return await this.program.account.faucetConfig.fetch(await this.getFaucetConfigPublicKey());
     }
     async mintToUser(userTokenAccount, amount) {
-        const state = await this.fetchState();
         return await this.program.rpc.mintToUser(amount, {
             accounts: {
-                mockUsdcFaucetState: await this.getMockUSDCFaucetStatePublicKey(),
-                mintAccount: state.mint,
+                faucetConfig: await this.getFaucetConfigPublicKey(),
+                mintAccount: this.mint,
                 userTokenAccount,
-                mintAuthority: state.mintAuthority,
+                mintAuthority: await this.getMintAuthority(),
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
         });
     }
+    async transferMintAuthority() {
+        return await this.program.rpc.transferMintAuthority({
+            accounts: {
+                faucetConfig: await this.getFaucetConfigPublicKey(),
+                mintAccount: this.mint,
+                mintAuthority: await this.getMintAuthority(),
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                admin: this.wallet.publicKey,
+            },
+        });
+    }
     async createAssociatedTokenAccountAndMintTo(userPublicKey, amount) {
         const [associatedTokenPublicKey, createAssociatedAccountIx, mintToTx] = await this.createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount);
         const tx = new web3_js_1.Transaction().add(createAssociatedAccountIx).add(mintToTx);
@@ -106,7 +107,7 @@ class MockUSDCFaucet {
         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: {
-                mockUsdcFaucetState: await this.getMockUSDCFaucetStatePublicKey(),
+                faucetConfig: await this.getFaucetConfigPublicKey(),
                 mintAccount: state.mint,
                 userTokenAccount: associateTokenPublicKey,
                 mintAuthority: state.mintAuthority,
@@ -143,4 +144,4 @@ class MockUSDCFaucet {
         }
     }
 }
-exports.MockUSDCFaucet = MockUSDCFaucet;
+exports.TokenFaucet = TokenFaucet;

package/lib/tx/utils.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrapInTx = void 0;
 const web3_js_1 = require("@solana/web3.js");
 const COMPUTE_UNITS_DEFAULT = 200000;
-function wrapInTx(instruction, computeUnits = 500000 // TODO, requires less code change
+function wrapInTx(instruction, computeUnits = 600000 // TODO, requires less code change
 ) {
     const tx = new web3_js_1.Transaction();
     if (computeUnits != COMPUTE_UNITS_DEFAULT) {