@drift-labs/sdk 0.2.0-temp.2 → 2.0.1

package/lib/accounts/webSocketClearingHouseAccountSubscriber.d.ts

@@ -1,49 +0,0 @@
-/// <reference types="bn.js" />
-/// <reference types="node" />
-import { ClearingHouseAccountSubscriber, ClearingHouseAccountEvents, DataAndSlot } from './types';
-import { AccountSubscriber } from './types';
-import { BankAccount, MarketAccount, StateAccount } from '../types';
-import { BN, Program } from '@project-serum/anchor';
-import StrictEventEmitter from 'strict-event-emitter-types';
-import { EventEmitter } from 'events';
-import { PublicKey } from '@solana/web3.js';
-import { OracleInfo, OraclePriceData } from '../oracles/types';
-import { OracleClientCache } from '../oracles/oracleClientCache';
-export declare class WebSocketClearingHouseAccountSubscriber implements ClearingHouseAccountSubscriber {
-    isSubscribed: boolean;
-    program: Program;
-    marketIndexes: BN[];
-    bankIndexes: BN[];
-    oracleInfos: OracleInfo[];
-    oracleClientCache: OracleClientCache;
-    eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
-    stateAccountSubscriber?: AccountSubscriber<StateAccount>;
-    marketAccountSubscribers: Map<number, AccountSubscriber<MarketAccount>>;
-    bankAccountSubscribers: Map<number, AccountSubscriber<BankAccount>>;
-    oracleSubscribers: Map<string, AccountSubscriber<OraclePriceData>>;
-    private isSubscribing;
-    private subscriptionPromise;
-    private subscriptionPromiseResolver;
-    constructor(program: Program, marketIndexes: BN[], bankIndexes: BN[], oracleInfos: OracleInfo[]);
-    subscribe(): Promise<boolean>;
-    subscribeToMarketAccounts(): Promise<boolean>;
-    subscribeToMarketAccount(marketIndex: BN): Promise<boolean>;
-    subscribeToBankAccounts(): Promise<boolean>;
-    subscribeToBankAccount(bankIndex: BN): Promise<boolean>;
-    subscribeToOracles(): Promise<boolean>;
-    subscribeToOracle(oracleInfo: OracleInfo): Promise<boolean>;
-    unsubscribeFromMarketAccounts(): Promise<void>;
-    unsubscribeFromBankAccounts(): Promise<void>;
-    unsubscribeFromOracles(): Promise<void>;
-    fetch(): Promise<void>;
-    unsubscribe(): Promise<void>;
-    addBank(bankIndex: BN): Promise<boolean>;
-    addMarket(marketIndex: BN): Promise<boolean>;
-    addOracle(oracleInfo: OracleInfo): Promise<boolean>;
-    assertIsSubscribed(): void;
-    getStateAccountAndSlot(): DataAndSlot<StateAccount>;
-    getMarketAccountAndSlot(marketIndex: BN): DataAndSlot<MarketAccount> | undefined;
-    getMarketAccountsAndSlots(): DataAndSlot<MarketAccount>[];
-    getBankAccountAndSlot(bankIndex: BN): DataAndSlot<BankAccount> | undefined;
-    getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
-}

package/lib/admin.d.ts

