@drift-labs/sdk 2.82.0-beta.2 → 2.82.0-beta.20

package/lib/accounts/webSocketUserStatsAccountSubsriber.js

@@ -5,19 +5,19 @@ const types_1 = require("./types");
 const events_1 = require("events");
 const webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
 class WebSocketUserStatsAccountSubscriber {
-    constructor(program, userStatsAccountPublicKey, reconnectTimeoutMs, commitment) {
+    constructor(program, userStatsAccountPublicKey, resubOpts, commitment) {
         this.isSubscribed = false;
         this.program = program;
         this.userStatsAccountPublicKey = userStatsAccountPublicKey;
         this.eventEmitter = new events_1.EventEmitter();
-        this.reconnectTimeoutMs = reconnectTimeoutMs;
+        this.resubOpts = resubOpts;
         this.commitment = commitment;
     }
     async subscribe(userStatsAccount) {
         if (this.isSubscribed) {
             return true;
         }
-        this.userStatsAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('userStats', this.program, this.userStatsAccountPublicKey, undefined, this.reconnectTimeoutMs, this.commitment);
+        this.userStatsAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('userStats', this.program, this.userStatsAccountPublicKey, undefined, this.resubOpts, this.commitment);
         if (userStatsAccount) {
             this.userStatsAccountSubscriber.setData(userStatsAccount);
         }

package/lib/auctionSubscriber/auctionSubscriber.d.ts

@@ -5,10 +5,10 @@ import { EventEmitter } from 'events';
 export declare class AuctionSubscriber {
     private driftClient;
     private opts;
-    private resubTimeoutMs?;
+    private resubOpts?;
     eventEmitter: StrictEventEmitter<EventEmitter, AuctionSubscriberEvents>;
     private subscriber;
-    constructor({ driftClient, opts, resubTimeoutMs }: AuctionSubscriberConfig);
+    constructor({ driftClient, opts, resubTimeoutMs, logResubMessages, }: AuctionSubscriberConfig);
     subscribe(): Promise<void>;
     unsubscribe(): Promise<void>;
 }

package/lib/auctionSubscriber/auctionSubscriber.js

@@ -5,18 +5,18 @@ const memcmp_1 = require("../memcmp");
 const events_1 = require("events");
 const webSocketProgramAccountSubscriber_1 = require("../accounts/webSocketProgramAccountSubscriber");
 class AuctionSubscriber {
-    constructor({ driftClient, opts, resubTimeoutMs }) {
+    constructor({ driftClient, opts, resubTimeoutMs, logResubMessages, }) {
         this.driftClient = driftClient;
         this.opts = opts || this.driftClient.opts;
         this.eventEmitter = new events_1.EventEmitter();
-        this.resubTimeoutMs = resubTimeoutMs;
+        this.resubOpts = { resubTimeoutMs, logResubMessages };
     }
     async subscribe() {
         if (!this.subscriber) {
             this.subscriber = new webSocketProgramAccountSubscriber_1.WebSocketProgramAccountSubscriber('AuctionSubscriber', 'User', this.driftClient.program, this.driftClient.program.account.user.coder.accounts.decode.bind(this.driftClient.program.account.user.coder.accounts), {
                 filters: [(0, memcmp_1.getUserFilter)(), (0, memcmp_1.getUserWithAuctionFilter)()],
                 commitment: this.opts.commitment,
-            }, this.resubTimeoutMs);
+            }, this.resubOpts);
         }
         await this.subscriber.subscribe((accountId, data, context) => {
             this.eventEmitter.emit('onAccountUpdate', data, accountId, context.slot);

package/lib/auctionSubscriber/types.d.ts

@@ -5,6 +5,7 @@ export type AuctionSubscriberConfig = {
     driftClient: DriftClient;
     opts?: ConfirmOptions;
     resubTimeoutMs?: number;
+    logResubMessages?: boolean;
 };
 export interface AuctionSubscriberEvents {
     onAccountUpdate: (account: UserAccount, pubkey: PublicKey, slot: number) => void;

package/lib/clock/clockSubscriber.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { Commitment, Connection } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types/types/src';
+type ClockSubscriberConfig = {
+    commitment: Commitment;
+    resubTimeoutMs?: number;
+};
+export interface ClockSubscriberEvent {
+    clockUpdate: (ts: number) => void;
+}
+export declare class ClockSubscriber {
+    private connection;
+    private latestSlot;
+    currentTs: number;
+    private subscriptionId;
+    commitment: Commitment;
+    eventEmitter: StrictEventEmitter<EventEmitter, ClockSubscriberEvent>;
+    private timeoutId?;
+    private resubTimeoutMs?;
+    private isUnsubscribing;
+    private receivingData;
+    constructor(connection: Connection, config?: ClockSubscriberConfig);
+    subscribe(): Promise<void>;
+    private setTimeout;
+    getUnixTs(): number;
+    unsubscribe(onResub?: boolean): Promise<void>;
+}
+export {};

package/lib/clock/clockSubscriber.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClockSubscriber = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const events_1 = require("events");
+const __1 = require("..");
+class ClockSubscriber {
+    constructor(connection, config) {
+        this.connection = connection;
+        this.isUnsubscribing = false;
+        this.receivingData = false;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.resubTimeoutMs = config === null || config === void 0 ? void 0 : config.resubTimeoutMs;
+        this.commitment = (config === null || config === void 0 ? void 0 : config.commitment) || 'confirmed';
+        if (this.resubTimeoutMs < 1000) {
+            console.log('resubTimeoutMs should be at least 1000ms to avoid spamming resub');
+        }
+    }
+    async subscribe() {
+        if (this.subscriptionId != null) {
+            return;
+        }
+        this.subscriptionId = this.connection.onAccountChange(web3_js_1.SYSVAR_CLOCK_PUBKEY, (acctInfo, context) => {
+            if (!this.latestSlot || this.latestSlot < context.slot) {
+                if (this.resubTimeoutMs && !this.isUnsubscribing) {
+                    this.receivingData = true;
+                    clearTimeout(this.timeoutId);
+                    this.setTimeout();
+                }
+                this.latestSlot = context.slot;
+                this.currentTs = new __1.BN(acctInfo.data.subarray(32, 39), undefined, 'le').toNumber();
+                this.eventEmitter.emit('clockUpdate', this.currentTs);
+            }
+        }, this.commitment);
+        if (this.resubTimeoutMs) {
+            this.receivingData = true;
+            this.setTimeout();
+        }
+    }
+    setTimeout() {
+        this.timeoutId = setTimeout(async () => {
+            if (this.isUnsubscribing) {
+                // If we are in the process of unsubscribing, do not attempt to resubscribe
+                return;
+            }
+            if (this.receivingData) {
+                console.log(`No new slot in ${this.resubTimeoutMs}ms, slot subscriber resubscribing`);
+                await this.unsubscribe(true);
+                this.receivingData = false;
+                await this.subscribe();
+            }
+        }, this.resubTimeoutMs);
+    }
+    getUnixTs() {
+        return this.currentTs;
+    }
+    async unsubscribe(onResub = false) {
+        if (!onResub) {
+            this.resubTimeoutMs = undefined;
+        }
+        this.isUnsubscribing = true;
+        clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        if (this.subscriptionId != null) {
+            await this.connection.removeAccountChangeListener(this.subscriptionId);
+            this.subscriptionId = undefined;
+            this.isUnsubscribing = false;
+        }
+        else {
+            this.isUnsubscribing = false;
+        }
+    }
+}
+exports.ClockSubscriber = ClockSubscriber;

package/lib/constants/perpMarkets.js

@@ -542,9 +542,9 @@ exports.MainnetPerpMarkets = [
         symbol: 'KMNO-PERP',
         baseAssetSymbol: 'KMNO',
         marketIndex: 28,
-        oracle: new web3_js_1.PublicKey('sDAQaZQJQ4RXAxH3x526mbEXyQZT15ktkL84d7hmk7M'),
+        oracle: new web3_js_1.PublicKey('6ynsvjkE2UoiRScbDx7ZxbBsyn7wyvg5P1vENvhtkG1C'),
         launchTs: 1712240681000,
-        oracleSource: __1.OracleSource.Prelaunch,
+        oracleSource: __1.OracleSource.SWITCHBOARD,
     },
     {
         fullName: 'Tensor',

package/lib/constants/spotMarkets.js

@@ -197,6 +197,17 @@ exports.MainnetSpotMarkets = [
         phoenixMarket: new web3_js_1.PublicKey('AbJCZ9TAJiby5AY3cHcXS2gUdENC6mtsm6m7XpC2ZMvE'),
         launchTs: 1712593532000,
     },
+    {
+        symbol: 'DRIFT',
+        marketIndex: 15,
+        oracle: new web3_js_1.PublicKey('PeNpQeGEm9UEFJ6MBCMauY4WW4h3YxoESPWbsqVKucE'),
+        oracleSource: __1.OracleSource.SWITCHBOARD,
+        mint: new web3_js_1.PublicKey('DriFtupJYLTosbwoN8koMbEYSx54aFAVLddWsbksjwg7'),
+        precision: new __1.BN(10).pow(numericConstants_1.SIX),
+        precisionExp: numericConstants_1.SIX,
+        phoenixMarket: new web3_js_1.PublicKey('8BV6rrWsUabnTDA3dE6A69oUDJAj3hMhtBHTJyXB7czp'),
+        launchTs: 1715860800000,
+    },
 ];
 exports.SpotMarkets = {
     devnet: exports.DevnetSpotMarkets,

package/lib/dlob/DLOB.js

@@ -528,7 +528,7 @@ class DLOB {
         ];
         for (const bidGenerator of bidGenerators) {
             for (const bid of bidGenerator) {
-                if ((0, __1.isOrderExpired)(bid.order, ts, true)) {
+                if ((0, __1.isOrderExpired)(bid.order, ts, true, 25)) {
                     nodesToFill.push({
                         node: bid,
                         makerNodes: [],
@@ -538,7 +538,7 @@ class DLOB {
         }
         for (const askGenerator of askGenerators) {
             for (const ask of askGenerator) {
-                if ((0, __1.isOrderExpired)(ask.order, ts, true)) {
+                if ((0, __1.isOrderExpired)(ask.order, ts, true, 25)) {
                     nodesToFill.push({
                         node: ask,
                         makerNodes: [],

package/lib/dlob/orderBookLevels.js

@@ -246,6 +246,7 @@ function groupL2Levels(levels, grouping, direction, depth) {
                     currentLevel.sources[source] = size;
                 }
             }
+            groupedLevels[groupedLevels.length - 1] = currentLevel;
         }
         else {
             const groupedLevel = {

package/lib/driftClient.d.ts

@@ -3,11 +3,12 @@
 import { AnchorProvider, BN, Program, ProgramAccount } from '@coral-xyz/anchor';
 import { StateAccount, IWallet, PositionDirection, UserAccount, PerpMarketAccount, OrderParams, Order, SpotMarketAccount, SpotPosition, MakerInfo, TakerInfo, OptionalOrderParams, ReferrerInfo, MarketType, TxParams, SerumV3FulfillmentConfigAccount, ReferrerNameAccount, OrderTriggerCondition, PerpMarketExtendedInfo, UserStatsAccount, PhoenixV1FulfillmentConfigAccount, ModifyOrderPolicy, SwapReduceOnly } from './types';
 import * as anchor from '@coral-xyz/anchor';
-import { Connection, PublicKey, TransactionSignature, ConfirmOptions, Transaction, TransactionInstruction, AccountMeta, Signer, AddressLookupTableAccount, TransactionVersion, VersionedTransaction } from '@solana/web3.js';
+import { Connection, PublicKey, TransactionSignature, ConfirmOptions, Transaction, TransactionInstruction, AccountMeta, Signer, AddressLookupTableAccount, TransactionVersion, VersionedTransaction, BlockhashWithExpiryBlockHeight } from '@solana/web3.js';
 import { TokenFaucet } from './tokenFaucet';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
-import { DriftClientAccountSubscriber, DriftClientAccountEvents, DataAndSlot, DriftClientMetricsEvents } from './accounts/types';
+import { DriftClientAccountSubscriber, DriftClientAccountEvents, DataAndSlot } from './accounts/types';
+import { DriftClientMetricsEvents } from './types';
 import { TxSender, TxSigAndSlot } from './tx/types';
 import { OraclePriceData } from './oracles/types';
 import { DriftClientConfig } from './driftClientConfig';
@@ -16,6 +17,7 @@ import { UserSubscriptionConfig } from './userConfig';
 import { UserStats } from './userStats';
 import { JupiterClient, QuoteResponse, Route, SwapMode } from './jupiter/jupiterClient';
 import { UserStatsSubscriptionConfig } from './userStatsConfig';
+import { TxHandler } from './tx/txHandler';
 type RemainingAccountParams = {
     userAccounts: UserAccount[];
     writablePerpMarketIndexes?: number[];
@@ -57,6 +59,7 @@ export declare class DriftClient {
     txVersion: TransactionVersion;
     txParams: TxParams;
     enableMetricsEvents?: boolean;
+    txHandler: TxHandler;
     get isSubscribed(): boolean;
     set isSubscribed(val: boolean);
     constructor(config: DriftClientConfig);
@@ -112,7 +115,6 @@ export declare class DriftClient {
      * Adds and subscribes to users based on params set by the constructor or by updateWallet.
      */
     addAndSubscribeToUsers(): Promise<boolean>;
-    private getProcessedTransactionParams;
     initializeUserAccount(subAccountId?: number, name?: string, referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<[TransactionSignature, PublicKey]>;
     getInitializeUserInstructions(subAccountId?: number, name?: string, referrerInfo?: ReferrerInfo): Promise<[PublicKey, TransactionInstruction]>;
     getInitializeUserStatsIx(): Promise<TransactionInstruction>;
@@ -289,7 +291,7 @@ export declare class DriftClient {
      * @deprecated use {@link placePerpOrder} or {@link placeAndTakePerpOrder} instead
      */
     openPosition(direction: PositionDirection, amount: BN, marketIndex: number, limitPrice?: BN, subAccountId?: number): Promise<TransactionSignature>;
-    sendSignedTx(tx: Transaction): Promise<TransactionSignature>;
+    sendSignedTx(tx: Transaction, opts?: ConfirmOptions): Promise<TransactionSignature>;
     /**
      * Sends a market order and returns a signed tx which can fill the order against the vamm, which the caller can use to fill their own order if required.
      * @param orderParams
@@ -657,6 +659,16 @@ export declare class DriftClient {
     getDepositIntoSpotMarketRevenuePoolIx(marketIndex: number, amount: BN, userTokenAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
     depositIntoSpotMarketRevenuePool(marketIndex: number, amount: BN, userTokenAccountPublicKey: PublicKey): Promise<TransactionSignature>;
     getPerpMarketExtendedInfo(marketIndex: number): PerpMarketExtendedInfo;
+    /**
+     * Calculates taker / maker fee (as a percentage, e.g. .001 = 10 basis points) for particular marketType
+     * @param marketType
+     * @param positionMarketIndex
+     * @returns : {takerFee: number, makerFee: number} Precision None
+     */
+    getMarketFees(marketType: MarketType, marketIndex?: number, user?: User): {
+        takerFee: number;
+        makerFee: number;
+    };
     /**
      * Returns the market index and type for a given market name
      * E.g. "SOL-PERP" -> { marketIndex: 0, marketType: MarketType.PERP }
@@ -670,15 +682,10 @@ export declare class DriftClient {
     private handleSignedTransaction;
     private isVersionedTransaction;
     sendTransaction(tx: Transaction | VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
-    /**
-     *
-     * @param instructions
-     * @param txParams
-     * @param txVersion
-     * @param lookupTables
-     * @param forceVersionedTransaction Return a VersionedTransaction instance even if the version of the transaction is Legacy
-     * @returns
-     */
-    buildTransaction(instructions: TransactionInstruction | TransactionInstruction[], txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean): Promise<Transaction | VersionedTransaction>;
+    buildTransaction(instructions: TransactionInstruction | TransactionInstruction[], txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean, recentBlockHash?: BlockhashWithExpiryBlockHeight): Promise<Transaction | VersionedTransaction>;
+    buildBulkTransactions(instructions: (TransactionInstruction | TransactionInstruction[])[], txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean): Promise<(Transaction | VersionedTransaction)[]>;
+    buildAndSignBulkTransactions(instructions: (TransactionInstruction | TransactionInstruction[])[], keys: string[], txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean): Promise<{
+        [key: string]: anchor.web3.Transaction | anchor.web3.VersionedTransaction;
+    }>;
 }
 export {};