@velocity-exchange/sdk 0.0.1

package/lib/browser/pyth/utils.d.ts

@@ -0,0 +1,2 @@
+import { PublicKey } from '@solana/web3.js';
+export declare const getGuardianSetPda: (guardianSetIndex: number, wormholeProgramId: PublicKey) => PublicKey;

package/lib/browser/pyth/utils.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGuardianSetPda = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const getGuardianSetPda = (guardianSetIndex, wormholeProgramId) => {
+    const guardianSetIndexBuf = Buffer.alloc(4);
+    guardianSetIndexBuf.writeUInt32BE(guardianSetIndex, 0);
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('GuardianSet'), guardianSetIndexBuf], wormholeProgramId)[0];
+};
+exports.getGuardianSetPda = getGuardianSetPda;

package/lib/browser/slot/SlotSubscriber.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { Connection } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types/types/src';
+type SlotSubscriberConfig = {
+    resubTimeoutMs?: number;
+};
+export interface SlotSubscriberEvents {
+    newSlot: (newSlot: number) => void;
+}
+export declare class SlotSubscriber {
+    private connection;
+    currentSlot: number;
+    subscriptionId: number;
+    eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
+    timeoutId?: ReturnType<typeof setTimeout>;
+    resubTimeoutMs?: number;
+    isUnsubscribing: boolean;
+    receivingData: boolean;
+    constructor(connection: Connection, config?: SlotSubscriberConfig);
+    subscribe(): Promise<void>;
+    private updateCurrentSlot;
+    private setTimeout;
+    getSlot(): number;
+    unsubscribe(onResub?: boolean): Promise<void>;
+}
+export {};

package/lib/browser/slot/SlotSubscriber.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlotSubscriber = void 0;
+const events_1 = require("events");
+class SlotSubscriber {
+    constructor(connection, config) {
+        this.connection = connection;
+        this.isUnsubscribing = false;
+        this.receivingData = false;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.resubTimeoutMs = config === null || config === void 0 ? void 0 : config.resubTimeoutMs;
+        if (this.resubTimeoutMs < 1000) {
+            console.log('resubTimeoutMs should be at least 1000ms to avoid spamming resub');
+        }
+    }
+    async subscribe() {
+        if (this.subscriptionId != null) {
+            return;
+        }
+        const newSlot = await this.connection.getSlot('confirmed');
+        this.updateCurrentSlot(newSlot);
+        this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
+            const newSlot = slotInfo.slot;
+            if (!this.currentSlot || this.currentSlot < newSlot) {
+                if (this.resubTimeoutMs && !this.isUnsubscribing) {
+                    this.receivingData = true;
+                    clearTimeout(this.timeoutId);
+                    this.setTimeout();
+                }
+                this.updateCurrentSlot(newSlot);
+            }
+        });
+        if (this.resubTimeoutMs) {
+            this.receivingData = true;
+            this.setTimeout();
+        }
+    }
+    updateCurrentSlot(slot) {
+        this.currentSlot = slot;
+        this.eventEmitter.emit('newSlot', slot);
+    }
+    setTimeout() {
+        this.timeoutId = setTimeout(async () => {
+            if (this.isUnsubscribing) {
+                // If we are in the process of unsubscribing, do not attempt to resubscribe
+                return;
+            }
+            if (this.receivingData) {
+                console.log(`No new slot in ${this.resubTimeoutMs}ms, slot subscriber resubscribing`);
+                await this.unsubscribe(true);
+                this.receivingData = false;
+                await this.subscribe();
+            }
+        }, this.resubTimeoutMs);
+    }
+    getSlot() {
+        return this.currentSlot;
+    }
+    async unsubscribe(onResub = false) {
+        if (!onResub) {
+            this.resubTimeoutMs = undefined;
+        }
+        this.isUnsubscribing = true;
+        clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        if (this.subscriptionId != null) {
+            await this.connection.removeSlotChangeListener(this.subscriptionId);
+            this.subscriptionId = undefined;
+            this.isUnsubscribing = false;
+        }
+        else {
+            this.isUnsubscribing = false;
+        }
+    }
+}
+exports.SlotSubscriber = SlotSubscriber;

