@drift-labs/sdk 0.2.0-master.1 → 0.2.0-master.10

package/src/accounts/webSocketAccountSubscriber.js

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketAccountSubscriber = void 0;
+const utils_1 = require("./utils");
+class WebSocketAccountSubscriber {
+    constructor(accountName, program, accountPublicKey, decodeBuffer) {
+        this.accountName = accountName;
+        this.program = program;
+        this.accountPublicKey = accountPublicKey;
+        this.decodeBufferFn = decodeBuffer;
+    }
+    subscribe(onChange) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.listenerId) {
+                return;
+            }
+            this.onChange = onChange;
+            yield this.fetch();
+            this.listenerId = this.program.provider.connection.onAccountChange(this.accountPublicKey, (accountInfo, context) => {
+                this.handleRpcResponse(context, accountInfo);
+            }, this.program.provider.opts.commitment);
+        });
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rpcResponse = yield this.program.provider.connection.getAccountInfoAndContext(this.accountPublicKey, this.program.provider.opts.commitment);
+            this.handleRpcResponse(rpcResponse.context, rpcResponse === null || rpcResponse === void 0 ? void 0 : rpcResponse.value);
+        });
+    }
+    handleRpcResponse(context, accountInfo) {
+        const newSlot = context.slot;
+        let newBuffer = undefined;
+        if (accountInfo) {
+            newBuffer = accountInfo.data;
+        }
+        if (!this.bufferAndSlot) {
+            this.bufferAndSlot = {
+                buffer: newBuffer,
+                slot: newSlot,
+            };
+            if (newBuffer) {
+                const account = this.decodeBuffer(newBuffer);
+                this.dataAndSlot = {
+                    data: account,
+                    slot: newSlot,
+                };
+                this.onChange(account);
+            }
+            return;
+        }
+        if (newSlot <= this.bufferAndSlot.slot) {
+            return;
+        }
+        const oldBuffer = this.bufferAndSlot.buffer;
+        if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+            this.bufferAndSlot = {
+                buffer: newBuffer,
+                slot: newSlot,
+            };
+            const account = this.decodeBuffer(newBuffer);
+            this.dataAndSlot = {
+                data: account,
+                slot: newSlot,
+            };
+            this.onChange(account);
+        }
+    }
+    decodeBuffer(buffer) {
+        if (this.decodeBufferFn) {
+            return this.decodeBufferFn(buffer);
+        }
+        else {
+            return this.program.account[this.accountName].coder.accounts.decode(utils_1.capitalize(this.accountName), buffer);
+        }
+    }
+    unsubscribe() {
+        if (this.listenerId) {
+            const promise = this.program.provider.connection.removeAccountChangeListener(this.listenerId);
+            this.listenerId = undefined;
+            return promise;
+        }
+    }
+}
+exports.WebSocketAccountSubscriber = WebSocketAccountSubscriber;

package/src/accounts/webSocketClearingHouseAccountSubscriber.js

