@drift-labs/sdk 2.97.0-beta.9 → 2.98.0-beta.0

package/lib/node/jupiter/jupiterClient.d.ts

@@ -0,0 +1,296 @@
+/// <reference types="bn.js" />
+import { AddressLookupTableAccount, Connection, PublicKey, TransactionInstruction, TransactionMessage, VersionedTransaction } from '@solana/web3.js';
+import { BN } from '@coral-xyz/anchor';
+export type SwapMode = 'ExactIn' | 'ExactOut';
+export interface MarketInfo {
+    id: string;
+    inAmount: number;
+    inputMint: string;
+    label: string;
+    lpFee: Fee;
+    notEnoughLiquidity: boolean;
+    outAmount: number;
+    outputMint: string;
+    platformFee: Fee;
+    priceImpactPct: number;
+}
+export interface Fee {
+    amount: number;
+    mint: string;
+    pct: number;
+}
+export interface Route {
+    amount: number;
+    inAmount: number;
+    marketInfos: MarketInfo[];
+    otherAmountThreshold: number;
+    outAmount: number;
+    priceImpactPct: number;
+    slippageBps: number;
+    swapMode: SwapMode;
+}
+/**
+ *
+ * @export
+ * @interface RoutePlanStep
+ */
+export interface RoutePlanStep {
+    /**
+     *
+     * @type {SwapInfo}
+     * @memberof RoutePlanStep
+     */
+    swapInfo: SwapInfo;
+    /**
+     *
+     * @type {number}
+     * @memberof RoutePlanStep
+     */
+    percent: number;
+}
+export interface SwapInfo {
+    /**
+     *
+     * @type {string}
+     * @memberof SwapInfo
+     */
+    ammKey: string;
+    /**
+     *
+     * @type {string}
+     * @memberof SwapInfo
+     */
+    label?: string;
+    /**
+     *
+     * @type {string}
+     * @memberof SwapInfo
+     */
+    inputMint: string;
+    /**
+     *
+     * @type {string}
+     * @memberof SwapInfo
+     */
+    outputMint: string;
+    /**
+     *
+     * @type {string}
+     * @memberof SwapInfo
+     */
+    inAmount: string;
+    /**
+     *
+     * @type {string}
+     * @memberof SwapInfo
+     */
+    outAmount: string;
+    /**
+     *
+     * @type {string}
+     * @memberof SwapInfo
+     */
+    feeAmount: string;
+    /**
+     *
+     * @type {string}
+     * @memberof SwapInfo
+     */
+    feeMint: string;
+}
+/**
+ *
+ * @export
+ * @interface PlatformFee
+ */
+export interface PlatformFee {
+    /**
+     *
+     * @type {string}
+     * @memberof PlatformFee
+     */
+    amount?: string;
+    /**
+     *
+     * @type {number}
+     * @memberof PlatformFee
+     */
+    feeBps?: number;
+}
+/**
+ *
+ * @export
+ * @interface QuoteResponse
+ */
+export interface QuoteResponse {
+    /**
+     *
+     * @type {string}
+     * @memberof QuoteResponse
+     */
+    inputMint: string;
+    /**
+     *
+     * @type {string}
+     * @memberof QuoteResponse
+     */
+    inAmount: string;
+    /**
+     *
+     * @type {string}
+     * @memberof QuoteResponse
+     */
+    outputMint: string;
+    /**
+     *
+     * @type {string}
+     * @memberof QuoteResponse
+     */
+    outAmount: string;
+    /**
+     *
+     * @type {string}
+     * @memberof QuoteResponse
+     */
+    otherAmountThreshold: string;
+    /**
+     *
+     * @type {SwapMode}
+     * @memberof QuoteResponse
+     */
+    swapMode: SwapMode;
+    /**
+     *
+     * @type {number}
+     * @memberof QuoteResponse
+     */
+    slippageBps: number;
+    /**
+     *
+     * @type {PlatformFee}
+     * @memberof QuoteResponse
+     */
+    platformFee?: PlatformFee;
+    /**
+     *
+     * @type {string}
+     * @memberof QuoteResponse
+     */
+    priceImpactPct: string;
+    /**
+     *
+     * @type {Array<RoutePlanStep>}
+     * @memberof QuoteResponse
+     */
+    routePlan: Array<RoutePlanStep>;
+    /**
+     *
+     * @type {number}
+     * @memberof QuoteResponse
+     */
+    contextSlot?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof QuoteResponse
+     */
+    timeTaken?: number;
+    /**
+     *
+     * @type {string}
+     * @memberof QuoteResponse
+     */
+    error?: string;
+}
+export declare class JupiterClient {
+    url: string;
+    connection: Connection;
+    lookupTableCahce: Map<string, AddressLookupTableAccount>;
+    constructor({ connection, url }: {
+        connection: Connection;
+        url?: string;
+    });
+    /**
+     * ** @deprecated - use getQuote
+     * Get routes for a swap
+     * @param inputMint the mint of the input token
+     * @param outputMint the mint of the output token
+     * @param amount the amount of the input token
+     * @param slippageBps the slippage tolerance in basis points
+     * @param swapMode the swap mode (ExactIn or ExactOut)
+     * @param onlyDirectRoutes whether to only return direct routes
+     */
+    getRoutes({ inputMint, outputMint, amount, slippageBps, swapMode, onlyDirectRoutes, }: {
+        inputMint: PublicKey;
+        outputMint: PublicKey;
+        amount: BN;
+        slippageBps?: number;
+        swapMode?: SwapMode;
+        onlyDirectRoutes?: boolean;
+    }): Promise<Route[]>;
+    /**
+     * Get routes for a swap
+     * @param inputMint the mint of the input token
+     * @param outputMint the mint of the output token
+     * @param amount the amount of the input token
+     * @param slippageBps the slippage tolerance in basis points
+     * @param swapMode the swap mode (ExactIn or ExactOut)
+     * @param onlyDirectRoutes whether to only return direct routes
+     */
+    getQuote({ inputMint, outputMint, amount, maxAccounts, // 50 is an estimated amount with buffer
+    slippageBps, swapMode, onlyDirectRoutes, excludeDexes, }: {
+        inputMint: PublicKey;
+        outputMint: PublicKey;
+        amount: BN;
+        maxAccounts?: number;
+        slippageBps?: number;
+        swapMode?: SwapMode;
+        onlyDirectRoutes?: boolean;
+        excludeDexes?: string[];
+    }): Promise<QuoteResponse>;
+    /**
+     * Get a swap transaction for quote
+     * @param quoteResponse quote to perform swap
+     * @param userPublicKey the signer's wallet public key
+     * @param slippageBps the slippage tolerance in basis points
+     */
+    getSwap({ quote, userPublicKey, slippageBps, }: {
+        quote: QuoteResponse;
+        userPublicKey: PublicKey;
+        slippageBps?: number;
+    }): Promise<VersionedTransaction>;
+    /**
+     * ** @deprecated - use getSwap
+     * Get a swap transaction for a route
+     * @param route the route to perform swap
+     * @param userPublicKey the signer's wallet public key
+     * @param slippageBps the slippage tolerance in basis points
+     */
+    getSwapTransaction({ route, userPublicKey, slippageBps, }: {
+        route: Route;
+        userPublicKey: PublicKey;
+        slippageBps?: number;
+    }): Promise<VersionedTransaction>;
+    /**
+     * Get the transaction message and lookup tables for a transaction
+     * @param transaction
+     */
+    getTransactionMessageAndLookupTables({ transaction, }: {
+        transaction: VersionedTransaction;
+    }): Promise<{
+        transactionMessage: TransactionMessage;
+        lookupTables: AddressLookupTableAccount[];
+    }>;
+    getLookupTable(accountKey: PublicKey): Promise<AddressLookupTableAccount>;
+    /**
+     * Get the jupiter instructions from transaction by filtering out instructions to compute budget and associated token programs
+     * @param transactionMessage the transaction message
+     * @param inputMint the input mint
+     * @param outputMint the output mint
+     */
+    getJupiterInstructions({ transactionMessage, inputMint, outputMint, }: {
+        transactionMessage: TransactionMessage;
+        inputMint: PublicKey;
+        outputMint: PublicKey;
+    }): TransactionInstruction[];
+}