package/lib/browser/slot/SlothashSubscriber.d.ts

@@ -0,0 +1,25 @@
+import { Commitment, Connection } from '@solana/web3.js';
+type SlothashSubscriberConfig = {
+    resubTimeoutMs?: number;
+    commitment?: Commitment;
+};
+export type Slothash = {
+    slot: number;
+    hash: string;
+};
+export declare class SlothashSubscriber {
+    private connection;
+    currentSlothash: Slothash;
+    subscriptionId: number;
+    commitment: Commitment;
+    timeoutId?: ReturnType<typeof setTimeout>;
+    resubTimeoutMs?: number;
+    isUnsubscribing: boolean;
+    receivingData: boolean;
+    constructor(connection: Connection, config?: SlothashSubscriberConfig);
+    subscribe(): Promise<void>;
+    private setTimeout;
+    getSlothash(): Slothash;
+    unsubscribe(onResub?: boolean): Promise<void>;
+}
+export {};

package/lib/browser/slot/SlothashSubscriber.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlothashSubscriber = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const bs58_1 = __importDefault(require("bs58"));
+const anchor_1 = require("../isomorphic/anchor");
+class SlothashSubscriber {
+    constructor(connection, config) {
+        var _a;
+        this.connection = connection;
+        this.isUnsubscribing = false;
+        this.receivingData = false;
+        this.resubTimeoutMs = config === null || config === void 0 ? void 0 : config.resubTimeoutMs;
+        this.commitment = (_a = config === null || config === void 0 ? void 0 : config.commitment) !== null && _a !== void 0 ? _a : 'processed';
+        if (this.resubTimeoutMs < 1000) {
+            console.log('resubTimeoutMs should be at least 1000ms to avoid spamming resub');
+        }
+    }
+    async subscribe() {
+        if (this.subscriptionId != null) {
+            return;
+        }
+        const currentAccountData = await this.connection.getAccountInfo(web3_js_1.SYSVAR_SLOT_HASHES_PUBKEY, this.commitment);
+        if (currentAccountData == null) {
+            throw new Error('Failed to retrieve current slot hash');
+        }
+        this.currentSlothash = deserializeSlothash(currentAccountData.data);
+        this.subscriptionId = this.connection.onAccountChange(web3_js_1.SYSVAR_SLOT_HASHES_PUBKEY, (slothashInfo, context) => {
+            if (!this.currentSlothash || this.currentSlothash.slot < context.slot) {
+                if (this.resubTimeoutMs && !this.isUnsubscribing) {
+                    this.receivingData = true;
+                    clearTimeout(this.timeoutId);
+                    this.setTimeout();
+                }
+                this.currentSlothash = deserializeSlothash(slothashInfo.data);
+            }
+        }, this.commitment);
+        if (this.resubTimeoutMs) {
+            this.receivingData = true;
+            this.setTimeout();
+        }
+    }
+    setTimeout() {
+        this.timeoutId = setTimeout(async () => {
+            if (this.isUnsubscribing) {
+                // If we are in the process of unsubscribing, do not attempt to resubscribe
+                return;
+            }
+            if (this.receivingData) {
+                console.log(`No new slot in ${this.resubTimeoutMs}ms, slot subscriber resubscribing`);
+                await this.unsubscribe(true);
+                this.receivingData = false;
+                await this.subscribe();
+            }
+        }, this.resubTimeoutMs);
+    }
+    getSlothash() {
+        return this.currentSlothash;
+    }
+    async unsubscribe(onResub = false) {
+        if (!onResub) {
+            this.resubTimeoutMs = undefined;
+        }
+        this.isUnsubscribing = true;
+        clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        if (this.subscriptionId != null) {
+            await this.connection.removeSlotChangeListener(this.subscriptionId);
+            this.subscriptionId = undefined;
+            this.isUnsubscribing = false;
+        }
+        else {
+            this.isUnsubscribing = false;
+        }
+    }
+}
+exports.SlothashSubscriber = SlothashSubscriber;
+function deserializeSlothash(data) {
+    const slotNumber = new anchor_1.BN(data.subarray(8, 16), 10, 'le');
+    const hash = bs58_1.default.encode(data.subarray(16, 48));
+    return {
+        slot: slotNumber.toNumber(),
+        hash,
+    };
+}

