@orionprotocol/contracts/lib/ethers-v5/Exchange.d.ts

Orion Protocol contracts typings

import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, PopulatedTransaction, Signer, utils } from "ethers";
import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "./common";
export declare namespace MarginalFunctionality {
    type PositionStruct = {
        state: PromiseOrValue<BigNumberish>;
        weightedPosition: PromiseOrValue<BigNumberish>;
        totalPosition: PromiseOrValue<BigNumberish>;
        totalLiabilities: PromiseOrValue<BigNumberish>;
    };
    type PositionStructOutput = [
        number,
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        state: number;
        weightedPosition: BigNumber;
        totalPosition: BigNumber;
        totalLiabilities: BigNumber;
    };
    type LiabilityStruct = {
        asset: PromiseOrValue<string>;
        timestamp: PromiseOrValue<BigNumberish>;
        outstandingAmount: PromiseOrValue<BigNumberish>;
    };
    type LiabilityStructOutput = [string, BigNumber, BigNumber] & {
        asset: string;
        timestamp: BigNumber;
        outstandingAmount: BigNumber;
    };
}
export declare namespace LibValidator {
    type OrderStruct = {
        senderAddress: PromiseOrValue<string>;
        matcherAddress: PromiseOrValue<string>;
        baseAsset: PromiseOrValue<string>;
        quoteAsset: PromiseOrValue<string>;
        matcherFeeAsset: PromiseOrValue<string>;
        amount: PromiseOrValue<BigNumberish>;
        price: PromiseOrValue<BigNumberish>;
        matcherFee: PromiseOrValue<BigNumberish>;
        nonce: PromiseOrValue<BigNumberish>;
        expiration: PromiseOrValue<BigNumberish>;
        buySide: PromiseOrValue<BigNumberish>;
        signature: PromiseOrValue<BytesLike>;
    };
    type OrderStructOutput = [
        string,
        string,
        string,
        string,
        string,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        number,
        string
    ] & {
        senderAddress: string;
        matcherAddress: string;
        baseAsset: string;
        quoteAsset: string;
        matcherFeeAsset: string;
        amount: BigNumber;
        price: BigNumber;
        matcherFee: BigNumber;
        nonce: BigNumber;
        expiration: BigNumber;
        buySide: number;
        signature: string;
    };
    type CrossChainOrderStruct = {
        limitOrder: LibValidator.OrderStruct;
        targetChainId: PromiseOrValue<BigNumberish>;
        secretHash: PromiseOrValue<BytesLike>;
        lockOrderExpiration: PromiseOrValue<BigNumberish>;
    };
    type CrossChainOrderStructOutput = [
        LibValidator.OrderStructOutput,
        number,
        string,
        BigNumber
    ] & {
        limitOrder: LibValidator.OrderStructOutput;
        targetChainId: number;
        secretHash: string;
        lockOrderExpiration: BigNumber;
    };
    type SwapDescriptionStruct = {
        srcToken: PromiseOrValue<string>;
        dstToken: PromiseOrValue<string>;
        srcReceiver: PromiseOrValue<string>;
        dstReceiver: PromiseOrValue<string>;
        amount: PromiseOrValue<BigNumberish>;
        minReturnAmount: PromiseOrValue<BigNumberish>;
        flags: PromiseOrValue<BigNumberish>;
    };
    type SwapDescriptionStructOutput = [
        string,
        string,
        string,
        string,
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        srcToken: string;
        dstToken: string;
        srcReceiver: string;
        dstReceiver: string;
        amount: BigNumber;
        minReturnAmount: BigNumber;
        flags: BigNumber;
    };
    type LockOrderStruct = {
        sender: PromiseOrValue<string>;
        expiration: PromiseOrValue<BigNumberish>;
        asset: PromiseOrValue<string>;
        amount: PromiseOrValue<BigNumberish>;
        targetChainId: PromiseOrValue<BigNumberish>;
        secretHash: PromiseOrValue<BytesLike>;
        signature: PromiseOrValue<BytesLike>;
    };
    type LockOrderStructOutput = [
        string,
        BigNumber,
        string,
        BigNumber,
        number,
        string,
        string
    ] & {
        sender: string;
        expiration: BigNumber;
        asset: string;
        amount: BigNumber;
        targetChainId: number;
        secretHash: string;
        signature: string;
    };
}
export declare namespace LibAtomic {
    type RedeemOrderStruct = {
        sender: PromiseOrValue<string>;
        receiver: PromiseOrValue<string>;
        claimReceiver: PromiseOrValue<string>;
        asset: PromiseOrValue<string>;
        amount: PromiseOrValue<BigNumberish>;
        expiration: PromiseOrValue<BigNumberish>;
        secretHash: PromiseOrValue<BytesLike>;
        signature: PromiseOrValue<BytesLike>;
    };
    type RedeemOrderStructOutput = [
        string,
        string,
        string,
        string,
        BigNumber,
        BigNumber,
        string,
        string
    ] & {
        sender: string;
        receiver: string;
        claimReceiver: string;
        asset: string;
        amount: BigNumber;
        expiration: BigNumber;
        secretHash: string;
        signature: string;
    };
}
export interface ExchangeInterface extends utils.Interface {
    functions: {
        "WETH()": FunctionFragment;
        "addBroker(address,uint256)": FunctionFragment;
        "assetRisks(address)": FunctionFragment;
        "atomicSwaps(bytes32)": FunctionFragment;
        "brokers(address)": FunctionFragment;
        "calcPosition(address)": FunctionFragment;
        "checkPosition(address)": FunctionFragment;
        "claimAtomic(address,bytes,bytes)": FunctionFragment;
        "deposit()": FunctionFragment;
        "depositAsset(address,uint112)": FunctionFragment;
        "depositAssetTo(address,uint112,address)": FunctionFragment;
        "depositTo(address)": FunctionFragment;
        "fillAndLockAtomic(((address,address,address,address,address,uint64,uint64,uint64,uint64,uint64,uint8,bytes),uint24,bytes32,uint64),(address,address,address,address,address,uint64,uint64,uint64,uint64,uint64,uint8,bytes),uint64,uint64)": FunctionFragment;
        "fillOrders((address,address,address,address,address,uint64,uint64,uint64,uint64,uint64,uint8,bytes),(address,address,address,address,address,uint64,uint64,uint64,uint64,uint64,uint8,bytes),uint64,uint112)": FunctionFragment;
        "fillThroughPools(uint112,(address,address,address,address,address,uint64,uint64,uint64,uint64,uint64,uint8,bytes),address,(address,address,address,address,uint256,uint256,uint256),bytes,bytes)": FunctionFragment;
        "filledAmounts(bytes32)": FunctionFragment;
        "getBalance(address,address)": FunctionFragment;
        "getBalances(address[],address)": FunctionFragment;
        "getCollateralAssets()": FunctionFragment;
        "getFilledAmounts(bytes32,(address,address,address,address,address,uint64,uint64,uint64,uint64,uint64,uint8,bytes))": FunctionFragment;
        "getLiabilities(address)": FunctionFragment;
        "getLockedStakeBalance(address)": FunctionFragment;
        "initialize()": FunctionFragment;
        "liabilities(address,uint256)": FunctionFragment;
        "liquidationPremium()": FunctionFragment;
        "lockAtomic((address,uint64,address,uint64,uint24,bytes32,bytes))": FunctionFragment;
        "lockAtomicByMatcher((address,uint64,address,uint64,uint24,bytes32,bytes))": FunctionFragment;
        "owner()": FunctionFragment;
        "positionOverdue()": FunctionFragment;
        "priceOverdue()": FunctionFragment;
        "redeem2Atomics((address,address,address,address,uint64,uint64,bytes32,bytes),bytes,(address,address,address,address,uint64,uint64,bytes32,bytes),bytes)": FunctionFragment;
        "redeemAtomic((address,address,address,address,uint64,uint64,bytes32,bytes),bytes)": FunctionFragment;
        "refundAtomic(bytes32)": FunctionFragment;
        "renounceOwnership()": FunctionFragment;
        "requireBroker(address)": FunctionFragment;
        "secrets(bytes32)": FunctionFragment;
        "setAssetBalance(address,address,int192)": FunctionFragment;
        "setBasicParams(address,address,address,address,uint64)": FunctionFragment;
        "stakeRisk()": FunctionFragment;
        "swap(address,(address,address,address,address,uint256,uint256,uint256),bytes,bytes)": FunctionFragment;
        "transferOwnership(address)": FunctionFragment;
        "updateAssetRisks(address[],uint8[])": FunctionFragment;
        "updateMarginalSettings(address[],uint8,uint8,uint64,uint64)": FunctionFragment;
        "withdraw(address,uint112)": FunctionFragment;
        "withdrawAssets(address,uint256)": FunctionFragment;
        "withdrawTo(address,uint112,address)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "WETH" | "addBroker" | "assetRisks" | "atomicSwaps" | "brokers" | "calcPosition" | "checkPosition" | "claimAtomic" | "deposit" | "depositAsset" | "depositAssetTo" | "depositTo" | "fillAndLockAtomic" | "fillOrders" | "fillThroughPools" | "filledAmounts" | "getBalance" | "getBalances" | "getCollateralAssets" | "getFilledAmounts" | "getLiabilities" | "getLockedStakeBalance" | "initialize" | "liabilities" | "liquidationPremium" | "lockAtomic" | "lockAtomicByMatcher" | "owner" | "positionOverdue" | "priceOverdue" | "redeem2Atomics" | "redeemAtomic" | "refundAtomic" | "renounceOwnership" | "requireBroker" | "secrets" | "setAssetBalance" | "setBasicParams" | "stakeRisk" | "swap" | "transferOwnership" | "updateAssetRisks" | "updateMarginalSettings" | "withdraw" | "withdrawAssets" | "withdrawTo"): FunctionFragment;
    encodeFunctionData(functionFragment: "WETH", values?: undefined): string;
    encodeFunctionData(functionFragment: "addBroker", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "assetRisks", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "atomicSwaps", values: [PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "brokers", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "calcPosition", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "checkPosition", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "claimAtomic", values: [
        PromiseOrValue<string>,
        PromiseOrValue<BytesLike>,
        PromiseOrValue<BytesLike>
    ]): string;
    encodeFunctionData(functionFragment: "deposit", values?: undefined): string;
    encodeFunctionData(functionFragment: "depositAsset", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "depositAssetTo", values: [
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<string>
    ]): string;
    encodeFunctionData(functionFragment: "depositTo", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "fillAndLockAtomic", values: [
        LibValidator.CrossChainOrderStruct,
        LibValidator.OrderStruct,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "fillOrders", values: [
        LibValidator.OrderStruct,
        LibValidator.OrderStruct,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "fillThroughPools", values: [
        PromiseOrValue<BigNumberish>,
        LibValidator.OrderStruct,
        PromiseOrValue<string>,
        LibValidator.SwapDescriptionStruct,
        PromiseOrValue<BytesLike>,
        PromiseOrValue<BytesLike>
    ]): string;
    encodeFunctionData(functionFragment: "filledAmounts", values: [PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "getBalance", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getBalances", values: [PromiseOrValue<string>[], PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getCollateralAssets", values?: undefined): string;
    encodeFunctionData(functionFragment: "getFilledAmounts", values: [PromiseOrValue<BytesLike>, LibValidator.OrderStruct]): string;
    encodeFunctionData(functionFragment: "getLiabilities", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getLockedStakeBalance", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "initialize", values?: undefined): string;
    encodeFunctionData(functionFragment: "liabilities", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "liquidationPremium", values?: undefined): string;
    encodeFunctionData(functionFragment: "lockAtomic", values: [LibValidator.LockOrderStruct]): string;
    encodeFunctionData(functionFragment: "lockAtomicByMatcher", values: [LibValidator.LockOrderStruct]): string;
    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
    encodeFunctionData(functionFragment: "positionOverdue", values?: undefined): string;
    encodeFunctionData(functionFragment: "priceOverdue", values?: undefined): string;
    encodeFunctionData(functionFragment: "redeem2Atomics", values: [
        LibAtomic.RedeemOrderStruct,
        PromiseOrValue<BytesLike>,
        LibAtomic.RedeemOrderStruct,
        PromiseOrValue<BytesLike>
    ]): string;
    encodeFunctionData(functionFragment: "redeemAtomic", values: [LibAtomic.RedeemOrderStruct, PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "refundAtomic", values: [PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
    encodeFunctionData(functionFragment: "requireBroker", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "secrets", values: [PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "setAssetBalance", values: [
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "setBasicParams", values: [
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "stakeRisk", values?: undefined): string;
    encodeFunctionData(functionFragment: "swap", values: [
        PromiseOrValue<string>,
        LibValidator.SwapDescriptionStruct,
        PromiseOrValue<BytesLike>,
        PromiseOrValue<BytesLike>
    ]): string;
    encodeFunctionData(functionFragment: "transferOwnership", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "updateAssetRisks", values: [PromiseOrValue<string>[], PromiseOrValue<BigNumberish>[]]): string;
    encodeFunctionData(functionFragment: "updateMarginalSettings", values: [
        PromiseOrValue<string>[],
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "withdraw", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "withdrawAssets", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "withdrawTo", values: [
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<string>
    ]): string;
    decodeFunctionResult(functionFragment: "WETH", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "addBroker", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "assetRisks", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "atomicSwaps", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "brokers", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "calcPosition", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "checkPosition", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "claimAtomic", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "depositAsset", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "depositAssetTo", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "depositTo", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "fillAndLockAtomic", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "fillOrders", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "fillThroughPools", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "filledAmounts", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getBalance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getBalances", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getCollateralAssets", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getFilledAmounts", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getLiabilities", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getLockedStakeBalance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "liabilities", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "liquidationPremium", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lockAtomic", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lockAtomicByMatcher", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "positionOverdue", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "priceOverdue", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "redeem2Atomics", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "redeemAtomic", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "refundAtomic", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "requireBroker", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "secrets", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setAssetBalance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setBasicParams", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stakeRisk", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "swap", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "updateAssetRisks", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "updateMarginalSettings", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawAssets", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawTo", data: BytesLike): Result;
    events: {
        "AtomicClaimed(address,address,bytes)": EventFragment;
        "AtomicLocked(address,address,bytes32)": EventFragment;
        "AtomicRedeemed(address,address,address,bytes)": EventFragment;
        "AtomicRefunded(address,address,bytes32)": EventFragment;
        "Initialized(uint8)": EventFragment;
        "NewAssetTransaction(address,address,address,bool,uint112,uint64)": EventFragment;
        "OwnershipTransferred(address,address)": EventFragment;
        "Trade(address,address,address,address,uint64,uint192,uint192,bytes32)": EventFragment;
        "BalanceChange(address,address,int192)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "AtomicClaimed"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "AtomicLocked"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "AtomicRedeemed"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "AtomicRefunded"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "NewAssetTransaction"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Trade"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "BalanceChange"): EventFragment;
}
export interface AtomicClaimedEventObject {
    receiver: string;
    asset: string;
    secret: string;
}
export type AtomicClaimedEvent = TypedEvent<[
    string,
    string,
    string
], AtomicClaimedEventObject>;
export type AtomicClaimedEventFilter = TypedEventFilter<AtomicClaimedEvent>;
export interface AtomicLockedEventObject {
    sender: string;
    asset: string;
    secretHash: string;
}
export type AtomicLockedEvent = TypedEvent<[
    string,
    string,
    string
], AtomicLockedEventObject>;
export type AtomicLockedEventFilter = TypedEventFilter<AtomicLockedEvent>;
export interface AtomicRedeemedEventObject {
    sender: string;
    receiver: string;
    asset: string;
    secret: string;
}
export type AtomicRedeemedEvent = TypedEvent<[
    string,
    string,
    string,
    string
], AtomicRedeemedEventObject>;
export type AtomicRedeemedEventFilter = TypedEventFilter<AtomicRedeemedEvent>;
export interface AtomicRefundedEventObject {
    receiver: string;
    asset: string;
    secretHash: string;
}
export type AtomicRefundedEvent = TypedEvent<[
    string,
    string,
    string
], AtomicRefundedEventObject>;
export type AtomicRefundedEventFilter = TypedEventFilter<AtomicRefundedEvent>;
export interface InitializedEventObject {
    version: number;
}
export type InitializedEvent = TypedEvent<[number], InitializedEventObject>;
export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
export interface NewAssetTransactionEventObject {
    beneficiary: string;
    recipient: string;
    assetAddress: string;
    isDeposit: boolean;
    amount: BigNumber;
    timestamp: BigNumber;
}
export type NewAssetTransactionEvent = TypedEvent<[
    string,
    string,
    string,
    boolean,
    BigNumber,
    BigNumber
], NewAssetTransactionEventObject>;
export type NewAssetTransactionEventFilter = TypedEventFilter<NewAssetTransactionEvent>;
export interface OwnershipTransferredEventObject {
    previousOwner: string;
    newOwner: string;
}
export type OwnershipTransferredEvent = TypedEvent<[
    string,
    string
], OwnershipTransferredEventObject>;
export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
export interface TradeEventObject {
    buyer: string;
    seller: string;
    baseAsset: string;
    quoteAsset: string;
    filledPrice: BigNumber;
    filledAmount: BigNumber;
    amountQuote: BigNumber;
    tradeId: string;
}
export type TradeEvent = TypedEvent<[
    string,
    string,
    string,
    string,
    BigNumber,
    BigNumber,
    BigNumber,
    string
], TradeEventObject>;
export type TradeEventFilter = TypedEventFilter<TradeEvent>;
export interface BalanceChangeEventObject {
    user: string;
    asset: string;
    delta: BigNumber;
}
export type BalanceChangeEvent = TypedEvent<[
    string,
    string,
    BigNumber
], BalanceChangeEventObject>;
export type BalanceChangeEventFilter = TypedEventFilter<BalanceChangeEvent>;
export interface Exchange extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: ExchangeInterface;
    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
    listeners(eventName?: string): Array<Listener>;
    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
    removeAllListeners(eventName?: string): this;
    off: OnEvent<this>;
    on: OnEvent<this>;
    once: OnEvent<this>;
    removeListener: OnEvent<this>;
    functions: {
        WETH(overrides?: CallOverrides): Promise<[string]>;
        addBroker(user: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        assetRisks(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[number]>;
        atomicSwaps(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
            string,
            BigNumber,
            boolean,
            string,
            BigNumber,
            number
        ] & {
            sender: string;
            expiration: BigNumber;
            used: boolean;
            asset: string;
            amount: BigNumber;
            targetChainId: number;
        }>;
        brokers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        calcPosition(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[MarginalFunctionality.PositionStructOutput]>;
        checkPosition(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        claimAtomic(receiver: PromiseOrValue<string>, secret: PromiseOrValue<BytesLike>, matcherSignature: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        deposit(overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        depositAsset(assetAddress: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        depositAssetTo(assetAddress: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, account: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        depositTo(account: PromiseOrValue<string>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        fillAndLockAtomic(userOrder: LibValidator.CrossChainOrderStruct, brokerOrder: LibValidator.OrderStruct, filledPrice: PromiseOrValue<BigNumberish>, filledAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        fillOrders(buyOrder: LibValidator.OrderStruct, sellOrder: LibValidator.OrderStruct, filledPrice: PromiseOrValue<BigNumberish>, filledAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        fillThroughPools(filledAmount: PromiseOrValue<BigNumberish>, order: LibValidator.OrderStruct, executor: PromiseOrValue<string>, desc: LibValidator.SwapDescriptionStruct, permit: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        filledAmounts(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[BigNumber]>;
        getBalance(assetAddress: PromiseOrValue<string>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        getBalances(assetsAddresses: PromiseOrValue<string>[], user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber[]] & {
            balances: BigNumber[];
        }>;
        getCollateralAssets(overrides?: CallOverrides): Promise<[string[]]>;
        getFilledAmounts(orderHash: PromiseOrValue<BytesLike>, order: LibValidator.OrderStruct, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber
        ] & {
            totalFilled: BigNumber;
            totalFeesPaid: BigNumber;
        }>;
        getLiabilities(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            MarginalFunctionality.LiabilityStructOutput[]
        ] & {
            liabilitiesArray: MarginalFunctionality.LiabilityStructOutput[];
        }>;
        getLockedStakeBalance(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        initialize(overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        liabilities(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            string,
            BigNumber,
            BigNumber
        ] & {
            asset: string;
            timestamp: BigNumber;
            outstandingAmount: BigNumber;
        }>;
        liquidationPremium(overrides?: CallOverrides): Promise<[number]>;
        lockAtomic(lockOrder: LibValidator.LockOrderStruct, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        lockAtomicByMatcher(lockOrder: LibValidator.LockOrderStruct, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        owner(overrides?: CallOverrides): Promise<[string]>;
        positionOverdue(overrides?: CallOverrides): Promise<[BigNumber]>;
        priceOverdue(overrides?: CallOverrides): Promise<[BigNumber]>;
        redeem2Atomics(order1: LibAtomic.RedeemOrderStruct, secret1: PromiseOrValue<BytesLike>, order2: LibAtomic.RedeemOrderStruct, secret2: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        redeemAtomic(order: LibAtomic.RedeemOrderStruct, secret: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        refundAtomic(secretHash: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        requireBroker(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[void]>;
        secrets(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean]>;
        setAssetBalance(assetAddress: PromiseOrValue<string>, account: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setBasicParams(orionToken: PromiseOrValue<string>, priceOracleAddress: PromiseOrValue<string>, allowedMatcher: PromiseOrValue<string>, WETH_: PromiseOrValue<string>, claimAtomicFee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        stakeRisk(overrides?: CallOverrides): Promise<[number]>;
        swap(executor: PromiseOrValue<string>, desc: LibValidator.SwapDescriptionStruct, permit: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        updateAssetRisks(assets: PromiseOrValue<string>[], risks: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        updateMarginalSettings(_collateralAssets: PromiseOrValue<string>[], _stakeRisk: PromiseOrValue<BigNumberish>, _liquidationPremium: PromiseOrValue<BigNumberish>, _priceOverdue: PromiseOrValue<BigNumberish>, _positionOverdue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdraw(assetAddress: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdrawAssets(assetAddress: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdrawTo(assetAddress: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
    };
    WETH(overrides?: CallOverrides): Promise<string>;
    addBroker(user: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    assetRisks(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<number>;
    atomicSwaps(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
        string,
        BigNumber,
        boolean,
        string,
        BigNumber,
        number
    ] & {
        sender: string;
        expiration: BigNumber;
        used: boolean;
        asset: string;
        amount: BigNumber;
        targetChainId: number;
    }>;
    brokers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    calcPosition(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<MarginalFunctionality.PositionStructOutput>;
    checkPosition(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    claimAtomic(receiver: PromiseOrValue<string>, secret: PromiseOrValue<BytesLike>, matcherSignature: PromiseOrValue<BytesLike>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    deposit(overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    depositAsset(assetAddress: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    depositAssetTo(assetAddress: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, account: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    depositTo(account: PromiseOrValue<string>, overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    fillAndLockAtomic(userOrder: LibValidator.CrossChainOrderStruct, brokerOrder: LibValidator.OrderStruct, filledPrice: PromiseOrValue<BigNumberish>, filledAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    fillOrders(buyOrder: LibValidator.OrderStruct, sellOrder: LibValidator.OrderStruct, filledPrice: PromiseOrValue<BigNumberish>, filledAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    fillThroughPools(filledAmount: PromiseOrValue<BigNumberish>, order: LibValidator.OrderStruct, executor: PromiseOrValue<string>, desc: LibValidator.SwapDescriptionStruct, permit: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    filledAmounts(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
    getBalance(assetAddress: PromiseOrValue<string>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    getBalances(assetsAddresses: PromiseOrValue<string>[], user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber[]>;
    getCollateralAssets(overrides?: CallOverrides): Promise<string[]>;
    getFilledAmounts(orderHash: PromiseOrValue<BytesLike>, order: LibValidator.OrderStruct, overrides?: CallOverrides): Promise<[
        BigNumber,
        BigNumber
    ] & {
        totalFilled: BigNumber;
        totalFeesPaid: BigNumber;
    }>;
    getLiabilities(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<MarginalFunctionality.LiabilityStructOutput[]>;
    getLockedStakeBalance(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    initialize(overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    liabilities(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
        string,
        BigNumber,
        BigNumber
    ] & {
        asset: string;
        timestamp: BigNumber;
        outstandingAmount: BigNumber;
    }>;
    liquidationPremium(overrides?: CallOverrides): Promise<number>;
    lockAtomic(lockOrder: LibValidator.LockOrderStruct, overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    lockAtomicByMatcher(lockOrder: LibValidator.LockOrderStruct, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    owner(overrides?: CallOverrides): Promise<string>;
    positionOverdue(overrides?: CallOverrides): Promise<BigNumber>;
    priceOverdue(overrides?: CallOverrides): Promise<BigNumber>;
    redeem2Atomics(order1: LibAtomic.RedeemOrderStruct, secret1: PromiseOrValue<BytesLike>, order2: LibAtomic.RedeemOrderStruct, secret2: PromiseOrValue<BytesLike>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    redeemAtomic(order: LibAtomic.RedeemOrderStruct, secret: PromiseOrValue<BytesLike>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    refundAtomic(secretHash: PromiseOrValue<BytesLike>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    renounceOwnership(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    requireBroker(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
    secrets(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
    setAssetBalance(assetAddress: PromiseOrValue<string>, account: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setBasicParams(orionToken: PromiseOrValue<string>, priceOracleAddress: PromiseOrValue<string>, allowedMatcher: PromiseOrValue<string>, WETH_: PromiseOrValue<string>, claimAtomicFee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    stakeRisk(overrides?: CallOverrides): Promise<number>;
    swap(executor: PromiseOrValue<string>, desc: LibValidator.SwapDescriptionStruct, permit: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    updateAssetRisks(assets: PromiseOrValue<string>[], risks: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    updateMarginalSettings(_collateralAssets: PromiseOrValue<string>[], _stakeRisk: PromiseOrValue<BigNumberish>, _liquidationPremium: PromiseOrValue<BigNumberish>, _priceOverdue: PromiseOrValue<BigNumberish>, _positionOverdue: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdraw(assetAddress: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdrawAssets(assetAddress: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdrawTo(assetAddress: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    callStatic: {
        WETH(overrides?: CallOverrides): Promise<string>;
        addBroker(user: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        assetRisks(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<number>;
        atomicSwaps(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
            string,
            BigNumber,
            boolean,
            string,
            BigNumber,
            number
        ] & {
            sender: string;
            expiration: BigNumber;
            used: boolean;
            asset: string;
            amount: BigNumber;
            targetChainId: number;
        }>;
        brokers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        calcPosition(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<MarginalFunctionality.PositionStructOutput>;
        checkPosition(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        claimAtomic(receiver: PromiseOrValue<string>, secret: PromiseOrValue<BytesLike>, matcherSignature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
        deposit(overrides?: CallOverrides): Promise<void>;
        depositAsset(assetAddress: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        depositAssetTo(assetAddress: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        depositTo(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        fillAndLockAtomic(userOrder: LibValidator.CrossChainOrderStruct, brokerOrder: LibValidator.OrderStruct, filledPrice: PromiseOrValue<BigNumberish>, filledAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        fillOrders(buyOrder: LibValidator.OrderStruct, sellOrder: LibValidator.OrderStruct, filledPrice: PromiseOrValue<BigNumberish>, filledAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        fillThroughPools(filledAmount: PromiseOrValue<BigNumberish>, order: LibValidator.OrderStruct, executor: PromiseOrValue<string>, desc: LibValidator.SwapDescriptionStruct, permit: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
        filledAmounts(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
        getBalance(assetAddress: PromiseOrValue<string>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getBalances(assetsAddresses: PromiseOrValue<string>[], user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber[]>;
        getCollateralAssets(overrides?: CallOverrides): Promise<string[]>;
        getFilledAmounts(orderHash: PromiseOrValue<BytesLike>, order: LibValidator.OrderStruct, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber
        ] & {
            totalFilled: BigNumber;
            totalFeesPaid: BigNumber;
        }>;
        getLiabilities(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<MarginalFunctionality.LiabilityStructOutput[]>;
        getLockedStakeBalance(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        initialize(overrides?: CallOverrides): Promise<void>;
        liabilities(arg0: PromiseOrValue<string>, arg1: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            string,
            BigNumber,
            BigNumber
        ] & {
            asset: string;
            timestamp: BigNumber;
            outstandingAmount: BigNumber;
        }>;
        liquidationPremium(overrides?: CallOverrides): Promise<number>;
        lockAtomic(lockOrder: LibValidator.LockOrderStruct, overrides?: CallOverrides): Promise<void>;
        lockAtomicByMatcher(lockOrder: LibValidator.LockOrderStruct, overrides?: CallOverrides): Promise<void>;
        owner(overrides?: CallOverrides): Promise<string>;
        positionOverdue(overrides?: CallOverrides): Promise<BigNumber>;
        priceOverdue(overrides?: CallOverrides): Promise<BigNumber>;
        redeem2Atomics(order1: LibAtomic.RedeemOrderStruct, secret1: PromiseOrValue<BytesLike>, order2: LibAtomic.RedeemOrderStruct, secret2: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
        redeemAtomic(order: LibAtomic.RedeemOrderStruct, secret: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
        refundAtomic(secretHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
        renounceOwnership(overrides?: CallOverrides): Promise<void>;
        requireBroker(user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        secrets(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
        setAssetBalance(assetAddress: PromiseOrValue<string>, account: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setBasicParams(orionToken: PromiseOrValue<string>, priceOracleAddress: PromiseOrValue<string>, allowedMatcher: PromiseOrValue<string>, WETH_: PromiseOrValue<string>, claimAtomicFee: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        stakeRisk(overrides?: CallOverrides): Promise<number>;
        swap(executor: PromiseOrValue<string>, desc: LibValidator.SwapDescriptionStruct, permit: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            returnAmount: BigNumber;
            spentAmount: BigNumber;
            gasLeft: BigNumber;
        }>;
        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        updateAssetRisks(assets: PromiseOrValue<string>[], risks: PromiseOrValue<BigNumberish>[], overrides?: CallOverrides): Promise<void>;
        updateMarginalSettings(_collateralAssets: PromiseOrValue<string>[], _stakeRisk: PromiseOrValue<BigNumberish>, _liquidationPremium: PromiseOrValue<BigNumberish>, _priceOverdue: PromiseOrValue<BigNumberish>, _positionOverdue: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        withdraw(assetAddress: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        withdrawAssets(assetAddress: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        withdrawTo(assetAddress: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, to: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
    };
    filters: {
        "AtomicClaimed(address,address,bytes)"(receiver?: null, asset?: null, secret?: null): AtomicClaimedEventFilter;
        AtomicClaimed(receiver?: null, asset?: null, secret?: null): AtomicClaimedEventFilter;
        "AtomicLocked(address,address,bytes32)"(sender?: null, asset?: null, secretHash?: null): AtomicLockedEventFilter;
        AtomicLocked(sender?: null, asset?: null, secretHash?: null): AtomicLockedEventFilter;
        "AtomicRedeemed(address,address,address,bytes)"(sender?: null, receiver?: null, asset?: null, secret?: null): AtomicRedeemedEventFilter;
        AtomicRedeemed(sender?: null, receiver?: null, asset?: null, secret?: null): AtomicRedeemedEventFilter;
        "AtomicRefunded(address,address,bytes32)"(receiver?: null, asset?: null, secretHash?: null): AtomicRefundedEventFilter;
        AtomicRefunded(receiver?: null, asset?: null, secretHash?: null): AtomicRefundedEventFilter;
        "Initialized(uint8)"(version?: null): InitializedEventFilter;
        Initialized(version?: null): InitializedEventFilter;
        "NewAssetTransaction(address,address,address,bool,uint112,uint64)"(beneficiary?: PromiseOrValue<string> | null, recipient?: PromiseOrValue<string> | null, assetAddress?: PromiseOrValue<string> | null, isDeposit?: null, amount?: null, timestamp?: null): NewAssetTransactionEventFilter;
        NewAssetTransaction(beneficiary?: PromiseOrValue<string> | null, recipient?: PromiseOrValue<string> | null, assetAddress?: PromiseOrValue<string> | null, isDeposit?: null, amount?: null, timestamp?: null