@drift-labs/sdk-browser 2.104.0-beta.21

package/lib/browser/math/utils.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberToSafeBN = exports.isBNSafe = exports.checkSameDate = exports.timeRemainingUntilUpdate = exports.sigNum = exports.divCeil = exports.squareRootBN = exports.clampBN = void 0;
+const __1 = require("../");
+function clampBN(x, min, max) {
+    return __1.BN.max(min, __1.BN.min(x, max));
+}
+exports.clampBN = clampBN;
+const squareRootBN = (n) => {
+    if (n.lt(new __1.BN(0))) {
+        throw new Error('Sqrt only works on non-negtiave inputs');
+    }
+    if (n.lt(new __1.BN(2))) {
+        return n;
+    }
+    const smallCand = (0, exports.squareRootBN)(n.shrn(2)).shln(1);
+    const largeCand = smallCand.add(new __1.BN(1));
+    if (largeCand.mul(largeCand).gt(n)) {
+        return smallCand;
+    }
+    else {
+        return largeCand;
+    }
+};
+exports.squareRootBN = squareRootBN;
+const divCeil = (a, b) => {
+    const quotient = a.div(b);
+    const remainder = a.mod(b);
+    if (remainder.gt(__1.ZERO)) {
+        return quotient.add(__1.ONE);
+    }
+    else {
+        return quotient;
+    }
+};
+exports.divCeil = divCeil;
+const sigNum = (x) => {
+    return x.isNeg() ? new __1.BN(-1) : new __1.BN(1);
+};
+exports.sigNum = sigNum;
+/**
+ * calculates the time remaining until the next update based on a rounded, "on-the-hour" update schedule
+ * this schedule is used for Perpetual Funding Rate and Revenue -> Insurance Updates
+ * @param now: current blockchain unix timestamp
+ * @param lastUpdateTs: the unix timestamp of the last update
+ * @param updatePeriod: desired interval between updates (in seconds)
+ * @returns: timeRemainingUntilUpdate (in seconds)
+ */
+function timeRemainingUntilUpdate(now, lastUpdateTs, updatePeriod) {
+    const timeSinceLastUpdate = now.sub(lastUpdateTs);
+    // round next update time to be available on the hour
+    let nextUpdateWait = updatePeriod;
+    if (updatePeriod.gt(new __1.BN(1))) {
+        const lastUpdateDelay = lastUpdateTs.umod(updatePeriod);
+        if (!lastUpdateDelay.isZero()) {
+            const maxDelayForNextPeriod = updatePeriod.div(new __1.BN(3));
+            const twoFundingPeriods = updatePeriod.mul(new __1.BN(2));
+            if (lastUpdateDelay.gt(maxDelayForNextPeriod)) {
+                // too late for on the hour next period, delay to following period
+                nextUpdateWait = twoFundingPeriods.sub(lastUpdateDelay);
+            }
+            else {
+                // allow update on the hour
+                nextUpdateWait = updatePeriod.sub(lastUpdateDelay);
+            }
+            if (nextUpdateWait.gt(twoFundingPeriods)) {
+                nextUpdateWait = nextUpdateWait.sub(updatePeriod);
+            }
+        }
+    }
+    const timeRemainingUntilUpdate = nextUpdateWait
+        .sub(timeSinceLastUpdate)
+        .isNeg()
+        ? __1.ZERO
+        : nextUpdateWait.sub(timeSinceLastUpdate);
+    return timeRemainingUntilUpdate;
+}
+exports.timeRemainingUntilUpdate = timeRemainingUntilUpdate;
+const checkSameDate = (dateString1, dateString2) => {
+    const date1 = new Date(dateString1);
+    const date2 = new Date(dateString2);
+    const isSameDate = date1.getDate() === date2.getDate() &&
+        date1.getMonth() === date2.getMonth() &&
+        date1.getFullYear() === date2.getFullYear();
+    return isSameDate;
+};
+exports.checkSameDate = checkSameDate;
+function isBNSafe(number) {
+    return number <= 0x1fffffffffffff;
+}
+exports.isBNSafe = isBNSafe;
+/**
+ * Converts a number to BN makes sure the number is safe to convert to BN (that it does not overflow number after multiplying by precision)
+ * @param number the number to convert to BN
+ * @param precision the BN precision to use (i.e. QUOTE_PRECISION and BASE_PRECISION from drift sdk)
+ */
+function numberToSafeBN(number, precision) {
+    // check if number has decimals
+    const candidate = number * precision.toNumber();
+    if (isBNSafe(candidate)) {
+        return new __1.BN(candidate);
+    }
+    else {
+        if (number % 1 === 0) {
+            return new __1.BN(number.toString()).mul(precision);
+        }
+        else {
+            return new __1.BN(number).mul(precision);
+        }
+    }
+}
+exports.numberToSafeBN = numberToSafeBN;

