/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  PopulatedTransaction,
  Signer,
  utils,
} from "ethers";
import { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
import { Listener, Provider } from "@ethersproject/providers";
import { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";

export interface StableswapInterface extends utils.Interface {
  functions: {
    "get_virtual_price()": FunctionFragment;
    "calc_token_amount(uint256[4],bool)": FunctionFragment;
    "add_liquidity(uint256[4],uint256)": FunctionFragment;
    "get_dy(int128,int128,uint256)": FunctionFragment;
    "get_dy_underlying(int128,int128,uint256)": FunctionFragment;
    "exchange(int128,int128,uint256,uint256)": FunctionFragment;
    "exchange_underlying(int128,int128,uint256,uint256)": FunctionFragment;
    "remove_liquidity(uint256,uint256[4])": FunctionFragment;
    "remove_liquidity_imbalance(uint256[4],uint256)": FunctionFragment;
    "commit_new_parameters(uint256,uint256,uint256)": FunctionFragment;
    "apply_new_parameters()": FunctionFragment;
    "revert_new_parameters()": FunctionFragment;
    "commit_transfer_ownership(address)": FunctionFragment;
    "apply_transfer_ownership()": FunctionFragment;
    "revert_transfer_ownership()": FunctionFragment;
    "withdraw_admin_fees()": FunctionFragment;
    "kill_me()": FunctionFragment;
    "unkill_me()": FunctionFragment;
    "coins(int128)": FunctionFragment;
    "underlying_coins(int128)": FunctionFragment;
    "balances(int128)": FunctionFragment;
    "A()": FunctionFragment;
    "fee()": FunctionFragment;
    "admin_fee()": FunctionFragment;
    "owner()": FunctionFragment;
    "admin_actions_deadline()": FunctionFragment;
    "transfer_ownership_deadline()": FunctionFragment;
    "future_A()": FunctionFragment;
    "future_fee()": FunctionFragment;
    "future_admin_fee()": FunctionFragment;
    "future_owner()": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "get_virtual_price",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "calc_token_amount",
    values: [[BigNumberish, BigNumberish, BigNumberish, BigNumberish], boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "add_liquidity",
    values: [
      [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      BigNumberish
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "get_dy",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "get_dy_underlying",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "exchange",
    values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "exchange_underlying",
    values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "remove_liquidity",
    values: [
      BigNumberish,
      [BigNumberish, BigNumberish, BigNumberish, BigNumberish]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "remove_liquidity_imbalance",
    values: [
      [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      BigNumberish
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "commit_new_parameters",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "apply_new_parameters",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "revert_new_parameters",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "commit_transfer_ownership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "apply_transfer_ownership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "revert_transfer_ownership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "withdraw_admin_fees",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "kill_me", values?: undefined): string;
  encodeFunctionData(functionFragment: "unkill_me", values?: undefined): string;
  encodeFunctionData(functionFragment: "coins", values: [BigNumberish]): string;
  encodeFunctionData(
    functionFragment: "underlying_coins",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "balances",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "A", values?: undefined): string;
  encodeFunctionData(functionFragment: "fee", values?: undefined): string;
  encodeFunctionData(functionFragment: "admin_fee", values?: undefined): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "admin_actions_deadline",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transfer_ownership_deadline",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "future_A", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "future_fee",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "future_admin_fee",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "future_owner",
    values?: undefined
  ): string;

  decodeFunctionResult(
    functionFragment: "get_virtual_price",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "calc_token_amount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "add_liquidity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "get_dy", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "get_dy_underlying",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "exchange", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "exchange_underlying",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "remove_liquidity",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "remove_liquidity_imbalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "commit_new_parameters",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "apply_new_parameters",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "revert_new_parameters",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "commit_transfer_ownership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "apply_transfer_ownership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "revert_transfer_ownership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdraw_admin_fees",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "kill_me", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "unkill_me", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "coins", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "underlying_coins",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "balances", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "A", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "fee", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "admin_fee", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "admin_actions_deadline",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transfer_ownership_deadline",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "future_A", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "future_fee", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "future_admin_fee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "future_owner",
    data: BytesLike
  ): Result;

  events: {
    "TokenExchange(address,int128,uint256,int128,uint256)": EventFragment;
    "TokenExchangeUnderlying(address,int128,uint256,int128,uint256)": EventFragment;
    "AddLiquidity(address,uint256[4],uint256[4],uint256,uint256)": EventFragment;
    "RemoveLiquidity(address,uint256[4],uint256[4],uint256)": EventFragment;
    "RemoveLiquidityImbalance(address,uint256[4],uint256[4],uint256,uint256)": EventFragment;
    "CommitNewAdmin(uint256,address)": EventFragment;
    "NewAdmin(address)": EventFragment;
    "CommitNewParameters(uint256,uint256,uint256,uint256)": EventFragment;
    "NewParameters(uint256,uint256,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "TokenExchange"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokenExchangeUnderlying"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "AddLiquidity"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RemoveLiquidity"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RemoveLiquidityImbalance"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "CommitNewAdmin"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewAdmin"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "CommitNewParameters"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewParameters"): EventFragment;
}

export type TokenExchangeEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber, BigNumber],
  {
    buyer: string;
    sold_id: BigNumber;
    tokens_sold: BigNumber;
    bought_id: BigNumber;
    tokens_bought: BigNumber;
  }
>;

export type TokenExchangeEventFilter = TypedEventFilter<TokenExchangeEvent>;

export type TokenExchangeUnderlyingEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber, BigNumber],
  {
    buyer: string;
    sold_id: BigNumber;
    tokens_sold: BigNumber;
    bought_id: BigNumber;
    tokens_bought: BigNumber;
  }
>;

export type TokenExchangeUnderlyingEventFilter = TypedEventFilter<TokenExchangeUnderlyingEvent>;

export type AddLiquidityEvent = TypedEvent<
  [
    string,
    [BigNumber, BigNumber, BigNumber, BigNumber],
    [BigNumber, BigNumber, BigNumber, BigNumber],
    BigNumber,
    BigNumber
  ],
  {
    provider: string;
    token_amounts: [BigNumber, BigNumber, BigNumber, BigNumber];
    fees: [BigNumber, BigNumber, BigNumber, BigNumber];
    invariant: BigNumber;
    token_supply: BigNumber;
  }
>;

export type AddLiquidityEventFilter = TypedEventFilter<AddLiquidityEvent>;

export type RemoveLiquidityEvent = TypedEvent<
  [
    string,
    [BigNumber, BigNumber, BigNumber, BigNumber],
    [BigNumber, BigNumber, BigNumber, BigNumber],
    BigNumber
  ],
  {
    provider: string;
    token_amounts: [BigNumber, BigNumber, BigNumber, BigNumber];
    fees: [BigNumber, BigNumber, BigNumber, BigNumber];
    token_supply: BigNumber;
  }
>;

export type RemoveLiquidityEventFilter = TypedEventFilter<RemoveLiquidityEvent>;

export type RemoveLiquidityImbalanceEvent = TypedEvent<
  [
    string,
    [BigNumber, BigNumber, BigNumber, BigNumber],
    [BigNumber, BigNumber, BigNumber, BigNumber],
    BigNumber,
    BigNumber
  ],
  {
    provider: string;
    token_amounts: [BigNumber, BigNumber, BigNumber, BigNumber];
    fees: [BigNumber, BigNumber, BigNumber, BigNumber];
    invariant: BigNumber;
    token_supply: BigNumber;
  }
>;

export type RemoveLiquidityImbalanceEventFilter = TypedEventFilter<RemoveLiquidityImbalanceEvent>;

export type CommitNewAdminEvent = TypedEvent<
  [BigNumber, string],
  { deadline: BigNumber; admin: string }
>;

export type CommitNewAdminEventFilter = TypedEventFilter<CommitNewAdminEvent>;

export type NewAdminEvent = TypedEvent<[string], { admin: string }>;

export type NewAdminEventFilter = TypedEventFilter<NewAdminEvent>;

export type CommitNewParametersEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber, BigNumber],
  { deadline: BigNumber; A: BigNumber; fee: BigNumber; admin_fee: BigNumber }
>;

export type CommitNewParametersEventFilter = TypedEventFilter<CommitNewParametersEvent>;

export type NewParametersEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber],
  { A: BigNumber; fee: BigNumber; admin_fee: BigNumber }
>;

export type NewParametersEventFilter = TypedEventFilter<NewParametersEvent>;

export interface Stableswap extends BaseContract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  interface: StableswapInterface;

  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: {
    get_virtual_price(overrides?: CallOverrides): Promise<[BigNumber]>;

    calc_token_amount(
      amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      deposit: boolean,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    add_liquidity(
      amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      min_mint_amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    get_dy(
      i: BigNumberish,
      j: BigNumberish,
      dx: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    get_dy_underlying(
      i: BigNumberish,
      j: BigNumberish,
      dx: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    exchange(
      i: BigNumberish,
      j: BigNumberish,
      dx: BigNumberish,
      min_dy: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    exchange_underlying(
      i: BigNumberish,
      j: BigNumberish,
      dx: BigNumberish,
      min_dy: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    remove_liquidity(
      _amount: BigNumberish,
      min_amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    remove_liquidity_imbalance(
      amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      max_burn_amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    commit_new_parameters(
      amplification: BigNumberish,
      new_fee: BigNumberish,
      new_admin_fee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    apply_new_parameters(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    revert_new_parameters(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    commit_transfer_ownership(
      _owner: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    apply_transfer_ownership(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    revert_transfer_ownership(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    withdraw_admin_fees(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    kill_me(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    unkill_me(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    coins(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;

    underlying_coins(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

    balances(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    A(overrides?: CallOverrides): Promise<[BigNumber]>;

    fee(overrides?: CallOverrides): Promise<[BigNumber]>;

    admin_fee(overrides?: CallOverrides): Promise<[BigNumber]>;

    owner(overrides?: CallOverrides): Promise<[string]>;

    admin_actions_deadline(overrides?: CallOverrides): Promise<[BigNumber]>;

    transfer_ownership_deadline(
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    future_A(overrides?: CallOverrides): Promise<[BigNumber]>;

    future_fee(overrides?: CallOverrides): Promise<[BigNumber]>;

    future_admin_fee(overrides?: CallOverrides): Promise<[BigNumber]>;

    future_owner(overrides?: CallOverrides): Promise<[string]>;
  };

  get_virtual_price(overrides?: CallOverrides): Promise<BigNumber>;

  calc_token_amount(
    amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
    deposit: boolean,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  add_liquidity(
    amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
    min_mint_amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  get_dy(
    i: BigNumberish,
    j: BigNumberish,
    dx: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  get_dy_underlying(
    i: BigNumberish,
    j: BigNumberish,
    dx: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  exchange(
    i: BigNumberish,
    j: BigNumberish,
    dx: BigNumberish,
    min_dy: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  exchange_underlying(
    i: BigNumberish,
    j: BigNumberish,
    dx: BigNumberish,
    min_dy: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  remove_liquidity(
    _amount: BigNumberish,
    min_amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  remove_liquidity_imbalance(
    amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
    max_burn_amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  commit_new_parameters(
    amplification: BigNumberish,
    new_fee: BigNumberish,
    new_admin_fee: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  apply_new_parameters(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  revert_new_parameters(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  commit_transfer_ownership(
    _owner: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  apply_transfer_ownership(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  revert_transfer_ownership(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  withdraw_admin_fees(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  kill_me(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  unkill_me(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  coins(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;

  underlying_coins(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  balances(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

  A(overrides?: CallOverrides): Promise<BigNumber>;

  fee(overrides?: CallOverrides): Promise<BigNumber>;

  admin_fee(overrides?: CallOverrides): Promise<BigNumber>;

  owner(overrides?: CallOverrides): Promise<string>;

  admin_actions_deadline(overrides?: CallOverrides): Promise<BigNumber>;

  transfer_ownership_deadline(overrides?: CallOverrides): Promise<BigNumber>;

  future_A(overrides?: CallOverrides): Promise<BigNumber>;

  future_fee(overrides?: CallOverrides): Promise<BigNumber>;

  future_admin_fee(overrides?: CallOverrides): Promise<BigNumber>;

  future_owner(overrides?: CallOverrides): Promise<string>;

  callStatic: {
    get_virtual_price(overrides?: CallOverrides): Promise<BigNumber>;

    calc_token_amount(
      amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      deposit: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    add_liquidity(
      amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      min_mint_amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    get_dy(
      i: BigNumberish,
      j: BigNumberish,
      dx: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    get_dy_underlying(
      i: BigNumberish,
      j: BigNumberish,
      dx: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    exchange(
      i: BigNumberish,
      j: BigNumberish,
      dx: BigNumberish,
      min_dy: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    exchange_underlying(
      i: BigNumberish,
      j: BigNumberish,
      dx: BigNumberish,
      min_dy: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    remove_liquidity(
      _amount: BigNumberish,
      min_amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      overrides?: CallOverrides
    ): Promise<void>;

    remove_liquidity_imbalance(
      amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      max_burn_amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    commit_new_parameters(
      amplification: BigNumberish,
      new_fee: BigNumberish,
      new_admin_fee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    apply_new_parameters(overrides?: CallOverrides): Promise<void>;

    revert_new_parameters(overrides?: CallOverrides): Promise<void>;

    commit_transfer_ownership(
      _owner: string,
      overrides?: CallOverrides
    ): Promise<void>;

    apply_transfer_ownership(overrides?: CallOverrides): Promise<void>;

    revert_transfer_ownership(overrides?: CallOverrides): Promise<void>;

    withdraw_admin_fees(overrides?: CallOverrides): Promise<void>;

    kill_me(overrides?: CallOverrides): Promise<void>;

    unkill_me(overrides?: CallOverrides): Promise<void>;

    coins(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;

    underlying_coins(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    balances(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

    A(overrides?: CallOverrides): Promise<BigNumber>;

    fee(overrides?: CallOverrides): Promise<BigNumber>;

    admin_fee(overrides?: CallOverrides): Promise<BigNumber>;

    owner(overrides?: CallOverrides): Promise<string>;

    admin_actions_deadline(overrides?: CallOverrides): Promise<BigNumber>;

    transfer_ownership_deadline(overrides?: CallOverrides): Promise<BigNumber>;

    future_A(overrides?: CallOverrides): Promise<BigNumber>;

    future_fee(overrides?: CallOverrides): Promise<BigNumber>;

    future_admin_fee(overrides?: CallOverrides): Promise<BigNumber>;

    future_owner(overrides?: CallOverrides): Promise<string>;
  };

  filters: {
    "TokenExchange(address,int128,uint256,int128,uint256)"(
      buyer?: string | null,
      sold_id?: null,
      tokens_sold?: null,
      bought_id?: null,
      tokens_bought?: null
    ): TokenExchangeEventFilter;
    TokenExchange(
      buyer?: string | null,
      sold_id?: null,
      tokens_sold?: null,
      bought_id?: null,
      tokens_bought?: null
    ): TokenExchangeEventFilter;

    "TokenExchangeUnderlying(address,int128,uint256,int128,uint256)"(
      buyer?: string | null,
      sold_id?: null,
      tokens_sold?: null,
      bought_id?: null,
      tokens_bought?: null
    ): TokenExchangeUnderlyingEventFilter;
    TokenExchangeUnderlying(
      buyer?: string | null,
      sold_id?: null,
      tokens_sold?: null,
      bought_id?: null,
      tokens_bought?: null
    ): TokenExchangeUnderlyingEventFilter;

    "AddLiquidity(address,uint256[4],uint256[4],uint256,uint256)"(
      provider?: string | null,
      token_amounts?: null,
      fees?: null,
      invariant?: null,
      token_supply?: null
    ): AddLiquidityEventFilter;
    AddLiquidity(
      provider?: string | null,
      token_amounts?: null,
      fees?: null,
      invariant?: null,
      token_supply?: null
    ): AddLiquidityEventFilter;

    "RemoveLiquidity(address,uint256[4],uint256[4],uint256)"(
      provider?: string | null,
      token_amounts?: null,
      fees?: null,
      token_supply?: null
    ): RemoveLiquidityEventFilter;
    RemoveLiquidity(
      provider?: string | null,
      token_amounts?: null,
      fees?: null,
      token_supply?: null
    ): RemoveLiquidityEventFilter;

    "RemoveLiquidityImbalance(address,uint256[4],uint256[4],uint256,uint256)"(
      provider?: string | null,
      token_amounts?: null,
      fees?: null,
      invariant?: null,
      token_supply?: null
    ): RemoveLiquidityImbalanceEventFilter;
    RemoveLiquidityImbalance(
      provider?: string | null,
      token_amounts?: null,
      fees?: null,
      invariant?: null,
      token_supply?: null
    ): RemoveLiquidityImbalanceEventFilter;

    "CommitNewAdmin(uint256,address)"(
      deadline?: BigNumberish | null,
      admin?: string | null
    ): CommitNewAdminEventFilter;
    CommitNewAdmin(
      deadline?: BigNumberish | null,
      admin?: string | null
    ): CommitNewAdminEventFilter;

    "NewAdmin(address)"(admin?: string | null): NewAdminEventFilter;
    NewAdmin(admin?: string | null): NewAdminEventFilter;

    "CommitNewParameters(uint256,uint256,uint256,uint256)"(
      deadline?: BigNumberish | null,
      A?: null,
      fee?: null,
      admin_fee?: null
    ): CommitNewParametersEventFilter;
    CommitNewParameters(
      deadline?: BigNumberish | null,
      A?: null,
      fee?: null,
      admin_fee?: null
    ): CommitNewParametersEventFilter;

    "NewParameters(uint256,uint256,uint256)"(
      A?: null,
      fee?: null,
      admin_fee?: null
    ): NewParametersEventFilter;
    NewParameters(
      A?: null,
      fee?: null,
      admin_fee?: null
    ): NewParametersEventFilter;
  };

  estimateGas: {
    get_virtual_price(overrides?: CallOverrides): Promise<BigNumber>;

    calc_token_amount(
      amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      deposit: boolean,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    add_liquidity(
      amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      min_mint_amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    get_dy(
      i: BigNumberish,
      j: BigNumberish,
      dx: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    get_dy_underlying(
      i: BigNumberish,
      j: BigNumberish,
      dx: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    exchange(
      i: BigNumberish,
      j: BigNumberish,
      dx: BigNumberish,
      min_dy: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    exchange_underlying(
      i: BigNumberish,
      j: BigNumberish,
      dx: BigNumberish,
      min_dy: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    remove_liquidity(
      _amount: BigNumberish,
      min_amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    remove_liquidity_imbalance(
      amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      max_burn_amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    commit_new_parameters(
      amplification: BigNumberish,
      new_fee: BigNumberish,
      new_admin_fee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    apply_new_parameters(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    revert_new_parameters(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    commit_transfer_ownership(
      _owner: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    apply_transfer_ownership(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    revert_transfer_ownership(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    withdraw_admin_fees(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    kill_me(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    unkill_me(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    coins(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

    underlying_coins(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    balances(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

    A(overrides?: CallOverrides): Promise<BigNumber>;

    fee(overrides?: CallOverrides): Promise<BigNumber>;

    admin_fee(overrides?: CallOverrides): Promise<BigNumber>;

    owner(overrides?: CallOverrides): Promise<BigNumber>;

    admin_actions_deadline(overrides?: CallOverrides): Promise<BigNumber>;

    transfer_ownership_deadline(overrides?: CallOverrides): Promise<BigNumber>;

    future_A(overrides?: CallOverrides): Promise<BigNumber>;

    future_fee(overrides?: CallOverrides): Promise<BigNumber>;

    future_admin_fee(overrides?: CallOverrides): Promise<BigNumber>;

    future_owner(overrides?: CallOverrides): Promise<BigNumber>;
  };

  populateTransaction: {
    get_virtual_price(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    calc_token_amount(
      amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      deposit: boolean,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    add_liquidity(
      amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      min_mint_amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    get_dy(
      i: BigNumberish,
      j: BigNumberish,
      dx: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    get_dy_underlying(
      i: BigNumberish,
      j: BigNumberish,
      dx: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    exchange(
      i: BigNumberish,
      j: BigNumberish,
      dx: BigNumberish,
      min_dy: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    exchange_underlying(
      i: BigNumberish,
      j: BigNumberish,
      dx: BigNumberish,
      min_dy: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    remove_liquidity(
      _amount: BigNumberish,
      min_amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    remove_liquidity_imbalance(
      amounts: [BigNumberish, BigNumberish, BigNumberish, BigNumberish],
      max_burn_amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    commit_new_parameters(
      amplification: BigNumberish,
      new_fee: BigNumberish,
      new_admin_fee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    apply_new_parameters(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    revert_new_parameters(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    commit_transfer_ownership(
      _owner: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    apply_transfer_ownership(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    revert_transfer_ownership(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    withdraw_admin_fees(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    kill_me(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    unkill_me(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    coins(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    underlying_coins(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    balances(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    A(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    fee(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    admin_fee(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    admin_actions_deadline(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    transfer_ownership_deadline(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    future_A(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    future_fee(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    future_admin_fee(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    future_owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
  };
}