@drift-labs/sdk 2.65.0-beta.8 → 2.66.0-beta.0

package/VERSION

@@ -1 +1 @@
-2.65.0-beta.8
+2.66.0-beta.0

package/lib/adminClient.js

@@ -44,7 +44,7 @@ class AdminClient extends driftClient_1.DriftClient {
             throw new Error('Clearing house already initialized');
         }
         const [driftStatePublicKey] = await (0, pda_1.getDriftStateAccountPublicKeyAndNonce)(this.program.programId);
-        const initializeTx = await this.program.transaction.initialize({
+        const initializeIx = await this.program.instruction.initialize({
             accounts: {
                 admin: this.wallet.publicKey,
                 state: driftStatePublicKey,
@@ -55,8 +55,9 @@ class AdminClient extends driftClient_1.DriftClient {
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
         });
-        const { txSig: initializeTxSig } = await super.sendTransaction(initializeTx, [], this.opts);
-        return [initializeTxSig];
+        const tx = await this.buildTransaction(initializeIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return [txSig];
     }
     async initializeSpotMarket(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = 0, liquidatorFee = 0, activeStatus = true, name = userName_1.DEFAULT_MARKET_NAME) {
         const spotMarketIndex = this.getStateAccount().numberOfSpotMarkets;
@@ -64,7 +65,7 @@ class AdminClient extends driftClient_1.DriftClient {
         const spotMarketVault = await (0, pda_1.getSpotMarketVaultPublicKey)(this.program.programId, spotMarketIndex);
         const insuranceFundVault = await (0, pda_1.getInsuranceFundVaultPublicKey)(this.program.programId, spotMarketIndex);
         const nameBuffer = (0, userName_1.encodeName)(name);
-        const initializeTx = await this.program.transaction.initializeSpotMarket(optimalUtilization, optimalRate, maxRate, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, liquidatorFee, activeStatus, nameBuffer, {
+        const initializeIx = await this.program.instruction.initializeSpotMarket(optimalUtilization, optimalRate, maxRate, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, liquidatorFee, activeStatus, nameBuffer, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
@@ -79,7 +80,9 @@ class AdminClient extends driftClient_1.DriftClient {
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
         });
-        const { txSig } = await this.sendTransaction(initializeTx, [], this.opts);
+        const tx = await this.buildTransaction(initializeIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        // const { txSig } = await this.sendTransaction(initializeTx, [], this.opts);
         await this.accountSubscriber.addSpotMarket(spotMarketIndex);
         await this.accountSubscriber.addOracle({
             source: oracleSource,
@@ -90,7 +93,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);
-        const tx = await this.program.transaction.initializeSerumFulfillmentConfig(marketIndex, {
+        const initializeIx = await this.program.instruction.initializeSerumFulfillmentConfig(marketIndex, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
@@ -105,12 +108,13 @@ class AdminClient extends driftClient_1.DriftClient {
                 serumFulfillmentConfig,
             },
         });
+        const tx = await this.buildTransaction(initializeIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async initializePhoenixFulfillmentConfig(marketIndex, phoenixMarket) {
         const phoenixFulfillmentConfig = (0, pda_1.getPhoenixFulfillmentConfigPublicKey)(this.program.programId, phoenixMarket);
-        const tx = await this.program.transaction.initializePhoenixFulfillmentConfig(marketIndex, {
+        const initializeIx = await this.program.instruction.initializePhoenixFulfillmentConfig(marketIndex, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
@@ -124,6 +128,7 @@ class AdminClient extends driftClient_1.DriftClient {
                 phoenixFulfillmentConfig,
             },
         });
+        const tx = await this.buildTransaction(initializeIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
@@ -131,7 +136,7 @@ class AdminClient extends driftClient_1.DriftClient {
         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(marketIndex, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, marginRatioInitial, marginRatioMaintenance, liquidatorFee, activeStatus, nameBuffer, {
+        const initializeMarketIx = await this.program.instruction.initializePerpMarket(marketIndex, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, marginRatioInitial, marginRatioMaintenance, liquidatorFee, activeStatus, nameBuffer, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
@@ -141,7 +146,8 @@ class AdminClient extends driftClient_1.DriftClient {
                 systemProgram: anchor.web3.SystemProgram.programId,
             },
         });
-        const { txSig } = await this.sendTransaction(initializeMarketTx, [], this.opts);
+        const tx = await this.buildTransaction(initializeMarketIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
         while (this.getStateAccount().numberOfMarkets <= currentPerpMarketIndex) {
             await this.fetchAccounts();
         }
@@ -154,14 +160,15 @@ class AdminClient extends driftClient_1.DriftClient {
     }
     async deleteInitializedPerpMarket(marketIndex) {
         const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, marketIndex);
-        const deleteInitializeMarketTx = await this.program.transaction.deleteInitializedPerpMarket(marketIndex, {
+        const deleteInitializeMarketIx = await this.program.instruction.deleteInitializedPerpMarket(marketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
                 perpMarket: perpMarketPublicKey,
             },
         });
-        const { txSig } = await this.sendTransaction(deleteInitializeMarketTx, [], this.opts);
+        const tx = await this.buildTransaction(deleteInitializeMarketIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async moveAmmPrice(perpMarketIndex, baseAssetReserve, quoteAssetReserve, sqrtK) {
@@ -169,18 +176,19 @@ class AdminClient extends driftClient_1.DriftClient {
         if (sqrtK == undefined) {
             sqrtK = (0, utils_1.squareRootBN)(baseAssetReserve.mul(quoteAssetReserve));
         }
-        const tx = await this.program.transaction.moveAmmPrice(baseAssetReserve, quoteAssetReserve, sqrtK, {
+        const moveAmmPriceIx = await this.program.instruction.moveAmmPrice(baseAssetReserve, quoteAssetReserve, sqrtK, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
                 perpMarket: marketPublicKey,
             },
         });
+        const tx = await this.buildTransaction(moveAmmPriceIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updateK(perpMarketIndex, sqrtK) {
-        const tx = await this.program.transaction.updateK(sqrtK, {
+        const updateKIx = await this.program.instruction.updateK(sqrtK, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
@@ -188,18 +196,20 @@ class AdminClient extends driftClient_1.DriftClient {
                 oracle: this.getPerpMarketAccount(perpMarketIndex).amm.oracle,
             },
         });
+        const tx = await this.buildTransaction(updateKIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async recenterPerpMarketAmm(perpMarketIndex, pegMultiplier, sqrtK) {
         const marketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
-        const tx = await this.program.transaction.recenterPerpMarketAmm(pegMultiplier, sqrtK, {
+        const recenterPerpMarketAmmIx = await this.program.instruction.recenterPerpMarketAmm(pegMultiplier, sqrtK, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
                 perpMarket: marketPublicKey,
             },
         });
+        const tx = await this.buildTransaction(recenterPerpMarketAmmIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
@@ -218,20 +228,21 @@ 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);
-        const tx = await this.program.transaction.moveAmmPrice(newBaseAssetAmount, newQuoteAssetAmount, perpMarket.amm.sqrtK, {
+        const moveAmmPriceIx = await this.program.instruction.moveAmmPrice(newBaseAssetAmount, newQuoteAssetAmount, perpMarket.amm.sqrtK, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
                 perpMarket: perpMarketPublicKey,
             },
         });
+        const tx = await this.buildTransaction(moveAmmPriceIx);
         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;
-        const tx = await this.program.transaction.repegAmmCurve(newPeg, {
+        const repegAmmCurveIx = await this.program.instruction.repegAmmCurve(newPeg, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
@@ -239,6 +250,7 @@ class AdminClient extends driftClient_1.DriftClient {
                 perpMarket: perpMarketPublicKey,
             },
         });
+        const tx = await this.buildTransaction(repegAmmCurveIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
@@ -268,7 +280,7 @@ class AdminClient extends driftClient_1.DriftClient {
     }
     async depositIntoPerpMarketFeePool(perpMarketIndex, amount, sourceVault) {
         const spotMarket = this.getQuoteSpotMarketAccount();
-        const tx = await this.program.transaction.depositIntoPerpMarketFeePool(amount, {
+        const depositIntoPerpMarketFeePoolIx = await this.program.instruction.depositIntoPerpMarketFeePool(amount, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
@@ -280,16 +292,18 @@ class AdminClient extends driftClient_1.DriftClient {
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
         });
+        const tx = await this.buildTransaction(depositIntoPerpMarketFeePoolIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updateAdmin(admin) {
-        const tx = await this.program.transaction.updateAdmin(admin, {
+        const updateAdminIx = await this.program.instruction.updateAdmin(admin, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const tx = await this.buildTransaction(updateAdminIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
@@ -314,13 +328,14 @@ class AdminClient extends driftClient_1.DriftClient {
         });
     }
     async updatePerpMarketMarginRatio(perpMarketIndex, marginRatioInitial, marginRatioMaintenance) {
-        const tx = await this.program.transaction.updatePerpMarketMarginRatio(marginRatioInitial, marginRatioMaintenance, {
+        const updatePerpMarketMarginRatioIx = await this.program.instruction.updatePerpMarketMarginRatio(marginRatioInitial, marginRatioMaintenance, {
             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;
     }
@@ -334,36 +349,39 @@ class AdminClient extends driftClient_1.DriftClient {
         });
     }
     async updatePerpMarketBaseSpread(perpMarketIndex, baseSpread) {
-        const tx = await this.program.transaction.updatePerpMarketBaseSpread(baseSpread, {
+        const updatePerpMarketBaseSpreadIx = await this.program.instruction.updatePerpMarketBaseSpread(baseSpread, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketBaseSpreadIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updateAmmJitIntensity(perpMarketIndex, ammJitIntensity) {
-        const tx = await this.program.transaction.updateAmmJitIntensity(ammJitIntensity, {
+        const updateAmmJitIntensityIx = await this.program.instruction.updateAmmJitIntensity(ammJitIntensity, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updateAmmJitIntensityIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updatePerpMarketName(perpMarketIndex, name) {
         const nameBuffer = (0, userName_1.encodeName)(name);
-        const tx = await this.program.transaction.updatePerpMarketName(nameBuffer, {
+        const updatePerpMarketNameIx = await this.program.instruction.updatePerpMarketName(nameBuffer, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketNameIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
@@ -398,22 +416,24 @@ class AdminClient extends driftClient_1.DriftClient {
         });
     }
     async updatePerpFeeStructure(feeStructure) {
-        const tx = this.program.transaction.updatePerpFeeStructure(feeStructure, {
+        const updatePerpFeeStructureIx = this.program.instruction.updatePerpFeeStructure(feeStructure, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const tx = await this.buildTransaction(updatePerpFeeStructureIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updateSpotFeeStructure(feeStructure) {
-        const tx = await this.program.transaction.updateSpotFeeStructure(feeStructure, {
+        const updateSpotFeeStructureIx = await this.program.instruction.updateSpotFeeStructure(feeStructure, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const tx = await this.buildTransaction(updateSpotFeeStructureIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
@@ -442,12 +462,13 @@ class AdminClient extends driftClient_1.DriftClient {
         });
     }
     async updateOracleGuardRails(oracleGuardRails) {
-        const tx = await this.program.transaction.updateOracleGuardRails(oracleGuardRails, {
+        const updateOracleGuardRailsIx = await this.program.instruction.updateOracleGuardRails(oracleGuardRails, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const tx = await this.buildTransaction(updateOracleGuardRailsIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
@@ -476,83 +497,90 @@ class AdminClient extends driftClient_1.DriftClient {
         });
     }
     async updateWithdrawGuardThreshold(spotMarketIndex, withdrawGuardThreshold) {
-        const tx = await this.program.transaction.updateWithdrawGuardThreshold(withdrawGuardThreshold, {
+        const updateWithdrawGuardThresholdIx = await this.program.instruction.updateWithdrawGuardThreshold(withdrawGuardThreshold, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updateWithdrawGuardThresholdIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updateSpotMarketIfFactor(spotMarketIndex, userIfFactor, totalIfFactor) {
-        const tx = await this.program.transaction.updateSpotMarketIfFactor(spotMarketIndex, userIfFactor, totalIfFactor, {
+        const updateSpotMarketIfFactorIx = await this.program.instruction.updateSpotMarketIfFactor(spotMarketIndex, userIfFactor, totalIfFactor, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updateSpotMarketIfFactorIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updateSpotMarketRevenueSettlePeriod(spotMarketIndex, revenueSettlePeriod) {
-        const tx = await this.program.transaction.updateSpotMarketRevenueSettlePeriod(revenueSettlePeriod, {
+        const updateSpotMarketRevenueSettlePeriodIx = await this.program.instruction.updateSpotMarketRevenueSettlePeriod(revenueSettlePeriod, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updateSpotMarketRevenueSettlePeriodIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updateSpotMarketMaxTokenDeposits(spotMarketIndex, maxTokenDeposits) {
-        const tx = this.program.transaction.updateSpotMarketMaxTokenDeposits(maxTokenDeposits, {
+        const updateSpotMarketMaxTokenDepositsIx = this.program.instruction.updateSpotMarketMaxTokenDeposits(maxTokenDeposits, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updateSpotMarketMaxTokenDepositsIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updateSpotMarketScaleInitialAssetWeightStart(spotMarketIndex, scaleInitialAssetWeightStart) {
-        const tx = this.program.transaction.updateSpotMarketScaleInitialAssetWeightStart(scaleInitialAssetWeightStart, {
+        const updateSpotMarketScaleInitialAssetWeightStartIx = this.program.instruction.updateSpotMarketScaleInitialAssetWeightStart(scaleInitialAssetWeightStart, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updateSpotMarketScaleInitialAssetWeightStartIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updateInsuranceFundUnstakingPeriod(spotMarketIndex, insuranceWithdrawEscrowPeriod) {
-        const tx = await this.program.transaction.updateInsuranceFundUnstakingPeriod(insuranceWithdrawEscrowPeriod, {
+        const updateInsuranceFundUnstakingPeriodIx = await this.program.instruction.updateInsuranceFundUnstakingPeriod(insuranceWithdrawEscrowPeriod, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updateInsuranceFundUnstakingPeriodIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updateLpCooldownTime(cooldownTime) {
-        const tx = await this.program.transaction.updateLpCooldownTime(cooldownTime, {
+        const updateLpCooldownTimeIx = await this.program.instruction.updateLpCooldownTime(cooldownTime, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const tx = await this.buildTransaction(updateLpCooldownTimeIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updatePerpMarketOracle(perpMarketIndex, oracle, oracleSource) {
-        const tx = await this.program.transaction.updatePerpMarketOracle(oracle, oracleSource, {
+        const updatePerpMarketOracleIx = await this.program.instruction.updatePerpMarketOracle(oracle, oracleSource, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
@@ -560,17 +588,19 @@ class AdminClient extends driftClient_1.DriftClient {
                 oracle: oracle,
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketOracleIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updatePerpMarketStepSizeAndTickSize(perpMarketIndex, stepSize, tickSize) {
-        const tx = await this.program.transaction.updatePerpMarketStepSizeAndTickSize(stepSize, tickSize, {
+        const updatePerpMarketStepSizeAndTickSizeIx = await this.program.instruction.updatePerpMarketStepSizeAndTickSize(stepSize, tickSize, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketStepSizeAndTickSizeIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
@@ -657,22 +687,24 @@ class AdminClient extends driftClient_1.DriftClient {
         });
     }
     async updateWhitelistMint(whitelistMint) {
-        const tx = await this.program.transaction.updateWhitelistMint(whitelistMint, {
+        const updateWhitelistMintIx = await this.program.instruction.updateWhitelistMint(whitelistMint, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const tx = await this.buildTransaction(updateWhitelistMintIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updateDiscountMint(discountMint) {
-        const tx = await this.program.transaction.updateDiscountMint(discountMint, {
+        const updateDiscountMintIx = await this.program.instruction.updateDiscountMint(discountMint, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const tx = await this.buildTransaction(updateDiscountMintIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
@@ -695,78 +727,85 @@ class AdminClient extends driftClient_1.DriftClient {
         });
     }
     async updateSpotMarketAssetTier(spotMarketIndex, assetTier) {
-        const tx = await this.program.transaction.updateSpotMarketAssetTier(assetTier, {
+        const updateSpotMarketAssetTierIx = await this.program.instruction.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);
+        const tx = await this.buildTransaction(updateSpotMarketAssetTierIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updateSpotMarketStatus(spotMarketIndex, marketStatus) {
-        const tx = await this.program.transaction.updateSpotMarketStatus(marketStatus, {
+        const updateSpotMarketStatusIx = await this.program.instruction.updateSpotMarketStatus(marketStatus, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updateSpotMarketStatusIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updateSpotMarketPausedOperations(spotMarketIndex, pausedOperations) {
-        const tx = await this.program.transaction.updateSpotMarketPausedOperations(pausedOperations, {
+        const updateSpotMarketPausedOperationsIx = await this.program.instruction.updateSpotMarketPausedOperations(pausedOperations, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updateSpotMarketPausedOperationsIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updatePerpMarketStatus(perpMarketIndex, marketStatus) {
-        const tx = await this.program.transaction.updatePerpMarketStatus(marketStatus, {
+        const updatePerpMarketStatusIx = await this.program.instruction.updatePerpMarketStatus(marketStatus, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketStatusIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updatePerpMarketPausedOperations(perpMarketIndex, pausedOperations) {
-        const tx = await this.program.transaction.updatePerpMarketPausedOperations(pausedOperations, {
+        const updatePerpMarketPausedOperationsIx = await this.program.instruction.updatePerpMarketPausedOperations(pausedOperations, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketPausedOperationsIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updatePerpMarketContractTier(perpMarketIndex, contractTier) {
-        const tx = await this.program.transaction.updatePerpMarketContractTier(contractTier, {
+        const updatePerpMarketContractTierIx = await this.program.instruction.updatePerpMarketContractTier(contractTier, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 perpMarket: await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
+        const tx = await this.buildTransaction(updatePerpMarketContractTierIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
     async updateExchangeStatus(exchangeStatus) {
-        const tx = await this.program.transaction.updateExchangeStatus(exchangeStatus, {
+        const updateExchangeStatusIx = await this.program.instruction.updateExchangeStatus(exchangeStatus, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
             },
         });
+        const tx = await this.buildTransaction(updateExchangeStatusIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }

package/lib/constants/spotMarkets.js

@@ -164,6 +164,17 @@ exports.MainnetSpotMarkets = [
         phoenixMarket: new web3_js_1.PublicKey('2pspvjWWaf3dNgt3jsgSzFCNvMGPb7t8FrEYvLGjvcCe'),
         launchTs: 1706731200000,
     },
+    {
+        symbol: 'RNDR',
+        marketIndex: 12,
+        oracle: new web3_js_1.PublicKey('CYGfrBJB9HgLf9iZyN4aH5HvUAi2htQ4MjPxeXMf4Egn'),
+        oracleSource: __1.OracleSource.PYTH,
+        mint: new web3_js_1.PublicKey('rndrizKT3MK1iimdxRdWabcF7Zg7AR5T4nud4EkHBof'),
+        precision: new __1.BN(10).pow(numericConstants_1.EIGHT),
+        precisionExp: numericConstants_1.EIGHT,
+        serumMarket: new web3_js_1.PublicKey('2m7ZLEKtxWF29727DSb5D91erpXPUY1bqhRWRC3wQX7u'),
+        launchTs: 1708964021000,
+    },
 ];
 exports.SpotMarkets = {
     devnet: exports.DevnetSpotMarkets,

package/lib/events/eventSubscriber.js

@@ -122,7 +122,7 @@ class EventSubscriber {
     parseEventsFromLogs(txSig, slot, logs) {
         const records = [];
         // @ts-ignore
-        const events = (0, parse_1.parseLogs)(this.program, slot, logs);
+        const events = (0, parse_1.parseLogs)(this.program, logs);
         let runningEventIndex = 0;
         for (const event of events) {
             // @ts-ignore

package/lib/events/fetchLogs.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LogParser = exports.fetchTransactionLogs = exports.fetchLogs = void 0;
 const promiseTimeout_1 = require("../util/promiseTimeout");
+const parse_1 = require("./parse");
 function mapTransactionResponseToLog(transaction) {
     return {
         txSig: transaction.transaction.signatures[0],
@@ -82,14 +83,13 @@ class LogParser {
         const records = [];
         if (!event.logs)
             return records;
-        // @ts-ignore
-        const eventGenerator = this.program._events._eventParser.parseLogs(event.logs, false);
         let runningEventIndex = 0;
-        for (const eventLog of eventGenerator) {
+        for (const eventLog of (0, parse_1.parseLogs)(this.program, event.logs)) {
             eventLog.data.txSig = event.txSig;
             eventLog.data.slot = event.slot;
             eventLog.data.eventType = eventLog.name;
             eventLog.data.txSigIndex = runningEventIndex;
+            // @ts-ignore
             records.push(eventLog.data);
             runningEventIndex++;
         }

package/lib/events/parse.d.ts

@@ -1,2 +1,2 @@
 import { Program, Event } from '@coral-xyz/anchor';
-export declare function parseLogs(program: Program, slot: number, logs: string[]): Event[];
+export declare function parseLogs(program: Program, logs: string[]): Event[];

package/lib/events/parse.js

@@ -7,10 +7,13 @@ const PROGRAM_LOG = 'Program log: ';
 const PROGRAM_DATA = 'Program data: ';
 const PROGRAM_LOG_START_INDEX = PROGRAM_LOG.length;
 const PROGRAM_DATA_START_INDEX = PROGRAM_DATA.length;
-function parseLogs(program, slot, logs) {
+function parseLogs(program, logs) {
     const events = [];
     const execution = new ExecutionContext();
     for (const log of logs) {
+        if (log.startsWith('Log truncated')) {
+            break;
+        }
         const [event, newProgram, didPop] = handleLog(execution, log, program);
         if (event) {
             events.push(event);

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.64.0",
+    "version": "2.65.0",
     "name": "drift",
     "instructions": [
         {