package/lib/browser/memcmp.d.ts

@@ -0,0 +1,11 @@
+import { MemcmpFilter } from '@solana/web3.js';
+export declare function getUserFilter(): MemcmpFilter;
+export declare function getNonIdleUserFilter(): MemcmpFilter;
+export declare function getUserWithOrderFilter(): MemcmpFilter;
+export declare function getUserWithoutOrderFilter(): MemcmpFilter;
+export declare function getUserWithAuctionFilter(): MemcmpFilter;
+export declare function getUserThatHasBeenLP(): MemcmpFilter;
+export declare function getUserWithName(name: string): MemcmpFilter;
+export declare function getUserStatsFilter(): MemcmpFilter;
+export declare function getUserStatsIsReferredFilter(): MemcmpFilter;
+export declare function getUserStatsIsReferredOrReferrerFilter(): MemcmpFilter;

package/lib/browser/memcmp.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserStatsIsReferredOrReferrerFilter = exports.getUserStatsIsReferredFilter = exports.getUserStatsFilter = exports.getUserWithName = exports.getUserThatHasBeenLP = exports.getUserWithAuctionFilter = exports.getUserWithoutOrderFilter = exports.getUserWithOrderFilter = exports.getNonIdleUserFilter = exports.getUserFilter = void 0;
+const bs58_1 = __importDefault(require("bs58"));
+const anchor_1 = require("@coral-xyz/anchor");
+const userName_1 = require("./userName");
+function getUserFilter() {
+    return {
+        memcmp: {
+            offset: 0,
+            bytes: bs58_1.default.encode(anchor_1.BorshAccountsCoder.accountDiscriminator('User')),
+        },
+    };
+}
+exports.getUserFilter = getUserFilter;
+function getNonIdleUserFilter() {
+    return {
+        memcmp: {
+            offset: 4350,
+            bytes: bs58_1.default.encode(Uint8Array.from([0])),
+        },
+    };
+}
+exports.getNonIdleUserFilter = getNonIdleUserFilter;
+function getUserWithOrderFilter() {
+    return {
+        memcmp: {
+            offset: 4352,
+            bytes: bs58_1.default.encode(Uint8Array.from([1])),
+        },
+    };
+}
+exports.getUserWithOrderFilter = getUserWithOrderFilter;
+function getUserWithoutOrderFilter() {
+    return {
+        memcmp: {
+            offset: 4352,
+            bytes: bs58_1.default.encode(Uint8Array.from([0])),
+        },
+    };
+}
+exports.getUserWithoutOrderFilter = getUserWithoutOrderFilter;
+function getUserWithAuctionFilter() {
+    return {
+        memcmp: {
+            offset: 4354,
+            bytes: bs58_1.default.encode(Uint8Array.from([1])),
+        },
+    };
+}
+exports.getUserWithAuctionFilter = getUserWithAuctionFilter;
+function getUserThatHasBeenLP() {
+    return {
+        memcmp: {
+            offset: 4267,
+            bytes: bs58_1.default.encode(Uint8Array.from([99])),
+        },
+    };
+}
+exports.getUserThatHasBeenLP = getUserThatHasBeenLP;
+function getUserWithName(name) {
+    return {
+        memcmp: {
+            offset: 72,
+            bytes: bs58_1.default.encode(Uint8Array.from((0, userName_1.encodeName)(name))),
+        },
+    };
+}
+exports.getUserWithName = getUserWithName;
+function getUserStatsFilter() {
+    return {
+        memcmp: {
+            offset: 0,
+            bytes: bs58_1.default.encode(anchor_1.BorshAccountsCoder.accountDiscriminator('UserStats')),
+        },
+    };
+}
+exports.getUserStatsFilter = getUserStatsFilter;
+function getUserStatsIsReferredFilter() {
+    return {
+        memcmp: {
+            offset: 188,
+            bytes: bs58_1.default.encode(Buffer.from(Uint8Array.from([2]))),
+        },
+    };
+}
+exports.getUserStatsIsReferredFilter = getUserStatsIsReferredFilter;
+function getUserStatsIsReferredOrReferrerFilter() {
+    return {
+        memcmp: {
+            offset: 188,
+            bytes: bs58_1.default.encode(Buffer.from(Uint8Array.from([3]))),
+        },
+    };
+}
+exports.getUserStatsIsReferredOrReferrerFilter = getUserStatsIsReferredOrReferrerFilter;