@@ -1,44 +0,0 @@
-/// <reference types="bn.js" />
-import { PublicKey, TransactionSignature } from '@solana/web3.js';
-import { FeeStructure, OracleGuardRails, OracleSource, OrderFillerRewardStructure } from './types';
-import { BN } from '@project-serum/anchor';
-import { ClearingHouse } from './clearingHouse';
-export declare class Admin extends ClearingHouse {
-    initialize(usdcMint: PublicKey, adminControlsPrices: boolean): Promise<[TransactionSignature]>;
-    initializeBank(mint: PublicKey, optimalUtilization: BN, optimalRate: BN, maxRate: BN, oracle: PublicKey, oracleSource: OracleSource, initialAssetWeight: BN, maintenanceAssetWeight: BN, initialLiabilityWeight: BN, maintenanceLiabilityWeight: BN, imfFactor?: BN, liquidationFee?: BN): Promise<TransactionSignature>;
-    initializeMarket(priceOracle: PublicKey, baseAssetReserve: BN, quoteAssetReserve: BN, periodicity: BN, pegMultiplier?: BN, oracleSource?: OracleSource, marginRatioInitial?: number, marginRatioMaintenance?: number, liquidationFee?: BN): Promise<TransactionSignature>;
-    moveAmmPrice(baseAssetReserve: BN, quoteAssetReserve: BN, marketIndex: BN): Promise<TransactionSignature>;
-    updateK(sqrtK: BN, marketIndex: BN): Promise<TransactionSignature>;
-    moveAmmToPrice(marketIndex: BN, targetPrice: BN): Promise<TransactionSignature>;
-    repegAmmCurve(newPeg: BN, marketIndex: BN): Promise<TransactionSignature>;
-    updateAmmOracleTwap(marketIndex: BN): Promise<TransactionSignature>;
-    resetAmmOracleTwap(marketIndex: BN): Promise<TransactionSignature>;
-    withdrawFromInsuranceVault(amount: BN, recipient: PublicKey): Promise<TransactionSignature>;
-    withdrawFromMarketToInsuranceVault(marketIndex: BN, amount: BN, recipient: PublicKey): Promise<TransactionSignature>;
-    withdrawFromInsuranceVaultToMarket(marketIndex: BN, amount: BN): Promise<TransactionSignature>;
-    updateAdmin(admin: PublicKey): Promise<TransactionSignature>;
-    updateCurveUpdateIntensity(marketIndex: BN, curveUpdateIntensity: number): Promise<TransactionSignature>;
-    updateMarginRatio(marketIndex: BN, marginRatioInitial: number, marginRatioMaintenance: number): Promise<TransactionSignature>;
-    updateMarketBaseSpread(marketIndex: BN, baseSpread: number): Promise<TransactionSignature>;
-    updateMarketMaxSpread(marketIndex: BN, maxSpread: number): Promise<TransactionSignature>;
-    updatePartialLiquidationClosePercentage(numerator: BN, denominator: BN): Promise<TransactionSignature>;
-    updatePartialLiquidationPenaltyPercentage(numerator: BN, denominator: BN): Promise<TransactionSignature>;
-    updateFullLiquidationPenaltyPercentage(numerator: BN, denominator: BN): Promise<TransactionSignature>;
-    updatePartialLiquidationShareDenominator(denominator: BN): Promise<TransactionSignature>;
-    updateFullLiquidationShareDenominator(denominator: BN): Promise<TransactionSignature>;
-    updateOrderFillerRewardStructure(orderFillerRewardStructure: OrderFillerRewardStructure): Promise<TransactionSignature>;
-    updateFee(fees: FeeStructure): Promise<TransactionSignature>;
-    updateOracleGuardRails(oracleGuardRails: OracleGuardRails): Promise<TransactionSignature>;
-    updateMarketOracle(marketIndex: BN, oracle: PublicKey, oracleSource: OracleSource): Promise<TransactionSignature>;
-    updateMarketMinimumQuoteAssetTradeSize(marketIndex: BN, minimumTradeSize: BN): Promise<TransactionSignature>;
-    updateMarketBaseAssetAmountStepSize(marketIndex: BN, stepSize: BN): Promise<TransactionSignature>;
-    updateWhitelistMint(whitelistMint?: PublicKey): Promise<TransactionSignature>;
-    updateDiscountMint(discountMint: PublicKey): Promise<TransactionSignature>;
-    updateMaxDeposit(maxDeposit: BN): Promise<TransactionSignature>;
-    updateFundingPaused(fundingPaused: boolean): Promise<TransactionSignature>;
-    updateExchangePaused(exchangePaused: boolean): Promise<TransactionSignature>;
-    disableAdminControlsPrices(): Promise<TransactionSignature>;
-    updateAuctionDuration(minDuration: BN | number, maxDuration: BN | number): Promise<TransactionSignature>;
-    updateMaxBaseAssetAmountRatio(marketIndex: BN, maxBaseAssetAmountRatio: number): Promise<TransactionSignature>;
-    updateMaxSlippageRatio(marketIndex: BN, maxSlippageRatio: number): Promise<TransactionSignature>;
-}

package/lib/admin.js

