@augumented-finance/protocol-v1/dist/types/IBPool.d.ts

Augmented Protocol smart contracts

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

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
} from "ethers";
import {
  Contract,
  ContractTransaction,
  Overrides,
  CallOverrides,
} from "@ethersproject/contracts";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";

interface IBPoolInterface extends ethers.utils.Interface {
  functions: {
    "EXIT_FEE()": FunctionFragment;
    "bind(address,uint256,uint256)": FunctionFragment;
    "calcPoolInGivenSingleOut(uint256,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
    "calcPoolOutGivenSingleIn(uint256,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
    "calcSingleInGivenPoolOut(uint256,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
    "calcSingleOutGivenPoolIn(uint256,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
    "finalize()": FunctionFragment;
    "getBalance(address)": FunctionFragment;
    "getCurrentTokens()": FunctionFragment;
    "getDenormalizedWeight(address)": FunctionFragment;
    "getSwapFee()": FunctionFragment;
    "getTotalDenormalizedWeight()": FunctionFragment;
    "gulp(address)": FunctionFragment;
    "isBound(address)": FunctionFragment;
    "isPublicSwap()": FunctionFragment;
    "joinPool(uint256,uint256[])": FunctionFragment;
    "rebind(address,uint256,uint256)": FunctionFragment;
    "setPublicSwap(bool)": FunctionFragment;
    "setSwapFee(uint256)": FunctionFragment;
    "swapExactAmountIn(address,uint256,address,uint256,uint256)": FunctionFragment;
    "totalSupply()": FunctionFragment;
    "unbind(address)": FunctionFragment;
  };

