@stryke-xyz/premarket-sdk 1.0.0

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

@@ -0,0 +1,151 @@
+import { OrderStatus } from "../../shared/types.js";
+import { BaseSyncClient } from "./base-client.js";
+export class OrderbookSyncClient extends BaseSyncClient {
+    constructor(config) {
+        // Build full config with channel
+        const fullConfig = {
+            ...config,
+            channel: `orderbook:market:${config.marketId}`,
+        };
+        super(fullConfig);
+        this.expireCheckInterval = null;
+    }
+    async connect() {
+        await super.connect();
+        this.startExpireCheck();
+    }
+    async fetchSnapshot() {
+        try {
+            if (!this.config.snapshotUrl) {
+                return;
+            }
+            const url = `${this.config.snapshotUrl}/api/orders?marketId=${this.config.marketId}&status=ACTIVE`;
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Snapshot fetch failed: ${response.status} ${response.statusText}`);
+            }
+            const data = (await response.json());
+            if (data.success && data.data) {
+                const orders = data.data.orders || data.data;
+                const snapshotSeq = data.data.seq || data.seq || 0;
+                this.dataMap.clear();
+                orders.forEach((order) => {
+                    this.dataMap.set(order.orderHash, order);
+                });
+                this.lastSeq = snapshotSeq;
+                this.notifySnapshotListeners(orders);
+            }
+        }
+        catch (error) {
+            console.error("Error fetching snapshot:", error);
+        }
+    }
+    applyMessage(message) {
+        const change = message.change;
+        switch (change.type) {
+            case "INSERT":
+                if (change.order) {
+                    this.dataMap.set(change.orderHash, change.order);
+                }
+                break;
+            case "UPDATE":
+                if (change.order) {
+                    // Only keep the order if it's still ACTIVE, otherwise remove it
+                    // (CANCELLED and FILLED orders should not be in the orderbook)
+                    if (change.order.status === OrderStatus.ACTIVE) {
+                        this.dataMap.set(change.orderHash, change.order);
+                    }
+                    else {
+                        this.dataMap.delete(change.orderHash);
+                    }
+                }
+                break;
+            case "DELETE":
+                this.dataMap.delete(change.orderHash);
+                break;
+        }
+        this.changeListeners.forEach((listener) => {
+            try {
+                listener(change);
+            }
+            catch (error) {
+                console.error("Error in change 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/messages?marketId=${this.config.marketId}&fromSeq=${fromSeq}&toSeq=${toSeq}`;
+            const response = await fetch(url);
+            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) {
+            await this.fullResync();
+            return [];
+        }
+    }
+    getOrders() {
+        return Array.from(this.dataMap.values());
+    }
+    getOrder(orderHash) {
+        return this.dataMap.get(orderHash);
+    }
+    startExpireCheck() {
+        // Clear any existing interval
+        if (this.expireCheckInterval) {
+            clearInterval(this.expireCheckInterval);
+        }
+        // Check for expired orders every 1 second
+        this.expireCheckInterval = setInterval(() => {
+            const now = Math.floor(Date.now() / 1000);
+            const expiredOrders = [];
+            for (const [orderHash, order] of this.dataMap.entries()) {
+                // Check if order has expired
+                if (order.expiresAt && order.expiresAt < now) {
+                    expiredOrders.push(orderHash);
+                }
+            }
+            // Remove expired orders and notify listeners
+            for (const orderHash of expiredOrders) {
+                this.dataMap.delete(orderHash);
+                const change = {
+                    type: "DELETE",
+                    orderHash,
+                };
+                this.changeListeners.forEach((listener) => {
+                    try {
+                        listener(change);
+                    }
+                    catch (error) {
+                        console.error("Error in change listener:", error);
+                    }
+                });
+            }
+        }, 1000);
+    }
+    async disconnect() {
+        // Clear expire check interval
+        if (this.expireCheckInterval) {
+            clearInterval(this.expireCheckInterval);
+            this.expireCheckInterval = null;
+        }
+        await super.disconnect();
+    }
+}

package/dist/sync/index.d.ts