package/lib/browser/swap/UnifiedSwapClient.d.ts

@@ -0,0 +1,120 @@
+/// <reference types="bn.js" />
+import { Connection, PublicKey, TransactionMessage, AddressLookupTableAccount, VersionedTransaction, TransactionInstruction } from '@solana/web3.js';
+import { BN } from '../isomorphic/anchor';
+import { JupiterClient } from '../jupiter/jupiterClient';
+import { TitanClient } from '../titan/titanClient';
+export type SwapMode = 'ExactIn' | 'ExactOut';
+export type SwapClientType = 'jupiter' | 'titan';
+/**
+ * Unified quote response interface that combines properties from both Jupiter and Titan
+ * This provides a consistent interface while allowing for provider-specific fields
+ */
+export interface UnifiedQuoteResponse {
+    inputMint: string;
+    inAmount: string;
+    outputMint: string;
+    outAmount: string;
+    swapMode: SwapMode;
+    slippageBps: number;
+    routePlan: Array<{
+        swapInfo: any;
+        percent: number;
+    }>;
+    otherAmountThreshold?: string;
+    priceImpactPct?: string;
+    platformFee?: {
+        amount?: string;
+        feeBps?: number;
+    };
+    contextSlot?: number;
+    timeTaken?: number;
+    error?: string;
+    errorCode?: string;
+}
+export interface SwapQuoteParams {
+    inputMint: PublicKey;
+    outputMint: PublicKey;
+    amount: BN;
+    userPublicKey?: PublicKey;
+    maxAccounts?: number;
+    slippageBps?: number;
+    swapMode?: SwapMode;
+    onlyDirectRoutes?: boolean;
+    excludeDexes?: string[];
+    sizeConstraint?: number;
+    accountsLimitWritable?: number;
+    autoSlippage?: boolean;
+    maxAutoSlippageBps?: number;
+    usdEstimate?: number;
+}
+export interface SwapTransactionParams {
+    quote: UnifiedQuoteResponse;
+    userPublicKey: PublicKey;
+    slippageBps?: number;
+}
+export interface SwapTransactionResult {
+    transaction?: VersionedTransaction;
+    transactionMessage?: TransactionMessage;
+    lookupTables?: AddressLookupTableAccount[];
+}
+export declare class UnifiedSwapClient {
+    private client;
+    private clientType;
+    /**
+     * Create a unified swap client
+     * @param clientType - 'jupiter' or 'titan'
+     * @param connection - Solana connection
+     * @param authToken - For Titan: auth token (required when not using proxy). For Jupiter: API key (required for api.jup.ag, get free key at https://portal.jup.ag)
+     * @param url - Optional custom URL
+     * @param proxyUrl - Optional proxy URL for Titan
+     */
+    constructor({ clientType, connection, authToken, url, proxyUrl, }: {
+        clientType: SwapClientType;
+        connection: Connection;
+        authToken?: string;
+        url?: string;
+        proxyUrl?: string;
+    });
+    /**
+     * Get a swap quote from the underlying client
+     */
+    getQuote(params: SwapQuoteParams): Promise<UnifiedQuoteResponse>;
+    /**
+     * Get a swap transaction from the underlying client
+     */
+    getSwap(params: SwapTransactionParams): Promise<SwapTransactionResult>;
+    /**
+     * Get swap instructions from the underlying client (Jupiter or Titan)
+     * This is the core swap logic without any context preparation
+     */
+    getSwapInstructions({ inputMint, outputMint, amount, userPublicKey, slippageBps, swapMode, onlyDirectRoutes, quote, sizeConstraint, }: {
+        inputMint: PublicKey;
+        outputMint: PublicKey;
+        amount: BN;
+        userPublicKey: PublicKey;
+        slippageBps?: number;
+        swapMode?: SwapMode;
+        onlyDirectRoutes?: boolean;
+        quote?: UnifiedQuoteResponse;
+        sizeConstraint?: number;
+    }): Promise<{
+        instructions: TransactionInstruction[];
+        lookupTables: AddressLookupTableAccount[];
+    }>;
+    /**
+     * Get the underlying client instance
+     */
+    getClient(): JupiterClient | TitanClient;
+    /**
+     * Get the client type
+     */
+    getClientType(): SwapClientType;
+    /**
+     * Check if this is a Jupiter client
+     */
+    isJupiter(): boolean;
+    /**
+     * Check if this is a Titan client
+     */
+    isTitan(): boolean;
+}

