@stryke-xyz/premarket-sdk 1.0.0

package/dist/limit-order-contract/limit-order-contract.js

@@ -0,0 +1,79 @@
+import { Interface, Signature } from 'ethers';
+import assert from 'assert';
+import LOP_V4_ABI from '../abi/AggregationRouterV6.abi.json' with { type: 'json' };
+import { ZX } from '../constants.js';
+const lopContract = new Interface(LOP_V4_ABI);
+/**
+ * @see https://github.com/1inch/limit-order-protocol/blob/3169ea46932ef44114a215a60d1d91ef022b416d/contracts/OrderMixin.sol#L27
+ */
+export class LimitOrderContract {
+    /**
+     *  Fill order WITHOUT an extension and taker interaction
+     *
+     *  @see getFillOrderArgsCalldata
+     *  @see getFillContractOrderCalldata
+     */
+    static getFillOrderCalldata(order, signature, takerTraits, amount) {
+        const { r, yParityAndS: vs } = Signature.from(signature);
+        const { args, trait } = takerTraits.encode();
+        assert(args === ZX, 'takerTraits contains args data, use LimitOrderContract.getFillOrderArgsCalldata method');
+        return lopContract.encodeFunctionData('fillOrder', [
+            order,
+            r,
+            vs,
+            amount,
+            trait
+        ]);
+    }
+    /**
+     *  Fill contract order (order maker is smart-contract) WITHOUT an extension and taker interaction
+     *
+     *  @see getFillContractOrderArgsCalldata
+     *  @see getFillOrderCalldata
+     */
+    static getFillContractOrderCalldata(order, signature, takerTraits, amount) {
+        const { args, trait } = takerTraits.encode();
+        assert(args === ZX, 'takerTraits contains args data, use LimitOrderContract.getFillContractOrderArgsCalldata method');
+        return lopContract.encodeFunctionData('fillContractOrder', [
+            order,
+            signature,
+            amount,
+            trait,
+            args
+        ]);
+    }
+    /**
+     *  Fill order WITH an extension or taker interaction
+     *
+     *  @see getFillOrderCalldata
+     *  @see getFillContractOrderArgsCalldata
+     */
+    static getFillOrderArgsCalldata(order, signature, takerTraits, amount) {
+        const { r, yParityAndS: vs } = Signature.from(signature);
+        const { args, trait } = takerTraits.encode();
+        return lopContract.encodeFunctionData('fillOrderArgs', [
+            order,
+            r,
+            vs,
+            amount,
+            trait,
+            args
+        ]);
+    }
+    /**
+     *  Fill contract order (order maker is smart-contract) WITH an extension or taker interaction
+     *
+     *  @see getFillOrderArgsCalldata
+     *  @see getFillContractOrderCalldata
+     */
+    static getFillContractOrderArgsCalldata(order, signature, takerTraits, amount) {
+        const { args, trait } = takerTraits.encode();
+        return lopContract.encodeFunctionData('fillContractOrderArgs', [
+            order,
+            signature,
+            amount,
+            trait,
+            args
+        ]);
+    }
+}

package/dist/limit-order-contract/native-order-factory.d.ts

@@ -0,0 +1,10 @@
+import { CallInfo } from './types.js';
+import { LimitOrderV4Struct } from '../limit-order/index.js';
+import { Address } from '../address.js';
+export declare class NativeOrdersFactory {
+    readonly address: Address;
+    private readonly iface;
+    constructor(address: Address);
+    static default(chainId: number): NativeOrdersFactory;
+    create(maker: Address, order: LimitOrderV4Struct): CallInfo;
+}

package/dist/limit-order-contract/native-order-factory.js

@@ -0,0 +1,22 @@
+import { Interface } from 'ethers';
+import ABI from '../abi/NativeOrderFactory.abi.json' with { type: 'json' };
+import { Address } from '../address.js';
+import { getNativeOrderFactoryContract } from '../constants.js';
+export class NativeOrdersFactory {
+    constructor(address) {
+        this.address = address;
+        this.iface = new Interface(ABI);
+    }
+    static default(chainId) {
+        return new NativeOrdersFactory(new Address(getNativeOrderFactoryContract(chainId)));
+    }
+    create(maker, order) {
+        return {
+            to: this.address,
+            value: BigInt(order.makingAmount),
+            data: this.iface.encodeFunctionData('create', [
+                { ...order, maker: maker.toString() }
+            ])
+        };
+    }
+}

package/dist/limit-order-contract/native-order-impl.d.ts

