@stryke-xyz/premarket-sdk 1.0.0

package/dist/api/order-helper.js

@@ -0,0 +1,112 @@
+import { pad, toHex } from "viem";
+import { LimitOrder, MakerTraits, ExtensionBuilder } from "../limit-order";
+import { Address as OneInchAddress } from "../address";
+import { randBigInt } from "../utils/rand-bigint";
+import { buildMakerAssetSuffix } from "../utils/orderUtils";
+import { calculateOptionTokenId as sharedCalculateOptionTokenId } from "../shared/utils.js";
+const UINT_40_MAX = (1n << 40n) - 1n;
+export class OrderHelper {
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Calculate option token ID from option parameters
+     * Delegates to shared utility function
+     */
+    calculateOptionTokenId(option) {
+        return sharedCalculateOptionTokenId(option);
+    }
+    /**
+     * Build sell options order
+     */
+    buildSellOptionsOrder(params) {
+        const optionTokenId = this.calculateOptionTokenId(params.option);
+        const makerAssetSuffix = buildMakerAssetSuffix(this.config.optionTokenFactoryAddress, optionTokenId);
+        const extension = new ExtensionBuilder()
+            .withMakerAssetSuffix(makerAssetSuffix)
+            .build();
+        const makerTraits = MakerTraits.default()
+            .withNonce(randBigInt(UINT_40_MAX))
+            .withExtension()
+            .allowPartialFills()
+            .allowMultipleFills();
+        if (params.expiresAt) {
+            makerTraits.withExpiration(params.expiresAt);
+        }
+        const order = new LimitOrder({
+            makerAsset: new OneInchAddress(params.makerProxyAddress),
+            takerAsset: new OneInchAddress(params.stableToken),
+            makingAmount: BigInt(params.optionAmount),
+            takingAmount: BigInt(params.stableAmount),
+            maker: new OneInchAddress(params.maker),
+        }, makerTraits, extension);
+        return {
+            order,
+            optionTokenId,
+            calldata: order.toCalldata(),
+            extensionEncoded: extension.encode(),
+        };
+    }
+    /**
+     * Build buy options order
+     * For buy orders:
+     * - Maker gives: USDC (ERC20) - no suffix needed
+     * - Maker receives: Options (ERC6909) - needs takerAssetSuffix
+     */
+    buildBuyOptionsOrder(params) {
+        const optionTokenId = this.calculateOptionTokenId(params.option);
+        // For buy orders, the taker asset is ERC6909 options, so we use takerAssetSuffix
+        const takerAssetSuffix = buildMakerAssetSuffix(this.config.optionTokenFactoryAddress, optionTokenId);
+        const extension = new ExtensionBuilder()
+            .withTakerAssetSuffix(takerAssetSuffix)
+            .build();
+        const makerTraits = MakerTraits.default()
+            .withNonce(randBigInt(UINT_40_MAX))
+            .withExtension()
+            .allowPartialFills()
+            .allowMultipleFills();
+        if (params.expiresAt) {
+            makerTraits.withExpiration(params.expiresAt);
+        }
+        const order = new LimitOrder({
+            makerAsset: new OneInchAddress(params.stableToken),
+            takerAsset: new OneInchAddress(params.makerProxyAddress),
+            makingAmount: BigInt(params.stableAmount),
+            takingAmount: BigInt(params.optionAmount),
+            maker: new OneInchAddress(params.maker),
+        }, makerTraits, extension);
+        return {
+            order,
+            optionTokenId,
+            calldata: order.toCalldata(),
+            extensionEncoded: extension.encode(),
+        };
+    }
+    /**
+     * Sign an order with wallet client
+     */
+    async signOrder(order, walletClient) {
+        const account = walletClient.account;
+        if (!account)
+            throw new Error("No account connected");
+        const typedData = order.getTypedData(this.config.chainId);
+        const signature = await walletClient.signTypedData({
+            account,
+            domain: typedData.domain,
+            types: { Order: typedData.types.Order },
+            primaryType: "Order",
+            message: typedData.message,
+        });
+        // Convert to r, vs format
+        const rHex = signature.slice(0, 66);
+        const r = pad(rHex, { size: 32 });
+        const sHex = `0x${signature.slice(66, 130)}`;
+        const vHex = signature.slice(130, 132);
+        const v = parseInt(vHex, 16);
+        const sBigInt = BigInt(sHex);
+        const vBit = v === 28 ? BigInt(1) << BigInt(255) : BigInt(0);
+        const vsBigInt = vBit | sBigInt;
+        const vs = pad(toHex(vsBigInt), { size: 32 });
+        return { r, vs };
+    }
+}

