@drift-labs/sdk 0.2.0-master.11 → 0.2.0-master.14

package/src/{accounts/fetch.js → util/computeUnits.js}

@@ -9,21 +9,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchUserAccounts = void 0;
-const pda_1 = require("../addresses/pda");
-function fetchUserAccounts(connection, program, authority, limit = 8) {
+exports.findComputeUnitConsumption = void 0;
+function findComputeUnitConsumption(programId, connection, txSignature, commitment = 'confirmed') {
     return __awaiter(this, void 0, void 0, function* () {
-        const userAccountPublicKeys = new Array();
-        for (let i = 0; i < limit; i++) {
-            userAccountPublicKeys.push(yield pda_1.getUserAccountPublicKey(program.programId, authority, i));
-        }
-        const accountInfos = yield connection.getMultipleAccountsInfo(userAccountPublicKeys, 'confirmed');
-        return accountInfos.map((accountInfo) => {
-            if (!accountInfo) {
-                return undefined;
+        const tx = yield connection.getTransaction(txSignature, { commitment });
+        const computeUnits = [];
+        const regex = new RegExp(`Program ${programId.toString()} consumed ([0-9]{0,6}) of ([0-9]{0,7}) compute units`);
+        tx.meta.logMessages.forEach((logMessage) => {
+            const match = logMessage.match(regex);
+            if (match && match[1]) {
+                computeUnits.push(match[1]);
             }
-            return program.account.user.coder.accounts.decode('User', accountInfo.data);
         });
+        return computeUnits;
     });
 }
-exports.fetchUserAccounts = fetchUserAccounts;
+exports.findComputeUnitConsumption = findComputeUnitConsumption;

package/src/util/getTokenAddress.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenAddress = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const getTokenAddress = (mintAddress, userPubKey) => {
+    return spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, new web3_js_1.PublicKey(mintAddress), new web3_js_1.PublicKey(userPubKey));
+};
+exports.getTokenAddress = getTokenAddress;

package/src/util/getTokenAddress.ts

@@ -0,0 +1,18 @@
+import {
+	Token,
+	ASSOCIATED_TOKEN_PROGRAM_ID,
+	TOKEN_PROGRAM_ID,
+} from '@solana/spl-token';
+import { PublicKey } from '@solana/web3.js';
+
+export const getTokenAddress = (
+	mintAddress: string,
+	userPubKey: string
+): Promise<PublicKey> => {
+	return Token.getAssociatedTokenAddress(
+		ASSOCIATED_TOKEN_PROGRAM_ID,
+		TOKEN_PROGRAM_ID,
+		new PublicKey(mintAddress),
+		new PublicKey(userPubKey)
+	);
+};

package/tests/bn/test.ts

@@ -125,6 +125,8 @@ describe('BigNum Tests', () => {
 		expect(BigNum.fromPrint('1234567').toMillified(5)).to.equal('1.2345M');
 		expect(BigNum.fromPrint('12345678').toMillified(5)).to.equal('12.345M');
 		expect(BigNum.fromPrint('123456789').toMillified(5)).to.equal('123.45M');
+
+		expect(BigNum.from(-95, 2).print()).to.equal('-0.95');
 	});
 
 	it('can initialise from string values correctly', () => {

package/src/accounts/bulkAccountLoader.js

@@ -1,197 +0,0 @@
-"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.BulkAccountLoader = void 0;
-const uuid_1 = require("uuid");
-const promiseTimeout_1 = require("../util/promiseTimeout");
-const GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE = 99;
-const oneMinute = 60 * 1000;
-class BulkAccountLoader {
-    constructor(connection, commitment, pollingFrequency) {
-        this.accountsToLoad = new Map();
-        this.bufferAndSlotMap = new Map();
-        this.errorCallbacks = new Map();
-        this.lastTimeLoadingPromiseCleared = Date.now();
-        this.mostRecentSlot = 0;
-        this.connection = connection;
-        this.commitment = commitment;
-        this.pollingFrequency = pollingFrequency;
-    }
-    addAccount(publicKey, callback) {
-        const existingSize = this.accountsToLoad.size;
-        const callbackId = uuid_1.v4();
-        const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
-        if (existingAccountToLoad) {
-            existingAccountToLoad.callbacks.set(callbackId, callback);
-        }
-        else {
-            const callbacks = new Map();
-            callbacks.set(callbackId, callback);
-            const newAccountToLoad = {
-                publicKey,
-                callbacks,
-            };
-            this.accountsToLoad.set(publicKey.toString(), newAccountToLoad);
-        }
-        if (existingSize === 0) {
-            this.startPolling();
-        }
-        // if a new account needs to be polled, remove the cached loadPromise in case client calls load immediately after
-        this.loadPromise = undefined;
-        return callbackId;
-    }
-    removeAccount(publicKey, callbackId) {
-        const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
-        if (existingAccountToLoad) {
-            existingAccountToLoad.callbacks.delete(callbackId);
-            if (existingAccountToLoad.callbacks.size === 0) {
-                this.accountsToLoad.delete(existingAccountToLoad.publicKey.toString());
-            }
-        }
-        if (this.accountsToLoad.size === 0) {
-            this.stopPolling();
-        }
-    }
-    addErrorCallbacks(callback) {
-        const callbackId = uuid_1.v4();
-        this.errorCallbacks.set(callbackId, callback);
-        return callbackId;
-    }
-    removeErrorCallbacks(callbackId) {
-        this.errorCallbacks.delete(callbackId);
-    }
-    chunks(array, size) {
-        return new Array(Math.ceil(array.length / size))
-            .fill(null)
-            .map((_, index) => index * size)
-            .map((begin) => array.slice(begin, begin + size));
-    }
-    load() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.loadPromise) {
-                const now = Date.now();
-                if (now - this.lastTimeLoadingPromiseCleared > oneMinute) {
-                    this.loadPromise = undefined;
-                }
-                else {
-                    return this.loadPromise;
-                }
-            }
-            this.loadPromise = new Promise((resolver) => {
-                this.loadPromiseResolver = resolver;
-            });
-            this.lastTimeLoadingPromiseCleared = Date.now();
-            try {
-                const chunks = this.chunks(Array.from(this.accountsToLoad.values()), GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE);
-                yield Promise.all(chunks.map((chunk) => {
-                    return this.loadChunk(chunk);
-                }));
-            }
-            catch (e) {
-                console.error(`Error in bulkAccountLoader.load()`);
-                console.error(e);
-                for (const [_, callback] of this.errorCallbacks) {
-                    callback(e);
-                }
-            }
-            finally {
-                this.loadPromiseResolver();
-                this.loadPromise = undefined;
-            }
-        });
-    }
-    loadChunk(accountsToLoad) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (accountsToLoad.length === 0) {
-                return;
-            }
-            const args = [
-                accountsToLoad.map((accountToLoad) => {
-                    return accountToLoad.publicKey.toBase58();
-                }),
-                { commitment: this.commitment },
-            ];
-            const rpcResponse = yield promiseTimeout_1.promiseTimeout(
-            // @ts-ignore
-            this.connection._rpcRequest('getMultipleAccounts', args), 10 * 1000 // 30 second timeout
-            );
-            if (rpcResponse === null) {
-                this.log('request to rpc timed out');
-                return;
-            }
-            const newSlot = rpcResponse.result.context.slot;
-            if (newSlot > this.mostRecentSlot) {
-                this.mostRecentSlot = newSlot;
-            }
-            for (const i in accountsToLoad) {
-                const accountToLoad = accountsToLoad[i];
-                const key = accountToLoad.publicKey.toString();
-                const oldRPCResponse = this.bufferAndSlotMap.get(key);
-                let newBuffer = undefined;
-                if (rpcResponse.result.value[i]) {
-                    const raw = rpcResponse.result.value[i].data[0];
-                    const dataType = rpcResponse.result.value[i].data[1];
-                    newBuffer = Buffer.from(raw, dataType);
-                }
-                if (!oldRPCResponse) {
-                    this.bufferAndSlotMap.set(key, {
-                        slot: newSlot,
-                        buffer: newBuffer,
-                    });
-                    this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
-                    continue;
-                }
-                if (newSlot <= oldRPCResponse.slot) {
-                    continue;
-                }
-                const oldBuffer = oldRPCResponse.buffer;
-                if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
-                    this.bufferAndSlotMap.set(key, {
-                        slot: newSlot,
-                        buffer: newBuffer,
-                    });
-                    this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
-                }
-            }
-        });
-    }
-    handleAccountCallbacks(accountToLoad, buffer, slot) {
-        for (const [_, callback] of accountToLoad.callbacks) {
-            callback(buffer, slot);
-        }
-    }
-    getBufferAndSlot(publicKey) {
-        return this.bufferAndSlotMap.get(publicKey.toString());
-    }
-    startPolling() {
-        if (this.intervalId) {
-            return;
-        }
-        this.intervalId = setInterval(this.load.bind(this), this.pollingFrequency);
-    }
-    stopPolling() {
-        if (this.intervalId) {
-            clearInterval(this.intervalId);
-            this.intervalId = undefined;
-        }
-    }
-    log(msg) {
-        console.log(msg);
-    }
-    updatePollingFrequency(pollingFrequency) {
-        this.stopPolling();
-        this.pollingFrequency = pollingFrequency;
-        if (this.accountsToLoad.size > 0) {
-            this.startPolling();
-        }
-    }
-}
-exports.BulkAccountLoader = BulkAccountLoader;

