@drift-labs/sdk 2.10.0-beta.1 → 2.10.0-beta.2

package/lib/accounts/pollingDriftClientAccountSubscriber.js

@@ -214,19 +214,28 @@ class PollingDriftClientAccountSubscriber {
         this.isSubscribed = false;
     }
     async addSpotMarket(marketIndex) {
+        const marketPublicKey = await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex);
+        if (this.accountsToPoll.has(marketPublicKey.toString())) {
+            return true;
+        }
         await this.addSpotMarketAccountToPoll(marketIndex);
-        const accountToPoll = this.accountsToPoll.get(marketIndex.toString());
+        const accountToPoll = this.accountsToPoll.get(marketPublicKey.toString());
         await this.addAccountToAccountLoader(accountToPoll);
         return true;
     }
     async addPerpMarket(marketIndex) {
+        const marketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, marketIndex);
+        if (this.accountsToPoll.has(marketPublicKey.toString())) {
+            return true;
+        }
         await this.addPerpMarketAccountToPoll(marketIndex);
-        const accountToPoll = this.accountsToPoll.get(marketIndex.toString());
+        const accountToPoll = this.accountsToPoll.get(marketPublicKey.toString());
         await this.addAccountToAccountLoader(accountToPoll);
         return true;
     }
     async addOracle(oracleInfo) {
-        if (oracleInfo.publicKey.equals(web3_js_1.PublicKey.default)) {
+        if (oracleInfo.publicKey.equals(web3_js_1.PublicKey.default) ||
+            this.oraclesToPoll.has(oracleInfo.publicKey.toString())) {
             return true;
         }
         this.addOracleToPoll(oracleInfo);

package/lib/adminClient.js

@@ -54,7 +54,7 @@ class AdminClient extends driftClient_1.DriftClient {
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
         });
-        const { txSig: initializeTxSig } = await this.txSender.send(initializeTx, [], this.opts);
+        const { txSig: initializeTxSig } = await super.sendTransaction(initializeTx, [], this.opts);
         return [initializeTxSig];
     }
     async initializeSpotMarket(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = 0, liquidatorFee = 0, activeStatus = true, name = userName_1.DEFAULT_MARKET_NAME) {
@@ -78,7 +78,7 @@ class AdminClient extends driftClient_1.DriftClient {
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
         });
