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

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: {};
     };

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.6",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -34,10 +34,11 @@
 		"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",
+		"@pythnetwork/pyth-solana-receiver": "^0.7.0",
 		"@solana/spl-token": "^0.3.7",
 		"@solana/web3.js": "1.92.3",
 		"strict-event-emitter-types": "^2.0.0",

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[] } = {