@drift-labs/sdk 2.73.0-beta.1 → 2.74.0-beta.0

package/VERSION

@@ -1 +1 @@
-2.73.0-beta.1
+2.74.0-beta.0

package/lib/adminClient.js

@@ -216,13 +216,16 @@ class AdminClient extends driftClient_1.DriftClient {
         return txSig;
     }
     async updatePerpMarketConcentrationScale(perpMarketIndex, concentrationScale) {
-        return await this.program.rpc.updatePerpMarketConcentrationCoef(concentrationScale, {
+        const updatePerpMarketConcentrationCoefIx = await this.program.instruction.updatePerpMarketConcentrationCoef(concentrationScale, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketConcentrationCoefIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async moveAmmToPrice(perpMarketIndex, targetPrice) {
         const perpMarket = this.getPerpMarketAccount(perpMarketIndex);
@@ -259,7 +262,7 @@ class AdminClient extends driftClient_1.DriftClient {
     async updatePerpMarketAmmOracleTwap(perpMarketIndex) {
         const ammData = this.getPerpMarketAccount(perpMarketIndex).amm;
         const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
-        return await this.program.rpc.updatePerpMarketAmmOracleTwap({
+        const updatePerpMarketAmmOracleTwapIx = await this.program.instruction.updatePerpMarketAmmOracleTwap({
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
@@ -267,11 +270,14 @@ class AdminClient extends driftClient_1.DriftClient {
                 perpMarket: perpMarketPublicKey,
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketAmmOracleTwapIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async resetPerpMarketAmmOracleTwap(perpMarketIndex) {
         const ammData = this.getPerpMarketAccount(perpMarketIndex).amm;
         const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
-        return await this.program.rpc.resetPerpMarketAmmOracleTwap({
+        const resetPerpMarketAmmOracleTwapIx = await this.program.instruction.resetPerpMarketAmmOracleTwap({
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
@@ -279,6 +285,9 @@ class AdminClient extends driftClient_1.DriftClient {
                 perpMarket: perpMarketPublicKey,
             },
         });
+        const tx = await this.buildTransaction(resetPerpMarketAmmOracleTwapIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async depositIntoPerpMarketFeePool(perpMarketIndex, amount, sourceVault) {
         const spotMarket = this.getQuoteSpotMarketAccount();
@@ -312,22 +321,28 @@ class AdminClient extends driftClient_1.DriftClient {
     async updatePerpMarketCurveUpdateIntensity(perpMarketIndex, curveUpdateIntensity) {
         // assert(curveUpdateIntensity >= 0 && curveUpdateIntensity <= 100);
         // assert(Number.isInteger(curveUpdateIntensity));
-        return await this.program.rpc.updatePerpMarketCurveUpdateIntensity(curveUpdateIntensity, {
+        const updatePerpMarketCurveUpdateIntensityIx = await this.program.instruction.updatePerpMarketCurveUpdateIntensity(curveUpdateIntensity, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketCurveUpdateIntensityIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketTargetBaseAssetAmountPerLp(perpMarketIndex, targetBaseAssetAmountPerLP) {
-        return await this.program.rpc.updatePerpMarketTargetBaseAssetAmountPerLp(targetBaseAssetAmountPerLP, {
+        const updatePerpMarketTargetBaseAssetAmountPerLpIx = await this.program.instruction.updatePerpMarketTargetBaseAssetAmountPerLp(targetBaseAssetAmountPerLP, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketTargetBaseAssetAmountPerLpIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketMarginRatio(perpMarketIndex, marginRatioInitial, marginRatioMaintenance) {
         const updatePerpMarketMarginRatioIx = await this.program.instruction.updatePerpMarketMarginRatio(marginRatioInitial, marginRatioMaintenance, {
@@ -342,13 +357,16 @@ class AdminClient extends driftClient_1.DriftClient {
         return txSig;
     }
     async updatePerpMarketImfFactor(perpMarketIndex, imfFactor, unrealizedPnlImfFactor) {
-        return await this.program.rpc.updatePerpMarketImfFactor(imfFactor, unrealizedPnlImfFactor, {
+        const updatePerpMarketImfFactorIx = await this.program.instruction.updatePerpMarketImfFactor(imfFactor, unrealizedPnlImfFactor, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketImfFactorIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketBaseSpread(perpMarketIndex, baseSpread) {
         const updatePerpMarketBaseSpreadIx = await this.program.instruction.updatePerpMarketBaseSpread(baseSpread, {
@@ -389,33 +407,42 @@ class AdminClient extends driftClient_1.DriftClient {
     }
     async updateSpotMarketName(spotMarketIndex, name) {
         const nameBuffer = (0, userName_1.encodeName)(name);
-        return await this.program.rpc.updateSpotMarketName(nameBuffer, {
+        const updateSpotMarketNameIx = await this.program.instruction.updateSpotMarketName(nameBuffer, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updateSpotMarketNameIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketPerLpBase(perpMarketIndex, perLpBase) {
         const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
-        return await this.program.rpc.updatePerpMarketPerLpBase(perLpBase, {
+        const updatePerpMarketPerLpBaseIx = await this.program.instruction.updatePerpMarketPerLpBase(perLpBase, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: perpMarketPublicKey,
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketPerLpBaseIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketMaxSpread(perpMarketIndex, maxSpread) {
         const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
-        return await this.program.rpc.updatePerpMarketMaxSpread(maxSpread, {
+        const updatePerpMarketMaxSpreadIx = await this.program.instruction.updatePerpMarketMaxSpread(maxSpread, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: perpMarketPublicKey,
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketMaxSpreadIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpFeeStructure(feeStructure) {
         const updatePerpFeeStructureIx = this.program.instruction.updatePerpFeeStructure(feeStructure, {
@@ -440,28 +467,37 @@ class AdminClient extends driftClient_1.DriftClient {
         return txSig;
     }
     async updateInitialPctToLiquidate(initialPctToLiquidate) {
-        return await this.program.rpc.updateInitialPctToLiquidate(initialPctToLiquidate, {
+        const updateInitialPctToLiquidateIx = await this.program.instruction.updateInitialPctToLiquidate(initialPctToLiquidate, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const tx = await this.buildTransaction(updateInitialPctToLiquidateIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateLiquidationDuration(liquidationDuration) {
-        return await this.program.rpc.updateLiquidationDuration(liquidationDuration, {
+        const updateLiquidationDurationIx = await this.program.instruction.updateLiquidationDuration(liquidationDuration, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const tx = await this.buildTransaction(updateLiquidationDurationIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateLiquidationMarginBufferRatio(updateLiquidationMarginBufferRatio) {
-        return await this.program.rpc.updateLiquidationMarginBufferRatio(updateLiquidationMarginBufferRatio, {
+        const updateLiquidationMarginBufferRatioIx = await this.program.instruction.updateLiquidationMarginBufferRatio(updateLiquidationMarginBufferRatio, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const tx = await this.buildTransaction(updateLiquidationMarginBufferRatioIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateOracleGuardRails(oracleGuardRails) {
         const updateOracleGuardRailsIx = await this.program.instruction.updateOracleGuardRails(oracleGuardRails, {
@@ -475,28 +511,37 @@ class AdminClient extends driftClient_1.DriftClient {
         return txSig;
     }
     async updateStateSettlementDuration(settlementDuration) {
-        return await this.program.rpc.updateStateSettlementDuration(settlementDuration, {
+        const updateStateSettlementDurationIx = await this.program.instruction.updateStateSettlementDuration(settlementDuration, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const tx = await this.buildTransaction(updateStateSettlementDurationIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateStateMaxNumberOfSubAccounts(maxNumberOfSubAccounts) {
-        return await this.program.rpc.updateStateMaxNumberOfSubAccounts(maxNumberOfSubAccounts, {
+        const updateStateMaxNumberOfSubAccountsIx = await this.program.instruction.updateStateMaxNumberOfSubAccounts(maxNumberOfSubAccounts, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const tx = await this.buildTransaction(updateStateMaxNumberOfSubAccountsIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateStateMaxInitializeUserFee(maxInitializeUserFee) {
-        return await this.program.rpc.updateStateMaxInitializeUserFee(maxInitializeUserFee, {
+        const updateStateMaxInitializeUserFeeIx = await this.program.instruction.updateStateMaxInitializeUserFee(maxInitializeUserFee, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const tx = await this.buildTransaction(updateStateMaxInitializeUserFeeIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateWithdrawGuardThreshold(spotMarketIndex, withdrawGuardThreshold) {
         const updateWithdrawGuardThresholdIx = await this.program.instruction.updateWithdrawGuardThreshold(withdrawGuardThreshold, {
@@ -607,43 +652,55 @@ class AdminClient extends driftClient_1.DriftClient {
         return txSig;
     }
     async updatePerpMarketMinOrderSize(perpMarketIndex, orderSize) {
-        return await this.program.rpc.updatePerpMarketMinOrderSize(orderSize, {
+        const updatePerpMarketMinOrderSizeIx = await this.program.instruction.updatePerpMarketMinOrderSize(orderSize, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketMinOrderSizeIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateSpotMarketStepSizeAndTickSize(spotMarketIndex, stepSize, tickSize) {
-        return await this.program.rpc.updateSpotMarketStepSizeAndTickSize(stepSize, tickSize, {
+        const updateSpotMarketStepSizeAndTickSizeIx = await this.program.instruction.updateSpotMarketStepSizeAndTickSize(stepSize, tickSize, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updateSpotMarketStepSizeAndTickSizeIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateSpotMarketMinOrderSize(spotMarketIndex, orderSize) {
-        return await this.program.rpc.updateSpotMarketMinOrderSize(orderSize, {
+        const updateSpotMarketMinOrderSizeIx = await this.program.instruction.updateSpotMarketMinOrderSize(orderSize, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updateSpotMarketMinOrderSizeIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePerpMarketExpiry(perpMarketIndex, expiryTs) {
-        return await this.program.rpc.updatePerpMarketExpiry(expiryTs, {
+        const updatePerpMarketExpiryIx = await this.program.instruction.updatePerpMarketExpiry(expiryTs, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketExpiryIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateSpotMarketOracle(spotMarketIndex, oracle, oracleSource) {
-        return await this.program.rpc.updateSpotMarketOracle(oracle, oracleSource, {
+        const updateSpotMarketOracleIx = await this.program.instruction.updateSpotMarketOracle(oracle, oracleSource, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
@@ -651,42 +708,57 @@ class AdminClient extends driftClient_1.DriftClient {
                 oracle: oracle,
             },
         });
+        const tx = await this.buildTransaction(updateSpotMarketOracleIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateSpotMarketOrdersEnabled(spotMarketIndex, ordersEnabled) {
-        return await this.program.rpc.updateSpotMarketOrdersEnabled(ordersEnabled, {
+        const updateSpotMarketOrdersEnabledIx = await this.program.instruction.updateSpotMarketOrdersEnabled(ordersEnabled, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updateSpotMarketOrdersEnabledIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateSerumFulfillmentConfigStatus(serumFulfillmentConfig, status) {
-        return await this.program.rpc.updateSerumFulfillmentConfigStatus(status, {
+        const updateSerumFulfillmentConfigStatusIx = await this.program.instruction.updateSerumFulfillmentConfigStatus(status, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 serumFulfillmentConfig,
             },
         });
+        const tx = await this.buildTransaction(updateSerumFulfillmentConfigStatusIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updatePhoenixFulfillmentConfigStatus(phoenixFulfillmentConfig, status) {
-        return await this.program.rpc.phoenixFulfillmentConfigStatus(status, {
+        const updatePhoenixFulfillmentConfigStatusIx = await this.program.instruction.phoenixFulfillmentConfigStatus(status, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 phoenixFulfillmentConfig,
             },
         });
+        const tx = await this.buildTransaction(updatePhoenixFulfillmentConfigStatusIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateSpotMarketExpiry(spotMarketIndex, expiryTs) {
-        return await this.program.rpc.updateSpotMarketExpiry(expiryTs, {
+        const updateSpotMarketExpiryIx = await this.program.instruction.updateSpotMarketExpiry(expiryTs, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updateSpotMarketExpiryIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateWhitelistMint(whitelistMint) {
         const updateWhitelistMintIx = await this.program.instruction.updateWhitelistMint(whitelistMint, {
@@ -711,22 +783,28 @@ class AdminClient extends driftClient_1.DriftClient {
         return txSig;
     }
     async updateSpotMarketMarginWeights(spotMarketIndex, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = 0) {
-        return await this.program.rpc.updateSpotMarketMarginWeights(initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, {
+        const updateSpotMarketMarginWeightsIx = await this.program.instruction.updateSpotMarketMarginWeights(initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updateSpotMarketMarginWeightsIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateSpotMarketBorrowRate(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate) {
-        return await this.program.rpc.updateSpotMarketBorrowRate(optimalUtilization, optimalBorrowRate, optimalMaxRate, {
+        const updateSpotMarketBorrowRateIx = await this.program.instruction.updateSpotMarketBorrowRate(optimalUtilization, optimalBorrowRate, optimalMaxRate, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updateSpotMarketBorrowRateIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
     }
     async updateSpotMarketAssetTier(spotMarketIndex, assetTier) {
         const updateSpotMarketAssetTierIx = await this.program.instruction.updateSpotMarketAssetTier(assetTier, {
@@ -992,10 +1070,12 @@ class AdminClient extends driftClient_1.DriftClient {
             price: price || null,
             maxPrice: maxPrice || null,
         };
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
         const updatePrelaunchOracleParamsIx = await this.program.instruction.updatePrelaunchOracleParams(params, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
+                perpMarket: perpMarketPublicKey,
                 prelaunchOracle: await (0, pda_1.getPrelaunchOraclePublicKey)(this.program.programId, perpMarketIndex),
             },
         });

package/lib/idl/drift.json

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

package/package.json

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