@drift-labs/sdk 2.84.0-beta.5 → 2.84.0-beta.7

package/src/factory/oracleClient.ts

@@ -7,6 +7,7 @@ import { QuoteAssetOracleClient } from '../oracles/quoteAssetOracleClient';
 import { BN, Program } from '@coral-xyz/anchor';
 import { PrelaunchOracleClient } from '../oracles/prelaunchOracleClient';
 import { SwitchboardClient } from '../oracles/switchboardClient';
+import { PythPullClient } from '../oracles/pythPullClient';
 
 export function getOracleClient(
 	oracleSource: OracleSource,
@@ -17,18 +18,34 @@ export function getOracleClient(
 		return new PythClient(connection);
 	}
 
+	if (isVariant(oracleSource, 'pythPull')) {
+		return new PythPullClient(connection);
+	}
+
 	if (isVariant(oracleSource, 'pyth1K')) {
 		return new PythClient(connection, new BN(1000));
 	}
 
+	if (isVariant(oracleSource, 'pyth1KPull')) {
+		return new PythPullClient(connection, new BN(1000));
+	}
+
 	if (isVariant(oracleSource, 'pyth1M')) {
 		return new PythClient(connection, new BN(1000000));
 	}
 
+	if (isVariant(oracleSource, 'pyth1MPull')) {
+		return new PythPullClient(connection, new BN(1000000));
+	}
+
 	if (isVariant(oracleSource, 'pythStableCoin')) {
 		return new PythClient(connection, undefined, true);
 	}
 
+	if (isVariant(oracleSource, 'pythStableCoinPull')) {
+		return new PythPullClient(connection, undefined, true);
+	}
+
 	if (isVariant(oracleSource, 'switchboard')) {
 		return new SwitchboardClient(connection);
 	}

package/src/idl/drift.json

@@ -9254,6 +9254,18 @@
           },
           {
             "name": "Prelaunch"
+          },
+          {
+            "name": "PythPull"
+          },
+          {
+            "name": "Pyth1KPull"
+          },
+          {
+            "name": "Pyth1MPull"
+          },
+          {
+            "name": "PythStableCoinPull"
           }
         ]
       }
@@ -11992,6 +12004,11 @@
       "code": 6266,
       "name": "OracleStaleForAMM",
       "msg": "OracleStaleForAMM"
+    },
+    {
+      "code": 6267,
+      "name": "UnableToParsePullOracleMessage",
+      "msg": "Unable to parse pull oracle message"
     }
   ]
 }

package/src/math/spotBalance.ts

@@ -363,6 +363,17 @@ export function calculateSpotMarketBorrowCapacity(
 		remainingCapacity = BN.max(ZERO, totalCapacity.sub(tokenBorrowAmount));
 	}
 
+	if (spotMarketAccount.maxTokenBorrowsFraction > 0) {
+		const maxTokenBorrows = spotMarketAccount.maxTokenDeposits
+			.mul(new BN(spotMarketAccount.maxTokenBorrowsFraction))
+			.divn(10000);
+
+		remainingCapacity = BN.min(
+			remainingCapacity,
+			BN.max(ZERO, maxTokenBorrows.sub(tokenBorrowAmount))
+		);
+	}
+
 	return { totalCapacity, remainingCapacity };
 }
 
@@ -395,7 +406,10 @@ export function calculateInterestRate(
 			.div(SPOT_MARKET_UTILIZATION_PRECISION);
 	}
 
