@drift-labs/sdk 0.2.0-temp.1 → 2.0.0

package/lib/math/bankBalance.d.ts

@@ -1,9 +0,0 @@
-/// <reference types="bn.js" />
-import { BankAccount, BankBalanceType } from '../types';
-import { BN } from '@project-serum/anchor';
-export declare function getBalance(tokenAmount: BN, bank: BankAccount, balanceType: BankBalanceType): BN;
-export declare function getTokenAmount(balanceAmount: BN, bank: BankAccount, balanceType: BankBalanceType): BN;
-export declare function calculateInterestAccumulated(bank: BankAccount, now: BN): {
-    borrowInterest: BN;
-    depositInterest: BN;
-};

package/lib/math/bankBalance.js

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateInterestAccumulated = exports.getTokenAmount = exports.getBalance = void 0;
-const types_1 = require("../types");
-const anchor_1 = require("@project-serum/anchor");
-const numericConstants_1 = require("../constants/numericConstants");
-function getBalance(tokenAmount, bank, balanceType) {
-    const precisionIncrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - bank.decimals));
-    const cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
-        ? bank.cumulativeDepositInterest
-        : bank.cumulativeBorrowInterest;
-    let balance = tokenAmount.mul(precisionIncrease).div(cumulativeInterest);
-    if (!balance.eq(numericConstants_1.ZERO) && (0, types_1.isVariant)(balanceType, 'borrow')) {
-        balance = balance.add(numericConstants_1.ONE);
-    }
-    return balance;
-}
-exports.getBalance = getBalance;
-function getTokenAmount(balanceAmount, bank, balanceType) {
-    const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - bank.decimals));
-    const cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
-        ? bank.cumulativeDepositInterest
-        : bank.cumulativeBorrowInterest;
-    return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
-}
-exports.getTokenAmount = getTokenAmount;
-function calculateInterestAccumulated(bank, now) {
-    const token_deposit_amount = getTokenAmount(bank.depositBalance, bank, types_1.BankBalanceType.DEPOSIT);
-    const token_borrow_amount = getTokenAmount(bank.borrowBalance, bank, types_1.BankBalanceType.BORROW);
-    let utilization;
-    if (token_borrow_amount.eq(numericConstants_1.ZERO) && token_deposit_amount.eq(numericConstants_1.ZERO)) {
-        utilization = numericConstants_1.ZERO;
-    }
-    else if (token_deposit_amount.eq(numericConstants_1.ZERO)) {
-        utilization = numericConstants_1.BANK_UTILIZATION_PRECISION;
-    }
-    else {
-        utilization = token_borrow_amount
-            .mul(numericConstants_1.BANK_UTILIZATION_PRECISION)
-            .div(token_deposit_amount);
-    }
-    let interest_rate;
-    if (utilization.gt(bank.optimalUtilization)) {
-        const surplusUtilization = utilization.sub(bank.optimalUtilization);
-        const borrowRateSlope = bank.maxBorrowRate
-            .sub(bank.optimalBorrowRate)
-            .mul(numericConstants_1.BANK_UTILIZATION_PRECISION)
-            .div(numericConstants_1.BANK_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
-        interest_rate = bank.optimalBorrowRate.add(surplusUtilization.mul(borrowRateSlope).div(numericConstants_1.BANK_UTILIZATION_PRECISION));
-    }
-    else {
-        const borrowRateSlope = bank.optimalBorrowRate
-            .mul(numericConstants_1.BANK_UTILIZATION_PRECISION)
-            .div(numericConstants_1.BANK_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
-        interest_rate = utilization
-            .mul(borrowRateSlope)
-            .div(numericConstants_1.BANK_UTILIZATION_PRECISION);
-    }
-    const timeSinceLastUpdate = now.sub(bank.lastUpdated);
-    const modifiedBorrowRate = interest_rate.mul(timeSinceLastUpdate);
-    const modifiedDepositRate = modifiedBorrowRate
-        .mul(utilization)
-        .div(numericConstants_1.BANK_UTILIZATION_PRECISION);
-    const borrowInterest = bank.cumulativeBorrowInterest
-        .mul(modifiedBorrowRate)
-        .div(numericConstants_1.ONE_YEAR)
-        .div(numericConstants_1.BANK_INTEREST_PRECISION)
-        .add(numericConstants_1.ONE);
-    const depositInterest = bank.cumulativeDepositInterest
-        .mul(modifiedDepositRate)
-        .div(numericConstants_1.ONE_YEAR)
-        .div(numericConstants_1.BANK_INTEREST_PRECISION);
-    return { borrowInterest, depositInterest };
-}
-exports.calculateInterestAccumulated = calculateInterestAccumulated;

package/lib/math/state.d.ts

@@ -1,8 +0,0 @@
-import { StateAccount } from '../types';
-/**
- * Get the clearing house percent fee charged on notional of taking trades
- *
- * @param state
- * @returns Precision : basis points (bps)
- */
-export declare function getExchangeFee(state: StateAccount): number;

package/lib/math/state.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getExchangeFee = void 0;
-/**
- * Get the clearing house percent fee charged on notional of taking trades
- *
- * @param state
- * @returns Precision : basis points (bps)
- */
-function getExchangeFee(state) {
-    const exchangeFee = state.feeStructure.feeNumerator.toNumber() /
-        state.feeStructure.feeDenominator.toNumber();
-    return exchangeFee;
-}
-exports.getExchangeFee = getExchangeFee;

package/lib/orders.d.ts

@@ -1,8 +0,0 @@
-/// <reference types="bn.js" />
-import { MarketAccount, Order, UserAccount, UserPosition } from './types';
-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;

package/lib/orders.js

@@ -1,134 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = 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);
-    }
-    else if ((0, types_1.isVariant)(order.orderType, 'triggerLimit')) {
-        return calculateAmountToTradeForTriggerLimit(market, order);
-    }
-    else if ((0, types_1.isVariant)(order.orderType, 'market')) {
-        return numericConstants_1.ZERO;
-    }
-    else {
-        return calculateAmountToTradeForTriggerMarket(market, order);
-    }
-}
-exports.calculateBaseAssetAmountMarketCanExecute = calculateBaseAssetAmountMarketCanExecute;
-function calculateAmountToTradeForLimit(market, order, oraclePriceData) {
-    let limitPrice = order.price;
-    if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
-        if (!oraclePriceData) {
-            throw Error('Cant calculate limit price for oracle offset oracle without OraclePriceData');
-        }
-        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-    }
-    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);
-    if (!sameDirection) {
-        return numericConstants_1.ZERO;
-    }
-    return baseAssetAmount.gt(order.baseAssetAmount)
-        ? order.baseAssetAmount
-        : baseAssetAmount;
-}
-exports.calculateAmountToTradeForLimit = calculateAmountToTradeForLimit;
-function calculateAmountToTradeForTriggerLimit(market, order) {
-    if (!order.triggered) {
-        return numericConstants_1.ZERO;
-    }
-    return calculateAmountToTradeForLimit(market, order);
-}
-exports.calculateAmountToTradeForTriggerLimit = calculateAmountToTradeForTriggerLimit;
-function isSameDirection(firstDirection, secondDirection) {
-    return (((0, types_1.isVariant)(firstDirection, 'long') && (0, types_1.isVariant)(secondDirection, 'long')) ||
-        ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
-}
-function calculateAmountToTradeForTriggerMarket(market, order) {
-    if (!order.triggered) {
-        return numericConstants_1.ZERO;
-    }
-    return order.baseAssetAmount;
-}

package/src/accounts/bulkAccountLoader.js

@@ -1,197 +0,0 @@
-"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.BulkAccountLoader = void 0;
-const uuid_1 = require("uuid");
-const promiseTimeout_1 = require("../util/promiseTimeout");
-const GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE = 99;
-const oneMinute = 60 * 1000;
-class BulkAccountLoader {
-    constructor(connection, commitment, pollingFrequency) {
-        this.accountsToLoad = new Map();
-        this.bufferAndSlotMap = new Map();
-        this.errorCallbacks = new Map();
-        this.lastTimeLoadingPromiseCleared = Date.now();
-        this.mostRecentSlot = 0;
-        this.connection = connection;
-        this.commitment = commitment;
-        this.pollingFrequency = pollingFrequency;
-    }
-    addAccount(publicKey, callback) {
-        const existingSize = this.accountsToLoad.size;
-        const callbackId = uuid_1.v4();
-        const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
-        if (existingAccountToLoad) {
-            existingAccountToLoad.callbacks.set(callbackId, callback);
-        }
-        else {
-            const callbacks = new Map();
-            callbacks.set(callbackId, callback);
-            const newAccountToLoad = {
-                publicKey,
-                callbacks,
-            };
-            this.accountsToLoad.set(publicKey.toString(), newAccountToLoad);
-        }
-        if (existingSize === 0) {
-            this.startPolling();
-        }
-        // if a new account needs to be polled, remove the cached loadPromise in case client calls load immediately after
-        this.loadPromise = undefined;
-        return callbackId;
-    }
-    removeAccount(publicKey, callbackId) {
-        const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
-        if (existingAccountToLoad) {
-            existingAccountToLoad.callbacks.delete(callbackId);
-            if (existingAccountToLoad.callbacks.size === 0) {
-                this.accountsToLoad.delete(existingAccountToLoad.publicKey.toString());
-            }
-        }
-        if (this.accountsToLoad.size === 0) {
-            this.stopPolling();
-        }
-    }
-    addErrorCallbacks(callback) {
-        const callbackId = uuid_1.v4();
-        this.errorCallbacks.set(callbackId, callback);
-        return callbackId;
-    }
-    removeErrorCallbacks(callbackId) {
-        this.errorCallbacks.delete(callbackId);
-    }
-    chunks(array, size) {
-        return new Array(Math.ceil(array.length / size))
-            .fill(null)
-            .map((_, index) => index * size)
-            .map((begin) => array.slice(begin, begin + size));
-    }
-    load() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.loadPromise) {
-                const now = Date.now();
-                if (now - this.lastTimeLoadingPromiseCleared > oneMinute) {
-                    this.loadPromise = undefined;
-                }
-                else {
-                    return this.loadPromise;
-                }
-            }
-            this.loadPromise = new Promise((resolver) => {
-                this.loadPromiseResolver = resolver;
-            });
-            this.lastTimeLoadingPromiseCleared = Date.now();
-            try {
-                const chunks = this.chunks(Array.from(this.accountsToLoad.values()), GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE);
-                yield Promise.all(chunks.map((chunk) => {
-                    return this.loadChunk(chunk);
-                }));
-            }
-            catch (e) {
-                console.error(`Error in bulkAccountLoader.load()`);
-                console.error(e);
-                for (const [_, callback] of this.errorCallbacks) {
-                    callback(e);
-                }
-            }
-            finally {
-                this.loadPromiseResolver();
-                this.loadPromise = undefined;
-            }
-        });
-    }
-    loadChunk(accountsToLoad) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (accountsToLoad.length === 0) {
-                return;
-            }
-            const args = [
-                accountsToLoad.map((accountToLoad) => {
-                    return accountToLoad.publicKey.toBase58();
-                }),
-                { commitment: this.commitment },
-            ];
-            const rpcResponse = yield promiseTimeout_1.promiseTimeout(
-            // @ts-ignore
-            this.connection._rpcRequest('getMultipleAccounts', args), 10 * 1000 // 30 second timeout
-            );
-            if (rpcResponse === null) {
-                this.log('request to rpc timed out');
-                return;
-            }
-            const newSlot = rpcResponse.result.context.slot;
-            if (newSlot > this.mostRecentSlot) {
-                this.mostRecentSlot = newSlot;
-            }
-            for (const i in accountsToLoad) {
-                const accountToLoad = accountsToLoad[i];
-                const key = accountToLoad.publicKey.toString();
-                const oldRPCResponse = this.bufferAndSlotMap.get(key);
-                let newBuffer = undefined;
-                if (rpcResponse.result.value[i]) {
-                    const raw = rpcResponse.result.value[i].data[0];
-                    const dataType = rpcResponse.result.value[i].data[1];
-                    newBuffer = Buffer.from(raw, dataType);
-                }
-                if (!oldRPCResponse) {
-                    this.bufferAndSlotMap.set(key, {
-                        slot: newSlot,
-                        buffer: newBuffer,
-                    });
-                    this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
-                    continue;
-                }
-                if (newSlot <= oldRPCResponse.slot) {
-                    continue;
-                }
-                const oldBuffer = oldRPCResponse.buffer;
-                if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
-                    this.bufferAndSlotMap.set(key, {
-                        slot: newSlot,
-                        buffer: newBuffer,
-                    });
-                    this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
-                }
-            }
-        });
-    }
-    handleAccountCallbacks(accountToLoad, buffer, slot) {
-        for (const [_, callback] of accountToLoad.callbacks) {
-            callback(buffer, slot);
-        }
-    }
-    getBufferAndSlot(publicKey) {
-        return this.bufferAndSlotMap.get(publicKey.toString());
-    }
-    startPolling() {
-        if (this.intervalId) {
-            return;
-        }
-        this.intervalId = setInterval(this.load.bind(this), this.pollingFrequency);
-    }
-    stopPolling() {
-        if (this.intervalId) {
-            clearInterval(this.intervalId);
-            this.intervalId = undefined;
-        }
-    }
-    log(msg) {
-        console.log(msg);
-    }
-    updatePollingFrequency(pollingFrequency) {
-        this.stopPolling();
-        this.pollingFrequency = pollingFrequency;
-        if (this.accountsToLoad.size > 0) {
-            this.startPolling();
-        }
-    }
-}
-exports.BulkAccountLoader = BulkAccountLoader;

package/src/accounts/bulkUserSubscription.js

@@ -1,33 +0,0 @@
-"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.bulkPollingUserSubscribe = void 0;
-/**
- * @param users
- * @param accountLoader
- */
-function bulkPollingUserSubscribe(users, accountLoader) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (users.length === 0) {
-            yield accountLoader.load();
-            return;
-        }
-        yield Promise.all(users.map((user) => {
-            // Pull the keys from the authority map so we can skip fetching them in addToAccountLoader
-            return user.accountSubscriber.addToAccountLoader();
-        }));
-        yield accountLoader.load();
-        yield Promise.all(users.map((user) => __awaiter(this, void 0, void 0, function* () {
-            return user.subscribe();
-        })));
-    });
-}
-exports.bulkPollingUserSubscribe = bulkPollingUserSubscribe;