@drift-labs/sdk 0.2.0-master.4 → 0.2.0-master.41

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): Promise<TransactionSignature>;
-    initializeMarket(priceOracle: PublicKey, baseAssetReserve: BN, quoteAssetReserve: BN, periodicity: BN, pegMultiplier?: BN, oracleSource?: OracleSource, marginRatioInitial?: number, marginRatioPartial?: number, marginRatioMaintenance?: number): 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>;
-    withdrawFees(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, marginRatioPartial: 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,433 +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) {
-        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, {
-            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, marginRatioPartial = 625, marginRatioMaintenance = 500) {
-        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, marginRatioPartial, marginRatioMaintenance, {
-            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();
-        return await this.program.rpc.withdrawFromInsuranceVault(amount, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                insuranceVault: state.insuranceVault,
-                insuranceVaultAuthority: state.insuranceVaultAuthority,
-                recipient: recipient,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            },
-        });
-    }
-    async withdrawFees(marketIndex, amount, recipient) {
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        const bank = this.getQuoteAssetBankAccount();
-        return await this.program.rpc.withdrawFees(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();
-        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,
-                bankVault: this.getQuoteAssetBankAccount().vault,
-                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, marginRatioPartial, marginRatioMaintenance) {
-        return await this.program.rpc.updateMarginRatio(marginRatioInitial, marginRatioPartial, 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;

package/lib/clearingHouse.d.ts

@@ -1,133 +0,0 @@
-/// <reference types="node" />
-/// <reference types="bn.js" />
-import { AnchorProvider, BN, Program } from '@project-serum/anchor';
-import { StateAccount, IWallet, PositionDirection, UserAccount, MarketAccount, OrderParams, Order, BankAccount, UserBankBalance, MakerInfo, OptionalOrderParams } from './types';
-import { Connection, PublicKey, TransactionSignature, ConfirmOptions, TransactionInstruction, AccountMeta } from '@solana/web3.js';
-import { MockUSDCFaucet } from './mockUSDCFaucet';
-import { EventEmitter } from 'events';
-import StrictEventEmitter from 'strict-event-emitter-types';
-import { ClearingHouseAccountSubscriber, ClearingHouseAccountEvents, DataAndSlot } from './accounts/types';
-import { TxSender } from './tx/types';
-import { OraclePriceData } from './oracles/types';
-import { ClearingHouseConfig } from './clearingHouseConfig';
-import { ClearingHouseUser } from './clearingHouseUser';
-import { ClearingHouseUserAccountSubscriptionConfig } from './clearingHouseUserConfig';
-/**
- * # ClearingHouse
- * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
- */
-export declare class ClearingHouse {
-    connection: Connection;
-    wallet: IWallet;
-    program: Program;
-    provider: AnchorProvider;
-    opts?: ConfirmOptions;
-    users: Map<number, ClearingHouseUser>;
-    activeUserId: number;
-    userAccountSubscriptionConfig: ClearingHouseUserAccountSubscriptionConfig;
-    accountSubscriber: ClearingHouseAccountSubscriber;
-    eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
-    _isSubscribed: boolean;
-    txSender: TxSender;
-    marketLastSlotCache: Map<number, number>;
-    get isSubscribed(): boolean;
-    set isSubscribed(val: boolean);
-    constructor(config: ClearingHouseConfig);
-    createUsers(userIds: number[], accountSubscriptionConfig: ClearingHouseUserAccountSubscriptionConfig): void;
-    createUser(userId: number, accountSubscriptionConfig: ClearingHouseUserAccountSubscriptionConfig): ClearingHouseUser;
-    subscribe(): Promise<boolean>;
-    subscribeUsers(): Promise<boolean>[];
-    /**
-     *	Forces the accountSubscriber to fetch account updates from rpc
-     */
-    fetchAccounts(): Promise<void>;
-    unsubscribe(): Promise<void>;
-    unsubscribeUsers(): Promise<void>[];
-    statePublicKey?: PublicKey;
-    getStatePublicKey(): Promise<PublicKey>;
-    getStateAccount(): StateAccount;
-    getMarketAccount(marketIndex: BN | number): MarketAccount | undefined;
-    getMarketAccounts(): MarketAccount[];
-    getBankAccount(bankIndex: BN | number): BankAccount | undefined;
-    getQuoteAssetBankAccount(): BankAccount;
-    getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
-    /**
-     * Update the wallet to use for clearing house transactions and linked user account
-     * @param newWallet
-     * @param userIds
-     * @param activeUserId
-     */
-    updateWallet(newWallet: IWallet, userIds?: number[], activeUserId?: number): Promise<void>;
-    switchActiveUser(userId: number): Promise<void>;
-    addUser(userId: number): Promise<void>;
-    initializeUserAccount(userId?: number, name?: string): Promise<[TransactionSignature, PublicKey]>;
-    getInitializeUserInstructions(userId?: number, name?: string): Promise<[PublicKey, TransactionInstruction]>;
-    getUser(userId?: number): ClearingHouseUser;
-    getUsers(): ClearingHouseUser[];
-    getUserAccountPublicKey(): Promise<PublicKey>;
-    getUserAccount(userId?: number): UserAccount | undefined;
-    getUserAccountAndSlot(userId?: number): DataAndSlot<UserAccount> | undefined;
-    getUserBankBalance(bankIndex: number | BN): UserBankBalance | undefined;
-    getQuoteAssetTokenAmount(): BN;
-    getRemainingAccounts(params: {
-        writableMarketIndex?: BN;
-        writableBankIndex?: BN;
-    }): AccountMeta[];
-    getOrder(orderId: BN | number): Order | undefined;
-    getOrderByUserId(userOrderId: number): Order | undefined;
-    deposit(amount: BN, bankIndex: BN, collateralAccountPublicKey: PublicKey, userId?: number, reduceOnly?: boolean): Promise<TransactionSignature>;
-    getDepositInstruction(amount: BN, bankIndex: BN, userTokenAccount: PublicKey, userId?: number, reduceOnly?: boolean, userInitialized?: boolean): Promise<TransactionInstruction>;
-    /**
-     * Creates the Clearing House User account for a user, and deposits some initial collateral
-     * @param userId
-     * @param name
-     * @param amount
-     * @param userTokenAccount
-     * @param fromUserId
-     * @returns
-     */
-    initializeUserAccountAndDepositCollateral(amount: BN, userTokenAccount: PublicKey, bankIndex?: BN, userId?: number, name?: string, fromUserId?: number): Promise<[TransactionSignature, PublicKey]>;
-    initializeUserAccountForDevnet(userId: number, name: string, mockUSDCFaucet: MockUSDCFaucet, amount: BN): Promise<[TransactionSignature, PublicKey]>;
-    withdraw(amount: BN, bankIndex: BN, userTokenAccount: PublicKey, reduceOnly?: boolean): Promise<TransactionSignature>;
-    getWithdrawIx(amount: BN, bankIndex: BN, userTokenAccount: PublicKey, reduceOnly?: boolean): Promise<TransactionInstruction>;
-    transferDeposit(amount: BN, bankIndex: BN, fromUserId: number, toUserId: number): Promise<TransactionSignature>;
-    getTransferDepositIx(amount: BN, bankIndex: BN, fromUserId: number, toUserId: number): Promise<TransactionInstruction>;
-    updateBankCumulativeInterest(bankIndex: BN): Promise<TransactionSignature>;
-    updateBankCumulativeInterestIx(bankIndex: BN): Promise<TransactionInstruction>;
-    openPosition(direction: PositionDirection, amount: BN, marketIndex: BN, limitPrice?: BN): Promise<TransactionSignature>;
-    placeOrder(orderParams: OptionalOrderParams): Promise<TransactionSignature>;
-    getOrderParams(optionalOrderParams: OptionalOrderParams): OrderParams;
-    getPlaceOrderIx(orderParams: OptionalOrderParams): Promise<TransactionInstruction>;
-    updateAMMs(marketIndexes: BN[]): Promise<TransactionSignature>;
-    getUpdateAMMsIx(marketIndexes: BN[]): Promise<TransactionInstruction>;
-    cancelOrder(orderId?: BN): Promise<TransactionSignature>;
-    getCancelOrderIx(orderId?: BN): Promise<TransactionInstruction>;
-    cancelOrderByUserId(userOrderId: number): Promise<TransactionSignature>;
-    getCancelOrderByUserIdIx(userOrderId: number): Promise<TransactionInstruction>;
-    fillOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Order, makerInfo?: MakerInfo): Promise<TransactionSignature>;
-    getFillOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order, makerInfo?: MakerInfo): Promise<TransactionInstruction>;
-    triggerOrder(userAccountPublicKey: PublicKey, user: UserAccount, order: Order): Promise<TransactionSignature>;
-    getTriggerOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order): Promise<TransactionInstruction>;
-    placeAndTake(orderParams: OptionalOrderParams, makerInfo?: MakerInfo): Promise<TransactionSignature>;
-    getPlaceAndTakeIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo): Promise<TransactionInstruction>;
-    /**
-     * Close an entire position. If you want to reduce a position, use the {@link openPosition} method in the opposite direction of the current position.
-     * @param marketIndex
-     * @returns
-     */
-    closePosition(marketIndex: BN): Promise<TransactionSignature>;
-    settlePNLs(users: {
-        settleeUserAccountPublicKey: PublicKey;
-        settleeUserAccount: UserAccount;
-    }[], marketIndex: BN): Promise<TransactionSignature>;
-    settlePNL(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: BN): Promise<TransactionSignature>;
-    settlePNLIx(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: BN): Promise<TransactionInstruction>;
-    liquidate(liquidateeUserAccountPublicKey: PublicKey): Promise<TransactionSignature>;
-    getLiquidateIx(liquidateeUserAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
-    updateFundingRate(oracle: PublicKey, marketIndex: BN): Promise<TransactionSignature>;
-    getUpdateFundingRateIx(oracle: PublicKey, marketIndex: BN): Promise<TransactionInstruction>;
-    settleFundingPayment(userAccount: PublicKey): Promise<TransactionSignature>;
-    getSettleFundingPaymentIx(userAccount: PublicKey): Promise<TransactionInstruction>;
-    triggerEvent(eventName: keyof ClearingHouseAccountEvents, data?: any): void;
-    getOracleDataForMarket(marketIndex: BN): OraclePriceData;
-}