@velocity-exchange/sdk 0.0.1

package/lib/browser/isomorphic/anchor29.js

@@ -0,0 +1,48 @@
+"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.Program = exports.AnchorProvider = exports.web3 = exports.BN = void 0;
+// eslint-disable-next-line no-restricted-imports -- browser stub: minimal BN without pulling full Anchor
+const bn_js_1 = __importDefault(require("bn.js"));
+const web3 = __importStar(require("@solana/web3.js"));
+exports.web3 = web3;
+class BN extends bn_js_1.default {
+}
+exports.BN = BN;
+class AnchorProvider {
+    constructor() {
+        throw new Error('Anchor (0.29) is not supported in the browser build. Use `VelocityCore` instead of `VelocityClient`.');
+    }
+}
+exports.AnchorProvider = AnchorProvider;
+class Program {
+    constructor() {
+        throw new Error('Anchor (0.29) Program is not supported in the browser build. Use `VelocityCore` instead of `VelocityClient`.');
+    }
+}
+exports.Program = Program;

package/lib/browser/isomorphic/grpc.browser.d.ts

@@ -0,0 +1 @@
+export declare function createClient(..._args: any): void;

package/lib/browser/isomorphic/grpc.browser.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = void 0;
+// Export a function to create a new Client instance
+function createClient(..._args) {
+    throw new Error('Only available in node context');
+}
+exports.createClient = createClient;

package/lib/browser/isomorphic/grpc.d.ts

@@ -0,0 +1 @@
+export declare function createClient(..._args: any): void;

package/lib/browser/isomorphic/grpc.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = void 0;
+// Export a function to create a new Client instance
+function createClient(..._args) {
+    throw new Error('Only available in node context');
+}
+exports.createClient = createClient;

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