package/lib/browser/openbook/openbookV2FulfillmentConfigMap.d.ts

@@ -0,0 +1,10 @@
+import { PublicKey } from '@solana/web3.js';
+import { OpenbookV2FulfillmentConfigAccount } from '../types';
+import { DriftClient } from '../driftClient';
+export declare class OpenbookV2FulfillmentConfigMap {
+    driftClient: DriftClient;
+    map: Map<number, OpenbookV2FulfillmentConfigAccount>;
+    constructor(driftClient: DriftClient);
+    add(marketIndex: number, openbookV2MarketAddress: PublicKey): Promise<void>;
+    get(marketIndex: number): OpenbookV2FulfillmentConfigAccount | undefined;
+}

package/lib/browser/openbook/openbookV2FulfillmentConfigMap.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenbookV2FulfillmentConfigMap = void 0;
+class OpenbookV2FulfillmentConfigMap {
+    constructor(driftClient) {
+        this.map = new Map();
+        this.driftClient = driftClient;
+    }
+    async add(marketIndex, openbookV2MarketAddress) {
+        const account = await this.driftClient.getOpenbookV2FulfillmentConfig(openbookV2MarketAddress);
+        this.map.set(marketIndex, account);
+    }
+    get(marketIndex) {
+        return this.map.get(marketIndex);
+    }
+}
+exports.OpenbookV2FulfillmentConfigMap = OpenbookV2FulfillmentConfigMap;

