@drift-labs/sdk 2.97.0-beta.21 → 2.97.0-beta.23

package/lib/node/accounts/webSocketInsuranceFundStakeAccountSubscriber.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { DataAndSlot, AccountSubscriber, InsuranceFundStakeAccountEvents, InsuranceFundStakeAccountSubscriber } from './types';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { InsuranceFundStake } from '../types';
+export declare class WebSocketInsuranceFundStakeAccountSubscriber implements InsuranceFundStakeAccountSubscriber {
+    isSubscribed: boolean;
+    resubTimeoutMs?: number;
+    commitment?: Commitment;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, InsuranceFundStakeAccountEvents>;
+    insuranceFundStakeAccountPublicKey: PublicKey;
+    insuranceFundStakeDataAccountSubscriber: AccountSubscriber<InsuranceFundStake>;
+    constructor(program: Program, insuranceFundStakeAccountPublicKey: PublicKey, resubTimeoutMs?: number, commitment?: Commitment);
+    subscribe(insuranceFundStakeAccount?: InsuranceFundStake): Promise<boolean>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getInsuranceFundStakeAccountAndSlot(): DataAndSlot<InsuranceFundStake>;
+    updateData(insuranceFundStake: InsuranceFundStake, slot: number): void;
+}

package/lib/node/accounts/webSocketInsuranceFundStakeAccountSubscriber.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketInsuranceFundStakeAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
+class WebSocketInsuranceFundStakeAccountSubscriber {
+    constructor(program, insuranceFundStakeAccountPublicKey, resubTimeoutMs, commitment) {
+        this.isSubscribed = false;
+        this.program = program;
+        this.insuranceFundStakeAccountPublicKey =
+            insuranceFundStakeAccountPublicKey;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.resubTimeoutMs = resubTimeoutMs;
+        this.commitment = commitment;
+    }
+    async subscribe(insuranceFundStakeAccount) {
+        if (this.isSubscribed) {
+            return true;
+        }
+        this.insuranceFundStakeDataAccountSubscriber =
+            new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('insuranceFundStake', this.program, this.insuranceFundStakeAccountPublicKey, undefined, {
+                resubTimeoutMs: this.resubTimeoutMs,
+            }, this.commitment);
+        if (insuranceFundStakeAccount) {
+            this.insuranceFundStakeDataAccountSubscriber.setData(insuranceFundStakeAccount);
+        }
+        await this.insuranceFundStakeDataAccountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('insuranceFundStakeAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.eventEmitter.emit('update');
+        this.isSubscribed = true;
+        return true;
+    }
+    async fetch() {
+        await Promise.all([this.insuranceFundStakeDataAccountSubscriber.fetch()]);
+    }
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        await Promise.all([
+            this.insuranceFundStakeDataAccountSubscriber.unsubscribe(),
+        ]);
+        this.isSubscribed = false;
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getInsuranceFundStakeAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.insuranceFundStakeDataAccountSubscriber.dataAndSlot;
+    }
+    updateData(insuranceFundStake, slot) {
+        var _a;
+        const currentDataSlot = ((_a = this.insuranceFundStakeDataAccountSubscriber.dataAndSlot) === null || _a === void 0 ? void 0 : _a.slot) || 0;
+        if (currentDataSlot <= slot) {
+            this.insuranceFundStakeDataAccountSubscriber.setData(insuranceFundStake, slot);
+            this.eventEmitter.emit('insuranceFundStakeAccountUpdate', insuranceFundStake);
+            this.eventEmitter.emit('update');
+        }
+    }
+}
+exports.WebSocketInsuranceFundStakeAccountSubscriber = WebSocketInsuranceFundStakeAccountSubscriber;

