@velocity-exchange/sdk 0.0.1

package/lib/browser/adminClient.d.ts

@@ -0,0 +1,402 @@
+/// <reference types="bn.js" />
+/**
+ * AdminClient — governance and protocol administration instruction builders.
+ * Extends {@link VelocityClient}; all trading/keeper methods are also available.
+ *
+ * Covers: perp/spot market initialization and updates, oracle guard rail config,
+ * fee structure updates, insurance fund operations, vault management, IF rebalancing,
+ * pause/unpause exchange, and all ~126 admin instruction handlers in `instructions/admin.rs`.
+ */
+import { AddressLookupTableAccount, Keypair, PublicKey, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
+import { FeeStructure, OracleGuardRails, OracleSource, ExchangeStatus, MarketStatus, ContractTier, AssetTier, IfRebalanceConfigParams, TxParams, AddAmmConstituentMappingDatum, SwapReduceOnly, InitializeConstituentParams, ConstituentStatus, LPPoolAccount, TransferFeeAndPnlPoolDirection } from './types';
+import { BN } from './isomorphic/anchor';
+import { VelocityClient } from './velocityClient';
+import { JupiterClient, QuoteResponse } from './jupiter/jupiterClient';
+import { SwapMode } from './swap/UnifiedSwapClient';
+export declare class AdminClient extends VelocityClient {
+    initialize(usdcMint: PublicKey, _adminControlsPrices: boolean): Promise<[TransactionSignature]>;
+    initializeSpotMarket(mint: PublicKey, optimalUtilization: number, optimalRate: number, maxRate: number, oracle: PublicKey, oracleSource: OracleSource, initialAssetWeight: number, maintenanceAssetWeight: number, initialLiabilityWeight: number, maintenanceLiabilityWeight: number, imfFactor?: number, liquidatorFee?: number, ifLiquidationFee?: number, activeStatus?: boolean, assetTier?: {
+        collateral: {};
+    }, scaleInitialAssetWeightStart?: BN, withdrawGuardThreshold?: BN, orderTickSize?: BN, orderStepSize?: BN, ifTotalFactor?: number, name?: string, marketIndex?: number): Promise<TransactionSignature>;
+    getInitializeSpotMarketIx(mint: PublicKey, optimalUtilization: number, optimalRate: number, maxRate: number, oracle: PublicKey, oracleSource: OracleSource, initialAssetWeight: number, maintenanceAssetWeight: number, initialLiabilityWeight: number, maintenanceLiabilityWeight: number, imfFactor?: number, liquidatorFee?: number, ifLiquidationFee?: number, activeStatus?: boolean, assetTier?: {
+        collateral: {};
+    }, scaleInitialAssetWeightStart?: BN, withdrawGuardThreshold?: BN, orderTickSize?: BN, orderStepSize?: BN, ifTotalFactor?: number, name?: string, marketIndex?: number): Promise<TransactionInstruction>;
+    deleteInitializedSpotMarket(marketIndex: number): Promise<TransactionSignature>;
+    getDeleteInitializedSpotMarketIx(marketIndex: number): Promise<TransactionInstruction>;
+    initializePerpMarket(marketIndex: number, priceOracle: PublicKey, baseAssetReserve: BN, quoteAssetReserve: BN, periodicity: BN, pegMultiplier?: BN, oracleSource?: OracleSource, contractTier?: ContractTier, marginRatioInitial?: number, marginRatioMaintenance?: number, liquidatorFee?: number, ifLiquidatorFee?: number, imfFactor?: number, activeStatus?: boolean, baseSpread?: number, maxSpread?: number, maxOpenInterest?: BN, maxRevenueWithdrawPerPeriod?: BN, quoteMaxInsurance?: BN, orderStepSize?: BN, orderTickSize?: BN, minOrderSize?: BN, concentrationCoefScale?: BN, curveUpdateIntensity?: number, ammJitIntensity?: number, name?: string, lpPoolId?: number): Promise<TransactionSignature>;
+    getInitializePerpMarketIx(marketIndex: number, priceOracle: PublicKey, baseAssetReserve: BN, quoteAssetReserve: BN, periodicity: BN, pegMultiplier?: BN, oracleSource?: OracleSource, contractTier?: ContractTier, marginRatioInitial?: number, marginRatioMaintenance?: number, liquidatorFee?: number, ifLiquidatorFee?: number, imfFactor?: number, activeStatus?: boolean, baseSpread?: number, maxSpread?: number, maxOpenInterest?: BN, maxRevenueWithdrawPerPeriod?: BN, quoteMaxInsurance?: BN, orderStepSize?: BN, orderTickSize?: BN, minOrderSize?: BN, concentrationCoefScale?: BN, curveUpdateIntensity?: number, ammJitIntensity?: number, name?: string, lpPoolId?: number): Promise<TransactionInstruction[]>;
+    initializeAmmCache(txParams?: TxParams): Promise<TransactionSignature>;
+    getInitializeAmmCacheIx(): Promise<TransactionInstruction>;
+    addMarketToAmmCache(perpMarketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
+    getAddMarketToAmmCacheIx(perpMarketIndex: number): Promise<TransactionInstruction>;
+    deleteAmmCache(txParams?: TxParams): Promise<TransactionSignature>;
+    getDeleteAmmCacheIx(): Promise<TransactionInstruction>;
+    updateInitialAmmCacheInfo(perpMarketIndexes: number[], txParams?: TxParams): Promise<TransactionSignature>;
+    getUpdateInitialAmmCacheInfoIx(perpMarketIndexes: number[]): Promise<TransactionInstruction>;
+    overrideAmmCacheInfo(perpMarketIndex: number, params: {
+        quoteOwedFromLpPool?: BN;
+        lastSettleTs?: BN;
+        lastFeePoolTokenAmount?: BN;
+        lastNetPnlPoolTokenAmount?: BN;
+        ammPositionScalar?: number;
+        ammInventoryLimit?: BN;
+    }, txParams?: TxParams): Promise<TransactionSignature>;
+    getOverrideAmmCacheInfoIx(perpMarketIndex: number, params: {
+        quoteOwedFromLpPool?: BN;
+        lastSettleSlot?: BN;
+        lastFeePoolTokenAmount?: BN;
+        lastNetPnlPoolTokenAmount?: BN;
+        ammPositionScalar?: number;
+        ammInventoryLimit?: BN;
+    }): Promise<TransactionInstruction>;
+    resetAmmCache(txParams?: TxParams): Promise<TransactionSignature>;
+    getResetAmmCacheIx(): Promise<TransactionInstruction>;
+    deleteInitializedPerpMarket(marketIndex: number): Promise<TransactionSignature>;
+    getDeleteInitializedPerpMarketIx(marketIndex: number): Promise<TransactionInstruction>;
+    moveAmmPrice(perpMarketIndex: number, baseAssetReserve: BN, quoteAssetReserve: BN, sqrtK?: BN): Promise<TransactionSignature>;
+    getMoveAmmPriceIx(perpMarketIndex: number, baseAssetReserve: BN, quoteAssetReserve: BN, sqrtK?: BN): Promise<TransactionInstruction>;
+    updateK(perpMarketIndex: number, sqrtK: BN): Promise<TransactionSignature>;
+    getUpdateKIx(perpMarketIndex: number, sqrtK: BN): Promise<TransactionInstruction>;
+    recenterPerpMarketAmm(perpMarketIndex: number, pegMultiplier: BN, sqrtK: BN): Promise<TransactionSignature>;
+    getRecenterPerpMarketAmmIx(perpMarketIndex: number, pegMultiplier: BN, sqrtK: BN): Promise<TransactionInstruction>;
+    recenterPerpMarketAmmCrank(perpMarketIndex: number, depth?: BN): Promise<TransactionSignature>;
+    getRecenterPerpMarketAmmCrankIx(perpMarketIndex: number, depth: BN): Promise<TransactionInstruction>;
+    updatePerpMarketConcentrationScale(perpMarketIndex: number, concentrationScale: BN): Promise<TransactionSignature>;
+    getUpdatePerpMarketConcentrationScaleIx(perpMarketIndex: number, concentrationScale: BN): Promise<TransactionInstruction>;
+    updatePerpMarketLpPoolId(perpMarketIndex: number, lpPoolId: number): Promise<string>;
+    getUpdatePerpMarketLpPoolIdIx(perpMarketIndex: number, lpPoolId: number): Promise<TransactionInstruction>;
+    updatePerpMarketLpPoolStatus(perpMarketIndex: number, lpStatus: number): Promise<string>;
+    getUpdatePerpMarketLpPoolStatusIx(perpMarketIndex: number, lpStatus: number): Promise<TransactionInstruction>;
+    moveAmmToPrice(perpMarketIndex: number, targetPrice: BN): Promise<TransactionSignature>;
+    getMoveAmmToPriceIx(perpMarketIndex: number, targetPrice: BN): Promise<TransactionInstruction>;
+    repegAmmCurve(newPeg: BN, perpMarketIndex: number): Promise<TransactionSignature>;
+    getRepegAmmCurveIx(newPeg: BN, perpMarketIndex: number): Promise<TransactionInstruction>;
+    updatePerpMarketAmmOracleTwap(perpMarketIndex: number): Promise<TransactionSignature>;
+    getUpdatePerpMarketAmmOracleTwapIx(perpMarketIndex: number): Promise<TransactionInstruction>;
+    resetPerpMarketAmmOracleTwap(perpMarketIndex: number): Promise<TransactionSignature>;
+    getResetPerpMarketAmmOracleTwapIx(perpMarketIndex: number): Promise<TransactionInstruction>;
+    depositIntoPerpMarketFeePool(perpMarketIndex: number, amount: BN, sourceVault: PublicKey): Promise<TransactionSignature>;
+    getDepositIntoPerpMarketFeePoolIx(perpMarketIndex: number, amount: BN, sourceVault: PublicKey): Promise<TransactionInstruction>;
+    updatePerpMarketPnlPool(perpMarketIndex: number, amount: BN): Promise<TransactionSignature>;
+    getUpdatePerpMarketPnlPoolIx(perpMarketIndex: number, amount: BN): Promise<TransactionInstruction>;
+    depositIntoSpotMarketVault(spotMarketIndex: number, amount: BN, sourceVault: PublicKey): Promise<TransactionSignature>;
+    getDepositIntoSpotMarketVaultIx(spotMarketIndex: number, amount: BN, sourceVault: PublicKey): Promise<TransactionInstruction>;
+    updateAdmin(admin: PublicKey): Promise<TransactionSignature>;
+    getUpdateAdminIx(admin: PublicKey): Promise<TransactionInstruction>;
+    updatePerpMarketCurveUpdateIntensity(perpMarketIndex: number, curveUpdateIntensity: number): Promise<TransactionSignature>;
+    getUpdatePerpMarketCurveUpdateIntensityIx(perpMarketIndex: number, curveUpdateIntensity: number): Promise<TransactionInstruction>;
+    updatePerpMarketReferencePriceOffsetDeadbandPct(perpMarketIndex: number, referencePriceOffsetDeadbandPct: number): Promise<TransactionSignature>;
+    getUpdatePerpMarketReferencePriceOffsetDeadbandPctIx(perpMarketIndex: number, referencePriceOffsetDeadbandPct: number): Promise<TransactionInstruction>;
+    updatePerpMarketTargetBaseAssetAmountPerLp(perpMarketIndex: number, targetBaseAssetAmountPerLP: number): Promise<TransactionSignature>;
+    updatePerpMarketAmmSummaryStats(perpMarketIndex: number, updateAmmSummaryStats?: boolean, netUnsettledFundingPnl?: BN, excludeTotalLiqFee?: boolean): Promise<TransactionSignature>;
+    getUpdatePerpMarketAmmSummaryStatsIx(perpMarketIndex: number, updateAmmSummaryStats?: boolean, netUnsettledFundingPnl?: BN, excludeTotalLiqFee?: boolean): Promise<TransactionInstruction>;
+    getUpdatePerpMarketTargetBaseAssetAmountPerLpIx(perpMarketIndex: number, targetBaseAssetAmountPerLP: number): Promise<TransactionInstruction>;
+    updatePerpMarketMarginRatio(perpMarketIndex: number, marginRatioInitial: number, marginRatioMaintenance: number): Promise<TransactionSignature>;
+    getUpdatePerpMarketMarginRatioIx(perpMarketIndex: number, marginRatioInitial: number, marginRatioMaintenance: number): Promise<TransactionInstruction>;
+    updatePerpMarketImfFactor(perpMarketIndex: number, imfFactor: number, unrealizedPnlImfFactor: number): Promise<TransactionSignature>;
+    getUpdatePerpMarketImfFactorIx(perpMarketIndex: number, imfFactor: number, unrealizedPnlImfFactor: number): Promise<TransactionInstruction>;
+    updatePerpMarketBaseSpread(perpMarketIndex: number, baseSpread: number): Promise<TransactionSignature>;
+    getUpdatePerpMarketBaseSpreadIx(perpMarketIndex: number, baseSpread: number): Promise<TransactionInstruction>;
+    updateAmmJitIntensity(perpMarketIndex: number, ammJitIntensity: number): Promise<TransactionSignature>;
+    getUpdateAmmJitIntensityIx(perpMarketIndex: number, ammJitIntensity: number): Promise<TransactionInstruction>;
+    updatePerpMarketName(perpMarketIndex: number, name: string): Promise<TransactionSignature>;
+    getUpdatePerpMarketNameIx(perpMarketIndex: number, name: string): Promise<TransactionInstruction>;
+    updateSpotMarketName(spotMarketIndex: number, name: string): Promise<TransactionSignature>;
+    getUpdateSpotMarketNameIx(spotMarketIndex: number, name: string): Promise<TransactionInstruction>;
+    updateSpotMarketPoolId(spotMarketIndex: number, poolId: number): Promise<TransactionSignature>;
+    getUpdateSpotMarketPoolIdIx(spotMarketIndex: number, poolId: number): Promise<TransactionInstruction>;
+    updatePerpMarketMaxSpread(perpMarketIndex: number, maxSpread: number): Promise<TransactionSignature>;
+    getUpdatePerpMarketMaxSpreadIx(perpMarketIndex: number, maxSpread: number): Promise<TransactionInstruction>;
+    updatePerpFeeStructure(feeStructure: FeeStructure): Promise<TransactionSignature>;
+    getUpdatePerpFeeStructureIx(feeStructure: FeeStructure): Promise<TransactionInstruction>;
+    updateSpotFeeStructure(feeStructure: FeeStructure): Promise<TransactionSignature>;
+    getUpdateSpotFeeStructureIx(feeStructure: FeeStructure): Promise<TransactionInstruction>;
+    updateInitialPctToLiquidate(initialPctToLiquidate: number): Promise<TransactionSignature>;
+    getUpdateInitialPctToLiquidateIx(initialPctToLiquidate: number): Promise<TransactionInstruction>;
+    updateLiquidationDuration(liquidationDuration: number): Promise<TransactionSignature>;
+    getUpdateLiquidationDurationIx(liquidationDuration: number): Promise<TransactionInstruction>;
+    updateLiquidationMarginBufferRatio(updateLiquidationMarginBufferRatio: number): Promise<TransactionSignature>;
+    getUpdateLiquidationMarginBufferRatioIx(updateLiquidationMarginBufferRatio: number): Promise<TransactionInstruction>;
+    updateOracleGuardRails(oracleGuardRails: OracleGuardRails): Promise<TransactionSignature>;
+    getUpdateOracleGuardRailsIx(oracleGuardRails: OracleGuardRails): Promise<TransactionInstruction>;
+    updateStateSettlementDuration(settlementDuration: number): Promise<TransactionSignature>;
+    getUpdateStateSettlementDurationIx(settlementDuration: number): Promise<TransactionInstruction>;
+    updateStateMaxNumberOfSubAccounts(maxNumberOfSubAccounts: number): Promise<TransactionSignature>;
+    getUpdateStateMaxNumberOfSubAccountsIx(maxNumberOfSubAccounts: number): Promise<TransactionInstruction>;
+    updateStateMaxInitializeUserFee(maxInitializeUserFee: number): Promise<TransactionSignature>;
+    getUpdateStateMaxInitializeUserFeeIx(maxInitializeUserFee: number): Promise<TransactionInstruction>;
+    updateWithdrawGuardThreshold(spotMarketIndex: number, withdrawGuardThreshold: BN): Promise<TransactionSignature>;
+    getUpdateWithdrawGuardThresholdIx(spotMarketIndex: number, withdrawGuardThreshold: BN): Promise<TransactionInstruction>;
+    updateSpotMarketIfFactor(spotMarketIndex: number, userIfFactor: BN, totalIfFactor: BN): Promise<TransactionSignature>;
+    getUpdateSpotMarketIfFactorIx(spotMarketIndex: number, userIfFactor: BN, totalIfFactor: BN): Promise<TransactionInstruction>;
+    updateSpotMarketRevenueSettlePeriod(spotMarketIndex: number, revenueSettlePeriod: BN): Promise<TransactionSignature>;
+    getUpdateSpotMarketRevenueSettlePeriodIx(spotMarketIndex: number, revenueSettlePeriod: BN): Promise<TransactionInstruction>;
+    updateSpotMarketMaxTokenDeposits(spotMarketIndex: number, maxTokenDeposits: BN): Promise<TransactionSignature>;
+    getUpdateSpotMarketMaxTokenDepositsIx(spotMarketIndex: number, maxTokenDeposits: BN): Promise<TransactionInstruction>;
+    updateSpotMarketMaxTokenBorrows(spotMarketIndex: number, maxTokenBorrowsFraction: number): Promise<TransactionSignature>;
+    getUpdateSpotMarketMaxTokenBorrowsIx(spotMarketIndex: number, maxTokenBorrowsFraction: number): Promise<TransactionInstruction>;
+    updateSpotMarketScaleInitialAssetWeightStart(spotMarketIndex: number, scaleInitialAssetWeightStart: BN): Promise<TransactionSignature>;
+    getUpdateSpotMarketScaleInitialAssetWeightStartIx(spotMarketIndex: number, scaleInitialAssetWeightStart: BN): Promise<TransactionInstruction>;
+    updateInsuranceFundUnstakingPeriod(spotMarketIndex: number, insuranceWithdrawEscrowPeriod: BN): Promise<TransactionSignature>;
+    getUpdateInsuranceFundUnstakingPeriodIx(spotMarketIndex: number, insuranceWithdrawEscrowPeriod: BN): Promise<TransactionInstruction>;
+    updatePerpMarketOracle(perpMarketIndex: number, oracle: PublicKey, oracleSource: OracleSource, skipInvaraintCheck?: boolean): Promise<TransactionSignature>;
+    getUpdatePerpMarketOracleIx(perpMarketIndex: number, oracle: PublicKey, oracleSource: OracleSource, skipInvaraintCheck?: boolean): Promise<TransactionInstruction>;
+    updatePerpMarketStepSizeAndTickSize(perpMarketIndex: number, stepSize: BN, tickSize: BN): Promise<TransactionSignature>;
+    getUpdatePerpMarketStepSizeAndTickSizeIx(perpMarketIndex: number, stepSize: BN, tickSize: BN): Promise<TransactionInstruction>;
+    updatePerpMarketMinOrderSize(perpMarketIndex: number, orderSize: BN): Promise<TransactionSignature>;
+    getUpdatePerpMarketMinOrderSizeIx(perpMarketIndex: number, orderSize: BN): Promise<TransactionInstruction>;
+    updateSpotMarketStepSizeAndTickSize(spotMarketIndex: number, stepSize: BN, tickSize: BN): Promise<TransactionSignature>;
+    getUpdateSpotMarketStepSizeAndTickSizeIx(spotMarketIndex: number, stepSize: BN, tickSize: BN): Promise<TransactionInstruction>;
+    updateSpotMarketMinOrderSize(spotMarketIndex: number, orderSize: BN): Promise<TransactionSignature>;
+    getUpdateSpotMarketMinOrderSizeIx(spotMarketIndex: number, orderSize: BN): Promise<TransactionInstruction>;
+    updatePerpMarketExpiry(perpMarketIndex: number, expiryTs: BN): Promise<TransactionSignature>;
+    getUpdatePerpMarketExpiryIx(perpMarketIndex: number, expiryTs: BN): Promise<TransactionInstruction>;
+    updateSpotMarketOracle(spotMarketIndex: number, oracle: PublicKey, oracleSource: OracleSource, skipInvaraintCheck?: boolean): Promise<TransactionSignature>;
+    getUpdateSpotMarketOracleIx(spotMarketIndex: number, oracle: PublicKey, oracleSource: OracleSource, skipInvaraintCheck?: boolean): Promise<TransactionInstruction>;
+    updateSpotMarketOrdersEnabled(spotMarketIndex: number, ordersEnabled: boolean): Promise<TransactionSignature>;
+    getUpdateSpotMarketOrdersEnabledIx(spotMarketIndex: number, ordersEnabled: boolean): Promise<TransactionInstruction>;
+    updateSpotMarketIfPausedOperations(spotMarketIndex: number, pausedOperations: number): Promise<TransactionSignature>;
+    getUpdateSpotMarketIfPausedOperationsIx(spotMarketIndex: number, pausedOperations: number): Promise<TransactionInstruction>;
+    updateSpotMarketExpiry(spotMarketIndex: number, expiryTs: BN): Promise<TransactionSignature>;
+    getUpdateSpotMarketExpiryIx(spotMarketIndex: number, expiryTs: BN): Promise<TransactionInstruction>;
+    updateWhitelistMint(whitelistMint?: PublicKey): Promise<TransactionSignature>;
+    getUpdateWhitelistMintIx(whitelistMint?: PublicKey): Promise<TransactionInstruction>;
+    updateDiscountMint(discountMint: PublicKey): Promise<TransactionSignature>;
+    getUpdateDiscountMintIx(discountMint: PublicKey): Promise<TransactionInstruction>;
+    updateSpotMarketMarginWeights(spotMarketIndex: number, initialAssetWeight: number, maintenanceAssetWeight: number, initialLiabilityWeight: number, maintenanceLiabilityWeight: number, imfFactor?: number): Promise<TransactionSignature>;
+    getUpdateSpotMarketMarginWeightsIx(spotMarketIndex: number, initialAssetWeight: number, maintenanceAssetWeight: number, initialLiabilityWeight: number, maintenanceLiabilityWeight: number, imfFactor?: number): Promise<TransactionInstruction>;
+    updateSpotMarketBorrowRate(spotMarketIndex: number, optimalUtilization: number, optimalBorrowRate: number, optimalMaxRate: number, minBorrowRate?: number | undefined): Promise<TransactionSignature>;
+    getUpdateSpotMarketBorrowRateIx(spotMarketIndex: number, optimalUtilization: number, optimalBorrowRate: number, optimalMaxRate: number, minBorrowRate?: number | undefined): Promise<TransactionInstruction>;
+    updateSpotMarketAssetTier(spotMarketIndex: number, assetTier: AssetTier): Promise<TransactionSignature>;
+    getUpdateSpotMarketAssetTierIx(spotMarketIndex: number, assetTier: AssetTier): Promise<TransactionInstruction>;
+    updateSpotMarketStatus(spotMarketIndex: number, marketStatus: MarketStatus): Promise<TransactionSignature>;
+    getUpdateSpotMarketStatusIx(spotMarketIndex: number, marketStatus: MarketStatus): Promise<TransactionInstruction>;
+    updateSpotMarketPausedOperations(spotMarketIndex: number, pausedOperations: number): Promise<TransactionSignature>;
+    getUpdateSpotMarketPausedOperationsIx(spotMarketIndex: number, pausedOperations: number): Promise<TransactionInstruction>;
+    updatePerpMarketStatus(perpMarketIndex: number, marketStatus: MarketStatus): Promise<TransactionSignature>;
+    getUpdatePerpMarketStatusIx(perpMarketIndex: number, marketStatus: MarketStatus): Promise<TransactionInstruction>;
+    updatePerpMarketPausedOperations(perpMarketIndex: number, pausedOperations: number): Promise<TransactionSignature>;
+    getUpdatePerpMarketPausedOperationsIx(perpMarketIndex: number, pausedOperations: number): Promise<TransactionInstruction>;
+    updatePerpMarketContractTier(perpMarketIndex: number, contractTier: ContractTier): Promise<TransactionSignature>;
+    getUpdatePerpMarketContractTierIx(perpMarketIndex: number, contractTier: ContractTier): Promise<TransactionInstruction>;
+    updateExchangeStatus(exchangeStatus: ExchangeStatus): Promise<TransactionSignature>;
+    getUpdateExchangeStatusIx(exchangeStatus: ExchangeStatus): Promise<TransactionInstruction>;
+    updatePerpAuctionDuration(minDuration: BN | number): Promise<TransactionSignature>;
+    getUpdatePerpAuctionDurationIx(minDuration: BN | number): Promise<TransactionInstruction>;
+    updateSpotAuctionDuration(defaultAuctionDuration: number): Promise<TransactionSignature>;
+    getUpdateSpotAuctionDurationIx(defaultAuctionDuration: number): Promise<TransactionInstruction>;
+    updatePerpMarketMaxFillReserveFraction(perpMarketIndex: number, maxBaseAssetAmountRatio: number): Promise<TransactionSignature>;
+    getUpdatePerpMarketMaxFillReserveFractionIx(perpMarketIndex: number, maxBaseAssetAmountRatio: number): Promise<TransactionInstruction>;
+    updateMaxSlippageRatio(perpMarketIndex: number, maxSlippageRatio: number): Promise<TransactionSignature>;
+    getUpdateMaxSlippageRatioIx(perpMarketIndex: number, maxSlippageRatio: number): Promise<TransactionInstruction>;
+    updatePerpMarketUnrealizedAssetWeight(perpMarketIndex: number, unrealizedInitialAssetWeight: number, unrealizedMaintenanceAssetWeight: number): Promise<TransactionSignature>;
+    getUpdatePerpMarketUnrealizedAssetWeightIx(perpMarketIndex: number, unrealizedInitialAssetWeight: number, unrealizedMaintenanceAssetWeight: number): Promise<TransactionInstruction>;
+    updatePerpMarketMaxImbalances(perpMarketIndex: number, unrealizedMaxImbalance: BN, maxRevenueWithdrawPerPeriod: BN, quoteMaxInsurance: BN): Promise<TransactionSignature>;
+    getUpdatePerpMarketMaxImbalancesIx(perpMarketIndex: number, unrealizedMaxImbalance: BN, maxRevenueWithdrawPerPeriod: BN, quoteMaxInsurance: BN): Promise<TransactionInstruction>;
+    updatePerpMarketMaxOpenInterest(perpMarketIndex: number, maxOpenInterest: BN): Promise<TransactionSignature>;
+    getUpdatePerpMarketMaxOpenInterestIx(perpMarketIndex: number, maxOpenInterest: BN): Promise<TransactionInstruction>;
+    updatePerpMarketNumberOfUser(perpMarketIndex: number, numberOfUsers?: number, numberOfUsersWithBase?: number): Promise<TransactionSignature>;
+    getUpdatePerpMarketNumberOfUsersIx(perpMarketIndex: number, numberOfUsers?: number, numberOfUsersWithBase?: number): Promise<TransactionInstruction>;
+    updatePerpMarketFeeAdjustment(perpMarketIndex: number, feeAdjustment: number): Promise<TransactionSignature>;
+    getUpdatePerpMarketFeeAdjustmentIx(perpMarketIndex: number, feeAdjustment: number): Promise<TransactionInstruction>;
+    updateSpotMarketFeeAdjustment(perpMarketIndex: number, feeAdjustment: number): Promise<TransactionSignature>;
+    getUpdateSpotMarketFeeAdjustmentIx(spotMarketIndex: number, feeAdjustment: number): Promise<TransactionInstruction>;
+    updatePerpMarketLiquidationFee(perpMarketIndex: number, liquidatorFee: number, ifLiquidationFee: number): Promise<TransactionSignature>;
+    getUpdatePerpMarketLiquidationFeeIx(perpMarketIndex: number, liquidatorFee: number, ifLiquidationFee: number): Promise<TransactionInstruction>;
+    updateSpotMarketLiquidationFee(spotMarketIndex: number, liquidatorFee: number, ifLiquidationFee: number): Promise<TransactionSignature>;
+    getUpdateSpotMarketLiquidationFeeIx(spotMarketIndex: number, liquidatorFee: number, ifLiquidationFee: number): Promise<TransactionInstruction>;
+    initializeProtocolIfSharesTransferConfig(): Promise<TransactionSignature>;
+    getInitializeProtocolIfSharesTransferConfigIx(): Promise<TransactionInstruction>;
+    updateProtocolIfSharesTransferConfig(whitelistedSigners?: PublicKey[], maxTransferPerEpoch?: BN): Promise<TransactionSignature>;
+    getUpdateProtocolIfSharesTransferConfigIx(whitelistedSigners?: PublicKey[], maxTransferPerEpoch?: BN): Promise<TransactionInstruction>;
+    transferProtocolIfSharesToRevenuePool(outMarketIndex: number, inMarketIndex: number, amount: BN): Promise<TransactionSignature>;
+    getTransferProtocolIfSharesToRevenuePoolIx(outMarketIndex: number, inMarketIndex: number, amount: BN): Promise<TransactionInstruction>;
+    adminWithdrawFromInsuranceFundVault(marketIndex: number, amount: BN, recipientTokenAccount: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
+    getAdminWithdrawFromInsuranceFundVaultIx(marketIndex: number, amount: BN, recipientTokenAccount: PublicKey): Promise<TransactionInstruction>;
+    initializePrelaunchOracle(perpMarketIndex: number, price?: BN, maxPrice?: BN): Promise<TransactionSignature>;
+    getInitializePrelaunchOracleIx(perpMarketIndex: number, price?: BN, maxPrice?: BN): Promise<TransactionInstruction>;
+    updatePrelaunchOracleParams(perpMarketIndex: number, price?: BN, maxPrice?: BN): Promise<TransactionSignature>;
+    getUpdatePrelaunchOracleParamsIx(perpMarketIndex: number, price?: BN, maxPrice?: BN): Promise<TransactionInstruction>;
+    deletePrelaunchOracle(perpMarketIndex: number): Promise<TransactionSignature>;
+    getDeletePrelaunchOracleIx(perpMarketIndex: number, price?: BN, maxPrice?: BN): Promise<TransactionInstruction>;
+    updatePerpMarketOracleLowRiskSlotDelayOverride(perpMarketIndex: number, oracleLowRiskSlotDelayOverride: number): Promise<TransactionSignature>;
+    getUpdatePerpMarketOracleLowRiskSlotDelayOverrideIx(perpMarketIndex: number, oracleLowRiskSlotDelayOverride: number): Promise<TransactionInstruction>;
+    updatePerpMarketOracleSlotDelayOverride(perpMarketIndex: number, oracleSlotDelay: number): Promise<TransactionSignature>;
+    getUpdatePerpMarketOracleSlotDelayOverrideIx(perpMarketIndex: number, oracleSlotDelay: number): Promise<TransactionInstruction>;
+    updatePerpMarketAmmSpreadAdjustment(perpMarketIndex: number, ammSpreadAdjustment: number, ammInventorySpreadAdjustment: number, referencePriceOffset: number): Promise<TransactionSignature>;
+    getUpdatePerpMarketAmmSpreadAdjustmentIx(perpMarketIndex: number, ammSpreadAdjustment: number, ammInventorySpreadAdjustment: number, referencePriceOffset: number): Promise<TransactionInstruction>;
+    initializeIfRebalanceConfig(params: IfRebalanceConfigParams): Promise<TransactionSignature>;
+    getInitializeIfRebalanceConfigIx(params: IfRebalanceConfigParams): Promise<TransactionInstruction>;
+    initializePythLazerOracle(feedId: number): Promise<TransactionSignature>;
+    getInitializePythLazerOracleIx(feedId: number): Promise<TransactionInstruction>;
+    adminDeposit(marketIndex: number, amount: BN, depositUserAccount: PublicKey, adminTokenAccount?: PublicKey): Promise<TransactionSignature>;
+    getAdminDepositIx(marketIndex: number, amount: BN, depositUserAccount: PublicKey, adminTokenAccount?: PublicKey): Promise<TransactionInstruction>;
+    zeroMMOracleFields(marketIndex: number): Promise<TransactionSignature>;
+    getZeroMMOracleFieldsIx(marketIndex: number): Promise<TransactionInstruction>;
+    updateFeatureBitFlagsMMOracle(enable: boolean): Promise<TransactionSignature>;
+    getUpdateFeatureBitFlagsMMOracleIx(enable: boolean): Promise<TransactionInstruction>;
+    updateFeatureBitFlagsBuilderCodes(enable: boolean): Promise<TransactionSignature>;
+    getUpdateFeatureBitFlagsBuilderCodesIx(enable: boolean): Promise<TransactionInstruction>;
+    updateFeatureBitFlagsBuilderReferral(enable: boolean): Promise<TransactionSignature>;
+    getUpdateFeatureBitFlagsBuilderReferralIx(enable: boolean): Promise<TransactionInstruction>;
+    updateFeatureBitFlagsMedianTriggerPrice(enable: boolean): Promise<TransactionSignature>;
+    getUpdateFeatureBitFlagsMedianTriggerPriceIx(enable: boolean): Promise<TransactionInstruction>;
+    updateDelegateUserGovTokenInsuranceStake(authority: PublicKey, delegate: PublicKey): Promise<TransactionSignature>;
+    getUpdateDelegateUserGovTokenInsuranceStakeIx(authority: PublicKey, delegate: PublicKey): Promise<TransactionInstruction>;
+    depositIntoInsuranceFundStake(marketIndex: number, amount: BN, userStatsPublicKey: PublicKey, insuranceFundStakePublicKey: PublicKey, userTokenAccountPublicKey: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
+    getDepositIntoInsuranceFundStakeIx(marketIndex: number, amount: BN, userStatsPublicKey: PublicKey, insuranceFundStakePublicKey: PublicKey, userTokenAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
+    updateFeatureBitFlagsSettleLpPool(enable: boolean): Promise<TransactionSignature>;
+    getUpdateFeatureBitFlagsSettleLpPoolIx(enable: boolean): Promise<TransactionInstruction>;
+    updateFeatureBitFlagsSwapLpPool(enable: boolean): Promise<TransactionSignature>;
+    getUpdateFeatureBitFlagsSwapLpPoolIx(enable: boolean): Promise<TransactionInstruction>;
+    updateFeatureBitFlagsMintRedeemLpPool(enable: boolean): Promise<TransactionSignature>;
+    getUpdateFeatureBitFlagsMintRedeemLpPoolIx(enable: boolean): Promise<TransactionInstruction>;
+    adminUpdateUserStatsPausedOperations(authority: PublicKey, pausedOperations: number): Promise<TransactionSignature>;
+    getAdminUpdateUserStatsPausedOperationsIx(authority: PublicKey, pausedOperations: number): Promise<TransactionInstruction>;
+    initializeLpPool(lpPoolId: number, minMintFee: BN, maxAum: BN, maxSettleQuoteAmountPerMarket: BN, mint: Keypair, whitelistMint?: PublicKey): Promise<TransactionSignature>;
+    getInitializeLpPoolIx(lpPoolId: number, minMintFee: BN, maxAum: BN, maxSettleQuoteAmountPerMarket: BN, mint: Keypair, whitelistMint?: PublicKey): Promise<TransactionInstruction[]>;
+    initializeConstituent(lpPoolId: number, initializeConstituentParams: InitializeConstituentParams): Promise<TransactionSignature>;
+    getInitializeConstituentIx(lpPoolId: number, initializeConstituentParams: InitializeConstituentParams): Promise<TransactionInstruction[]>;
+    updateConstituentStatus(constituent: PublicKey, constituentStatus: ConstituentStatus): Promise<TransactionSignature>;
+    getUpdateConstituentStatusIx(constituent: PublicKey, constituentStatus: ConstituentStatus): Promise<TransactionInstruction>;
+    updateConstituentPausedOperations(constituent: PublicKey, pausedOperations: number): Promise<TransactionSignature>;
+    getUpdateConstituentPausedOperationsIx(constituent: PublicKey, pausedOperations: number): Promise<TransactionInstruction>;
+    updateConstituentParams(lpPoolId: number, constituentPublicKey: PublicKey, updateConstituentParams: {
+        maxWeightDeviation?: BN;
+        swapFeeMin?: BN;
+        swapFeeMax?: BN;
+        maxBorrowTokenAmount?: BN;
+        oracleStalenessThreshold?: BN;
+        costToTradeBps?: number;
+        derivativeWeight?: BN;
+        constituentDerivativeIndex?: number;
+        volatility?: BN;
+        gammaExecution?: number;
+        gammaInventory?: number;
+        xi?: number;
+    }): Promise<TransactionSignature>;
+    getUpdateConstituentParamsIx(lpPoolId: number, constituentPublicKey: PublicKey, updateConstituentParams: {
+        maxWeightDeviation?: BN;
+        swapFeeMin?: BN;
+        swapFeeMax?: BN;
+        maxBorrowTokenAmount?: BN;
+        oracleStalenessThreshold?: BN;
+        derivativeWeight?: BN;
+        constituentDerivativeIndex?: number;
+        volatility?: BN;
+        gammaExecution?: number;
+        gammaInventory?: number;
+        xi?: number;
+    }): Promise<TransactionInstruction[]>;
+    updateLpPoolParams(lpPoolId: number, updateLpPoolParams: {
+        maxSettleQuoteAmount?: BN;
+        volatility?: BN;
+        gammaExecution?: number;
+        xi?: number;
+        whitelistMint?: PublicKey;
+        maxAum?: BN;
+    }): Promise<TransactionSignature>;
+    getUpdateLpPoolParamsIx(lpPoolId: number, updateLpPoolParams: {
+        maxSettleQuoteAmount?: BN;
+        volatility?: BN;
+        gammaExecution?: number;
+        xi?: number;
+        whitelistMint?: PublicKey;
+        maxAum?: BN;
+    }): Promise<TransactionInstruction[]>;
+    addAmmConstituentMappingData(lpPoolId: number, addAmmConstituentMappingData: AddAmmConstituentMappingDatum[]): Promise<TransactionSignature>;
+    getAddAmmConstituentMappingDataIx(lpPoolId: number, addAmmConstituentMappingData: AddAmmConstituentMappingDatum[]): Promise<TransactionInstruction[]>;
+    updateAmmConstituentMappingData(lpPoolId: number, addAmmConstituentMappingData: AddAmmConstituentMappingDatum[]): Promise<TransactionSignature>;
+    getUpdateAmmConstituentMappingDataIx(lpPoolId: number, addAmmConstituentMappingData: AddAmmConstituentMappingDatum[]): Promise<TransactionInstruction[]>;
+    removeAmmConstituentMappingData(lpPoolId: number, perpMarketIndex: number, constituentIndex: number): Promise<TransactionSignature>;
+    getRemoveAmmConstituentMappingDataIx(lpPoolId: number, perpMarketIndex: number, constituentIndex: number): Promise<TransactionInstruction[]>;
+    updateConstituentCorrelationData(lpPoolId: number, index1: number, index2: number, correlation: BN): Promise<TransactionSignature>;
+    getUpdateConstituentCorrelationDataIx(lpPoolId: number, index1: number, index2: number, correlation: BN): Promise<TransactionInstruction[]>;
+    /**
+     * Get the drift begin_swap and end_swap instructions
+     *
+     * @param outMarketIndex the market index of the token you're buying
+     * @param inMarketIndex the market index of the token you're selling
+     * @param amountIn the amount of the token to sell
+     * @param inTokenAccount the token account to move the tokens being sold (admin signer ata for lp swap)
+     * @param outTokenAccount the token account to receive the tokens being bought (admin signer ata for lp swap)
+     * @param limitPrice the limit price of the swap
+     * @param reduceOnly
+     * @param userAccountPublicKey optional, specify a custom userAccountPublicKey to use instead of getting the current user account; can be helpful if the account is being created within the current tx
+     */
+    getSwapIx({ lpPoolId, outMarketIndex, inMarketIndex, amountIn, inTokenAccount, outTokenAccount, limitPrice, reduceOnly, userAccountPublicKey, }: {
+        lpPoolId: number;
+        outMarketIndex: number;
+        inMarketIndex: number;
+        amountIn: BN;
+        inTokenAccount: PublicKey;
+        outTokenAccount: PublicKey;
+        limitPrice?: BN;
+        reduceOnly?: SwapReduceOnly;
+        userAccountPublicKey?: PublicKey;
+    }, lpSwap?: boolean): Promise<{
+        beginSwapIx: TransactionInstruction;
+        endSwapIx: TransactionInstruction;
+    }>;
+    getLpJupiterSwapIxV6({ jupiterClient, outMarketIndex, inMarketIndex, amount, slippageBps, swapMode, onlyDirectRoutes, quote, lpPoolId, }: {
+        jupiterClient: JupiterClient;
+        outMarketIndex: number;
+        inMarketIndex: number;
+        outAssociatedTokenAccount?: PublicKey;
+        inAssociatedTokenAccount?: PublicKey;
+        amount: BN;
+        slippageBps?: number;
+        swapMode?: SwapMode;
+        onlyDirectRoutes?: boolean;
+        quote?: QuoteResponse;
+        lpPoolId: number;
+    }): Promise<{
+        ixs: TransactionInstruction[];
+        lookupTables: AddressLookupTableAccount[];
+    }>;
+    getDevnetLpSwapIxs(amountIn: BN, amountOut: BN, externalUserAuthority: PublicKey, externalUserInTokenAccount: PublicKey, externalUserOutTokenAccount: PublicKey, inSpotMarketIndex: number, outSpotMarketIndex: number): Promise<TransactionInstruction[]>;
+    getAllDevnetLpSwapIxs(lpPoolId: number, inMarketIndex: number, outMarketIndex: number, inAmount: BN, minOutAmount: BN, externalUserAuthority: PublicKey): Promise<TransactionInstruction[]>;
+    depositWithdrawToProgramVault(lpPoolId: number, depositMarketIndex: number, borrowMarketIndex: number, amountToDeposit: BN, amountToBorrow: BN): Promise<TransactionSignature>;
+    getDepositWithdrawToProgramVaultIxs(lpPoolId: number, depositMarketIndex: number, borrowMarketIndex: number, amountToDeposit: BN, amountToBorrow: BN): Promise<{
+        depositIx: TransactionInstruction;
+        withdrawIx: TransactionInstruction;
+    }>;
+    depositToProgramVault(lpPoolId: number, depositMarketIndex: number, amountToDeposit: BN): Promise<TransactionSignature>;
+    withdrawFromProgramVault(lpPoolId: number, borrowMarketIndex: number, amountToWithdraw: BN): Promise<TransactionSignature>;
+    getDepositToProgramVaultIx(lpPoolId: number, depositMarketIndex: number, amountToDeposit: BN): Promise<TransactionInstruction>;
+    getWithdrawFromProgramVaultIx(lpPoolId: number, borrowMarketIndex: number, amountToWithdraw: BN): Promise<TransactionInstruction>;
+    updatePerpMarketLpPoolFeeTransferScalar(marketIndex: number, lpFeeTransferScalar?: number, lpExchangeFeeExcluscionScalar?: number): Promise<string>;
+    getUpdatePerpMarketLpPoolFeeTransferScalarIx(marketIndex: number, lpFeeTransferScalar?: number, lpExchangeFeeExcluscionScalar?: number): Promise<TransactionInstruction>;
+    updatePerpMarketLpPoolPausedOperations(marketIndex: number, pausedOperations: number): Promise<string>;
+    getUpdatePerpMarketLpPoolPausedOperationsIx(marketIndex: number, pausedOperations: number): Promise<TransactionInstruction>;
+    mintLpWhitelistToken(lpPool: LPPoolAccount, authority: PublicKey): Promise<TransactionSignature>;
+    getMintLpWhitelistTokenIx(lpPool: LPPoolAccount, authority: PublicKey): Promise<TransactionInstruction[]>;
+    updatePerpMarketConfig(marketIndex: number, marketConfig: number): Promise<string>;
+    getUpdatePerpMarketConfigIx(marketIndex: number, marketConfig: number): Promise<TransactionInstruction>;
+    transferFeeAndPnlPool(perpMarketIndexWithFeePool: number, perpMarketIndexWithPnlPool: number, amount: BN, direction: TransferFeeAndPnlPoolDirection): Promise<TransactionSignature>;
+    getTransferFeeAndPnlPoolIx(perpMarketIndexWithFeePool: number, perpMarketIndexWithPnlPool: number, amount: BN, direction: TransferFeeAndPnlPoolDirection): Promise<TransactionInstruction>;
+    updateSpecialUserStatus(userAccountPublicKey: PublicKey, status: number, txParams?: TxParams): Promise<TransactionSignature>;
+    getUpdateSpecialUserStatusIx(userAccountPublicKey: PublicKey, status: number): Promise<TransactionInstruction>;
+    updateWarmAdmin(newWarmAdmin: PublicKey): Promise<TransactionSignature>;
+    getUpdateWarmAdminIx(newWarmAdmin: PublicKey): Promise<TransactionInstruction>;
+    updateHotAdmin(role: HotRole, newPubkey: PublicKey): Promise<TransactionSignature>;
+    getUpdateHotAdminIx(role: HotRole, newPubkey: PublicKey): Promise<TransactionInstruction>;
+}
+/**
+ * Hot-admin role identifier. Each role is a separate purpose-specific signer key
+ * stored on the `AdminAuthorityConfig` PDA. Compromise of one role's key only
+ * enables that role's instructions.
+ */
+export declare enum HotRole {
+    AmmCrank = "ammCrank",
+    LpCache = "lpCache",
+    LpSwap = "lpSwap",
+    LpSettle = "lpSettle",
+    IfRebalance = "ifRebalance",
+    FeatureFlag = "featureFlag",
+    Fuel = "fuel",
+    UserFlag = "userFlag",
+    VaultDeposit = "vaultDeposit",
+    MmOracleCrank = "mmOracleCrank",
+    AmmSpreadAdjust = "ammSpreadAdjust"
+}