@velocity-exchange/sdk 0.0.1

package/lib/browser/swift/signedMsgUserAccountSubscriber.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
+import { SignedMsgOrderId, SignedMsgUserOrdersAccount } from '../types';
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { ResubOpts } from '../accounts/types';
+import { VelocityClient } from '../velocityClient';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+export interface SignedMsgUserOrdersAccountSubscriberEvents {
+    onAccountUpdate: (activeSignedMsgOrderIds: SignedMsgOrderId[], authorityPubkey: PublicKey, slot: number) => void;
+    newSignedMsgOrderIds: (newSignedMsgOrderIds: SignedMsgOrderId[], authorityPubkey: PublicKey, slot: number) => void;
+}
+export declare class SignedMsgUserOrdersAccountSubscriber {
+    protected driftClient: VelocityClient;
+    protected commitment: Commitment;
+    protected resubOpts?: ResubOpts;
+    protected resyncTimeoutId?: ReturnType<typeof setTimeout>;
+    protected resyncIntervalMs?: number;
+    protected decodeFn: (name: string, data: Buffer) => SignedMsgUserOrdersAccount;
+    signedMsgUserOrderAccounts: Map<string, {
+        slot: number;
+        signedMsgUserOrdersAccount: SignedMsgUserOrdersAccount;
+    }>;
+    mostRecentSlot: number;
+    fetchPromise?: Promise<void>;
+    fetchPromiseResolver: () => void;
+    protected subscriber: WebSocketProgramAccountSubscriber<SignedMsgUserOrdersAccount>;
+    eventEmitter: StrictEventEmitter<EventEmitter, SignedMsgUserOrdersAccountSubscriberEvents>;
+    constructor({ driftClient, commitment, resubOpts, decodeFn, resyncIntervalMs, }: {
+        driftClient: VelocityClient;
+        commitment?: Commitment;
+        resubOpts?: ResubOpts;
+        decodeFn?: (name: string, data: Buffer) => SignedMsgUserOrdersAccount;
+        resyncIntervalMs?: number;
+    });
+    subscribe(): Promise<void>;
+    fetch(): Promise<void>;
+    tryUpdateSignedMsgUserOrdersAccount(data: Buffer | SignedMsgUserOrdersAccount, dataType: 'buffer' | 'decoded', slot: number, skipEventEmitting?: boolean): void;
+    unsubscribe(): Promise<void>;
+}

