@drift-labs/sdk 2.142.0-beta.1 → 2.142.0-beta.11

package/lib/node/accounts/grpcDriftClientAccountSubscriberV2.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcDriftClientAccountSubscriberV2 = void 0;
+const webSocketDriftClientAccountSubscriber_1 = require("./webSocketDriftClientAccountSubscriber");
+const web3_js_1 = require("@solana/web3.js");
+const config_1 = require("../config");
+const pda_1 = require("../addresses/pda");
+const grpcAccountSubscriber_1 = require("./grpcAccountSubscriber");
+const grpcMultiAccountSubscriber_1 = require("./grpcMultiAccountSubscriber");
+const oracleId_1 = require("../oracles/oracleId");
+class grpcDriftClientAccountSubscriberV2 extends webSocketDriftClientAccountSubscriber_1.WebSocketDriftClientAccountSubscriber {
+    constructor(grpcConfigs, program, perpMarketIndexes, spotMarketIndexes, oracleInfos, shouldFindAllMarketsAndOracles, delistedMarketSetting, resubOpts) {
+        super(program, perpMarketIndexes, spotMarketIndexes, oracleInfos, shouldFindAllMarketsAndOracles, delistedMarketSetting, resubOpts);
+        this.perpMarketIndexToAccountPubkeyMap = new Map();
+        this.spotMarketIndexToAccountPubkeyMap = new Map();
+        this.grpcConfigs = grpcConfigs;
+    }
+    async subscribe() {
+        if (this.isSubscribed) {
+            return true;
+        }
+        if (this.isSubscribing) {
+            return await this.subscriptionPromise;
+        }
+        this.isSubscribing = true;
+        this.subscriptionPromise = new Promise((res) => {
+            this.subscriptionPromiseResolver = res;
+        });
+        if (this.shouldFindAllMarketsAndOracles) {
+            const { perpMarketIndexes, perpMarketAccounts, spotMarketIndexes, spotMarketAccounts, oracleInfos, } = await (0, config_1.findAllMarketAndOracles)(this.program);
+            this.perpMarketIndexes = perpMarketIndexes;
+            this.spotMarketIndexes = spotMarketIndexes;
+            this.oracleInfos = oracleInfos;
+            // front run and set the initial data here to save extra gma call in set initial data
+            this.initialPerpMarketAccountData = new Map(perpMarketAccounts.map((market) => [market.marketIndex, market]));
+            this.initialSpotMarketAccountData = new Map(spotMarketAccounts.map((market) => [market.marketIndex, market]));
+        }
+        const statePublicKey = await (0, pda_1.getDriftStateAccountPublicKey)(this.program.programId);
+        // create and activate main state account subscription
+        this.stateAccountSubscriber =
+            await grpcAccountSubscriber_1.grpcAccountSubscriber.create(this.grpcConfigs, 'state', this.program, statePublicKey, undefined, undefined);
+        await this.stateAccountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('stateAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        // set initial data to avoid spamming getAccountInfo calls in webSocketAccountSubscriber
+        await this.setInitialData();
+        // subscribe to perp + spot markets (separate) and oracles
+        await Promise.all([
+            this.subscribeToPerpMarketAccounts(),
+            this.subscribeToSpotMarketAccounts(),
+            this.subscribeToOracles(),
+        ]);
+        this.eventEmitter.emit('update');
+        await this.handleDelistedMarkets();
+        await Promise.all([this.setPerpOracleMap(), this.setSpotOracleMap()]);
+        this.subscriptionPromiseResolver(true);
+        this.isSubscribing = false;
+        this.isSubscribed = true;
+        // delete initial data
+        this.removeInitialData();
+        return true;
+    }
+    getMarketAccountAndSlot(marketIndex) {
+        var _a;
+        return (_a = this.perpMarketsSubscriber) === null || _a === void 0 ? void 0 : _a.getAccountData(this.perpMarketIndexToAccountPubkeyMap.get(marketIndex));
+    }
+    getSpotMarketAccountAndSlot(marketIndex) {
+        var _a;
+        return (_a = this.spotMarketsSubscriber) === null || _a === void 0 ? void 0 : _a.getAccountData(this.spotMarketIndexToAccountPubkeyMap.get(marketIndex));
+    }
+    async setPerpOracleMap() {
+        var _a;
+        const perpMarketsMap = (_a = this.perpMarketsSubscriber) === null || _a === void 0 ? void 0 : _a.getAccountDataMap();
+        const perpMarkets = Array.from(perpMarketsMap.values());
+        const addOraclePromises = [];
+        for (const perpMarket of perpMarkets) {
+            if (!perpMarket || !perpMarket.data) {
+                continue;
+            }
+            const perpMarketAccount = perpMarket.data;
+            const perpMarketIndex = perpMarketAccount.marketIndex;
+            const oracle = perpMarketAccount.amm.oracle;
+            const oracleId = (0, oracleId_1.getOracleId)(oracle, perpMarket.data.amm.oracleSource);
+            if (!this.oracleSubscribers.has(oracleId)) {
+                addOraclePromises.push(this.addOracle({
+                    publicKey: oracle,
+                    source: perpMarket.data.amm.oracleSource,
+                }));
+            }
+            this.perpOracleMap.set(perpMarketIndex, oracle);
+            this.perpOracleStringMap.set(perpMarketIndex, oracleId);
+        }
+        await Promise.all(addOraclePromises);
+    }
+    async setSpotOracleMap() {
+        var _a;
+        const spotMarketsMap = (_a = this.spotMarketsSubscriber) === null || _a === void 0 ? void 0 : _a.getAccountDataMap();
+        const spotMarkets = Array.from(spotMarketsMap.values());
+        const addOraclePromises = [];
+        for (const spotMarket of spotMarkets) {
+            if (!spotMarket || !spotMarket.data) {
+                continue;
+            }
+            const spotMarketAccount = spotMarket.data;
+            const spotMarketIndex = spotMarketAccount.marketIndex;
+            const oracle = spotMarketAccount.oracle;
+            const oracleId = (0, oracleId_1.getOracleId)(oracle, spotMarketAccount.oracleSource);
+            if (!this.oracleSubscribers.has(oracleId)) {
+                addOraclePromises.push(this.addOracle({
+                    publicKey: oracle,
+                    source: spotMarketAccount.oracleSource,
+                }));
+            }
+            this.spotOracleMap.set(spotMarketIndex, oracle);
+            this.spotOracleStringMap.set(spotMarketIndex, oracleId);
+        }
+        await Promise.all(addOraclePromises);
+    }
+    async subscribeToPerpMarketAccounts() {
+        const perpMarketIndexToAccountPubkeys = await Promise.all(this.perpMarketIndexes.map(async (marketIndex) => [
+            marketIndex,
+            await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, marketIndex),
+        ]));
+        for (const [marketIndex, accountPubkey,] of perpMarketIndexToAccountPubkeys) {
+            this.perpMarketIndexToAccountPubkeyMap.set(marketIndex, accountPubkey.toBase58());
+        }
+        const perpMarketPubkeys = perpMarketIndexToAccountPubkeys.map(([_, accountPubkey]) => accountPubkey);
+        this.perpMarketsSubscriber =
+            await grpcMultiAccountSubscriber_1.grpcMultiAccountSubscriber.create(this.grpcConfigs, 'perpMarket', this.program, undefined, this.resubOpts, undefined, async () => {
+                var _a;
+                try {
+                    if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.logResubMessages) {
+                        console.log('[grpcDriftClientAccountSubscriberV2] perp markets subscriber unsubscribed; resubscribing');
+                    }
+                    await this.subscribeToPerpMarketAccounts();
+                }
+                catch (e) {
+                    console.error('Perp markets resubscribe failed:', e);
+                }
+            });
+        for (const data of this.initialPerpMarketAccountData.values()) {
+            this.perpMarketsSubscriber.setAccountData(data.pubkey.toBase58(), data);
+        }
+        await this.perpMarketsSubscriber.subscribe(perpMarketPubkeys, (_accountId, data) => {
+            this.eventEmitter.emit('perpMarketAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        return true;
+    }
+    async subscribeToSpotMarketAccounts() {
+        const spotMarketIndexToAccountPubkeys = await Promise.all(this.spotMarketIndexes.map(async (marketIndex) => [
+            marketIndex,
+            await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex),
+        ]));
+        for (const [marketIndex, accountPubkey,] of spotMarketIndexToAccountPubkeys) {
+            this.spotMarketIndexToAccountPubkeyMap.set(marketIndex, accountPubkey.toBase58());
+        }
+        const spotMarketPubkeys = spotMarketIndexToAccountPubkeys.map(([_, accountPubkey]) => accountPubkey);
+        this.spotMarketsSubscriber =
+            await grpcMultiAccountSubscriber_1.grpcMultiAccountSubscriber.create(this.grpcConfigs, 'spotMarket', this.program, undefined, this.resubOpts, undefined, async () => {
+                var _a;
+                try {
+                    if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.logResubMessages) {
+                        console.log('[grpcDriftClientAccountSubscriberV2] spot markets subscriber unsubscribed; resubscribing');
+                    }
+                    await this.subscribeToSpotMarketAccounts();
+                }
+                catch (e) {
+                    console.error('Spot markets resubscribe failed:', e);
+                }
+            });
+        for (const data of this.initialSpotMarketAccountData.values()) {
+            this.spotMarketsSubscriber.setAccountData(data.pubkey.toBase58(), data);
+        }
+        await this.spotMarketsSubscriber.subscribe(spotMarketPubkeys, (_accountId, data) => {
+            this.eventEmitter.emit('spotMarketAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        return true;
+    }
+    async subscribeToOracles() {
+        const pubkeyToSources = new Map();
+        for (const info of this.oracleInfos) {
+            if (info.publicKey.equals(web3_js_1.PublicKey.default)) {
+                continue;
+            }
+            const key = info.publicKey.toBase58();
+            let sources = pubkeyToSources.get(key);
+            if (!sources) {
+                sources = new Set();
+                pubkeyToSources.set(key, sources);
+            }
+            sources.add(info.source);
+        }
+        const oraclePubkeys = Array.from(pubkeyToSources.keys()).map((k) => new web3_js_1.PublicKey(k));
+        this.oracleMultiSubscriber =
+            await grpcMultiAccountSubscriber_1.grpcMultiAccountSubscriber.create(this.grpcConfigs, 'oracle', this.program, (buffer, pubkey) => {
+                if (!pubkey) {
+                    throw new Error('Oracle pubkey missing in decode');
+                }
+                const sources = pubkeyToSources.get(pubkey);
+                if (!sources || sources.size === 0) {
+                    throw new Error('Oracle sources missing for pubkey in decode');
+                }
+                const primarySource = sources.values().next().value;
+                const client = this.oracleClientCache.get(primarySource, this.program.provider.connection, this.program);
+                return client.getOraclePriceDataFromBuffer(buffer);
+            }, this.resubOpts, undefined, async () => {
+                var _a;
+                try {
+                    if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.logResubMessages) {
+                        console.log('[grpcDriftClientAccountSubscriberV2] oracle subscriber unsubscribed; resubscribing');
+                    }
+                    await this.subscribeToOracles();
+                }
+                catch (e) {
+                    console.error('Oracle resubscribe failed:', e);
+                }
+            });
+        for (const data of this.initialOraclePriceData.entries()) {
+            const { publicKey } = (0, oracleId_1.getPublicKeyAndSourceFromOracleId)(data[0]);
+            this.oracleMultiSubscriber.setAccountData(publicKey.toBase58(), data[1]);
+        }
+        await this.oracleMultiSubscriber.subscribe(oraclePubkeys, (accountId, data) => {
+            const sources = pubkeyToSources.get(accountId.toBase58());
+            if (sources) {
+                for (const source of sources.values()) {
+                    this.eventEmitter.emit('oraclePriceUpdate', accountId, source, data);
+                }
+            }
+            this.eventEmitter.emit('update');
+        });
+        return true;
+    }
+    async unsubscribeFromOracles() {
+        if (this.oracleMultiSubscriber) {
+            await this.oracleMultiSubscriber.unsubscribe();
+            this.oracleMultiSubscriber = undefined;
+            return;
+        }
+        await super.unsubscribeFromOracles();
+    }
+    async unsubscribe() {
+        if (this.isSubscribed) {
+            return;
+        }
+        await this.stateAccountSubscriber.unsubscribe();
+    }
+}
+exports.grpcDriftClientAccountSubscriberV2 = grpcDriftClientAccountSubscriberV2;

package/lib/node/accounts/grpcMultiAccountSubscriber.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Program } from '@coral-xyz/anchor';
+import { Context, PublicKey } from '@solana/web3.js';
+import { Client } from '../isomorphic/grpc';
+import { DataAndSlot, GrpcConfigs, ResubOpts } from './types';
+export declare class grpcMultiAccountSubscriber<T> {
+    private client;
+    private stream;
+    private commitmentLevel;
+    private program;
+    private accountName;
+    private decodeBufferFn?;
+    private resubOpts?;
+    private onUnsubscribe?;
+    listenerId?: number;
+    isUnsubscribing: boolean;
+    private timeoutId?;
+    private receivingData;
+    private subscribedAccounts;
+    private onChangeMap;
+    private dataMap;
+    private constructor();
+    static create<U>(grpcConfigs: GrpcConfigs, accountName: string, program: Program, decodeBuffer?: (buffer: Buffer, pubkey?: string) => U, resubOpts?: ResubOpts, clientProp?: Client, onUnsubscribe?: () => Promise<void>): Promise<grpcMultiAccountSubscriber<U>>;
+    setAccountData(accountPubkey: string, data: T, slot?: number): void;
+    getAccountData(accountPubkey: string): DataAndSlot<T> | undefined;
+    getAccountDataMap(): Map<string, DataAndSlot<T>>;
+    subscribe(accounts: PublicKey[], onChange: (accountId: PublicKey, data: T, context: Context, buffer: Buffer) => void): Promise<void>;
+    addAccounts(accounts: PublicKey[]): Promise<void>;
+    removeAccounts(accounts: PublicKey[]): Promise<void>;
+    unsubscribe(): Promise<void>;
+    private setTimeout;
+    private capitalize;
+}
+//# sourceMappingURL=grpcMultiAccountSubscriber.d.ts.map

package/lib/node/accounts/grpcMultiAccountSubscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grpcMultiAccountSubscriber.d.ts","sourceRoot":"","sources":["../../../src/accounts/grpcMultiAccountSubscriber.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAIrD,OAAO,EACN,MAAM,EAMN,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAU9D,qBAAa,0BAA0B,CAAC,CAAC;IACxC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAwD;IACtE,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,cAAc,CAAC,CAAyC;IAChE,OAAO,CAAC,SAAS,CAAC,CAAY;IAC9B,OAAO,CAAC,aAAa,CAAC,CAAsB;IAErC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,UAAS;IAC/B,OAAO,CAAC,SAAS,CAAC,CAAgC;IAClD,OAAO,CAAC,aAAa,CAAS;IAE9B,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,WAAW,CAGf;IAEJ,OAAO,CAAC,OAAO,CAAqC;IAEpD,OAAO;WAkBa,MAAM,CAAC,CAAC,EAC3B,WAAW,EAAE,WAAW,EACxB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,OAAO,EAChB,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,EACrD,SAAS,CAAC,EAAE,SAAS,EACrB,UAAU,CAAC,EAAE,MAAM,EACnB,aAAa,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GACjC,OAAO,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC;IAuBzC,cAAc,CAAC,aAAa,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI;IAInE,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS;IAIjE,iBAAiB,IAAI,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IAI1C,SAAS,CACd,QAAQ,EAAE,SAAS,EAAE,EACrB,QAAQ,EAAE,CACT,SAAS,EAAE,SAAS,EACpB,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,KACV,IAAI,GACP,OAAO,CAAC,IAAI,CAAC;IAgGV,WAAW,CAAC,QAAQ,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAiCjD,cAAc,CAAC,QAAQ,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAmCpD,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IA4ClC,OAAO,CAAC,UAAU;IAelB,OAAO,CAAC,UAAU;CAIlB"}

package/lib/node/accounts/grpcMultiAccountSubscriber.js

@@ -0,0 +1,284 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcMultiAccountSubscriber = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const Buffer = __importStar(require("buffer"));
+const bs58_1 = __importDefault(require("bs58"));
+const grpc_1 = require("../isomorphic/grpc");
+class grpcMultiAccountSubscriber {
+    constructor(client, commitmentLevel, accountName, program, decodeBuffer, resubOpts, onUnsubscribe) {
+        this.isUnsubscribing = false;
+        this.receivingData = false;
+        this.subscribedAccounts = new Set();
+        this.onChangeMap = new Map();
+        this.dataMap = new Map();
+        this.client = client;
+        this.commitmentLevel = commitmentLevel;
+        this.accountName = accountName;
+        this.program = program;
+        this.decodeBufferFn = decodeBuffer;
+        this.resubOpts = resubOpts;
+        this.onUnsubscribe = onUnsubscribe;
+    }
+    static async create(grpcConfigs, accountName, program, decodeBuffer, resubOpts, clientProp, onUnsubscribe) {
+        var _a, _b;
+        const client = clientProp
+            ? clientProp
+            : await (0, grpc_1.createClient)(grpcConfigs.endpoint, grpcConfigs.token, (_a = grpcConfigs.channelOptions) !== null && _a !== void 0 ? _a : {});
+        const commitmentLevel = 
+        // @ts-ignore :: isomorphic exported enum fails typescript but will work at runtime
+        (_b = grpcConfigs.commitmentLevel) !== null && _b !== void 0 ? _b : grpc_1.CommitmentLevel.CONFIRMED;
+        return new grpcMultiAccountSubscriber(client, commitmentLevel, accountName, program, decodeBuffer, resubOpts, onUnsubscribe);
+    }
+    setAccountData(accountPubkey, data, slot) {
+        this.dataMap.set(accountPubkey, { data, slot });
+    }
+    getAccountData(accountPubkey) {
+        return this.dataMap.get(accountPubkey);
+    }
+    getAccountDataMap() {
+        return this.dataMap;
+    }
+    async subscribe(accounts, onChange) {
+        if (this.listenerId != null || this.isUnsubscribing) {
+            return;
+        }
+        // Track accounts and single onChange for all
+        for (const pk of accounts) {
+            const key = pk.toBase58();
+            this.subscribedAccounts.add(key);
+            this.onChangeMap.set(key, (data, ctx, buffer) => {
+                this.setAccountData(key, data, ctx.slot);
+                onChange(new web3_js_1.PublicKey(key), data, ctx, buffer);
+            });
+        }
+        this.stream =
+            (await this.client.subscribe());
+        const request = {
+            slots: {},
+            accounts: {
+                account: {
+                    account: accounts.map((a) => a.toBase58()),
+                    owner: [],
+                    filters: [],
+                },
+            },
+            transactions: {},
+            blocks: {},
+            blocksMeta: {},
+            accountsDataSlice: [],
+            commitment: this.commitmentLevel,
+            entry: {},
+            transactionsStatus: {},
+        };
+        this.stream.on('data', (chunk) => {
+            var _a;
+            if (!chunk.account) {
+                return;
+            }
+            const slot = Number(chunk.account.slot);
+            const accountPubkeyBytes = chunk.account.account.pubkey;
+            const accountPubkey = bs58_1.default.encode(accountPubkeyBytes);
+            if (!accountPubkey || !this.subscribedAccounts.has(accountPubkey)) {
+                return;
+            }
+            const accountInfo = {
+                owner: new web3_js_1.PublicKey(chunk.account.account.owner),
+                lamports: Number(chunk.account.account.lamports),
+                data: Buffer.Buffer.from(chunk.account.account.data),
+                executable: chunk.account.account.executable,
+                rentEpoch: Number(chunk.account.account.rentEpoch),
+            };
+            const context = { slot };
+            const buffer = accountInfo.data;
+            const data = this.decodeBufferFn
+                ? this.decodeBufferFn(buffer, accountPubkey)
+                : this.program.account[this.accountName].coder.accounts.decode(this.capitalize(this.accountName), buffer);
+            const handler = this.onChangeMap.get(accountPubkey);
+            if (handler) {
+                if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs) {
+                    this.receivingData = true;
+                    clearTimeout(this.timeoutId);
+                    handler(data, context, buffer);
+                    this.setTimeout();
+                }
+                else {
+                    handler(data, context, buffer);
+                }
+            }
+        });
+        return new Promise((resolve, reject) => {
+            this.stream.write(request, (err) => {
+                var _a;
+                if (err === null || err === undefined) {
+                    this.listenerId = 1;
+                    if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs) {
+                        this.receivingData = true;
+                        this.setTimeout();
+                    }
+                    resolve();
+                }
+                else {
+                    reject(err);
+                }
+            });
+        }).catch((reason) => {
+            console.error(reason);
+            throw reason;
+        });
+    }
+    async addAccounts(accounts) {
+        for (const pk of accounts) {
+            this.subscribedAccounts.add(pk.toBase58());
+        }
+        const request = {
+            slots: {},
+            accounts: {
+                account: {
+                    account: Array.from(this.subscribedAccounts.values()),
+                    owner: [],
+                    filters: [],
+                },
+            },
+            transactions: {},
+            blocks: {},
+            blocksMeta: {},
+            accountsDataSlice: [],
+            commitment: this.commitmentLevel,
+            entry: {},
+            transactionsStatus: {},
+        };
+        await new Promise((resolve, reject) => {
+            this.stream.write(request, (err) => {
+                if (err === null || err === undefined) {
+                    resolve();
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+    }
+    async removeAccounts(accounts) {
+        for (const pk of accounts) {
+            const k = pk.toBase58();
+            this.subscribedAccounts.delete(k);
+            this.onChangeMap.delete(k);
+        }
+        const request = {
+            slots: {},
+            accounts: {
+                account: {
+                    account: Array.from(this.subscribedAccounts.values()),
+                    owner: [],
+                    filters: [],
+                },
+            },
+            transactions: {},
+            blocks: {},
+            blocksMeta: {},
+            accountsDataSlice: [],
+            commitment: this.commitmentLevel,
+            entry: {},
+            transactionsStatus: {},
+        };
+        await new Promise((resolve, reject) => {
+            this.stream.write(request, (err) => {
+                if (err === null || err === undefined) {
+                    resolve();
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+    }
+    async unsubscribe() {
+        this.isUnsubscribing = true;
+        clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        if (this.listenerId != null) {
+            const promise = new Promise((resolve, reject) => {
+                const request = {
+                    slots: {},
+                    accounts: {},
+                    transactions: {},
+                    blocks: {},
+                    blocksMeta: {},
+                    accountsDataSlice: [],
+                    entry: {},
+                    transactionsStatus: {},
+                };
+                this.stream.write(request, (err) => {
+                    if (err === null || err === undefined) {
+                        this.listenerId = undefined;
+                        this.isUnsubscribing = false;
+                        resolve();
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+            }).catch((reason) => {
+                console.error(reason);
+                throw reason;
+            });
+            return promise;
+        }
+        else {
+            this.isUnsubscribing = false;
+        }
+        if (this.onUnsubscribe) {
+            try {
+                await this.onUnsubscribe();
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+    }
+    setTimeout() {
+        var _a;
+        this.timeoutId = setTimeout(async () => {
+            if (this.isUnsubscribing) {
+                return;
+            }
+            if (this.receivingData) {
+                await this.unsubscribe();
+                this.receivingData = false;
+            }
+        }, (_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs);
+    }
+    capitalize(value) {
+        if (!value)
+            return value;
+        return value.charAt(0).toUpperCase() + value.slice(1);
+    }
+}
+exports.grpcMultiAccountSubscriber = grpcMultiAccountSubscriber;

package/lib/node/constants/spotMarkets.js

@@ -11,8 +11,8 @@ exports.DevnetSpotMarkets = [
         symbol: 'USDC',
         marketIndex: 0,
         poolId: 0,
-        oracle: new web3_js_1.PublicKey('En8hkHLkRe9d9DraYmBTrus518BvmVH448YcvmrFM6Ce'),
-        oracleSource: types_1.OracleSource.PYTH_STABLE_COIN_PULL,
+        oracle: new web3_js_1.PublicKey('9VCioxmni2gDLv11qufWzT3RDERhQE4iY5Gf7NTfYyAV'),
+        oracleSource: types_1.OracleSource.PYTH_LAZER_STABLE_COIN,
         mint: new web3_js_1.PublicKey('8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2'),
         precision: new anchor_1.BN(10).pow(numericConstants_1.SIX),
         precisionExp: numericConstants_1.SIX,
@@ -23,8 +23,8 @@ exports.DevnetSpotMarkets = [
         symbol: 'SOL',
         marketIndex: 1,
         poolId: 0,
-        oracle: new web3_js_1.PublicKey('BAtFj4kQttZRVep3UZS2aZRDixkGYgWsbqTBVDbnSsPF'),
-        oracleSource: types_1.OracleSource.PYTH_PULL,
+        oracle: new web3_js_1.PublicKey('3m6i4RFWEDw2Ft4tFHPJtYgmpPe21k56M3FHeWYrgGBz'),
+        oracleSource: types_1.OracleSource.PYTH_LAZER,
         mint: new web3_js_1.PublicKey(exports.WRAPPED_SOL_MINT),
         precision: numericConstants_1.LAMPORTS_PRECISION,
         precisionExp: numericConstants_1.LAMPORTS_EXP,