@@ -0,0 +1,233 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClearingHouseAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const pda_1 = require("../addresses/pda");
+const webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
+const web3_js_1 = require("@solana/web3.js");
+const oracleClientCache_1 = require("../oracles/oracleClientCache");
+const quoteAssetOracleClient_1 = require("../oracles/quoteAssetOracleClient");
+class WebSocketClearingHouseAccountSubscriber {
+    constructor(program, marketIndexes, bankIndexes, oracleInfos) {
+        this.oracleClientCache = new oracleClientCache_1.OracleClientCache();
+        this.marketAccountSubscribers = new Map();
+        this.bankAccountSubscribers = new Map();
+        this.oracleSubscribers = new Map();
+        this.isSubscribing = false;
+        this.isSubscribed = false;
+        this.program = program;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.marketIndexes = marketIndexes;
+        this.bankIndexes = bankIndexes;
+        this.oracleInfos = oracleInfos;
+    }
+    subscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSubscribed) {
+                return true;
+            }
+            if (this.isSubscribing) {
+                return yield this.subscriptionPromise;
+            }
+            this.isSubscribing = true;
+            this.subscriptionPromise = new Promise((res) => {
+                this.subscriptionPromiseResolver = res;
+            });
+            const statePublicKey = yield pda_1.getClearingHouseStateAccountPublicKey(this.program.programId);
+            // create and activate main state account subscription
+            this.stateAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('state', this.program, statePublicKey);
+            yield this.stateAccountSubscriber.subscribe((data) => {
+                this.eventEmitter.emit('stateAccountUpdate', data);
+                this.eventEmitter.emit('update');
+            });
+            // subscribe to market accounts
+            yield this.subscribeToMarketAccounts();
+            // subscribe to bank accounts
+            yield this.subscribeToBankAccounts();
+            // subscribe to oracles
+            yield this.subscribeToOracles();
+            this.eventEmitter.emit('update');
+            this.isSubscribing = false;
+            this.isSubscribed = true;
+            this.subscriptionPromiseResolver(true);
+            return true;
+        });
+    }
+    subscribeToMarketAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const marketIndex of this.marketIndexes) {
+                yield this.subscribeToMarketAccount(marketIndex);
+            }
+            return true;
+        });
+    }
+    subscribeToMarketAccount(marketIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPublicKey = yield pda_1.getMarketPublicKey(this.program.programId, marketIndex);
+            const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('market', this.program, marketPublicKey);
+            yield accountSubscriber.subscribe((data) => {
+                this.eventEmitter.emit('marketAccountUpdate', data);
+                this.eventEmitter.emit('update');
+            });
+            this.marketAccountSubscribers.set(marketIndex.toNumber(), accountSubscriber);
+            return true;
+        });
+    }
+    subscribeToBankAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const bankIndex of this.bankIndexes) {
+                yield this.subscribeToBankAccount(bankIndex);
+            }
+            return true;
+        });
+    }
+    subscribeToBankAccount(bankIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bankPublicKey = yield pda_1.getBankPublicKey(this.program.programId, bankIndex);
+            const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('bank', this.program, bankPublicKey);
+            yield accountSubscriber.subscribe((data) => {
+                this.eventEmitter.emit('bankAccountUpdate', data);
+                this.eventEmitter.emit('update');
+            });
+            this.bankAccountSubscribers.set(bankIndex.toNumber(), accountSubscriber);
+            return true;
+        });
+    }
+    subscribeToOracles() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const oracleInfo of this.oracleInfos) {
+                if (!oracleInfo.publicKey.equals(web3_js_1.PublicKey.default)) {
+                    yield this.subscribeToOracle(oracleInfo);
+                }
+            }
+            return true;
+        });
+    }
+    subscribeToOracle(oracleInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.oracleClientCache.get(oracleInfo.source, this.program.provider.connection);
+            const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('oracle', this.program, oracleInfo.publicKey, (buffer) => {
+                return client.getOraclePriceDataFromBuffer(buffer);
+            });
+            yield accountSubscriber.subscribe((data) => {
+                this.eventEmitter.emit('oraclePriceUpdate', oracleInfo.publicKey, data);
+                this.eventEmitter.emit('update');
+            });
+            this.oracleSubscribers.set(oracleInfo.publicKey.toString(), accountSubscriber);
+            return true;
+        });
+    }
+    unsubscribeFromMarketAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const accountSubscriber of this.marketAccountSubscribers.values()) {
+                yield accountSubscriber.unsubscribe();
+            }
+        });
+    }
+    unsubscribeFromBankAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const accountSubscriber of this.bankAccountSubscribers.values()) {
+                yield accountSubscriber.unsubscribe();
+            }
+        });
+    }
+    unsubscribeFromOracles() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const accountSubscriber of this.oracleSubscribers.values()) {
+                yield accountSubscriber.unsubscribe();
+            }
+        });
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isSubscribed) {
+                return;
+            }
+            const promises = [this.stateAccountSubscriber.fetch()]
+                .concat(Array.from(this.marketAccountSubscribers.values()).map((subscriber) => subscriber.fetch()))
+                .concat(Array.from(this.bankAccountSubscribers.values()).map((subscriber) => subscriber.fetch()));
+            yield Promise.all(promises);
+        });
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isSubscribed) {
+                return;
+            }
+            yield this.stateAccountSubscriber.unsubscribe();
+            yield this.unsubscribeFromMarketAccounts();
+            yield this.unsubscribeFromBankAccounts();
+            yield this.unsubscribeFromOracles();
+            this.isSubscribed = false;
+        });
+    }
+    addBank(bankIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.bankAccountSubscribers.has(bankIndex.toNumber())) {
+                return true;
+            }
+            return this.subscribeToBankAccount(bankIndex);
+        });
+    }
+    addMarket(marketIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.marketAccountSubscribers.has(marketIndex.toNumber())) {
+                return true;
+            }
+            return this.subscribeToMarketAccount(marketIndex);
+        });
+    }
+    addOracle(oracleInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.oracleSubscribers.has(oracleInfo.publicKey.toString())) {
+                return true;
+            }
+            if (oracleInfo.publicKey.equals(web3_js_1.PublicKey.default)) {
+                return true;
+            }
+            return this.subscribeToOracle(oracleInfo);
+        });
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getStateAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.stateAccountSubscriber.dataAndSlot;
+    }
+    getMarketAccountAndSlot(marketIndex) {
+        this.assertIsSubscribed();
+        return this.marketAccountSubscribers.get(marketIndex.toNumber())
+            .dataAndSlot;
+    }
+    getMarketAccountsAndSlots() {
+        return Array.from(this.marketAccountSubscribers.values()).map((subscriber) => subscriber.dataAndSlot);
+    }
+    getBankAccountAndSlot(bankIndex) {
+        this.assertIsSubscribed();
+        return this.bankAccountSubscribers.get(bankIndex.toNumber()).dataAndSlot;
+    }
+    getOraclePriceDataAndSlot(oraclePublicKey) {
+        this.assertIsSubscribed();
+        if (oraclePublicKey.equals(web3_js_1.PublicKey.default)) {
+            return {
+                data: quoteAssetOracleClient_1.QUOTE_ORACLE_PRICE_DATA,
+                slot: 0,
+            };
+        }
+        return this.oracleSubscribers.get(oraclePublicKey.toString()).dataAndSlot;
+    }
+}
+exports.WebSocketClearingHouseAccountSubscriber = WebSocketClearingHouseAccountSubscriber;

