import { TransactionRequest } from 'ethers';
import { ethers, BigNumberish } from 'ethers';
import { Chain } from 'viem';
import LimitOrderAbi from "../LimitOrderABI.json";
/**
 * Order structure matching the Solidity contract
 */
export interface Order {
    maker: string;
    makerToken: string;
    takerToken: string;
    makerAmount: BigNumberish;
    takerAmount: BigNumberish;
    salt: BigNumberish;
    expiry: BigNumberish;
}
export interface BaseOrder extends Omit<Order, "maker"> {
}
/**
 * Permit2 TokenPermissions structure
 */
export interface TokenPermissions {
    token: string;
    amount: BigNumberish;
}
/**
 * Permit2 PermitTransferFrom structure
 */
export interface PermitTransferFrom {
    permitted: TokenPermissions;
    spender: string;
    nonce: BigNumberish;
    deadline: BigNumberish;
}
/**
 * Event data structures
 */
export interface OrderFilledEvent {
    orderHash: string;
    maker: string;
    taker: string;
    makerAmount: bigint;
    takerAmount: bigint;
    blockNumber: number;
    transactionHash: string;
}
export interface OrderCancelledEvent {
    orderHash: string;
    maker: string;
    salt: bigint;
    blockNumber: number;
    transactionHash: string;
}
/**
 * Transaction options
 */
export interface TxOptions {
    gasLimit?: BigNumberish;
    gasPrice?: BigNumberish;
    maxFeePerGas?: BigNumberish;
    maxPriorityFeePerGas?: BigNumberish;
    nonce?: number;
    value?: BigNumberish;
}
export declare const TESTNET_CHAIN_ID = 16602;
export declare const MAINNET_CHAIN_ID = 16601;
/**
 * TypeScript client for interacting with the LimitOrderWithPermit2 smart contract
 */
