@stryke-xyz/premarket-sdk 1.0.0

package/dist/ponder/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./client/index.js";
+export * from "./types.js";

package/dist/ponder/index.js

@@ -0,0 +1,2 @@
+export * from "./client/index.js";
+export * from "./types.js";

package/dist/ponder/types.d.ts

@@ -0,0 +1,3 @@
+export interface PonderClientConfig {
+    graphqlUrl: string;
+}

package/dist/ponder/types.js

@@ -0,0 +1 @@
+export {};

package/dist/rfq-order/index.d.ts

@@ -0,0 +1 @@
+export * from './rfq-order.js';

package/dist/rfq-order/index.js

@@ -0,0 +1 @@
+export * from './rfq-order.js';

package/dist/rfq-order/rfq-order.d.ts

@@ -0,0 +1,21 @@
+import { LimitOrder, OrderInfoData } from '../limit-order/index.js';
+import { Address } from '../address.js';
+/**
+ * Light, gas efficient version of LimitOrder
+ * It does not support multiple fills and extension
+ */
+export declare class RfqOrder extends LimitOrder {
+    constructor(orderInfo: Omit<OrderInfoData, 'salt' | 'receiver'>, options: {
+        allowedSender?: Address;
+        /**
+         * Timestamp in seconds
+         */
+        expiration: bigint;
+        /**
+         * Unique id among all maker orders
+         * Max value is UINT_40_MAX
+         */
+        nonce: bigint;
+        usePermit2?: boolean;
+    });
+}

package/dist/rfq-order/rfq-order.js

@@ -0,0 +1,22 @@
+import { LimitOrder, MakerTraits } from '../limit-order/index.js';
+/**
+ * Light, gas efficient version of LimitOrder
+ * It does not support multiple fills and extension
+ */
+export class RfqOrder extends LimitOrder {
+    constructor(orderInfo, options) {
+        const { allowedSender, nonce, expiration, usePermit2 } = options;
+        const makerTraits = new MakerTraits(0n)
+            .disableMultipleFills()
+            .allowPartialFills()
+            .withExpiration(expiration)
+            .withNonce(nonce);
+        if (allowedSender) {
+            makerTraits.withAllowedSender(allowedSender);
+        }
+        if (usePermit2) {
+            makerTraits.enablePermit2();
+        }
+        super(orderInfo, makerTraits);
+    }
+}

package/dist/rfq-order/rfq-order.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/rfq-order/rfq-order.spec.js

@@ -0,0 +1,27 @@
+import { RfqOrder } from './rfq-order.js';
+import { Address } from '../address.js';
+describe('RfqOrder', () => {
+    it('Should validate max nonce', () => {
+        expect(() => new RfqOrder({
+            makerAsset: new Address('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'),
+            takerAsset: new Address('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'),
+            makingAmount: 1000000000000000000n,
+            takingAmount: 1420000000n,
+            maker: new Address('0x00000000219ab540356cbb839cbe05303d7705fa')
+        }, { nonce: 1n << 41n, expiration: 1000n })).toThrow();
+    });
+});
+it('should create RfqOrder with permit2', () => {
+    const order = new RfqOrder({
+        makerAsset: new Address('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'),
+        takerAsset: new Address('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'),
+        makingAmount: 1000000000000000000n,
+        takingAmount: 1420000000n,
+        maker: new Address('0x00000000219ab540356cbb839cbe05303d7705fa')
+    }, {
+        nonce: 1n,
+        expiration: 1000n,
+        usePermit2: true
+    });
+    expect(order.makerTraits.isPermit2()).toEqual(true);
+});

package/dist/shared/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export { calculateOptionTokenId } from "./utils.js";

package/dist/shared/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export { calculateOptionTokenId } from "./utils.js";

package/dist/shared/types.d.ts