package/src/accounts/webSocketUserAccountSubscriber.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketUserAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
+class WebSocketUserAccountSubscriber {
+    constructor(program, userAccountPublicKey) {
+        this.isSubscribed = false;
+        this.program = program;
+        this.userAccountPublicKey = userAccountPublicKey;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    subscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSubscribed) {
+                return true;
+            }
+            this.userDataAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('user', this.program, this.userAccountPublicKey);
+            yield this.userDataAccountSubscriber.subscribe((data) => {
+                this.eventEmitter.emit('userAccountUpdate', data);
+                this.eventEmitter.emit('update');
+            });
+            this.eventEmitter.emit('update');
+            this.isSubscribed = true;
+            return true;
+        });
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all([this.userDataAccountSubscriber.fetch()]);
+        });
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isSubscribed) {
+                return;
+            }
+            yield Promise.all([this.userDataAccountSubscriber.unsubscribe()]);
+            this.isSubscribed = false;
+        });
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getUserAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.userDataAccountSubscriber.dataAndSlot;
+    }
+}
+exports.WebSocketUserAccountSubscriber = WebSocketUserAccountSubscriber;

package/src/addresses/marketAddresses.js

@@ -0,0 +1,26 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMarketAddress = void 0;
+const pda_1 = require("./pda");
+const CACHE = new Map();
+function getMarketAddress(programId, marketIndex) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cacheKey = `${programId.toString()}-${marketIndex.toString()}`;
+        if (CACHE.has(cacheKey)) {
+            return CACHE.get(cacheKey);
+        }
+        const publicKey = yield pda_1.getMarketPublicKey(programId, marketIndex);
+        CACHE.set(cacheKey, publicKey);
+        return publicKey;
+    });
+}
+exports.getMarketAddress = getMarketAddress;