@@ -0,0 +1,10 @@
+import { CallInfo } from './types.js';
+import { LimitOrderV4Struct } from '../limit-order/index.js';
+import { Address } from '../address.js';
+export declare class NativeOrdersImpl {
+    readonly address: Address;
+    private readonly iface;
+    constructor(address: Address);
+    cancel(maker: Address, order: LimitOrderV4Struct): CallInfo;
+    cancelExpiredOrderByResolver(maker: Address, order: LimitOrderV4Struct, rewardLimit: bigint): CallInfo;
+}

package/dist/limit-order-contract/native-order-impl.js

@@ -0,0 +1,24 @@
+import { Interface } from 'ethers';
+import ABI from '../abi/NativeOrderImpl.abi.json' with { type: 'json' };
+export class NativeOrdersImpl {
+    constructor(address) {
+        this.address = address;
+        this.iface = new Interface(ABI);
+    }
+    cancel(maker, order) {
+        return {
+            to: this.address,
+            value: 0n,
+            data: this.iface.encodeFunctionData('cancelOrder', [
+                { ...order, maker: maker.toString() }
+            ])
+        };
+    }
+    cancelExpiredOrderByResolver(maker, order, rewardLimit) {
+        return {
+            to: this.address,
+            value: 0n,
+            data: this.iface.encodeFunctionData('cancelExpiredOrderByResolver', [{ ...order, maker: maker.toString() }, rewardLimit])
+        };
+    }
+}

package/dist/limit-order-contract/proxy-factory.d.ts

@@ -0,0 +1,20 @@
+import { Address } from '../address.js';
+export declare class ProxyFactory {
+    readonly factory: Address;
+    readonly implementation: Address;
+    constructor(factory: Address, implementation: Address);
+    static default(chainId: number): ProxyFactory;
+    /**
+     * See https://github.com/1inch/cross-chain-swap/blob/03d99b9604d8f7a5a396720fbe1059f7d94db762/contracts/libraries/ProxyHashLib.sol#L14
+     */
+    private static calcProxyBytecodeHash;
+    /**
+     * Calculates deterministic address of proxy contract
+     *
+     * @see https://github.com/OpenZeppelin/openzeppelin-contracts/blob/69c8def5f222ff96f2b5beff05dfba996368aa79/contracts/proxy/Clones.sol#L60
+     *
+     * @param salt must be valid hex string
+     * @returns address of proxy contract
+     */
+    getProxyAddress(salt: string): Address;
+}

package/dist/limit-order-contract/proxy-factory.js

@@ -0,0 +1,32 @@
+import { isHexBytes, trim0x } from '@1inch/byte-utils';
+import { getCreate2Address, keccak256 } from 'ethers';
+import assert from 'assert';
+import { Address } from '../address.js';
+import { getNativeOrderFactoryContract, getNativeOrderImplContract } from '../constants.js';
+export class ProxyFactory {
+    constructor(factory, implementation) {
+        this.factory = factory;
+        this.implementation = implementation;
+    }
+    static default(chainId) {
+        return new ProxyFactory(new Address(getNativeOrderFactoryContract(chainId)), new Address(getNativeOrderImplContract(chainId)));
+    }
+    /**
+     * See https://github.com/1inch/cross-chain-swap/blob/03d99b9604d8f7a5a396720fbe1059f7d94db762/contracts/libraries/ProxyHashLib.sol#L14
+     */
+    static calcProxyBytecodeHash(impl) {
+        return keccak256(`0x3d602d80600a3d3981f3363d3d373d3d3d363d73${trim0x(impl.toString())}5af43d82803e903d91602b57fd5bf3`);
+    }
+    /**
+     * Calculates deterministic address of proxy contract
+     *
+     * @see https://github.com/OpenZeppelin/openzeppelin-contracts/blob/69c8def5f222ff96f2b5beff05dfba996368aa79/contracts/proxy/Clones.sol#L60
+     *
+     * @param salt must be valid hex string
+     * @returns address of proxy contract
+     */
+    getProxyAddress(salt) {
+        assert(isHexBytes(salt), 'invalid salt');
+        return new Address(getCreate2Address(this.factory.toString(), salt, ProxyFactory.calcProxyBytecodeHash(this.implementation)));
+    }
+}

package/dist/limit-order-contract/proxy-factory.spec.d.ts

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

package/dist/limit-order-contract/proxy-factory.spec.js

