@stryke-xyz/premarket-sdk 1.0.0

package/dist/abi/limitOrderProtocol.json

@@ -0,0 +1,63 @@
+[
+    {
+        "name": "fillOrderArgs",
+        "type": "function",
+        "stateMutability": "payable",
+        "inputs": [
+            {
+                "name": "order",
+                "type": "tuple",
+                "components": [
+                    { "name": "salt", "type": "uint256" },
+                    { "name": "maker", "type": "uint256" },
+                    { "name": "receiver", "type": "uint256" },
+                    { "name": "makerAsset", "type": "uint256" },
+                    { "name": "takerAsset", "type": "uint256" },
+                    { "name": "makingAmount", "type": "uint256" },
+                    { "name": "takingAmount", "type": "uint256" },
+                    { "name": "makerTraits", "type": "uint256" }
+                ]
+            },
+            { "name": "r", "type": "bytes32" },
+            { "name": "vs", "type": "bytes32" },
+            { "name": "amount", "type": "uint256" },
+            { "name": "takerTraits", "type": "uint256" },
+            { "name": "args", "type": "bytes" }
+        ],
+        "outputs": [
+            { "name": "makingAmount", "type": "uint256" },
+            { "name": "takingAmount", "type": "uint256" },
+            { "name": "orderHash", "type": "bytes32" }
+        ]
+    },
+    {
+        "name": "fillContractOrderArgs",
+        "type": "function",
+        "stateMutability": "nonpayable",
+        "inputs": [
+            {
+                "name": "order",
+                "type": "tuple",
+                "components": [
+                    { "name": "salt", "type": "uint256" },
+                    { "name": "maker", "type": "uint256" },
+                    { "name": "receiver", "type": "uint256" },
+                    { "name": "makerAsset", "type": "uint256" },
+                    { "name": "takerAsset", "type": "uint256" },
+                    { "name": "makingAmount", "type": "uint256" },
+                    { "name": "takingAmount", "type": "uint256" },
+                    { "name": "makerTraits", "type": "uint256" }
+                ]
+            },
+            { "name": "signature", "type": "bytes" },
+            { "name": "amount", "type": "uint256" },
+            { "name": "takerTraits", "type": "uint256" },
+            { "name": "args", "type": "bytes" }
+        ],
+        "outputs": [
+            { "name": "makingAmount", "type": "uint256" },
+            { "name": "takingAmount", "type": "uint256" },
+            { "name": "orderHash", "type": "bytes32" }
+        ]
+    }
+]

package/dist/address.d.ts

@@ -0,0 +1,13 @@
+export declare class Address {
+    static NATIVE_CURRENCY: Address;
+    static ZERO_ADDRESS: Address;
+    private readonly val;
+    constructor(val: string);
+    static fromBigInt(val: bigint): Address;
+    static fromFirstBytes(bytes: string): Address;
+    toString(): string;
+    equal(other: Address): boolean;
+    isNative(): boolean;
+    isZero(): boolean;
+    lastHalf(): string;
+}

package/dist/address.js

@@ -0,0 +1,32 @@
+import { isAddress } from 'ethers';
+import { add0x } from '@1inch/byte-utils';
+import assert from 'assert';
+export class Address {
+    constructor(val) {
+        assert(isAddress(val), `Invalid address ${val}`);
+        this.val = val.toLowerCase();
+    }
+    static fromBigInt(val) {
+        return new Address(add0x(val.toString(16).padStart(40, '0')));
+    }
+    static fromFirstBytes(bytes) {
+        return new Address(bytes.slice(0, 42));
+    }
+    toString() {
+        return this.val;
+    }
+    equal(other) {
+        return this.val === other.val;
+    }
+    isNative() {
+        return this.equal(Address.NATIVE_CURRENCY);
+    }
+    isZero() {
+        return this.equal(Address.ZERO_ADDRESS);
+    }
+    lastHalf() {
+        return add0x(this.val.slice(-20));
+    }
+}
+Address.NATIVE_CURRENCY = new Address('0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee');
+Address.ZERO_ADDRESS = new Address('0x0000000000000000000000000000000000000000');