package/src/addresses/pda.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBankVaultAuthorityPublicKey = exports.getBankVaultPublicKey = exports.getBankPublicKey = exports.getMarketPublicKey = exports.getUserAccountPublicKeySync = exports.getUserAccountPublicKey = exports.getUserAccountPublicKeyAndNonce = exports.getClearingHouseStateAccountPublicKey = exports.getClearingHouseStateAccountPublicKeyAndNonce = void 0;
+const anchor = __importStar(require("@project-serum/anchor"));
+function getClearingHouseStateAccountPublicKeyAndNonce(programId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return anchor.web3.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('clearing_house'))], programId);
+    });
+}
+exports.getClearingHouseStateAccountPublicKeyAndNonce = getClearingHouseStateAccountPublicKeyAndNonce;
+function getClearingHouseStateAccountPublicKey(programId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (yield getClearingHouseStateAccountPublicKeyAndNonce(programId))[0];
+    });
+}
+exports.getClearingHouseStateAccountPublicKey = getClearingHouseStateAccountPublicKey;
+function getUserAccountPublicKeyAndNonce(programId, authority, userId = 0) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return anchor.web3.PublicKey.findProgramAddress([
+            Buffer.from(anchor.utils.bytes.utf8.encode('user')),
+            authority.toBuffer(),
+            Uint8Array.from([userId]),
+        ], programId);
+    });
+}
+exports.getUserAccountPublicKeyAndNonce = getUserAccountPublicKeyAndNonce;
+function getUserAccountPublicKey(programId, authority, userId = 0) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (yield getUserAccountPublicKeyAndNonce(programId, authority, userId))[0];
+    });
+}
+exports.getUserAccountPublicKey = getUserAccountPublicKey;
+function getUserAccountPublicKeySync(programId, authority, userId = 0) {
+    return anchor.web3.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('user')),
+        authority.toBuffer(),
+        Uint8Array.from([userId]),
+    ], programId)[0];
+}
+exports.getUserAccountPublicKeySync = getUserAccountPublicKeySync;
+function getMarketPublicKey(programId, marketIndex) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (yield anchor.web3.PublicKey.findProgramAddress([
+            Buffer.from(anchor.utils.bytes.utf8.encode('market')),
+            marketIndex.toArrayLike(Buffer, 'le', 8),
+        ], programId))[0];
+    });
+}
+exports.getMarketPublicKey = getMarketPublicKey;
+function getBankPublicKey(programId, bankIndex) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (yield anchor.web3.PublicKey.findProgramAddress([
+            Buffer.from(anchor.utils.bytes.utf8.encode('bank')),
+            bankIndex.toArrayLike(Buffer, 'le', 8),
+        ], programId))[0];
+    });
+}
+exports.getBankPublicKey = getBankPublicKey;
+function getBankVaultPublicKey(programId, bankIndex) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (yield anchor.web3.PublicKey.findProgramAddress([
+            Buffer.from(anchor.utils.bytes.utf8.encode('bank_vault')),
+            bankIndex.toArrayLike(Buffer, 'le', 8),
+        ], programId))[0];
+    });
+}
+exports.getBankVaultPublicKey = getBankVaultPublicKey;
+function getBankVaultAuthorityPublicKey(programId, bankIndex) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (yield anchor.web3.PublicKey.findProgramAddress([
+            Buffer.from(anchor.utils.bytes.utf8.encode('bank_vault_authority')),
+            bankIndex.toArrayLike(Buffer, 'le', 8),
+        ], programId))[0];
+    });
+}
+exports.getBankVaultAuthorityPublicKey = getBankVaultAuthorityPublicKey;

package/src/admin.ts