package/lib/browser/openbook/openbookV2Subscriber.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="bn.js" />
+import { Connection, PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+import { BN } from '@coral-xyz/anchor';
+import { L2Level, L2OrderBookGenerator } from '../dlob/orderBookLevels';
+import { Market, OpenBookV2Client } from '@openbook-dex/openbook-v2';
+export type OpenbookV2SubscriberConfig = {
+    connection: Connection;
+    programId: PublicKey;
+    marketAddress: PublicKey;
+    accountSubscription: {
+        type: 'polling';
+        accountLoader: BulkAccountLoader;
+    } | {
+        type: 'websocket';
+    };
+};
+export declare class OpenbookV2Subscriber implements L2OrderBookGenerator {
+    connection: Connection;
+    programId: PublicKey;
+    marketAddress: PublicKey;
+    subscriptionType: 'polling' | 'websocket';
+    accountLoader: BulkAccountLoader | undefined;
+    subscribed: boolean;
+    market: Market;
+    marketCallbackId: string | number;
+    client: OpenBookV2Client;
+    constructor(config: OpenbookV2SubscriberConfig);
+    subscribe(): Promise<void>;
+    getBestBid(): BN | undefined;
+    getBestAsk(): BN | undefined;
+    getL2Bids(): Generator<L2Level>;
+    getL2Asks(): Generator<L2Level>;
+    getL2Levels(side: 'bids' | 'asks'): Generator<L2Level>;
+    unsubscribe(): Promise<void>;
+}

package/lib/browser/openbook/openbookV2Subscriber.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenbookV2Subscriber = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const numericConstants_1 = require("../constants/numericConstants");
+const anchor_1 = require("@coral-xyz/anchor");
+const openbook_v2_1 = require("@openbook-dex/openbook-v2");
+const openbook_json_1 = __importDefault(require("../idl/openbook.json"));
+class OpenbookV2Subscriber {
+    constructor(config) {
+        this.connection = config.connection;
+        this.programId = config.programId;
+        this.marketAddress = config.marketAddress;
+        this.subscribed = false;
+        if (config.accountSubscription.type === 'polling') {
+            this.subscriptionType = 'polling';
+            this.accountLoader = config.accountSubscription.accountLoader;
+        }
+        else {
+            this.subscriptionType = 'websocket';
+        }
+    }
+    async subscribe() {
+        if (this.subscribed === true) {
+            return;
+        }
+        const anchorProvider = new anchor_1.AnchorProvider(this.connection, new anchor_1.Wallet(web3_js_1.Keypair.generate()), {});
+        const openbookV2Program = new anchor_1.Program(openbook_json_1.default, this.programId, anchorProvider);
+        this.client = new openbook_v2_1.OpenBookV2Client(anchorProvider);
+        const market = await openbook_v2_1.Market.load(this.client, this.marketAddress);
+        this.market = await market.loadOrderBook();
+        if (this.subscriptionType === 'websocket') {
+            this.marketCallbackId = this.connection.onAccountChange(this.marketAddress, async (accountInfo, _) => {
+                const marketRaw = openbookV2Program.coder.accounts.decode('Market', accountInfo.data);
+                const market = new openbook_v2_1.Market(this.client, this.marketAddress, marketRaw);
+                await market.loadOrderBook();
+                this.market = market;
+            });
+        }
+        else {
+            this.marketCallbackId = await this.accountLoader.addAccount(this.marketAddress, async (buffer, _) => {
+                const marketRaw = openbookV2Program.coder.accounts.decode('Market', buffer);
+                const market = new openbook_v2_1.Market(this.client, this.marketAddress, marketRaw);
+                await market.loadOrderBook();
+                this.market = market;
+            });
+        }
+        this.subscribed = true;
+    }
+    getBestBid() {
+        var _a;
+        const bestBid = (_a = this.market.bids) === null || _a === void 0 ? void 0 : _a.best();
+        if (bestBid === undefined) {
+            return undefined;
+        }
+        return new anchor_1.BN(Math.floor(bestBid.price * numericConstants_1.PRICE_PRECISION.toNumber()));
+    }
+    getBestAsk() {
+        var _a;
+        const bestAsk = (_a = this.market.asks) === null || _a === void 0 ? void 0 : _a.best();
+        if (bestAsk === undefined) {
+            return undefined;
+        }
+        return new anchor_1.BN(Math.floor(bestAsk.price * numericConstants_1.PRICE_PRECISION.toNumber()));
+    }
+    getL2Bids() {
+        return this.getL2Levels('bids');
+    }
+    getL2Asks() {
+        return this.getL2Levels('asks');
+    }
+    *getL2Levels(side) {
+        const basePrecision = Math.ceil(1 / this.market.baseNativeFactor.toNumber());
+        const pricePrecision = numericConstants_1.PRICE_PRECISION.toNumber();
+        const levels = side === 'bids' ? this.market.bids : this.market.asks;
+        for (const order of levels === null || levels === void 0 ? void 0 : levels.items()) {
+            const size = new anchor_1.BN(order.size * basePrecision);
+            const price = new anchor_1.BN(order.price * pricePrecision);
+            yield {
+                price,
+                size,
+                sources: {
+                    openbook: size,
+                },
+            };
+        }
+    }
+    async unsubscribe() {
+        if (!this.subscribed) {
+            return;
+        }
+        if (this.subscriptionType === 'websocket') {
+            await this.connection.removeAccountChangeListener(this.marketCallbackId);
+        }
+        else {
+            this.accountLoader.removeAccount(this.marketAddress, this.marketCallbackId);
+        }
+        this.subscribed = false;
+    }
+}
+exports.OpenbookV2Subscriber = OpenbookV2Subscriber;

package/lib/browser/oracles/oracleClientCache.d.ts

@@ -0,0 +1,9 @@
+import { OracleClient } from './types';
+import { OracleSource } from '../types';
+import { Connection } from '@solana/web3.js';
+import { Program } from '@coral-xyz/anchor';
+export declare class OracleClientCache {
+    cache: Map<string, OracleClient>;
+    constructor();
+    get(oracleSource: OracleSource, connection: Connection, program: Program): OracleClient;
+}

package/lib/browser/oracles/oracleClientCache.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OracleClientCache = void 0;
+const oracleClient_1 = require("../factory/oracleClient");
+class OracleClientCache {
+    constructor() {
+        this.cache = new Map();
+    }
+    get(oracleSource, connection, program) {
+        const key = Object.keys(oracleSource)[0];
+        if (this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        const client = (0, oracleClient_1.getOracleClient)(oracleSource, connection, program);
+        this.cache.set(key, client);
+        return client;
+    }
+}
+exports.OracleClientCache = OracleClientCache;

package/lib/browser/oracles/oracleId.d.ts

@@ -0,0 +1,4 @@
+import { PublicKey } from '@solana/web3.js';
+import { OracleSource } from '../types';
+export declare function getOracleSourceNum(source: OracleSource): number;
+export declare function getOracleId(publicKey: PublicKey, source: OracleSource): string;

package/lib/browser/oracles/oracleId.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOracleId = exports.getOracleSourceNum = void 0;
+const types_1 = require("../types");
+function getOracleSourceNum(source) {
+    if ('pyth' in source)
+        return types_1.OracleSourceNum.PYTH;
+    if ('pyth1K' in source)
+        return types_1.OracleSourceNum.PYTH_1K;
+    if ('pyth1M' in source)
+        return types_1.OracleSourceNum.PYTH_1M;
+    if ('pythPull' in source)
+        return types_1.OracleSourceNum.PYTH_PULL;
+    if ('pyth1KPull' in source)
+        return types_1.OracleSourceNum.PYTH_1K_PULL;
+    if ('pyth1MPull' in source)
+        return types_1.OracleSourceNum.PYTH_1M_PULL;
+    if ('switchboard' in source)
+        return types_1.OracleSourceNum.SWITCHBOARD;
+    if ('quoteAsset' in source)
+        return types_1.OracleSourceNum.QUOTE_ASSET;
+    if ('pythStableCoin' in source)
+        return types_1.OracleSourceNum.PYTH_STABLE_COIN;
+    if ('pythStableCoinPull' in source)
+        return types_1.OracleSourceNum.PYTH_STABLE_COIN_PULL;
+    if ('prelaunch' in source)
+        return types_1.OracleSourceNum.PRELAUNCH;
+    if ('switchboardOnDemand' in source)
+        return types_1.OracleSourceNum.SWITCHBOARD_ON_DEMAND;
+    if ('pythLazer' in source)
+        return types_1.OracleSourceNum.PYTH_LAZER;
+    throw new Error('Invalid oracle source');
+}
+exports.getOracleSourceNum = getOracleSourceNum;
+function getOracleId(publicKey, source) {
+    return `${publicKey.toBase58()}-${getOracleSourceNum(source)}`;
+}
+exports.getOracleId = getOracleId;

package/lib/browser/oracles/prelaunchOracleClient.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Connection, PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { Program } from '@coral-xyz/anchor';
+export declare class PrelaunchOracleClient implements OracleClient {
+    private connection;
+    private program;
+    constructor(connection: Connection, program: Program);
+    getOraclePriceData(pricePublicKey: PublicKey): Promise<OraclePriceData>;
+    getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData;
+}

package/lib/browser/oracles/prelaunchOracleClient.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrelaunchOracleClient = void 0;
+class PrelaunchOracleClient {
+    constructor(connection, program) {
+        this.connection = connection;
+        this.program = program;
+    }
+    async getOraclePriceData(pricePublicKey) {
+        const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
+        return this.getOraclePriceDataFromBuffer(accountInfo.data);
+    }
+    getOraclePriceDataFromBuffer(buffer) {
+        const prelaunchOracle = this.program.account.prelaunchOracle.coder.accounts.decodeUnchecked('PrelaunchOracle', buffer);
+        return {
+            price: prelaunchOracle.price,
+            slot: prelaunchOracle.ammLastUpdateSlot,
+            confidence: prelaunchOracle.confidence,
+            hasSufficientNumberOfDataPoints: true,
+            maxPrice: prelaunchOracle.maxPrice,
+        };
+    }
+}
+exports.PrelaunchOracleClient = PrelaunchOracleClient;

package/lib/browser/oracles/pythClient.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="bn.js" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Connection, PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { BN } from '@coral-xyz/anchor';
+export declare class PythClient implements OracleClient {
+    private connection;
+    private multiple;
+    private stableCoin;
+    constructor(connection: Connection, multiple?: BN, stableCoin?: boolean);
+    getOraclePriceData(pricePublicKey: PublicKey): Promise<OraclePriceData>;
+    getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData;
+}

package/lib/browser/oracles/pythClient.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythClient = void 0;
+const client_1 = require("@pythnetwork/client");
+const anchor_1 = require("@coral-xyz/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+class PythClient {
+    constructor(connection, multiple = numericConstants_1.ONE, stableCoin = false) {
+        this.connection = connection;
+        this.multiple = multiple;
+        this.stableCoin = stableCoin;
+    }
+    async getOraclePriceData(pricePublicKey) {
+        const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
+        return this.getOraclePriceDataFromBuffer(accountInfo.data);
+    }
+    getOraclePriceDataFromBuffer(buffer) {
+        const priceData = (0, client_1.parsePriceData)(buffer);
+        const confidence = convertPythPrice(priceData.confidence, priceData.exponent, this.multiple);
+        const minPublishers = Math.min(priceData.numComponentPrices, 3);
+        let price = convertPythPrice(priceData.aggregate.price, priceData.exponent, this.multiple);
+        if (this.stableCoin) {
+            price = getStableCoinPrice(price, confidence);
+        }
+        return {
+            price,
+            slot: new anchor_1.BN(priceData.lastSlot.toString()),
+            confidence,
+            twap: convertPythPrice(priceData.twap.value, priceData.exponent, this.multiple),
+            twapConfidence: convertPythPrice(priceData.twac.value, priceData.exponent, this.multiple),
+            hasSufficientNumberOfDataPoints: priceData.numQuoters >= minPublishers,
+        };
+    }
+}
+exports.PythClient = PythClient;
+function convertPythPrice(price, exponent, multiple) {
+    exponent = Math.abs(exponent);
+    const pythPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(exponent).abs()).div(multiple);
+    return new anchor_1.BN(price * Math.pow(10, exponent))
+        .mul(numericConstants_1.PRICE_PRECISION)
+        .div(pythPrecision);
+}
+const fiveBPS = new anchor_1.BN(500);
+function getStableCoinPrice(price, confidence) {
+    if (price.sub(numericConstants_1.QUOTE_PRECISION).abs().lt(anchor_1.BN.min(confidence, fiveBPS))) {
+        return numericConstants_1.QUOTE_PRECISION;
+    }
+    else {
+        return price;
+    }
+}

package/lib/browser/oracles/pythLazerClient.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="bn.js" />
+import { Connection, PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { BN } from '@coral-xyz/anchor';
+export declare class PythLazerClient implements OracleClient {
+    private connection;
+    private multiple;
+    private stableCoin;
+    private program;
+    readonly decodeFunc: (name: string, data: Buffer) => any;
+    constructor(connection: Connection, multiple?: BN, stableCoin?: boolean);
+    getOraclePriceData(pricePublicKey: PublicKey): Promise<OraclePriceData>;
+    getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData;
+}

package/lib/browser/oracles/pythLazerClient.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythLazerClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@coral-xyz/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+const __1 = require("..");
+const drift_json_1 = __importDefault(require("../idl/drift.json"));
+class PythLazerClient {
+    constructor(connection, multiple = numericConstants_1.ONE, stableCoin = false) {
+        this.connection = connection;
+        this.multiple = multiple;
+        this.stableCoin = stableCoin;
+        const provider = new anchor_1.AnchorProvider(this.connection, 
+        //@ts-ignore
+        new __1.Wallet(new web3_js_1.Keypair()), {
+            commitment: connection.commitment,
+        });
+        this.program = new anchor_1.Program(drift_json_1.default, new web3_js_1.PublicKey(__1.DRIFT_PROGRAM_ID), provider);
+        this.decodeFunc =
+            this.program.account.pythLazerOracle.coder.accounts.decodeUnchecked.bind(this.program.account.pythLazerOracle.coder.accounts);
+    }
+    async getOraclePriceData(pricePublicKey) {
+        const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
+        return this.getOraclePriceDataFromBuffer(accountInfo.data);
+    }
+    getOraclePriceDataFromBuffer(buffer) {
+        const priceData = this.decodeFunc('PythLazerOracle', buffer);
+        const confidence = convertPythPrice(priceData.conf, priceData.exponent, this.multiple);
+        let price = convertPythPrice(priceData.price, priceData.exponent, this.multiple);
+        if (this.stableCoin) {
+            price = getStableCoinPrice(price, confidence);
+        }
+        return {
+            price,
+            slot: priceData.postedSlot,
+            confidence,
+            twap: convertPythPrice(priceData.price, priceData.exponent, this.multiple),
+            twapConfidence: convertPythPrice(priceData.price, priceData.exponent, this.multiple),
+            hasSufficientNumberOfDataPoints: true,
+        };
+    }
+}
+exports.PythLazerClient = PythLazerClient;
+function convertPythPrice(price, exponent, multiple) {
+    exponent = Math.abs(exponent);
+    const pythPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(exponent).abs()).div(multiple);
+    return price.mul(numericConstants_1.PRICE_PRECISION).div(pythPrecision);
+}
+const fiveBPS = new anchor_1.BN(500);
+function getStableCoinPrice(price, confidence) {
+    if (price.sub(numericConstants_1.QUOTE_PRECISION).abs().lt(anchor_1.BN.min(confidence, fiveBPS))) {
+        return numericConstants_1.QUOTE_PRECISION;
+    }
+    else {
+        return price;
+    }
+}