import {ethers, Contract, ContractReceipt} from 'ethers';
import {Obligation} from '../typechain/Obligation';
import {OptionPairFactory} from '../typechain/OptionPairFactory';
import {BigNumberish, BytesLike, BigNumber} from 'ethers';
import {Option} from '../typechain/Option';
import {OptionLib} from '../typechain/OptionLib';
import {Script} from './constants';
import {Ierc20} from '../typechain/Ierc20';
import {IRelay} from '../typechain/IRelay';
import {IReferee} from '../typechain/IReferee';
import {ITreasury} from '../typechain/ITreasury';
import {IWriterRegistry} from '../typechain/IWriterRegistry';
import {SignerOrProvider, Optional, Signer, Provider} from './core';
import {Addresses} from './addresses';
import {EventFragment, Result} from 'ethers/lib/utils';
import {ConfirmationNotifier} from './notifier';
export declare type AddressesPair = {
  option: string;
  obligation: string;
};
declare type ObligationInfo = {
  _expiryTime: BigNumber;
  _windowSize: BigNumber;
  _strikePrice: BigNumber;
  _decimals: BigNumber;
  _collateral: string;
  _option: string;
};
interface Connectable<C> {
  connect: (addr: string, signer: SignerOrProvider) => C;
}
interface Callable {
  address: string;
}
export declare function reconnect<C extends Callable, A extends Connectable<C>>(
  contract: C,
  factory: A,
  signer: Signer
): C;
export declare function deploy0<C extends Callable>(
  signer: Signer,
  factory: new (signer: Signer) => {
    deploy: () => Promise<C>;
  }
): Promise<C>;
export declare function deploy1<A extends Callable, B>(
  signer: Signer,
  factory: new (signer: Signer) => {
    deploy: (b: B) => Promise<A>;
  },
  arg: B
): Promise<A>;
export declare function deploy2<A extends Callable, B, C>(
  signer: Signer,
  factory: new (signer: Signer) => {
    deploy: (b: B, c: C) => Promise<A>;
  },
  arg0: B,
  arg1: C
): Promise<A>;
export declare function getEvent<T extends any[]>(
  fragment: EventFragment,
  args: T,
  receipt: ContractReceipt,
  contract: Contract
): Promise<Result>;
export declare function getRequestEvent(
  obligation: Obligation,
  buyer: string,
  seller: string,
  receipt: ContractReceipt
): Promise<Result>;
export declare function getCreatePairEvent(
  optionFactory: OptionPairFactory,
  receipt: ContractReceipt
): Promise<Result>;
export declare function createPair(
  optionFactory: OptionPairFactory,
  expiryTime: BigNumberish,
  windowSize: BigNumberish,
  strikePrice: BigNumberish,
  collateral: string,
  referee: string,
  confirmations?: number
): Promise<AddressesPair>;
export declare type BtcAddress = {
  hash: BytesLike;
  format: Script;
};
export interface ReadOptionPair {
  getDetails(): Promise<ObligationInfo>;
  getPairAddress(): Promise<string>;
  totalSupplied(account: string): Promise<BigNumber>;
  totalWritten(account: string): Promise<BigNumber>;
  optionsBalance(account: string): Promise<BigNumber>;
  getOptionInPrice(amount: BigNumberish): Promise<BigNumber>;
  getOptionOutPrice(amount: BigNumberish): Promise<BigNumber>;
}
export interface WriteOptionPair extends ReadOptionPair {
  approveMaxOption(): Promise<void>;
  checkAllowanceOption(): Promise<boolean>;
  write(
    premium: BigNumberish,
    amount: BigNumberish,
    btcAddress?: BtcAddress
  ): ConfirmationNotifier;
  buyOptions(
    amountOut: BigNumberish,
    amountInMax: BigNumberish,
    deadline: BigNumberish
  ): ConfirmationNotifier;
  sellOptions(
    amountIn: BigNumberish,
    amountOutMin: BigNumberish,
    deadline: BigNumberish
  ): ConfirmationNotifier;
  sellObligations(
    amountADesired: BigNumberish,
    amountBDesired: BigNumberish,
    amountAMin: BigNumberish,
    amountBMin: BigNumberish,
    deadline: BigNumberish
  ): ConfirmationNotifier;
  buyObligations(
    amountOut: BigNumberish,
    amountInMax: BigNumberish
  ): ConfirmationNotifier;
  requestExercise(seller: string, satoshis: BigNumberish): ConfirmationNotifier;
  executeExercise(
    seller: string,
    height: BigNumberish,
    index: BigNumberish,
    txid: BytesLike,
    header: BytesLike,
    proof: BytesLike,
    rawtx: BytesLike
  ): ConfirmationNotifier;
}
export declare class ReadOnlyOptionPair implements ReadOptionPair {
  protected option: Option;
  protected obligation: Obligation;
  protected optionLib: OptionLib;
  protected collateral: Ierc20;
  protected treasury: ITreasury;
  constructor(
    option: Option,
    obligation: Obligation,
    optionLib: OptionLib,
    collateral: Ierc20,
    treasury: ITreasury
  );
  getDetails(): Promise<ObligationInfo>;
  getPairAddress(): Promise<string>;
  totalSupplied(account: string): Promise<BigNumber>;
  totalWritten(account: string): Promise<BigNumber>;
  optionsBalance(account: string): Promise<BigNumber>;
  getOptionInPrice(amount: BigNumberish): Promise<BigNumber>;
  getOptionOutPrice(amount: BigNumberish): Promise<BigNumber>;
}
export declare class ReadWriteOptionPair extends ReadOnlyOptionPair
  implements WriteOptionPair {
  readonly account: string;
  readonly confirmations?: number;
  constructor(
    option: Option,
    obligation: Obligation,
    optionLib: OptionLib,
    collateral: Ierc20,
    treasury: ITreasury,
    account: string,
    confirmations?: number
  );
  approveMaxOption(): Promise<void>;
  checkAllowanceOption(): Promise<boolean>;
  write(
    premium: BigNumberish,
    amount: BigNumberish,
    _btcAddress: BtcAddress
  ): ConfirmationNotifier;
  buyOptions(
    amountOut: BigNumberish,
    amountInMax: BigNumberish,
    deadline: BigNumberish
  ): ConfirmationNotifier;
  sellOptions(
    amountIn: BigNumberish,
    amountOutMin: BigNumberish,
    deadline: BigNumberish
  ): ConfirmationNotifier;
  sellObligations(
    amountADesired: BigNumberish,
    amountBDesired: BigNumberish,
    amountAMin: BigNumberish,
    amountBMin: BigNumberish,
    deadline: BigNumberish
  ): ConfirmationNotifier;
  buyObligations(
    amountOut: BigNumberish,
    amountInMax: BigNumberish
  ): ConfirmationNotifier;
  requestExercise(seller: string, satoshis: BigNumberish): ConfirmationNotifier;
  executeExercise(
    seller: string,
    height: BigNumberish,
    index: BigNumberish,
    txid: BytesLike,
    header: BytesLike,
    proof: BytesLike,
    rawtx: BytesLike
  ): ConfirmationNotifier;
  private waitConfirm;
}
export interface ReadContracts {
  getRelayHeight(): Promise<number>;
  getPair(option: string): Promise<ReadOptionPair>;
  listOptions(): Promise<string[]>;
  totalLiquidity(): Promise<BigNumber>;
}
export interface WriteContracts extends ReadContracts {
  checkAllowanceCollateral(): Promise<boolean>;
  approveMaxCollateral(): Promise<void>;
  createPair(
    expiryTime: BigNumberish,
    windowSize: BigNumberish,
    strikePrice: BigNumberish
  ): Promise<WriteOptionPair>;
  getPair(option: string): Promise<WriteOptionPair>;
}
export declare class ReadOnlyContracts implements ReadContracts {
  readonly optionFactory: OptionPairFactory;
  readonly optionLib: OptionLib;
  readonly collateral: Ierc20;
  readonly referee: IReferee;
  readonly relay: IRelay;
  readonly writerRegistry: IWriterRegistry;
  readonly signer: SignerOrProvider;
  constructor(
    optionFactory: OptionPairFactory,
    optionLib: OptionLib,
    collateral: Ierc20,
    referee: IReferee,
    relay: IRelay,
    writerRegistry: IWriterRegistry,
    signer: SignerOrProvider
  );
  static load(
    contracts: Addresses,
    signer: SignerOrProvider
  ): Promise<ReadOnlyContracts>;
  static resolve(provider: Provider): Promise<Optional<ReadOnlyContracts>>;
  getRelayHeight(): Promise<number>;
  getPair(optionAddress: string): Promise<ReadOptionPair>;
  totalLiquidity(): Promise<BigNumber>;
  listOptions(): Promise<string[]>;
}
declare type JsonRpcProvider = ethers.providers.JsonRpcProvider;
export declare class ReadWriteContracts extends ReadOnlyContracts
  implements WriteContracts {
  readonly account: string;
  readonly confirmations?: number;
  constructor(
    optionFactory: OptionPairFactory,
    optionLib: OptionLib,
    collateral: Ierc20,
    referee: IReferee,
    relay: IRelay,
    writerRegistry: IWriterRegistry,
    signer: Signer,
    account: string,
    confirmations?: number
  );
  static load(
    contracts: Addresses,
    signer: Signer,
    confirmations?: number
  ): Promise<ReadWriteContracts>;
  static resolve(
    provider: JsonRpcProvider,
    confirmations?: number
  ): Promise<Optional<ReadWriteContracts>>;
  checkAllowanceCollateral(): Promise<boolean>;
  approveMaxCollateral(): Promise<void>;
  createPair(
    expiryTime: BigNumberish,
    windowSize: BigNumberish,
    strikePrice: BigNumberish
  ): Promise<WriteOptionPair>;
  getPair(optionAddress: string): Promise<WriteOptionPair>;
}
export {};