export declare class LimitOrderClient {
    private contract;
    private provider;
    readonly PERMIT2_CONTRACT: string;
    readonly LIMIT_ORDER_CONTRACT: string;
    readonly W_NATIVE_ADDRESS: string;
    chain: Chain;
    readonly NATIVE_TOKEN = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
    readonly NAME = "LimitOrderWithPermit2";
    readonly VERSION = "1";
    private domain;
    private readonly ORDER_TYPES;
    /**
     * Creates a new LimitOrderClient instance
     * @param provider JsonRpcProvider instance
     * @param contractAddress The deployed contract address
     * @param abi Contract ABI
     * @param signer Optional signer or signer index for transactions
     */
    constructor(provider: ethers.JsonRpcProvider, contractAddress: string, abi: ethers.InterfaceAbi | undefined, permit2Address: string, chain: Chain, warpedNativeAddress: string);
    /**
     * Get the contract name
     */
    getName(): Promise<string>;
    /**
     * Get the contract version
     */
    getVersion(): Promise<string>;
    /**
     * Get the domain separator
     */
    getDomainSeparator(): Promise<string>;
    /**
     * Get the Permit2 contract address
     */
    getPermit2Address(): Promise<string>;
    /**
     * Check if an order has been filled
     * @param orderHash The hash of the order
     */
    isOrderFilled(orderHash: string): Promise<boolean>;
    /**
     * Check if an order has been cancelled
     * @param maker The maker address
     * @param salt The order salt/nonce
     */
    isCancelled(maker: string, salt: BigNumberish): Promise<boolean>;
    /**
     * Check if the contract is paused
     */
    isPaused(): Promise<boolean>;
    /**
     * Get the contract owner
     */
    getOwner(): Promise<string>;
    /**
     * Get the order hash for a given order
     * @param order The order struct
     */
    getOrderHash(order: Order): Promise<string>;
    /**
     * Check if an order is filled by computing its hash
     * @param order The order struct
     */
    isFilled(order: Order): Promise<boolean>;
    getWrapNativeTransaction: (amount: string, wNativeAddress?: string, wNativeAbi?: string[]) => TransactionRequest;
    getPermitFromOrder(order: Order): PermitTransferFrom;
    /**
     * Get the EIP-712 domain for signing
     */
    private getDomain;
    /**
     * Sign an order using EIP-712
     * @param order The order to sign
     * @param signer Optional signer (uses default if not provided)
     */
    signOrder(order: Order, signer: ethers.Signer): Promise<string>;
    getOrderDataToSign(order: Order): {
        domain: ethers.TypedDataDomain;
        types: any;
        value: Order;
    };
    /**
     * Verify an order signature
     * @param order The order struct
     * @param signature The signature to verify
     * @param expectedMaker The expected maker address
     */
    verifyOrderSignature(order: Order, signature: string, expectedMaker: string): Promise<boolean>;
    /**
     * Create a Permit2 signature for token transfer
     * Note: This requires the maker to sign with their wallet
     * @param permit The permit data
     * @param signer The signer (maker)
     */
    signPermit2(order: Order, signer: ethers.Signer): Promise<string>;
    getPermit2DataToSign(order: Order): {
        domain: ethers.TypedDataDomain;
        types: any;
        value: PermitTransferFrom;
    };
    verifyPermit2Signature(signature: string, order: Order): Promise<boolean>;
    /**
     * Decode custom error from error data
     */
    private decodeError;
    /**
     * Fill an order using Permit2 by manually encoding the transaction
     * @param signer The signer to use for the transaction
     * @param order The order to fill
     * @param makerSignature The maker's order signature
     * @param permit2Signature The maker's Permit2 signature
     * @param options Transaction options
     */
    fillOrderWithPermit2(signer: ethers.Signer, order: Order, makerSignature: string, permit2Signature: string, options?: TxOptions): Promise<ethers.ContractTransactionResponse>;
    getFillOrderWithPermit2Transaction(order: Order, makerSignature: string, permit2Signature: string, options?: TxOptions): ethers.TransactionRequest;
    /**
     * Cancel an order by salt
     * @param salt The order salt/nonce
     * @param options Transaction options
     */
    cancelOrder(salt: BigNumberish, signer: ethers.Signer, options?: TxOptions): Promise<ethers.ContractTransactionResponse>;
    getCancelOrderTransaction(salt: BigNumberish, options?: TxOptions): ethers.TransactionRequest;
    /**
     * Query OrderFilled events
     * @param fromBlock Starting block
     * @param toBlock Ending block
     * @param filters Optional filters (orderHash, maker, taker)
     */
    getOrderFilledEvents(fromBlock?: number | string, toBlock?: number | string, filters?: {
        orderHash?: string;
        maker?: string;
        taker?: string;
    }): Promise<OrderFilledEvent[]>;
    /**
     * Query OrderCancelled events
     * @param fromBlock Starting block
     * @param toBlock Ending block
     * @param filters Optional filters (orderHash, maker)
     */
    getOrderCancelledEvents(fromBlock?: number | string, toBlock?: number | string, filters?: {
        orderHash?: string;
        maker?: string;
    }): Promise<OrderCancelledEvent[]>;
    /**
     * Listen for OrderFilled events
     * @param callback Callback function
     * @param filters Optional filters
     */
    onOrderFilled(callback: (event: OrderFilledEvent) => void, filters?: {
        orderHash?: string;
        maker?: string;
        taker?: string;
    }): void;
    /**
     * Listen for OrderCancelled events
     * @param callback Callback function
     * @param filters Optional filters
     */
    onOrderCancelled(callback: (event: OrderCancelledEvent) => void, filters?: {
        orderHash?: string;
        maker?: string;
    }): void;
    /**
     * Remove all event listeners
     */
    removeAllListeners(): void;
    /**
     * Create a complete order with both signatures
     * @param orderParams Order parameters
     * @param makerSigner The maker's signer
     */
    createSignedOrder(orderParams: Order, makerSigner: ethers.Signer): Promise<{
        order: Order;
        orderSignature: string;
        permit2Signature: string;
        orderHash: string;
    }>;
    validateOrderSignatures(order: Order, orderSignature: string, permit2Signature: string): Promise<boolean>;
    getCreateOrderMessageData(orderParams: Order): {
        order: Order;
        orderDataToSign: {
            domain: ethers.TypedDataDomain;
            types: any;
            value: Order;
        };
        permit2DataToSign: {
            domain: ethers.TypedDataDomain;
            types: any;
            value: PermitTransferFrom;
        };
    };
    /**
     * Estimate gas for filling an order
     * @param order The order to fill
     * @param makerSignature The maker's signature
     * @param usePermit2 Whether to use Permit2
     * @param permit2Signature Optional Permit2 signature
     */
    estimateFillGas(order: Order, makerSignature: string, usePermit2?: boolean, permit2Signature?: string): Promise<bigint>;
    /**
     * Get the contract address
     */
    getAddress(): string;
    /**
     * Get the underlying ethers contract instance
     */
    getContract(): ethers.Contract;
}
/**
 * Generate a random salt for an order
 */
export declare function generateOrderSalt(): bigint;
export declare function ensureAllowanceForLimitOrderContract(signer: ethers.Signer, tokenAddress: string, limitOrderContractAddress: string, amount?: BigNumberish): Promise<unknown>;
/**
 * Create an order expiry timestamp
 * @param durationInSeconds Duration from now in seconds
 */
export declare function createOrderExpiry(durationInSeconds: number): bigint;
/**
 * Check if an order has expired
 * @param expiry The order expiry timestamp
 */
export declare function isOrderExpired(expiry: BigNumberish): boolean;
/**
 * Calculate the exchange rate (maker amount per taker amount)
 * @param order The order
 */
export declare function calculateExchangeRate(order: Order): string;
export { LimitOrderAbi };