package/lib/browser/swap/UnifiedSwapClient.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnifiedSwapClient = void 0;
+const jupiterClient_1 = require("../jupiter/jupiterClient");
+const titanClient_1 = require("../titan/titanClient");
+class UnifiedSwapClient {
+    /**
+     * Create a unified swap client
+     * @param clientType - 'jupiter' or 'titan'
+     * @param connection - Solana connection
+     * @param authToken - For Titan: auth token (required when not using proxy). For Jupiter: API key (required for api.jup.ag, get free key at https://portal.jup.ag)
+     * @param url - Optional custom URL
+     * @param proxyUrl - Optional proxy URL for Titan
+     */
+    constructor({ clientType, connection, authToken, url, proxyUrl, }) {
+        this.clientType = clientType;
+        if (clientType === 'jupiter') {
+            this.client = new jupiterClient_1.JupiterClient({
+                connection,
+                url,
+                apiKey: authToken,
+            });
+        }
+        else if (clientType === 'titan') {
+            this.client = new titanClient_1.TitanClient({
+                connection,
+                authToken: authToken || '', // Not needed when using proxy
+                url,
+                proxyUrl,
+            });
+        }
+        else {
+            throw new Error(`Unsupported client type: ${clientType}`);
+        }
+    }
+    /**
+     * Get a swap quote from the underlying client
+     */
+    async getQuote(params) {
+        if (this.clientType === 'jupiter') {
+            const jupiterClient = this.client;
+            const { userPublicKey: _userPublicKey, // Not needed for Jupiter
+            sizeConstraint: _sizeConstraint, // Jupiter-specific params to exclude
+            accountsLimitWritable: _accountsLimitWritable, ...jupiterParams } = params;
+            return await jupiterClient.getQuote(jupiterParams);
+        }
+        else {
+            const titanClient = this.client;
+            const { autoSlippage: _autoSlippage, // Titan-specific params to exclude
+            maxAutoSlippageBps: _maxAutoSlippageBps, usdEstimate: _usdEstimate, ...titanParams } = params;
+            if (!titanParams.userPublicKey) {
+                throw new Error('userPublicKey is required for Titan quotes');
+            }
+            // Cast to ensure TypeScript knows userPublicKey is defined
+            const titanParamsWithUser = {
+                ...titanParams,
+                userPublicKey: titanParams.userPublicKey,
+                swapMode: titanParams.swapMode, // Titan expects string
+                sizeConstraint: titanParams.sizeConstraint || 1280 - 375, // Use same default as getSwapInstructions
+            };
+            return await titanClient.getQuote(titanParamsWithUser);
+        }
+    }
+    /**
+     * Get a swap transaction from the underlying client
+     */
+    async getSwap(params) {
+        if (this.clientType === 'jupiter') {
+            const jupiterClient = this.client;
+            // Cast the quote to Jupiter's specific QuoteResponse type
+            const jupiterParams = {
+                ...params,
+                quote: params.quote,
+            };
+            const transaction = await jupiterClient.getSwap(jupiterParams);
+            return { transaction };
+        }
+        else {
+            const titanClient = this.client;
+            const { userPublicKey } = params;
+            // For Titan, we need to reconstruct the parameters from the quote
+            const result = await titanClient.getSwap({
+                userPublicKey,
+            });
+            return {
+                transactionMessage: result.transactionMessage,
+                lookupTables: result.lookupTables,
+            };
+        }
+    }
+    /**
+     * Get swap instructions from the underlying client (Jupiter or Titan)
+     * This is the core swap logic without any context preparation
+     */
+    async getSwapInstructions({ inputMint, outputMint, amount, userPublicKey, slippageBps, swapMode = 'ExactIn', onlyDirectRoutes = false, quote, sizeConstraint, }) {
+        const isExactOut = swapMode === 'ExactOut';
+        let swapInstructions;
+        let lookupTables;
+        if (this.clientType === 'jupiter') {
+            const jupiterClient = this.client;
+            // Get quote if not provided
+            let finalQuote = quote;
+            if (!finalQuote) {
+                finalQuote = await jupiterClient.getQuote({
+                    inputMint,
+                    outputMint,
+                    amount,
+                    slippageBps,
+                    swapMode,
+                    onlyDirectRoutes,
+                });
+            }
+            if (!finalQuote) {
+                throw new Error('Could not fetch swap quote. Please try again.');
+            }
+            // Get swap transaction and extract instructions
+            const transaction = await jupiterClient.getSwap({
+                quote: finalQuote,
+                userPublicKey,
+                slippageBps,
+            });
+            const { transactionMessage, lookupTables: jupiterLookupTables } = await jupiterClient.getTransactionMessageAndLookupTables({
+                transaction,
+            });
+            swapInstructions = jupiterClient.getJupiterInstructions({
+                transactionMessage,
+                inputMint,
+                outputMint,
+            });
+            lookupTables = jupiterLookupTables;
+        }
+        else {
+            const titanClient = this.client;
+            // For Titan, get swap directly (it handles quote internally)
+            const { transactionMessage, lookupTables: titanLookupTables } = await titanClient.getSwap({
+                inputMint,
+                outputMint,
+                amount,
+                userPublicKey,
+                slippageBps,
+                swapMode: isExactOut ? titanClient_1.SwapMode.ExactOut : titanClient_1.SwapMode.ExactIn,
+                onlyDirectRoutes,
+                sizeConstraint: sizeConstraint || 1280 - 375, // MAX_TX_BYTE_SIZE - buffer for drift instructions
+            });
+            swapInstructions = titanClient.getTitanInstructions({
+                transactionMessage,
+                inputMint,
+                outputMint,
+            });
+            lookupTables = titanLookupTables;
+        }
+        return { instructions: swapInstructions, lookupTables };
+    }
+    /**
+     * Get the underlying client instance
+     */
+    getClient() {
+        return this.client;
+    }
+    /**
+     * Get the client type
+     */
+    getClientType() {
+        return this.clientType;
+    }
+    /**
+     * Check if this is a Jupiter client
+     */
+    isJupiter() {
+        return this.clientType === 'jupiter';
+    }
+    /**
+     * Check if this is a Titan client
+     */
+    isTitan() {
+        return this.clientType === 'titan';
+    }
+}
+exports.UnifiedSwapClient = UnifiedSwapClient;

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

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Commitment } from '@solana/web3.js';
+import { grpcProgramAccountSubscriber } from '../accounts/grpcProgramAccountSubscriber';
+import { GrpcConfigs, ResubOpts } from '../accounts/types';
+import { SignedMsgUserOrdersAccount } from '../types';
+import { SignedMsgUserOrdersAccountSubscriber } from './signedMsgUserAccountSubscriber';
+import { VelocityClient } from '../velocityClient';
+export declare class grpcSignedMsgUserOrdersAccountSubscriber extends SignedMsgUserOrdersAccountSubscriber {
+    private grpcConfigs;
+    subscriber: grpcProgramAccountSubscriber<SignedMsgUserOrdersAccount>;
+    constructor({ grpcConfigs, driftClient, commitment, resubOpts, decodeFn, resyncIntervalMs, }: {
+        grpcConfigs: GrpcConfigs;
+        driftClient: VelocityClient;
+        commitment?: Commitment;
+        resubOpts?: ResubOpts;
+        decodeFn?: (name: string, data: Buffer) => SignedMsgUserOrdersAccount;
+        resyncIntervalMs?: number;
+    });
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/browser/swift/grpcSignedMsgUserAccountSubscriber.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcSignedMsgUserOrdersAccountSubscriber = void 0;
+const grpcProgramAccountSubscriber_1 = require("../accounts/grpcProgramAccountSubscriber");
+const memcmp_1 = require("../memcmp");
+const signedMsgUserAccountSubscriber_1 = require("./signedMsgUserAccountSubscriber");
+class grpcSignedMsgUserOrdersAccountSubscriber extends signedMsgUserAccountSubscriber_1.SignedMsgUserOrdersAccountSubscriber {
+    constructor({ grpcConfigs, driftClient, commitment, resubOpts, decodeFn, resyncIntervalMs, }) {
+        super({
+            driftClient,
+            commitment,
+            resubOpts,
+            decodeFn,
+            resyncIntervalMs,
+        });
+        this.grpcConfigs = grpcConfigs;
+    }
+    async subscribe() {
+        if (!this.subscriber) {
+            this.subscriber =
+                await grpcProgramAccountSubscriber_1.grpcProgramAccountSubscriber.create(this.grpcConfigs, 'SingedMsgUserOrdersAccountMap', 'signedMsgUserOrders', this.driftClient.program, this.decodeFn, {
+                    filters: [(0, memcmp_1.getSignedMsgUserOrdersFilter)()],
+                }, this.resubOpts);
+        }
+        await this.subscriber.subscribe((_accountId, account, context) => {
+            this.tryUpdateSignedMsgUserOrdersAccount(account, 'decoded', context.slot);
+        });
+        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 unsubscribe() {
+        if (!this.subscriber)
+            return;
+        await this.subscriber.unsubscribe();
+        this.subscriber = undefined;
+        if (this.resyncTimeoutId !== undefined) {
+            clearTimeout(this.resyncTimeoutId);
+            this.resyncTimeoutId = undefined;
+        }
+    }
+}
+exports.grpcSignedMsgUserOrdersAccountSubscriber = grpcSignedMsgUserOrdersAccountSubscriber;

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

@@ -0,0 +1,10 @@
+/**
+ * Swift / signed-message order infrastructure.
+ * Supports off-chain signed order messages that are matched and settled on-chain without
+ * a separate place-order transaction. Used for low-latency taker flows.
+ * `swiftOrderSubscriber.ts` — subscribes to incoming Swift orders via gRPC or WebSocket.
+ * `signedMsgUserAccountSubscriber.ts` — caches signed-message user account state.
+ */
+export * from './swiftOrderSubscriber';
+export * from './signedMsgUserAccountSubscriber';
+export * from './grpcSignedMsgUserAccountSubscriber';

package/lib/browser/swift/index.js

@@ -0,0 +1,26 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Swift / signed-message order infrastructure.
+ * Supports off-chain signed order messages that are matched and settled on-chain without
+ * a separate place-order transaction. Used for low-latency taker flows.
+ * `swiftOrderSubscriber.ts` — subscribes to incoming Swift orders via gRPC or WebSocket.
+ * `signedMsgUserAccountSubscriber.ts` — caches signed-message user account state.
+ */
+__exportStar(require("./swiftOrderSubscriber"), exports);
+__exportStar(require("./signedMsgUserAccountSubscriber"), exports);
+__exportStar(require("./grpcSignedMsgUserAccountSubscriber"), exports);