@@ -0,0 +1,16 @@
+import { Address } from './../address.js';
+import { ProxyFactory } from './proxy-factory.js';
+describe('ProxyFactory', () => {
+    it('should correct calc proxy address for Ethereum', () => {
+        const facade = new ProxyFactory(new Address('0x4bc5a9d205adf1091d596bc2e1aa0d6b9dc3b12c'), new Address('0xfbc2d33fc6c7fadb155974b847dc04f39010caa9'));
+        const salt = '0x3fccfe0035a1010d48c1573e1fc78290082e778619ddb01429af83b5f3faf29c';
+        const address = facade.getProxyAddress(salt);
+        expect(address).toEqual(new Address('0x762bef5aa97185121b080f6cacb58901fe1e7751'));
+    });
+    it('should correct calc proxy address 2', () => {
+        const facade = new ProxyFactory(new Address('0x584aEaB186D81dbB52a8a14820c573480c3d4773'), new Address('0xddc60c7babfc55d8030f51910b157e179f7a41fc'));
+        const salt = '0x7d1798e1fe1eef8c94c50886f476477781a4d56f4126ae8a3a88f5546649d153';
+        const address = facade.getProxyAddress(salt);
+        expect(address).toEqual(new Address('0xf81af95bb417a82923e5fa001b1e052034026e64'));
+    });
+});

package/dist/limit-order-contract/types.d.ts

@@ -0,0 +1,6 @@
+import { Address } from '../address.js';
+export type CallInfo = {
+    data: string;
+    to: Address;
+    value: bigint;
+};

package/dist/limit-order-contract/types.js

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

package/dist/ponder/client/index.d.ts

@@ -0,0 +1,23 @@
+import type { PonderClientConfig } from "../types.js";
+import { type MarketData, type MarketPositions } from "./queries/markets.js";
+export * from "./types/index.js";
+export type { MarketData, MarketPositions } from "./queries/markets.js";
+export declare class PonderClient {
+    private client;
+    constructor(config: PonderClientConfig);
+    getMarkets(): Promise<import("./index.js").OptionMarket[]>;
+    getMarket(marketId: string): Promise<import("./index.js").OptionMarket | null>;
+    getMarketData(marketId: string): Promise<MarketData | null>;
+    getMarketPositions(marketId: string): Promise<MarketPositions>;
+    getUserCollateralPositions(userAddress: string, marketId: string): Promise<import("./index.js").CollateralPosition[]>;
+    getUserOptionPositions(userAddress: string, marketId: string): Promise<import("./index.js").OptionPosition[]>;
+    getUserHistories(userAddress: string, marketId: string): Promise<import("./index.js").UserHistories>;
+    getAllUserOptionPositions(userAddress: string): Promise<import("./index.js").OptionPosition[]>;
+    getAllUserCollateralPositions(userAddress: string): Promise<import("./index.js").CollateralPosition[]>;
+    getHourlyVolumes(marketId: string, startTimestamp: bigint, endTimestamp: bigint): Promise<import("./index.js").HourlyVolume[]>;
+    get24hVolume(marketId: string, optionId: string): Promise<{
+        totalVolume: bigint;
+        tradeVolume: bigint;
+        tradeCount: number;
+    }>;
+}

package/dist/ponder/client/index.js

@@ -0,0 +1,44 @@
+import { createClient } from "../generated/index.js";
+import { getMarkets, getMarket, getMarketData, getMarketPositions, getHourlyVolumes, get24hVolume, } from "./queries/markets.js";
+import { getUserCollateralPositions, getUserOptionPositions, getUserHistories, getAllUserOptionPositions, getAllUserCollateralPositions, } from "./queries/positions.js";
+export * from "./types/index.js";
+export class PonderClient {
+    constructor(config) {
+        this.client = createClient({
+            url: config.graphqlUrl,
+        });
+    }
+    async getMarkets() {
+        return getMarkets(this.client);
+    }
+    async getMarket(marketId) {
+        return getMarket(this.client, marketId);
+    }
+    async getMarketData(marketId) {
+        return getMarketData(this.client, marketId);
+    }
+    async getMarketPositions(marketId) {
+        return getMarketPositions(this.client, marketId);
+    }
+    async getUserCollateralPositions(userAddress, marketId) {
+        return getUserCollateralPositions(this.client, userAddress, marketId);
+    }
+    async getUserOptionPositions(userAddress, marketId) {
+        return getUserOptionPositions(this.client, userAddress, marketId);
+    }
+    async getUserHistories(userAddress, marketId) {
+        return getUserHistories(this.client, userAddress, marketId);
+    }
+    async getAllUserOptionPositions(userAddress) {
+        return getAllUserOptionPositions(this.client, userAddress);
+    }
+    async getAllUserCollateralPositions(userAddress) {
+        return getAllUserCollateralPositions(this.client, userAddress);
+    }
+    async getHourlyVolumes(marketId, startTimestamp, endTimestamp) {
+        return getHourlyVolumes(this.client, marketId, startTimestamp, endTimestamp);
+    }
+    async get24hVolume(marketId, optionId) {
+        return get24hVolume(this.client, marketId, optionId);
+    }
+}