@@ -1,438 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Admin = void 0;
-const web3_js_1 = require("@solana/web3.js");
-const types_1 = require("./types");
-const anchor_1 = require("@project-serum/anchor");
-const anchor = __importStar(require("@project-serum/anchor"));
-const pda_1 = require("./addresses/pda");
-const spl_token_1 = require("@solana/spl-token");
-const clearingHouse_1 = require("./clearingHouse");
-const numericConstants_1 = require("./constants/numericConstants");
-const trade_1 = require("./math/trade");
-const amm_1 = require("./math/amm");
-class Admin extends clearingHouse_1.ClearingHouse {
-    async initialize(usdcMint, adminControlsPrices) {
-        const stateAccountRPCResponse = await this.connection.getParsedAccountInfo(await this.getStatePublicKey());
-        if (stateAccountRPCResponse.value !== null) {
-            throw new Error('Clearing house already initialized');
-        }
-        const [insuranceVaultPublicKey] = await web3_js_1.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('insurance_vault'))], this.program.programId);
-        const [insuranceVaultAuthority] = await web3_js_1.PublicKey.findProgramAddress([insuranceVaultPublicKey.toBuffer()], this.program.programId);
-        const [clearingHouseStatePublicKey] = await (0, pda_1.getClearingHouseStateAccountPublicKeyAndNonce)(this.program.programId);
-        const initializeTx = await this.program.transaction.initialize(adminControlsPrices, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: clearingHouseStatePublicKey,
-                quoteAssetMint: usdcMint,
-                insuranceVault: insuranceVaultPublicKey,
-                insuranceVaultAuthority: insuranceVaultAuthority,
-                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
-                systemProgram: anchor.web3.SystemProgram.programId,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            },
-        });
-        const { txSig: initializeTxSig } = await this.txSender.send(initializeTx, [], this.opts);
-        return [initializeTxSig];
-    }
-    async initializeBank(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = new anchor_1.BN(0), liquidationFee = numericConstants_1.ZERO) {
-        const bankIndex = this.getStateAccount().numberOfBanks;
-        const bank = await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex);
-        const bankVault = await (0, pda_1.getBankVaultPublicKey)(this.program.programId, bankIndex);
-        const bankVaultAuthority = await (0, pda_1.getBankVaultAuthorityPublicKey)(this.program.programId, bankIndex);
-        const initializeTx = await this.program.transaction.initializeBank(optimalUtilization, optimalRate, maxRate, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, liquidationFee, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                bank,
-                bankVault,
-                bankVaultAuthority,
-                bankMint: mint,
-                oracle,
-                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
-                systemProgram: anchor.web3.SystemProgram.programId,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            },
-        });
-        const { txSig } = await this.txSender.send(initializeTx, [], this.opts);
-        await this.accountSubscriber.addBank(bankIndex);
-        await this.accountSubscriber.addOracle({
-            source: oracleSource,
-            publicKey: oracle,
-        });
-        return txSig;
-    }
-    async initializeMarket(priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, marginRatioInitial = 2000, marginRatioMaintenance = 500, liquidationFee = numericConstants_1.ZERO) {
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, this.getStateAccount().numberOfMarkets);
-        const initializeMarketTx = await this.program.transaction.initializeMarket(baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, marginRatioInitial, marginRatioMaintenance, liquidationFee, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                admin: this.wallet.publicKey,
-                oracle: priceOracle,
-                market: marketPublicKey,
-                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
-                systemProgram: anchor.web3.SystemProgram.programId,
-            },
-        });
-        const { txSig } = await this.txSender.send(initializeMarketTx, [], this.opts);
-        await this.accountSubscriber.addMarket(this.getStateAccount().numberOfMarkets);
-        await this.accountSubscriber.addOracle({
-            source: oracleSource,
-            publicKey: priceOracle,
-        });
-        return txSig;
-    }
-    async moveAmmPrice(baseAssetReserve, quoteAssetReserve, marketIndex) {
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        return await this.program.rpc.moveAmmPrice(baseAssetReserve, quoteAssetReserve, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                admin: this.wallet.publicKey,
-                market: marketPublicKey,
-            },
-        });
-    }
-    async updateK(sqrtK, marketIndex) {
-        return await this.program.rpc.updateK(sqrtK, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                admin: this.wallet.publicKey,
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
-                oracle: this.getMarketAccount(marketIndex).amm.oracle,
-            },
-        });
-    }
-    async moveAmmToPrice(marketIndex, targetPrice) {
-        const market = this.getMarketAccount(marketIndex);
-        const [direction, tradeSize, _] = (0, trade_1.calculateTargetPriceTrade)(market, targetPrice, new anchor_1.BN(1000), 'quote', undefined //todo
-        );
-        const [newQuoteAssetAmount, newBaseAssetAmount] = (0, amm_1.calculateAmmReservesAfterSwap)(market.amm, 'quote', tradeSize, (0, amm_1.getSwapDirection)('quote', direction));
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        return await this.program.rpc.moveAmmPrice(newBaseAssetAmount, newQuoteAssetAmount, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                admin: this.wallet.publicKey,
-                market: marketPublicKey,
-            },
-        });
-    }
-    async repegAmmCurve(newPeg, marketIndex) {
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        const ammData = this.getMarketAccount(marketIndex).amm;
-        return await this.program.rpc.repegAmmCurve(newPeg, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                admin: this.wallet.publicKey,
-                oracle: ammData.oracle,
-                market: marketPublicKey,
-            },
-        });
-    }
-    async updateAmmOracleTwap(marketIndex) {
-        const ammData = this.getMarketAccount(marketIndex).amm;
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        return await this.program.rpc.updateAmmOracleTwap({
-            accounts: {
-                state: await this.getStatePublicKey(),
-                admin: this.wallet.publicKey,
-                oracle: ammData.oracle,
-                market: marketPublicKey,
-            },
-        });
-    }
-    async resetAmmOracleTwap(marketIndex) {
-        const ammData = this.getMarketAccount(marketIndex).amm;
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        return await this.program.rpc.resetAmmOracleTwap({
-            accounts: {
-                state: await this.getStatePublicKey(),
-                admin: this.wallet.publicKey,
-                oracle: ammData.oracle,
-                market: marketPublicKey,
-            },
-        });
-    }
-    async withdrawFromInsuranceVault(amount, recipient) {
-        const state = await this.getStateAccount();
-        const bank = this.getQuoteAssetBankAccount();
-        return await this.program.rpc.withdrawFromInsuranceVault(amount, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                bank: bank.pubkey,
-                insuranceVault: state.insuranceVault,
-                insuranceVaultAuthority: state.insuranceVaultAuthority,
-                recipient: recipient,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            },
-        });
-    }
-    async withdrawFromMarketToInsuranceVault(marketIndex, amount, recipient) {
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        const bank = this.getQuoteAssetBankAccount();
-        return await this.program.rpc.withdrawFromMarketToInsuranceVault(amount, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                market: marketPublicKey,
-                bank: bank.pubkey,
-                bankVault: bank.vault,
-                bankVaultAuthority: bank.vaultAuthority,
-                recipient: recipient,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            },
-        });
-    }
-    async withdrawFromInsuranceVaultToMarket(marketIndex, amount) {
-        const state = await this.getStateAccount();
-        const bank = this.getQuoteAssetBankAccount();
-        return await this.program.rpc.withdrawFromInsuranceVaultToMarket(amount, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
-                insuranceVault: state.insuranceVault,
-                insuranceVaultAuthority: state.insuranceVaultAuthority,
-                bank: bank.pubkey,
-                bankVault: bank.vault,
-                bankVaultAuthority: bank.vaultAuthority,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            },
-        });
-    }
-    async updateAdmin(admin) {
-        return await this.program.rpc.updateAdmin(admin, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-            },
-        });
-    }
-    async updateCurveUpdateIntensity(marketIndex, curveUpdateIntensity) {
-        // assert(curveUpdateIntensity >= 0 && curveUpdateIntensity <= 100);
-        // assert(Number.isInteger(curveUpdateIntensity));
-        return await this.program.rpc.updateCurveUpdateIntensity(curveUpdateIntensity, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
-            },
-        });
-    }
-    async updateMarginRatio(marketIndex, marginRatioInitial, marginRatioMaintenance) {
-        return await this.program.rpc.updateMarginRatio(marginRatioInitial, marginRatioMaintenance, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
-            },
-        });
-    }
-    async updateMarketBaseSpread(marketIndex, baseSpread) {
-        return await this.program.rpc.updateMarketBaseSpread(baseSpread, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
-            },
-        });
-    }
-    async updateMarketMaxSpread(marketIndex, maxSpread) {
-        return await this.program.rpc.updateMarketMaxSpread(maxSpread, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
-            },
-        });
-    }
-    async updatePartialLiquidationClosePercentage(numerator, denominator) {
-        return await this.program.rpc.updatePartialLiquidationClosePercentage(numerator, denominator, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-            },
-        });
-    }
-    async updatePartialLiquidationPenaltyPercentage(numerator, denominator) {
-        return await this.program.rpc.updatePartialLiquidationPenaltyPercentage(numerator, denominator, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-            },
-        });
-    }
-    async updateFullLiquidationPenaltyPercentage(numerator, denominator) {
-        return await this.program.rpc.updateFullLiquidationPenaltyPercentage(numerator, denominator, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-            },
-        });
-    }
-    async updatePartialLiquidationShareDenominator(denominator) {
-        return await this.program.rpc.updatePartialLiquidationLiquidatorShareDenominator(denominator, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-            },
-        });
-    }
-    async updateFullLiquidationShareDenominator(denominator) {
-        return await this.program.rpc.updateFullLiquidationLiquidatorShareDenominator(denominator, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-            },
-        });
-    }
-    async updateOrderFillerRewardStructure(orderFillerRewardStructure) {
-        return await this.program.rpc.updateOrderFillerRewardStructure(orderFillerRewardStructure, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-            },
-        });
-    }
-    async updateFee(fees) {
-        return await this.program.rpc.updateFee(fees, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-            },
-        });
-    }
-    async updateOracleGuardRails(oracleGuardRails) {
-        return await this.program.rpc.updateOracleGuardRails(oracleGuardRails, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-            },
-        });
-    }
-    async updateMarketOracle(marketIndex, oracle, oracleSource) {
-        return await this.program.rpc.updateMarketOracle(oracle, oracleSource, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
-            },
-        });
-    }
-    async updateMarketMinimumQuoteAssetTradeSize(marketIndex, minimumTradeSize) {
-        return await this.program.rpc.updateMarketMinimumQuoteAssetTradeSize(minimumTradeSize, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
-            },
-        });
-    }
-    async updateMarketBaseAssetAmountStepSize(marketIndex, stepSize) {
-        return await this.program.rpc.updateMarketBaseAssetAmountStepSize(stepSize, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
-            },
-        });
-    }
-    async updateWhitelistMint(whitelistMint) {
-        return await this.program.rpc.updateWhitelistMint(whitelistMint, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-            },
-        });
-    }
-    async updateDiscountMint(discountMint) {
-        return await this.program.rpc.updateDiscountMint(discountMint, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-            },
-        });
-    }
-    async updateMaxDeposit(maxDeposit) {
-        return await this.program.rpc.updateMaxDeposit(maxDeposit, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-            },
-        });
-    }
-    async updateFundingPaused(fundingPaused) {
-        return await this.program.rpc.updateFundingPaused(fundingPaused, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-            },
-        });
-    }
-    async updateExchangePaused(exchangePaused) {
-        return await this.program.rpc.updateExchangePaused(exchangePaused, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-            },
-        });
-    }
-    async disableAdminControlsPrices() {
-        return await this.program.rpc.disableAdminControlsPrices({
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-            },
-        });
-    }
-    async updateAuctionDuration(minDuration, maxDuration) {
-        return await this.program.rpc.updateAuctionDuration(typeof minDuration === 'number' ? minDuration : minDuration.toNumber(), typeof maxDuration === 'number' ? maxDuration : maxDuration.toNumber(), {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-            },
-        });
-    }
-    async updateMaxBaseAssetAmountRatio(marketIndex, maxBaseAssetAmountRatio) {
-        return await this.program.rpc.updateMaxBaseAssetAmountRatio(maxBaseAssetAmountRatio, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                market: this.getMarketAccount(marketIndex).pubkey,
-            },
-        });
-    }
-    async updateMaxSlippageRatio(marketIndex, maxSlippageRatio) {
-        return await this.program.rpc.updateMaxSlippageRatio(maxSlippageRatio, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                market: this.getMarketAccount(marketIndex).pubkey,
-            },
-        });
-    }
-}
-exports.Admin = Admin;