@@ -0,0 +1,5 @@
+export { BaseSyncClient } from "./clients/base-client.js";
+export { OrderbookSyncClient } from "./clients/order-client.js";
+export { BalanceSyncClient } from "./clients/balance-client.js";
+export type { OrderChange, SequencedMessage, SyncClientConfig, SyncStatus, } from "./types.js";
+export type { BalanceData, BalanceUpdateMessage, BalanceSyncClientConfig, } from "./clients/balance-client.js";

package/dist/sync/index.js

@@ -0,0 +1,3 @@
+export { BaseSyncClient } from "./clients/base-client.js";
+export { OrderbookSyncClient } from "./clients/order-client.js";
+export { BalanceSyncClient } from "./clients/balance-client.js";

package/dist/sync/redis-ws-client.d.ts

@@ -0,0 +1,18 @@
+type Handler<T = any> = (data: T) => void;
+export declare class RedisWsClient {
+    private url;
+    private ws;
+    private handlers;
+    private heartbeat?;
+    constructor(url: string);
+    private connect;
+    private reconnect;
+    private startHeartbeat;
+    private stopHeartbeat;
+    subscribe<T>(channel: string, handler: Handler<T>): void;
+    unsubscribe(channel: string, handler?: Handler): void;
+    private subscribeInternal;
+    private unsubscribeInternal;
+    close(): void;
+}
+export {};

package/dist/sync/redis-ws-client.js

@@ -0,0 +1,88 @@
+export class RedisWsClient {
+    constructor(url) {
+        this.url = url;
+        this.handlers = new Map();
+        this.connect();
+    }
+    connect() {
+        this.ws = new WebSocket(this.url);
+        this.ws.onopen = () => {
+            this.startHeartbeat();
+            // Re-subscribe to all channels after reconnection
+            for (const channel of this.handlers.keys()) {
+                this.subscribeInternal(channel);
+            }
+        };
+        this.ws.onmessage = (event) => {
+            const message = event.data;
+            // Redis messages come directly as strings from the bridge
+            // Since we subscribe to one channel per client instance in practice,
+            // we can call all handlers
+            for (const handlers of this.handlers.values()) {
+                handlers.forEach((fn) => fn(message));
+            }
+        };
+        this.ws.onclose = () => this.reconnect();
+        this.ws.onerror = () => this.ws.close();
+    }
+    reconnect() {
+        this.stopHeartbeat();
+        setTimeout(() => this.connect(), 1000);
+    }
+    startHeartbeat() {
+        this.heartbeat = setInterval(() => {
+            if (this.ws.readyState === WebSocket.OPEN) {
+                this.ws.send(JSON.stringify({ type: "ping" }));
+            }
+        }, 20000);
+    }
+    stopHeartbeat() {
+        if (this.heartbeat)
+            clearInterval(this.heartbeat);
+    }
+    subscribe(channel, handler) {
+        if (!this.handlers.has(channel)) {
+            this.handlers.set(channel, new Set());
+            this.subscribeInternal(channel);
+        }
+        this.handlers.get(channel).add(handler);
+    }
+    unsubscribe(channel, handler) {
+        const handlers = this.handlers.get(channel);
+        if (!handlers)
+            return;
+        if (handler) {
+            handlers.delete(handler);
+            if (handlers.size === 0) {
+                this.handlers.delete(channel);
+                this.unsubscribeInternal(channel);
+            }
+        }
+        else {
+            this.handlers.delete(channel);
+            this.unsubscribeInternal(channel);
+        }
+    }
+    subscribeInternal(channel) {
+        if (this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify({
+                type: "subscribe",
+                channel,
+            }));
+        }
+    }
+    unsubscribeInternal(channel) {
+        if (this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify({
+                type: "unsubscribe",
+                channel,
+            }));
+        }
+    }
+    close() {
+        this.stopHeartbeat();
+        if (this.ws) {
+            this.ws.close();
+        }
+    }
+}

package/dist/sync/types.d.ts

@@ -0,0 +1,20 @@
+import type { StoredOrder } from "../shared/types.js";
+export type SyncStatus = "connecting" | "syncing" | "synced" | "recovering" | "disconnected" | "error";
+export interface OrderChange {
+    type: "INSERT" | "UPDATE" | "DELETE";
+    orderHash: string;
+    order?: StoredOrder;
+}
+export interface SequencedMessage {
+    seq: number;
+    marketId: string;
+    change: OrderChange;
+    timestamp: number;
+}
+export interface SyncClientConfig {
+    redisUrl: string;
+    gapRecoveryUrl?: string;
+    marketId: string;
+    snapshotUrl?: string;
+    channel?: string;
+}