@@ -85,7 +85,8 @@ export class Admin extends ClearingHouse {
 		initialAssetWeight: BN,
 		maintenanceAssetWeight: BN,
 		initialLiabilityWeight: BN,
-		maintenanceLiabilityWeight: BN
+		maintenanceLiabilityWeight: BN,
+		imfFactor = new BN(0)
 	): Promise<TransactionSignature> {
 		const bankIndex = this.getStateAccount().numberOfBanks;
 		const bank = await getBankPublicKey(this.program.programId, bankIndex);
@@ -109,6 +110,7 @@ export class Admin extends ClearingHouse {
 			maintenanceAssetWeight,
 			initialLiabilityWeight,
 			maintenanceLiabilityWeight,
+			imfFactor,
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
@@ -329,10 +331,12 @@ export class Admin extends ClearingHouse {
 		recipient: PublicKey
 	): Promise<TransactionSignature> {
 		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,
@@ -341,7 +345,7 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
-	public async withdrawFees(
+	public async withdrawFromMarketToInsuranceVault(
 		marketIndex: BN,
 		amount: BN,
 		recipient: PublicKey
@@ -351,7 +355,7 @@ export class Admin extends ClearingHouse {
 			marketIndex
 		);
 		const bank = this.getQuoteAssetBankAccount();
-		return await this.program.rpc.withdrawFees(amount, {
+		return await this.program.rpc.withdrawFromMarketToInsuranceVault(amount, {
 			accounts: {
 				admin: this.wallet.publicKey,
 				state: await this.getStatePublicKey(),
@@ -370,6 +374,8 @@ export class Admin extends ClearingHouse {
 		amount: BN
 	): Promise<TransactionSignature> {
 		const state = await this.getStateAccount();
+		const bank = this.getQuoteAssetBankAccount();
+
 		return await this.program.rpc.withdrawFromInsuranceVaultToMarket(amount, {
 			accounts: {
 				admin: this.wallet.publicKey,
@@ -377,7 +383,9 @@ export class Admin extends ClearingHouse {
 				market: await getMarketPublicKey(this.program.programId, marketIndex),
 				insuranceVault: state.insuranceVault,
 				insuranceVaultAuthority: state.insuranceVaultAuthority,
-				bankVault: this.getQuoteAssetBankAccount().vault,
+				bank: bank.pubkey,
+				bankVault: bank.vault,
+				bankVaultAuthority: bank.vaultAuthority,
 				tokenProgram: TOKEN_PROGRAM_ID,
 			},
 		});
@@ -444,6 +452,19 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
+	public async updateMarketMaxSpread(
+		marketIndex: BN,
+		maxSpread: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateMarketMaxSpread(maxSpread, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				market: await getMarketPublicKey(this.program.programId, marketIndex),
+			},
+		});
+	}
+
 	public async updatePartialLiquidationClosePercentage(
 		numerator: BN,
 		denominator: BN
@@ -662,11 +683,13 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
-	public async updateOrderAuctionTime(
-		time: BN | number
+	public async updateAuctionDuration(
+		minDuration: BN | number,
+		maxDuration: BN | number
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateOrderAuctionTime(
-			typeof time === 'number' ? time : time.toNumber,
+		return await this.program.rpc.updateAuctionDuration(
+			typeof minDuration === 'number' ? minDuration : minDuration.toNumber(),
+			typeof maxDuration === 'number' ? maxDuration : maxDuration.toNumber(),
 			{
 				accounts: {
 					admin: this.wallet.publicKey,
@@ -675,4 +698,33 @@ export class Admin extends ClearingHouse {
 			}
 		);
 	}
+
+	public async updateMaxBaseAssetAmountRatio(
+		marketIndex: BN,
+		maxBaseAssetAmountRatio: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateMaxBaseAssetAmountRatio(
+			maxBaseAssetAmountRatio,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					market: this.getMarketAccount(marketIndex).pubkey,
+				},
+			}
+		);
+	}
+
+	public async updateMaxSlippageRatio(
+		marketIndex: BN,
+		maxSlippageRatio: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateMaxSlippageRatio(maxSlippageRatio, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				market: this.getMarketAccount(marketIndex).pubkey,
+			},
+		});
+	}
 }

package/src/assert/assert.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+function assert(condition, error) {
+    if (!condition) {
+        throw new Error(error || 'Unspecified AssertionError');
+    }
+}
+exports.assert = assert;