package/dist/api/orderbook-api.d.ts

@@ -0,0 +1,36 @@
+import type { StoredOrder, CreateOrderParams, Option } from "../shared/types.js";
+export type { StoredOrder, CreateOrderParams, Option };
+export interface OrderbookApiConfig {
+    baseUrl: string;
+}
+/**
+ * Orderbook API client
+ */
+export declare class OrderbookApi {
+    private readonly config;
+    constructor(config: OrderbookApiConfig);
+    /**
+     * Create a new order
+     */
+    createOrder(params: CreateOrderParams): Promise<StoredOrder>;
+    /**
+     * Get order by hash
+     */
+    getOrder(orderHash: string): Promise<StoredOrder | null>;
+    /**
+     * Get orders for a market
+     */
+    getOrdersByMarket(marketId: string): Promise<StoredOrder[]>;
+    /**
+     * Get orders by option token ID
+     */
+    getOrdersByOptionId(optionTokenId: string): Promise<StoredOrder[]>;
+    /**
+     * Get active orders
+     */
+    getActiveOrders(): Promise<StoredOrder[]>;
+    /**
+     * Cancel order
+     */
+    cancelOrder(orderHash: string, maker: string): Promise<void>;
+}

package/dist/api/orderbook-api.js

@@ -0,0 +1,69 @@
+/**
+ * Orderbook API client
+ */
+export class OrderbookApi {
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Create a new order
+     */
+    async createOrder(params) {
+        const response = await fetch(`${this.config.baseUrl}/api/orders`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(params),
+        });
+        const data = await response.json();
+        if (!data.success) {
+            throw new Error(data.error || "Failed to create order");
+        }
+        return data.data;
+    }
+    /**
+     * Get order by hash
+     */
+    async getOrder(orderHash) {
+        const response = await fetch(`${this.config.baseUrl}/api/orders/${orderHash}`);
+        const data = await response.json();
+        return data.success ? data.data : null;
+    }
+    /**
+     * Get orders for a market
+     */
+    async getOrdersByMarket(marketId) {
+        const response = await fetch(`${this.config.baseUrl}/api/orders?marketId=${marketId}`);
+        const data = await response.json();
+        return data.success ? data.data.orders : [];
+    }
+    /**
+     * Get orders by option token ID
+     */
+    async getOrdersByOptionId(optionTokenId) {
+        const response = await fetch(`${this.config.baseUrl}/api/orders?optionTokenId=${optionTokenId}`);
+        const data = await response.json();
+        return data.success ? data.data.orders : [];
+    }
+    /**
+     * Get active orders
+     */
+    async getActiveOrders() {
+        const response = await fetch(`${this.config.baseUrl}/api/orders/active`);
+        const data = await response.json();
+        return data.success ? data.data.orders : [];
+    }
+    /**
+     * Cancel order
+     */
+    async cancelOrder(orderHash, maker) {
+        const response = await fetch(`${this.config.baseUrl}/api/orders/${orderHash}/cancel`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ maker }),
+        });
+        const data = await response.json();
+        if (!data.success) {
+            throw new Error(data.error || "Failed to cancel order");
+        }
+    }
+}