package/dist/sync/types.js

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

package/dist/utils/mul-div.d.ts

@@ -0,0 +1,5 @@
+export declare enum Rounding {
+    Ceil = 0,
+    Floor = 1
+}
+export declare function mulDiv(a: bigint, b: bigint, x: bigint, rounding?: Rounding): bigint;

package/dist/utils/mul-div.js

@@ -0,0 +1,13 @@
+export var Rounding;
+(function (Rounding) {
+    Rounding[Rounding["Ceil"] = 0] = "Ceil";
+    Rounding[Rounding["Floor"] = 1] = "Floor";
+})(Rounding || (Rounding = {}));
+// todo: move to more appropriate place
+export function mulDiv(a, b, x, rounding = Rounding.Floor) {
+    const res = (a * b) / x;
+    if (rounding === Rounding.Ceil && (a * b) % x > 0) {
+        return res + 1n;
+    }
+    return res;
+}

package/dist/utils/orderUtils.d.ts

@@ -0,0 +1,19 @@
+import { type Hex } from "viem";
+import { LimitOrder } from "../limit-order";
+import type { OrderSignature } from "../shared/types.js";
+/**
+ * Build makerAssetSuffix for ERC6909 extension
+ */
+export declare function buildMakerAssetSuffix(tokenAddress: string, tokenId: Hex): string;
+/**
+ * Decode asset suffix (makerAssetSuffix or takerAssetSuffix) to extract token address and tokenId
+ * Format: 0x + [32 bytes padded token address] + [32 bytes tokenId] + [32 bytes offset] + [32 bytes length]
+ */
+export declare function decodeAssetSuffix(suffix: string): {
+    token: `0x${string}`;
+    tokenId: bigint;
+} | null;
+/**
+ * Verify order signature and recover signer address
+ */
+export declare function verifyOrderSignature(limitOrder: LimitOrder, signature: OrderSignature, chainId: number): Promise<string>;

package/dist/utils/orderUtils.js

@@ -0,0 +1,51 @@
+import { pad, toHex, recoverAddress, concat } from "viem";
+/**
+ * Build makerAssetSuffix for ERC6909 extension
+ */
+export function buildMakerAssetSuffix(tokenAddress, tokenId) {
+    const tokenPadded = pad(tokenAddress, { size: 32 }).slice(2);
+    const tokenIdPadded = pad(tokenId, { size: 32 }).slice(2);
+    const offsetPadded = pad(toHex(192), { size: 32 }).slice(2);
+    const lengthPadded = pad(toHex(0), { size: 32 }).slice(2);
+    return "0x" + tokenPadded + tokenIdPadded + offsetPadded + lengthPadded;
+}
+/**
+ * Decode asset suffix (makerAssetSuffix or takerAssetSuffix) to extract token address and tokenId
+ * Format: 0x + [32 bytes padded token address] + [32 bytes tokenId] + [32 bytes offset] + [32 bytes length]
+ */
+export function decodeAssetSuffix(suffix) {
+    if (suffix === "0x" || suffix.length < 130)
+        return null;
+    const data = suffix.slice(2); // Remove 0x prefix
+    if (data.length < 128)
+        return null; // Need at least 64 bytes (128 hex chars) for address + tokenId
+    // Token address is in the last 20 bytes (40 hex chars) of the first 32-byte chunk
+    // Bytes 0-31: padded address (address is in bytes 12-31, hex chars 24-64)
+    const tokenAddressHex = ("0x" + data.slice(24, 64));
+    // TokenId is in the second 32-byte chunk
+    // Bytes 32-63: tokenId (hex chars 64-128)
+    const tokenIdHex = "0x" + data.slice(64, 128);
+    const tokenId = BigInt(tokenIdHex);
+    return {
+        token: tokenAddressHex,
+        tokenId,
+    };
+}
+/**
+ * Verify order signature and recover signer address
+ */
+export async function verifyOrderSignature(limitOrder, signature, chainId) {
+    const orderHash = limitOrder.getOrderHash(chainId);
+    // Extract v from vs
+    const vsBigInt = BigInt(signature.vs);
+    const v = vsBigInt >> BigInt(255) === BigInt(1) ? 28 : 27;
+    const sMask = (BigInt(1) << BigInt(255)) - BigInt(1);
+    const s = pad(toHex(vsBigInt & sMask), { size: 32 });
+    // Reconstruct full signature
+    const fullSignature = concat([signature.r, s, toHex(v)]);
+    const recoveredAddress = await recoverAddress({
+        hash: orderHash,
+        signature: fullSignature,
+    });
+    return recoveredAddress.toLowerCase();
+}

