@drift-labs/sdk 0.2.0-master.2 → 0.2.0-master.22

package/src/math/trade.ts

@@ -1,4 +1,4 @@
-import { MarketAccount, PositionDirection, SwapDirection } from '../types';
+import { MarketAccount, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
@@ -78,28 +78,20 @@ export function calculateTradeSlippage(
 	if (amount.eq(ZERO)) {
 		return [ZERO, ZERO, oldPrice, oldPrice];
 	}
-	const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(
-		direction,
-		amount,
-		market,
-		inputAssetType,
-		oraclePriceData,
-		useSpread
-	);
-
-	const swapDirection = isVariant(direction, 'long')
-		? SwapDirection.REMOVE
-		: SwapDirection.ADD;
-	const quoteAssetAmountAcquired = calculateQuoteAssetAmountSwapped(
-		acquiredQuote.abs(),
-		market.amm.pegMultiplier,
-		swapDirection
-	);
+	const [acquiredBaseReserve, acquiredQuoteReserve, acquiredQuoteAssetAmount] =
+		calculateTradeAcquiredAmounts(
+			direction,
+			amount,
+			market,
+			inputAssetType,
+			oraclePriceData,
+			useSpread
+		);
 
-	const entryPrice = quoteAssetAmountAcquired
+	const entryPrice = acquiredQuoteAssetAmount
 		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
 		.mul(MARK_PRICE_PRECISION)
-		.div(acquiredBase.abs());
+		.div(acquiredBaseReserve.abs());
 
 	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
 	if (useSpread && market.amm.baseSpread > 0) {
@@ -116,8 +108,8 @@ export function calculateTradeSlippage(
 	}
 
 	const newPrice = calculatePrice(
-		amm.baseAssetReserve.sub(acquiredBase),
-		amm.quoteAssetReserve.sub(acquiredQuote),
+		amm.baseAssetReserve.sub(acquiredBaseReserve),
+		amm.quoteAssetReserve.sub(acquiredQuoteReserve),
 		amm.pegMultiplier
 	);
 
@@ -159,9 +151,9 @@ export function calculateTradeAcquiredAmounts(
 	inputAssetType: AssetType = 'quote',
 	oraclePriceData: OraclePriceData,
 	useSpread = true
-): [BN, BN] {
+): [BN, BN, BN] {
 	if (amount.eq(ZERO)) {
-		return [ZERO, ZERO];
+		return [ZERO, ZERO, ZERO];
 	}
 
 	const swapDirection = getSwapDirection(inputAssetType, direction);
@@ -185,7 +177,13 @@ export function calculateTradeAcquiredAmounts(
 
 	const acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
 	const acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
-	return [acquiredBase, acquiredQuote];
+	const acquiredQuoteAssetAmount = calculateQuoteAssetAmountSwapped(
+		acquiredQuote.abs(),
+		amm.pegMultiplier,
+		swapDirection
+	);
+
+	return [acquiredBase, acquiredQuote, acquiredQuoteAssetAmount];
 }
 
 /**

package/src/math/utils.js

@@ -24,4 +24,3 @@ const squareRootBN = (n, closeness = new __1.BN(1)) => {
     return root;
 };
 exports.squareRootBN = squareRootBN;
-//# sourceMappingURL=utils.js.map

package/src/oracles/oracleClientCache.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OracleClientCache = void 0;
+const oracleClient_1 = require("../factory/oracleClient");
+class OracleClientCache {
+    constructor() {
+        this.cache = new Map();
+    }
+    get(oracleSource, connection) {
+        const key = Object.keys(oracleSource)[0];
+        if (this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        const client = oracleClient_1.getOracleClient(oracleSource, connection);
+        this.cache.set(key, client);
+        return client;
+    }
+}
+exports.OracleClientCache = OracleClientCache;

package/src/oracles/pythClient.js

@@ -0,0 +1,46 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertPythPrice = exports.PythClient = void 0;
+const client_1 = require("@pythnetwork/client");
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+class PythClient {
+    constructor(connection) {
+        this.connection = connection;
+    }
+    getOraclePriceData(pricePublicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accountInfo = yield this.connection.getAccountInfo(pricePublicKey);
+            return this.getOraclePriceDataFromBuffer(accountInfo.data);
+        });
+    }
+    getOraclePriceDataFromBuffer(buffer) {
+        const priceData = client_1.parsePriceData(buffer);
+        return {
+            price: convertPythPrice(priceData.aggregate.price, priceData.exponent),
+            slot: new anchor_1.BN(priceData.lastSlot.toString()),
+            confidence: convertPythPrice(priceData.confidence, priceData.exponent),
+            twap: convertPythPrice(priceData.twap.value, priceData.exponent),
+            twapConfidence: convertPythPrice(priceData.twac.value, priceData.exponent),
+            hasSufficientNumberOfDataPoints: true,
+        };
+    }
+}
+exports.PythClient = PythClient;
+function convertPythPrice(price, exponent) {
+    exponent = Math.abs(exponent);
+    const pythPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(exponent).abs());
+    return new anchor_1.BN(price * Math.pow(10, exponent))
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(pythPrecision);
+}
+exports.convertPythPrice = convertPythPrice;

package/src/oracles/quoteAssetOracleClient.js

@@ -0,0 +1,32 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuoteAssetOracleClient = exports.QUOTE_ORACLE_PRICE_DATA = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+exports.QUOTE_ORACLE_PRICE_DATA = {
+    price: numericConstants_1.MARK_PRICE_PRECISION,
+    slot: new anchor_1.BN(0),
+    confidence: new anchor_1.BN(1),
+    hasSufficientNumberOfDataPoints: true,
+};
+class QuoteAssetOracleClient {
+    constructor() { }
+    getOraclePriceData(_pricePublicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve(exports.QUOTE_ORACLE_PRICE_DATA);
+        });
+    }
+    getOraclePriceDataFromBuffer(_buffer) {
+        return exports.QUOTE_ORACLE_PRICE_DATA;
+    }
+}
+exports.QuoteAssetOracleClient = QuoteAssetOracleClient;

package/src/oracles/switchboardClient.js

@@ -0,0 +1,69 @@
+"use strict";
+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.SwitchboardClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+const wallet_1 = require("../wallet");
+const switchboard_v2_json_1 = __importDefault(require("../idl/switchboard_v2.json"));
+let program;
+class SwitchboardClient {
+    constructor(connection) {
+        this.connection = connection;
+    }
+    getOraclePriceData(pricePublicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accountInfo = yield this.connection.getAccountInfo(pricePublicKey);
+            return this.getOraclePriceDataFromBuffer(accountInfo.data);
+        });
+    }
+    getOraclePriceDataFromBuffer(buffer) {
+        const program = this.getProgram();
+        const aggregatorAccountData = program.account.aggregatorAccountData.coder.accounts.decode('AggregatorAccountData', buffer);
+        const price = convertSwitchboardDecimal(aggregatorAccountData.latestConfirmedRound.result);
+        const confidence = convertSwitchboardDecimal(aggregatorAccountData.latestConfirmedRound
+            .stdDeviation);
+        const hasSufficientNumberOfDataPoints = aggregatorAccountData.latestConfirmedRound.numSuccess >=
+            aggregatorAccountData.minOracleResults;
+        const slot = aggregatorAccountData.latestConfirmedRound.roundOpenSlot;
+        return {
+            price,
+            slot,
+            confidence,
+            hasSufficientNumberOfDataPoints,
+        };
+    }
+    getProgram() {
+        if (program) {
+            return program;
+        }
+        program = getSwitchboardProgram(this.connection);
+        return program;
+    }
+}
+exports.SwitchboardClient = SwitchboardClient;
+function getSwitchboardProgram(connection) {
+    const DEFAULT_KEYPAIR = web3_js_1.Keypair.fromSeed(new Uint8Array(32).fill(1));
+    const programId = web3_js_1.PublicKey.default;
+    const wallet = new wallet_1.Wallet(DEFAULT_KEYPAIR);
+    const provider = new anchor_1.AnchorProvider(connection, wallet, {});
+    return new anchor_1.Program(switchboard_v2_json_1.default, programId, provider);
+}
+function convertSwitchboardDecimal(switchboardDecimal) {
+    const switchboardPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(switchboardDecimal.scale));
+    return switchboardDecimal.mantissa
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(switchboardPrecision);
+}

package/src/oracles/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/orderParams.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMarketOrderParams = exports.getTriggerLimitOrderParams = exports.getTriggerMarketOrderParams = exports.getLimitOrderParams = void 0;
+const types_1 = require("./types");
+function getLimitOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.LIMIT });
+}
+exports.getLimitOrderParams = getLimitOrderParams;
+function getTriggerMarketOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_MARKET });
+}
+exports.getTriggerMarketOrderParams = getTriggerMarketOrderParams;
+function getTriggerLimitOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_LIMIT });
+}
+exports.getTriggerLimitOrderParams = getTriggerLimitOrderParams;
+function getMarketOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.MARKET });
+}
+exports.getMarketOrderParams = getMarketOrderParams;

package/src/orderParams.ts

@@ -1,154 +1,33 @@
-import {
-	OrderParams,
-	OrderTriggerCondition,
-	OrderType,
-	PositionDirection,
-} from './types';
+import { OptionalOrderParams, OrderTriggerCondition, OrderType } from './types';
 import { BN } from '@project-serum/anchor';
-import { ZERO } from './constants/numericConstants';
 
 export function getLimitOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	baseAssetAmount: BN,
-	price: BN,
-	reduceOnly: boolean,
-	discountToken = false,
-	referrer = false,
-	userOrderId = 0,
-	postOnly = false,
-	oraclePriceOffset = ZERO,
-	immediateOrCancel = false
-): OrderParams {
-	return {
-		orderType: OrderType.LIMIT,
-		userOrderId,
-		marketIndex,
-		direction,
-		quoteAssetAmount: ZERO,
-		baseAssetAmount,
-		price,
-		reduceOnly,
-		postOnly,
-		immediateOrCancel,
-		positionLimit: ZERO,
-		padding0: true,
-		padding1: ZERO,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition: OrderTriggerCondition.ABOVE,
-		triggerPrice: ZERO,
-		oraclePriceOffset,
-	};
+	params: Omit<OptionalOrderParams, 'orderType'> & { price: BN }
+): OptionalOrderParams {
+	return Object.assign({}, params, { orderType: OrderType.LIMIT });
 }
 
 export function getTriggerMarketOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	baseAssetAmount: BN,
-	triggerPrice: BN,
-	triggerCondition: OrderTriggerCondition,
-	reduceOnly: boolean,
-	discountToken = false,
-	referrer = false,
-	userOrderId = 0
-): OrderParams {
-	return {
-		orderType: OrderType.TRIGGER_MARKET,
-		userOrderId,
-		marketIndex,
-		direction,
-		quoteAssetAmount: ZERO,
-		baseAssetAmount,
-		price: ZERO,
-		reduceOnly,
-		postOnly: false,
-		immediateOrCancel: false,
-		positionLimit: ZERO,
-		padding0: true,
-		padding1: ZERO,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition,
-		triggerPrice,
-		oraclePriceOffset: ZERO,
-	};
+	params: Omit<OptionalOrderParams, 'orderType'> & {
+		triggerCondition: OrderTriggerCondition;
+		triggerPrice: BN;
+	}
+): OptionalOrderParams {
+	return Object.assign({}, params, { orderType: OrderType.TRIGGER_MARKET });
 }
 
 export function getTriggerLimitOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	baseAssetAmount: BN,
-	price: BN,
-	triggerPrice: BN,
-	triggerCondition: OrderTriggerCondition,
-	reduceOnly: boolean,
-	discountToken = false,
-	referrer = false,
-	userOrderId = 0
-): OrderParams {
-	return {
-		orderType: OrderType.TRIGGER_LIMIT,
-		userOrderId,
-		marketIndex,
-		direction,
-		quoteAssetAmount: ZERO,
-		baseAssetAmount,
-		price,
-		reduceOnly,
-		postOnly: false,
-		immediateOrCancel: false,
-		positionLimit: ZERO,
-		padding0: true,
-		padding1: ZERO,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition,
-		triggerPrice,
-		oraclePriceOffset: ZERO,
-	};
+	params: Omit<OptionalOrderParams, 'orderType'> & {
+		triggerCondition: OrderTriggerCondition;
+		triggerPrice: BN;
+		price: BN;
+	}
+): OptionalOrderParams {
+	return Object.assign({}, params, { orderType: OrderType.TRIGGER_LIMIT });
 }
 
 export function getMarketOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	quoteAssetAmount: BN,
-	baseAssetAmount: BN,
-	reduceOnly: boolean,
-	price = ZERO,
-	discountToken = false,
-	referrer = false
-): OrderParams {
-	if (baseAssetAmount.eq(ZERO) && quoteAssetAmount.eq(ZERO)) {
-		throw Error('baseAssetAmount or quoteAssetAmount must be zero');
-	}
-
-	return {
-		orderType: OrderType.MARKET,
-		userOrderId: 0,
-		marketIndex,
-		direction,
-		quoteAssetAmount,
-		baseAssetAmount,
-		price,
-		reduceOnly,
-		postOnly: false,
-		immediateOrCancel: false,
-		positionLimit: ZERO,
-		padding0: true,
-		padding1: ZERO,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition: OrderTriggerCondition.ABOVE,
-		triggerPrice: ZERO,
-		oraclePriceOffset: ZERO,
-	};
+	params: Omit<OptionalOrderParams, 'orderType'>
+): OptionalOrderParams {
+	return Object.assign({}, params, { orderType: OrderType.MARKET });
 }

package/src/slot/SlotSubscriber.js

@@ -0,0 +1,39 @@
+"use strict";
+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());
+    });
+};
+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();
+    }
+    subscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.currentSlot = yield this.connection.getSlot('confirmed');
+            this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
+                this.currentSlot = slotInfo.slot;
+                this.eventEmitter.emit('newSlot', slotInfo.slot);
+            });
+        });
+    }
+    getSlot() {
+        return this.currentSlot;
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.subscriptionId) {
+                yield this.connection.removeSlotChangeListener(this.subscriptionId);
+            }
+        });
+    }
+}
+exports.SlotSubscriber = SlotSubscriber;

package/src/slot/SlotSubscriber.ts

@@ -1,22 +1,32 @@
 import { Connection } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types/types/src';
 
 // eslint-disable-next-line @typescript-eslint/ban-types
 type SlotSubscriberConfig = {}; // for future customization
 
+export interface SlotSubscriberEvents {
+	newSlot: (newSlot: number) => void;
+}
+
 export class SlotSubscriber {
 	currentSlot: number;
 	subscriptionId: number;
+	eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
 
 	public constructor(
 		private connection: Connection,
 		_config?: SlotSubscriberConfig
-	) {}
+	) {
+		this.eventEmitter = new EventEmitter();
+	}
 
 	public async subscribe(): Promise<void> {
 		this.currentSlot = await this.connection.getSlot('confirmed');
 
 		this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
 			this.currentSlot = slotInfo.slot;
+			this.eventEmitter.emit('newSlot', slotInfo.slot);
 		});
 	}
 

package/src/token/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTokenAccount = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+function parseTokenAccount(data) {
+    const accountInfo = spl_token_1.AccountLayout.decode(data);
+    accountInfo.mint = new web3_js_1.PublicKey(accountInfo.mint);
+    accountInfo.owner = new web3_js_1.PublicKey(accountInfo.owner);
+    accountInfo.amount = spl_token_1.u64.fromBuffer(accountInfo.amount);
+    if (accountInfo.delegateOption === 0) {
+        accountInfo.delegate = null;
+        // eslint-disable-next-line new-cap
+        accountInfo.delegatedAmount = new spl_token_1.u64(0);
+    }
+    else {
+        accountInfo.delegate = new web3_js_1.PublicKey(accountInfo.delegate);
+        accountInfo.delegatedAmount = spl_token_1.u64.fromBuffer(accountInfo.delegatedAmount);
+    }
+    accountInfo.isInitialized = accountInfo.state !== 0;
+    accountInfo.isFrozen = accountInfo.state === 2;
+    if (accountInfo.isNativeOption === 1) {
+        accountInfo.rentExemptReserve = spl_token_1.u64.fromBuffer(accountInfo.isNative);
+        accountInfo.isNative = true;
+    }
+    else {
+        accountInfo.rentExemptReserve = null;
+        accountInfo.isNative = false;
+    }
+    if (accountInfo.closeAuthorityOption === 0) {
+        accountInfo.closeAuthority = null;
+    }
+    else {
+        accountInfo.closeAuthority = new web3_js_1.PublicKey(accountInfo.closeAuthority);
+    }
+    return accountInfo;
+}
+exports.parseTokenAccount = parseTokenAccount;