@drift-labs/sdk 2.72.0-beta.3 → 2.73.0-beta.0

package/VERSION

@@ -1 +1 @@
-2.72.0-beta.3
+2.73.0-beta.0

package/lib/adminClient.d.ts

@@ -23,7 +23,6 @@ export declare class AdminClient extends DriftClient {
     updatePerpMarketCurveUpdateIntensity(perpMarketIndex: number, curveUpdateIntensity: number): Promise<TransactionSignature>;
     updatePerpMarketTargetBaseAssetAmountPerLp(perpMarketIndex: number, targetBaseAssetAmountPerLP: number): Promise<TransactionSignature>;
     updatePerpMarketMarginRatio(perpMarketIndex: number, marginRatioInitial: number, marginRatioMaintenance: number): Promise<TransactionSignature>;
-    updatePerpMarketFundingPeriod(perpMarketIndex: number, fundingPeriod: BN): Promise<TransactionSignature>;
     updatePerpMarketImfFactor(perpMarketIndex: number, imfFactor: number, unrealizedPnlImfFactor: number): Promise<TransactionSignature>;
     updatePerpMarketBaseSpread(perpMarketIndex: number, baseSpread: number): Promise<TransactionSignature>;
     updateAmmJitIntensity(perpMarketIndex: number, ammJitIntensity: number): Promise<TransactionSignature>;
@@ -84,5 +83,4 @@ export declare class AdminClient extends DriftClient {
     updateProtocolIfSharesTransferConfig(whitelistedSigners?: PublicKey[], maxTransferPerEpoch?: BN): Promise<TransactionSignature>;
     initializePrelaunchOracle(perpMarketIndex: number, price?: BN, maxPrice?: BN): Promise<TransactionSignature>;
     updatePrelaunchOracleParams(perpMarketIndex: number, price?: BN, maxPrice?: BN): Promise<TransactionSignature>;
-    deletePrelaunchOracle(perpMarketIndex: number): Promise<TransactionSignature>;
 }

package/lib/adminClient.js

@@ -341,18 +341,6 @@ class AdminClient extends driftClient_1.DriftClient {
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
-    async updatePerpMarketFundingPeriod(perpMarketIndex, fundingPeriod) {
-        const updatePerpMarketMarginRatioIx = await this.program.instruction.updatePerpMarketFundingRate(fundingPeriod, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
-            },
-        });
-        const tx = await this.buildTransaction(updatePerpMarketMarginRatioIx);
-        const { txSig } = await this.sendTransaction(tx, [], this.opts);
-        return txSig;
-    }
     async updatePerpMarketImfFactor(perpMarketIndex, imfFactor, unrealizedPnlImfFactor) {
         return await this.program.rpc.updatePerpMarketImfFactor(imfFactor, unrealizedPnlImfFactor, {
             accounts: {
@@ -824,104 +812,137 @@ class AdminClient extends driftClient_1.DriftClient {
         return txSig;
     }
     async updatePerpAuctionDuration(minDuration) {
-        return await this.program.rpc.updatePerpAuctionDuration(typeof minDuration === 'number' ? minDuration : minDuration.toNumber(), {
+        const updatePerpAuctionDurationIx = await this.program.instruction.updatePerpAuctionDuration(typeof minDuration === 'number' ? minDuration : minDuration.toNumber(), {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const tx = await this.buildTransaction(updatePerpAuctionDurationIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateSpotAuctionDuration(defaultAuctionDuration) {
-        return await this.program.rpc.updateSpotAuctionDuration(defaultAuctionDuration, {
+        const updateSpotAuctionDurationIx = await this.program.instruction.updateSpotAuctionDuration(defaultAuctionDuration, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const tx = await this.buildTransaction(updateSpotAuctionDurationIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketMaxFillReserveFraction(perpMarketIndex, maxBaseAssetAmountRatio) {
-        return await this.program.rpc.updatePerpMarketMaxFillReserveFraction(maxBaseAssetAmountRatio, {
+        const updatePerpMarketMaxFillReserveFractionIx = await this.program.instruction.updatePerpMarketMaxFillReserveFraction(maxBaseAssetAmountRatio, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketMaxFillReserveFractionIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateMaxSlippageRatio(perpMarketIndex, maxSlippageRatio) {
-        return await this.program.rpc.updateMaxSlippageRatio(maxSlippageRatio, {
+        const updateMaxSlippageRatioIx = await this.program.instruction.updateMaxSlippageRatio(maxSlippageRatio, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: this.getPerpMarketAccount(perpMarketIndex).pubkey,
             },
         });
+        const tx = await this.buildTransaction(updateMaxSlippageRatioIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketUnrealizedAssetWeight(perpMarketIndex, unrealizedInitialAssetWeight, unrealizedMaintenanceAssetWeight) {
-        return await this.program.rpc.updatePerpMarketUnrealizedAssetWeight(unrealizedInitialAssetWeight, unrealizedMaintenanceAssetWeight, {
+        const updatePerpMarketUnrealizedAssetWeightIx = await this.program.instruction.updatePerpMarketUnrealizedAssetWeight(unrealizedInitialAssetWeight, unrealizedMaintenanceAssetWeight, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketUnrealizedAssetWeightIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketMaxImbalances(perpMarketIndex, unrealizedMaxImbalance, maxRevenueWithdrawPerPeriod, quoteMaxInsurance) {
-        return await this.program.rpc.updatePerpMarketMaxImbalances(unrealizedMaxImbalance, maxRevenueWithdrawPerPeriod, quoteMaxInsurance, {
+        const updatePerpMarketMaxImabalancesIx = await this.program.instruction.updatePerpMarketMaxImbalances(unrealizedMaxImbalance, maxRevenueWithdrawPerPeriod, quoteMaxInsurance, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketMaxImabalancesIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketMaxOpenInterest(perpMarketIndex, maxOpenInterest) {
-        return await this.program.rpc.updatePerpMarketMaxOpenInterest(maxOpenInterest, {
+        const updatePerpMarketMaxOpenInterestIx = await this.program.instruction.updatePerpMarketMaxOpenInterest(maxOpenInterest, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketMaxOpenInterestIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketFeeAdjustment(perpMarketIndex, feeAdjustment) {
-        return await this.program.rpc.updatePerpMarketFeeAdjustment(feeAdjustment, {
+        const updatepPerpMarketFeeAdjustmentIx = await this.program.instruction.updatePerpMarketFeeAdjustment(feeAdjustment, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatepPerpMarketFeeAdjustmentIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateSerumVault(srmVault) {
-        return await this.program.rpc.updateSerumVault({
+        const updateSerumVaultIx = await this.program.instruction.updateSerumVault(srmVault, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 srmVault: srmVault,
             },
         });
+        const tx = await this.buildTransaction(updateSerumVaultIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketLiquidationFee(perpMarketIndex, liquidatorFee, ifLiquidationFee) {
-        return await this.program.rpc.updatePerpMarketLiquidationFee(liquidatorFee, ifLiquidationFee, {
+        const updatePerpMarketLiquidationFeeIx = await this.program.instruction.updatePerpMarketLiquidationFee(liquidatorFee, ifLiquidationFee, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketLiquidationFeeIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateSpotMarketLiquidationFee(spotMarketIndex, liquidatorFee, ifLiquidationFee) {
-        return await this.program.rpc.updateSpotMarketLiquidationFee(liquidatorFee, ifLiquidationFee, {
+        const updateSpotMarketLiquidationFeeIx = await this.program.instruction.updateSpotMarketLiquidationFee(liquidatorFee, ifLiquidationFee, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updateSpotMarketLiquidationFeeIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async initializeProtocolIfSharesTransferConfig() {
-        return await this.program.rpc.initializeProtocolIfSharesTransferConfig({
+        const initializeProtocolIfSharesTransferConfigIx = await this.program.instruction.initializeProtocolIfSharesTransferConfig({
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
@@ -930,15 +951,21 @@ class AdminClient extends driftClient_1.DriftClient {
                 protocolIfSharesTransferConfig: (0, pda_1.getProtocolIfSharesTransferConfigPublicKey)(this.program.programId),
             },
         });
+        const tx = await this.buildTransaction(initializeProtocolIfSharesTransferConfigIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateProtocolIfSharesTransferConfig(whitelistedSigners, maxTransferPerEpoch) {
-        return await this.program.rpc.updateProtocolIfSharesTransferConfig(whitelistedSigners || null, maxTransferPerEpoch, {
+        const updateProtocolIfSharesTransferConfigIx = await this.program.instruction.updateProtocolIfSharesTransferConfig(whitelistedSigners || null, maxTransferPerEpoch, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 protocolIfSharesTransferConfig: (0, pda_1.getProtocolIfSharesTransferConfigPublicKey)(this.program.programId),
             },
         });
+        const tx = await this.buildTransaction(updateProtocolIfSharesTransferConfigIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async initializePrelaunchOracle(perpMarketIndex, price, maxPrice) {
         const params = {
@@ -946,7 +973,7 @@ class AdminClient extends driftClient_1.DriftClient {
             price: price || null,
             maxPrice: maxPrice || null,
         };
-        return await this.program.rpc.initializePrelaunchOracle(params, {
+        const initializePrelaunchOracleIx = await this.program.instruction.initializePrelaunchOracle(params, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
@@ -955,6 +982,9 @@ class AdminClient extends driftClient_1.DriftClient {
                 systemProgram: anchor.web3.SystemProgram.programId,
             },
         });
+        const tx = await this.buildTransaction(initializePrelaunchOracleIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePrelaunchOracleParams(perpMarketIndex, price, maxPrice) {
         const params = {
@@ -962,24 +992,16 @@ class AdminClient extends driftClient_1.DriftClient {
             price: price || null,
             maxPrice: maxPrice || null,
         };
-        return await this.program.rpc.updatePrelaunchOracleParams(params, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                prelaunchOracle: await (0, pda_1.getPrelaunchOraclePublicKey)(this.program.programId, perpMarketIndex),
-                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
-            },
-        });
-    }
-    async deletePrelaunchOracle(perpMarketIndex) {
-        return await this.program.rpc.deletePrelaunchOracle(perpMarketIndex, {
+        const updatePrelaunchOracleParamsIx = await this.program.instruction.updatePrelaunchOracleParams(params, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 prelaunchOracle: await (0, pda_1.getPrelaunchOraclePublicKey)(this.program.programId, perpMarketIndex),
-                perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePrelaunchOracleParamsIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
 }
 exports.AdminClient = AdminClient;

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.71.0",
+    "version": "2.72.0",
     "name": "drift",
     "instructions": [
         {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.72.0-beta.3",
+	"version": "2.73.0-beta.0",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/adminClient.ts

@@ -650,32 +650,6 @@ export class AdminClient extends DriftClient {
 		return txSig;
 	}
 
-	public async updatePerpMarketFundingPeriod(
-		perpMarketIndex: number,
-		fundingPeriod: BN
-	): Promise<TransactionSignature> {
-		const updatePerpMarketMarginRatioIx =
-			await this.program.instruction.updatePerpMarketFundingRate(
-				fundingPeriod,
-				{
-					accounts: {
-						admin: this.wallet.publicKey,
-						state: await this.getStatePublicKey(),
-						perpMarket: await getPerpMarketPublicKey(
-							this.program.programId,
-							perpMarketIndex
-						),
-					},
-				}
-			);
-
-		const tx = await this.buildTransaction(updatePerpMarketMarginRatioIx);
-
-		const { txSig } = await this.sendTransaction(tx, [], this.opts);
-
-		return txSig;
-	}
-
 	public async updatePerpMarketImfFactor(
 		perpMarketIndex: number,
 		imfFactor: number,
@@ -1601,61 +1575,91 @@ export class AdminClient extends DriftClient {
 	public async updatePerpAuctionDuration(
 		minDuration: BN | number
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updatePerpAuctionDuration(
-			typeof minDuration === 'number' ? minDuration : minDuration.toNumber(),
-			{
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: await this.getStatePublicKey(),
-				},
-			}
-		);
+		const updatePerpAuctionDurationIx =
+			await this.program.instruction.updatePerpAuctionDuration(
+				typeof minDuration === 'number' ? minDuration : minDuration.toNumber(),
+				{
+					accounts: {
+						admin: this.wallet.publicKey,
+						state: await this.getStatePublicKey(),
+					},
+				}
+			);
+
+		const tx = await this.buildTransaction(updatePerpAuctionDurationIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
 	}
 
 	public async updateSpotAuctionDuration(
 		defaultAuctionDuration: number
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateSpotAuctionDuration(
-			defaultAuctionDuration,
-			{
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: await this.getStatePublicKey(),
-				},
-			}
-		);
+		const updateSpotAuctionDurationIx =
+			await this.program.instruction.updateSpotAuctionDuration(
+				defaultAuctionDuration,
+				{
+					accounts: {
+						admin: this.wallet.publicKey,
+						state: await this.getStatePublicKey(),
+					},
+				}
+			);
+
+		const tx = await this.buildTransaction(updateSpotAuctionDurationIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
 	}
 
 	public async updatePerpMarketMaxFillReserveFraction(
 		perpMarketIndex: number,
 		maxBaseAssetAmountRatio: number
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updatePerpMarketMaxFillReserveFraction(
-			maxBaseAssetAmountRatio,
-			{
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: await this.getStatePublicKey(),
-					perpMarket: await getPerpMarketPublicKey(
-						this.program.programId,
-						perpMarketIndex
-					),
-				},
-			}
+		const updatePerpMarketMaxFillReserveFractionIx =
+			await this.program.instruction.updatePerpMarketMaxFillReserveFraction(
+				maxBaseAssetAmountRatio,
+				{
+					accounts: {
+						admin: this.wallet.publicKey,
+						state: await this.getStatePublicKey(),
+						perpMarket: await getPerpMarketPublicKey(
+							this.program.programId,
+							perpMarketIndex
+						),
+					},
+				}
+			);
+
+		const tx = await this.buildTransaction(
+			updatePerpMarketMaxFillReserveFractionIx
 		);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
 	}
 
 	public async updateMaxSlippageRatio(
 		perpMarketIndex: number,
 		maxSlippageRatio: number
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateMaxSlippageRatio(maxSlippageRatio, {
-			accounts: {
-				admin: this.wallet.publicKey,
-				state: await this.getStatePublicKey(),
-				perpMarket: this.getPerpMarketAccount(perpMarketIndex).pubkey,
-			},
-		});
+		const updateMaxSlippageRatioIx =
+			await this.program.instruction.updateMaxSlippageRatio(maxSlippageRatio, {
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					perpMarket: this.getPerpMarketAccount(perpMarketIndex).pubkey,
+				},
+			});
+
+		const tx = await this.buildTransaction(updateMaxSlippageRatioIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
 	}
 
 	public async updatePerpMarketUnrealizedAssetWeight(
@@ -1663,20 +1667,29 @@ export class AdminClient extends DriftClient {
 		unrealizedInitialAssetWeight: number,
 		unrealizedMaintenanceAssetWeight: number
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updatePerpMarketUnrealizedAssetWeight(
-			unrealizedInitialAssetWeight,
-			unrealizedMaintenanceAssetWeight,
-			{
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: await this.getStatePublicKey(),
-					perpMarket: await getPerpMarketPublicKey(
-						this.program.programId,
-						perpMarketIndex
-					),
-				},
-			}
+		const updatePerpMarketUnrealizedAssetWeightIx =
+			await this.program.instruction.updatePerpMarketUnrealizedAssetWeight(
+				unrealizedInitialAssetWeight,
+				unrealizedMaintenanceAssetWeight,
+				{
+					accounts: {
+						admin: this.wallet.publicKey,
+						state: await this.getStatePublicKey(),
+						perpMarket: await getPerpMarketPublicKey(
+							this.program.programId,
+							perpMarketIndex
+						),
+					},
+				}
+			);
+
+		const tx = await this.buildTransaction(
+			updatePerpMarketUnrealizedAssetWeightIx
 		);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
 	}
 
 	public async updatePerpMarketMaxImbalances(
@@ -1685,89 +1698,129 @@ export class AdminClient extends DriftClient {
 		maxRevenueWithdrawPerPeriod: BN,
 		quoteMaxInsurance: BN
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updatePerpMarketMaxImbalances(
-			unrealizedMaxImbalance,
-			maxRevenueWithdrawPerPeriod,
-			quoteMaxInsurance,
-			{
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: await this.getStatePublicKey(),
-					perpMarket: await getPerpMarketPublicKey(
-						this.program.programId,
-						perpMarketIndex
-					),
-				},
-			}
-		);
+		const updatePerpMarketMaxImabalancesIx =
+			await this.program.instruction.updatePerpMarketMaxImbalances(
+				unrealizedMaxImbalance,
+				maxRevenueWithdrawPerPeriod,
+				quoteMaxInsurance,
+				{
+					accounts: {
+						admin: this.wallet.publicKey,
+						state: await this.getStatePublicKey(),
+						perpMarket: await getPerpMarketPublicKey(
+							this.program.programId,
+							perpMarketIndex
+						),
+					},
+				}
+			);
+
+		const tx = await this.buildTransaction(updatePerpMarketMaxImabalancesIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
 	}
 
 	public async updatePerpMarketMaxOpenInterest(
 		perpMarketIndex: number,
 		maxOpenInterest: BN
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updatePerpMarketMaxOpenInterest(
-			maxOpenInterest,
-			{
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: await this.getStatePublicKey(),
-					perpMarket: await getPerpMarketPublicKey(
-						this.program.programId,
-						perpMarketIndex
-					),
-				},
-			}
-		);
+		const updatePerpMarketMaxOpenInterestIx =
+			await this.program.instruction.updatePerpMarketMaxOpenInterest(
+				maxOpenInterest,
+				{
+					accounts: {
+						admin: this.wallet.publicKey,
+						state: await this.getStatePublicKey(),
+						perpMarket: await getPerpMarketPublicKey(
+							this.program.programId,
+							perpMarketIndex
+						),
+					},
+				}
+			);
+
+		const tx = await this.buildTransaction(updatePerpMarketMaxOpenInterestIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
 	}
 
 	public async updatePerpMarketFeeAdjustment(
 		perpMarketIndex: number,
 		feeAdjustment: number
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updatePerpMarketFeeAdjustment(feeAdjustment, {
-			accounts: {
-				admin: this.wallet.publicKey,
-				state: await this.getStatePublicKey(),
-				perpMarket: await getPerpMarketPublicKey(
-					this.program.programId,
-					perpMarketIndex
-				),
-			},
-		});
+		const updatepPerpMarketFeeAdjustmentIx =
+			await this.program.instruction.updatePerpMarketFeeAdjustment(
+				feeAdjustment,
+				{
+					accounts: {
+						admin: this.wallet.publicKey,
+						state: await this.getStatePublicKey(),
+						perpMarket: await getPerpMarketPublicKey(
+							this.program.programId,
+							perpMarketIndex
+						),
+					},
+				}
+			);
+
+		const tx = await this.buildTransaction(updatepPerpMarketFeeAdjustmentIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
 	}
 
 	public async updateSerumVault(
 		srmVault: PublicKey
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateSerumVault({
-			accounts: {
-				admin: this.wallet.publicKey,
-				state: await this.getStatePublicKey(),
-				srmVault: srmVault,
-			},
-		});
-	}
-
-	public async updatePerpMarketLiquidationFee(
-		perpMarketIndex: number,
-		liquidatorFee: number,
-		ifLiquidationFee: number
-	): Promise<TransactionSignature> {
-		return await this.program.rpc.updatePerpMarketLiquidationFee(
-			liquidatorFee,
-			ifLiquidationFee,
+		const updateSerumVaultIx = await this.program.instruction.updateSerumVault(
+			srmVault,
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
-					perpMarket: await getPerpMarketPublicKey(
-						this.program.programId,
-						perpMarketIndex
-					),
+					srmVault: srmVault,
 				},
 			}
 		);
+
+		const tx = await this.buildTransaction(updateSerumVaultIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
+	}
+
+	public async updatePerpMarketLiquidationFee(
+		perpMarketIndex: number,
+		liquidatorFee: number,
+		ifLiquidationFee: number
+	): Promise<TransactionSignature> {
+		const updatePerpMarketLiquidationFeeIx =
+			await this.program.instruction.updatePerpMarketLiquidationFee(
+				liquidatorFee,
+				ifLiquidationFee,
+				{
+					accounts: {
+						admin: this.wallet.publicKey,
+						state: await this.getStatePublicKey(),
+						perpMarket: await getPerpMarketPublicKey(
+							this.program.programId,
+							perpMarketIndex
+						),
+					},
+				}
+			);
+
+		const tx = await this.buildTransaction(updatePerpMarketLiquidationFeeIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
 	}
 
 	public async updateSpotMarketLiquidationFee(
@@ -1775,51 +1828,78 @@ export class AdminClient extends DriftClient {
 		liquidatorFee: number,
 		ifLiquidationFee: number
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateSpotMarketLiquidationFee(
-			liquidatorFee,
-			ifLiquidationFee,
-			{
+		const updateSpotMarketLiquidationFeeIx =
+			await this.program.instruction.updateSpotMarketLiquidationFee(
+				liquidatorFee,
+				ifLiquidationFee,
+				{
+					accounts: {
+						admin: this.wallet.publicKey,
+						state: await this.getStatePublicKey(),
+						spotMarket: await getSpotMarketPublicKey(
+							this.program.programId,
+							spotMarketIndex
+						),
+					},
+				}
+			);
+
+		const tx = await this.buildTransaction(updateSpotMarketLiquidationFeeIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
+	}
+
+	public async initializeProtocolIfSharesTransferConfig(): Promise<TransactionSignature> {
+		const initializeProtocolIfSharesTransferConfigIx =
+			await this.program.instruction.initializeProtocolIfSharesTransferConfig({
 				accounts: {
 					admin: this.wallet.publicKey,
 					state: await this.getStatePublicKey(),
-					spotMarket: await getSpotMarketPublicKey(
-						this.program.programId,
-						spotMarketIndex
-					),
+					rent: SYSVAR_RENT_PUBKEY,
+					systemProgram: anchor.web3.SystemProgram.programId,
+					protocolIfSharesTransferConfig:
+						getProtocolIfSharesTransferConfigPublicKey(this.program.programId),
 				},
-			}
+			});
+
+		const tx = await this.buildTransaction(
+			initializeProtocolIfSharesTransferConfigIx
 		);
-	}
 
-	public async initializeProtocolIfSharesTransferConfig(): Promise<TransactionSignature> {
-		return await this.program.rpc.initializeProtocolIfSharesTransferConfig({
-			accounts: {
-				admin: this.wallet.publicKey,
-				state: await this.getStatePublicKey(),
-				rent: SYSVAR_RENT_PUBKEY,
-				systemProgram: anchor.web3.SystemProgram.programId,
-				protocolIfSharesTransferConfig:
-					getProtocolIfSharesTransferConfigPublicKey(this.program.programId),
-			},
-		});
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
 	}
 
 	public async updateProtocolIfSharesTransferConfig(
 		whitelistedSigners?: PublicKey[],
 		maxTransferPerEpoch?: BN
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateProtocolIfSharesTransferConfig(
-			whitelistedSigners || null,
-			maxTransferPerEpoch,
-			{
-				accounts: {
-					admin: this.wallet.publicKey,
-					state: await this.getStatePublicKey(),
-					protocolIfSharesTransferConfig:
-						getProtocolIfSharesTransferConfigPublicKey(this.program.programId),
-				},
-			}
+		const updateProtocolIfSharesTransferConfigIx =
+			await this.program.instruction.updateProtocolIfSharesTransferConfig(
+				whitelistedSigners || null,
+				maxTransferPerEpoch,
+				{
+					accounts: {
+						admin: this.wallet.publicKey,
+						state: await this.getStatePublicKey(),
+						protocolIfSharesTransferConfig:
+							getProtocolIfSharesTransferConfigPublicKey(
+								this.program.programId
+							),
+					},
+				}
+			);
+
+		const tx = await this.buildTransaction(
+			updateProtocolIfSharesTransferConfigIx
 		);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
 	}
 
 	public async initializePrelaunchOracle(
@@ -1832,18 +1912,26 @@ export class AdminClient extends DriftClient {
 			price: price || null,
 			maxPrice: maxPrice || null,
 		};
-		return await this.program.rpc.initializePrelaunchOracle(params, {
-			accounts: {
-				admin: this.wallet.publicKey,
-				state: await this.getStatePublicKey(),
-				prelaunchOracle: await getPrelaunchOraclePublicKey(
-					this.program.programId,
-					perpMarketIndex
-				),
-				rent: SYSVAR_RENT_PUBKEY,
-				systemProgram: anchor.web3.SystemProgram.programId,
-			},
-		});
+
+		const initializePrelaunchOracleIx =
+			await this.program.instruction.initializePrelaunchOracle(params, {
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					prelaunchOracle: await getPrelaunchOraclePublicKey(
+						this.program.programId,
+						perpMarketIndex
+					),
+					rent: SYSVAR_RENT_PUBKEY,
+					systemProgram: anchor.web3.SystemProgram.programId,
+				},
+			});
+
+		const tx = await this.buildTransaction(initializePrelaunchOracleIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
 	}
 
 	public async updatePrelaunchOracleParams(
@@ -1856,38 +1944,23 @@ export class AdminClient extends DriftClient {
 			price: price || null,
 			maxPrice: maxPrice || null,
 		};
-		return await this.program.rpc.updatePrelaunchOracleParams(params, {
-			accounts: {
-				admin: this.wallet.publicKey,
-				state: await this.getStatePublicKey(),
-				prelaunchOracle: await getPrelaunchOraclePublicKey(
-					this.program.programId,
-					perpMarketIndex
-				),
-				perpMarket: await getPerpMarketPublicKey(
-					this.program.programId,
-					perpMarketIndex
-				),
-			},
-		});
-	}
 
-	public async deletePrelaunchOracle(
-		perpMarketIndex: number
-	): Promise<TransactionSignature> {
-		return await this.program.rpc.deletePrelaunchOracle(perpMarketIndex, {
-			accounts: {
-				admin: this.wallet.publicKey,
-				state: await this.getStatePublicKey(),
-				prelaunchOracle: await getPrelaunchOraclePublicKey(
-					this.program.programId,
-					perpMarketIndex
-				),
-				perpMarket: await getPerpMarketPublicKey(
-					this.program.programId,
-					perpMarketIndex
-				),
-			},
-		});
+		const updatePrelaunchOracleParamsIx =
+			await this.program.instruction.updatePrelaunchOracleParams(params, {
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					prelaunchOracle: await getPrelaunchOraclePublicKey(
+						this.program.programId,
+						perpMarketIndex
+					),
+				},
+			});
+
+		const tx = await this.buildTransaction(updatePrelaunchOracleParamsIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
 	}
 }

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.71.0",
+  "version": "2.72.0",
   "name": "drift",
   "instructions": [
     {