package/lib/node/accounts/webSocketProgramAccountSubscriber.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { DataAndSlot, BufferAndSlot, ProgramAccountSubscriber, ResubOpts } from './types';
+import { Program } from '@coral-xyz/anchor';
+import { Commitment, Context, KeyedAccountInfo, MemcmpFilter, PublicKey } from '@solana/web3.js';
+export declare class WebSocketProgramAccountSubscriber<T> implements ProgramAccountSubscriber<T> {
+    subscriptionName: string;
+    accountDiscriminator: string;
+    dataAndSlot?: DataAndSlot<T> & {
+        accountId: PublicKey;
+    };
+    bufferAndSlot?: BufferAndSlot;
+    program: Program;
+    decodeBuffer: (accountName: string, ix: Buffer) => T;
+    onChange: (accountId: PublicKey, data: T, context: Context, buffer: Buffer) => void;
+    listenerId?: number;
+    resubOpts?: ResubOpts;
+    isUnsubscribing: boolean;
+    timeoutId?: NodeJS.Timeout;
+    options: {
+        filters: MemcmpFilter[];
+        commitment?: Commitment;
+    };
+    receivingData: boolean;
+    constructor(subscriptionName: string, accountDiscriminator: string, program: Program, decodeBufferFn: (accountName: string, ix: Buffer) => T, options?: {
+        filters: MemcmpFilter[];
+        commitment?: Commitment;
+    }, resubOpts?: ResubOpts);
+    subscribe(onChange: (accountId: PublicKey, data: T, context: Context, buffer: Buffer) => void): Promise<void>;
+    protected setTimeout(): void;
+    handleRpcResponse(context: Context, keyedAccountInfo: KeyedAccountInfo): void;
+    unsubscribe(onResub?: boolean): Promise<void>;
+}

package/lib/node/accounts/webSocketProgramAccountSubscriber.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketProgramAccountSubscriber = void 0;
+class WebSocketProgramAccountSubscriber {
+    constructor(subscriptionName, accountDiscriminator, program, decodeBufferFn, options = {
+        filters: [],
+    }, resubOpts) {
+        var _a;
+        this.isUnsubscribing = false;
+        this.receivingData = false;
+        this.subscriptionName = subscriptionName;
+        this.accountDiscriminator = accountDiscriminator;
+        this.program = program;
+        this.decodeBuffer = decodeBufferFn;
+        this.resubOpts = resubOpts;
+        if (((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs) < 1000) {
+            console.log('resubTimeoutMs should be at least 1000ms to avoid spamming resub');
+        }
+        this.options = options;
+        this.receivingData = false;
+    }
+    async subscribe(onChange) {
+        var _a, _b;
+        if (this.listenerId != null || this.isUnsubscribing) {
+            return;
+        }
+        this.onChange = onChange;
+        this.listenerId = this.program.provider.connection.onProgramAccountChange(this.program.programId, (keyedAccountInfo, context) => {
+            var _a;
+            if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs) {
+                this.receivingData = true;
+                clearTimeout(this.timeoutId);
+                this.handleRpcResponse(context, keyedAccountInfo);
+                this.setTimeout();
+            }
+            else {
+                this.handleRpcResponse(context, keyedAccountInfo);
+            }
+        }, (_a = this.options.commitment) !== null && _a !== void 0 ? _a : this.program.provider.opts.commitment, this.options.filters);
+        if ((_b = this.resubOpts) === null || _b === void 0 ? void 0 : _b.resubTimeoutMs) {
+            this.receivingData = true;
+            this.setTimeout();
+        }
+    }
+    setTimeout() {
+        var _a;
+        if (!this.onChange) {
+            throw new Error('onChange callback function must be set');
+        }
+        this.timeoutId = setTimeout(async () => {
+            var _a, _b;
+            if (this.isUnsubscribing) {
+                // If we are in the process of unsubscribing, do not attempt to resubscribe
+                return;
+            }
+            if (this.receivingData) {
+                if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.logResubMessages) {
+                    console.log(`No ws data from ${this.subscriptionName} in ${(_b = this.resubOpts) === null || _b === void 0 ? void 0 : _b.resubTimeoutMs}ms, resubscribing`);
+                }
+                await this.unsubscribe(true);
+                this.receivingData = false;
+                await this.subscribe(this.onChange);
+            }
+        }, (_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs);
+    }
+    handleRpcResponse(context, keyedAccountInfo) {
+        const newSlot = context.slot;
+        let newBuffer = undefined;
+        if (keyedAccountInfo) {
+            newBuffer = keyedAccountInfo.accountInfo.data;
+        }
+        if (!this.bufferAndSlot) {
+            this.bufferAndSlot = {
+                buffer: newBuffer,
+                slot: newSlot,
+            };
+            if (newBuffer) {
+                const account = this.decodeBuffer(this.accountDiscriminator, newBuffer);
+                this.dataAndSlot = {
+                    data: account,
+                    slot: newSlot,
+                    accountId: keyedAccountInfo.accountId,
+                };
+                this.onChange(keyedAccountInfo.accountId, account, context, newBuffer);
+            }
+            return;
+        }
+        if (newSlot < this.bufferAndSlot.slot) {
+            return;
+        }
+        const oldBuffer = this.bufferAndSlot.buffer;
+        if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+            this.bufferAndSlot = {
+                buffer: newBuffer,
+                slot: newSlot,
+            };
+            const account = this.decodeBuffer(this.accountDiscriminator, newBuffer);
+            this.dataAndSlot = {
+                data: account,
+                slot: newSlot,
+                accountId: keyedAccountInfo.accountId,
+            };
+            this.onChange(keyedAccountInfo.accountId, account, context, newBuffer);
+        }
+    }
+    unsubscribe(onResub = false) {
+        if (!onResub) {
+            this.resubOpts.resubTimeoutMs = undefined;
+        }
+        this.isUnsubscribing = true;
+        clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        if (this.listenerId != null) {
+            const promise = this.program.provider.connection
+                .removeAccountChangeListener(this.listenerId)
+                .then(() => {
+                this.listenerId = undefined;
+                this.isUnsubscribing = false;
+            });
+            return promise;
+        }
+        else {
+            this.isUnsubscribing = false;
+        }
+    }
+}
+exports.WebSocketProgramAccountSubscriber = WebSocketProgramAccountSubscriber;