-	return interestRate;
+	return BN.max(
+		interestRate,
+		new BN(bank.minBorrowRate).mul(PERCENTAGE_PRECISION.divn(200))
+	);
 }
 
 export function calculateDepositRate(

package/src/oracles/pythPullClient.ts

@@ -0,0 +1,112 @@
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { AnchorProvider, BN, Program } from '@coral-xyz/anchor';
+import {
+	ONE,
+	PRICE_PRECISION,
+	QUOTE_PRECISION,
+	TEN,
+} from '../constants/numericConstants';
+import {
+	PythSolanaReceiverProgram,
+	DEFAULT_RECEIVER_PROGRAM_ID,
+	pythSolanaReceiverIdl,
+} from '@pythnetwork/pyth-solana-receiver';
+import { PriceUpdateAccount } from '@pythnetwork/pyth-solana-receiver/lib/PythSolanaReceiver';
+import { Wallet } from '..';
+
+export class PythPullClient implements OracleClient {
+	private connection: Connection;
+	private multiple: BN;
+	private stableCoin: boolean;
+	readonly receiver: Program<PythSolanaReceiverProgram>;
+	readonly decodeFunc: (name: string, data: Buffer) => PriceUpdateAccount;
+
+	public constructor(
+		connection: Connection,
+		multiple = ONE,
+		stableCoin = false
+	) {
+		this.connection = connection;
+		this.multiple = multiple;
+		this.stableCoin = stableCoin;
+		const provider = new AnchorProvider(
+			this.connection,
+			//@ts-ignore
+			new Wallet(new Keypair()),
+			{
+				commitment: connection.commitment,
+			}
+		);
+		this.receiver = new Program<PythSolanaReceiverProgram>(
+			pythSolanaReceiverIdl as PythSolanaReceiverProgram,
+			DEFAULT_RECEIVER_PROGRAM_ID,
+			provider
+		);
+		this.decodeFunc =
+			this.receiver.account.priceUpdateV2.coder.accounts.decodeUnchecked.bind(
+				this.receiver.account.priceUpdateV2.coder.accounts
+			);
+	}
+
+	public async getOraclePriceData(
+		pricePublicKey: PublicKey
+	): Promise<OraclePriceData> {
+		const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
+		return this.getOraclePriceDataFromBuffer(accountInfo.data);
+	}
+
+	public getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData {
+		const message = this.decodeFunc('priceUpdateV2', buffer);
+		const priceData = message.priceMessage;
+		const confidence = convertPythPrice(
+			priceData.conf,
+			priceData.exponent,
+			this.multiple
+		);
+		let price = convertPythPrice(
+			priceData.price,
+			priceData.exponent,
+			this.multiple
+		);
+		if (this.stableCoin) {
+			price = getStableCoinPrice(price, confidence);
+		}
+
+		return {
+			price,
+			slot: message.postedSlot,
+			confidence,
+			twap: convertPythPrice(
+				priceData.price,
+				priceData.exponent,
+				this.multiple
+			),
+			twapConfidence: convertPythPrice(
+				priceData.price,
+				priceData.exponent,
+				this.multiple
+			),
+			hasSufficientNumberOfDataPoints: true,
+		};
+	}
+}
+
+export function convertPythPrice(
+	price: BN,
+	exponent: number,
+	multiple: BN
+): BN {
+	exponent = Math.abs(exponent);
+	const pythPrecision = TEN.pow(new BN(exponent).abs()).div(multiple);
+	return price.mul(PRICE_PRECISION).div(pythPrecision);
+}
+
+const fiveBPS = new BN(500);
+function getStableCoinPrice(price: BN, confidence: BN): BN {
+	if (price.sub(QUOTE_PRECISION).abs().lt(BN.min(confidence, fiveBPS))) {
+		return QUOTE_PRECISION;
+	} else {
+		return price;
+	}
+}

package/src/tx/txHandler.ts

@@ -20,6 +20,7 @@ import {
 	BaseTxParams,
 	DriftClientMetricsEvents,
 	IWallet,
+	MappedRecord,
 	SignedTxData,
 	TxParams,
 } from '../types';
@@ -160,6 +161,10 @@ export class TxHandler {
 		return (tx as VersionedTransaction)?.message && true;
 	}
 
+	private isLegacyTransaction(tx: Transaction | VersionedTransaction) {
+		return !this.isVersionedTransaction(tx);
+	}
+
 	private getTxSigFromSignedTx(signedTx: Transaction | VersionedTransaction) {
 		if (this.isVersionedTransaction(signedTx)) {
 			return bs58.encode(
@@ -266,7 +271,7 @@ export class TxHandler {
 			return;
 		}
 
-		const fullTxData = txData.map((tx) => {
+		const signedTxData = txData.map((tx) => {
 			const lastValidBlockHeight =
 				this.blockHashToLastValidBlockHeightLookup[tx.blockHash];
 
@@ -277,8 +282,10 @@ export class TxHandler {
 		});
 
 		if (this.onSignedCb) {
-			this.onSignedCb(fullTxData);
+			this.onSignedCb(signedTxData);
 		}
+
+		return signedTxData;
 	}
 
 	/**
@@ -373,8 +380,15 @@ export class TxHandler {
 		return tx;
 	}
 
-	public generateLegacyTransaction(ixs: TransactionInstruction[]) {
-		return new Transaction().add(...ixs);
+	public generateLegacyTransaction(
+		ixs: TransactionInstruction[],
+		recentBlockhash?: BlockhashWithExpiryBlockHeight
+	) {
+		const tx = new Transaction().add(...ixs);
+		if (recentBlockhash) {
+			tx.recentBlockhash = recentBlockhash.blockhash;
+		}
+		return tx;
 	}
 
 	/**
@@ -484,7 +498,7 @@ export class TxHandler {
 			if (forceVersionedTransaction) {
 				return this.generateLegacyVersionedTransaction(recentBlockhash, allIx);
 			} else {
-				return this.generateLegacyTransaction(allIx);
+				return this.generateLegacyTransaction(allIx, recentBlockhash);
 			}
 		} else {
 			const marketLookupTable = await fetchMarketLookupTableAccount();
@@ -532,39 +546,6 @@ export class TxHandler {
 		return tx.add(instruction);
 	}
 
-	/**
-	 * Build a map of transactions from an array of instructions for multiple transactions.
-	 * @param txsToSign
-	 * @param keys
-	 * @param wallet
-	 * @param commitment
-	 * @returns
-	 */
-	public async buildTransactionMap(
-		txsToSign: (Transaction | undefined)[],
-		keys: string[],
-		wallet?: IWallet,
-		commitment?: Commitment,
-		recentBlockhash?: BlockhashWithExpiryBlockHeight
-	) {
-		recentBlockhash = recentBlockhash
-			? recentBlockhash
-			: await this.getLatestBlockhashForTransaction();
-
-		this.addHashAndExpiryToLookup(recentBlockhash);
-
-		for (const tx of txsToSign) {
-			if (!tx) continue;
-			tx.recentBlockhash = recentBlockhash.blockhash;
-			tx.feePayer = wallet?.publicKey ?? this.wallet?.publicKey;
-
-			// @ts-ignore
-			tx.SIGNATURE_BLOCK_AND_EXPIRY = recentBlockhash;
-		}
-
-		return this.getSignedTransactionMap(txsToSign, keys, wallet);
-	}
-
 	/**
 	 * Get a map of signed and prepared transactions from an array of legacy transactions
 	 * @param txsToSign
@@ -573,9 +554,10 @@ export class TxHandler {
 	 * @param commitment
 	 * @returns
 	 */
-	public async getPreparedAndSignedLegacyTransactionMap(
-		txsToSign: (Transaction | undefined)[],
-		keys: string[],
+	public async getPreparedAndSignedLegacyTransactionMap<
+		T extends Record<string, Transaction | undefined>,
+	>(
+		txsMap: T,
 		wallet?: IWallet,
 		commitment?: Commitment,
 		recentBlockhash?: BlockhashWithExpiryBlockHeight
@@ -586,7 +568,7 @@ export class TxHandler {
 
 		this.addHashAndExpiryToLookup(recentBlockhash);
 
-		for (const tx of txsToSign) {
+		for (const tx of Object.values(txsMap)) {
 			if (!tx) continue;
 			tx.recentBlockhash = recentBlockhash.blockhash;
 			tx.feePayer = wallet?.publicKey ?? this.wallet?.publicKey;
@@ -595,7 +577,7 @@ export class TxHandler {
 			tx.SIGNATURE_BLOCK_AND_EXPIRY = recentBlockhash;
 		}
 
-		return this.getSignedTransactionMap(txsToSign, keys, wallet);
+		return this.getSignedTransactionMap(txsMap, wallet);
 	}
 
 	/**
@@ -605,47 +587,49 @@ export class TxHandler {
 	 * @param wallet
 	 * @returns
 	 */
-	public async getSignedTransactionMap(
-		txsToSign: (Transaction | VersionedTransaction | undefined)[],
-		keys: string[],
+	public async getSignedTransactionMap<
+		T extends Record<string, Transaction | VersionedTransaction | undefined>,
+	>(
+		txsToSignMap: T,
 		wallet?: IWallet
 	): Promise<{
-		[key: string]: Transaction | VersionedTransaction | undefined;
+		signedTxMap: T;
+		signedTxData: SignedTxData[];
 	}> {
 		[wallet] = this.getProps(wallet);
 
-		const signedTxMap: {
-			[key: string]: Transaction | VersionedTransaction | undefined;
-		} = {};
+		const txsToSignEntries = Object.entries(txsToSignMap);
 
-		const keysWithTx = [];
-		txsToSign.forEach((tx, index) => {
-			if (tx == undefined) {
-				signedTxMap[keys[index]] = undefined;
-			} else {
-				keysWithTx.push(keys[index]);
+		// Create a map of the same keys as the input map, but with the values set to undefined. We'll populate the filtered (non-undefined) values with signed transactions.
+		const signedTxMap = txsToSignEntries.reduce((acc, [key]) => {
+			acc[key] = undefined;
+			return acc;
+		}, {}) as T;
+
+		const filteredTxEntries = txsToSignEntries.filter(([_, tx]) => !!tx);
+
+		// Extra handling for legacy transactions
+		for (const [_key, tx] of filteredTxEntries) {
+			if (this.isLegacyTransaction(tx)) {
+				(tx as Transaction).feePayer = wallet.publicKey;
 			}
-		});
+		}
 
 		this.preSignedCb?.();
 
-		const filteredTxs = txsToSign
-			.map((tx) => {
-				return tx as Transaction;
-			})
-			.filter((tx) => tx !== undefined);
-
-		const signedTxs = await wallet.signAllTransactions(filteredTxs);
+		const signedFilteredTxs = await wallet.signAllTransactions(
+			filteredTxEntries.map(([_, tx]) => tx as Transaction)
+		);
 
-		signedTxs.forEach((signedTx, index) => {
+		signedFilteredTxs.forEach((signedTx, index) => {
 			// @ts-ignore
 			signedTx.SIGNATURE_BLOCK_AND_EXPIRY =
 				// @ts-ignore
-				txsToSign[index]?.SIGNATURE_BLOCK_AND_EXPIRY;
+				filteredTxEntries[index][1]?.SIGNATURE_BLOCK_AND_EXPIRY;
 		});
 
-		this.handleSignedTxData(
-			signedTxs.map((signedTx) => {
+		const signedTxData = this.handleSignedTxData(
+			signedFilteredTxs.map((signedTx) => {
 				return {
 					txSig: this.getTxSigFromSignedTx(signedTx),
 					signedTx,
@@ -654,11 +638,36 @@ export class TxHandler {
 			})
 		);
 
-		signedTxs.forEach((signedTx, index) => {
-			signedTxMap[keysWithTx[index]] = signedTx;
+		filteredTxEntries.forEach(([key], index) => {
+			const signedTx = signedFilteredTxs[index];
+			// @ts-ignore
+			signedTxMap[key] = signedTx;
+		});
+
+		return { signedTxMap, signedTxData };
+	}
+
+	/**
+	 * Accepts multiple instructions and builds a transaction for each. Prevents needing to spam RPC with requests for the same blockhash.
+	 * @param props
+	 * @returns
+	 */
+	public async buildTransactionsMap<
+		T extends Record<string, TransactionInstruction | TransactionInstruction[]>,
+	>(
+		props: Omit<TxBuildingProps, 'instructions'> & {
+			instructionsMap: T;
+		}
+	): Promise<MappedRecord<T, Transaction | VersionedTransaction>> {
+		const builtTxs = await this.buildBulkTransactions({
+			...props,
+			instructions: Object.values(props.instructionsMap),
 		});
 
-		return signedTxMap;
+		return Object.keys(props.instructionsMap).reduce((acc, key, index) => {
+			acc[key] = builtTxs[index];
+			return acc;
+		}, {}) as MappedRecord<T, Transaction | VersionedTransaction>;
 	}
 
 	/**
@@ -666,22 +675,22 @@ export class TxHandler {
 	 * @param props
 	 * @returns
 	 */
-	public async buildAndSignTransactionMap(
+	public async buildAndSignTransactionMap<
+		T extends Record<string, TransactionInstruction | TransactionInstruction[]>,
+	>(
 		props: Omit<TxBuildingProps, 'instructions'> & {
-			keys: string[];
-			instructions: (TransactionInstruction | TransactionInstruction[])[];
+			instructionsMap: T;
 		}
 	) {
-		const transactions = await this.buildBulkTransactions(props);
+		const builtTxs = await this.buildTransactionsMap(props);
 
 		const preppedTransactions = await (props.txVersion === 'legacy'
 			? this.getPreparedAndSignedLegacyTransactionMap(
-					transactions as Transaction[],
-					props.keys,
+					builtTxs as Record<string, Transaction>,
 					props.wallet,
 					props.preFlightCommitment
 			  )
-			: this.getSignedTransactionMap(transactions, props.keys, props.wallet));
+			: this.getSignedTransactionMap(builtTxs, props.wallet));
 
 		return preppedTransactions;
 	}

package/src/types.ts

@@ -1,6 +1,11 @@
 import { PublicKey, Transaction, VersionedTransaction } from '@solana/web3.js';
 import { BN, ZERO } from '.';
 
+// Utility type which lets you denote record with values of type A mapped to a record with the same keys but values of type B
+export type MappedRecord<A extends Record<string, unknown>, B> = {
+	[K in keyof A]: B;
+};
+
 // # Utility Types / Enums / Constants
 
 export enum ExchangeStatus {
@@ -103,9 +108,13 @@ export class OracleSource {
 	static readonly PYTH = { pyth: {} };
 	static readonly PYTH_1K = { pyth1K: {} };
 	static readonly PYTH_1M = { pyth1M: {} };
+	static readonly PYTH_PULL = { pythPull: {} };
+	static readonly PYTH_1K_PULL = { pyth1KPull: {} };
+	static readonly PYTH_1M_PULL = { pyth1MPull: {} };
 	static readonly SWITCHBOARD = { switchboard: {} };
 	static readonly QUOTE_ASSET = { quoteAsset: {} };
 	static readonly PYTH_STABLE_COIN = { pythStableCoin: {} };
+	static readonly PYTH_STABLE_COIN_PULL = { pythStableCoinPull: {} };
 	static readonly Prelaunch = { prelaunch: {} };
 }
 
@@ -722,6 +731,9 @@ export type SpotMarketAccount = {
 	pausedOperations: number;
 
 	ifPausedOperations: number;
+
+	maxTokenBorrowsFraction: number;
+	minBorrowRate: number;
 };
 
 export type PoolBalance = {