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

package/lib/oracles/pythPullClient.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertPythPrice = exports.PythPullClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@coral-xyz/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+const pyth_solana_receiver_1 = require("@pythnetwork/pyth-solana-receiver");
+const __1 = require("..");
+class PythPullClient {
+    constructor(connection, multiple = numericConstants_1.ONE, stableCoin = false) {
+        this.connection = connection;
+        this.multiple = multiple;
+        this.stableCoin = stableCoin;
+        const provider = new anchor_1.AnchorProvider(this.connection, 
+        //@ts-ignore
+        new __1.Wallet(new web3_js_1.Keypair()), {
+            commitment: connection.commitment,
+        });
+        this.receiver = new anchor_1.Program(pyth_solana_receiver_1.pythSolanaReceiverIdl, pyth_solana_receiver_1.DEFAULT_RECEIVER_PROGRAM_ID, provider);
+        this.decodeFunc =
+            this.receiver.account.priceUpdateV2.coder.accounts.decodeUnchecked.bind(this.receiver.account.priceUpdateV2.coder.accounts);
+    }
+    async getOraclePriceData(pricePublicKey) {
+        const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
+        return this.getOraclePriceDataFromBuffer(accountInfo.data);
+    }
+    getOraclePriceDataFromBuffer(buffer) {
+        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,
+        };
+    }
+}
+exports.PythPullClient = PythPullClient;
+function convertPythPrice(price, exponent, multiple) {
+    exponent = Math.abs(exponent);
+    const pythPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(exponent).abs()).div(multiple);
+    return price.mul(numericConstants_1.PRICE_PRECISION).div(pythPrecision);
+}
+exports.convertPythPrice = convertPythPrice;
+const fiveBPS = new anchor_1.BN(500);
+function getStableCoinPrice(price, confidence) {
+    if (price.sub(numericConstants_1.QUOTE_PRECISION).abs().lt(anchor_1.BN.min(confidence, fiveBPS))) {
+        return numericConstants_1.QUOTE_PRECISION;
+    }
+    else {
+        return price;
+    }
+}

package/lib/tx/txHandler.d.ts

@@ -1,5 +1,5 @@
 import { AddressLookupTableAccount, BlockhashWithExpiryBlockHeight, Commitment, ConfirmOptions, Connection, Signer, Transaction, TransactionInstruction, TransactionVersion, VersionedTransaction } from '@solana/web3.js';