package/dist/api/filler.d.ts

@@ -0,0 +1,109 @@
+import type { Address, Hex, WalletClient, PublicClient } from "viem";
+import type { StoredOrder } from "../shared/types.js";
+import LIMIT_ORDER_PROTOCOL_ABI from "../abi/limitOrderProtocol.json";
+export interface FillOrderWriteContractParams {
+    address: Address;
+    abi: typeof LIMIT_ORDER_PROTOCOL_ABI;
+    functionName: "fillOrderArgs" | "fillContractOrderArgs";
+    args: readonly unknown[];
+}
+export declare class OrderFiller {
+    private config;
+    private publicClient;
+    private walletClient;
+    constructor(config: {
+        chainId: number;
+    }, publicClient: PublicClient, walletClient: WalletClient);
+    /**
+     * Build writeContract parameters for filling an order from EOA maker
+     * Tokens go to msg.sender
+     *
+     * @param storedOrder - The order fetched from the API
+     * @param fillAmount - Amount to fill (in makingAmount units)
+     * @returns Parameters to pass to writeContract
+     */
+    buildFillOrderParams(storedOrder: StoredOrder, fillAmount: bigint): FillOrderWriteContractParams;
+    /**
+     * Fill order from EOA maker - tokens go to msg.sender
+     *
+     * @param storedOrder - The order fetched from the API
+     * @param fillAmount - Amount to fill (in makingAmount units)
+     */
+    fillOrder(storedOrder: StoredOrder, fillAmount: bigint): Promise<{
+        txHash: Hex;
+        makingAmount: bigint;
+        takingAmount: bigint;
+        orderHash: Hex;
+    }>;
+    /**
+     * Build writeContract parameters for filling an order from EOA maker
+     * Tokens go to specified target address
+     *
+     * @param storedOrder - The order fetched from the API
+     * @param fillAmount - Amount to fill (in makingAmount units)
+     * @param targetAddress - Address to receive the maker's tokens
+     * @returns Parameters to pass to writeContract
+     */
+    buildFillOrderToParams(storedOrder: StoredOrder, fillAmount: bigint, targetAddress: Address): FillOrderWriteContractParams;
+    /**
+     * Fill order from EOA maker - tokens go to specified target address
+     *
+     * @param storedOrder - The order fetched from the API
+     * @param fillAmount - Amount to fill (in makingAmount units)
+     * @param targetAddress - Address to receive the maker's tokens
+     */
+    fillOrderTo(storedOrder: StoredOrder, fillAmount: bigint, targetAddress: Address): Promise<{
+        txHash: Hex;
+        makingAmount: bigint;
+        takingAmount: bigint;
+        orderHash: Hex;
+    }>;
+    /**
+     * Build writeContract parameters for filling an order from smart contract maker
+     * Tokens go to msg.sender
+     *
+     * @param storedOrder - The order fetched from the API
+     * @param fillAmount - Amount to fill (in makingAmount units)
+     * @param ownerSignature - EIP-1271 signature from the smart account owner
+     * @returns Parameters to pass to writeContract
+     */
+    buildFillContractOrderParams(storedOrder: StoredOrder, fillAmount: bigint, ownerSignature: Hex): FillOrderWriteContractParams;
+    /**
+     * Fill order from smart contract maker - tokens go to msg.sender
+     *
+     * @param storedOrder - The order fetched from the API
+     * @param fillAmount - Amount to fill (in makingAmount units)
+     * @param ownerSignature - EIP-1271 signature from the smart account owner
+     */
+    fillContractOrder(storedOrder: StoredOrder, fillAmount: bigint, ownerSignature: Hex): Promise<{
+        txHash: Hex;
+        makingAmount: bigint;
+        takingAmount: bigint;
+        orderHash: Hex;
+    }>;
+    /**
+     * Build writeContract parameters for filling an order from smart contract maker
+     * Tokens go to specified target address
+     *
+     * @param storedOrder - The order fetched from the API
+     * @param fillAmount - Amount to fill (in makingAmount units)
+     * @param ownerSignature - EIP-1271 signature from the smart account owner
+     * @param targetAddress - Address to receive the maker's tokens
+     * @returns Parameters to pass to writeContract
+     */
+    buildFillContractOrderToParams(storedOrder: StoredOrder, fillAmount: bigint, ownerSignature: Hex, targetAddress: Address): FillOrderWriteContractParams;
+    /**
+     * Fill order from smart contract maker - tokens go to specified target address
+     *
+     * @param storedOrder - The order fetched from the API
+     * @param fillAmount - Amount to fill (in makingAmount units)
+     * @param ownerSignature - EIP-1271 signature from the smart account owner
+     * @param targetAddress - Address to receive the maker's tokens
+     */
+    fillContractOrderTo(storedOrder: StoredOrder, fillAmount: bigint, ownerSignature: Hex, targetAddress: Address): Promise<{
+        txHash: Hex;
+        makingAmount: bigint;
+        takingAmount: bigint;
+        orderHash: Hex;
+    }>;
+}

