@drift-labs/sdk 2.85.0-beta.3 → 2.85.0-beta.5

package/VERSION

@@ -1 +1 @@
-2.85.0-beta.3
+2.85.0-beta.5

package/lib/accounts/bulkAccountLoader.d.ts

@@ -1,7 +1,8 @@
 /// <reference types="node" />
-import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+import { Commitment, PublicKey } from '@solana/web3.js';
 import { BufferAndSlot } from './types';
-type AccountToLoad = {
+import { Connection } from '../bankrun/bankrunConnection';
+export type AccountToLoad = {
     publicKey: PublicKey;
     callbacks: Map<string, (buffer: Buffer, slot: number) => void>;
 };
@@ -33,4 +34,3 @@ export declare class BulkAccountLoader {
     log(msg: string): void;
     updatePollingFrequency(pollingFrequency: number): void;
 }
-export {};

package/lib/accounts/pollingDriftClientAccountSubscriber.js

@@ -178,7 +178,11 @@ class PollingDriftClientAccountSubscriber {
     async fetch() {
         await this.accountLoader.load();
         for (const [_, accountToPoll] of this.accountsToPoll) {
-            const { buffer, slot } = this.accountLoader.getBufferAndSlot(accountToPoll.publicKey);
+            const bufferAndSlot = this.accountLoader.getBufferAndSlot(accountToPoll.publicKey);
+            if (!bufferAndSlot) {
+                continue;
+            }
+            const { buffer, slot } = bufferAndSlot;
             if (buffer) {
                 const account = this.program.account[accountToPoll.key].coder.accounts.decodeUnchecked((0, utils_1.capitalize)(accountToPoll.key), buffer);
                 if (accountToPoll.mapKey != undefined) {
@@ -196,7 +200,11 @@ class PollingDriftClientAccountSubscriber {
             }
         }
         for (const [_, oracleToPoll] of this.oraclesToPoll) {
-            const { buffer, slot } = this.accountLoader.getBufferAndSlot(oracleToPoll.publicKey);
+            const bufferAndSlot = this.accountLoader.getBufferAndSlot(oracleToPoll.publicKey);
+            if (!bufferAndSlot) {
+                continue;
+            }
+            const { buffer, slot } = bufferAndSlot;
             if (buffer) {
                 const oracleClient = this.oracleClientCache.get(oracleToPoll.source, this.program.provider.connection, this.program);
                 const oraclePriceData = oracleClient.getOraclePriceDataFromBuffer(buffer);

package/lib/accounts/pollingUserAccountSubscriber.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { DataAndSlot, UserAccountEvents, UserAccountSubscriber } from './types';
-import { Program } from '@coral-xyz/anchor';
+import { Connection } from '../bankrun/bankrunConnection';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
@@ -8,14 +8,15 @@ import { UserAccount } from '../types';
 import { BulkAccountLoader } from './bulkAccountLoader';
 export declare class PollingUserAccountSubscriber implements UserAccountSubscriber {
     isSubscribed: boolean;
-    program: Program;
+    connection: Connection;
     eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
     userAccountPublicKey: PublicKey;
     accountLoader: BulkAccountLoader;
     callbackId?: string;
     errorCallbackId?: string;
+    decode: (name: any, buffer: any) => UserAccount;
     user?: DataAndSlot<UserAccount>;
-    constructor(program: Program, userAccountPublicKey: PublicKey, accountLoader: BulkAccountLoader);
+    constructor(connection: Connection, userAccountPublicKey: PublicKey, accountLoader: BulkAccountLoader, decode: (name: any, buffer: any) => UserAccount);
     subscribe(userAccount?: UserAccount): Promise<boolean>;
     addToAccountLoader(): Promise<void>;
     fetchIfUnloaded(): Promise<void>;

package/lib/accounts/pollingUserAccountSubscriber.js

@@ -4,12 +4,13 @@ exports.PollingUserAccountSubscriber = void 0;
 const types_1 = require("./types");
 const events_1 = require("events");
 class PollingUserAccountSubscriber {
-    constructor(program, userAccountPublicKey, accountLoader) {
+    constructor(connection, userAccountPublicKey, accountLoader, decode) {
         this.isSubscribed = false;
-        this.program = program;
+        this.connection = connection;
         this.accountLoader = accountLoader;
         this.eventEmitter = new events_1.EventEmitter();
         this.userAccountPublicKey = userAccountPublicKey;
+        this.decode = decode;
     }
     async subscribe(userAccount) {
         if (this.isSubscribed) {
@@ -37,7 +38,7 @@ class PollingUserAccountSubscriber {
             if (this.user && this.user.slot > slot) {
                 return;
             }
-            const account = this.program.account.user.coder.accounts.decode('User', buffer);
+            const account = this.decode('User', buffer);
             this.user = { data: account, slot };
             this.eventEmitter.emit('userAccountUpdate', account);
             this.eventEmitter.emit('update');
@@ -54,16 +55,16 @@ class PollingUserAccountSubscriber {
     async fetch() {
         var _a, _b;
         try {
-            const dataAndContext = await this.program.account.user.fetchAndContext(this.userAccountPublicKey, this.accountLoader.commitment);
+            const dataAndContext = await this.connection.getAccountInfoAndContext(this.userAccountPublicKey, this.accountLoader.commitment);
             if (dataAndContext.context.slot > ((_b = (_a = this.user) === null || _a === void 0 ? void 0 : _a.slot) !== null && _b !== void 0 ? _b : 0)) {
                 this.user = {
-                    data: dataAndContext.data,
+                    data: this.decode('User', dataAndContext.value.data),
                     slot: dataAndContext.context.slot,
                 };
             }
         }
         catch (e) {
-            console.log(`PollingUserAccountSubscriber.fetch() UserAccount does not exist: ${e.message}`);
+            console.log(`PollingUserAccountSubscriber.fetch() UserAccount does not exist: ${e.message}-${e.stack}`);
         }
     }
     doesAccountExist() {

package/lib/accounts/testBulkAccountLoader.d.ts

@@ -0,0 +1,4 @@
+import { AccountToLoad, BulkAccountLoader } from './bulkAccountLoader';
+export declare class TestBulkAccountLoader extends BulkAccountLoader {
+    loadChunk(accountsToLoadChunks: AccountToLoad[][]): Promise<void>;
+}

package/lib/accounts/testBulkAccountLoader.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestBulkAccountLoader = void 0;
+const bulkAccountLoader_1 = require("./bulkAccountLoader");
+class TestBulkAccountLoader extends bulkAccountLoader_1.BulkAccountLoader {
+    async loadChunk(accountsToLoadChunks) {
+        if (accountsToLoadChunks.length === 0) {
+            return;
+        }
+        const accounts = [];
+        for (const accountsToLoadChunk of accountsToLoadChunks) {
+            for (const accountToLoad of accountsToLoadChunk) {
+                const account = await this.connection.getAccountInfoAndContext(accountToLoad.publicKey, this.commitment);
+                accounts.push(account);
+                const newSlot = account.context.slot;
+                if (newSlot > this.mostRecentSlot) {
+                    this.mostRecentSlot = newSlot;
+                }
+                if (accountToLoad.callbacks.size === 0) {
+                    return;
+                }
+                const key = accountToLoad.publicKey.toBase58();
+                const prev = this.bufferAndSlotMap.get(key);
+                if (prev && newSlot < prev.slot) {
+                    return;
+                }
+                let newBuffer = undefined;
+                if (account.value) {
+                    newBuffer = account.value.data;
+                }
+                if (!prev) {
+                    this.bufferAndSlotMap.set(key, { slot: newSlot, buffer: newBuffer });
+                    this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
+                    return;
+                }
+                const oldBuffer = prev.buffer;
+                if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+                    this.bufferAndSlotMap.set(key, { slot: newSlot, buffer: newBuffer });
+                    this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
+                }
+            }
+        }
+    }
+}
+exports.TestBulkAccountLoader = TestBulkAccountLoader;

package/lib/bankrun/bankrunConnection.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="node" />
+/// <reference types="bn.js" />
+import { AccountInfo, Keypair, PublicKey, Transaction, RpcResponseAndContext, Commitment, TransactionSignature, SignatureStatusConfig, SignatureStatus, GetVersionedTransactionConfig, GetTransactionConfig, VersionedTransaction, SimulateTransactionConfig, SimulatedTransactionResponse, TransactionError, SignatureResultCallback, ClientSubscriptionId, Connection as SolanaConnection, Blockhash, LogsFilter, LogsCallback, AccountChangeCallback } from '@solana/web3.js';
+import { ProgramTestContext, BanksClient } from 'solana-bankrun';
+import { BankrunProvider } from 'anchor-bankrun';
+import { BN, Wallet } from '@coral-xyz/anchor';
+import { Account } from '@solana/spl-token';
+export type Connection = SolanaConnection | BankrunConnection;
+type BankrunTransactionMetaNormalized = {
+    logMessages: string[];
+    err: TransactionError;
+};
+type BankrunTransactionRespose = {
+    slot: number;
+    meta: BankrunTransactionMetaNormalized;
+};
+export declare class BankrunContextWrapper {
+    readonly connection: BankrunConnection;
+    readonly context: ProgramTestContext;
+    readonly provider: BankrunProvider;
+    readonly commitment: Commitment;
+    constructor(context: ProgramTestContext);
+    sendTransaction(tx: Transaction, additionalSigners?: Keypair[]): Promise<TransactionSignature>;
+    getMinimumBalanceForRentExemption(_: number): Promise<number>;
+    fundKeypair(keypair: Keypair | Wallet, lamports: number | bigint): Promise<TransactionSignature>;
+    getLatestBlockhash(): Promise<Blockhash>;
+    printTxLogs(signature: string): void;
+    moveTimeForward(increment: number): Promise<void>;
+}
+export declare class BankrunConnection {
+    private readonly _banksClient;
+    private readonly context;
+    private transactionToMeta;
+    private clock;
+    private nextClientSubscriptionId;
+    private onLogCallbacks;
+    private onAccountChangeCallbacks;
+    constructor(banksClient: BanksClient, context: ProgramTestContext);
+    getSlot(): Promise<bigint>;
+    toConnection(): SolanaConnection;
+    getTokenAccount(publicKey: PublicKey): Promise<Account>;
+    getMultipleAccountsInfo(publicKeys: PublicKey[], _commitmentOrConfig?: Commitment): Promise<AccountInfo<Buffer>[]>;
+    getAccountInfo(publicKey: PublicKey): Promise<null | AccountInfo<Buffer>>;
+    getAccountInfoAndContext(publicKey: PublicKey, _commitment?: Commitment): Promise<RpcResponseAndContext<null | AccountInfo<Buffer>>>;
+    sendRawTransaction(rawTransaction: Buffer | Uint8Array | Array<number>, _options?: any): Promise<TransactionSignature>;
+    sendTransaction(tx: Transaction): Promise<TransactionSignature>;
+    private updateSlotAndClock;
+    getTime(): number;
+    getParsedAccountInfo(publicKey: PublicKey): Promise<RpcResponseAndContext<AccountInfo<Buffer>>>;
+    getLatestBlockhash(commitment?: Commitment): Promise<Readonly<{
+        blockhash: string;
+        lastValidBlockHeight: number;
+    }>>;
+    getSignatureStatus(signature: string, _config?: SignatureStatusConfig): Promise<RpcResponseAndContext<null | SignatureStatus>>;
+    /**
+     * There's really no direct equivalent to getTransaction exposed by SolanaProgramTest, so we do the best that we can here - it's a little hacky.
+     */
+    getTransaction(signature: string, _rawConfig?: GetTransactionConfig | GetVersionedTransactionConfig): Promise<BankrunTransactionRespose | null>;
+    findComputeUnitConsumption(signature: string): bigint;
+    printTxLogs(signature: string): void;
+    simulateTransaction(transaction: Transaction | VersionedTransaction, _config?: SimulateTransactionConfig): Promise<RpcResponseAndContext<SimulatedTransactionResponse>>;
+    onSignature(signature: string, callback: SignatureResultCallback, commitment?: Commitment): ClientSubscriptionId;
+    removeSignatureListener(_clientSubscriptionId: number): Promise<void>;
+    onLogs(filter: LogsFilter, callback: LogsCallback, _commitment?: Commitment): ClientSubscriptionId;
+    removeOnLogsListener(clientSubscriptionId: ClientSubscriptionId): Promise<void>;
+    onAccountChange(publicKey: PublicKey, callback: AccountChangeCallback, _commitment?: Commitment): ClientSubscriptionId;
+    removeAccountChangeListener(clientSubscriptionId: ClientSubscriptionId): Promise<void>;
+    getMinimumBalanceForRentExemption(_: number): Promise<number>;
+}
+export declare function asBN(value: number | bigint): BN;
+export {};

package/lib/bankrun/bankrunConnection.js

@@ -0,0 +1,285 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asBN = exports.BankrunConnection = exports.BankrunContextWrapper = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const solana_bankrun_1 = require("solana-bankrun");
+const anchor_bankrun_1 = require("anchor-bankrun");
+const bs58_1 = __importDefault(require("bs58"));
+const anchor_1 = require("@coral-xyz/anchor");
+const spl_token_1 = require("@solana/spl-token");
+class BankrunContextWrapper {
+    constructor(context) {
+        this.commitment = 'confirmed';
+        this.context = context;
+        this.provider = new anchor_bankrun_1.BankrunProvider(context);
+        this.connection = new BankrunConnection(this.context.banksClient, this.context);
+    }
+    async sendTransaction(tx, additionalSigners) {
+        tx.recentBlockhash = (await this.getLatestBlockhash()).toString();
+        tx.feePayer = this.context.payer.publicKey;
+        if (!additionalSigners) {
+            additionalSigners = [];
+        }
+        tx.sign(this.context.payer, ...additionalSigners);
+        return await this.connection.sendTransaction(tx);
+    }
+    async getMinimumBalanceForRentExemption(_) {
+        return 10 * web3_js_1.LAMPORTS_PER_SOL;
+    }
+    async fundKeypair(keypair, lamports) {
+        const ixs = [
+            web3_js_1.SystemProgram.transfer({
+                fromPubkey: this.context.payer.publicKey,
+                toPubkey: keypair.publicKey,
+                lamports,
+            }),
+        ];
+        const tx = new web3_js_1.Transaction().add(...ixs);
+        return await this.sendTransaction(tx);
+    }
+    async getLatestBlockhash() {
+        const blockhash = await this.connection.getLatestBlockhash('finalized');
+        return blockhash.blockhash;
+    }
+    printTxLogs(signature) {
+        this.connection.printTxLogs(signature);
+    }
+    async moveTimeForward(increment) {
+        const currentClock = await this.context.banksClient.getClock();
+        const newUnixTimestamp = currentClock.unixTimestamp + BigInt(increment);
+        const newClock = new solana_bankrun_1.Clock(currentClock.slot, currentClock.epochStartTimestamp, currentClock.epoch, currentClock.leaderScheduleEpoch, newUnixTimestamp);
+        await this.context.setClock(newClock);
+    }
+}
+exports.BankrunContextWrapper = BankrunContextWrapper;
+class BankrunConnection {
+    constructor(banksClient, context) {
+        this.transactionToMeta = new Map();
+        this.nextClientSubscriptionId = 0;
+        this.onLogCallbacks = new Map();
+        this.onAccountChangeCallbacks = new Map();
+        this._banksClient = banksClient;
+        this.context = context;
+    }
+    getSlot() {
+        return this._banksClient.getSlot();
+    }
+    toConnection() {
+        return this;
+    }
+    async getTokenAccount(publicKey) {
+        const info = await this.getAccountInfo(publicKey);
+        return (0, spl_token_1.unpackAccount)(publicKey, info, spl_token_1.TOKEN_PROGRAM_ID);
+    }
+    async getMultipleAccountsInfo(publicKeys, _commitmentOrConfig) {
+        const accountInfos = [];
+        for (const publicKey of publicKeys) {
+            const accountInfo = await this.getAccountInfo(publicKey);
+            accountInfos.push(accountInfo);
+        }
+        return accountInfos;
+    }
+    async getAccountInfo(publicKey) {
+        const parsedAccountInfo = await this.getParsedAccountInfo(publicKey);
+        return parsedAccountInfo ? parsedAccountInfo.value : null;
+    }
+    async getAccountInfoAndContext(publicKey, _commitment) {
+        return await this.getParsedAccountInfo(publicKey);
+    }
+    async sendRawTransaction(rawTransaction, 
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    _options) {
+        const tx = web3_js_1.Transaction.from(rawTransaction);
+        const signature = await this.sendTransaction(tx);
+        return signature;
+    }
+    async sendTransaction(tx) {
+        const banksTransactionMeta = await this._banksClient.tryProcessTransaction(tx);
+        if (banksTransactionMeta.result) {
+            throw new Error(banksTransactionMeta.result);
+        }
+        const signature = bs58_1.default.encode(tx.signatures[0].signature);
+        this.transactionToMeta.set(signature, banksTransactionMeta);
+        let finalizedCount = 0;
+        while (finalizedCount < 10) {
+            const signatureStatus = (await this.getSignatureStatus(signature)).value
+                .confirmationStatus;
+            if (signatureStatus.toString() == '"finalized"') {
+                finalizedCount += 1;
+            }
+        }
+        // update the clock slot/timestamp
+        // sometimes race condition causes failures so we retry
+        try {
+            await this.updateSlotAndClock();
+        }
+        catch (e) {
+            await this.updateSlotAndClock();
+        }
+        if (this.onLogCallbacks.size > 0) {
+            const transaction = await this.getTransaction(signature);
+            const context = { slot: transaction.slot };
+            const logs = {
+                logs: transaction.meta.logMessages,
+                err: transaction.meta.err,
+                signature,
+            };
+            for (const logCallback of this.onLogCallbacks.values()) {
+                logCallback(logs, context);
+            }
+        }
+        for (const [publicKey, callback,] of this.onAccountChangeCallbacks.values()) {
+            const accountInfo = await this.getParsedAccountInfo(publicKey);
+            callback(accountInfo.value, accountInfo.context);
+        }
+        return signature;
+    }
+    async updateSlotAndClock() {
+        const currentSlot = await this.getSlot();
+        const nextSlot = currentSlot + BigInt(1);
+        this.context.warpToSlot(nextSlot);
+        const currentClock = await this._banksClient.getClock();
+        const newClock = new solana_bankrun_1.Clock(nextSlot, currentClock.epochStartTimestamp, currentClock.epoch, currentClock.leaderScheduleEpoch, currentClock.unixTimestamp + BigInt(1));
+        this.context.setClock(newClock);
+        this.clock = newClock;
+    }
+    getTime() {
+        return Number(this.clock.unixTimestamp);
+    }
+    async getParsedAccountInfo(publicKey) {
+        const accountInfoBytes = await this._banksClient.getAccount(publicKey);
+        if (accountInfoBytes === null) {
+            return {
+                context: { slot: Number(await this._banksClient.getSlot()) },
+                value: null,
+            };
+        }
+        accountInfoBytes.data = Buffer.from(accountInfoBytes.data);
+        const accountInfoBuffer = accountInfoBytes;
+        return {
+            context: { slot: Number(await this._banksClient.getSlot()) },
+            value: accountInfoBuffer,
+        };
+    }
+    async getLatestBlockhash(commitment) {
+        const blockhashAndBlockheight = await this._banksClient.getLatestBlockhash(commitment);
+        return {
+            blockhash: blockhashAndBlockheight[0],
+            lastValidBlockHeight: Number(blockhashAndBlockheight[1]),
+        };
+    }
+    async getSignatureStatus(signature, _config) {
+        const transactionStatus = await this._banksClient.getTransactionStatus(signature);
+        if (transactionStatus === null) {
+            return {
+                context: { slot: Number(await this._banksClient.getSlot()) },
+                value: null,
+            };
+        }
+        return {
+            context: { slot: Number(await this._banksClient.getSlot()) },
+            value: {
+                slot: Number(transactionStatus.slot),
+                confirmations: Number(transactionStatus.confirmations),
+                err: transactionStatus.err,
+                confirmationStatus: transactionStatus.confirmationStatus,
+            },
+        };
+    }
+    /**
+     * There's really no direct equivalent to getTransaction exposed by SolanaProgramTest, so we do the best that we can here - it's a little hacky.
+     */
+    async getTransaction(signature, _rawConfig) {
+        const txMeta = this.transactionToMeta.get(signature);
+        if (txMeta === undefined) {
+            return null;
+        }
+        const transactionStatus = await this._banksClient.getTransactionStatus(signature);
+        const meta = {
+            logMessages: txMeta.meta.logMessages,
+            err: txMeta.result,
+        };
+        return {
+            slot: Number(transactionStatus.slot),
+            meta,
+        };
+    }
+    findComputeUnitConsumption(signature) {
+        const txMeta = this.transactionToMeta.get(signature);
+        if (txMeta === undefined) {
+            throw new Error('Transaction not found');
+        }
+        return txMeta.meta.computeUnitsConsumed;
+    }
+    printTxLogs(signature) {
+        const txMeta = this.transactionToMeta.get(signature);
+        if (txMeta === undefined) {
+            throw new Error('Transaction not found');
+        }
+        console.log(txMeta.meta.logMessages);
+    }
+    async simulateTransaction(transaction, _config) {
+        var _a, _b, _c, _d;
+        const simulationResult = await this._banksClient.simulateTransaction(transaction);
+        const returnDataProgramId = (_b = (_a = simulationResult.meta) === null || _a === void 0 ? void 0 : _a.returnData) === null || _b === void 0 ? void 0 : _b.programId.toBase58();
+        const returnDataNormalized = Buffer.from((_d = (_c = simulationResult.meta) === null || _c === void 0 ? void 0 : _c.returnData) === null || _d === void 0 ? void 0 : _d.data).toString('base64');
+        const returnData = {
+            programId: returnDataProgramId,
+            data: [returnDataNormalized, 'base64'],
+        };
+        return {
+            context: { slot: Number(await this._banksClient.getSlot()) },
+            value: {
+                err: simulationResult.result,
+                logs: simulationResult.meta.logMessages,
+                accounts: undefined,
+                unitsConsumed: Number(simulationResult.meta.computeUnitsConsumed),
+                returnData,
+            },
+        };
+    }
+    onSignature(signature, callback, commitment) {
+        const txMeta = this.transactionToMeta.get(signature);
+        this._banksClient.getSlot(commitment).then((slot) => {
+            if (txMeta) {
+                callback({ err: txMeta.result }, { slot: Number(slot) });
+            }
+        });
+        return 0;
+    }
+    async removeSignatureListener(_clientSubscriptionId) {
+        // Nothing actually has to happen here! Pretty cool, huh?
+        // This function signature only exists to match the web3js interface
+    }
+    onLogs(filter, callback, _commitment) {
+        const subscriptId = this.nextClientSubscriptionId;
+        this.onLogCallbacks.set(subscriptId, callback);
+        this.nextClientSubscriptionId += 1;
+        return subscriptId;
+    }
+    async removeOnLogsListener(clientSubscriptionId) {
+        this.onLogCallbacks.delete(clientSubscriptionId);
+    }
+    onAccountChange(publicKey, callback, 
+    // @ts-ignore
+    _commitment) {
+        const subscriptId = this.nextClientSubscriptionId;
+        this.onAccountChangeCallbacks.set(subscriptId, [publicKey, callback]);
+        this.nextClientSubscriptionId += 1;
+        return subscriptId;
+    }
+    async removeAccountChangeListener(clientSubscriptionId) {
+        this.onAccountChangeCallbacks.delete(clientSubscriptionId);
+    }
+    async getMinimumBalanceForRentExemption(_) {
+        return 10 * web3_js_1.LAMPORTS_PER_SOL;
+    }
+}
+exports.BankrunConnection = BankrunConnection;
+function asBN(value) {
+    return new anchor_1.BN(Number(value));
+}
+exports.asBN = asBN;

package/lib/constants/perpMarkets.js

@@ -586,6 +586,16 @@ exports.MainnetPerpMarkets = [
         launchTs: 1718021389000,
         oracleSource: __1.OracleSource.SWITCHBOARD,
     },
+    {
+        fullName: 'ZEX',
+        category: ['DEX', 'Solana'],
+        symbol: 'ZEX-PERP',
+        baseAssetSymbol: 'ZEX',
+        marketIndex: 33,
+        oracle: new web3_js_1.PublicKey('5P3hx3t85eZucSqzXF4KfqbeENx1hNGPbAbGDYxTTvqs'),
+        launchTs: 1719415157000,
+        oracleSource: __1.OracleSource.Prelaunch,
+    },
 ];
 exports.PerpMarkets = {
     devnet: exports.DevnetPerpMarkets,

package/lib/constants/spotMarkets.js

@@ -238,6 +238,16 @@ exports.MainnetSpotMarkets = [
         precisionExp: numericConstants_1.SIX,
         launchTs: 1718811089000,
     },
+    {
+        symbol: 'JLP',
+        marketIndex: 19,
+        oracle: new web3_js_1.PublicKey('HR1mmjm2GeTRvdaN9VCy3wyx35h8Pimjv5wyzZ5NJmxE'),
+        oracleSource: __1.OracleSource.SWITCHBOARD,
+        mint: new web3_js_1.PublicKey('27G8MtK7VtTcCHkpASjSDdkWWYfoqT6ggEuKidVJidD4'),
+        precision: new __1.BN(10).pow(numericConstants_1.SIX),
+        precisionExp: numericConstants_1.SIX,
+        launchTs: 1719415157000,
+    },
 ];
 exports.SpotMarkets = {
     devnet: exports.DevnetSpotMarkets,

package/lib/events/eventSubscriber.js

@@ -24,10 +24,14 @@ class EventSubscriber {
         this.eventListMap = new Map();
         this.eventEmitter = new events_1.EventEmitter();
         if (this.options.logProviderConfig.type === 'websocket') {
-            this.logProvider = new webSocketLogProvider_1.WebSocketLogProvider(this.connection, this.address, this.options.commitment, this.options.logProviderConfig.resubTimeoutMs);
+            this.logProvider = new webSocketLogProvider_1.WebSocketLogProvider(
+            // @ts-ignore
+            this.connection, this.address, this.options.commitment, this.options.logProviderConfig.resubTimeoutMs);
         }
         else {
-            this.logProvider = new pollingLogProvider_1.PollingLogProvider(this.connection, this.address, options.commitment, this.options.logProviderConfig.frequency, this.options.logProviderConfig.batchSize);
+            this.logProvider = new pollingLogProvider_1.PollingLogProvider(
+            // @ts-ignore
+            this.connection, this.address, options.commitment, this.options.logProviderConfig.frequency, this.options.logProviderConfig.batchSize);
         }
     }
     populateInitialEventListMap() {
@@ -52,7 +56,9 @@ class EventSubscriber {
                                 console.log('Failing over to polling');
                                 this.logProvider.eventEmitter.removeAllListeners('reconnect');
                                 this.unsubscribe().then(() => {
-                                    this.logProvider = new pollingLogProvider_1.PollingLogProvider(this.connection, this.address, this.options.commitment, logProviderConfig.fallbackFrequency, logProviderConfig.fallbackBatchSize);
+                                    this.logProvider = new pollingLogProvider_1.PollingLogProvider(
+                                    // @ts-ignore
+                                    this.connection, this.address, this.options.commitment, logProviderConfig.fallbackFrequency, logProviderConfig.fallbackBatchSize);
                                     this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime) => {
                                         this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime);
                                     }, true);
@@ -108,7 +114,9 @@ class EventSubscriber {
         let beforeTx = undefined;
         const untilTx = this.options.untilTx;
         while (txFetched < this.options.maxTx) {
-            const response = await (0, fetchLogs_1.fetchLogs)(this.connection, this.address, this.options.commitment === 'finalized' ? 'finalized' : 'confirmed', beforeTx, untilTx);
+            const response = await (0, fetchLogs_1.fetchLogs)(
+            // @ts-ignore
+            this.connection, this.address, this.options.commitment === 'finalized' ? 'finalized' : 'confirmed', beforeTx, untilTx);
             if (response === undefined) {
                 break;
             }