@drift-labs/sdk 0.2.0-master.21 → 0.2.0-master.24

package/src/events/txEventCache.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxEventCache = void 0;
+class Node {
+    constructor(key, value, next, prev) {
+        this.key = key;
+        this.value = value;
+        this.next = next;
+        this.prev = prev;
+    }
+}
+// lru cache
+class TxEventCache {
+    constructor(maxTx = 1024) {
+        this.maxTx = maxTx;
+        this.size = 0;
+        this.cacheMap = {};
+    }
+    add(key, events) {
+        const existingNode = this.cacheMap[key];
+        if (existingNode) {
+            this.detach(existingNode);
+            this.size--;
+        }
+        else if (this.size === this.maxTx) {
+            delete this.cacheMap[this.tail.key];
+            this.detach(this.tail);
+            this.size--;
+        }
+        // Write to head of LinkedList
+        if (!this.head) {
+            this.head = this.tail = new Node(key, events);
+        }
+        else {
+            const node = new Node(key, events, this.head);
+            this.head.prev = node;
+            this.head = node;
+        }
+        // update cacheMap with LinkedList key and Node reference
+        this.cacheMap[key] = this.head;
+        this.size++;
+    }
+    has(key) {
+        return this.cacheMap.hasOwnProperty(key);
+    }
+    get(key) {
+        var _a;
+        return (_a = this.cacheMap[key]) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    detach(node) {
+        if (node.prev !== undefined) {
+            node.prev.next = node.next;
+        }
+        else {
+            this.head = node.next;
+        }
+        if (node.next !== undefined) {
+            node.next.prev = node.prev;
+        }
+        else {
+            this.tail = node.prev;
+        }
+    }
+    clear() {
+        this.head = undefined;
+        this.tail = undefined;
+        this.size = 0;
+        this.cacheMap = {};
+    }
+}
+exports.TxEventCache = TxEventCache;

package/src/events/types.ts

@@ -5,6 +5,7 @@ import {
 	FundingRateRecord,
 	LiquidationRecord,
 	NewUserRecord,
+	OrderActionRecord,
 	OrderRecord,
 	SettlePnlRecord,
 } from '../index';
@@ -28,6 +29,7 @@ export const DefaultEventSubscriptionOptions: EventSubscriptionOptions = {
 		'FundingPaymentRecord',
 		'LiquidationRecord',
 		'OrderRecord',
+		'OrderActionRecord',
 		'FundingRateRecord',
 		'NewUserRecord',
 		'SettlePnlRecord',
@@ -63,6 +65,7 @@ export type EventMap = {
 	LiquidationRecord: Event<LiquidationRecord>;
 	FundingRateRecord: Event<FundingRateRecord>;
 	OrderRecord: Event<OrderRecord>;
+	OrderActionRecord: Event<OrderActionRecord>;
 	SettlePnlRecord: Event<SettlePnlRecord>;
 	NewUserRecord: Event<NewUserRecord>;
 };

package/src/examples/makeTradeExample.js

@@ -0,0 +1,80 @@
+"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.getTokenAddress = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const __1 = require("..");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const __2 = require("..");
+const banks_1 = require("../constants/banks");
+const getTokenAddress = (mintAddress, userPubKey) => {
+    return spl_token_1.Token.getAssociatedTokenAddress(new web3_js_1.PublicKey(`ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL`), spl_token_1.TOKEN_PROGRAM_ID, new web3_js_1.PublicKey(mintAddress), new web3_js_1.PublicKey(userPubKey));
+};
+exports.getTokenAddress = getTokenAddress;
+const main = () => __awaiter(void 0, void 0, void 0, function* () {
+    // Initialize Drift SDK
+    const sdkConfig = __2.initialize({ env: 'devnet' });
+    // Set up the Wallet and Provider
+    const privateKey = process.env.BOT_PRIVATE_KEY; // stored as an array string
+    const keypair = web3_js_1.Keypair.fromSecretKey(Uint8Array.from(JSON.parse(privateKey)));
+    const wallet = new __1.Wallet(keypair);
+    // Set up the Connection
+    const rpcAddress = process.env.RPC_ADDRESS; // can use: https://api.devnet.solana.com for devnet; https://api.mainnet-beta.solana.com for mainnet;
+    const connection = new web3_js_1.Connection(rpcAddress);
+    // Set up the Provider
+    const provider = new anchor_1.AnchorProvider(connection, wallet, anchor_1.AnchorProvider.defaultOptions());
+    // Check SOL Balance
+    const lamportsBalance = yield connection.getBalance(wallet.publicKey);
+    console.log('SOL balance:', lamportsBalance / Math.pow(10, 9));
+    // Misc. other things to set up
+    const usdcTokenAddress = yield exports.getTokenAddress(sdkConfig.USDC_MINT_ADDRESS, wallet.publicKey.toString());
+    // Set up the Drift Clearing House
+    const clearingHousePublicKey = new web3_js_1.PublicKey(sdkConfig.CLEARING_HOUSE_PROGRAM_ID);
+    const clearingHouse = new __2.ClearingHouse({
+        connection,
+        wallet: provider.wallet,
+        programID: clearingHousePublicKey,
+    });
+    yield clearingHouse.subscribe();
+    // Set up Clearing House user client
+    const user = new __2.ClearingHouseUser({
+        clearingHouse,
+        userAccountPublicKey: yield clearingHouse.getUserAccountPublicKey(),
+    });
+    //// Check if clearing house account exists for the current wallet
+    const userAccountExists = yield user.exists();
+    if (!userAccountExists) {
+        //// Create a Clearing House account by Depositing some USDC ($10,000 in this case)
+        const depositAmount = new anchor_1.BN(10000).mul(__2.QUOTE_PRECISION);
+        yield clearingHouse.initializeUserAccountAndDepositCollateral(depositAmount, yield exports.getTokenAddress(usdcTokenAddress.toString(), wallet.publicKey.toString()), banks_1.Banks['devnet'][0].bankIndex);
+    }
+    yield user.subscribe();
+    // Get current price
+    const solMarketInfo = sdkConfig.MARKETS.find((market) => market.baseAssetSymbol === 'SOL');
+    const currentMarketPrice = __2.calculateMarkPrice(clearingHouse.getMarketAccount(solMarketInfo.marketIndex), undefined);
+    const formattedPrice = __2.convertToNumber(currentMarketPrice, __2.MARK_PRICE_PRECISION);
+    console.log(`Current Market Price is $${formattedPrice}`);
+    // Estimate the slippage for a $5000 LONG trade
+    const solMarketAccount = clearingHouse.getMarketAccount(solMarketInfo.marketIndex);
+    const longAmount = new anchor_1.BN(5000).mul(__2.QUOTE_PRECISION);
+    const slippage = __2.convertToNumber(__2.calculateTradeSlippage(__2.PositionDirection.LONG, longAmount, solMarketAccount, 'quote', undefined)[0], __2.MARK_PRICE_PRECISION);
+    console.log(`Slippage for a $5000 LONG on the SOL market would be $${slippage}`);
+    // Make a $5000 LONG trade
+    yield clearingHouse.openPosition(__2.PositionDirection.LONG, longAmount, solMarketInfo.marketIndex);
+    console.log(`LONGED $5000 SOL`);
+    // Reduce the position by $2000
+    const reduceAmount = new anchor_1.BN(2000).mul(__2.QUOTE_PRECISION);
+    yield clearingHouse.openPosition(__2.PositionDirection.SHORT, reduceAmount, solMarketInfo.marketIndex);
+    // Close the rest of the position
+    yield clearingHouse.closePosition(solMarketInfo.marketIndex);
+});
+main();

package/src/factory/bigNum.js

@@ -0,0 +1,390 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigNum = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const assert_1 = require("../assert/assert");
+const numericConstants_1 = require("./../constants/numericConstants");
+class BigNum {
+    constructor(val, precisionVal = new anchor_1.BN(0)) {
+        this.toString = (base, length) => this.val.toString(base, length);
+        this.val = new anchor_1.BN(val);
+        this.precision = new anchor_1.BN(precisionVal);
+    }
+    bigNumFromParam(bn) {
+        return anchor_1.BN.isBN(bn) ? BigNum.from(bn) : bn;
+    }
+    add(bn) {
+        assert_1.assert(bn.precision.eq(this.precision), 'Adding unequal precisions');
+        return BigNum.from(this.val.add(bn.val), this.precision);
+    }
+    sub(bn) {
+        assert_1.assert(bn.precision.eq(this.precision), 'Subtracting unequal precisions');
+        return BigNum.from(this.val.sub(bn.val), this.precision);
+    }
+    mul(bn) {
+        const mulVal = this.bigNumFromParam(bn);
+        return BigNum.from(this.val.mul(mulVal.val), this.precision.add(mulVal.precision));
+    }
+    /**
+     * Multiplies by another big number then scales the result down by the big number's precision so that we're in the same precision space
+     * @param bn
+     * @returns
+     */
+    scalarMul(bn) {
+        if (anchor_1.BN.isBN(bn))
+            return BigNum.from(this.val.mul(bn), this.precision);
+        return BigNum.from(this.val.mul(bn.val), this.precision.add(bn.precision)).shift(bn.precision.neg());
+    }
+    div(bn) {
+        if (anchor_1.BN.isBN(bn))
+            return BigNum.from(this.val.div(bn), this.precision);
+        return BigNum.from(this.val.div(bn.val), this.precision.sub(bn.precision));
+    }
+    /**
+     * Shift precision up or down
+     * @param exponent
+     * @param skipAdjustingPrecision
+     * @returns
+     */
+    shift(exponent, skipAdjustingPrecision = false) {
+        const shiftVal = typeof exponent === 'number' ? new anchor_1.BN(exponent) : exponent;
+        return BigNum.from(shiftVal.isNeg()
+            ? this.val.div(new anchor_1.BN(10).pow(shiftVal))
+            : this.val.mul(new anchor_1.BN(10).pow(shiftVal)), skipAdjustingPrecision ? this.precision : this.precision.add(shiftVal));
+    }
+    /**
+     * Shift to a target precision
+     * @param targetPrecision
+     * @returns
+     */
+    shiftTo(targetPrecision) {
+        return this.shift(targetPrecision.sub(this.precision));
+    }
+    /**
+     * Scale the number by a fraction
+     * @param numerator
+     * @param denominator
+     * @returns
+     */
+    scale(numerator, denominator) {
+        return this.mul(BigNum.from(new anchor_1.BN(numerator))).div(new anchor_1.BN(denominator));
+    }
+    toPercentage(denominator, precision) {
+        return this.shift(precision)
+            .shift(2, true)
+            .div(denominator)
+            .toPrecision(precision);
+    }
+    gt(bn, ignorePrecision) {
+        const comparisonVal = this.bigNumFromParam(bn);
+        if (!ignorePrecision && !comparisonVal.eq(numericConstants_1.ZERO)) {
+            assert_1.assert(comparisonVal.precision.eq(this.precision), 'Trying to compare numbers with different precision. Yo can opt to ignore precision using the ignorePrecision parameter');
+        }
+        return this.val.gt(comparisonVal.val);
+    }
+    lt(bn, ignorePrecision) {
+        const comparisonVal = this.bigNumFromParam(bn);
+        if (!ignorePrecision && !comparisonVal.val.eq(numericConstants_1.ZERO)) {
+            assert_1.assert(comparisonVal.precision.eq(this.precision), 'Trying to compare numbers with different precision. Yo can opt to ignore precision using the ignorePrecision parameter');
+        }
+        return this.val.lt(comparisonVal.val);
+    }
+    gte(bn, ignorePrecision) {
+        const comparisonVal = this.bigNumFromParam(bn);
+        if (!ignorePrecision && !comparisonVal.val.eq(numericConstants_1.ZERO)) {
+            assert_1.assert(comparisonVal.precision.eq(this.precision), 'Trying to compare numbers with different precision. Yo can opt to ignore precision using the ignorePrecision parameter');
+        }
+        return this.val.gte(comparisonVal.val);
+    }
+    lte(bn, ignorePrecision) {
+        const comparisonVal = this.bigNumFromParam(bn);
+        if (!ignorePrecision && !comparisonVal.val.eq(numericConstants_1.ZERO)) {
+            assert_1.assert(comparisonVal.precision.eq(this.precision), 'Trying to compare numbers with different precision. Yo can opt to ignore precision using the ignorePrecision parameter');
+        }
+        return this.val.lte(comparisonVal.val);
+    }
+    eq(bn, ignorePrecision) {
+        const comparisonVal = this.bigNumFromParam(bn);
+        if (!ignorePrecision && !comparisonVal.val.eq(numericConstants_1.ZERO)) {
+            assert_1.assert(comparisonVal.precision.eq(this.precision), 'Trying to compare numbers with different precision. Yo can opt to ignore precision using the ignorePrecision parameter');
+        }
+        return this.val.eq(comparisonVal.val);
+    }
+    eqZero() {
+        return this.val.eq(numericConstants_1.ZERO);
+    }
+    gtZero() {
+        return this.val.gt(numericConstants_1.ZERO);
+    }
+    ltZero() {
+        return this.val.lt(numericConstants_1.ZERO);
+    }
+    gteZero() {
+        return this.val.gte(numericConstants_1.ZERO);
+    }
+    lteZero() {
+        return this.val.lte(numericConstants_1.ZERO);
+    }
+    abs() {
+        return new BigNum(this.val.abs(), this.precision);
+    }
+    neg() {
+        return new BigNum(this.val.neg(), this.precision);
+    }
+    /**
+     * Pretty print the underlying value in human-readable form. Depends on precision being correct for the output string to be correct
+     * @returns
+     */
+    print() {
+        assert_1.assert(this.precision.gte(numericConstants_1.ZERO), 'Tried to print a BN with precision lower than zero');
+        const plainString = this.toString();
+        const precisionNum = this.precision.toNumber();
+        // make a string with at least the precisionNum number of zeroes
+        let printString = [
+            ...Array(this.precision.toNumber()).fill(0),
+            ...plainString.split(''),
+        ].join('');
+        // inject decimal
+        printString =
+            printString.substring(0, printString.length - precisionNum) +
+                BigNum.delim +
+                printString.substring(printString.length - precisionNum);
+        // remove leading zeroes
+        printString = printString.replace(/^0+/, '');
+        // add zero if leading delim
+        if (this.isNeg()) {
+            if (printString[1] === BigNum.delim)
+                printString = printString.replace('-.', '-0.');
+        }
+        else {
+            if (printString[0] === BigNum.delim)
+                printString = `0${printString}`;
+        }
+        // remove trailing delim
+        if (printString[printString.length - 1] === BigNum.delim)
+            printString = printString.slice(0, printString.length - 1);
+        return printString;
+    }
+    prettyPrint(useTradePrecision, precisionOverride) {
+        const [leftSide, rightSide] = this.printShort(useTradePrecision, precisionOverride).split(BigNum.delim);
+        let formattedLeftSide = leftSide;
+        const isNeg = formattedLeftSide.includes('-');
+        if (isNeg) {
+            formattedLeftSide = formattedLeftSide.replace('-', '');
+        }
+        let index = formattedLeftSide.length - 3;
+        while (index >= 1) {
+            const formattedLeftSideArray = formattedLeftSide.split('');
+            formattedLeftSideArray.splice(index, 0, BigNum.spacer);
+            formattedLeftSide = formattedLeftSideArray.join('');
+            index -= 3;
+        }
+        return `${isNeg ? '-' : ''}${formattedLeftSide}${rightSide ? `${BigNum.delim}${rightSide}` : ''}`;
+    }
+    /**
+     * Print and remove unnecessary trailing zeroes
+     * @returns
+     */
+    printShort(useTradePrecision, precisionOverride) {
+        const printVal = precisionOverride
+            ? this.toPrecision(precisionOverride)
+            : useTradePrecision
+                ? this.toTradePrecision()
+                : this.print();
+        return printVal.replace(/0+$/g, '').replace(/\.$/, '').replace(/,$/, '');
+    }
+    debug() {
+        console.log(`${this.toString()} | ${this.print()} | ${this.precision.toString()}`);
+    }
+    /**
+     * Pretty print with the specified number of decimal places
+     * @param fixedPrecision
+     * @returns
+     */
+    toFixed(fixedPrecision) {
+        const printString = this.print();
+        const [leftSide, rightSide] = printString.split(BigNum.delim);
+        const filledRightSide = [
+            ...(rightSide !== null && rightSide !== void 0 ? rightSide : '').slice(0, fixedPrecision),
+            ...Array(fixedPrecision).fill('0'),
+        ]
+            .slice(0, fixedPrecision)
+            .join('');
+        return `${leftSide}${BigNum.delim}${filledRightSide}`;
+    }
+    /**
+     * Pretty print to the specified number of significant figures
+     * @param fixedPrecision
+     * @returns
+     */
+    toPrecision(fixedPrecision, trailingZeroes = false) {
+        const printString = this.print();
+        let precisionPrintString = printString.slice(0, fixedPrecision + 1);
+        if (!precisionPrintString.includes(BigNum.delim) ||
+            precisionPrintString[precisionPrintString.length - 1] === BigNum.delim) {
+            precisionPrintString = printString.slice(0, fixedPrecision);
+        }
+        const pointsOfPrecision = precisionPrintString.replace(BigNum.delim, '').length;
+        if (pointsOfPrecision < fixedPrecision) {
+            precisionPrintString = [
+                ...precisionPrintString.split(''),
+                ...Array(fixedPrecision - pointsOfPrecision).fill('0'),
+            ].join('');
+        }
+        if (!precisionPrintString.includes(BigNum.delim)) {
+            const delimFullStringLocation = printString.indexOf(BigNum.delim);
+            let skipExponent = false;
+            if (delimFullStringLocation === -1) {
+                // no decimal, not missing any precision
+                skipExponent = true;
+            }
+            if (precisionPrintString[precisionPrintString.length - 1] === BigNum.delim) {
+                // decimal is at end of string, not missing any precision, do nothing
+                skipExponent = true;
+            }
+            if (printString.indexOf(BigNum.delim) === fixedPrecision) {
+                // decimal is at end of string, not missing any precision, do nothing
+                skipExponent = true;
+            }
+            if (!skipExponent) {
+                const exponent = delimFullStringLocation - fixedPrecision;
+                if (trailingZeroes) {
+                    precisionPrintString = `${precisionPrintString}${Array(exponent)
+                        .fill('0')
+                        .join('')}`;
+                }
+                else {
+                    precisionPrintString = `${precisionPrintString}e${exponent}`;
+                }
+            }
+        }
+        return precisionPrintString;
+    }
+    toTradePrecision() {
+        return this.toPrecision(6, true);
+    }
+    /**
+     * Print dollar formatted value. Defaults to fixed decimals two unless a given precision is given.
+     * @param useTradePrecision
+     * @param precisionOverride
+     * @returns
+     */
+    toNotional(useTradePrecision, precisionOverride) {
+        var _a;
+        const prefix = `${this.lt(BigNum.zero()) ? `-` : ``}$`;
+        const usingCustomPrecision = true && (useTradePrecision || precisionOverride);
+        let val = usingCustomPrecision
+            ? this.prettyPrint(useTradePrecision, precisionOverride)
+            : BigNum.fromPrint(this.toFixed(2), new anchor_1.BN(2)).prettyPrint();
+        // Append two trailing zeroes if not using custom precision
+        if (!usingCustomPrecision) {
+            const [_, rightSide] = val.split(BigNum.delim);
+            const trailingLength = (_a = rightSide === null || rightSide === void 0 ? void 0 : rightSide.length) !== null && _a !== void 0 ? _a : 0;
+            if (trailingLength < 2) {
+                const numHasDecimals = this.print().includes(BigNum.delim);
+                // Handle case where pretty print won't include the decimal point
+                if (trailingLength === 0 && numHasDecimals) {
+                    val = `${val}.00`;
+                }
+                else {
+                    val = `${val}${new Array(2 - trailingLength).fill('0').join('')}`;
+                }
+            }
+        }
+        return `${prefix}${val.replace('-', '')}`;
+    }
+    toMillified(precision = 3) {
+        const stringVal = this.print();
+        const [leftSide] = stringVal.split(BigNum.delim);
+        if (!leftSide) {
+            return this.shift(new anchor_1.BN(precision)).toPrecision(precision, true);
+        }
+        if (leftSide.length <= 3) {
+            return this.shift(new anchor_1.BN(precision)).toPrecision(precision, true);
+        }
+        const unitTicks = ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
+        const unitNumber = Math.floor((leftSide.length - 1) / 3);
+        const unit = unitTicks[unitNumber];
+        let leadDigits = leftSide.slice(0, precision);
+        if (leadDigits.length < precision) {
+            leadDigits = [
+                ...leadDigits.split(''),
+                ...Array(precision - leadDigits.length).fill('0'),
+            ].join('');
+        }
+        const decimalLocation = leftSide.length - 3 * unitNumber;
+        let leadString = '';
+        if (decimalLocation >= precision) {
+            leadString = `${leadDigits}`;
+        }
+        else {
+            leadString = `${leadDigits.slice(0, decimalLocation)}${BigNum.delim}${leadDigits.slice(decimalLocation)}`;
+        }
+        return `${leadString}${unit}`;
+    }
+    toJSON() {
+        return {
+            val: this.val.toString(),
+            precision: this.precision.toString(),
+        };
+    }
+    isNeg() {
+        return this.lt(numericConstants_1.ZERO, true);
+    }
+    isPos() {
+        return !this.isNeg();
+    }
+    /**
+     * Get the numerical value of the BigNum. This can break if the BigNum is too large.
+     * @returns
+     */
+    toNum() {
+        return parseFloat(this.print());
+    }
+    static fromJSON(json) {
+        return BigNum.from(new anchor_1.BN(json.val), new anchor_1.BN(json.precision));
+    }
+    /**
+     * Create a BigNum instance
+     * @param val
+     * @param precision
+     * @returns
+     */
+    static from(val = numericConstants_1.ZERO, precision) {
+        assert_1.assert(new anchor_1.BN(precision).lt(new anchor_1.BN(100)), 'Tried to create a bignum with precision higher than 10^100');
+        return new BigNum(val, precision);
+    }
+    /**
+     * Create a BigNum instance from a printed BigNum
+     * @param val
+     * @param precisionOverride
+     * @returns
+     */
+    static fromPrint(val, precisionShift) {
+        var _a;
+        // Handle empty number edge cases
+        if (!val)
+            return BigNum.from(numericConstants_1.ZERO, precisionShift);
+        if (!val.replace(BigNum.delim, ''))
+            return BigNum.from(numericConstants_1.ZERO, precisionShift);
+        const [leftSide, rightSide] = val.split(BigNum.delim);
+        const rawBn = new anchor_1.BN(`${leftSide !== null && leftSide !== void 0 ? leftSide : ''}${rightSide !== null && rightSide !== void 0 ? rightSide : ''}`);
+        const rightSideLength = (_a = rightSide === null || rightSide === void 0 ? void 0 : rightSide.length) !== null && _a !== void 0 ? _a : 0;
+        const totalShift = precisionShift
+            ? precisionShift.sub(new anchor_1.BN(rightSideLength))
+            : numericConstants_1.ZERO;
+        return BigNum.from(rawBn, precisionShift).shift(totalShift, true);
+    }
+    static max(a, b) {
+        return a.gt(b) ? a : b;
+    }
+    static min(a, b) {
+        return a.lt(b) ? a : b;
+    }
+    static zero(precision) {
+        return BigNum.from(0, precision);
+    }
+}
+exports.BigNum = BigNum;
+BigNum.delim = '.';
+BigNum.spacer = ',';

package/src/factory/oracleClient.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOracleClient = void 0;
+const types_1 = require("../types");
+const pythClient_1 = require("../oracles/pythClient");
+const switchboardClient_1 = require("../oracles/switchboardClient");
+const quoteAssetOracleClient_1 = require("../oracles/quoteAssetOracleClient");
+function getOracleClient(oracleSource, connection) {
+    if (types_1.isVariant(oracleSource, 'pyth')) {
+        return new pythClient_1.PythClient(connection);
+    }
+    if (types_1.isVariant(oracleSource, 'switchboard')) {
+        return new switchboardClient_1.SwitchboardClient(connection);
+    }
+    if (types_1.isVariant(oracleSource, 'quoteAsset')) {
+        return new quoteAssetOracleClient_1.QuoteAssetOracleClient();
+    }
+    throw new Error(`Unknown oracle source ${oracleSource}`);
+}
+exports.getOracleClient = getOracleClient;