package/lib/node/accounts/webSocketUserAccountSubscriber.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { DataAndSlot, AccountSubscriber, UserAccountEvents, UserAccountSubscriber, ResubOpts } from './types';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { UserAccount } from '../types';
+export declare class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
+    isSubscribed: boolean;
+    resubOpts?: ResubOpts;
+    commitment?: Commitment;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
+    userAccountPublicKey: PublicKey;
+    userDataAccountSubscriber: AccountSubscriber<UserAccount>;
+    constructor(program: Program, userAccountPublicKey: PublicKey, resubOpts?: ResubOpts, commitment?: Commitment);
+    subscribe(userAccount?: UserAccount): Promise<boolean>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getUserAccountAndSlot(): DataAndSlot<UserAccount>;
+    updateData(userAccount: UserAccount, slot: number): void;
+}

package/lib/node/accounts/webSocketUserAccountSubscriber.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketUserAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
+class WebSocketUserAccountSubscriber {
+    constructor(program, userAccountPublicKey, resubOpts, commitment) {
+        this.isSubscribed = false;
+        this.program = program;
+        this.resubOpts = resubOpts;
+        this.userAccountPublicKey = userAccountPublicKey;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.commitment = commitment;
+    }
+    async subscribe(userAccount) {
+        if (this.isSubscribed) {
+            return true;
+        }
+        this.userDataAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('user', this.program, this.userAccountPublicKey, undefined, this.resubOpts, this.commitment);
+        if (userAccount) {
+            this.userDataAccountSubscriber.setData(userAccount);
+        }
+        await this.userDataAccountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('userAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.eventEmitter.emit('update');
+        this.isSubscribed = true;
+        return true;
+    }
+    async fetch() {
+        await Promise.all([this.userDataAccountSubscriber.fetch()]);
+    }
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        await Promise.all([this.userDataAccountSubscriber.unsubscribe()]);
+        this.isSubscribed = false;
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getUserAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.userDataAccountSubscriber.dataAndSlot;
+    }
+    updateData(userAccount, slot) {
+        var _a;
+        const currentDataSlot = ((_a = this.userDataAccountSubscriber.dataAndSlot) === null || _a === void 0 ? void 0 : _a.slot) || 0;
+        if (currentDataSlot <= slot) {
+            this.userDataAccountSubscriber.setData(userAccount, slot);
+            this.eventEmitter.emit('userAccountUpdate', userAccount);
+            this.eventEmitter.emit('update');
+        }
+    }
+}
+exports.WebSocketUserAccountSubscriber = WebSocketUserAccountSubscriber;

