@mstable/protocol/dist/types/generated/ICurve.d.ts

mStable Contracts

/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  BaseContract,
  ContractTransaction,
  Overrides,
  CallOverrides,
} from "ethers";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
import { TypedEventFilter, TypedEvent, TypedListener } from "./commons";

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

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

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

  events: {};
}

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

  listeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter?: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): Array<TypedListener<EventArgsArray, EventArgsObject>>;
  off<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  on<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  once<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeListener<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeAllListeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): this;

  listeners(eventName?: string): Array<Listener>;
  off(eventName: string, listener: Listener): this;
  on(eventName: string, listener: Listener): this;
  once(eventName: string, listener: Listener): this;
  removeListener(eventName: string, listener: Listener): this;
  removeAllListeners(eventName?: string): this;

  queryFilter<EventArgsArray extends Array<any>, EventArgsObject>(
    event: TypedEventFilter<EventArgsArray, EventArgsObject>,
    fromBlockOrBlockhash?: string | number | undefined,
    toBlock?: string | number | undefined
  ): Promise<Array<TypedEvent<EventArgsArray & EventArgsObject>>>;

  interface: ICurveInterface;

  functions: {
    A(overrides?: CallOverrides): Promise<[BigNumber] & { out: BigNumber }>;

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

    admin_actions_deadline(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { out: BigNumber }>;

    admin_fee(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { out: BigNumber }>;

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

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

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

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

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

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

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

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

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

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

    fee(overrides?: CallOverrides): Promise<[BigNumber] & { out: BigNumber }>;

    future_A(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { out: BigNumber }>;

    future_admin_fee(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { out: BigNumber }>;

    future_fee(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { out: BigNumber }>;

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

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

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

    get_virtual_price(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { out: BigNumber }>;

    owner(overrides?: CallOverrides): Promise<[string] & { out: string }>;

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

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

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

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

    transfer_ownership_deadline(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { out: BigNumber }>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  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>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    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>;

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

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

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

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

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

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

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

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

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

  filters: {};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    future_owner(overrides?: CallOverrides): 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>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    future_owner(overrides?: CallOverrides): 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>;

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

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

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

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

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

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

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

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

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