package/lib/browser/swift/signedMsgUserAccountSubscriber.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignedMsgUserOrdersAccountSubscriber = void 0;
+const memcmp_1 = require("../memcmp");
+const webSocketProgramAccountSubscriber_1 = require("../accounts/webSocketProgramAccountSubscriber");
+const events_1 = require("events");
+class SignedMsgUserOrdersAccountSubscriber {
+    constructor({ driftClient, commitment, resubOpts, decodeFn, resyncIntervalMs, }) {
+        this.signedMsgUserOrderAccounts = new Map();
+        this.commitment = commitment !== null && commitment !== void 0 ? commitment : 'confirmed';
+        this.resubOpts = resubOpts;
+        this.driftClient = driftClient;
+        this.decodeFn =
+            decodeFn !== null && decodeFn !== void 0 ? decodeFn : this.driftClient.program.account.signedMsgUserOrders.coder.accounts.decodeUnchecked.bind(this.driftClient.program.account.signedMsgUserOrders.coder
+                .accounts);
+        this.resyncIntervalMs = resyncIntervalMs;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.resubOpts = resubOpts;
+    }
+    async subscribe() {
+        if (!this.subscriber) {
+            const filters = [(0, memcmp_1.getSignedMsgUserOrdersFilter)()];
+            this.subscriber =
+                new webSocketProgramAccountSubscriber_1.WebSocketProgramAccountSubscriber('SingedMsgUserOrdersAccountMap', 'signedMsgUserOrders', this.driftClient.program, this.decodeFn, {
+                    filters,
+                    commitment: this.commitment,
+                }, this.resubOpts);
+        }
+        await this.subscriber.subscribe((_accountId, account, context) => {
+            this.tryUpdateSignedMsgUserOrdersAccount(account, 'decoded', context.slot);
+        });
+        await this.fetch();
+        if (this.resyncIntervalMs) {
+            const recursiveResync = () => {
+                this.resyncTimeoutId = setTimeout(() => {
+                    this.fetch()
+                        .catch((e) => {
+                        console.error('Failed to resync in OrderSubscriber');
+                        console.log(e);
+                    })
+                        .finally(() => {
+                        if (!this.resyncTimeoutId)
+                            return;
+                        recursiveResync();
+                    });
+                }, this.resyncIntervalMs);
+            };
+            recursiveResync();
+        }
+    }
+    async fetch() {
+        if (this.fetchPromise) {
+            return this.fetchPromise;
+        }
+        this.fetchPromise = new Promise((resolver) => {
+            this.fetchPromiseResolver = resolver;
+        });
+        const skipEventEmitting = this.signedMsgUserOrderAccounts.size === 0;
+        try {
+            const rpcResponseAndContext = await this.driftClient.connection.getProgramAccounts(this.driftClient.program.programId, {
+                commitment: this.commitment,
+                filters: [(0, memcmp_1.getSignedMsgUserOrdersFilter)()],
+                encoding: 'base64',
+                withContext: true,
+            });
+            const slot = rpcResponseAndContext.context.slot;
+            for (const programAccount of rpcResponseAndContext.value) {
+                this.tryUpdateSignedMsgUserOrdersAccount(programAccount.account.data, 'buffer', slot, skipEventEmitting);
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+        finally {
+            this.fetchPromiseResolver();
+            this.fetchPromise = undefined;
+        }
+    }
+    tryUpdateSignedMsgUserOrdersAccount(data, dataType, slot, skipEventEmitting = false) {
+        var _a;
+        if (!this.mostRecentSlot || slot > this.mostRecentSlot) {
+            this.mostRecentSlot = slot;
+        }
+        const signedMsgUserOrdersAccount = dataType === 'buffer'
+            ? this.decodeFn('signedMsgUserOrders', data)
+            : data;
+        const key = signedMsgUserOrdersAccount.authorityPubkey.toBase58();
+        const slotAndSignedMsgUserOrdersAccount = this.signedMsgUserOrderAccounts.get(key);
+        if (!slotAndSignedMsgUserOrdersAccount ||
+            slotAndSignedMsgUserOrdersAccount.slot <= slot) {
+            if (!skipEventEmitting) {
+                this.eventEmitter.emit('onAccountUpdate', signedMsgUserOrdersAccount.signedMsgOrderData.filter((signedMsgOrderId) => signedMsgOrderId.orderId !== 0), signedMsgUserOrdersAccount.authorityPubkey, slot);
+            }
+            const existingSignedMsgOrderIds = (_a = slotAndSignedMsgUserOrdersAccount === null || slotAndSignedMsgUserOrdersAccount === void 0 ? void 0 : slotAndSignedMsgUserOrdersAccount.signedMsgUserOrdersAccount.signedMsgOrderData.map((signedMsgOrderId) => signedMsgOrderId.orderId)) !== null && _a !== void 0 ? _a : [];
+            const newSignedMsgOrderIds = signedMsgUserOrdersAccount.signedMsgOrderData.filter((signedMsgOrderId) => !existingSignedMsgOrderIds.includes(signedMsgOrderId.orderId) &&
+                signedMsgOrderId.orderId !== 0);
+            if (newSignedMsgOrderIds.length > 0 && !skipEventEmitting) {
+                this.eventEmitter.emit('newSignedMsgOrderIds', newSignedMsgOrderIds, signedMsgUserOrdersAccount.authorityPubkey, slot);
+            }
+            this.signedMsgUserOrderAccounts.set(key, {
+                slot,
+                signedMsgUserOrdersAccount,
+            });
+        }
+    }
+    async unsubscribe() {
+        if (!this.subscriber)
+            return;
+        await this.subscriber.unsubscribe();
+        this.subscriber = undefined;
+        if (this.resyncTimeoutId !== undefined) {
+            clearTimeout(this.resyncTimeoutId);
+            this.resyncTimeoutId = undefined;
+        }
+    }
+}
+exports.SignedMsgUserOrdersAccountSubscriber = SignedMsgUserOrdersAccountSubscriber;

package/lib/browser/swift/swiftOrderSubscriber.d.ts

@@ -0,0 +1,63 @@
+import { VelocityClient } from '../velocityClient';
+import { VelocityEnv } from '../config';
+import { OptionalOrderParams, SignedMsgOrderParamsDelegateMessage, SignedMsgOrderParamsMessage, UserAccount } from '../types';
+import { Keypair, TransactionInstruction } from '@solana/web3.js';
+export interface AccountGetter {
+    mustGetUserAccount(publicKey: string): Promise<UserAccount>;
+}
+export type SwiftOrderSubscriberConfig = {
+    driftClient: VelocityClient;
+    userAccountGetter?: AccountGetter;
+    driftEnv: VelocityEnv;
+    endpoint?: string;
+    marketIndexes: number[];
+    /**
+        In the future, this will be used for verifying $DRIFT stake as we add
+        authentication for delegate signers
+        For now, pass a new keypair or a keypair to an empty wallet
+    */
+    keypair: Keypair;
+};
+/**
+ * Swift order message received from WebSocket
+ */
+export interface SwiftOrderMessage {
+    /** Hex string of the order message */
+    order_message: string;
+    /** Base58 string of taker authority */
+    taker_authority: string;
+    /** Base58 string of signing authority */
+    signing_authority: string;
+    /** Base64 string containing the order signature */
+    order_signature: string;
+    /** Swift order UUID */
+    uuid: string;
+    /** Whether the order auction params are likely to be sanitized on submission to program */
+    will_sanitize?: boolean;
+    /** Base64 string of a prerequisite deposit tx. The swift order_message should be bundled
+     * after the deposit when present  */
+    depositTx?: string;
+    /** order market index */
+    market_index: number;
+    /** order timestamp in unix ms */
+    ts: number;
+}
+export declare class SwiftOrderSubscriber {
+    private config;
+    private heartbeatTimeout;
+    private readonly heartbeatIntervalMs;
+    private ws;
+    private driftClient;
+    userAccountGetter?: AccountGetter;
+    onOrder: (orderMessageRaw: SwiftOrderMessage, signedMessage: SignedMsgOrderParamsMessage | SignedMsgOrderParamsDelegateMessage, isDelegateSigner?: boolean) => Promise<void>;
+    subscribed: boolean;
+    constructor(config: SwiftOrderSubscriberConfig);
+    unsubscribe(): void;
+    getSymbolForMarketIndex(marketIndex: number): string;
+    generateChallengeResponse(nonce: string): string;
+    handleAuthMessage(message: any): void;
+    subscribe(onOrder: (orderMessageRaw: SwiftOrderMessage, signedMessage: SignedMsgOrderParamsMessage | SignedMsgOrderParamsDelegateMessage, isDelegateSigner?: boolean) => Promise<void>, acceptSanitized?: boolean, acceptDepositTrade?: boolean): Promise<void>;
+    getPlaceAndMakeSignedMsgOrderIxs(orderMessageRaw: SwiftOrderMessage, signedMsgOrderParamsMessage: SignedMsgOrderParamsMessage | SignedMsgOrderParamsDelegateMessage, makerOrderParams: OptionalOrderParams): Promise<TransactionInstruction[]>;
+    private startHeartbeatTimer;
+    private reconnect;
+}

package/lib/browser/swift/swiftOrderSubscriber.js

@@ -0,0 +1,187 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwiftOrderSubscriber = void 0;
+const perpMarkets_1 = require("../constants/perpMarkets");
+const pda_1 = require("../addresses/pda");
+const types_1 = require("../types");
+const web3_js_1 = require("@solana/web3.js");
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const tweetnacl_util_1 = require("tweetnacl-util");
+const ws_1 = __importDefault(require("ws"));
+const sha256_1 = require("@noble/hashes/sha256");
+class SwiftOrderSubscriber {
+    constructor(config) {
+        this.config = config;
+        this.heartbeatTimeout = null;
+        this.heartbeatIntervalMs = 60000;
+        this.ws = null;
+        this.subscribed = false;
+        this.driftClient = config.driftClient;
+        this.userAccountGetter = config.userAccountGetter;
+    }
+    unsubscribe() {
+        if (this.subscribed) {
+            this.ws.removeAllListeners();
+            this.ws.terminate();
+            this.ws = null;
+            this.subscribed = false;
+        }
+    }
+    getSymbolForMarketIndex(marketIndex) {
+        const markets = this.config.driftEnv === 'devnet'
+            ? perpMarkets_1.DevnetPerpMarkets
+            : perpMarkets_1.MainnetPerpMarkets;
+        return markets[marketIndex].symbol;
+    }
+    generateChallengeResponse(nonce) {
+        const messageBytes = (0, tweetnacl_util_1.decodeUTF8)(nonce);
+        const signature = tweetnacl_1.default.sign.detached(messageBytes, this.config.keypair.secretKey);
+        const signatureBase64 = Buffer.from(signature).toString('base64');
+        return signatureBase64;
+    }
+    handleAuthMessage(message) {
+        var _a, _b;
+        if (message['channel'] === 'auth' && message['nonce'] != null) {
+            const signatureBase64 = this.generateChallengeResponse(message['nonce']);
+            (_a = this.ws) === null || _a === void 0 ? void 0 : _a.send(JSON.stringify({
+                pubkey: this.config.keypair.publicKey.toBase58(),
+                signature: signatureBase64,
+            }));
+        }
+        if (message['channel'] === 'auth' &&
+            ((_b = message['message']) === null || _b === void 0 ? void 0 : _b.toLowerCase()) === 'authenticated') {
+            this.subscribed = true;
+            this.config.marketIndexes.forEach(async (marketIndex) => {
+                var _a;
+                (_a = this.ws) === null || _a === void 0 ? void 0 : _a.send(JSON.stringify({
+                    action: 'subscribe',
+                    market_type: 'perp',
+                    market_name: this.getSymbolForMarketIndex(marketIndex),
+                }));
+                await new Promise((resolve) => setTimeout(resolve, 100));
+            });
+        }
+    }
+    async subscribe(onOrder, acceptSanitized = false, acceptDepositTrade = false) {
+        this.onOrder = onOrder;
+        const endpoint = this.config.endpoint || this.config.driftEnv === 'devnet'
+            ? 'wss://master.swift.drift.trade/ws'
+            : 'wss://swift.drift.trade/ws';
+        const ws = new ws_1.default(endpoint + '?pubkey=' + this.config.keypair.publicKey.toBase58());
+        this.ws = ws;
+        ws.on('open', async () => {
+            console.log('Connected to the server');
+            ws.on('message', async (data) => {
+                const message = JSON.parse(data.toString());
+                this.startHeartbeatTimer();
+                if (message['channel'] === 'auth') {
+                    this.handleAuthMessage(message);
+                }
+                if (message['order']) {
+                    const order = message['order'];
+                    // ignore likely sanitized orders by default
+                    if (order.will_sanitize === true && !acceptSanitized) {
+                        return;
+                    }
+                    // order has a prerequisite deposit tx attached
+                    if (message['deposit']) {
+                        order.depositTx = message['deposit'];
+                        if (!acceptDepositTrade) {
+                            return;
+                        }
+                    }
+                    const signedMsgOrderParamsBuf = Buffer.from(order.order_message, 'hex');
+                    const isDelegateSigner = signedMsgOrderParamsBuf
+                        .slice(0, 8)
+                        .equals(Uint8Array.from(Buffer.from((0, sha256_1.sha256)('global' + ':' + 'SignedMsgOrderParamsDelegateMessage')).slice(0, 8)));
+                    const signedMessage = this.driftClient.decodeSignedMsgOrderParamsMessage(signedMsgOrderParamsBuf, isDelegateSigner);
+                    if (!signedMessage.signedMsgOrderParams.price) {
+                        console.error(`order has no price: ${JSON.stringify(signedMessage.signedMsgOrderParams)}`);
+                        return;
+                    }
+                    onOrder(order, signedMessage, isDelegateSigner);
+                }
+            });
+            ws.on('close', () => {
+                console.log('Disconnected from the server');
+                this.reconnect();
+            });
+            ws.on('error', (error) => {
+                console.error('WebSocket error:', error);
+                this.reconnect();
+            });
+        });
+        ws.on('unexpected-response', async (request, response) => {
+            console.error('Unexpected response, reconnecting in 5s:', response.statusCode);
+            setTimeout(() => {
+                if (this.heartbeatTimeout)
+                    clearTimeout(this.heartbeatTimeout);
+                this.reconnect();
+            }, 5000);
+        });
+        ws.on('error', async (request, response) => {
+            console.error('WS closed from error, reconnecting in 1s:', response.statusCode);
+            setTimeout(() => {
+                if (this.heartbeatTimeout)
+                    clearTimeout(this.heartbeatTimeout);
+                this.reconnect();
+            }, 1000);
+        });
+    }
+    async getPlaceAndMakeSignedMsgOrderIxs(orderMessageRaw, signedMsgOrderParamsMessage, makerOrderParams) {
+        if (!this.userAccountGetter) {
+            throw new Error('userAccountGetter must be set to use this function');
+        }
+        const signedMsgOrderParamsBuf = Buffer.from(orderMessageRaw.order_message, 'hex');
+        const isDelegateSigner = signedMsgOrderParamsBuf
+            .slice(0, 8)
+            .equals(Uint8Array.from(Buffer.from((0, sha256_1.sha256)('global' + ':' + 'SignedMsgOrderParamsDelegateMessage')).slice(0, 8)));
+        const signedMessage = this.driftClient.decodeSignedMsgOrderParamsMessage(signedMsgOrderParamsBuf, isDelegateSigner);
+        const takerAuthority = new web3_js_1.PublicKey(orderMessageRaw.taker_authority);
+        const signingAuthority = new web3_js_1.PublicKey(orderMessageRaw.signing_authority);
+        const takerUserPubkey = isDelegateSigner
+            ? signedMessage.takerPubkey
+            : await (0, pda_1.getUserAccountPublicKey)(this.driftClient.program.programId, takerAuthority, signedMessage.subAccountId);
+        const takerUserAccount = await this.userAccountGetter.mustGetUserAccount(takerUserPubkey.toString());
+        const ixs = await this.driftClient.getPlaceAndMakeSignedMsgPerpOrderIxs({
+            orderParams: signedMsgOrderParamsBuf,
+            signature: Buffer.from(orderMessageRaw.order_signature, 'base64'),
+        }, (0, tweetnacl_util_1.decodeUTF8)(orderMessageRaw.uuid), {
+            taker: takerUserPubkey,
+            takerUserAccount,
+            takerStats: (0, pda_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, takerUserAccount.authority),
+            signingAuthority: signingAuthority,
+        }, Object.assign({}, makerOrderParams, {
+            postOnly: types_1.PostOnlyParams.MUST_POST_ONLY,
+            immediateOrCancel: true,
+            marketType: types_1.MarketType.PERP,
+        }));
+        return ixs;
+    }
+    startHeartbeatTimer() {
+        if (this.heartbeatTimeout) {
+            clearTimeout(this.heartbeatTimeout);
+        }
+        if (!this.onOrder) {
+            throw new Error('onOrder callback function must be set');
+        }
+        this.heartbeatTimeout = setTimeout(() => {
+            console.warn('No heartbeat received within 30 seconds, reconnecting...');
+            this.reconnect();
+        }, this.heartbeatIntervalMs);
+    }
+    reconnect() {
+        if (this.ws) {
+            this.ws.removeAllListeners();
+            this.ws.terminate();
+        }
+        console.log('Reconnecting to WebSocket...');
+        setTimeout(() => {
+            this.subscribe(this.onOrder);
+        }, 1000);
+    }
+}
+exports.SwiftOrderSubscriber = SwiftOrderSubscriber;

package/lib/browser/testClient.d.ts

@@ -0,0 +1,8 @@
+import { AdminClient } from './adminClient';
+import { ConfirmOptions, Signer, Transaction } from '@solana/web3.js';
+import { TxSigAndSlot } from './tx/types';
+import { VelocityClientConfig } from './velocityClientConfig';
+export declare class TestClient extends AdminClient {
+    constructor(config: VelocityClientConfig);
+    sendTransaction(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
+}

package/lib/browser/testClient.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestClient = void 0;
+const adminClient_1 = require("./adminClient");
+class TestClient extends adminClient_1.AdminClient {
+    constructor(config) {
+        config.txVersion = 'legacy';
+        if (config.accountSubscription.type !== 'polling') {
+            throw new Error('Test client must be polling');
+        }
+        super(config);
+    }
+    async sendTransaction(tx, additionalSigners, opts, preSigned) {
+        const { txSig, slot } = await super.sendTransaction(tx, additionalSigners, opts, preSigned);
+        let lastFetchedSlot = this.accountSubscriber.accountLoader.mostRecentSlot;
+        await this.fetchAccounts();
+        while (lastFetchedSlot < slot) {
+            await this.fetchAccounts();
+            lastFetchedSlot = this.accountSubscriber.accountLoader.mostRecentSlot;
+        }
+        return { txSig, slot };
+    }
+}
+exports.TestClient = TestClient;

package/lib/browser/titan/titanClient.d.ts

@@ -0,0 +1,90 @@
+/// <reference types="bn.js" />
+import { Connection, PublicKey, TransactionMessage, AddressLookupTableAccount, TransactionInstruction } from '@solana/web3.js';
+import { BN } from '../isomorphic/anchor';
+export declare enum SwapMode {
+    ExactIn = "ExactIn",
+    ExactOut = "ExactOut"
+}
+export interface QuoteResponse {
+    inputMint: string;
+    inAmount: string;
+    outputMint: string;
+    outAmount: string;
+    swapMode: SwapMode;
+    slippageBps: number;
+    platformFee?: {
+        amount?: string;
+        feeBps?: number;
+    };
+    routePlan: Array<{
+        swapInfo: any;
+        percent: number;
+    }>;
+    contextSlot?: number;
+    timeTaken?: number;
+    error?: string;
+    errorCode?: string;
+}
+export declare class TitanClient {
+    authToken: string;
+    url: string;
+    connection: Connection;
+    proxyUrl?: string;
+    private lastQuoteData?;
+    private lastQuoteParams?;
+    constructor({ connection, authToken, url, proxyUrl, }: {
+        connection: Connection;
+        authToken: string;
+        url?: string;
+        proxyUrl?: string;
+    });
+    private buildParams;
+    /**
+     * Get routes for a swap
+     */
+    getQuote({ inputMint, outputMint, amount, userPublicKey, maxAccounts, // 50 is an estimated amount with buffer
+    slippageBps, swapMode, onlyDirectRoutes, excludeDexes, sizeConstraint, accountsLimitWritable, }: {
+        inputMint: PublicKey;
+        outputMint: PublicKey;
+        amount: BN;
+        userPublicKey: PublicKey;
+        maxAccounts?: number;
+        slippageBps?: number;
+        swapMode?: string;
+        onlyDirectRoutes?: boolean;
+        excludeDexes?: string[];
+        sizeConstraint?: number;
+        accountsLimitWritable?: number;
+    }): Promise<QuoteResponse>;
+    /**
+     * Get a swap transaction for quote
+     */
+    getSwap({ userPublicKey, }: {
+        inputMint?: PublicKey;
+        outputMint?: PublicKey;
+        amount?: BN;
+        userPublicKey: PublicKey;
+        maxAccounts?: number;
+        slippageBps?: number;
+        swapMode?: SwapMode;
+        onlyDirectRoutes?: boolean;
+        excludeDexes?: string[];
+        sizeConstraint?: number;
+        accountsLimitWritable?: number;
+    }): Promise<{
+        transactionMessage: TransactionMessage;
+        lookupTables: AddressLookupTableAccount[];
+    }>;
+    /**
+     * Get the titan 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
+     */
+    getTitanInstructions({ transactionMessage, inputMint, outputMint, }: {
+        transactionMessage: TransactionMessage;
+        inputMint: PublicKey;
+        outputMint: PublicKey;
+    }): TransactionInstruction[];
+    private getTransactionMessageAndLookupTables;
+}