package/dist/utils/rand-bigint.d.ts

@@ -0,0 +1 @@
+export declare function randBigInt(max: number | bigint): bigint;

package/dist/utils/rand-bigint.js

@@ -0,0 +1,13 @@
+import { randomBytes } from 'ethers';
+export function randBigInt(max) {
+    let bytesCount = 0;
+    max = BigInt(max) + 1n;
+    let rest = max;
+    while (rest) {
+        rest = rest >> 8n;
+        bytesCount += 1;
+    }
+    const bytes = randomBytes(bytesCount);
+    const val = bytes.reduce((acc, val, i) => acc + (BigInt(val) << BigInt(i * 8)), 0n);
+    return val % max;
+}

package/dist/utils/rand-bigint.spec.d.ts

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

package/dist/utils/rand-bigint.spec.js

@@ -0,0 +1,11 @@
+import { randBigInt } from './rand-bigint.js';
+describe('randBigint', () => {
+    it('should generate rand bigint in correct interval', () => {
+        expect(randBigInt(1)).toBeGreaterThanOrEqual(0n);
+        expect(randBigInt(1)).toBeLessThanOrEqual(1n);
+        expect(randBigInt(10n)).toBeGreaterThanOrEqual(0);
+        expect(randBigInt(10n)).toBeLessThanOrEqual(10n);
+        expect(randBigInt(2n << 96n)).toBeGreaterThanOrEqual(0);
+        expect(randBigInt(2n << 96n)).toBeLessThanOrEqual(2n << 96n);
+    });
+});

package/dist/validations.d.ts

@@ -0,0 +1 @@
+export declare function isInt(val: number): boolean;

package/dist/validations.js

@@ -0,0 +1,3 @@
+export function isInt(val) {
+    return Math.floor(val) === val;
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@stryke-xyz/premarket-sdk",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test",
+    "test:e2e": "bun test test/e2e/index.test.ts",
+    "ponder:codegen": "genql --schema ./src/ponder/schema.graphql --output ./src/ponder/generated",
+    "fill-orderbook": "bun run scripts/fill-orderbook.ts"
+  },
+  "dependencies": {
+    "@1inch/byte-utils": "3.0.0",
+    "ethers": "6.13.5"
+  },
+  "devDependencies": {
+    "@1inch/eslint-config": "3.0.7",
+    "@1inch/tsconfig": "^1.0.9",
+    "@swc/cli": "0.7.7",
+    "@swc/core": "^1.13.3",
+    "@swc/jest": "^0.2.39",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.17.0",
+    "@typescript-eslint/eslint-plugin": "~8.20.0",
+    "@typescript-eslint/parser": "~8.20.0",
+    "axios": "^1.12.0",
+    "eslint": "^9.32.0",
+    "eslint-config-prettier": "~10.1.8",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-import-resolver-typescript": "3.7.0",
+    "eslint-plugin-import": "~2.31.0",
+    "eslint-plugin-n": "^17.21.3",
+    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-promise": "^7.2.1",
+    "eslint-plugin-unused-imports": "^4.1.4",
+    "generate-changelog": "1.8.0",
+    "jest": "^30.0.5",
+    "prettier": "^3.6.2",
+    "testcontainers": "^11.5.1",
+    "tsdoc-markdown": "^1.4.1",
+    "tslib": "2.8.1",
+    "typescript": "5.8.3",
+    "bun-types": "^1.0.0",
+    "@genql/cli": "^3.0.0",
+    "viem": "^2.7.0"
+  }
+}