@@ -0,0 +1,79 @@
+export interface Order {
+    salt: string;
+    maker: string;
+    receiver: string;
+    makerAsset: string;
+    takerAsset: string;
+    makingAmount: string;
+    takingAmount: string;
+    makerTraits: string;
+}
+export interface OrderSignature {
+    r: string;
+    vs: string;
+}
+export interface Option {
+    marketId: string;
+    strikeLowerLimit: string;
+    strikeUpperLimit: string;
+    isPut: boolean;
+}
+export declare enum OrderType {
+    SELL_OPTIONS = "SELL_OPTIONS",
+    BUY_OPTIONS = "BUY_OPTIONS"
+}
+export declare enum OrderStatus {
+    ACTIVE = "ACTIVE",
+    FILLED = "FILLED",
+    CANCELLED = "CANCELLED",
+    EXPIRED = "EXPIRED"
+}
+export interface StoredOrder {
+    id: string;
+    orderHash: string;
+    orderType: OrderType;
+    order: Order;
+    extensionEncoded: string;
+    signature: OrderSignature;
+    marketId: string;
+    optionTokenId: string;
+    stableToken: string;
+    optionAmount: string;
+    stableAmount: string;
+    status: OrderStatus;
+    filledAmount: string;
+    remainingMakerAmount: string;
+    maker: string;
+    operator?: string;
+    createdAt: number;
+    expiresAt?: number;
+}
+export interface CreateOrderParams {
+    orderType: OrderType;
+    marketId: string;
+    option: Option;
+    order: Order;
+    extensionEncoded: string;
+    signature: OrderSignature;
+    optionAmount: string;
+    stableAmount: string;
+    stableToken: string;
+    makerProxyAddress: string;
+    operator?: string;
+    expiresAt?: number;
+}
+export type CreateOrderRequest = CreateOrderParams;
+export interface OrderQueryParams {
+    marketId?: string;
+    orderType?: OrderType;
+    maker?: string;
+    stableToken?: string;
+    status?: OrderStatus;
+    limit?: number;
+    offset?: number;
+}
+export interface OrderResponse {
+    success: boolean;
+    data?: any;
+    error?: string;
+}

package/dist/shared/types.js

@@ -0,0 +1,12 @@
+export var OrderType;
+(function (OrderType) {
+    OrderType["SELL_OPTIONS"] = "SELL_OPTIONS";
+    OrderType["BUY_OPTIONS"] = "BUY_OPTIONS";
+})(OrderType || (OrderType = {}));
+export var OrderStatus;
+(function (OrderStatus) {
+    OrderStatus["ACTIVE"] = "ACTIVE";
+    OrderStatus["FILLED"] = "FILLED";
+    OrderStatus["CANCELLED"] = "CANCELLED";
+    OrderStatus["EXPIRED"] = "EXPIRED";
+})(OrderStatus || (OrderStatus = {}));

package/dist/shared/utils.d.ts

@@ -0,0 +1,7 @@
+import { type Hex } from "viem";
+import type { Option } from "./types.js";
+/**
+ * Calculate option token ID from option parameters
+ * This should match the getTokenId function in OptionTokenFactory
+ */
+export declare function calculateOptionTokenId(option: Option): Hex;

package/dist/shared/utils.js

@@ -0,0 +1,19 @@
+import { encodeAbiParameters, keccak256 } from "viem";
+/**
+ * Calculate option token ID from option parameters
+ * This should match the getTokenId function in OptionTokenFactory
+ */
+export function calculateOptionTokenId(option) {
+    const encoded = encodeAbiParameters([
+        { name: "marketId", type: "uint256" },
+        { name: "strikeLowerLimit", type: "uint256" },
+        { name: "strikeUpperLimit", type: "uint256" },
+        { name: "isPut", type: "bool" },
+    ], [
+        BigInt(option.marketId),
+        BigInt(option.strikeLowerLimit),
+        BigInt(option.strikeUpperLimit),
+        option.isPut,
+    ]);
+    return keccak256(encoded);
+}

package/dist/sync/clients/balance-client.d.ts

@@ -0,0 +1,41 @@
+import { BaseSyncClient } from "./base-client.js";
+export interface BalanceData {
+    maker: string;
+    token: string;
+    usableBalance: string;
+    tokenId?: string;
+}
+export interface BalanceUpdateMessage {
+    type: "balanceUpdate";
+    seq: number;
+    marketId: string;
+    balances: BalanceData[];
+    timestamp: number;
+}
+export interface BalanceSyncClientConfig {
+    redisUrl: string;
+    marketId: string;
+    channel: string;
+    gapRecoveryUrl?: string;
+    snapshotUrl?: string;
+}
+export declare class BalanceSyncClient extends BaseSyncClient<BalanceUpdateMessage, BalanceData[], BalanceData, BalanceSyncClientConfig> {
+    private balanceListeners;
+    constructor(config: Omit<BalanceSyncClientConfig, "channel">);
+    protected fetchSnapshot(): Promise<void>;
+    protected applyMessage(message: BalanceUpdateMessage): void;
+    protected recoverGap(fromSeq: number, toSeq: number): Promise<BalanceUpdateMessage[]>;
+    /**
+     * Get usable balance for a maker/token pair (or maker/token/tokenId for ERC6909)
+     */
+    getUsableBalance(maker: string, token: string, tokenId?: string | bigint): string | undefined;
+    /**
+     * Get all balances as a map of key -> balance string
+     */
+    getBalanceMap(): Map<string, string>;
+    /**
+     * Get all balances as BalanceData array
+     */
+    getBalances(): BalanceData[];
+    onBalanceUpdate(callback: (balances: BalanceData[]) => void): () => void;
+}