  encodeFunctionData(functionFragment: "EXIT_FEE", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "bind",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "calcPoolInGivenSingleOut",
    values: [
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "calcPoolOutGivenSingleIn",
    values: [
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "calcSingleInGivenPoolOut",
    values: [
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "calcSingleOutGivenPoolIn",
    values: [
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(functionFragment: "finalize", values?: undefined): string;
  encodeFunctionData(functionFragment: "getBalance", values: [string]): string;
  encodeFunctionData(
    functionFragment: "getCurrentTokens",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getDenormalizedWeight",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getSwapFee",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getTotalDenormalizedWeight",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "gulp", values: [string]): string;
  encodeFunctionData(functionFragment: "isBound", values: [string]): string;
  encodeFunctionData(
    functionFragment: "isPublicSwap",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "joinPool",
    values: [BigNumberish, BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "rebind",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setPublicSwap",
    values: [boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setSwapFee",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "swapExactAmountIn",
    values: [string, BigNumberish, string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "totalSupply",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "unbind", values: [string]): string;

  decodeFunctionResult(functionFragment: "EXIT_FEE", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "bind", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "calcPoolInGivenSingleOut",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "calcPoolOutGivenSingleIn",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "calcSingleInGivenPoolOut",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "calcSingleOutGivenPoolIn",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "finalize", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getBalance", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getCurrentTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDenormalizedWeight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getSwapFee", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getTotalDenormalizedWeight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "gulp", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "isBound", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isPublicSwap",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "joinPool", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "rebind", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setPublicSwap",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setSwapFee", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "swapExactAmountIn",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unbind", data: BytesLike): Result;

  events: {};
}

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

  on(event: EventFilter | string, listener: Listener): this;
  once(event: EventFilter | string, listener: Listener): this;
  addListener(eventName: EventFilter | string, listener: Listener): this;
  removeAllListeners(eventName: EventFilter | string): this;
  removeListener(eventName: any, listener: Listener): this;

  interface: IBPoolInterface;

  functions: {
    EXIT_FEE(
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    "EXIT_FEE()"(
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    bind(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "bind(address,uint256,uint256)"(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    calcPoolInGivenSingleOut(
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      tokenAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      poolAmountIn: BigNumber;
      0: BigNumber;
    }>;

    "calcPoolInGivenSingleOut(uint256,uint256,uint256,uint256,uint256,uint256)"(
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      tokenAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      poolAmountIn: BigNumber;
      0: BigNumber;
    }>;

    calcPoolOutGivenSingleIn(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      tokenAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      poolAmountOut: BigNumber;
      0: BigNumber;
    }>;

    "calcPoolOutGivenSingleIn(uint256,uint256,uint256,uint256,uint256,uint256)"(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      tokenAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      poolAmountOut: BigNumber;
      0: BigNumber;
    }>;

    calcSingleInGivenPoolOut(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      poolAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      tokenAmountIn: BigNumber;
      0: BigNumber;
    }>;

    "calcSingleInGivenPoolOut(uint256,uint256,uint256,uint256,uint256,uint256)"(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      poolAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      tokenAmountIn: BigNumber;
      0: BigNumber;
    }>;

    calcSingleOutGivenPoolIn(
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      poolAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      tokenAmountOut: BigNumber;
      0: BigNumber;
    }>;

    "calcSingleOutGivenPoolIn(uint256,uint256,uint256,uint256,uint256,uint256)"(
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      poolAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      tokenAmountOut: BigNumber;
      0: BigNumber;
    }>;

    finalize(overrides?: Overrides): Promise<ContractTransaction>;

    "finalize()"(overrides?: Overrides): Promise<ContractTransaction>;

    getBalance(
      token: string,
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    "getBalance(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    getCurrentTokens(
      overrides?: CallOverrides
    ): Promise<{
      tokens: string[];
      0: string[];
    }>;

    "getCurrentTokens()"(
      overrides?: CallOverrides
    ): Promise<{
      tokens: string[];
      0: string[];
    }>;

    getDenormalizedWeight(
      token: string,
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    "getDenormalizedWeight(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    getSwapFee(
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    "getSwapFee()"(
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    getTotalDenormalizedWeight(
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    "getTotalDenormalizedWeight()"(
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    gulp(token: string, overrides?: Overrides): Promise<ContractTransaction>;

    "gulp(address)"(
      token: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    isBound(
      token: string,
      overrides?: CallOverrides
    ): Promise<{
      0: boolean;
    }>;

    "isBound(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<{
      0: boolean;
    }>;

    isPublicSwap(
      overrides?: CallOverrides
    ): Promise<{
      0: boolean;
    }>;

    "isPublicSwap()"(
      overrides?: CallOverrides
    ): Promise<{
      0: boolean;
    }>;

    joinPool(
      arg0: BigNumberish,
      arg1: BigNumberish[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "joinPool(uint256,uint256[])"(
      arg0: BigNumberish,
      arg1: BigNumberish[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    rebind(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "rebind(address,uint256,uint256)"(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    setPublicSwap(
      publicSwap: boolean,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "setPublicSwap(bool)"(
      publicSwap: boolean,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    setSwapFee(
      swapFee: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "setSwapFee(uint256)"(
      swapFee: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    swapExactAmountIn(
      tokenIn: string,
      tokenAmountIn: BigNumberish,
      tokenOut: string,
      minAmountOut: BigNumberish,
      maxPrice: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "swapExactAmountIn(address,uint256,address,uint256,uint256)"(
      tokenIn: string,
      tokenAmountIn: BigNumberish,
      tokenOut: string,
      minAmountOut: BigNumberish,
      maxPrice: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    totalSupply(
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    "totalSupply()"(
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    unbind(token: string, overrides?: Overrides): Promise<ContractTransaction>;

    "unbind(address)"(
      token: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;
  };

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

  "EXIT_FEE()"(overrides?: CallOverrides): Promise<BigNumber>;

  bind(
    token: string,
    balance: BigNumberish,
    denorm: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "bind(address,uint256,uint256)"(
    token: string,
    balance: BigNumberish,
    denorm: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  calcPoolInGivenSingleOut(
    tokenBalanceOut: BigNumberish,
    tokenWeightOut: BigNumberish,
    poolSupply: BigNumberish,
    totalWeight: BigNumberish,
    tokenAmountOut: BigNumberish,
    swapFee: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "calcPoolInGivenSingleOut(uint256,uint256,uint256,uint256,uint256,uint256)"(
    tokenBalanceOut: BigNumberish,
    tokenWeightOut: BigNumberish,
    poolSupply: BigNumberish,
    totalWeight: BigNumberish,
    tokenAmountOut: BigNumberish,
    swapFee: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  calcPoolOutGivenSingleIn(
    tokenBalanceIn: BigNumberish,
    tokenWeightIn: BigNumberish,
    poolSupply: BigNumberish,
    totalWeight: BigNumberish,
    tokenAmountIn: BigNumberish,
    swapFee: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "calcPoolOutGivenSingleIn(uint256,uint256,uint256,uint256,uint256,uint256)"(
    tokenBalanceIn: BigNumberish,
    tokenWeightIn: BigNumberish,
    poolSupply: BigNumberish,
    totalWeight: BigNumberish,
    tokenAmountIn: BigNumberish,
    swapFee: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  calcSingleInGivenPoolOut(
    tokenBalanceIn: BigNumberish,
    tokenWeightIn: BigNumberish,
    poolSupply: BigNumberish,
    totalWeight: BigNumberish,
    poolAmountOut: BigNumberish,
    swapFee: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "calcSingleInGivenPoolOut(uint256,uint256,uint256,uint256,uint256,uint256)"(
    tokenBalanceIn: BigNumberish,
    tokenWeightIn: BigNumberish,
    poolSupply: BigNumberish,
    totalWeight: BigNumberish,
    poolAmountOut: BigNumberish,
    swapFee: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  calcSingleOutGivenPoolIn(
    tokenBalanceOut: BigNumberish,
    tokenWeightOut: BigNumberish,
    poolSupply: BigNumberish,
    totalWeight: BigNumberish,
    poolAmountIn: BigNumberish,
    swapFee: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "calcSingleOutGivenPoolIn(uint256,uint256,uint256,uint256,uint256,uint256)"(
    tokenBalanceOut: BigNumberish,
    tokenWeightOut: BigNumberish,
    poolSupply: BigNumberish,
    totalWeight: BigNumberish,
    poolAmountIn: BigNumberish,
    swapFee: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  finalize(overrides?: Overrides): Promise<ContractTransaction>;

  "finalize()"(overrides?: Overrides): Promise<ContractTransaction>;

  getBalance(token: string, overrides?: CallOverrides): Promise<BigNumber>;

  "getBalance(address)"(
    token: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

  getDenormalizedWeight(
    token: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getDenormalizedWeight(address)"(
    token: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  "getSwapFee()"(overrides?: CallOverrides): Promise<BigNumber>;

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

  "getTotalDenormalizedWeight()"(overrides?: CallOverrides): Promise<BigNumber>;

  gulp(token: string, overrides?: Overrides): Promise<ContractTransaction>;

  "gulp(address)"(
    token: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  isBound(token: string, overrides?: CallOverrides): Promise<boolean>;

  "isBound(address)"(
    token: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isPublicSwap(overrides?: CallOverrides): Promise<boolean>;

  "isPublicSwap()"(overrides?: CallOverrides): Promise<boolean>;

  joinPool(
    arg0: BigNumberish,
    arg1: BigNumberish[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "joinPool(uint256,uint256[])"(
    arg0: BigNumberish,
    arg1: BigNumberish[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  rebind(
    token: string,
    balance: BigNumberish,
    denorm: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "rebind(address,uint256,uint256)"(
    token: string,
    balance: BigNumberish,
    denorm: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  setPublicSwap(
    publicSwap: boolean,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "setPublicSwap(bool)"(
    publicSwap: boolean,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  setSwapFee(
    swapFee: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "setSwapFee(uint256)"(
    swapFee: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  swapExactAmountIn(
    tokenIn: string,
    tokenAmountIn: BigNumberish,
    tokenOut: string,
    minAmountOut: BigNumberish,
    maxPrice: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "swapExactAmountIn(address,uint256,address,uint256,uint256)"(
    tokenIn: string,
    tokenAmountIn: BigNumberish,
    tokenOut: string,
    minAmountOut: BigNumberish,
    maxPrice: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

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

  "totalSupply()"(overrides?: CallOverrides): Promise<BigNumber>;

  unbind(token: string, overrides?: Overrides): Promise<ContractTransaction>;

  "unbind(address)"(
    token: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

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

    "EXIT_FEE()"(overrides?: CallOverrides): Promise<BigNumber>;

    bind(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "bind(address,uint256,uint256)"(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    calcPoolInGivenSingleOut(
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      tokenAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "calcPoolInGivenSingleOut(uint256,uint256,uint256,uint256,uint256,uint256)"(
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      tokenAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calcPoolOutGivenSingleIn(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      tokenAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "calcPoolOutGivenSingleIn(uint256,uint256,uint256,uint256,uint256,uint256)"(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      tokenAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calcSingleInGivenPoolOut(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      poolAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "calcSingleInGivenPoolOut(uint256,uint256,uint256,uint256,uint256,uint256)"(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      poolAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calcSingleOutGivenPoolIn(
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      poolAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "calcSingleOutGivenPoolIn(uint256,uint256,uint256,uint256,uint256,uint256)"(
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      poolAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "finalize()"(overrides?: CallOverrides): Promise<void>;

    getBalance(token: string, overrides?: CallOverrides): Promise<BigNumber>;

    "getBalance(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    getDenormalizedWeight(
      token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getDenormalizedWeight(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "getSwapFee()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "getTotalDenormalizedWeight()"(
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    gulp(token: string, overrides?: CallOverrides): Promise<void>;

    "gulp(address)"(token: string, overrides?: CallOverrides): Promise<void>;

    isBound(token: string, overrides?: CallOverrides): Promise<boolean>;

    "isBound(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isPublicSwap(overrides?: CallOverrides): Promise<boolean>;

    "isPublicSwap()"(overrides?: CallOverrides): Promise<boolean>;

    joinPool(
      arg0: BigNumberish,
      arg1: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    "joinPool(uint256,uint256[])"(
      arg0: BigNumberish,
      arg1: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    rebind(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "rebind(address,uint256,uint256)"(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setPublicSwap(
      publicSwap: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    "setPublicSwap(bool)"(
      publicSwap: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setSwapFee(swapFee: BigNumberish, overrides?: CallOverrides): Promise<void>;

    "setSwapFee(uint256)"(
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    swapExactAmountIn(
      tokenIn: string,
      tokenAmountIn: BigNumberish,
      tokenOut: string,
      minAmountOut: BigNumberish,
      maxPrice: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      tokenAmountOut: BigNumber;
      spotPriceAfter: BigNumber;
      0: BigNumber;
      1: BigNumber;
    }>;

    "swapExactAmountIn(address,uint256,address,uint256,uint256)"(
      tokenIn: string,
      tokenAmountIn: BigNumberish,
      tokenOut: string,
      minAmountOut: BigNumberish,
      maxPrice: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      tokenAmountOut: BigNumber;
      spotPriceAfter: BigNumber;
      0: BigNumber;
      1: BigNumber;
    }>;

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

    "totalSupply()"(overrides?: CallOverrides): Promise<BigNumber>;

    unbind(token: string, overrides?: CallOverrides): Promise<void>;

    "unbind(address)"(token: string, overrides?: CallOverrides): Promise<void>;
  };

  filters: {};

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

    "EXIT_FEE()"(overrides?: CallOverrides): Promise<BigNumber>;

    bind(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "bind(address,uint256,uint256)"(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    calcPoolInGivenSingleOut(
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      tokenAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "calcPoolInGivenSingleOut(uint256,uint256,uint256,uint256,uint256,uint256)"(
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      tokenAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calcPoolOutGivenSingleIn(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      tokenAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "calcPoolOutGivenSingleIn(uint256,uint256,uint256,uint256,uint256,uint256)"(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      tokenAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calcSingleInGivenPoolOut(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      poolAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "calcSingleInGivenPoolOut(uint256,uint256,uint256,uint256,uint256,uint256)"(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      poolAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calcSingleOutGivenPoolIn(
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      poolAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "calcSingleOutGivenPoolIn(uint256,uint256,uint256,uint256,uint256,uint256)"(
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      poolAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    finalize(overrides?: Overrides): Promise<BigNumber>;

    "finalize()"(overrides?: Overrides): Promise<BigNumber>;

    getBalance(token: string, overrides?: CallOverrides): Promise<BigNumber>;

    "getBalance(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "getCurrentTokens()"(overrides?: CallOverrides): Promise<BigNumber>;

    getDenormalizedWeight(
      token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getDenormalizedWeight(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "getSwapFee()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "getTotalDenormalizedWeight()"(
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    gulp(token: string, overrides?: Overrides): Promise<BigNumber>;

    "gulp(address)"(token: string, overrides?: Overrides): Promise<BigNumber>;

    isBound(token: string, overrides?: CallOverrides): Promise<BigNumber>;

    "isBound(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "isPublicSwap()"(overrides?: CallOverrides): Promise<BigNumber>;

    joinPool(
      arg0: BigNumberish,
      arg1: BigNumberish[],
      overrides?: Overrides
    ): Promise<BigNumber>;

    "joinPool(uint256,uint256[])"(
      arg0: BigNumberish,
      arg1: BigNumberish[],
      overrides?: Overrides
    ): Promise<BigNumber>;

    rebind(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "rebind(address,uint256,uint256)"(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    setPublicSwap(
      publicSwap: boolean,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "setPublicSwap(bool)"(
      publicSwap: boolean,
      overrides?: Overrides
    ): Promise<BigNumber>;

    setSwapFee(
      swapFee: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "setSwapFee(uint256)"(
      swapFee: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    swapExactAmountIn(
      tokenIn: string,
      tokenAmountIn: BigNumberish,
      tokenOut: string,
      minAmountOut: BigNumberish,
      maxPrice: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "swapExactAmountIn(address,uint256,address,uint256,uint256)"(
      tokenIn: string,
      tokenAmountIn: BigNumberish,
      tokenOut: string,
      minAmountOut: BigNumberish,
      maxPrice: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

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

    "totalSupply()"(overrides?: CallOverrides): Promise<BigNumber>;

    unbind(token: string, overrides?: Overrides): Promise<BigNumber>;

    "unbind(address)"(token: string, overrides?: Overrides): Promise<BigNumber>;
  };

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

    "EXIT_FEE()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    bind(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "bind(address,uint256,uint256)"(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    calcPoolInGivenSingleOut(
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      tokenAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "calcPoolInGivenSingleOut(uint256,uint256,uint256,uint256,uint256,uint256)"(
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      tokenAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    calcPoolOutGivenSingleIn(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      tokenAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "calcPoolOutGivenSingleIn(uint256,uint256,uint256,uint256,uint256,uint256)"(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      tokenAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    calcSingleInGivenPoolOut(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      poolAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "calcSingleInGivenPoolOut(uint256,uint256,uint256,uint256,uint256,uint256)"(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      poolAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    calcSingleOutGivenPoolIn(
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      poolAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "calcSingleOutGivenPoolIn(uint256,uint256,uint256,uint256,uint256,uint256)"(
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      poolSupply: BigNumberish,
      totalWeight: BigNumberish,
      poolAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    finalize(overrides?: Overrides): Promise<PopulatedTransaction>;

    "finalize()"(overrides?: Overrides): Promise<PopulatedTransaction>;

    getBalance(
      token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getBalance(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "getCurrentTokens()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getDenormalizedWeight(
      token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getDenormalizedWeight(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "getSwapFee()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "getTotalDenormalizedWeight()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    gulp(token: string, overrides?: Overrides): Promise<PopulatedTransaction>;

    "gulp(address)"(
      token: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    isBound(
      token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "isBound(address)"(
      token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "isPublicSwap()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    joinPool(
      arg0: BigNumberish,
      arg1: BigNumberish[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "joinPool(uint256,uint256[])"(
      arg0: BigNumberish,
      arg1: BigNumberish[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    rebind(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "rebind(address,uint256,uint256)"(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    setPublicSwap(
      publicSwap: boolean,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "setPublicSwap(bool)"(
      publicSwap: boolean,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    setSwapFee(
      swapFee: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "setSwapFee(uint256)"(
      swapFee: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    swapExactAmountIn(
      tokenIn: string,
      tokenAmountIn: BigNumberish,
      tokenOut: string,
      minAmountOut: BigNumberish,
      maxPrice: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "swapExactAmountIn(address,uint256,address,uint256,uint256)"(
      tokenIn: string,
      tokenAmountIn: BigNumberish,
      tokenOut: string,
      minAmountOut: BigNumberish,
      maxPrice: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

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

    "totalSupply()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    unbind(token: string, overrides?: Overrides): Promise<PopulatedTransaction>;

    "unbind(address)"(
      token: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;
  };
}