@@ -0,0 +1,291 @@
+/// <reference types="bn.js" />
+import { AddressLookupTableAccount, Connection, PublicKey, TransactionInstruction, TransactionMessage, VersionedTransaction } from '@solana/web3.js';
+import { BN } from '../isomorphic/anchor';
+import { SwapMode } from '../swap/UnifiedSwapClient';
+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;
+    /**
+     *
+     * @type {string}
+     * @memberof QuoteResponse
+     */
+    errorCode?: string;
+}
+export declare const RECOMMENDED_JUPITER_API_VERSION = "/v1";
+/** @deprecated Use RECOMMENDED_JUPITER_API instead. lite-api.jup.ag requires migration to api.jup.ag with API key. */
+export declare const LEGACY_JUPITER_API = "https://lite-api.jup.ag/swap";
+export declare const RECOMMENDED_JUPITER_API = "https://api.jup.ag/swap";
+export declare class JupiterClient {
+    url: string;
+    connection: Connection;
+    lookupTableCahce: Map<string, AddressLookupTableAccount>;
+    private apiKey?;
+    /**
+     * Create a Jupiter client
+     * @param connection - Solana connection
+     * @param url - Optional custom API URL. Defaults to https://api.jup.ag/swap
+     * @param apiKey - API key for Jupiter API. Required for api.jup.ag (free tier available at https://portal.jup.ag)
+     */
+    constructor({ connection, url, apiKey, }: {
+        connection: Connection;
+        url?: string;
+        apiKey?: string;
+    });
+    /**
+     * Get the headers for API requests, including API key if configured
+     */
+    private getHeaders;
+    /**
+     * 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, autoSlippage, maxAutoSlippageBps, usdEstimate, }: {
+        inputMint: PublicKey;
+        outputMint: PublicKey;
+        amount: BN;
+        maxAccounts?: number;
+        slippageBps?: number;
+        swapMode?: SwapMode;
+        onlyDirectRoutes?: boolean;
+        excludeDexes?: string[];
+        autoSlippage?: boolean;
+        maxAutoSlippageBps?: number;
+        usdEstimate?: number;
+    }): 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>;
+    /**
+     * 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/browser/jupiter/jupiterClient.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JupiterClient = exports.RECOMMENDED_JUPITER_API = exports.LEGACY_JUPITER_API = exports.RECOMMENDED_JUPITER_API_VERSION = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+exports.RECOMMENDED_JUPITER_API_VERSION = '/v1';
+/** @deprecated Use RECOMMENDED_JUPITER_API instead. lite-api.jup.ag requires migration to api.jup.ag with API key. */
+exports.LEGACY_JUPITER_API = 'https://lite-api.jup.ag/swap';
+exports.RECOMMENDED_JUPITER_API = 'https://api.jup.ag/swap';
+class JupiterClient {
+    /**
+     * Create a Jupiter client
+     * @param connection - Solana connection
+     * @param url - Optional custom API URL. Defaults to https://api.jup.ag/swap
+     * @param apiKey - API key for Jupiter API. Required for api.jup.ag (free tier available at https://portal.jup.ag)
+     */
+    constructor({ connection, url, apiKey, }) {
+        this.lookupTableCahce = new Map();
+        this.connection = connection;
+        this.url = url !== null && url !== void 0 ? url : exports.RECOMMENDED_JUPITER_API;
+        this.apiKey = apiKey;
+    }
+    /**
+     * Get the headers for API requests, including API key if configured
+     */
+    getHeaders(contentType) {
+        const headers = {};
+        if (contentType) {
+            headers['Content-Type'] = contentType;
+        }
+        if (this.apiKey) {
+            headers['x-api-key'] = this.apiKey;
+        }
+        return headers;
+    }
+    /**
+     * 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, autoSlippage = false, maxAutoSlippageBps, usdEstimate, }) {
+        const params = new URLSearchParams({
+            inputMint: inputMint.toString(),
+            outputMint: outputMint.toString(),
+            amount: amount.toString(),
+            slippageBps: autoSlippage ? '0' : slippageBps.toString(),
+            swapMode,
+            onlyDirectRoutes: onlyDirectRoutes.toString(),
+            maxAccounts: maxAccounts.toString(),
+            autoSlippage: autoSlippage.toString(),
+            maxAutoSlippageBps: autoSlippage ? maxAutoSlippageBps.toString() : '0',
+            autoSlippageCollisionUsdValue: autoSlippage
+                ? usdEstimate.toString()
+                : '0',
+            ...(excludeDexes && { excludeDexes: excludeDexes.join(',') }),
+        });
+        if (swapMode === 'ExactOut') {
+            params.delete('maxAccounts');
+        }
+        const apiVersionParam = this.url === exports.RECOMMENDED_JUPITER_API || this.url === exports.LEGACY_JUPITER_API
+            ? exports.RECOMMENDED_JUPITER_API_VERSION
+            : '';
+        const headers = this.getHeaders();
+        const fetchOptions = Object.keys(headers).length > 0 ? { headers } : {};
+        const quote = await (await (0, node_fetch_1.default)(`${this.url}${apiVersionParam}/quote?${params.toString()}`, fetchOptions)).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 === exports.RECOMMENDED_JUPITER_API || this.url === exports.LEGACY_JUPITER_API
+            ? exports.RECOMMENDED_JUPITER_API_VERSION
+            : '';
+        const resp = await (await (0, node_fetch_1.default)(`${this.url}${apiVersionParam}/swap`, {
+            method: 'POST',
+            headers: this.getHeaders('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.');
+        }
+    }
+    /**
+     * 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/browser/keypair.d.ts

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

package/lib/browser/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/browser/marginCalculation.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="bn.js" />
+import { BN } from './isomorphic/anchor';
+import { MarketType } from './types';
+export type MarginCategory = 'Initial' | 'Maintenance' | 'Fill';
+export type MarginCalculationMode = {
+    type: 'Standard';
+} | {
+    type: 'Liquidation';
+};
+export declare class MarketIdentifier {
+    marketType: MarketType;
+    marketIndex: number;
+    private constructor();
+    static spot(marketIndex: number): MarketIdentifier;
+    static perp(marketIndex: number): MarketIdentifier;
+    equals(other: MarketIdentifier | undefined): boolean;
+}
+export declare class MarginContext {
+    marginType: MarginCategory;
+    mode: MarginCalculationMode;
+    strict: boolean;
+    ignoreInvalidDepositOracles: boolean;
+    isolatedMarginBuffers: Map<number, BN>;
+    crossMarginBuffer: BN;
+    private constructor();
+    static standard(marginType: MarginCategory): MarginContext;
+    static liquidation(crossMarginBuffer: BN, isolatedMarginBuffers: Map<number, BN>): MarginContext;
+    strictMode(strict: boolean): this;
+    ignoreInvalidDeposits(ignore: boolean): this;
+    setCrossMarginBuffer(crossMarginBuffer: BN): this;
+    setIsolatedMarginBuffers(isolatedMarginBuffers: Map<number, BN>): this;
+    setIsolatedMarginBuffer(marketIndex: number, isolatedMarginBuffer: BN): this;
+}
+export declare class IsolatedMarginCalculation {
+    marginRequirement: BN;
+    totalCollateral: BN;
+    totalCollateralBuffer: BN;
+    marginRequirementPlusBuffer: BN;
+    constructor();
+    getTotalCollateralPlusBuffer(): BN;
+    meetsMarginRequirement(): boolean;
+    meetsMarginRequirementWithBuffer(): boolean;
+    marginShortage(): BN;
+}
+export declare class MarginCalculation {
+    context: MarginContext;
+    totalCollateral: BN;
+    totalCollateralBuffer: BN;
+    marginRequirement: BN;
+    marginRequirementPlusBuffer: BN;
+    isolatedMarginCalculations: Map<number, IsolatedMarginCalculation>;
+    totalPerpLiabilityValue: BN;
+    constructor(context: MarginContext);
+    addCrossMarginTotalCollateral(delta: BN): void;
+    addCrossMarginRequirement(marginRequirement: BN, liabilityValue: BN): void;
+    addIsolatedMarginCalculation(marketIndex: number, depositValue: BN, pnl: BN, liabilityValue: BN, marginRequirement: BN): void;
+    addPerpLiabilityValue(perpLiabilityValue: BN): void;
+    getCrossTotalCollateralPlusBuffer(): BN;
+    meetsCrossMarginRequirement(): boolean;
+    meetsCrossMarginRequirementWithBuffer(): boolean;
+    meetsMarginRequirement(): boolean;
+    meetsMarginRequirementWithBuffer(): boolean;
+    getCrossFreeCollateral(): BN;
+    getIsolatedFreeCollateral(marketIndex: number): BN;
+    getIsolatedMarginCalculation(marketIndex: number): IsolatedMarginCalculation | undefined;
+    hasIsolatedMarginCalculation(marketIndex: number): boolean;
+}