-import { DriftClientMetricsEvents, IWallet, TxParams } from '../types';
+import { DriftClientMetricsEvents, IWallet, MappedRecord, SignedTxData, TxParams } from '../types';
 export declare const COMPUTE_UNITS_DEFAULT = 200000;
 export type TxBuildingProps = {
     instructions: TransactionInstruction | TransactionInstruction[];
@@ -61,6 +61,7 @@ export declare class TxHandler {
      */
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, wallet?: IWallet, confirmationOpts?: ConfirmOptions, preSigned?: boolean, recentBlockhash?: BlockhashWithExpiryBlockHeight): Promise<Transaction>;
     private isVersionedTransaction;
+    private isLegacyTransaction;
     private getTxSigFromSignedTx;
     private getBlockhashFromSignedTx;
     private signTx;
@@ -75,7 +76,7 @@ export declare class TxHandler {
     private _generateVersionedTransaction;
     generateLegacyVersionedTransaction(recentBlockhash: BlockhashWithExpiryBlockHeight, ixs: TransactionInstruction[], wallet?: IWallet): VersionedTransaction;
     generateVersionedTransaction(recentBlockhash: BlockhashWithExpiryBlockHeight, ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], wallet?: IWallet): VersionedTransaction;
-    generateLegacyTransaction(ixs: TransactionInstruction[]): Transaction;
+    generateLegacyTransaction(ixs: TransactionInstruction[], recentBlockhash?: BlockhashWithExpiryBlockHeight): Transaction;
     /**
      * Accepts multiple instructions and builds a transaction for each. Prevents needing to spam RPC with requests for the same blockhash.
      * @param props
@@ -96,46 +97,48 @@ export declare class TxHandler {
     buildTransaction(props: TxBuildingProps): Promise<Transaction | VersionedTransaction>;
     wrapInTx(instruction: TransactionInstruction, computeUnits?: number, computeUnitsPrice?: number): Transaction;
     /**
-     * Build a map of transactions from an array of instructions for multiple transactions.
+     * Get a map of signed and prepared transactions from an array of legacy transactions
      * @param txsToSign
      * @param keys
      * @param wallet
      * @param commitment
      * @returns
      */
-    buildTransactionMap(txsToSign: (Transaction | undefined)[], keys: string[], wallet?: IWallet, commitment?: Commitment, recentBlockhash?: BlockhashWithExpiryBlockHeight): Promise<{
-        [key: string]: Transaction | VersionedTransaction;
+    getPreparedAndSignedLegacyTransactionMap<T extends Record<string, Transaction | undefined>>(txsMap: T, wallet?: IWallet, commitment?: Commitment, recentBlockhash?: BlockhashWithExpiryBlockHeight): Promise<{
+        signedTxMap: T;
+        signedTxData: SignedTxData[];
     }>;
     /**
-     * Get a map of signed and prepared transactions from an array of legacy transactions
+     * Get a map of signed transactions from an array of transactions to sign.
      * @param txsToSign
      * @param keys
      * @param wallet
-     * @param commitment
      * @returns
      */
-    getPreparedAndSignedLegacyTransactionMap(txsToSign: (Transaction | undefined)[], keys: string[], wallet?: IWallet, commitment?: Commitment, recentBlockhash?: BlockhashWithExpiryBlockHeight): Promise<{
-        [key: string]: Transaction | VersionedTransaction;
+    getSignedTransactionMap<T extends Record<string, Transaction | VersionedTransaction | undefined>>(txsToSignMap: T, wallet?: IWallet): Promise<{
+        signedTxMap: T;
+        signedTxData: SignedTxData[];
     }>;
     /**
-     * Get a map of signed transactions from an array of transactions to sign.
-     * @param txsToSign
-     * @param keys
-     * @param wallet
+     * Accepts multiple instructions and builds a transaction for each. Prevents needing to spam RPC with requests for the same blockhash.
+     * @param props
      * @returns
      */
-    getSignedTransactionMap(txsToSign: (Transaction | VersionedTransaction | undefined)[], keys: string[], wallet?: IWallet): Promise<{
-        [key: string]: Transaction | VersionedTransaction | undefined;
-    }>;
+    buildTransactionsMap<T extends Record<string, TransactionInstruction | TransactionInstruction[]>>(props: Omit<TxBuildingProps, 'instructions'> & {
+        instructionsMap: T;
+    }): Promise<MappedRecord<T, Transaction | VersionedTransaction>>;
     /**
      * Builds and signs transactions from a given array of instructions for multiple transactions.
      * @param props
      * @returns
      */
-    buildAndSignTransactionMap(props: Omit<TxBuildingProps, 'instructions'> & {
-        keys: string[];
-        instructions: (TransactionInstruction | TransactionInstruction[])[];
+    buildAndSignTransactionMap<T extends Record<string, TransactionInstruction | TransactionInstruction[]>>(props: Omit<TxBuildingProps, 'instructions'> & {
+        instructionsMap: T;
     }): Promise<{
-        [key: string]: Transaction | VersionedTransaction;
+        signedTxMap: Record<string, Transaction>;
+        signedTxData: SignedTxData[];
+    } | {
+        signedTxMap: MappedRecord<T, Transaction | VersionedTransaction>;
+        signedTxData: SignedTxData[];
     }>;
 }

package/lib/tx/txHandler.js

@@ -82,6 +82,9 @@ class TxHandler {
     isVersionedTransaction(tx) {
         return (tx === null || tx === void 0 ? void 0 : tx.message) && true;
     }
+    isLegacyTransaction(tx) {
+        return !this.isVersionedTransaction(tx);
+    }
     getTxSigFromSignedTx(signedTx) {
         if (this.isVersionedTransaction(signedTx)) {
             return bs58_1.default.encode(Buffer.from(signedTx.signatures[0]));
@@ -152,7 +155,7 @@ class TxHandler {
             }
             return;
         }
-        const fullTxData = txData.map((tx) => {
+        const signedTxData = txData.map((tx) => {
             const lastValidBlockHeight = this.blockHashToLastValidBlockHeightLookup[tx.blockHash];
             return {
                 ...tx,
@@ -160,8 +163,9 @@ class TxHandler {
             };
         });
         if (this.onSignedCb) {
-            this.onSignedCb(fullTxData);
+            this.onSignedCb(signedTxData);
         }
+        return signedTxData;
     }
     /**
      * Gets transaction params with extra processing applied, like using the simulated compute units or using a dynamically calculated compute unit price.
@@ -225,8 +229,12 @@ class TxHandler {
         tx.SIGNATURE_BLOCK_AND_EXPIRY = recentBlockhash;
         return tx;
     }
-    generateLegacyTransaction(ixs) {
-        return new web3_js_1.Transaction().add(...ixs);
+    generateLegacyTransaction(ixs, recentBlockhash) {
+        const tx = new web3_js_1.Transaction().add(...ixs);
+        if (recentBlockhash) {
+            tx.recentBlockhash = recentBlockhash.blockhash;
+        }
+        return tx;
     }
     /**
      * Accepts multiple instructions and builds a transaction for each. Prevents needing to spam RPC with requests for the same blockhash.
@@ -302,7 +310,7 @@ class TxHandler {
                 return this.generateLegacyVersionedTransaction(recentBlockhash, allIx);
             }
             else {
-                return this.generateLegacyTransaction(allIx);
+                return this.generateLegacyTransaction(allIx, recentBlockhash);
             }
         }
         else {
@@ -332,30 +340,6 @@ 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
-     */
-    async buildTransactionMap(txsToSign, keys, wallet, commitment, recentBlockhash) {
-        var _a, _b;
-        recentBlockhash = recentBlockhash
-            ? recentBlockhash
-            : await this.getLatestBlockhashForTransaction();
-        this.addHashAndExpiryToLookup(recentBlockhash);
-        for (const tx of txsToSign) {
-            if (!tx)
-                continue;
-            tx.recentBlockhash = recentBlockhash.blockhash;
-            tx.feePayer = (_a = wallet === null || wallet === void 0 ? void 0 : wallet.publicKey) !== null && _a !== void 0 ? _a : (_b = this.wallet) === null || _b === void 0 ? void 0 : _b.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
@@ -364,13 +348,13 @@ class TxHandler {
      * @param commitment
      * @returns
      */
-    async getPreparedAndSignedLegacyTransactionMap(txsToSign, keys, wallet, commitment, recentBlockhash) {
+    async getPreparedAndSignedLegacyTransactionMap(txsMap, wallet, commitment, recentBlockhash) {
         var _a, _b;
         recentBlockhash = recentBlockhash
             ? recentBlockhash
             : await this.getLatestBlockhashForTransaction();
         this.addHashAndExpiryToLookup(recentBlockhash);
-        for (const tx of txsToSign) {
+        for (const tx of Object.values(txsMap)) {
             if (!tx)
                 continue;
             tx.recentBlockhash = recentBlockhash.blockhash;
@@ -378,7 +362,7 @@ class TxHandler {
             // @ts-ignore
             tx.SIGNATURE_BLOCK_AND_EXPIRY = recentBlockhash;
         }
-        return this.getSignedTransactionMap(txsToSign, keys, wallet);
+        return this.getSignedTransactionMap(txsMap, wallet);
     }
     /**
      * Get a map of signed transactions from an array of transactions to sign.
@@ -387,44 +371,59 @@ class TxHandler {
      * @param wallet
      * @returns
      */
-    async getSignedTransactionMap(txsToSign, keys, wallet) {
+    async getSignedTransactionMap(txsToSignMap, wallet) {
         var _a;
         [wallet] = this.getProps(wallet);
-        const signedTxMap = {};
-        const keysWithTx = [];
-        txsToSign.forEach((tx, index) => {
-            if (tx == undefined) {
-                signedTxMap[keys[index]] = undefined;
-            }
-            else {
-                keysWithTx.push(keys[index]);
+        const txsToSignEntries = Object.entries(txsToSignMap);
+        // 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;
+        }, {});
+        const filteredTxEntries = txsToSignEntries.filter(([_, tx]) => !!tx);
+        // Extra handling for legacy transactions
+        for (const [_key, tx] of filteredTxEntries) {
+            if (this.isLegacyTransaction(tx)) {
+                tx.feePayer = wallet.publicKey;
             }
-        });
+        }
         (_a = this.preSignedCb) === null || _a === void 0 ? void 0 : _a.call(this);
-        const filteredTxs = txsToSign
-            .map((tx) => {
-            return tx;
-        })
-            .filter((tx) => tx !== undefined);
-        const signedTxs = await wallet.signAllTransactions(filteredTxs);
-        signedTxs.forEach((signedTx, index) => {
+        const signedFilteredTxs = await wallet.signAllTransactions(filteredTxEntries.map(([_, tx]) => tx));
+        signedFilteredTxs.forEach((signedTx, index) => {
             var _a;
             // @ts-ignore
             signedTx.SIGNATURE_BLOCK_AND_EXPIRY =
                 // @ts-ignore
-                (_a = txsToSign[index]) === null || _a === void 0 ? void 0 : _a.SIGNATURE_BLOCK_AND_EXPIRY;
+                (_a = filteredTxEntries[index][1]) === null || _a === void 0 ? void 0 : _a.SIGNATURE_BLOCK_AND_EXPIRY;
         });
-        this.handleSignedTxData(signedTxs.map((signedTx) => {
+        const signedTxData = this.handleSignedTxData(signedFilteredTxs.map((signedTx) => {
             return {
                 txSig: this.getTxSigFromSignedTx(signedTx),
                 signedTx,
                 blockHash: this.getBlockhashFromSignedTx(signedTx),
             };
         }));
-        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
+     */
+    async buildTransactionsMap(props) {
+        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;
+        }, {});
     }
     /**
      * Builds and signs transactions from a given array of instructions for multiple transactions.
@@ -432,10 +431,10 @@ class TxHandler {
      * @returns
      */
     async buildAndSignTransactionMap(props) {
-        const transactions = await this.buildBulkTransactions(props);
+        const builtTxs = await this.buildTransactionsMap(props);
         const preppedTransactions = await (props.txVersion === 'legacy'
-            ? this.getPreparedAndSignedLegacyTransactionMap(transactions, props.keys, props.wallet, props.preFlightCommitment)
-            : this.getSignedTransactionMap(transactions, props.keys, props.wallet));
+            ? this.getPreparedAndSignedLegacyTransactionMap(builtTxs, props.wallet, props.preFlightCommitment)
+            : this.getSignedTransactionMap(builtTxs, props.wallet));
         return preppedTransactions;
     }
 }

package/lib/types.d.ts

@@ -1,6 +1,9 @@
 /// <reference types="bn.js" />
 import { PublicKey, Transaction, VersionedTransaction } from '@solana/web3.js';
 import { BN } from '.';
+export type MappedRecord<A extends Record<string, unknown>, B> = {
+    [K in keyof A]: B;
+};
 export declare enum ExchangeStatus {
     ACTIVE = 0,
     DEPOSIT_PAUSED = 1,
@@ -154,6 +157,15 @@ export declare class OracleSource {
     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: {};
     };
@@ -163,6 +175,9 @@ export declare class OracleSource {
     static readonly PYTH_STABLE_COIN: {
         pythStableCoin: {};
     };
+    static readonly PYTH_STABLE_COIN_PULL: {
+        pythStableCoinPull: {};
+    };
     static readonly Prelaunch: {
         prelaunch: {};
     };
@@ -795,6 +810,8 @@ export type SpotMarketAccount = {
     ordersEnabled: boolean;
     pausedOperations: number;
     ifPausedOperations: number;
+    maxTokenBorrowsFraction: number;
+    minBorrowRate: number;
 };
 export type PoolBalance = {
     scaledBalance: BN;

package/lib/types.js

@@ -105,9 +105,13 @@ exports.OracleSource = OracleSource;
 OracleSource.PYTH = { pyth: {} };
 OracleSource.PYTH_1K = { pyth1K: {} };
 OracleSource.PYTH_1M = { pyth1M: {} };
+OracleSource.PYTH_PULL = { pythPull: {} };
+OracleSource.PYTH_1K_PULL = { pyth1KPull: {} };
+OracleSource.PYTH_1M_PULL = { pyth1MPull: {} };
 OracleSource.SWITCHBOARD = { switchboard: {} };
 OracleSource.QUOTE_ASSET = { quoteAsset: {} };
 OracleSource.PYTH_STABLE_COIN = { pythStableCoin: {} };
+OracleSource.PYTH_STABLE_COIN_PULL = { pythStableCoinPull: {} };
 OracleSource.Prelaunch = { prelaunch: {} };
 class OrderType {
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.84.0-beta.5",
+	"version": "2.84.0-beta.7",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -34,12 +34,14 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@coral-xyz/anchor": "0.29.0",
+		"@coral-xyz/anchor": "0.28.0",
 		"@ellipsis-labs/phoenix-sdk": "^1.4.2",
 		"@project-serum/serum": "^0.13.38",
 		"@pythnetwork/client": "2.5.3",
-		"@solana/spl-token": "^0.3.7",
+		"@pythnetwork/pyth-solana-receiver": "^0.7.0",
+		"@solana/spl-token": "0.3.7",
 		"@solana/web3.js": "1.92.3",
+		"rpc-websockets": "7.5.1",
 		"strict-event-emitter-types": "^2.0.0",
 		"uuid": "^8.3.2",
 		"zstddec": "^0.1.0"
@@ -50,17 +52,17 @@
 		"@types/chai": "^4.3.1",
 		"@types/jest": "^28.1.3",
 		"@types/mocha": "^9.1.1",
-		"@typescript-eslint/eslint-plugin": "^4.28.0",
-		"@typescript-eslint/parser": "^4.28.0",
+		"@typescript-eslint/eslint-plugin": "4.28.0",
+		"@typescript-eslint/parser": "4.28.0",
 		"chai": "^4.3.6",
 		"encoding": "^0.1.13",
-		"eslint": "^7.29.0",
-		"eslint-config-prettier": "^8.3.0",
-		"eslint-plugin-prettier": "^3.4.0",
+		"eslint": "7.29.0",
+		"eslint-config-prettier": "8.3.0",
+		"eslint-plugin-prettier": "3.4.0",
 		"lodash": "^4.17.21",
 		"mocha": "^10.0.0",
 		"object-sizeof": "^2.6.3",
-		"prettier": "^3.0.1",
+		"prettier": "3.0.1",
 		"ts-node": "^10.8.0",
 		"typescript": "^4.9.5"
 	},

package/src/adminClient.ts

@@ -1812,6 +1812,44 @@ export class AdminClient extends DriftClient {
 		);
 	}
 
+	public async updateSpotMarketMaxTokenBorrows(
+		spotMarketIndex: number,
+		maxTokenBorrows: BN
+	): Promise<TransactionSignature> {
+		const updateSpotMarketMaxTokenBorrowsIx =
+			await this.getUpdateSpotMarketMaxTokenBorrowsIx(
+				spotMarketIndex,
+				maxTokenBorrows
+			);
+
+		const tx = await this.buildTransaction(updateSpotMarketMaxTokenBorrowsIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
+	}
+
+	public async getUpdateSpotMarketMaxTokenBorrowsIx(
+		spotMarketIndex: number,
+		maxTokenBorrows: BN
+	): Promise<TransactionInstruction> {
+		return this.program.instruction.updateSpotMarketMaxTokenBorrows(
+			maxTokenBorrows,
+			{
+				accounts: {
+					admin: this.isSubscribed
+						? this.getStateAccount().admin
+						: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					spotMarket: await getSpotMarketPublicKey(
+						this.program.programId,
+						spotMarketIndex
+					),
+				},
+			}
+		);
+	}
+
 	public async updateSpotMarketScaleInitialAssetWeightStart(
 		spotMarketIndex: number,
 		scaleInitialAssetWeightStart: BN
@@ -2506,14 +2544,16 @@ export class AdminClient extends DriftClient {
 		spotMarketIndex: number,
 		optimalUtilization: number,
 		optimalBorrowRate: number,
-		optimalMaxRate: number
+		optimalMaxRate: number,
+		minBorrowRate?: number | undefined
 	): Promise<TransactionSignature> {
 		const updateSpotMarketBorrowRateIx =
 			await this.getUpdateSpotMarketBorrowRateIx(
 				spotMarketIndex,
 				optimalUtilization,
 				optimalBorrowRate,
-				optimalMaxRate
+				optimalMaxRate,
+				minBorrowRate
 			);
 
 		const tx = await this.buildTransaction(updateSpotMarketBorrowRateIx);
@@ -2527,12 +2567,14 @@ export class AdminClient extends DriftClient {
 		spotMarketIndex: number,
 		optimalUtilization: number,
 		optimalBorrowRate: number,
-		optimalMaxRate: number
+		optimalMaxRate: number,
+		minBorrowRate?: number | undefined
 	): Promise<TransactionInstruction> {
 		return await this.program.instruction.updateSpotMarketBorrowRate(
 			optimalUtilization,
 			optimalBorrowRate,
 			optimalMaxRate,
+			minBorrowRate,
 			{
 				accounts: {
 					admin: this.isSubscribed

package/src/blockhashSubscriber/BlockhashSubscriber.ts

@@ -39,15 +39,28 @@ export class BlockhashSubscriber {
 		return this.latestBlockHeightContext;
 	}
 
+	/**
+	 * Returns the latest cached blockhash, based on an offset from the latest obtained
+	 * @param offset Offset to use, defaulting to 0
+	 * @param offsetType If 'seconds', it will use calculate the actual element offset based on the update interval; otherwise it will return a fixed index
+	 * @returns Cached blockhash at the given offset, or undefined
+	 */
 	getLatestBlockhash(
-		offset?: number
+		offset = 0,
+		offsetType: 'index' | 'seconds' = 'index'
 	): BlockhashWithExpiryBlockHeight | undefined {
 		if (this.blockhashes.length === 0) {
 			return undefined;
 		}
+
+		const elementOffset =
+			offsetType == 'seconds'
+				? Math.floor((offset * 1000) / this.updateIntervalMs)
+				: offset;
+
 		const clampedOffset = Math.max(
 			0,
-			Math.min(this.blockhashes.length - 1, offset ?? 0)
+			Math.min(this.blockhashes.length - 1, elementOffset)
 		);
 
 		return this.blockhashes[this.blockhashes.length - 1 - clampedOffset];

package/src/constants/spotMarkets.ts

@@ -273,6 +273,16 @@ export const MainnetSpotMarkets: SpotMarketConfig[] = [
 		precisionExp: NINE,
 		launchTs: 1716595200000,
 	},
+	{
+		symbol: 'USDY',
+		marketIndex: 18,
+		oracle: new PublicKey('DiqUGbq5CV8Tjcae1whjrX97qPo6gU7BKAvKNFc2vrX8'),
+		oracleSource: OracleSource.SWITCHBOARD,
+		mint: new PublicKey('A1KLoBrKBde8Ty9qtNQUtq3C2ortoC3u7twggz7sEto6'),
+		precision: new BN(10).pow(SIX),
+		precisionExp: SIX,
+		launchTs: 1718811089000,
+	},
 ];
 
 export const SpotMarkets: { [key in DriftEnv]: SpotMarketConfig[] } = {