@deserialize/evm-limit-sdk/dist/src/LimitFiller.d.ts

TypeScript client for LimitOrderWithPermit2 smart contract

import { ethers, BigNumberish } from 'ethers';
import { LimitOrderClient, Order } from './LimitOrderClient';
export interface FetchedOrder {
    order: Order;
    orderSignature: string;
    permit2Signature: string;
    orderHash: string;
    createdAt: number;
}
export interface FillResult {
    success: boolean;
    transactionHash?: string;
    error?: string;
}
export interface OrderValidation {
    isValid: boolean;
    errors: string[];
    warnings: string[];
}
/**
 * SDK for filling limit orders (Taker/Filler side)
 * Designed for automated scripts and bots
 */
export declare class LimitOrderFiller {
    private client;
    private signer;
    private serverUrl;
    private provider;
    constructor(client: LimitOrderClient, signer: ethers.Signer, provider: ethers.JsonRpcProvider, serverUrl?: string);
    /**
     * Fetch unfilled orders from the external server
     * @param filters Optional filters for fetching orders
     */
    fetchUnfilledOrders(filters?: {
        makerToken?: string;
        takerToken?: string;
        minMakerAmount?: BigNumberish;
        maxTakerAmount?: BigNumberish;
        limit?: number;
    }): Promise<FetchedOrder[]>;
    /**
     * Fetch open orders (optimized endpoint for fillers)
     */
    fetchOpenOrders(filters?: {
        makerToken?: string;
        takerToken?: string;
        limit?: number;
    }): Promise<FetchedOrder[]>;
    /**
     * Fetch orders by token pair
     */
    fetchOrdersByTokenPair(makerToken: string, takerToken: string, limit?: number): Promise<FetchedOrder[]>;
    /**
     * Validate an order before filling
     * @param fetchedOrder The order to validate
     */
    validateOrder(fetchedOrder: FetchedOrder): Promise<OrderValidation>;
    /**
     * Fill a single order
     * @param fetchedOrder The order to fill
     * @param skipValidation Skip validation (use with caution)
     */
    fillOrder(fetchedOrder: FetchedOrder, skipValidation?: boolean): Promise<FillResult>;
    /**
     * Fill multiple orders in sequence with validation
     * @param orders Array of orders to fill
     */
    fillMultipleOrders(orders: FetchedOrder[]): Promise<{
        successful: string[];
        failed: {
            orderHash: string;
            error: string;
        }[];
    }>;
    /**
     * Continuously monitor and fill orders
     * @param pollIntervalMs Polling interval in milliseconds
     * @param filters Optional filters for fetching orders
     */
    startFillingLoop(pollIntervalMs?: number, filters?: {
        makerToken?: string;
        takerToken?: string;
        minMakerAmount?: BigNumberish;
        maxTakerAmount?: BigNumberish;
    }): Promise<void>;
    /**
     * Get token balance for an address
     */
    getTokenBalance(tokenAddress: string, address: string): Promise<bigint>;
    /**
     * Ensure the limit order contract has approval for the taker token
     */
    private ensureLimitOrderContractApproval;
    /**
     * Check if limit order contract is approved for a token
     */
    private isLimitOrderContractApproved;
    /**
     * Approve limit order contract for a token
     */
    private approveLimitOrderContract;
    /**
     * Fetch orders from external server with filters
     */
    private fetchOrdersFromServer;
    /**
     * Transform server order format to FetchedOrder format
     */
    private transformServerOrders;
    /**
     * Notify server that order was filled
     */
    private notifyServerOfFill;
    /**
     * Get the taker address
     */
    getTakerAddress(): Promise<string>;
    /**
     * Get the LimitOrderClient instance
     */
    getClient(): LimitOrderClient;
    /**
     * Set server URL
     */
    setServerUrl(url: string): void;
    /**
     * Get current server URL
     */
    getServerUrl(): string;
}