@drift-labs/sdk 2.96.0-beta.9 → 2.97.0-beta.1

package/lib/util/TransactionConfirmationManager.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionConfirmationManager = void 0;
+const config_1 = require("../config");
+const __1 = require("..");
+const txConstants_1 = require("../constants/txConstants");
+const reportTransactionError_1 = require("../tx/reportTransactionError");
+const promiseTimeout_1 = require("./promiseTimeout");
+const confirmationStatusValues = {
+    processed: 0,
+    confirmed: 1,
+    finalized: 2,
+};
+/**
+ * Class to await for transaction confirmations in an optimised manner. It tracks a shared list of all pending transactions and fetches them in bulk in a shared RPC request whenever they have an "overlapping" polling interval. E.g. tx1 with an interval of 200ms and tx2 with an interval of 300ms (if sent at the same time) will be fetched together at at 600ms, 1200ms, 1800ms, etc.
+ */
+class TransactionConfirmationManager {
+    constructor(connection) {
+        this.pendingConfirmations = new Map();
+        this.intervalId = null;
+        this.connection = connection;
+    }
+    async confirmTransactionWebSocket(txSig, timeout = 30000, desiredConfirmationStatus = config_1.DEFAULT_CONFIRMATION_OPTS.commitment) {
+        const start = Date.now();
+        const subscriptionCommitment = desiredConfirmationStatus || config_1.DEFAULT_CONFIRMATION_OPTS.commitment;
+        let response = null;
+        let subscriptionId;
+        const confirmationPromise = new Promise((resolve, reject) => {
+            try {
+                subscriptionId = this.connection.onSignature(txSig, (result, context) => {
+                    response = {
+                        context,
+                        value: result,
+                    };
+                    resolve(null);
+                }, subscriptionCommitment);
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+        // We do a one-shot confirmation check just in case the transaction is ALREADY confirmed when we create the websocket confirmation .. We want to run this concurrently with the onSignature subscription. If this returns true then we can return early as the transaction has already been confirmed.
+        const oneShotConfirmationPromise = this.connection.getSignatureStatuses([
+            txSig,
+        ]);
+        const resolveReference = {};
+        // This is the promise we are waiting on to resolve the overall confirmation. It will resolve the faster of a positive oneShot confirmation, or the websocket confirmation, or the timeout.
+        const overallWaitingForConfirmationPromise = new Promise((resolve) => {
+            resolveReference.resolve = resolve;
+        });
+        // Await for the one shot confirmation and resolve the waiting promise if we get a positive confirmation result
+        oneShotConfirmationPromise.then(async (oneShotResponse) => {
+            var _a, _b;
+            if (!oneShotResponse || !((_a = oneShotResponse === null || oneShotResponse === void 0 ? void 0 : oneShotResponse.value) === null || _a === void 0 ? void 0 : _a[0]))
+                return;
+            const resultValue = oneShotResponse.value[0];
+            if (resultValue.err) {
+                await (0, reportTransactionError_1.throwTransactionError)(txSig, this.connection);
+            }
+            if (this.checkStatusMatchesDesiredConfirmationStatus(resultValue, desiredConfirmationStatus)) {
+                response = {
+                    context: oneShotResponse.context,
+                    value: oneShotResponse.value[0],
+                };
+                (_b = resolveReference.resolve) === null || _b === void 0 ? void 0 : _b.call(resolveReference);
+            }
+        }, (onRejected) => {
+            throw onRejected;
+        });
+        // Await for the websocket confirmation with the configured timeout
+        (0, promiseTimeout_1.promiseTimeout)(confirmationPromise, timeout).then(() => {
+            var _a;
+            (_a = resolveReference.resolve) === null || _a === void 0 ? void 0 : _a.call(resolveReference);
+        }, (onRejected) => {
+            throw onRejected;
+        });
+        try {
+            await overallWaitingForConfirmationPromise;
+        }
+        finally {
+            if (subscriptionId !== undefined) {
+                this.connection.removeSignatureListener(subscriptionId);
+            }
+        }
+        const duration = (Date.now() - start) / 1000;
+        if (response === null) {
+            throw new __1.TxSendError(`Transaction was not confirmed in ${duration.toFixed(2)} seconds. It is unknown if it succeeded or failed. Check signature ${txSig} using the Solana Explorer or CLI tools.`, txConstants_1.NOT_CONFIRMED_ERROR_CODE);
+        }
+        return response;
+    }
+    async confirmTransactionPolling(txSig, desiredConfirmationStatus = config_1.DEFAULT_CONFIRMATION_OPTS.commitment, timeout = 30000, pollInterval = 1000, searchTransactionHistory = false) {
+        // Interval must be > 400ms and a multiple of 100ms
+        if (pollInterval < 400 || pollInterval % 100 !== 0) {
+            throw new Error('Transaction confirmation polling interval must be at least 400ms and a multiple of 100ms');
+        }
+        return new Promise((resolve, reject) => {
+            this.pendingConfirmations.set(txSig, {
+                txSig,
+                desiredConfirmationStatus,
+                timeout,
+                pollInterval,
+                searchTransactionHistory,
+                startTime: Date.now(),
+                resolve,
+                reject,
+            });
+            if (!this.intervalId) {
+                this.startConfirmationLoop();
+            }
+        });
+    }
+    startConfirmationLoop() {
+        this.intervalId = setInterval(() => this.checkPendingConfirmations(), 100);
+    }
+    async checkPendingConfirmations() {
+        const now = Date.now();
+        const transactionsToCheck = [];
+        for (const [txSig, request] of this.pendingConfirmations.entries()) {
+            if (now - request.startTime >= request.timeout) {
+                request.reject(new Error(`Transaction confirmation timeout after ${request.timeout}ms`));
+                this.pendingConfirmations.delete(txSig);
+            }
+            else if ((now - request.startTime) % request.pollInterval < 100) {
+                transactionsToCheck.push(request);
+            }
+        }
+        if (transactionsToCheck.length > 0) {
+            await this.checkTransactionStatuses(transactionsToCheck);
+        }
+        if (this.pendingConfirmations.size === 0 && this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    checkStatusMatchesDesiredConfirmationStatus(status, desiredConfirmationStatus) {
+        if (status.confirmationStatus &&
+            confirmationStatusValues[status.confirmationStatus] >=
+                confirmationStatusValues[desiredConfirmationStatus]) {
+            return true;
+        }
+        return false;
+    }
+    async checkTransactionStatuses(requests) {
+        const txSigs = requests.map((request) => request.txSig);
+        const { value: statuses } = await this.connection.getSignatureStatuses(txSigs, {
+            searchTransactionHistory: requests.some((req) => req.searchTransactionHistory),
+        });
+        if (!statuses || statuses.length !== txSigs.length) {
+            throw new Error('Failed to get signature statuses');
+        }
+        for (let i = 0; i < statuses.length; i++) {
+            const status = statuses[i];
+            const request = requests[i];
+            if (status === null) {
+                continue;
+            }
+            if (status.err) {
+                this.pendingConfirmations.delete(request.txSig);
+                request.reject(await (0, reportTransactionError_1.getTransactionErrorFromTxSig)(request.txSig, this.connection));
+                continue;
+            }
+            if (confirmationStatusValues[status.confirmationStatus] === undefined ||
+                confirmationStatusValues[request.desiredConfirmationStatus] ===
+                    undefined) {
+                throw new Error(`Invalid confirmation status when awaiting confirmation: ${status.confirmationStatus}`);
+            }
+            if (this.checkStatusMatchesDesiredConfirmationStatus(status, request.desiredConfirmationStatus)) {
+                request.resolve(status);
+                this.pendingConfirmations.delete(request.txSig);
+            }
+        }
+    }
+}
+exports.TransactionConfirmationManager = TransactionConfirmationManager;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.96.0-beta.9",
+	"version": "2.97.0-beta.1",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -37,14 +37,14 @@
 		"@coral-xyz/anchor": "0.28.0",
 		"@coral-xyz/anchor-30": "npm:@coral-xyz/anchor@0.30.1",
 		"@ellipsis-labs/phoenix-sdk": "^1.4.2",
-		"@openbook-dex/openbook-v2": "^0.2.10",
+		"@openbook-dex/openbook-v2": "0.2.10",
 		"@project-serum/serum": "^0.13.38",
 		"@pythnetwork/client": "2.5.3",
 		"@pythnetwork/price-service-sdk": "^1.7.1",
 		"@pythnetwork/pyth-solana-receiver": "^0.7.0",
 		"@solana/spl-token": "0.3.7",
 		"@solana/web3.js": "1.92.3",
-		"@switchboard-xyz/on-demand": "1.2.32",
+		"@switchboard-xyz/on-demand": "1.2.42",
 		"anchor-bankrun": "^0.3.0",
 		"node-cache": "^5.1.2",
 		"rpc-websockets": "7.5.1",
@@ -56,6 +56,7 @@
 	"devDependencies": {
 		"@types/big.js": "^6.2.0",
 		"@types/bn.js": "^5.1.3",
+		"@types/bs58": "^4.0.4",
 		"@types/chai": "^4.3.1",
 		"@types/jest": "^28.1.3",
 		"@types/mocha": "^9.1.1",

package/src/accounts/pollingDriftClientAccountSubscriber.ts

@@ -1,6 +1,7 @@
 import {
-	DataAndSlot,
 	AccountToPoll,
+	DataAndSlot,
+	DelistedMarketSetting,
 	DriftClientAccountEvents,
 	DriftClientAccountSubscriber,
 	NotSubscribedError,
@@ -10,18 +11,18 @@ import { Program } from '@coral-xyz/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import {
-	SpotMarketAccount,
 	PerpMarketAccount,
+	SpotMarketAccount,
 	StateAccount,
 	UserAccount,
 } from '../types';
 import {
 	getDriftStateAccountPublicKey,
-	getSpotMarketPublicKey,
 	getPerpMarketPublicKey,
+	getSpotMarketPublicKey,
 } from '../addresses/pda';
 import { BulkAccountLoader } from './bulkAccountLoader';
-import { capitalize } from './utils';
+import { capitalize, findDelistedPerpMarketsAndOracles } from './utils';
 import { PublicKey } from '@solana/web3.js';
 import { OracleInfo, OraclePriceData } from '../oracles/types';
 import { OracleClientCache } from '../oracles/oracleClientCache';
@@ -58,6 +59,7 @@ export class PollingDriftClientAccountSubscriber
 	spotOracleStringMap = new Map<number, string>();
 	oracles = new Map<string, DataAndSlot<OraclePriceData>>();
 	user?: DataAndSlot<UserAccount>;
+	delistedMarketSetting: DelistedMarketSetting;
 
 	private isSubscribing = false;
 	private subscriptionPromise: Promise<boolean>;
@@ -69,7 +71,8 @@ export class PollingDriftClientAccountSubscriber
 		perpMarketIndexes: number[],
 		spotMarketIndexes: number[],
 		oracleInfos: OracleInfo[],
-		shouldFindAllMarketsAndOracles: boolean
+		shouldFindAllMarketsAndOracles: boolean,
+		delistedMarketSetting: DelistedMarketSetting
 	) {
 		this.isSubscribed = false;
 		this.program = program;
@@ -79,6 +82,7 @@ export class PollingDriftClientAccountSubscriber
 		this.spotMarketIndexes = spotMarketIndexes;
 		this.oracleInfos = oracleInfos;
 		this.shouldFindAllMarketsAndOracles = shouldFindAllMarketsAndOracles;
+		this.delistedMarketSetting = delistedMarketSetting;
 	}
 
 	public async subscribe(): Promise<boolean> {
@@ -120,6 +124,8 @@ export class PollingDriftClientAccountSubscriber
 			this.eventEmitter.emit('update');
 		}
 
+		this.handleDelistedMarkets();
+
 		await Promise.all([this.setPerpOracleMap(), this.setSpotOracleMap()]);
 
 		this.isSubscribing = false;
@@ -500,6 +506,36 @@ export class PollingDriftClientAccountSubscriber
 		await Promise.all(oraclePromises);
 	}
 
+	handleDelistedMarkets(): void {
+		if (this.delistedMarketSetting === DelistedMarketSetting.Subscribe) {
+			return;
+		}
+
+		const { perpMarketIndexes, oracles } = findDelistedPerpMarketsAndOracles(
+			this.getMarketAccountsAndSlots(),
+			this.getSpotMarketAccountsAndSlots()
+		);
+
+		for (const perpMarketIndex of perpMarketIndexes) {
+			const perpMarketPubkey = this.perpMarket.get(perpMarketIndex).data.pubkey;
+			const callbackId = this.accountsToPoll.get(
+				perpMarketPubkey.toBase58()
+			).callbackId;
+			this.accountLoader.removeAccount(perpMarketPubkey, callbackId);
+			if (this.delistedMarketSetting === DelistedMarketSetting.Discard) {
+				this.perpMarket.delete(perpMarketIndex);
+			}
+		}
+
+		for (const oracle of oracles) {
+			const callbackId = this.oraclesToPoll.get(oracle.toBase58()).callbackId;
+			this.accountLoader.removeAccount(oracle, callbackId);
+			if (this.delistedMarketSetting === DelistedMarketSetting.Discard) {
+				this.oracles.delete(oracle.toBase58());
+			}
+		}
+	}
+
 	assertIsSubscribed(): void {
 		if (!this.isSubscribed) {
 			throw new NotSubscribedError(

package/src/accounts/types.ts

@@ -84,6 +84,12 @@ export interface DriftClientAccountSubscriber {
 	updateAccountLoaderPollingFrequency?: (pollingFrequency: number) => void;
 }
 
+export enum DelistedMarketSetting {
+	Unsubscribe,
+	Subscribe,
+	Discard,
+}
+
 export interface UserAccountEvents {
 	userAccountUpdate: (payload: UserAccount) => void;
 	update: void;

package/src/accounts/utils.ts

@@ -1,3 +1,45 @@
+import { PublicKey } from '@solana/web3.js';
+import { DataAndSlot } from './types';
+import { isVariant, PerpMarketAccount, SpotMarketAccount } from '../types';
+
 export function capitalize(value: string): string {
 	return value[0].toUpperCase() + value.slice(1);
 }
+
+export function findDelistedPerpMarketsAndOracles(
+	perpMarkets: DataAndSlot<PerpMarketAccount>[],
+	spotMarkets: DataAndSlot<SpotMarketAccount>[]
+): { perpMarketIndexes: number[]; oracles: PublicKey[] } {
+	const delistedPerpMarketIndexes = [];
+	const delistedOracles = [];
+	for (const perpMarket of perpMarkets) {
+		if (!perpMarket.data) {
+			continue;
+		}
+
+		if (isVariant(perpMarket.data.status, 'delisted')) {
+			delistedPerpMarketIndexes.push(perpMarket.data.marketIndex);
+			delistedOracles.push(perpMarket.data.amm.oracle);
+		}
+	}
+
+	// make sure oracle isn't used by spot market
+	const filteredDelistedOracles = [];
+	for (const delistedOracle of delistedOracles) {
+		for (const spotMarket of spotMarkets) {
+			if (!spotMarket.data) {
+				continue;
+			}
+
+			if (spotMarket.data.oracle.equals(delistedOracle)) {
+				break;
+			}
+		}
+		filteredDelistedOracles.push(delistedOracle);
+	}
+
+	return {
+		perpMarketIndexes: delistedPerpMarketIndexes,
+		oracles: filteredDelistedOracles,
+	};
+}

package/src/accounts/webSocketDriftClientAccountSubscriber.ts

@@ -1,19 +1,21 @@
 import {
-	DriftClientAccountSubscriber,
-	DriftClientAccountEvents,
+	AccountSubscriber,
 	DataAndSlot,
+	DelistedMarketSetting,
+	DriftClientAccountEvents,
+	DriftClientAccountSubscriber,
+	NotSubscribedError,
 	ResubOpts,
 } from './types';
-import { AccountSubscriber, NotSubscribedError } from './types';
-import { SpotMarketAccount, PerpMarketAccount, StateAccount } from '../types';
+import { PerpMarketAccount, SpotMarketAccount, StateAccount } from '../types';
 import { Program } from '@coral-xyz/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import {
 	getDriftStateAccountPublicKey,
-	getSpotMarketPublicKey,
 	getPerpMarketPublicKey,
 	getPerpMarketPublicKeySync,
+	getSpotMarketPublicKey,
 	getSpotMarketPublicKeySync,
 } from '../addresses/pda';
 import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
@@ -23,6 +25,7 @@ import { OracleClientCache } from '../oracles/oracleClientCache';
 import * as Buffer from 'buffer';
 import { QUOTE_ORACLE_PRICE_DATA } from '../oracles/quoteAssetOracleClient';
 import { findAllMarketAndOracles } from '../config';
+import { findDelistedPerpMarketsAndOracles } from './utils';
 
 const ORACLE_DEFAULT_KEY = PublicKey.default.toBase58();
 
@@ -55,6 +58,7 @@ export class WebSocketDriftClientAccountSubscriber
 	spotOracleMap = new Map<number, PublicKey>();
 	spotOracleStringMap = new Map<number, string>();
 	oracleSubscribers = new Map<string, AccountSubscriber<OraclePriceData>>();
+	delistedMarketSetting: DelistedMarketSetting;
 
 	initialPerpMarketAccountData: Map<number, PerpMarketAccount>;
 	initialSpotMarketAccountData: Map<number, SpotMarketAccount>;
@@ -70,6 +74,7 @@ export class WebSocketDriftClientAccountSubscriber
 		spotMarketIndexes: number[],
 		oracleInfos: OracleInfo[],
 		shouldFindAllMarketsAndOracles: boolean,
+		delistedMarketSetting: DelistedMarketSetting,
 		resubOpts?: ResubOpts,
 		commitment?: Commitment
 	) {
@@ -80,6 +85,7 @@ export class WebSocketDriftClientAccountSubscriber
 		this.spotMarketIndexes = spotMarketIndexes;
 		this.oracleInfos = oracleInfos;
 		this.shouldFindAllMarketsAndOracles = shouldFindAllMarketsAndOracles;
+		this.delistedMarketSetting = delistedMarketSetting;
 		this.resubOpts = resubOpts;
 		this.commitment = commitment;
 	}
@@ -151,6 +157,8 @@ export class WebSocketDriftClientAccountSubscriber
 
 		this.eventEmitter.emit('update');
 
+		await this.handleDelistedMarkets();
+
 		await Promise.all([this.setPerpOracleMap(), this.setSpotOracleMap()]);
 
 		this.isSubscribing = false;
@@ -480,6 +488,33 @@ export class WebSocketDriftClientAccountSubscriber
 		await Promise.all(addOraclePromises);
 	}
 
+	async handleDelistedMarkets(): Promise<void> {
+		if (this.delistedMarketSetting === DelistedMarketSetting.Subscribe) {
+			return;
+		}
+
+		const { perpMarketIndexes, oracles } = findDelistedPerpMarketsAndOracles(
+			this.getMarketAccountsAndSlots(),
+			this.getSpotMarketAccountsAndSlots()
+		);
+
+		for (const perpMarketIndex of perpMarketIndexes) {
+			await this.perpMarketAccountSubscribers
+				.get(perpMarketIndex)
+				.unsubscribe();
+			if (this.delistedMarketSetting === DelistedMarketSetting.Discard) {
+				this.perpMarketAccountSubscribers.delete(perpMarketIndex);
+			}
+		}
+
+		for (const oracle of oracles) {
+			await this.oracleSubscribers.get(oracle.toBase58()).unsubscribe();
+			if (this.delistedMarketSetting === DelistedMarketSetting.Discard) {
+				this.oracleSubscribers.delete(oracle.toBase58());
+			}
+		}
+	}
+
 	assertIsSubscribed(): void {
 		if (!this.isSubscribed) {
 			throw new NotSubscribedError(

package/src/config.ts

@@ -1,4 +1,5 @@
-import { PerpMarketAccount, SpotMarketAccount } from '.';
+import { ConfirmOptions } from '@solana/web3.js';
+import { PerpMarketAccount, PublicKey, SpotMarketAccount } from '.';
 import {
 	DevnetPerpMarkets,
 	MainnetPerpMarkets,
@@ -13,6 +14,10 @@ import {
 } from './constants/spotMarkets';
 import { OracleInfo } from './oracles/types';
 import { Program, ProgramAccount } from '@coral-xyz/anchor';
+import {
+	ON_DEMAND_DEVNET_PID,
+	ON_DEMAND_MAINNET_PID,
+} from '@switchboard-xyz/on-demand';
 
 type DriftConfig = {
 	ENV: DriftEnv;
@@ -30,6 +35,7 @@ type DriftConfig = {
 	MARKET_LOOKUP_TABLE: string;
 	SERUM_LOOKUP_TABLE?: string;
 	PYTH_PULL_ORACLE_LOOKUP_TABLE?: string;
+	SB_ON_DEMAND_PID: PublicKey;
 };
 
 export type DriftEnv = 'devnet' | 'mainnet-beta';
@@ -37,6 +43,14 @@ export type DriftEnv = 'devnet' | 'mainnet-beta';
 export const DRIFT_PROGRAM_ID = 'dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH';
 export const DRIFT_ORACLE_RECEIVER_ID =
 	'G6EoTTTgpkNBtVXo96EQp2m6uwwVh2Kt6YidjkmQqoha';
+export const SWIFT_ID = 'SW1fThqrxLzVprnCMpiybiqYQfoNCdduC5uWsSUKChS';
+export const ANCHOR_TEST_SWIFT_ID =
+	'DpaEdAPW3ZX67fnczT14AoX12Lx9VMkxvtT81nCHy3Nv';
+
+export const DEFAULT_CONFIRMATION_OPTS: ConfirmOptions = {
+	preflightCommitment: 'confirmed',
+	commitment: 'confirmed',
+};
 
 export const configs: { [key in DriftEnv]: DriftConfig } = {
 	devnet: {
@@ -54,6 +68,7 @@ export const configs: { [key in DriftEnv]: DriftConfig } = {
 		SPOT_MARKETS: DevnetSpotMarkets,
 		MARKET_LOOKUP_TABLE: 'FaMS3U4uBojvGn5FSDEPimddcXsCfwkKsFgMVVnDdxGb',
 		DRIFT_ORACLE_RECEIVER_ID,
+		SB_ON_DEMAND_PID: ON_DEMAND_DEVNET_PID,
 	},
 	'mainnet-beta': {
 		ENV: 'mainnet-beta',
@@ -71,6 +86,7 @@ export const configs: { [key in DriftEnv]: DriftConfig } = {
 		MARKET_LOOKUP_TABLE: 'D9cnvzswDikQDf53k4HpQ3KJ9y1Fv3HGGDFYMXnK5T6c',
 		SERUM_LOOKUP_TABLE: 'GPZkp76cJtNL2mphCvT6FXkJCVPpouidnacckR6rzKDN',
 		DRIFT_ORACLE_RECEIVER_ID,
+		SB_ON_DEMAND_PID: ON_DEMAND_MAINNET_PID,
 	},
 };
 

package/src/constants/perpMarkets.ts

@@ -297,7 +297,7 @@ export const DevnetPerpMarkets: PerpMarketConfig[] = [
 		symbol: 'W-PERP',
 		baseAssetSymbol: 'W',
 		marketIndex: 23,
-		oracle: new PublicKey('4iCi4DvXrubHQne8jzbMaWL3pd7v1Fip8iTe4H9vHNXB'),
+		oracle: new PublicKey('J9nrFWjDUeDVZ4BhhxsbQXWgLcLEgQyNBrCbwSADmJdr'),
 		launchTs: 1709852537000,
 		oracleSource: OracleSource.SWITCHBOARD_ON_DEMAND,
 		pythFeedId:
@@ -862,6 +862,40 @@ export const MainnetPerpMarkets: PerpMarketConfig[] = [
 		launchTs: 1726646453000,
 		oracleSource: OracleSource.Prelaunch,
 	},
+	{
+		fullName: 'MOTHER',
+		category: ['Solana', 'Meme'],
+		symbol: 'MOTHER-PERP',
+		baseAssetSymbol: 'MOTHER',
+		marketIndex: 44,
+		oracle: new PublicKey('56ap2coZG7FPWUigVm9XrpQs3xuCwnwQaWtjWZcffEUG'),
+		launchTs: 1727291859000,
+		oracleSource: OracleSource.PYTH_PULL,
+		pythFeedId:
+			'0x62742a997d01f7524f791fdb2dd43aaf0e567d765ebf8fd0406a994239e874d4',
+	},
+	{
+		fullName: 'MOODENG',
+		category: ['Solana', 'Meme'],
+		symbol: 'MOODENG-PERP',
+		baseAssetSymbol: 'MOODENG',
+		marketIndex: 45,
+		oracle: new PublicKey('21gjgEcuDppthwV16J1QpFzje3vmgMp2uSzh7pJsG7ob'),
+		launchTs: 1727965864000,
+		oracleSource: OracleSource.PYTH_PULL,
+		pythFeedId:
+			'0xffff73128917a90950cd0473fd2551d7cd274fd5a6cc45641881bbcc6ee73417',
+	},
+	{
+		fullName: 'WARWICK-FIGHT-WIN-BET',
+		category: ['Prediction', 'Sport'],
+		symbol: 'WARWICK-FIGHT-WIN-BET',
+		baseAssetSymbol: 'WARWICK-FIGHT-WIN',
+		marketIndex: 46,
+		oracle: new PublicKey('Dz5Nvxo1hv7Zfyu11hy8e97twLMRKk6heTWCDGXytj7N'),
+		launchTs: 1727965864000,
+		oracleSource: OracleSource.Prelaunch,
+	},
 ];
 
 export const PerpMarkets: { [key in DriftEnv]: PerpMarketConfig[] } = {

package/src/constants/spotMarkets.ts

@@ -425,6 +425,17 @@ export const MainnetSpotMarkets: SpotMarketConfig[] = [
 		pythFeedId:
 			'0xef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d',
 	},
+	{
+		symbol: 'MOTHER',
+		marketIndex: 26,
+		oracle: new PublicKey('56ap2coZG7FPWUigVm9XrpQs3xuCwnwQaWtjWZcffEUG'),
+		oracleSource: OracleSource.PYTH_PULL,
+		mint: new PublicKey('3S8qX1MsMqRbiwKg2cQyx7nis1oHMgaCuc9c4VfvVdPN'),
+		precision: new BN(10).pow(SIX),
+		precisionExp: SIX,
+		pythFeedId:
+			'0x62742a997d01f7524f791fdb2dd43aaf0e567d765ebf8fd0406a994239e874d4',
+	},
 ];
 
 export const SpotMarkets: { [key in DriftEnv]: SpotMarketConfig[] } = {

package/src/constants/txConstants.ts

@@ -0,0 +1 @@
+export const NOT_CONFIRMED_ERROR_CODE = -1001;