package/dist/bps.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Basis point in range [0, 100]%
+ *
+ * 1bps = 0.01%
+ */
+export declare class Bps {
+    readonly value: bigint;
+    static ZERO: Bps;
+    constructor(value: bigint);
+    /**
+     * Create BPS from percent value.
+     * If `value` has precision more than 1bps (with accounting to `base`), it will be rounded down
+     * @param val
+     * @param base what represents 100%
+     */
+    static fromPercent(val: number, base?: bigint): Bps;
+    /**
+     * Create BPS from fraction value.
+     * If `value` has precision more than 1bps (with accounting to `base`), it will be rounded down
+     * @param val
+     * @param base what represents 100%
+     */
+    static fromFraction(val: number, base?: bigint): Bps;
+    equal(other: Bps): boolean;
+    isZero(): boolean;
+    /**
+     * @param base what represents 100%
+     */
+    toPercent(base?: bigint): number;
+    /**
+     * @param base what represents 100%
+     */
+    toFraction(base?: bigint): number;
+    toString(): string;
+}

package/dist/bps.js

@@ -0,0 +1,52 @@
+import assert from 'assert';
+/**
+ * Basis point in range [0, 100]%
+ *
+ * 1bps = 0.01%
+ */
+export class Bps {
+    constructor(value) {
+        this.value = value;
+        assert(value >= 0 && value <= 10000, `invalid bps ${value}`);
+    }
+    /**
+     * Create BPS from percent value.
+     * If `value` has precision more than 1bps (with accounting to `base`), it will be rounded down
+     * @param val
+     * @param base what represents 100%
+     */
+    static fromPercent(val, base = 1n) {
+        return new Bps(BigInt(100 * val) / base);
+    }
+    /**
+     * Create BPS from fraction value.
+     * If `value` has precision more than 1bps (with accounting to `base`), it will be rounded down
+     * @param val
+     * @param base what represents 100%
+     */
+    static fromFraction(val, base = 1n) {
+        return new Bps(BigInt(10000 * val) / base);
+    }
+    equal(other) {
+        return this.value === other.value;
+    }
+    isZero() {
+        return this.value === 0n;
+    }
+    /**
+     * @param base what represents 100%
+     */
+    toPercent(base = 1n) {
+        return Number(this.value * base) / 100;
+    }
+    /**
+     * @param base what represents 100%
+     */
+    toFraction(base = 1n) {
+        return Number(this.value * base) / 10000;
+    }
+    toString() {
+        return this.value.toString();
+    }
+}
+Bps.ZERO = new Bps(0n);

package/dist/config/chains.d.ts