package/dist/ponder/client/queries/markets.d.ts

@@ -0,0 +1,30 @@
+import type { Client } from "../../generated/index.js";
+import type { OptionMarket, CollateralPosition, OptionPosition, HourlyVolume } from "../types/index.js";
+export interface MarketData {
+    market: OptionMarket;
+    collateralPositions: CollateralPosition[];
+    optionPositions: OptionPosition[];
+}
+export declare function getMarketData(client: Client, marketId: string): Promise<MarketData | null>;
+export declare function getMarkets(client: Client): Promise<OptionMarket[]>;
+export declare function getMarket(client: Client, marketId: string): Promise<OptionMarket | null>;
+export interface MarketPositions {
+    collateralPositions: CollateralPosition[];
+    optionPositions: OptionPosition[];
+}
+export declare function getMarketPositions(client: Client, marketId: string): Promise<MarketPositions>;
+/**
+ * Get hourly volume data for a market within a time range
+ * @param marketId - The market ID
+ * @param startTimestamp - Start of the time range (unix timestamp)
+ * @param endTimestamp - End of the time range (unix timestamp)
+ */
+export declare function getHourlyVolumes(client: Client, marketId: string, startTimestamp: bigint, endTimestamp: bigint): Promise<HourlyVolume[]>;
+/**
+ * Get 24h volume for a specific band (optionId)
+ */
+export declare function get24hVolume(client: Client, marketId: string, optionId: string): Promise<{
+    totalVolume: bigint;
+    tradeVolume: bigint;
+    tradeCount: number;
+}>;

package/dist/ponder/client/queries/markets.js