package/dist/sync/clients/balance-client.js

@@ -0,0 +1,139 @@
+import { BaseSyncClient } from "./base-client.js";
+export class BalanceSyncClient extends BaseSyncClient {
+    constructor(config) {
+        // Build full config with channel
+        const fullConfig = {
+            ...config,
+            channel: `orderbook:market:${config.marketId}:balances`,
+        };
+        super(fullConfig);
+        this.balanceListeners = new Set();
+    }
+    async fetchSnapshot() {
+        try {
+            // Use snapshotUrl if available, otherwise fall back to gapRecoveryUrl
+            const baseUrl = this.config.snapshotUrl || this.config.gapRecoveryUrl;
+            if (!baseUrl) {
+                // If no URL, start from 0
+                this.lastSeq = 0;
+                return;
+            }
+            const url = `${baseUrl}/api/sync/balance-snapshot?marketId=${this.config.marketId}`;
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Balance snapshot fetch failed: ${response.status} ${response.statusText}`);
+            }
+            const data = (await response.json());
+            if (data.success && data.data) {
+                const balances = data.data.balances || [];
+                const snapshotSeq = data.data.seq || 0;
+                // Clear and populate balance map
+                this.dataMap.clear();
+                for (const balance of balances) {
+                    const key = balance.tokenId
+                        ? `${balance.maker.toLowerCase()}:${balance.token.toLowerCase()}:${balance.tokenId}`
+                        : `${balance.maker.toLowerCase()}:${balance.token.toLowerCase()}`;
+                    this.dataMap.set(key, balance);
+                }
+                this.lastSeq = snapshotSeq;
+                // Notify snapshot listeners
+                this.notifySnapshotListeners(balances);
+            }
+        }
+        catch (error) {
+            console.error("Error fetching balance snapshot:", error);
+            // Fallback to starting from 0
+            this.lastSeq = 0;
+        }
+    }
+    applyMessage(message) {
+        // Update balance map
+        for (const balance of message.balances) {
+            // For ERC6909 tokens, include tokenId in the key
+            const key = balance.tokenId
+                ? `${balance.maker.toLowerCase()}:${balance.token.toLowerCase()}:${balance.tokenId}`
+                : `${balance.maker.toLowerCase()}:${balance.token.toLowerCase()}`;
+            this.dataMap.set(key, balance);
+        }
+        // Notify change listeners (from base class)
+        this.changeListeners.forEach((listener) => {
+            try {
+                listener(message.balances);
+            }
+            catch (error) {
+                console.error("Error in change listener:", error);
+            }
+        });
+        // Notify balance-specific listeners
+        this.balanceListeners.forEach((listener) => {
+            try {
+                listener(message.balances);
+            }
+            catch (error) {
+                console.error("Error in balance listener:", error);
+            }
+        });
+    }
+    async recoverGap(fromSeq, toSeq) {
+        if (!this.config.gapRecoveryUrl) {
+            return [];
+        }
+        const gapSize = toSeq - fromSeq + 1;
+        if (gapSize > 1000) {
+            await this.fullResync();
+            return [];
+        }
+        this.setStatus("recovering");
+        try {
+            const url = `${this.config.gapRecoveryUrl}/api/sync/balance-messages?marketId=${this.config.marketId}&fromSeq=${fromSeq}&toSeq=${toSeq}`;
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Gap recovery failed: ${response.status} ${response.statusText}`);
+            }
+            const data = (await response.json());
+            if (data.success && data.data) {
+                const messages = data.data;
+                messages.sort((a, b) => a.seq - b.seq);
+                this.setStatus("synced");
+                return messages;
+            }
+            this.setStatus("synced");
+            return [];
+        }
+        catch (error) {
+            console.error("Error recovering gap:", error);
+            await this.fullResync();
+            return [];
+        }
+    }
+    /**
+     * Get usable balance for a maker/token pair (or maker/token/tokenId for ERC6909)
+     */
+    getUsableBalance(maker, token, tokenId) {
+        const key = tokenId
+            ? `${maker.toLowerCase()}:${token.toLowerCase()}:${tokenId.toString()}`
+            : `${maker.toLowerCase()}:${token.toLowerCase()}`;
+        const balanceData = this.dataMap.get(key);
+        return balanceData?.usableBalance;
+    }
+    /**
+     * Get all balances as a map of key -> balance string
+     */
+    getBalanceMap() {
+        const map = new Map();
+        for (const [key, balanceData] of this.dataMap.entries()) {
+            map.set(key, balanceData.usableBalance);
+        }
+        return map;
+    }
+    /**
+     * Get all balances as BalanceData array
+     */
+    getBalances() {
+        return Array.from(this.dataMap.values());
+    }
+    onBalanceUpdate(callback) {
+        this.balanceListeners.add(callback);
+        return () => this.balanceListeners.delete(callback);
+    }
+}

