@drift-labs/sdk 0.1.36-master.5 → 0.2.0-master.0

package/lib/tx/retryTxSender.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { TxSender } from './types';
+import { TxSender, TxSigAndSlot } from './types';
 import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature, Connection } from '@solana/web3.js';
 import { AnchorProvider } from '@project-serum/anchor';
 declare type ResolveReference = {
@@ -11,7 +11,7 @@ export declare class RetryTxSender implements TxSender {
     retrySleep: number;
     additionalConnections: Connection[];
     constructor(provider: AnchorProvider, timeout?: number, retrySleep?: number, additionalConnections?: Connection[]);
-    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TransactionSignature>;
+    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TxSigAndSlot>;
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions): Promise<Transaction>;
     confirmTransaction(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
     getTimestamp(): number;

package/lib/tx/retryTxSender.js

@@ -1,13 +1,4 @@
 "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 };
 };
@@ -24,133 +15,127 @@ class RetryTxSender {
         this.retrySleep = retrySleep !== null && retrySleep !== void 0 ? retrySleep : DEFAULT_RETRY;
         this.additionalConnections = additionalConnections;
     }
-    send(tx, additionalSigners, opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (additionalSigners === undefined) {
-                additionalSigners = [];
-            }
-            if (opts === undefined) {
-                opts = this.provider.opts;
+    async send(tx, additionalSigners, opts) {
+        if (additionalSigners === undefined) {
+            additionalSigners = [];
+        }
+        if (opts === undefined) {
+            opts = this.provider.opts;
+        }
+        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 done = false;
+        const resolveReference = {
+            resolve: undefined,
+        };
+        const stopWaiting = () => {
+            done = true;
+            if (resolveReference.resolve) {
+                resolveReference.resolve();
             }
-            yield this.prepareTx(tx, additionalSigners, opts);
-            const rawTransaction = tx.serialize();
-            const startTime = this.getTimestamp();
-            const txid = yield this.provider.connection.sendRawTransaction(rawTransaction, opts);
-            this.sendToAdditionalConnections(rawTransaction, opts);
-            let done = false;
-            const resolveReference = {
-                resolve: undefined,
-            };
-            const stopWaiting = () => {
-                done = true;
-                if (resolveReference.resolve) {
-                    resolveReference.resolve();
+        };
+        (async () => {
+            while (!done && this.getTimestamp() - startTime < this.timeout) {
+                await this.sleep(resolveReference);
+                if (!done) {
+                    this.provider.connection
+                        .sendRawTransaction(rawTransaction, opts)
+                        .catch((e) => {
+                        console.error(e);
+                        stopWaiting();
+                    });
+                    this.sendToAdditionalConnections(rawTransaction, opts);
                 }
-            };
-            (() => __awaiter(this, void 0, void 0, function* () {
-                while (!done && this.getTimestamp() - startTime < this.timeout) {
-                    yield this.sleep(resolveReference);
-                    if (!done) {
-                        this.provider.connection
-                            .sendRawTransaction(rawTransaction, opts)
-                            .catch((e) => {
-                            console.error(e);
-                            stopWaiting();
-                        });
-                        this.sendToAdditionalConnections(rawTransaction, opts);
-                    }
-                }
-            }))();
-            try {
-                yield this.confirmTransaction(txid, opts.commitment);
-            }
-            catch (e) {
-                console.error(e);
-                throw e;
             }
-            finally {
-                stopWaiting();
-            }
-            return txid;
-        });
+        })();
+        let slot;
+        try {
+            const result = await this.confirmTransaction(txid, opts.commitment);
+            slot = result.context.slot;
+        }
+        catch (e) {
+            console.error(e);
+            throw e;
+        }
+        finally {
+            stopWaiting();
+        }
+        return { txSig: txid, slot };
     }
-    prepareTx(tx, additionalSigners, opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            tx.feePayer = this.provider.wallet.publicKey;
-            tx.recentBlockhash = (yield this.provider.connection.getRecentBlockhash(opts.preflightCommitment)).blockhash;
-            yield this.provider.wallet.signTransaction(tx);
-            additionalSigners
-                .filter((s) => s !== undefined)
-                .forEach((kp) => {
-                tx.partialSign(kp);
-            });
-            return tx;
+    async prepareTx(tx, additionalSigners, opts) {
+        tx.feePayer = this.provider.wallet.publicKey;
+        tx.recentBlockhash = (await this.provider.connection.getRecentBlockhash(opts.preflightCommitment)).blockhash;
+        await this.provider.wallet.signTransaction(tx);
+        additionalSigners
+            .filter((s) => s !== undefined)
+            .forEach((kp) => {
+            tx.partialSign(kp);
         });
+        return tx;
     }
-    confirmTransaction(signature, commitment) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let decodedSignature;
-            try {
-                decodedSignature = bs58_1.default.decode(signature);
-            }
-            catch (err) {
-                throw new Error('signature must be base58 encoded: ' + signature);
-            }
-            (0, assert_1.default)(decodedSignature.length === 64, 'signature has invalid length');
-            const start = Date.now();
-            const subscriptionCommitment = commitment || this.provider.opts.commitment;
-            const subscriptionIds = new Array();
-            const connections = [
-                this.provider.connection,
-                ...this.additionalConnections,
-            ];
-            let response = null;
-            const promises = connections.map((connection, i) => {
-                let subscriptionId;
-                const confirmPromise = new Promise((resolve, reject) => {
-                    try {
-                        subscriptionId = connection.onSignature(signature, (result, context) => {
-                            subscriptionIds[i] = undefined;
-                            response = {
-                                context,
-                                value: result,
-                            };
-                            resolve(null);
-                        }, subscriptionCommitment);
-                    }
-                    catch (err) {
-                        reject(err);
-                    }
-                });
-                subscriptionIds.push(subscriptionId);
-                return confirmPromise;
+    async confirmTransaction(signature, commitment) {
+        let decodedSignature;
+        try {
+            decodedSignature = bs58_1.default.decode(signature);
+        }
+        catch (err) {
+            throw new Error('signature must be base58 encoded: ' + signature);
+        }
+        (0, assert_1.default)(decodedSignature.length === 64, 'signature has invalid length');
+        const start = Date.now();
+        const subscriptionCommitment = commitment || this.provider.opts.commitment;
+        const subscriptionIds = new Array();
+        const connections = [
+            this.provider.connection,
+            ...this.additionalConnections,
+        ];
+        let response = null;
+        const promises = connections.map((connection, i) => {
+            let subscriptionId;
+            const confirmPromise = new Promise((resolve, reject) => {
+                try {
+                    subscriptionId = connection.onSignature(signature, (result, context) => {
+                        subscriptionIds[i] = undefined;
+                        response = {
+                            context,
+                            value: result,
+                        };
+                        resolve(null);
+                    }, subscriptionCommitment);
+                }
+                catch (err) {
+                    reject(err);
+                }
             });
-            try {
-                yield this.promiseTimeout(promises, this.timeout);
-            }
-            finally {
-                for (const [i, subscriptionId] of subscriptionIds.entries()) {
-                    if (subscriptionId) {
-                        connections[i].removeSignatureListener(subscriptionId);
-                    }
+            subscriptionIds.push(subscriptionId);
+            return confirmPromise;
+        });
+        try {
+            await this.promiseTimeout(promises, this.timeout);
+        }
+        finally {
+            for (const [i, subscriptionId] of subscriptionIds.entries()) {
+                if (subscriptionId) {
+                    connections[i].removeSignatureListener(subscriptionId);
                 }
             }
-            if (response === null) {
-                const duration = (Date.now() - start) / 1000;
-                throw new Error(`Transaction was not confirmed in ${duration.toFixed(2)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`);
-            }
-            return response;
-        });
+        }
+        if (response === null) {
+            const duration = (Date.now() - start) / 1000;
+            throw new Error(`Transaction was not confirmed in ${duration.toFixed(2)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`);
+        }
+        return response;
     }
     getTimestamp() {
         return new Date().getTime();
     }
-    sleep(reference) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve) => {
-                reference.resolve = resolve;
-                setTimeout(resolve, this.retrySleep);
-            });
+    async sleep(reference) {
+        return new Promise((resolve) => {
+            reference.resolve = resolve;
+            setTimeout(resolve, this.retrySleep);
         });
     }
     promiseTimeout(promises, timeoutMs) {

package/lib/tx/types.d.ts

@@ -1,6 +1,10 @@
 import { Provider } from '@project-serum/anchor';
 import { ConfirmOptions, Signer, Transaction, TransactionSignature } from '@solana/web3.js';
+export declare type TxSigAndSlot = {
+    txSig: TransactionSignature;
+    slot: number;
+};
 export interface TxSender {
     provider: Provider;
-    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TransactionSignature>;
+    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TxSigAndSlot>;
 }

package/lib/tx/utils.d.ts

@@ -1,2 +1,2 @@
 import { Transaction, TransactionInstruction } from '@solana/web3.js';
-export declare function wrapInTx(instruction: TransactionInstruction): Transaction;
+export declare function wrapInTx(instruction: TransactionInstruction, computeUnits?: number): Transaction;

package/lib/tx/utils.js

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

package/lib/types.d.ts

@@ -9,6 +9,14 @@ export declare class SwapDirection {
         remove: {};
     };
 }
+export declare class BankBalanceType {
+    static readonly DEPOSIT: {
+        deposit: {};
+    };
+    static readonly BORROW: {
+        borrow: {};
+    };
+}
 export declare class PositionDirection {
     static readonly LONG: {
         long: {};
@@ -24,6 +32,9 @@ export declare class OracleSource {
     static readonly SWITCHBOARD: {
         switchboard: {};
     };
+    static readonly QUOTE_ASSET: {
+        quoteAsset: {};
+    };
 }
 export declare class OrderType {
     static readonly LIMIT: {
@@ -87,55 +98,27 @@ export declare class OrderTriggerCondition {
     };
 }
 export declare function isVariant(object: unknown, type: string): boolean;
+export declare function isOneOfVariant(object: unknown, types: string[]): boolean;
 export declare enum TradeSide {
     None = 0,
     Buy = 1,
     Sell = 2
 }
 export declare type CandleResolution = '1' | '5' | '15' | '60' | '240' | 'D' | 'W' | 'M';
-export declare type TradeHistoryAccount = {
-    head: BN;
-    tradeRecords: TradeRecord[];
-};
-export declare type DepositHistoryAccount = {
-    head: BN;
-    depositRecords: DepositRecord[];
-};
-export declare type ExtendedCurveHistoryAccount = {
-    head: BN;
-    curveRecords: ExtendedCurveRecord[];
-};
-export declare type FundingRateHistoryAccount = {
-    head: BN;
-    fundingRateRecords: FundingRateRecord[];
-};
-export declare type FundingPaymentHistoryAccount = {
-    head: BN;
-    fundingPaymentRecords: FundingPaymentRecord[];
-};
-export declare type LiquidationHistoryAccount = {
-    head: BN;
-    liquidationRecords: LiquidationRecord[];
-};
-export declare type OrderHistoryAccount = {
-    head: BN;
-    lastOrderId: BN;
-    orderRecords: OrderRecord[];
-};
 export declare type DepositRecord = {
     ts: BN;
-    recordId: BN;
     userAuthority: PublicKey;
     user: PublicKey;
     direction: {
         deposit?: any;
         withdraw?: any;
     };
-    collateralBefore: BN;
-    cumulativeDepositsBefore: BN;
+    bankIndex: BN;
     amount: BN;
+    from?: PublicKey;
+    to?: PublicKey;
 };
-export declare type ExtendedCurveRecord = {
+export declare type CurveRecord = {
     ts: BN;
     recordId: BN;
     marketIndex: BN;
@@ -154,27 +137,6 @@ export declare type ExtendedCurveRecord = {
     oraclePrice: BN;
     tradeId: BN;
 };
-export declare type TradeRecord = {
-    ts: BN;
-    recordId: BN;
-    userAuthority: PublicKey;
-    user: PublicKey;
-    direction: {
-        long?: any;
-        short?: any;
-    };
-    baseAssetAmount: BN;
-    quoteAssetAmount: BN;
-    markPriceBefore: BN;
-    markPriceAfter: BN;
-    fee: BN;
-    quoteAssetAmountSurplus: BN;
-    refereeDiscount: BN;
-    tokenDiscount: BN;
-    marketIndex: BN;
-    liquidation: boolean;
-    oraclePrice: BN;
-};
 export declare type FundingRateRecord = {
     ts: BN;
     recordId: BN;
@@ -187,7 +149,6 @@ export declare type FundingRateRecord = {
 };
 export declare type FundingPaymentRecord = {
     ts: BN;
-    recordId: BN;
     userAuthority: PublicKey;
     user: PublicKey;
     marketIndex: BN;
@@ -217,41 +178,33 @@ export declare type LiquidationRecord = {
 };
 export declare type OrderRecord = {
     ts: BN;
-    recordId: BN;
-    order: Order;
-    user: PublicKey;
-    authority: PublicKey;
+    taker: PublicKey;
+    maker: PublicKey;
+    takerOrder: Order;
+    makerOrder: Order;
     action: OrderAction;
     filler: PublicKey;
+    fillRecordId: BN;
+    marketIndex: BN;
     baseAssetAmountFilled: BN;
     quoteAssetAmountFilled: BN;
-    fee: BN;
+    makerRebate: BN;
+    takerFee: BN;
     fillerReward: BN;
-    tradeRecordId: BN;
     quoteAssetAmountSurplus: BN;
+    oraclePrice: BN;
 };
 export declare type StateAccount = {
     admin: PublicKey;
     fundingPaused: boolean;
     exchangePaused: boolean;
     adminControlsPrices: boolean;
-    collateralMint: PublicKey;
-    collateralVault: PublicKey;
-    collateralVaultAuthority: PublicKey;
-    collateralVaultNonce: number;
     insuranceVault: PublicKey;
     insuranceVaultAuthority: PublicKey;
     insuranceVaultNonce: number;
     marginRatioInitial: BN;
     marginRatioMaintenance: BN;
     marginRatioPartial: BN;
-    markets: PublicKey;
-    curveHistory: PublicKey;
-    depositHistory: PublicKey;
-    fundingRateHistory: PublicKey;
-    fundingPaymentHistory: PublicKey;
-    tradeHistory: PublicKey;
-    liquidationHistory: PublicKey;
     partialLiquidationClosePercentageNumerator: BN;
     partialLiquidationClosePercentageDenominator: BN;
     partialLiquidationPenaltyPercentageNumerator: BN;
@@ -267,27 +220,49 @@ export declare type StateAccount = {
     discountMint: PublicKey;
     oracleGuardRails: OracleGuardRails;
     maxDeposit: BN;
-    orderState: PublicKey;
-    extendedCurveHistory: PublicKey;
-};
-export declare type OrderStateAccount = {
-    orderHistory: PublicKey;
-    orderFillerRewardStructure: OrderFillerRewardStructure;
+    numberOfMarkets: BN;
+    numberOfBanks: BN;
     minOrderQuoteAssetAmount: BN;
 };
-export declare type MarketsAccount = {
-    markets: Market[];
-};
-export declare type Market = {
+export declare type MarketAccount = {
+    initialized: boolean;
+    marketIndex: BN;
+    pubkey: PublicKey;
     amm: AMM;
     baseAssetAmount: BN;
     baseAssetAmountLong: BN;
     baseAssetAmountShort: BN;
-    initialized: boolean;
     openInterest: BN;
     marginRatioInitial: number;
     marginRatioMaintenance: number;
     marginRatioPartial: number;
+    nextFillRecordId: BN;
+    pnlPool: PoolBalance;
+};
+export declare type BankAccount = {
+    bankIndex: BN;
+    pubkey: PublicKey;
+    mint: PublicKey;
+    vault: PublicKey;
+    vaultAuthority: PublicKey;
+    vaultAuthorityNonce: number;
+    decimals: number;
+    optimalUtilization: BN;
+    optimalBorrowRate: BN;
+    maxBorrowRate: BN;
+    cumulativeDepositInterest: BN;
+    cumulativeBorrowInterest: BN;
+    depositBalance: BN;
+    borrowBalance: BN;
+    lastUpdated: BN;
+    oracle: PublicKey;
+    initialAssetWeight: BN;
+    maintenanceAssetWeight: BN;
+    initialLiabilityWeight: BN;
+    maintenanceLiabilityWeight: BN;
+};
+export declare type PoolBalance = {
+    balance: BN;
 };
 export declare type AMM = {
     baseAssetReserve: BN;
@@ -312,45 +287,66 @@ export declare type AMM = {
     totalFeeWithdrawn: BN;
     totalFee: BN;
     minimumQuoteAssetTradeSize: BN;
-    minimumBaseAssetTradeSize: BN;
+    baseAssetAmountStepSize: BN;
     lastOraclePrice: BN;
     baseSpread: number;
+    curveUpdateIntensity: number;
+    netBaseAssetAmount: BN;
+    quoteAssetAmountLong: BN;
+    quoteAssetAmountShort: BN;
+    terminalQuoteAssetReserve: BN;
+    feePool: PoolBalance;
+    totalExchangeFee: BN;
+    totalMmFee: BN;
+    netRevenueSinceLastFunding: BN;
+    lastUpdateSlot: BN;
+    lastBidPriceTwap: BN;
+    lastAskPriceTwap: BN;
+    longSpread: BN;
+    shortSpread: BN;
 };
 export declare type UserPosition = {
     baseAssetAmount: BN;
     lastCumulativeFundingRate: BN;
     marketIndex: BN;
     quoteAssetAmount: BN;
+    quoteEntryAmount: BN;
     openOrders: BN;
-};
-export declare type UserPositionsAccount = {
-    positions: UserPosition[];
-    user: PublicKey;
+    unsettledPnl: BN;
+    openBids: BN;
+    openAsks: BN;
 };
 export declare type UserAccount = {
     authority: PublicKey;
+    name: number[];
+    userId: number;
+    bankBalances: UserBankBalance[];
     collateral: BN;
     cumulativeDeposits: BN;
-    positions: PublicKey;
-    totalFeePaid: BN;
-    totalFeeRebate: BN;
-    totalTokenDiscount: BN;
-    totalReferralReward: BN;
-    totalRefereeDiscount: BN;
-};
-export declare type UserOrdersAccount = {
+    fees: {
+        totalFeePaid: BN;
+        totalFeeRebate: BN;
+        totalTokenDiscount: BN;
+        totalReferralReward: BN;
+        totalRefereeDiscount: BN;
+    };
+    positions: UserPosition[];
     orders: Order[];
-    user: PublicKey;
+};
+export declare type UserBankBalance = {
+    bankIndex: BN;
+    balanceType: BankBalanceType;
+    balance: BN;
 };
 export declare type Order = {
     status: OrderStatus;
     orderType: OrderType;
     ts: BN;
+    slot: BN;
     orderId: BN;
     userOrderId: number;
     marketIndex: BN;
     price: BN;
-    userBaseAssetAmount: BN;
     baseAssetAmount: BN;
     baseAssetAmountFilled: BN;
     quoteAssetAmount: BN;
@@ -361,10 +357,14 @@ export declare type Order = {
     triggerPrice: BN;
     triggerCondition: OrderTriggerCondition;
     discountTier: OrderDiscountTier;
+    existingPositionDirection: PositionDirection;
     referrer: PublicKey;
     postOnly: boolean;
     immediateOrCancel: boolean;
     oraclePriceOffset: BN;
+    auctionDuration: number;
+    auctionStartPrice: BN;
+    auctionEndPrice: BN;
 };
 export declare type OrderParams = {
     orderType: OrderType;
@@ -388,6 +388,10 @@ export declare type OrderParams = {
         referrer: boolean;
     };
 };
+export declare type MakerInfo = {
+    maker: PublicKey;
+    order: Order;
+};
 export interface IWallet {
     signTransaction(tx: Transaction): Promise<Transaction>;
     signAllTransactions(txs: Transaction[]): Promise<Transaction[]>;
@@ -424,6 +428,9 @@ export declare type FeeStructure = {
         refereeDiscountNumerator: BN;
         refereeDiscountDenominator: BN;
     };
+    makerRebateNumerator: BN;
+    makerRebateDenominator: BN;
+    fillerRewardStructure: OrderFillerRewardStructure;
 };
 export declare type OracleGuardRails = {
     priceDivergence: {