package/src/accounts/bulkUserSubscription.js

@@ -1,33 +0,0 @@
-"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.bulkPollingUserSubscribe = void 0;
-/**
- * @param users
- * @param accountLoader
- */
-function bulkPollingUserSubscribe(users, accountLoader) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (users.length === 0) {
-            yield accountLoader.load();
-            return;
-        }
-        yield Promise.all(users.map((user) => {
-            // Pull the keys from the authority map so we can skip fetching them in addToAccountLoader
-            return user.accountSubscriber.addToAccountLoader();
-        }));
-        yield accountLoader.load();
-        yield Promise.all(users.map((user) => __awaiter(this, void 0, void 0, function* () {
-            return user.subscribe();
-        })));
-    });
-}
-exports.bulkPollingUserSubscribe = bulkPollingUserSubscribe;

package/src/accounts/pollingClearingHouseAccountSubscriber.js

@@ -1,311 +0,0 @@
-"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.PollingClearingHouseAccountSubscriber = void 0;
-const types_1 = require("./types");
-const events_1 = require("events");
-const pda_1 = require("../addresses/pda");
-const utils_1 = require("./utils");
-const web3_js_1 = require("@solana/web3.js");
-const oracleClientCache_1 = require("../oracles/oracleClientCache");
-const quoteAssetOracleClient_1 = require("../oracles/quoteAssetOracleClient");
-class PollingClearingHouseAccountSubscriber {
-    constructor(program, accountLoader, marketIndexes, bankIndexes, oracleInfos) {
-        this.oracleClientCache = new oracleClientCache_1.OracleClientCache();
-        this.accountsToPoll = new Map();
-        this.oraclesToPoll = new Map();
-        this.market = new Map();
-        this.bank = new Map();
-        this.oracles = new Map();
-        this.isSubscribing = false;
-        this.isSubscribed = false;
-        this.program = program;
-        this.eventEmitter = new events_1.EventEmitter();
-        this.accountLoader = accountLoader;
-        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;
-            });
-            yield this.updateAccountsToPoll();
-            yield this.updateOraclesToPoll();
-            yield this.addToAccountLoader();
-            let subscriptionSucceeded = false;
-            let retries = 0;
-            while (!subscriptionSucceeded && retries < 5) {
-                yield this.fetch();
-                subscriptionSucceeded = this.didSubscriptionSucceed();
-                retries++;
-            }
-            if (subscriptionSucceeded) {
-                this.eventEmitter.emit('update');
-            }
-            this.isSubscribing = false;
-            this.isSubscribed = subscriptionSucceeded;
-            this.subscriptionPromiseResolver(subscriptionSucceeded);
-            return subscriptionSucceeded;
-        });
-    }
-    updateAccountsToPoll() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.accountsToPoll.size > 0) {
-                return;
-            }
-            const accounts = yield this.getClearingHouseAccounts();
-            this.accountsToPoll.set(accounts.state.toString(), {
-                key: 'state',
-                publicKey: accounts.state,
-                eventType: 'stateAccountUpdate',
-            });
-            yield this.updateMarketAccountsToPoll();
-            yield this.updateBankAccountsToPoll();
-        });
-    }
-    updateMarketAccountsToPoll() {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const marketIndex of this.marketIndexes) {
-                yield this.addMarketAccountToPoll(marketIndex);
-            }
-            return true;
-        });
-    }
-    addMarketAccountToPoll(marketIndex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const marketPublicKey = yield pda_1.getMarketPublicKey(this.program.programId, marketIndex);
-            this.accountsToPoll.set(marketPublicKey.toString(), {
-                key: 'market',
-                publicKey: marketPublicKey,
-                eventType: 'marketAccountUpdate',
-                mapKey: marketIndex.toNumber(),
-            });
-            return true;
-        });
-    }
-    updateBankAccountsToPoll() {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const bankIndex of this.bankIndexes) {
-                yield this.addBankAccountToPoll(bankIndex);
-            }
-            return true;
-        });
-    }
-    addBankAccountToPoll(bankIndex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const bankPublicKey = yield pda_1.getBankPublicKey(this.program.programId, bankIndex);
-            this.accountsToPoll.set(bankPublicKey.toString(), {
-                key: 'bank',
-                publicKey: bankPublicKey,
-                eventType: 'bankAccountUpdate',
-                mapKey: bankIndex.toNumber(),
-            });
-            return true;
-        });
-    }
-    updateOraclesToPoll() {
-        for (const oracleInfo of this.oracleInfos) {
-            if (!oracleInfo.publicKey.equals(web3_js_1.PublicKey.default)) {
-                this.addOracleToPoll(oracleInfo);
-            }
-        }
-        return true;
-    }
-    addOracleToPoll(oracleInfo) {
-        this.oraclesToPoll.set(oracleInfo.publicKey.toString(), {
-            publicKey: oracleInfo.publicKey,
-            source: oracleInfo.source,
-        });
-        return true;
-    }
-    getClearingHouseAccounts() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statePublicKey = yield pda_1.getClearingHouseStateAccountPublicKey(this.program.programId);
-            const accounts = {
-                state: statePublicKey,
-            };
-            return accounts;
-        });
-    }
-    addToAccountLoader() {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const [_, accountToPoll] of this.accountsToPoll) {
-                this.addAccountToAccountLoader(accountToPoll);
-            }
-            for (const [_, oracleToPoll] of this.oraclesToPoll) {
-                this.addOracleToAccountLoader(oracleToPoll);
-            }
-            this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
-                this.eventEmitter.emit('error', error);
-            });
-        });
-    }
-    addAccountToAccountLoader(accountToPoll) {
-        accountToPoll.callbackId = this.accountLoader.addAccount(accountToPoll.publicKey, (buffer, slot) => {
-            if (!buffer)
-                return;
-            const account = this.program.account[accountToPoll.key].coder.accounts.decode(utils_1.capitalize(accountToPoll.key), buffer);
-            const dataAndSlot = {
-                data: account,
-                slot,
-            };
-            if (accountToPoll.mapKey != undefined) {
-                this[accountToPoll.key].set(accountToPoll.mapKey, dataAndSlot);
-            }
-            else {
-                this[accountToPoll.key] = dataAndSlot;
-            }
-            // @ts-ignore
-            this.eventEmitter.emit(accountToPoll.eventType, account);
-            this.eventEmitter.emit('update');
-            if (!this.isSubscribed) {
-                this.isSubscribed = this.didSubscriptionSucceed();
-            }
-        });
-    }
-    addOracleToAccountLoader(oracleToPoll) {
-        const oracleClient = this.oracleClientCache.get(oracleToPoll.source, this.program.provider.connection);
-        oracleToPoll.callbackId = this.accountLoader.addAccount(oracleToPoll.publicKey, (buffer, slot) => {
-            if (!buffer)
-                return;
-            const oraclePriceData = oracleClient.getOraclePriceDataFromBuffer(buffer);
-            const dataAndSlot = {
-                data: oraclePriceData,
-                slot,
-            };
-            this.oracles.set(oracleToPoll.publicKey.toString(), dataAndSlot);
-            this.eventEmitter.emit('oraclePriceUpdate', oracleToPoll.publicKey, oraclePriceData);
-            this.eventEmitter.emit('update');
-        });
-    }
-    fetch() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.accountLoader.load();
-            for (const [_, accountToPoll] of this.accountsToPoll) {
-                const { buffer, slot } = this.accountLoader.getBufferAndSlot(accountToPoll.publicKey);
-                if (buffer) {
-                    const account = this.program.account[accountToPoll.key].coder.accounts.decode(utils_1.capitalize(accountToPoll.key), buffer);
-                    if (accountToPoll.mapKey != undefined) {
-                        this[accountToPoll.key].set(accountToPoll.mapKey, {
-                            data: account,
-                            slot,
-                        });
-                    }
-                    else {
-                        this[accountToPoll.key] = {
-                            data: account,
-                            slot,
-                        };
-                    }
-                }
-            }
-            for (const [_, oracleToPoll] of this.oraclesToPoll) {
-                const { buffer, slot } = this.accountLoader.getBufferAndSlot(oracleToPoll.publicKey);
-                if (buffer) {
-                    const oracleClient = this.oracleClientCache.get(oracleToPoll.source, this.program.provider.connection);
-                    const oraclePriceData = oracleClient.getOraclePriceDataFromBuffer(buffer);
-                    this.oracles.set(oracleToPoll.publicKey.toString(), {
-                        data: oraclePriceData,
-                        slot,
-                    });
-                }
-            }
-        });
-    }
-    didSubscriptionSucceed() {
-        if (this.state)
-            return true;
-        return false;
-    }
-    unsubscribe() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isSubscribed) {
-                return;
-            }
-            for (const [_, accountToPoll] of this.accountsToPoll) {
-                this.accountLoader.removeAccount(accountToPoll.publicKey, accountToPoll.callbackId);
-            }
-            for (const [_, oracleToPoll] of this.oraclesToPoll) {
-                this.accountLoader.removeAccount(oracleToPoll.publicKey, oracleToPoll.callbackId);
-            }
-            this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
-            this.errorCallbackId = undefined;
-            this.accountsToPoll.clear();
-            this.oraclesToPoll.clear();
-            this.isSubscribed = false;
-        });
-    }
-    addBank(bankIndex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.addBankAccountToPoll(bankIndex);
-            const accountToPoll = this.accountsToPoll.get(bankIndex.toString());
-            this.addAccountToAccountLoader(accountToPoll);
-            return true;
-        });
-    }
-    addMarket(marketIndex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.addMarketAccountToPoll(marketIndex);
-            const accountToPoll = this.accountsToPoll.get(marketIndex.toString());
-            this.addAccountToAccountLoader(accountToPoll);
-            return true;
-        });
-    }
-    addOracle(oracleInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (oracleInfo.publicKey.equals(web3_js_1.PublicKey.default)) {
-                return true;
-            }
-            this.addOracleToPoll(oracleInfo);
-            const oracleToPoll = this.oraclesToPoll.get(oracleInfo.publicKey.toString());
-            this.addOracleToAccountLoader(oracleToPoll);
-            return true;
-        });
-    }
-    assertIsSubscribed() {
-        if (!this.isSubscribed) {
-            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
-        }
-    }
-    getStateAccountAndSlot() {
-        this.assertIsSubscribed();
-        return this.state;
-    }
-    getMarketAccountAndSlot(marketIndex) {
-        return this.market.get(marketIndex.toNumber());
-    }
-    getMarketAccountsAndSlots() {
-        return Array.from(this.market.values());
-    }
-    getBankAccountAndSlot(bankIndex) {
-        return this.bank.get(bankIndex.toNumber());
-    }
-    getOraclePriceDataAndSlot(oraclePublicKey) {
-        this.assertIsSubscribed();
-        if (oraclePublicKey.equals(web3_js_1.PublicKey.default)) {
-            return {
-                data: quoteAssetOracleClient_1.QUOTE_ORACLE_PRICE_DATA,
-                slot: 0,
-            };
-        }
-        return this.oracles.get(oraclePublicKey.toString());
-    }
-}
-exports.PollingClearingHouseAccountSubscriber = PollingClearingHouseAccountSubscriber;