package/dist/sync/clients/base-client.d.ts

@@ -0,0 +1,47 @@
+import type { SyncStatus } from "../types.js";
+import { RedisWsClient } from "../redis-ws-client.js";
+/**
+ * Base abstract class for sync clients
+ * @template TMessage - The message type (e.g., SequencedMessage, BalanceUpdateMessage)
+ * @template TChange - The change type (e.g., OrderChange, BalanceData[])
+ * @template TData - The data type stored in the map (e.g., StoredOrder, string)
+ * @template TConfig - The config type (must have redisUrl and channel)
+ */
+export declare abstract class BaseSyncClient<TMessage extends {
+    seq: number;
+}, TChange, TData, TConfig extends {
+    redisUrl: string;
+    channel: string;
+}> {
+    protected wsClient: RedisWsClient | null;
+    protected config: TConfig;
+    protected status: SyncStatus;
+    protected lastSeq: number;
+    protected incomingQueue: TMessage[];
+    protected isProcessing: boolean;
+    protected statusListeners: Set<(status: SyncStatus) => void>;
+    protected changeListeners: Set<(change: TChange) => void>;
+    protected dataMap: Map<string, TData>;
+    protected snapshotListeners: Set<(data: TData[]) => void>;
+    constructor(config: TConfig);
+    connect(): Promise<void>;
+    protected enqueueMessage(message: TMessage): void;
+    protected processQueue(): Promise<void>;
+    protected fullResync(): Promise<void>;
+    protected setStatus(status: SyncStatus): void;
+    getStatus(): SyncStatus;
+    isSynced(): boolean;
+    getLastSequence(): number;
+    getBufferedCount(): number;
+    onStatus(callback: (status: SyncStatus) => void): () => void;
+    onChange(callback: (change: TChange) => void): () => void;
+    onSnapshot(callback: (data: TData[]) => void): () => void;
+    protected notifySnapshotListeners(data: TData[]): void;
+    disconnect(): Promise<void>;
+    /**
+     * Abstract methods to be implemented by child classes
+     */
+    protected abstract fetchSnapshot(): Promise<void>;
+    protected abstract applyMessage(message: TMessage): Promise<void> | void;
+    protected abstract recoverGap(fromSeq: number, toSeq: number): Promise<TMessage[]>;
+}

package/dist/sync/clients/base-client.js