package/lib/node/accounts/webSocketUserStatsAccountSubsriber.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { DataAndSlot, AccountSubscriber, UserStatsAccountSubscriber, UserStatsAccountEvents, ResubOpts } from './types';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { UserStatsAccount } from '../types';
+export declare class WebSocketUserStatsAccountSubscriber implements UserStatsAccountSubscriber {
+    isSubscribed: boolean;
+    resubOpts?: ResubOpts;
+    commitment?: Commitment;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+    userStatsAccountPublicKey: PublicKey;
+    userStatsAccountSubscriber: AccountSubscriber<UserStatsAccount>;
+    constructor(program: Program, userStatsAccountPublicKey: PublicKey, resubOpts?: ResubOpts, commitment?: Commitment);
+    subscribe(userStatsAccount?: UserStatsAccount): Promise<boolean>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+}

package/lib/node/accounts/webSocketUserStatsAccountSubsriber.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketUserStatsAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
+class WebSocketUserStatsAccountSubscriber {
+    constructor(program, userStatsAccountPublicKey, resubOpts, commitment) {
+        this.isSubscribed = false;
+        this.program = program;
+        this.userStatsAccountPublicKey = userStatsAccountPublicKey;
+        this.eventEmitter = new events_1.EventEmitter();
+        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.resubOpts, this.commitment);
+        if (userStatsAccount) {
+            this.userStatsAccountSubscriber.setData(userStatsAccount);
+        }
+        await this.userStatsAccountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('userStatsAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.eventEmitter.emit('update');
+        this.isSubscribed = true;
+        return true;
+    }
+    async fetch() {
+        await Promise.all([this.userStatsAccountSubscriber.fetch()]);
+    }
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        await Promise.all([this.userStatsAccountSubscriber.unsubscribe()]);
+        this.isSubscribed = false;
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getUserStatsAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.userStatsAccountSubscriber.dataAndSlot;
+    }
+}
+exports.WebSocketUserStatsAccountSubscriber = WebSocketUserStatsAccountSubscriber;

package/lib/node/addresses/marketAddresses.d.ts

@@ -0,0 +1,2 @@
+import { PublicKey } from '@solana/web3.js';
+export declare function getMarketAddress(programId: PublicKey, marketIndex: number): Promise<PublicKey>;

package/lib/node/addresses/marketAddresses.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMarketAddress = void 0;
+const pda_1 = require("./pda");
+const CACHE = new Map();
+async function getMarketAddress(programId, marketIndex) {
+    const cacheKey = `${programId.toString()}-${marketIndex.toString()}`;
+    if (CACHE.has(cacheKey)) {
+        return CACHE.get(cacheKey);
+    }
+    const publicKey = await (0, pda_1.getPerpMarketPublicKey)(programId, marketIndex);
+    CACHE.set(cacheKey, publicKey);
+    return publicKey;
+}
+exports.getMarketAddress = getMarketAddress;