package/dist/api/filler.js

@@ -0,0 +1,289 @@
+import { encodePacked } from "viem";
+import { getLimitOrderContract } from "../constants";
+import { LimitOrder, Extension } from "../limit-order";
+import LIMIT_ORDER_PROTOCOL_ABI from "../abi/limitOrderProtocol.json";
+export class OrderFiller {
+    constructor(config, publicClient, walletClient) {
+        this.config = config;
+        this.publicClient = publicClient;
+        this.walletClient = walletClient;
+    }
+    /**
+     * Build writeContract parameters for filling an order from EOA maker
+     * Tokens go to msg.sender
+     *
+     * @param storedOrder - The order fetched from the API
+     * @param fillAmount - Amount to fill (in makingAmount units)
+     * @returns Parameters to pass to writeContract
+     */
+    buildFillOrderParams(storedOrder, fillAmount) {
+        const limitOrderProtocolAddress = getLimitOrderContract(this.config.chainId);
+        const extension = Extension.decode(storedOrder.extensionEncoded);
+        const limitOrder = LimitOrder.fromDataAndExtension(storedOrder.order, extension);
+        const orderStruct = limitOrder.build();
+        const extensionBytes = storedOrder.extensionEncoded;
+        const extensionLength = (extensionBytes.length - 2) / 2;
+        // Build args: just extension (no target address when filling for yourself)
+        const args = extensionBytes;
+        // Build TakerTraits: bits 224-244 = extension length (no argsHasTarget flag)
+        const takerTraits = BigInt(extensionLength) << 224n;
+        return {
+            address: limitOrderProtocolAddress,
+            abi: LIMIT_ORDER_PROTOCOL_ABI,
+            functionName: "fillOrderArgs",
+            args: [
+                {
+                    salt: BigInt(orderStruct.salt),
+                    maker: BigInt(orderStruct.maker),
+                    receiver: BigInt(orderStruct.receiver),
+                    makerAsset: BigInt(orderStruct.makerAsset),
+                    takerAsset: BigInt(orderStruct.takerAsset),
+                    makingAmount: BigInt(orderStruct.makingAmount),
+                    takingAmount: BigInt(orderStruct.takingAmount),
+                    makerTraits: BigInt(orderStruct.makerTraits),
+                },
+                storedOrder.signature.r,
+                storedOrder.signature.vs,
+                fillAmount,
+                takerTraits,
+                args,
+            ],
+        };
+    }
+    /**
+     * Fill order from EOA maker - tokens go to msg.sender
+     *
+     * @param storedOrder - The order fetched from the API
+     * @param fillAmount - Amount to fill (in makingAmount units)
+     */
+    async fillOrder(storedOrder, fillAmount) {
+        const params = this.buildFillOrderParams(storedOrder, fillAmount);
+        const hash = await this.walletClient.writeContract({
+            chain: this.walletClient.chain,
+            account: this.walletClient.account,
+            ...params,
+        });
+        await this.publicClient.waitForTransactionReceipt({ hash });
+        // Calculate orderStruct for return value
+        const extension = Extension.decode(storedOrder.extensionEncoded);
+        const limitOrder = LimitOrder.fromDataAndExtension(storedOrder.order, extension);
+        const orderStruct = limitOrder.build();
+        return {
+            txHash: hash,
+            makingAmount: fillAmount,
+            takingAmount: (BigInt(orderStruct.takingAmount) * fillAmount) /
+                BigInt(orderStruct.makingAmount),
+            orderHash: storedOrder.orderHash,
+        };
+    }
+    /**
+     * Build writeContract parameters for filling an order from EOA maker
+     * Tokens go to specified target address
+     *
+     * @param storedOrder - The order fetched from the API
+     * @param fillAmount - Amount to fill (in makingAmount units)
+     * @param targetAddress - Address to receive the maker's tokens
+     * @returns Parameters to pass to writeContract
+     */
+    buildFillOrderToParams(storedOrder, fillAmount, targetAddress) {
+        const limitOrderProtocolAddress = getLimitOrderContract(this.config.chainId);
+        const extension = Extension.decode(storedOrder.extensionEncoded);
+        const limitOrder = LimitOrder.fromDataAndExtension(storedOrder.order, extension);
+        const orderStruct = limitOrder.build();
+        const extensionBytes = storedOrder.extensionEncoded;
+        const extensionLength = (extensionBytes.length - 2) / 2;
+        // Build args: target (20 bytes) + extension
+        const args = encodePacked(["address", "bytes"], [targetAddress, extensionBytes]);
+        // Build TakerTraits: bit 251 = argsHasTarget, bits 224-244 = extension length
+        const takerTraits = (1n << 251n) | (BigInt(extensionLength) << 224n);
+        return {
+            address: limitOrderProtocolAddress,
+            abi: LIMIT_ORDER_PROTOCOL_ABI,
+            functionName: "fillOrderArgs",
+            args: [
+                {
+                    salt: BigInt(orderStruct.salt),
+                    maker: BigInt(orderStruct.maker),
+                    receiver: BigInt(orderStruct.receiver),
+                    makerAsset: BigInt(orderStruct.makerAsset),
+                    takerAsset: BigInt(orderStruct.takerAsset),
+                    makingAmount: BigInt(orderStruct.makingAmount),
+                    takingAmount: BigInt(orderStruct.takingAmount),
+                    makerTraits: BigInt(orderStruct.makerTraits),
+                },
+                storedOrder.signature.r,
+                storedOrder.signature.vs,
+                fillAmount,
+                takerTraits,
+                args,
+            ],
+        };
+    }
+    /**
+     * Fill order from EOA maker - tokens go to specified target address
+     *
+     * @param storedOrder - The order fetched from the API
+     * @param fillAmount - Amount to fill (in makingAmount units)
+     * @param targetAddress - Address to receive the maker's tokens
+     */
+    async fillOrderTo(storedOrder, fillAmount, targetAddress) {
+        const params = this.buildFillOrderToParams(storedOrder, fillAmount, targetAddress);
+        const hash = await this.walletClient.writeContract({
+            chain: this.walletClient.chain,
+            account: this.walletClient.account,
+            ...params,
+        });
+        await this.publicClient.waitForTransactionReceipt({ hash });
+        // Calculate orderStruct for return value
+        const extension = Extension.decode(storedOrder.extensionEncoded);
+        const limitOrder = LimitOrder.fromDataAndExtension(storedOrder.order, extension);
+        const orderStruct = limitOrder.build();
+        return {
+            txHash: hash,
+            makingAmount: fillAmount,
+            takingAmount: (BigInt(orderStruct.takingAmount) * fillAmount) /
+                BigInt(orderStruct.makingAmount),
+            orderHash: storedOrder.orderHash,
+        };
+    }
+    /**
+     * Build writeContract parameters for filling an order from smart contract maker
+     * Tokens go to msg.sender
+     *
+     * @param storedOrder - The order fetched from the API
+     * @param fillAmount - Amount to fill (in makingAmount units)
+     * @param ownerSignature - EIP-1271 signature from the smart account owner
+     * @returns Parameters to pass to writeContract
+     */
+    buildFillContractOrderParams(storedOrder, fillAmount, ownerSignature) {
+        const limitOrderProtocolAddress = getLimitOrderContract(this.config.chainId);
+        const extension = Extension.decode(storedOrder.extensionEncoded);
+        const limitOrder = LimitOrder.fromDataAndExtension(storedOrder.order, extension);
+        const orderStruct = limitOrder.build();
+        const extensionBytes = storedOrder.extensionEncoded;
+        const extensionLength = (extensionBytes.length - 2) / 2;
+        // Build args: just extension (no target address when filling for yourself)
+        const args = extensionBytes;
+        // Build TakerTraits: bits 224-244 = extension length (no argsHasTarget flag)
+        const takerTraits = BigInt(extensionLength) << 224n;
+        return {
+            address: limitOrderProtocolAddress,
+            abi: LIMIT_ORDER_PROTOCOL_ABI,
+            functionName: "fillContractOrderArgs",
+            args: [
+                {
+                    salt: BigInt(orderStruct.salt),
+                    maker: BigInt(orderStruct.maker),
+                    receiver: BigInt(orderStruct.receiver),
+                    makerAsset: BigInt(orderStruct.makerAsset),
+                    takerAsset: BigInt(orderStruct.takerAsset),
+                    makingAmount: BigInt(orderStruct.makingAmount),
+                    takingAmount: BigInt(orderStruct.takingAmount),
+                    makerTraits: BigInt(orderStruct.makerTraits),
+                },
+                ownerSignature,
+                fillAmount,
+                takerTraits,
+                args,
+            ],
+        };
+    }
+    /**
+     * Fill order from smart contract maker - tokens go to msg.sender
+     *
+     * @param storedOrder - The order fetched from the API
+     * @param fillAmount - Amount to fill (in makingAmount units)
+     * @param ownerSignature - EIP-1271 signature from the smart account owner
+     */
+    async fillContractOrder(storedOrder, fillAmount, ownerSignature) {
+        const params = this.buildFillContractOrderParams(storedOrder, fillAmount, ownerSignature);
+        const hash = await this.walletClient.writeContract({
+            chain: this.walletClient.chain,
+            account: this.walletClient.account,
+            ...params,
+        });
+        await this.publicClient.waitForTransactionReceipt({ hash });
+        // Calculate orderStruct for return value
+        const extension = Extension.decode(storedOrder.extensionEncoded);
+        const limitOrder = LimitOrder.fromDataAndExtension(storedOrder.order, extension);
+        const orderStruct = limitOrder.build();
+        return {
+            txHash: hash,
+            makingAmount: fillAmount,
+            takingAmount: (BigInt(orderStruct.takingAmount) * fillAmount) /
+                BigInt(orderStruct.makingAmount),
+            orderHash: storedOrder.orderHash,
+        };
+    }
+    /**
+     * Build writeContract parameters for filling an order from smart contract maker
+     * Tokens go to specified target address
+     *
+     * @param storedOrder - The order fetched from the API
+     * @param fillAmount - Amount to fill (in makingAmount units)
+     * @param ownerSignature - EIP-1271 signature from the smart account owner
+     * @param targetAddress - Address to receive the maker's tokens
+     * @returns Parameters to pass to writeContract
+     */
+    buildFillContractOrderToParams(storedOrder, fillAmount, ownerSignature, targetAddress) {
+        const limitOrderProtocolAddress = getLimitOrderContract(this.config.chainId);
+        const extension = Extension.decode(storedOrder.extensionEncoded);
+        const limitOrder = LimitOrder.fromDataAndExtension(storedOrder.order, extension);
+        const orderStruct = limitOrder.build();
+        const extensionBytes = storedOrder.extensionEncoded;
+        const extensionLength = (extensionBytes.length - 2) / 2;
+        // Build args: target (20 bytes) + extension
+        const args = encodePacked(["address", "bytes"], [targetAddress, extensionBytes]);
+        // Build TakerTraits: bit 251 = argsHasTarget, bits 224-244 = extension length
+        const takerTraits = (1n << 251n) | (BigInt(extensionLength) << 224n);
+        return {
+            address: limitOrderProtocolAddress,
+            abi: LIMIT_ORDER_PROTOCOL_ABI,
+            functionName: "fillContractOrderArgs",
+            args: [
+                {
+                    salt: BigInt(orderStruct.salt),
+                    maker: BigInt(orderStruct.maker),
+                    receiver: BigInt(orderStruct.receiver),
+                    makerAsset: BigInt(orderStruct.makerAsset),
+                    takerAsset: BigInt(orderStruct.takerAsset),
+                    makingAmount: BigInt(orderStruct.makingAmount),
+                    takingAmount: BigInt(orderStruct.takingAmount),
+                    makerTraits: BigInt(orderStruct.makerTraits),
+                },
+                ownerSignature,
+                fillAmount,
+                takerTraits,
+                args,
+            ],
+        };
+    }
+    /**
+     * Fill order from smart contract maker - tokens go to specified target address
+     *
+     * @param storedOrder - The order fetched from the API
+     * @param fillAmount - Amount to fill (in makingAmount units)
+     * @param ownerSignature - EIP-1271 signature from the smart account owner
+     * @param targetAddress - Address to receive the maker's tokens
+     */
+    async fillContractOrderTo(storedOrder, fillAmount, ownerSignature, targetAddress) {
+        const params = this.buildFillContractOrderToParams(storedOrder, fillAmount, ownerSignature, targetAddress);
+        const hash = await this.walletClient.writeContract({
+            chain: this.walletClient.chain,
+            account: this.walletClient.account,
+            ...params,
+        });
+        await this.publicClient.waitForTransactionReceipt({ hash });
+        // Calculate orderStruct for return value
+        const extension = Extension.decode(storedOrder.extensionEncoded);
+        const limitOrder = LimitOrder.fromDataAndExtension(storedOrder.order, extension);
+        const orderStruct = limitOrder.build();
+        return {
+            txHash: hash,
+            makingAmount: fillAmount,
+            takingAmount: (BigInt(orderStruct.takingAmount) * fillAmount) /
+                BigInt(orderStruct.makingAmount),
+            orderHash: storedOrder.orderHash,
+        };
+    }
+}