package/lib/node/jupiter/jupiterClient.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JupiterClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+class JupiterClient {
+    constructor({ connection, url }) {
+        this.lookupTableCahce = new Map();
+        this.connection = connection;
+        this.url = url !== null && url !== void 0 ? url : 'https://quote-api.jup.ag';
+    }
+    /**
+     * ** @deprecated - use getQuote
+     * Get routes for a swap
+     * @param inputMint the mint of the input token
+     * @param outputMint the mint of the output token
+     * @param amount the amount of the input token
+     * @param slippageBps the slippage tolerance in basis points
+     * @param swapMode the swap mode (ExactIn or ExactOut)
+     * @param onlyDirectRoutes whether to only return direct routes
+     */
+    async getRoutes({ inputMint, outputMint, amount, slippageBps = 50, swapMode = 'ExactIn', onlyDirectRoutes = false, }) {
+        const params = new URLSearchParams({
+            inputMint: inputMint.toString(),
+            outputMint: outputMint.toString(),
+            amount: amount.toString(),
+            slippageBps: slippageBps.toString(),
+            swapMode,
+            onlyDirectRoutes: onlyDirectRoutes.toString(),
+        }).toString();
+        const apiVersionParam = this.url === 'https://quote-api.jup.ag' ? '/v4' : '';
+        const { data: routes } = await (await (0, node_fetch_1.default)(`${this.url}${apiVersionParam}/quote?${params}`)).json();
+        return routes;
+    }
+    /**
+     * Get routes for a swap
+     * @param inputMint the mint of the input token
+     * @param outputMint the mint of the output token
+     * @param amount the amount of the input token
+     * @param slippageBps the slippage tolerance in basis points
+     * @param swapMode the swap mode (ExactIn or ExactOut)
+     * @param onlyDirectRoutes whether to only return direct routes
+     */
+    async getQuote({ inputMint, outputMint, amount, maxAccounts = 50, // 50 is an estimated amount with buffer
+    slippageBps = 50, swapMode = 'ExactIn', onlyDirectRoutes = false, excludeDexes, }) {
+        const params = new URLSearchParams({
+            inputMint: inputMint.toString(),
+            outputMint: outputMint.toString(),
+            amount: amount.toString(),
+            slippageBps: slippageBps.toString(),
+            swapMode,
+            onlyDirectRoutes: onlyDirectRoutes.toString(),
+            maxAccounts: maxAccounts.toString(),
+            ...(excludeDexes && { excludeDexes: excludeDexes.join(',') }),
+        });
+        if (swapMode === 'ExactOut') {
+            params.delete('maxAccounts');
+        }
+        const apiVersionParam = this.url === 'https://quote-api.jup.ag' ? '/v6' : '';
+        const quote = await (await (0, node_fetch_1.default)(`${this.url}${apiVersionParam}/quote?${params.toString()}`)).json();
+        return quote;
+    }
+    /**
+     * Get a swap transaction for quote
+     * @param quoteResponse quote to perform swap
+     * @param userPublicKey the signer's wallet public key
+     * @param slippageBps the slippage tolerance in basis points
+     */
+    async getSwap({ quote, userPublicKey, slippageBps = 50, }) {
+        var _a;
+        if (!quote) {
+            throw new Error('Jupiter swap quote not provided. Please try again.');
+        }
+        const apiVersionParam = this.url === 'https://quote-api.jup.ag' ? '/v6' : '';
+        const resp = await (await (0, node_fetch_1.default)(`${this.url}${apiVersionParam}/swap`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                quoteResponse: quote,
+                userPublicKey,
+                slippageBps,
+            }),
+        })).json();
+        if (!('swapTransaction' in resp)) {
+            throw new Error(`swapTransaction not found, error from Jupiter: ${resp.error} ${(_a = ', ' + resp.message) !== null && _a !== void 0 ? _a : ''}`);
+        }
+        const { swapTransaction } = resp;
+        try {
+            const swapTransactionBuf = Buffer.from(swapTransaction, 'base64');
+            return web3_js_1.VersionedTransaction.deserialize(swapTransactionBuf);
+        }
+        catch (err) {
+            throw new Error('Something went wrong with creating the Jupiter swap transaction. Please try again.');
+        }
+    }
+    /**
+     * ** @deprecated - use getSwap
+     * Get a swap transaction for a route
+     * @param route the route to perform swap
+     * @param userPublicKey the signer's wallet public key
+     * @param slippageBps the slippage tolerance in basis points
+     */
+    async getSwapTransaction({ route, userPublicKey, slippageBps = 50, }) {
+        const apiVersionParam = this.url === 'https://quote-api.jup.ag' ? '/v4' : '';
+        const resp = await (await (0, node_fetch_1.default)(`${this.url}${apiVersionParam}/swap`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                route,
+                userPublicKey,
+                slippageBps,
+            }),
+        })).json();
+        const { swapTransaction } = resp;
+        const swapTransactionBuf = Buffer.from(swapTransaction, 'base64');
+        return web3_js_1.VersionedTransaction.deserialize(swapTransactionBuf);
+    }
+    /**
+     * Get the transaction message and lookup tables for a transaction
+     * @param transaction
+     */
+    async getTransactionMessageAndLookupTables({ transaction, }) {
+        const message = transaction.message;
+        const lookupTables = (await Promise.all(message.addressTableLookups.map(async (lookup) => {
+            return await this.getLookupTable(lookup.accountKey);
+        }))).filter((lookup) => lookup);
+        const transactionMessage = web3_js_1.TransactionMessage.decompile(message, {
+            addressLookupTableAccounts: lookupTables,
+        });
+        return {
+            transactionMessage,
+            lookupTables,
+        };
+    }
+    async getLookupTable(accountKey) {
+        if (this.lookupTableCahce.has(accountKey.toString())) {
+            return this.lookupTableCahce.get(accountKey.toString());
+        }
+        return (await this.connection.getAddressLookupTable(accountKey)).value;
+    }
+    /**
+     * Get the jupiter instructions from transaction by filtering out instructions to compute budget and associated token programs
+     * @param transactionMessage the transaction message
+     * @param inputMint the input mint
+     * @param outputMint the output mint
+     */
+    getJupiterInstructions({ transactionMessage, inputMint, outputMint, }) {
+        return transactionMessage.instructions.filter((instruction) => {
+            if (instruction.programId.toString() ===
+                'ComputeBudget111111111111111111111111111111') {
+                return false;
+            }
+            if (instruction.programId.toString() ===
+                'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA') {
+                return false;
+            }
+            if (instruction.programId.toString() === '11111111111111111111111111111111') {
+                return false;
+            }
+            if (instruction.programId.toString() ===
+                'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL') {
+                const mint = instruction.keys[3].pubkey;
+                if (mint.equals(inputMint) || mint.equals(outputMint)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+}
+exports.JupiterClient = JupiterClient;

package/lib/node/keypair.d.ts

@@ -0,0 +1,2 @@
+import { Keypair } from '@solana/web3.js';
+export declare function loadKeypair(privateKey: string): Keypair;

package/lib/node/keypair.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadKeypair = void 0;
+const fs_1 = __importDefault(require("fs"));
+const bs58_1 = __importDefault(require("bs58"));
+const web3_js_1 = require("@solana/web3.js");
+function loadKeypair(privateKey) {
+    // try to load privateKey as a filepath
+    let loadedKey;
+    if (fs_1.default.existsSync(privateKey)) {
+        privateKey = fs_1.default.readFileSync(privateKey).toString();
+    }
+    if (privateKey.includes('[') && privateKey.includes(']')) {
+        loadedKey = Uint8Array.from(JSON.parse(privateKey));
+    }
+    else if (privateKey.includes(',')) {
+        loadedKey = Uint8Array.from(privateKey.split(',').map((val) => Number(val)));
+    }
+    else {
+        privateKey = privateKey.replace(/\s/g, '');
+        loadedKey = new Uint8Array(bs58_1.default.decode(privateKey));
+    }
+    return web3_js_1.Keypair.fromSecretKey(Uint8Array.from(loadedKey));
+}
+exports.loadKeypair = loadKeypair;

package/lib/node/marinade/index.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="bn.js" />
+import { AnchorProvider, BN, Program } from '@coral-xyz/anchor';
+import { MarinadeFinance } from './types';
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+export declare function getMarinadeFinanceProgram(provider: AnchorProvider): Program<MarinadeFinance>;
+export declare function getMarinadeDepositIx({ program, amount, mSOLAccount, transferFrom, }: {
+    amount: BN;
+    mSOLAccount: PublicKey;
+    transferFrom: PublicKey;
+    program: Program<MarinadeFinance>;
+}): Promise<TransactionInstruction>;
+export declare function getMarinadeMSolPrice(program: Program<MarinadeFinance>): Promise<number>;

package/lib/node/marinade/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMarinadeMSolPrice = exports.getMarinadeDepositIx = exports.getMarinadeFinanceProgram = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const types_1 = require("./types");
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const marinadeFinanceProgramId = new web3_js_1.PublicKey('MarBmsSgKXdrN1egZf5sqe1TMai9K1rChYNDJgjq7aD');
+function getMarinadeFinanceProgram(provider) {
+    return new anchor_1.Program(types_1.IDL, marinadeFinanceProgramId, provider);
+}
+exports.getMarinadeFinanceProgram = getMarinadeFinanceProgram;
+function getMarinadeDepositIx({ program, amount, mSOLAccount, transferFrom, }) {
+    return program.methods
+        .deposit(amount)
+        .accountsStrict({
+        reservePda: new web3_js_1.PublicKey('Du3Ysj1wKbxPKkuPPnvzQLQh8oMSVifs3jGZjJWXFmHN'),
+        state: new web3_js_1.PublicKey('8szGkuLTAux9XMgZ2vtY39jVSowEcpBfFfD8hXSEqdGC'),
+        msolMint: new web3_js_1.PublicKey('mSoLzYCxHdYgdzU16g5QSh3i5K3z3KZK7ytfqcJm7So'),
+        msolMintAuthority: new web3_js_1.PublicKey('3JLPCS1qM2zRw3Dp6V4hZnYHd4toMNPkNesXdX9tg6KM'),
+        liqPoolMsolLegAuthority: new web3_js_1.PublicKey('EyaSjUtSgo9aRD1f8LWXwdvkpDTmXAW54yoSHZRF14WL'),
+        liqPoolMsolLeg: new web3_js_1.PublicKey('7GgPYjS5Dza89wV6FpZ23kUJRG5vbQ1GM25ezspYFSoE'),
+        liqPoolSolLegPda: new web3_js_1.PublicKey('UefNb6z6yvArqe4cJHTXCqStRsKmWhGxnZzuHbikP5Q'),
+        mintTo: mSOLAccount,
+        transferFrom,
+        systemProgram: web3_js_1.SystemProgram.programId,
+        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+    })
+        .instruction();
+}
+exports.getMarinadeDepositIx = getMarinadeDepositIx;
+async function getMarinadeMSolPrice(program) {
+    const state = await program.account.state.fetch(new web3_js_1.PublicKey('8szGkuLTAux9XMgZ2vtY39jVSowEcpBfFfD8hXSEqdGC'));
+    return state.msolPrice.toNumber() / 4294967296;
+}
+exports.getMarinadeMSolPrice = getMarinadeMSolPrice;