package/lib/node/addresses/pda.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="bn.js" />
+import { PublicKey } from '@solana/web3.js';
+import { BN } from '@coral-xyz/anchor';
+import { SpotMarketAccount } from '..';
+export declare function getDriftStateAccountPublicKeyAndNonce(programId: PublicKey): Promise<[PublicKey, number]>;
+export declare function getDriftStateAccountPublicKey(programId: PublicKey): Promise<PublicKey>;
+export declare function getUserAccountPublicKeyAndNonce(programId: PublicKey, authority: PublicKey, subAccountId?: number): Promise<[PublicKey, number]>;
+export declare function getUserAccountPublicKey(programId: PublicKey, authority: PublicKey, subAccountId?: number): Promise<PublicKey>;
+export declare function getUserAccountPublicKeySync(programId: PublicKey, authority: PublicKey, subAccountId?: number): PublicKey;
+export declare function getUserStatsAccountPublicKey(programId: PublicKey, authority: PublicKey): PublicKey;
+export declare function getRFQUserAccountPublicKey(programId: PublicKey, userAccountPublicKey: PublicKey): PublicKey;
+export declare function getPerpMarketPublicKey(programId: PublicKey, marketIndex: number): Promise<PublicKey>;
+export declare function getPerpMarketPublicKeySync(programId: PublicKey, marketIndex: number): PublicKey;
+export declare function getSpotMarketPublicKey(programId: PublicKey, marketIndex: number): Promise<PublicKey>;
+export declare function getSpotMarketPublicKeySync(programId: PublicKey, marketIndex: number): PublicKey;
+export declare function getSpotMarketVaultPublicKey(programId: PublicKey, marketIndex: number): Promise<PublicKey>;
+export declare function getInsuranceFundVaultPublicKey(programId: PublicKey, marketIndex: number): Promise<PublicKey>;
+export declare function getInsuranceFundStakeAccountPublicKey(programId: PublicKey, authority: PublicKey, marketIndex: number): PublicKey;
+export declare function getDriftSignerPublicKey(programId: PublicKey): PublicKey;
+export declare function getSerumOpenOrdersPublicKey(programId: PublicKey, market: PublicKey): PublicKey;
+export declare function getSerumSignerPublicKey(programId: PublicKey, market: PublicKey, nonce: BN): PublicKey;
+export declare function getSerumFulfillmentConfigPublicKey(programId: PublicKey, market: PublicKey): PublicKey;
+export declare function getPhoenixFulfillmentConfigPublicKey(programId: PublicKey, market: PublicKey): PublicKey;
+export declare function getOpenbookV2FulfillmentConfigPublicKey(programId: PublicKey, market: PublicKey): PublicKey;
+export declare function getReferrerNamePublicKeySync(programId: PublicKey, nameBuffer: number[]): PublicKey;
+export declare function getProtocolIfSharesTransferConfigPublicKey(programId: PublicKey): PublicKey;
+export declare function getPrelaunchOraclePublicKey(programId: PublicKey, marketIndex: number): PublicKey;
+export declare function getPythPullOraclePublicKey(progarmId: PublicKey, feedId: Uint8Array): PublicKey;
+export declare function getTokenProgramForSpotMarket(spotMarketAccount: SpotMarketAccount): PublicKey;
+export declare function getHighLeverageModeConfigPublicKey(programId: PublicKey): PublicKey;

package/lib/node/addresses/pda.js