-        const { txSig } = await this.txSender.send(initializeTx, [], this.opts);
+        const { txSig } = await this.sendTransaction(initializeTx, [], this.opts);
         await this.accountSubscriber.addSpotMarket(spotMarketIndex);
         await this.accountSubscriber.addOracle({
             source: oracleSource,
@@ -89,7 +89,7 @@ class AdminClient extends driftClient_1.DriftClient {
     async initializeSerumFulfillmentConfig(marketIndex, serumMarket, serumProgram) {
         const serumOpenOrders = (0, pda_1.getSerumOpenOrdersPublicKey)(this.program.programId, serumMarket);
         const serumFulfillmentConfig = (0, pda_1.getSerumFulfillmentConfigPublicKey)(this.program.programId, serumMarket);
-        return await this.program.rpc.initializeSerumFulfillmentConfig(marketIndex, {
+        const tx = await this.program.transaction.initializeSerumFulfillmentConfig(marketIndex, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
@@ -104,9 +104,12 @@ class AdminClient extends driftClient_1.DriftClient {
                 serumFulfillmentConfig,
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async initializePerpMarket(priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, marginRatioInitial = 2000, marginRatioMaintenance = 500, liquidatorFee = 0, activeStatus = true, name = userName_1.DEFAULT_MARKET_NAME) {
-        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, this.getStateAccount().numberOfMarkets);
+        const currentPerpMarketIndex = this.getStateAccount().numberOfMarkets;
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, currentPerpMarketIndex);
         const nameBuffer = (0, userName_1.encodeName)(name);
         const initializeMarketTx = await this.program.transaction.initializePerpMarket(baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, marginRatioInitial, marginRatioMaintenance, liquidatorFee, activeStatus, nameBuffer, {
             accounts: {
@@ -118,8 +121,11 @@ class AdminClient extends driftClient_1.DriftClient {
                 systemProgram: anchor.web3.SystemProgram.programId,
             },
         });
-        const { txSig } = await this.txSender.send(initializeMarketTx, [], this.opts);
-        await this.accountSubscriber.addPerpMarket(this.getStateAccount().numberOfMarkets);
+        const { txSig } = await this.sendTransaction(initializeMarketTx, [], this.opts);
+        while (this.getStateAccount().numberOfMarkets <= currentPerpMarketIndex) {
+            await this.fetchAccounts();
+        }
+        await this.accountSubscriber.addPerpMarket(currentPerpMarketIndex);
         await this.accountSubscriber.addOracle({
             source: oracleSource,
             publicKey: priceOracle,
@@ -131,16 +137,18 @@ class AdminClient extends driftClient_1.DriftClient {
         if (sqrtK == undefined) {
             sqrtK = (0, utils_1.squareRootBN)(baseAssetReserve.mul(quoteAssetReserve));
         }
-        return await this.program.rpc.moveAmmPrice(baseAssetReserve, quoteAssetReserve, sqrtK, {
+        const tx = await this.program.transaction.moveAmmPrice(baseAssetReserve, quoteAssetReserve, sqrtK, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
                 perpMarket: marketPublicKey,
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateK(perpMarketIndex, sqrtK) {
-        return await this.program.rpc.updateK(sqrtK, {
+        const tx = await this.program.transaction.updateK(sqrtK, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
@@ -148,6 +156,8 @@ class AdminClient extends driftClient_1.DriftClient {
                 oracle: this.getPerpMarketAccount(perpMarketIndex).amm.oracle,
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketConcentrationScale(perpMarketIndex, concentrationScale) {
         return await this.program.rpc.updatePerpMarketConcentrationCoef(concentrationScale, {
@@ -164,18 +174,20 @@ class AdminClient extends driftClient_1.DriftClient {
         );
         const [newQuoteAssetAmount, newBaseAssetAmount] = (0, amm_1.calculateAmmReservesAfterSwap)(perpMarket.amm, 'quote', tradeSize, (0, amm_1.getSwapDirection)('quote', direction));
         const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
-        return await this.program.rpc.moveAmmPrice(newBaseAssetAmount, newQuoteAssetAmount, perpMarket.amm.sqrtK, {
+        const tx = await this.program.transaction.moveAmmPrice(newBaseAssetAmount, newQuoteAssetAmount, perpMarket.amm.sqrtK, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
                 perpMarket: perpMarketPublicKey,
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async repegAmmCurve(newPeg, perpMarketIndex) {
         const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
         const ammData = this.getPerpMarketAccount(perpMarketIndex).amm;
-        return await this.program.rpc.repegAmmCurve(newPeg, {
+        const tx = await this.program.transaction.repegAmmCurve(newPeg, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
@@ -183,6 +195,8 @@ class AdminClient extends driftClient_1.DriftClient {
                 perpMarket: perpMarketPublicKey,
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketAmmOracleTwap(perpMarketIndex) {
         const ammData = this.getPerpMarketAccount(perpMarketIndex).amm;
@@ -210,7 +224,7 @@ class AdminClient extends driftClient_1.DriftClient {
     }
     async depositIntoPerpMarketFeePool(perpMarketIndex, amount, sourceVault) {
         const spotMarket = this.getQuoteSpotMarketAccount();
-        return await this.program.rpc.depositIntoPerpMarketFeePool(amount, {
+        const tx = await this.program.transaction.depositIntoPerpMarketFeePool(amount, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
@@ -222,14 +236,18 @@ class AdminClient extends driftClient_1.DriftClient {
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateAdmin(admin) {
-        return await this.program.rpc.updateAdmin(admin, {
+        const tx = await this.program.transaction.updateAdmin(admin, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketCurveUpdateIntensity(perpMarketIndex, curveUpdateIntensity) {
         // assert(curveUpdateIntensity >= 0 && curveUpdateIntensity <= 100);
@@ -243,13 +261,15 @@ class AdminClient extends driftClient_1.DriftClient {
         });
     }
     async updatePerpMarketMarginRatio(perpMarketIndex, marginRatioInitial, marginRatioMaintenance) {
-        return await this.program.rpc.updatePerpMarketMarginRatio(marginRatioInitial, marginRatioMaintenance, {
+        const tx = await this.program.transaction.updatePerpMarketMarginRatio(marginRatioInitial, marginRatioMaintenance, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketImfFactor(perpMarketIndex, imfFactor, unrealizedPnlImfFactor) {
         return await this.program.rpc.updatePerpMarketImfFactor(imfFactor, unrealizedPnlImfFactor, {
@@ -261,32 +281,38 @@ class AdminClient extends driftClient_1.DriftClient {
         });
     }
     async updatePerpMarketBaseSpread(perpMarketIndex, baseSpread) {
-        return await this.program.rpc.updatePerpMarketBaseSpread(baseSpread, {
+        const tx = await this.program.transaction.updatePerpMarketBaseSpread(baseSpread, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateAmmJitIntensity(perpMarketIndex, ammJitIntensity) {
-        return await this.program.rpc.updateAmmJitIntensity(ammJitIntensity, {
+        const tx = await this.program.transaction.updateAmmJitIntensity(ammJitIntensity, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketName(perpMarketIndex, name) {
         const nameBuffer = (0, userName_1.encodeName)(name);
-        return await this.program.rpc.updatePerpMarketName(nameBuffer, {
+        const tx = await this.program.transaction.updatePerpMarketName(nameBuffer, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateSpotMarketName(spotMarketIndex, name) {
         const nameBuffer = (0, userName_1.encodeName)(name);
@@ -309,20 +335,24 @@ class AdminClient extends driftClient_1.DriftClient {
         });
     }
     async updatePerpFeeStructure(feeStructure) {
-        return await this.program.rpc.updatePerpFeeStructure(feeStructure, {
+        const tx = this.program.transaction.updatePerpFeeStructure(feeStructure, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateSpotFeeStructure(feeStructure) {
-        return await this.program.rpc.updateSpotFeeStructure(feeStructure, {
+        const tx = await this.program.transaction.updateSpotFeeStructure(feeStructure, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateInitialPctToLiquidate(initialPctToLiquidate) {
         return await this.program.rpc.updateInitialPctToLiquidate(initialPctToLiquidate, {
@@ -341,12 +371,14 @@ class AdminClient extends driftClient_1.DriftClient {
         });
     }
     async updateOracleGuardRails(oracleGuardRails) {
-        return await this.program.rpc.updateOracleGuardRails(oracleGuardRails, {
+        const tx = await this.program.transaction.updateOracleGuardRails(oracleGuardRails, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateStateSettlementDuration(settlementDuration) {
         return await this.program.rpc.updateStateSettlementDuration(settlementDuration, {
@@ -357,60 +389,72 @@ class AdminClient extends driftClient_1.DriftClient {
         });
     }
     async updateWithdrawGuardThreshold(spotMarketIndex, withdrawGuardThreshold) {
-        return await this.program.rpc.updateWithdrawGuardThreshold(withdrawGuardThreshold, {
+        const tx = await this.program.transaction.updateWithdrawGuardThreshold(withdrawGuardThreshold, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateSpotMarketIfFactor(spotMarketIndex, userIfFactor, totalIfFactor) {
-        return await this.program.rpc.updateSpotMarketIfFactor(spotMarketIndex, userIfFactor, totalIfFactor, {
+        const tx = await this.program.transaction.updateSpotMarketIfFactor(spotMarketIndex, userIfFactor, totalIfFactor, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateSpotMarketRevenueSettlePeriod(spotMarketIndex, revenueSettlePeriod) {
-        return await this.program.rpc.updateSpotMarketRevenueSettlePeriod(revenueSettlePeriod, {
+        const tx = await this.program.transaction.updateSpotMarketRevenueSettlePeriod(revenueSettlePeriod, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateSpotMarketMaxTokenDeposits(spotMarketIndex, maxTokenDeposits) {
-        return await this.program.rpc.updateSpotMarketMaxTokenDeposits(maxTokenDeposits, {
+        const tx = this.program.transaction.updateSpotMarketMaxTokenDeposits(maxTokenDeposits, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateInsuranceFundUnstakingPeriod(spotMarketIndex, insuranceWithdrawEscrowPeriod) {
-        return await this.program.rpc.updateInsuranceFundUnstakingPeriod(insuranceWithdrawEscrowPeriod, {
+        const tx = await this.program.transaction.updateInsuranceFundUnstakingPeriod(insuranceWithdrawEscrowPeriod, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateLpCooldownTime(cooldownTime) {
-        return await this.program.rpc.updateLpCooldownTime(cooldownTime, {
+        const tx = await this.program.transaction.updateLpCooldownTime(cooldownTime, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketOracle(perpMarketIndex, oracle, oracleSource) {
-        return await this.program.rpc.updatePerpMarketOracle(oracle, oracleSource, {
+        const tx = await this.program.transaction.updatePerpMarketOracle(oracle, oracleSource, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
@@ -418,15 +462,19 @@ class AdminClient extends driftClient_1.DriftClient {
                 oracle: oracle,
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketStepSizeAndTickSize(perpMarketIndex, stepSize, tickSize) {
-        return await this.program.rpc.updatePerpMarketStepSizeAndTickSize(stepSize, tickSize, {
+        const tx = await this.program.transaction.updatePerpMarketStepSizeAndTickSize(stepSize, tickSize, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketMinOrderSize(perpMarketIndex, orderSize) {
         return await this.program.rpc.updatePerpMarketMinOrderSize(orderSize, {
@@ -502,20 +550,24 @@ class AdminClient extends driftClient_1.DriftClient {
         });
     }
     async updateWhitelistMint(whitelistMint) {
-        return await this.program.rpc.updateWhitelistMint(whitelistMint, {
+        const tx = await this.program.transaction.updateWhitelistMint(whitelistMint, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateDiscountMint(discountMint) {
-        return await this.program.rpc.updateDiscountMint(discountMint, {
+        const tx = await this.program.transaction.updateDiscountMint(discountMint, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateSpotMarketMarginWeights(spotMarketIndex, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = 0) {
         return await this.program.rpc.updateSpotMarketMarginWeights(initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, {
@@ -536,48 +588,58 @@ class AdminClient extends driftClient_1.DriftClient {
         });
     }
     async updateSpotMarketAssetTier(spotMarketIndex, assetTier) {
-        return await this.program.rpc.updateSpotMarketAssetTier(assetTier, {
+        const tx = await this.program.transaction.updateSpotMarketAssetTier(assetTier, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const { txSig } = await this.sendTransaction(tx);
+        return txSig;
     }
     async updateSpotMarketStatus(spotMarketIndex, marketStatus) {
-        return await this.program.rpc.updateSpotMarketStatus(marketStatus, {
+        const tx = await this.program.transaction.updateSpotMarketStatus(marketStatus, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketStatus(perpMarketIndex, marketStatus) {
-        return await this.program.rpc.updatePerpMarketStatus(marketStatus, {
+        const tx = await this.program.transaction.updatePerpMarketStatus(marketStatus, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketContractTier(perpMarketIndex, contractTier) {
-        return await this.program.rpc.updatePerpMarketContractTier(contractTier, {
+        const tx = await this.program.transaction.updatePerpMarketContractTier(contractTier, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateExchangeStatus(exchangeStatus) {
-        return await this.program.rpc.updateExchangeStatus(exchangeStatus, {
+        const tx = await this.program.transaction.updateExchangeStatus(exchangeStatus, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpAuctionDuration(minDuration) {
         return await this.program.rpc.updatePerpAuctionDuration(typeof minDuration === 'number' ? minDuration : minDuration.toNumber(), {

package/lib/driftClient.d.ts

@@ -3,12 +3,12 @@
 import { AnchorProvider, BN, Program } from '@project-serum/anchor';
 import { StateAccount, IWallet, PositionDirection, UserAccount, PerpMarketAccount, OrderParams, Order, SpotMarketAccount, SpotPosition, MakerInfo, TakerInfo, OptionalOrderParams, ReferrerInfo, MarketType, SerumV3FulfillmentConfigAccount } from './types';
 import * as anchor from '@project-serum/anchor';
-import { Connection, PublicKey, TransactionSignature, ConfirmOptions, Transaction, TransactionInstruction, AccountMeta } from '@solana/web3.js';
+import { Connection, PublicKey, TransactionSignature, ConfirmOptions, Transaction, TransactionInstruction, AccountMeta, Signer } from '@solana/web3.js';
 import { TokenFaucet } from './tokenFaucet';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { DriftClientAccountSubscriber, DriftClientAccountEvents, DataAndSlot } from './accounts/types';
-import { TxSender } from './tx/types';
+import { TxSender, TxSigAndSlot } from './tx/types';
 import { OraclePriceData } from './oracles/types';
 import { DriftClientConfig } from './driftClientConfig';
 import { User } from './user';
@@ -253,5 +253,6 @@ export declare class DriftClient {
     settleRevenueToInsuranceFund(marketIndex: number): Promise<TransactionSignature>;
     resolvePerpPnlDeficit(spotMarketIndex: number, perpMarketIndex: number): Promise<TransactionSignature>;
     getResolvePerpPnlDeficitIx(spotMarketIndex: number, perpMarketIndex: number): Promise<TransactionInstruction>;
+    sendTransaction(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
 }
 export {};