package/dist/api/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./orderbook-api.js";
+export * from "./order-helper.js";
+export * from "./filler.js";

package/dist/api/index.js

@@ -0,0 +1,3 @@
+export * from "./orderbook-api.js";
+export * from "./order-helper.js";
+export * from "./filler.js";

package/dist/api/order-helper.d.ts

@@ -0,0 +1,59 @@
+import { type Address, type Hex, type WalletClient } from "viem";
+import { LimitOrder } from "../limit-order";
+import type { Option } from "../shared/types.js";
+export declare class OrderHelper {
+    private config;
+    constructor(config: {
+        chainId: number;
+        optionTokenFactoryAddress: Address;
+    });
+    /**
+     * Calculate option token ID from option parameters
+     * Delegates to shared utility function
+     */
+    calculateOptionTokenId(option: Option): Hex;
+    /**
+     * Build sell options order
+     */
+    buildSellOptionsOrder(params: {
+        maker: Address;
+        makerProxyAddress: Address;
+        stableToken: Address;
+        option: Option;
+        optionAmount: string;
+        stableAmount: string;
+        expiresAt?: bigint;
+    }): {
+        order: LimitOrder;
+        optionTokenId: Hex;
+        calldata: string;
+        extensionEncoded: string;
+    };
+    /**
+     * Build buy options order
+     * For buy orders:
+     * - Maker gives: USDC (ERC20) - no suffix needed
+     * - Maker receives: Options (ERC6909) - needs takerAssetSuffix
+     */
+    buildBuyOptionsOrder(params: {
+        maker: Address;
+        makerProxyAddress: Address;
+        stableToken: Address;
+        option: Option;
+        optionAmount: string;
+        stableAmount: string;
+        expiresAt?: bigint;
+    }): {
+        order: LimitOrder;
+        optionTokenId: Hex;
+        calldata: string;
+        extensionEncoded: string;
+    };
+    /**
+     * Sign an order with wallet client
+     */
+    signOrder(order: LimitOrder, walletClient: WalletClient): Promise<{
+        r: string;
+        vs: string;
+    }>;
+}