@@ -0,0 +1,193 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHighLeverageModeConfigPublicKey = exports.getTokenProgramForSpotMarket = exports.getPythPullOraclePublicKey = exports.getPrelaunchOraclePublicKey = exports.getProtocolIfSharesTransferConfigPublicKey = exports.getReferrerNamePublicKeySync = exports.getOpenbookV2FulfillmentConfigPublicKey = exports.getPhoenixFulfillmentConfigPublicKey = exports.getSerumFulfillmentConfigPublicKey = exports.getSerumSignerPublicKey = exports.getSerumOpenOrdersPublicKey = exports.getDriftSignerPublicKey = exports.getInsuranceFundStakeAccountPublicKey = exports.getInsuranceFundVaultPublicKey = exports.getSpotMarketVaultPublicKey = exports.getSpotMarketPublicKeySync = exports.getSpotMarketPublicKey = exports.getPerpMarketPublicKeySync = exports.getPerpMarketPublicKey = exports.getRFQUserAccountPublicKey = exports.getUserStatsAccountPublicKey = exports.getUserAccountPublicKeySync = exports.getUserAccountPublicKey = exports.getUserAccountPublicKeyAndNonce = exports.getDriftStateAccountPublicKey = exports.getDriftStateAccountPublicKeyAndNonce = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const spl_token_1 = require("@solana/spl-token");
+async function getDriftStateAccountPublicKeyAndNonce(programId) {
+    return web3_js_1.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('drift_state'))], programId);
+}
+exports.getDriftStateAccountPublicKeyAndNonce = getDriftStateAccountPublicKeyAndNonce;
+async function getDriftStateAccountPublicKey(programId) {
+    return (await getDriftStateAccountPublicKeyAndNonce(programId))[0];
+}
+exports.getDriftStateAccountPublicKey = getDriftStateAccountPublicKey;
+async function getUserAccountPublicKeyAndNonce(programId, authority, subAccountId = 0) {
+    return web3_js_1.PublicKey.findProgramAddress([
+        Buffer.from(anchor.utils.bytes.utf8.encode('user')),
+        authority.toBuffer(),
+        new anchor.BN(subAccountId).toArrayLike(Buffer, 'le', 2),
+    ], programId);
+}
+exports.getUserAccountPublicKeyAndNonce = getUserAccountPublicKeyAndNonce;
+async function getUserAccountPublicKey(programId, authority, subAccountId = 0) {
+    return (await getUserAccountPublicKeyAndNonce(programId, authority, subAccountId))[0];
+}
+exports.getUserAccountPublicKey = getUserAccountPublicKey;
+function getUserAccountPublicKeySync(programId, authority, subAccountId = 0) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('user')),
+        authority.toBuffer(),
+        new anchor.BN(subAccountId).toArrayLike(Buffer, 'le', 2),
+    ], programId)[0];
+}
+exports.getUserAccountPublicKeySync = getUserAccountPublicKeySync;
+function getUserStatsAccountPublicKey(programId, authority) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('user_stats')),
+        authority.toBuffer(),
+    ], programId)[0];
+}
+exports.getUserStatsAccountPublicKey = getUserStatsAccountPublicKey;
+function getRFQUserAccountPublicKey(programId, userAccountPublicKey) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('RFQ')),
+        userAccountPublicKey.toBuffer(),
+    ], programId)[0];
+}
+exports.getRFQUserAccountPublicKey = getRFQUserAccountPublicKey;
+async function getPerpMarketPublicKey(programId, marketIndex) {
+    return (await web3_js_1.PublicKey.findProgramAddress([
+        Buffer.from(anchor.utils.bytes.utf8.encode('perp_market')),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
+    ], programId))[0];
+}
+exports.getPerpMarketPublicKey = getPerpMarketPublicKey;
+function getPerpMarketPublicKeySync(programId, marketIndex) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('perp_market')),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
+    ], programId)[0];
+}
+exports.getPerpMarketPublicKeySync = getPerpMarketPublicKeySync;
+async function getSpotMarketPublicKey(programId, marketIndex) {
+    return (await web3_js_1.PublicKey.findProgramAddress([
+        Buffer.from(anchor.utils.bytes.utf8.encode('spot_market')),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
+    ], programId))[0];
+}
+exports.getSpotMarketPublicKey = getSpotMarketPublicKey;
+function getSpotMarketPublicKeySync(programId, marketIndex) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('spot_market')),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
+    ], programId)[0];
+}
+exports.getSpotMarketPublicKeySync = getSpotMarketPublicKeySync;
+async function getSpotMarketVaultPublicKey(programId, marketIndex) {
+    return (await web3_js_1.PublicKey.findProgramAddress([
+        Buffer.from(anchor.utils.bytes.utf8.encode('spot_market_vault')),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
+    ], programId))[0];
+}
+exports.getSpotMarketVaultPublicKey = getSpotMarketVaultPublicKey;
+async function getInsuranceFundVaultPublicKey(programId, marketIndex) {
+    return (await web3_js_1.PublicKey.findProgramAddress([
+        Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_vault')),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
+    ], programId))[0];
+}
+exports.getInsuranceFundVaultPublicKey = getInsuranceFundVaultPublicKey;
+function getInsuranceFundStakeAccountPublicKey(programId, authority, marketIndex) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_stake')),
+        authority.toBuffer(),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
+    ], programId)[0];
+}
+exports.getInsuranceFundStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey;
+function getDriftSignerPublicKey(programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(anchor.utils.bytes.utf8.encode('drift_signer'))], programId)[0];
+}
+exports.getDriftSignerPublicKey = getDriftSignerPublicKey;
+function getSerumOpenOrdersPublicKey(programId, market) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('serum_open_orders')),
+        market.toBuffer(),
+    ], programId)[0];
+}
+exports.getSerumOpenOrdersPublicKey = getSerumOpenOrdersPublicKey;
+function getSerumSignerPublicKey(programId, market, nonce) {
+    return anchor.web3.PublicKey.createProgramAddressSync([market.toBuffer(), nonce.toArrayLike(Buffer, 'le', 8)], programId);
+}
+exports.getSerumSignerPublicKey = getSerumSignerPublicKey;
+function getSerumFulfillmentConfigPublicKey(programId, market) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('serum_fulfillment_config')),
+        market.toBuffer(),
+    ], programId)[0];
+}
+exports.getSerumFulfillmentConfigPublicKey = getSerumFulfillmentConfigPublicKey;
+function getPhoenixFulfillmentConfigPublicKey(programId, market) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('phoenix_fulfillment_config')),
+        market.toBuffer(),
+    ], programId)[0];
+}
+exports.getPhoenixFulfillmentConfigPublicKey = getPhoenixFulfillmentConfigPublicKey;
+function getOpenbookV2FulfillmentConfigPublicKey(programId, market) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('openbook_v2_fulfillment_config')),
+        market.toBuffer(),
+    ], programId)[0];
+}
+exports.getOpenbookV2FulfillmentConfigPublicKey = getOpenbookV2FulfillmentConfigPublicKey;
+function getReferrerNamePublicKeySync(programId, nameBuffer) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('referrer_name')),
+        Buffer.from(nameBuffer),
+    ], programId)[0];
+}
+exports.getReferrerNamePublicKeySync = getReferrerNamePublicKeySync;
+function getProtocolIfSharesTransferConfigPublicKey(programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(anchor.utils.bytes.utf8.encode('if_shares_transfer_config'))], programId)[0];
+}
+exports.getProtocolIfSharesTransferConfigPublicKey = getProtocolIfSharesTransferConfigPublicKey;
+function getPrelaunchOraclePublicKey(programId, marketIndex) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('prelaunch_oracle')),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
+    ], programId)[0];
+}
+exports.getPrelaunchOraclePublicKey = getPrelaunchOraclePublicKey;
+function getPythPullOraclePublicKey(progarmId, feedId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('pyth_pull')),
+        Buffer.from(feedId),
+    ], progarmId)[0];
+}
+exports.getPythPullOraclePublicKey = getPythPullOraclePublicKey;
+function getTokenProgramForSpotMarket(spotMarketAccount) {
+    if (spotMarketAccount.tokenProgram === 1) {
+        return spl_token_1.TOKEN_2022_PROGRAM_ID;
+    }
+    return spl_token_1.TOKEN_PROGRAM_ID;
+}
+exports.getTokenProgramForSpotMarket = getTokenProgramForSpotMarket;
+function getHighLeverageModeConfigPublicKey(programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(anchor.utils.bytes.utf8.encode('high_leverage_mode_config'))], programId)[0];
+}
+exports.getHighLeverageModeConfigPublicKey = getHighLeverageModeConfigPublicKey;