@@ -0,0 +1,154 @@
+import { RedisWsClient } from "../redis-ws-client.js";
+/**
+ * Base abstract class for sync clients
+ * @template TMessage - The message type (e.g., SequencedMessage, BalanceUpdateMessage)
+ * @template TChange - The change type (e.g., OrderChange, BalanceData[])
+ * @template TData - The data type stored in the map (e.g., StoredOrder, string)
+ * @template TConfig - The config type (must have redisUrl and channel)
+ */
+export class BaseSyncClient {
+    constructor(config) {
+        this.wsClient = null;
+        this.status = "disconnected";
+        this.lastSeq = 0;
+        this.incomingQueue = [];
+        this.isProcessing = false;
+        this.statusListeners = new Set();
+        this.changeListeners = new Set();
+        this.dataMap = new Map();
+        this.snapshotListeners = new Set();
+        this.config = config;
+    }
+    async connect() {
+        this.setStatus("connecting");
+        // Only allow ws:// or wss:// URLs
+        const wsUrl = this.config.redisUrl;
+        if (!wsUrl.startsWith("ws://") && !wsUrl.startsWith("wss://")) {
+            throw new Error(`Invalid WebSocket URL: ${wsUrl}. Only ws:// and wss:// URLs are supported.`);
+        }
+        this.wsClient = new RedisWsClient(wsUrl);
+        this.wsClient.subscribe(this.config.channel, (messageStr) => {
+            try {
+                const message = JSON.parse(messageStr);
+                this.enqueueMessage(message);
+            }
+            catch (error) {
+                console.error("Error parsing message:", error);
+            }
+        });
+        this.setStatus("syncing");
+        await this.fetchSnapshot();
+        this.setStatus("synced");
+    }
+    enqueueMessage(message) {
+        this.incomingQueue.push(message);
+        this.processQueue();
+    }
+    async processQueue() {
+        if (this.isProcessing)
+            return;
+        this.isProcessing = true;
+        try {
+            while (this.incomingQueue.length > 0) {
+                const message = this.incomingQueue.shift();
+                if (message.seq <= this.lastSeq) {
+                    continue;
+                }
+                const expectedSeq = this.lastSeq + 1;
+                if (message.seq === expectedSeq) {
+                    await this.applyMessage(message);
+                    this.lastSeq = message.seq;
+                }
+                else if (message.seq > expectedSeq) {
+                    const recovered = await this.recoverGap(expectedSeq, message.seq - 1);
+                    for (const msg of recovered) {
+                        if (msg.seq === this.lastSeq + 1) {
+                            await this.applyMessage(msg);
+                            this.lastSeq = msg.seq;
+                        }
+                    }
+                    if (message.seq === this.lastSeq + 1) {
+                        await this.applyMessage(message);
+                        this.lastSeq = message.seq;
+                    }
+                    else {
+                        this.incomingQueue.unshift(message);
+                        await this.recoverGap(this.lastSeq + 1, message.seq - 1);
+                    }
+                }
+            }
+        }
+        finally {
+            this.isProcessing = false;
+            if (this.incomingQueue.length > 0) {
+                setImmediate(() => this.processQueue());
+            }
+        }
+    }
+    async fullResync() {
+        this.isProcessing = true;
+        try {
+            this.incomingQueue = [];
+            this.lastSeq = 0;
+            await this.fetchSnapshot();
+            this.setStatus("synced");
+        }
+        finally {
+            this.isProcessing = false;
+        }
+    }
+    setStatus(status) {
+        if (this.status === status)
+            return;
+        this.status = status;
+        this.statusListeners.forEach((listener) => {
+            try {
+                listener(status);
+            }
+            catch (error) {
+                console.error("Error in status listener:", error);
+            }
+        });
+    }
+    getStatus() {
+        return this.status;
+    }
+    isSynced() {
+        return this.status === "synced";
+    }
+    getLastSequence() {
+        return this.lastSeq;
+    }
+    getBufferedCount() {
+        return this.incomingQueue.length;
+    }
+    onStatus(callback) {
+        this.statusListeners.add(callback);
+        return () => this.statusListeners.delete(callback);
+    }
+    onChange(callback) {
+        this.changeListeners.add(callback);
+        return () => this.changeListeners.delete(callback);
+    }
+    onSnapshot(callback) {
+        this.snapshotListeners.add(callback);
+        return () => this.snapshotListeners.delete(callback);
+    }
+    notifySnapshotListeners(data) {
+        this.snapshotListeners.forEach((listener) => {
+            try {
+                listener(data);
+            }
+            catch (error) {
+                console.error("Error in snapshot listener:", error);
+            }
+        });
+    }
+    async disconnect() {
+        if (this.wsClient) {
+            this.wsClient.close();
+            this.wsClient = null;
+        }
+        this.setStatus("disconnected");
+    }
+}

package/dist/sync/clients/order-client.d.ts

@@ -0,0 +1,18 @@
+import { type StoredOrder } from "../../shared/types.js";
+import type { OrderChange, SequencedMessage, SyncClientConfig } from "../types.js";
+import { BaseSyncClient } from "./base-client.js";
+export interface OrderbookSyncClientConfig extends SyncClientConfig {
+    channel: string;
+}
+export declare class OrderbookSyncClient extends BaseSyncClient<SequencedMessage, OrderChange, StoredOrder, OrderbookSyncClientConfig> {
+    private expireCheckInterval;
+    constructor(config: SyncClientConfig);
+    connect(): Promise<void>;
+    protected fetchSnapshot(): Promise<void>;
+    protected applyMessage(message: SequencedMessage): void;
+    protected recoverGap(fromSeq: number, toSeq: number): Promise<SequencedMessage[]>;
+    getOrders(): StoredOrder[];
+    getOrder(orderHash: string): StoredOrder | undefined;
+    private startExpireCheck;
+    disconnect(): Promise<void>;
+}