@@ -0,0 +1,50 @@
+export declare const megaETHTestnet: {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 4549927;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 6343;
+    name: "MegaETH Testnet";
+    nativeCurrency: {
+        readonly name: "Ethereum";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://carrot.megaeth.com/rpc"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+};

package/dist/config/chains.js

@@ -0,0 +1,21 @@
+import { defineChain as defineChainViem } from "viem";
+export const megaETHTestnet = defineChainViem({
+    id: 6343,
+    name: "MegaETH Testnet",
+    nativeCurrency: {
+        name: "Ethereum",
+        symbol: "ETH",
+        decimals: 18,
+    },
+    rpcUrls: {
+        default: {
+            http: ["https://carrot.megaeth.com/rpc"],
+        },
+    },
+    contracts: {
+        multicall3: {
+            address: '0xca11bde05977b3631167028862be2a173976ca11',
+            blockCreated: 4549927,
+        },
+    },
+});

package/dist/config/index.d.ts

@@ -0,0 +1,25 @@
+import { Chain } from "viem/chains";
+import { SUPPORTED_CHAINS } from "./markets";
+export interface Token {
+    name: string;
+    symbol: string;
+    address: `0x${string}`;
+    decimals: number;
+    logoURI?: string;
+}
+export declare const CHAIN_ID_TO_CHAIN: Record<number, Chain>;
+export declare const ZERO_ADDRESS: "0x0000000000000000000000000000000000000000";
+export declare const PERMIT2_ADDRESS: Record<SUPPORTED_CHAINS, `0x${string}`>;
+export declare const WETH: Record<SUPPORTED_CHAINS, Token>;
+export declare const TOKEN1: Record<SUPPORTED_CHAINS, Token>;
+export declare const TOKEN2: Record<SUPPORTED_CHAINS, Token>;
+export declare const USDC: Record<SUPPORTED_CHAINS, Token>;
+export declare const LIMIT_ORDER_PROTOCOL: Record<SUPPORTED_CHAINS, `0x${string}`>;
+export declare const COLLATERAL_TOKEN_FACTORY: Record<SUPPORTED_CHAINS, `0x${string}`>;
+export declare const OPTION_TOKEN_FACTORY: Record<SUPPORTED_CHAINS, `0x${string}`>;
+export declare const PRE_MARKET_OPTIONS_STRATEGY: Record<SUPPORTED_CHAINS, `0x${string}`>;
+export declare const OPTION_MARKET: Record<SUPPORTED_CHAINS, `0x${string}`>;
+export declare const ERC6909_PROXY: Record<SUPPORTED_CHAINS, `0x${string}`>;
+export declare const ENTRY_POINT: Record<SUPPORTED_CHAINS, `0x${string}`>;
+export declare const MOCK_PAYMASTER: Record<SUPPORTED_CHAINS, `0x${string}`>;
+export declare const SIMPLE_ACCOUNT_FACTORY: Record<SUPPORTED_CHAINS, `0x${string}`>;

package/dist/config/index.js

@@ -0,0 +1,103 @@
+import { hardhat } from "viem/chains";
+import { megaETHTestnet } from "./chains";
+export const CHAIN_ID_TO_CHAIN = {
+    31337: hardhat,
+    6343: megaETHTestnet,
+};
+export const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+export const PERMIT2_ADDRESS = {
+    [hardhat.id]: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+    [megaETHTestnet.id]: "0xd1739f41B25869c7457E502Db4E0eaad663535B7",
+};
+export const WETH = {
+    [hardhat.id]: {
+        name: "Wrapped Ether",
+        symbol: "WETH",
+        address: "0x5FbDB2315678afecb367f032d93F642f64180aa3",
+        decimals: 18,
+    },
+    [megaETHTestnet.id]: {
+        name: "Wrapped Ether",
+        symbol: "WETH",
+        address: "0x4200000000000000000000000000000000000006",
+        decimals: 18,
+    },
+};
+export const TOKEN1 = {
+    [hardhat.id]: {
+        name: "Token 1",
+        symbol: "USDAI",
+        address: "0x0B306BF915C4d645ff596e518fAf3F9669b97016",
+        decimals: 18,
+    },
+    [megaETHTestnet.id]: {
+        name: "Token 1",
+        symbol: "USDAI",
+        address: ZERO_ADDRESS,
+        decimals: 18,
+    },
+};
+export const TOKEN2 = {
+    [hardhat.id]: {
+        name: "Token 2",
+        symbol: "USDC",
+        address: "0x959922bE3CAee4b8Cd9a407cc3ac1C251C2007B1",
+        decimals: 6,
+    },
+    [megaETHTestnet.id]: {
+        name: "Token 2",
+        symbol: "USDC",
+        address: ZERO_ADDRESS,
+        decimals: 6,
+    },
+};
+export const USDC = {
+    [hardhat.id]: {
+        name: "USD Coin",
+        symbol: "USDC",
+        address: "0x851356ae760d987E095750cCeb3bC6014560891C",
+        decimals: 6,
+    },
+    [megaETHTestnet.id]: {
+        name: "USD Coin",
+        symbol: "USDC",
+        address: "0x31c9236db6D1280fb133F2bd7876721530049121",
+        decimals: 6,
+    },
+};
+export const LIMIT_ORDER_PROTOCOL = {
+    [hardhat.id]: "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512",
+    [megaETHTestnet.id]: "0xa0b7722c3F6c64010eEF97F045e1aA9126cC3e62",
+};
+export const COLLATERAL_TOKEN_FACTORY = {
+    [hardhat.id]: "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0",
+    [megaETHTestnet.id]: "0x5Ee2E49C38F5976E27CC45C5A47817e140eBB69E",
+};
+export const OPTION_TOKEN_FACTORY = {
+    [hardhat.id]: "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9",
+    [megaETHTestnet.id]: "0x405BF5630c60E6C0c36650ba25D7BdC9533a03C6",
+};
+export const PRE_MARKET_OPTIONS_STRATEGY = {
+    [hardhat.id]: "0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9",
+    [megaETHTestnet.id]: "0x32034F6889174f3ea32502Dfd27Da3A9C677d83c",
+};
+export const OPTION_MARKET = {
+    [hardhat.id]: "0x5FC8d32690cc91D4c39d9d3abcBD16989F875707",
+    [megaETHTestnet.id]: "0xB583C8d8218BfFE30bd45DB9F0E19a944Cb1deBd",
+};
+export const ERC6909_PROXY = {
+    [hardhat.id]: "0xE6E340D132b5f46d1e472DebcD681B2aBc16e57E",
+    [megaETHTestnet.id]: "0xC7B997B7a113108dA08562Fe1Bc87BF1bF3424B2",
+};
+export const ENTRY_POINT = {
+    [hardhat.id]: "0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6",
+    [megaETHTestnet.id]: "0x0000000071727De22E5E9d8BAf0edAc6f37da032",
+};
+export const MOCK_PAYMASTER = {
+    [hardhat.id]: "0x8A791620dd6260079BF849Dc5567aDC3F2FdC318",
+    [megaETHTestnet.id]: ZERO_ADDRESS,
+};
+export const SIMPLE_ACCOUNT_FACTORY = {
+    [hardhat.id]: "0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0",
+    [megaETHTestnet.id]: "0xca98DA1cB523DBff9234145ecA1158110dDd40dC",
+};

package/dist/config/markets.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Market type
+ */
+export type MarketType = "PRE-TGE" | "PRE-IPO";
+export type SUPPORTED_CHAINS = 31337 | 6343;
+/**
+ * Band configuration with strike limits and token IDs
+ */
+export interface Band {
+    strikeLowerLimit: bigint;
+    strikeUpperLimit: bigint;
+    strikeLowerDisplay: string;
+    strikeUpperDisplay: string;
+    callTokenId: string;
+    putTokenId: string;
+}
+/**
+ * Collateral token configuration
+ */
+export interface CollateralToken {
+    address: `0x${string}`;
+    decimals: number;
+    symbol: string;
+}
+/**
+ * Market configuration
+ */
+export interface MarketConfig {
+    marketKey: string;
+    id: string;
+    name: string;
+    type: MarketType;
+    bands: Band[];
+    icon?: string;
+    stableTokenDecimals?: number;
+    collateralToken: CollateralToken;
+}
+/**
+ * Market configurations per chain
+ */
+export declare const CHAIN_MARKET_CONFIGS: Record<SUPPORTED_CHAINS, Record<string, MarketConfig>>;
+/**
+ * Get market config by ID for a specific chain
+ */
+export declare function getMarketConfig(marketId: string, chainId: SUPPORTED_CHAINS): MarketConfig | undefined;
+/**
+ * Get all market configs as an array for a specific chain
+ */
+export declare function getAllMarketConfigs(chainId: SUPPORTED_CHAINS): MarketConfig[];
+/**
+ * Get the collateral token for a specific market on a specific chain
+ */
+export declare function getMarketCollateralToken(marketId: string, chainId: SUPPORTED_CHAINS): CollateralToken | undefined;

package/dist/config/markets.js

@@ -0,0 +1,125 @@
+import { hardhat } from "viem/chains";
+import { calculateOptionTokenId } from "../shared/utils.js";
+import { TOKEN1, TOKEN2, USDC } from "./index.js";
+import { megaETHTestnet } from "./chains.js";
+/**
+ * Helper function to format strike value for display
+ */
+function formatStrikeValue(value) {
+    const num = Number(value);
+    if (num >= 1e9) {
+        return `${num / 1e9}B`;
+    }
+    if (num >= 1e6) {
+        return `${num / 1e6}M`;
+    }
+    if (num >= 1e3) {
+        return `${num / 1e3}K`;
+    }
+    return num.toString();
+}
+/**
+ * Helper function to create a band with calculated token IDs and display values
+ */
+function createBand(marketId, strikeLowerLimit, strikeUpperLimit) {
+    return {
+        strikeLowerLimit,
+        strikeUpperLimit,
+        strikeLowerDisplay: formatStrikeValue(strikeLowerLimit),
+        strikeUpperDisplay: formatStrikeValue(strikeUpperLimit),
+        callTokenId: calculateOptionTokenId({
+            marketId,
+            strikeLowerLimit: strikeLowerLimit.toString(),
+            strikeUpperLimit: strikeUpperLimit.toString(),
+            isPut: false,
+        }),
+        putTokenId: calculateOptionTokenId({
+            marketId,
+            strikeLowerLimit: strikeLowerLimit.toString(),
+            strikeUpperLimit: strikeUpperLimit.toString(),
+            isPut: true,
+        }),
+    };
+}
+/**
+ * Market configurations per chain
+ */
+export const CHAIN_MARKET_CONFIGS = {
+    [hardhat.id]: {
+        "1": {
+            marketKey: "market1",
+            id: "1",
+            name: "Market 1",
+            type: "PRE-TGE",
+            bands: [
+                createBand("1", 1000000000n, 2000000000n),
+                createBand("1", 2000000000n, 5000000000n),
+                createBand("1", 5000000000n, 10000000000n),
+            ],
+            icon: "/images/usdai-icon.png",
+            stableTokenDecimals: 18,
+            collateralToken: {
+                address: TOKEN1[hardhat.id].address,
+                decimals: TOKEN1[hardhat.id].decimals,
+                symbol: TOKEN1[hardhat.id].symbol,
+            },
+        },
+        "2": {
+            marketKey: "market2",
+            id: "2",
+            name: "Market 2",
+            type: "PRE-IPO",
+            bands: [
+                createBand("2", 1000000000n, 2000000000n),
+                createBand("2", 2000000000n, 5000000000n),
+                createBand("2", 5000000000n, 10000000000n),
+            ],
+            icon: "/images/usdai-icon.png",
+            stableTokenDecimals: 6,
+            collateralToken: {
+                address: TOKEN2[hardhat.id].address,
+                decimals: TOKEN2[hardhat.id].decimals,
+                symbol: TOKEN2[hardhat.id].symbol,
+            },
+        },
+    },
+    [megaETHTestnet.id]: {
+        "1": {
+            marketKey: "market1",
+            id: "1",
+            name: "USDAI ICO",
+            type: "PRE-TGE",
+            bands: [
+                createBand("1", 1000000000n, 2000000000n),
+                createBand("1", 2000000000n, 5000000000n),
+                createBand("1", 5000000000n, 10000000000n),
+            ],
+            icon: "/images/usdai-icon.png",
+            stableTokenDecimals: 6,
+            collateralToken: {
+                address: USDC[megaETHTestnet.id].address,
+                decimals: USDC[megaETHTestnet.id].decimals,
+                symbol: USDC[megaETHTestnet.id].symbol,
+            },
+        },
+    },
+};
+/**
+ * Get market config by ID for a specific chain
+ */
+export function getMarketConfig(marketId, chainId) {
+    return CHAIN_MARKET_CONFIGS[chainId]?.[marketId];
+}
+/**
+ * Get all market configs as an array for a specific chain
+ */
+export function getAllMarketConfigs(chainId) {
+    return Object.values(CHAIN_MARKET_CONFIGS[chainId] || {});
+}
+/**
+ * Get the collateral token for a specific market on a specific chain
+ */
+export function getMarketCollateralToken(marketId, chainId) {
+    const config = getMarketConfig(marketId, chainId);
+    return config?.collateralToken;
+}