@@ -0,0 +1,200 @@
+import { convertBigIntFields } from "../utils.js";
+import { serializeOptionMarket, serializeCollateralPosition, serializeOptionPosition, serializeHourlyVolume, } from "../types/serializers.js";
+export async function getMarketData(client, marketId) {
+    const result = await client.query({
+        optionMarket: {
+            __args: { id: marketId },
+            id: true,
+            callToken: true,
+            putToken: true,
+            expiry: true,
+            maxTTL: true,
+            strategy: {
+                id: true,
+                finalFDV: true,
+                deadline: true,
+                bandPrecision: true,
+                collateralPerBandPrecision: true,
+                premiumRate: true,
+                depositFeeRate: true,
+                purchaseFeeRate: true,
+                settlementFeeRate: true,
+                collateralToken: true,
+            },
+            collateralToken: true,
+            totalCollateral: true,
+            totalCollateralAmount: true,
+            protocolFees: true,
+            collateralPositions: {
+                __args: { where: { optionMarketId: marketId }, limit: 1000 },
+                items: {
+                    id: true,
+                    totalCollateral: true,
+                    optionsMinted: true,
+                    optionsExercised: true,
+                    settled: true,
+                    fee: true,
+                },
+            },
+            optionPositions: {
+                __args: { where: { optionMarketId: marketId }, limit: 1000 },
+                items: {
+                    id: true,
+                    address: true,
+                    premium: true,
+                    fee: true,
+                    profit: true,
+                    amount: true,
+                    averagePrice: true,
+                },
+            },
+        },
+    });
+    if (!result.optionMarket)
+        return null;
+    const converted = convertBigIntFields({
+        market: result.optionMarket,
+        collateralPositions: result.optionMarket.collateralPositions?.items || [],
+        optionPositions: result.optionMarket.optionPositions?.items || [],
+    });
+    const marketData = converted;
+    return {
+        market: serializeOptionMarket(marketData.market),
+        collateralPositions: marketData.collateralPositions.map(serializeCollateralPosition),
+        optionPositions: marketData.optionPositions.map(serializeOptionPosition),
+    };
+}
+export async function getMarkets(client) {
+    const result = await client.query({
+        optionMarkets: {
+            __args: {},
+            items: {
+                id: true,
+                callToken: true,
+                putToken: true,
+                expiry: true,
+                maxTTL: true,
+                strategy: {
+                    id: true,
+                    finalFDV: true,
+                    deadline: true,
+                    bandPrecision: true,
+                    collateralPerBandPrecision: true,
+                    premiumRate: true,
+                    depositFeeRate: true,
+                    purchaseFeeRate: true,
+                    settlementFeeRate: true,
+                    collateralToken: true,
+                },
+                collateralToken: true,
+                totalCollateral: true,
+                totalCollateralAmount: true,
+                protocolFees: true,
+            },
+        },
+    });
+    const converted = convertBigIntFields(result.optionMarkets.items || []);
+    if (!Array.isArray(converted)) {
+        throw new Error("Expected array of markets");
+    }
+    return converted.map((item) => serializeOptionMarket(item));
+}
+export async function getMarket(client, marketId) {
+    const result = await client.query({
+        optionMarket: {
+            __args: { id: marketId },
+            id: true,
+            callToken: true,
+            putToken: true,
+            expiry: true,
+            maxTTL: true,
+            strategy: {
+                id: true,
+                finalFDV: true,
+                deadline: true,
+                bandPrecision: true,
+                collateralPerBandPrecision: true,
+                premiumRate: true,
+                depositFeeRate: true,
+                purchaseFeeRate: true,
+                settlementFeeRate: true,
+                collateralToken: true,
+            },
+            collateralToken: true,
+            totalCollateral: true,
+            totalCollateralAmount: true,
+            protocolFees: true,
+        },
+    });
+    if (!result.optionMarket)
+        return null;
+    const converted = convertBigIntFields(result.optionMarket);
+    return serializeOptionMarket(converted);
+}
+export async function getMarketPositions(client, marketId) {
+    const marketData = await getMarketData(client, marketId);
+    if (!marketData) {
+        return { collateralPositions: [], optionPositions: [] };
+    }
+    return {
+        collateralPositions: marketData.collateralPositions,
+        optionPositions: marketData.optionPositions,
+    };
+}
+/**
+ * Get hourly volume data for a market within a time range
+ * @param marketId - The market ID
+ * @param startTimestamp - Start of the time range (unix timestamp)
+ * @param endTimestamp - End of the time range (unix timestamp)
+ */
+export async function getHourlyVolumes(client, marketId, startTimestamp, endTimestamp) {
+    const result = await client.query({
+        hourlyVolumes: {
+            __args: {
+                where: {
+                    marketId: BigInt(marketId),
+                    hourTimestamp_gte: startTimestamp,
+                    hourTimestamp_lte: endTimestamp,
+                },
+                limit: 1000,
+            },
+            items: {
+                id: true,
+                marketId: true,
+                optionId: true,
+                hourTimestamp: true,
+                depositVolume: true,
+                tradeVolume: true,
+                unwindVolume: true,
+                withdrawVolume: true,
+                exerciseVolume: true,
+                totalVolume: true,
+                tradeCount: true,
+            },
+        },
+    });
+    const converted = convertBigIntFields(result.hourlyVolumes?.items || []);
+    if (!Array.isArray(converted)) {
+        throw new Error("Expected array of hourly volumes");
+    }
+    return converted.map((item) => serializeHourlyVolume(item));
+}
+/**
+ * Get 24h volume for a specific band (optionId)
+ */
+export async function get24hVolume(client, marketId, optionId) {
+    const now = BigInt(Math.floor(Date.now() / 1000));
+    const twentyFourHoursAgo = now - 86400n;
+    const volumes = await getHourlyVolumes(client, marketId, twentyFourHoursAgo, now);
+    // Filter by optionId and sum
+    const bandVolumes = volumes.filter((v) => v.optionId === optionId);
+    let totalVolume = 0n;
+    let tradeVolume = 0n;
+    let tradeCount = 0;
+    for (const v of bandVolumes) {
+        totalVolume += v.totalVolume;
+        tradeVolume += v.tradeVolume;
+        tradeCount += v.tradeCount;
+    }
+    return { totalVolume, tradeVolume, tradeCount };
+}

package/dist/ponder/client/queries/positions.d.ts

@@ -0,0 +1,13 @@
+import type { Client } from "../../generated/index.js";
+import type { CollateralPosition, OptionPosition, UserHistories } from "../types/index.js";
+export declare function getUserCollateralPositions(client: Client, userAddress: string, marketId: string): Promise<CollateralPosition[]>;
+export declare function getUserOptionPositions(client: Client, userAddress: string, marketId: string): Promise<OptionPosition[]>;
+/**
+ * Get all user option positions across all markets
+ */
+export declare function getAllUserOptionPositions(client: Client, userAddress: string): Promise<OptionPosition[]>;
+/**
+ * Get all user collateral positions across all markets
+ */
+export declare function getAllUserCollateralPositions(client: Client, userAddress: string): Promise<CollateralPosition[]>;
+export declare function getUserHistories(client: Client, userAddress: string, marketId: string): Promise<UserHistories>;