/* 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 BPoolInterface extends utils.Interface {
  functions: {
    "BONE()": FunctionFragment;
    "BPOW_PRECISION()": FunctionFragment;
    "EXIT_FEE()": FunctionFragment;
    "INIT_POOL_SUPPLY()": FunctionFragment;
    "MAX_BOUND_TOKENS()": FunctionFragment;
    "MAX_BPOW_BASE()": FunctionFragment;
    "MAX_FEE()": FunctionFragment;
    "MAX_IN_RATIO()": FunctionFragment;
    "MAX_OUT_RATIO()": FunctionFragment;
    "MAX_TOTAL_WEIGHT()": FunctionFragment;
    "MAX_WEIGHT()": FunctionFragment;
    "MIN_BALANCE()": FunctionFragment;
    "MIN_BOUND_TOKENS()": FunctionFragment;
    "MIN_BPOW_BASE()": FunctionFragment;
    "MIN_FEE()": FunctionFragment;
    "MIN_WEIGHT()": FunctionFragment;
    "allowance(address,address)": FunctionFragment;
    "approve(address,uint256)": FunctionFragment;
    "balanceOf(address)": FunctionFragment;
    "bind(address,uint256,uint256)": FunctionFragment;
    "calcInGivenOut(uint256,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
    "calcOutGivenIn(uint256,uint256,uint256,uint256,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;
    "calcSpotPrice(uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
    "decimals()": FunctionFragment;
    "decreaseApproval(address,uint256)": FunctionFragment;
    "exitPool(uint256,uint256[])": FunctionFragment;
    "exitswapExternAmountOut(address,uint256,uint256)": FunctionFragment;
    "exitswapPoolAmountIn(address,uint256,uint256)": FunctionFragment;
    "finalize()": FunctionFragment;
    "getBalance(address)": FunctionFragment;
    "getColor()": FunctionFragment;
    "getController()": FunctionFragment;
    "getCurrentTokens()": FunctionFragment;
    "getDenormalizedWeight(address)": FunctionFragment;
    "getFinalTokens()": FunctionFragment;
    "getNormalizedWeight(address)": FunctionFragment;
    "getNumTokens()": FunctionFragment;
    "getSpotPrice(address,address)": FunctionFragment;
    "getSpotPriceSansFee(address,address)": FunctionFragment;
    "getSwapFee()": FunctionFragment;
    "getTotalDenormalizedWeight()": FunctionFragment;
    "gulp(address)": FunctionFragment;
    "increaseApproval(address,uint256)": FunctionFragment;
    "isBound(address)": FunctionFragment;
    "isFinalized()": FunctionFragment;
    "isPublicSwap()": FunctionFragment;
    "joinPool(uint256,uint256[])": FunctionFragment;
    "joinswapExternAmountIn(address,uint256,uint256)": FunctionFragment;
    "joinswapPoolAmountOut(address,uint256,uint256)": FunctionFragment;
    "name()": FunctionFragment;
    "rebind(address,uint256,uint256)": FunctionFragment;
    "setController(address)": FunctionFragment;
    "setPublicSwap(bool)": FunctionFragment;
    "setSwapFee(uint256)": FunctionFragment;
    "swapExactAmountIn(address,uint256,address,uint256,uint256)": FunctionFragment;
    "swapExactAmountOut(address,uint256,address,uint256,uint256)": FunctionFragment;
    "symbol()": FunctionFragment;
    "totalSupply()": FunctionFragment;
    "transfer(address,uint256)": FunctionFragment;
    "transferFrom(address,address,uint256)": FunctionFragment;
    "unbind(address)": FunctionFragment;
  };

  encodeFunctionData(functionFragment: "BONE", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "BPOW_PRECISION",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "EXIT_FEE", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "INIT_POOL_SUPPLY",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MAX_BOUND_TOKENS",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MAX_BPOW_BASE",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "MAX_FEE", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "MAX_IN_RATIO",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MAX_OUT_RATIO",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MAX_TOTAL_WEIGHT",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MAX_WEIGHT",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MIN_BALANCE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MIN_BOUND_TOKENS",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MIN_BPOW_BASE",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "MIN_FEE", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "MIN_WEIGHT",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "allowance",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "approve",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
  encodeFunctionData(
    functionFragment: "bind",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "calcInGivenOut",
    values: [
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "calcOutGivenIn",
    values: [
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      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: "calcSpotPrice",
    values: [
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "decreaseApproval",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "exitPool",
    values: [BigNumberish, BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "exitswapExternAmountOut",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "exitswapPoolAmountIn",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "finalize", values?: undefined): string;
  encodeFunctionData(functionFragment: "getBalance", values: [string]): string;
  encodeFunctionData(functionFragment: "getColor", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getController",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getCurrentTokens",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getDenormalizedWeight",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getFinalTokens",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getNormalizedWeight",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getNumTokens",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getSpotPrice",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "getSpotPriceSansFee",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "getSwapFee",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getTotalDenormalizedWeight",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "gulp", values: [string]): string;
  encodeFunctionData(
    functionFragment: "increaseApproval",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "isBound", values: [string]): string;
  encodeFunctionData(
    functionFragment: "isFinalized",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isPublicSwap",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "joinPool",
    values: [BigNumberish, BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "joinswapExternAmountIn",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "joinswapPoolAmountOut",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "name", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "rebind",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setController",
    values: [string]
  ): 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: "swapExactAmountOut",
    values: [string, BigNumberish, string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "totalSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transfer",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferFrom",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "unbind", values: [string]): string;

  decodeFunctionResult(functionFragment: "BONE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "BPOW_PRECISION",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "EXIT_FEE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "INIT_POOL_SUPPLY",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MAX_BOUND_TOKENS",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MAX_BPOW_BASE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "MAX_FEE", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "MAX_IN_RATIO",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MAX_OUT_RATIO",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MAX_TOTAL_WEIGHT",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "MAX_WEIGHT", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "MIN_BALANCE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MIN_BOUND_TOKENS",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MIN_BPOW_BASE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "MIN_FEE", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "MIN_WEIGHT", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "bind", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "calcInGivenOut",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "calcOutGivenIn",
    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: "calcSpotPrice",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "decreaseApproval",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "exitPool", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "exitswapExternAmountOut",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "exitswapPoolAmountIn",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "finalize", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getBalance", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getColor", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getController",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getCurrentTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDenormalizedWeight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getFinalTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getNormalizedWeight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getNumTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getSpotPrice",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getSpotPriceSansFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getSwapFee", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getTotalDenormalizedWeight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "gulp", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "increaseApproval",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isBound", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isFinalized",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isPublicSwap",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "joinPool", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "joinswapExternAmountIn",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "joinswapPoolAmountOut",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "rebind", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setController",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setPublicSwap",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setSwapFee", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "swapExactAmountIn",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "swapExactAmountOut",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "totalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unbind", data: BytesLike): Result;

  events: {
    "Approval(address,address,uint256)": EventFragment;
    "LOG_CALL(bytes4,address,bytes)": EventFragment;
    "LOG_EXIT(address,address,uint256)": EventFragment;
    "LOG_JOIN(address,address,uint256)": EventFragment;
    "LOG_SWAP(address,address,address,uint256,uint256)": EventFragment;
    "Transfer(address,address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LOG_CALL"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LOG_EXIT"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LOG_JOIN"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LOG_SWAP"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
}

export type ApprovalEvent = TypedEvent<
  [string, string, BigNumber],
  { src: string; dst: string; amt: BigNumber }
>;

export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;

export type LOG_CALLEvent = TypedEvent<
  [string, string, string],
  { sig: string; caller: string; data: string }
>;

export type LOG_CALLEventFilter = TypedEventFilter<LOG_CALLEvent>;

export type LOG_EXITEvent = TypedEvent<
  [string, string, BigNumber],
  { caller: string; tokenOut: string; tokenAmountOut: BigNumber }
>;

export type LOG_EXITEventFilter = TypedEventFilter<LOG_EXITEvent>;

export type LOG_JOINEvent = TypedEvent<
  [string, string, BigNumber],
  { caller: string; tokenIn: string; tokenAmountIn: BigNumber }
>;

export type LOG_JOINEventFilter = TypedEventFilter<LOG_JOINEvent>;

export type LOG_SWAPEvent = TypedEvent<
  [string, string, string, BigNumber, BigNumber],
  {
    caller: string;
    tokenIn: string;
    tokenOut: string;
    tokenAmountIn: BigNumber;
    tokenAmountOut: BigNumber;
  }
>;

export type LOG_SWAPEventFilter = TypedEventFilter<LOG_SWAPEvent>;

export type TransferEvent = TypedEvent<
  [string, string, BigNumber],
  { src: string; dst: string; amt: BigNumber }
>;

export type TransferEventFilter = TypedEventFilter<TransferEvent>;

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

  interface: BPoolInterface;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    allowance(
      src: string,
      dst: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    approve(
      dst: string,
      amt: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    balanceOf(whom: string, overrides?: CallOverrides): Promise<[BigNumber]>;

    bind(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    calcInGivenOut(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      tokenAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { tokenAmountIn: BigNumber }>;

    calcOutGivenIn(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      tokenAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { tokenAmountOut: BigNumber }>;

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

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

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

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

    calcSpotPrice(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { spotPrice: BigNumber }>;

    decimals(overrides?: CallOverrides): Promise<[number]>;

    decreaseApproval(
      dst: string,
      amt: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    exitPool(
      poolAmountIn: BigNumberish,
      minAmountsOut: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    exitswapExternAmountOut(
      tokenOut: string,
      tokenAmountOut: BigNumberish,
      maxPoolAmountIn: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    exitswapPoolAmountIn(
      tokenOut: string,
      poolAmountIn: BigNumberish,
      minAmountOut: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

    getNormalizedWeight(
      token: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    getSpotPrice(
      tokenIn: string,
      tokenOut: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { spotPrice: BigNumber }>;

    getSpotPriceSansFee(
      tokenIn: string,
      tokenOut: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { spotPrice: BigNumber }>;

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

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

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

    increaseApproval(
      dst: string,
      amt: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    isBound(t: string, overrides?: CallOverrides): Promise<[boolean]>;

    isFinalized(overrides?: CallOverrides): Promise<[boolean]>;

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

    joinPool(
      poolAmountOut: BigNumberish,
      maxAmountsIn: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    joinswapExternAmountIn(
      tokenIn: string,
      tokenAmountIn: BigNumberish,
      minPoolAmountOut: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    joinswapPoolAmountOut(
      tokenIn: string,
      poolAmountOut: BigNumberish,
      maxAmountIn: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    rebind(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    setPublicSwap(
      public_: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setSwapFee(
      swapFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    swapExactAmountOut(
      tokenIn: string,
      maxAmountIn: BigNumberish,
      tokenOut: string,
      tokenAmountOut: BigNumberish,
      maxPrice: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    transfer(
      dst: string,
      amt: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    transferFrom(
      src: string,
      dst: string,
      amt: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  allowance(
    src: string,
    dst: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  approve(
    dst: string,
    amt: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  balanceOf(whom: string, overrides?: CallOverrides): Promise<BigNumber>;

  bind(
    token: string,
    balance: BigNumberish,
    denorm: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  calcInGivenOut(
    tokenBalanceIn: BigNumberish,
    tokenWeightIn: BigNumberish,
    tokenBalanceOut: BigNumberish,
    tokenWeightOut: BigNumberish,
    tokenAmountOut: BigNumberish,
    swapFee: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  calcOutGivenIn(
    tokenBalanceIn: BigNumberish,
    tokenWeightIn: BigNumberish,
    tokenBalanceOut: BigNumberish,
    tokenWeightOut: BigNumberish,
    tokenAmountIn: BigNumberish,
    swapFee: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

  calcSpotPrice(
    tokenBalanceIn: BigNumberish,
    tokenWeightIn: BigNumberish,
    tokenBalanceOut: BigNumberish,
    tokenWeightOut: BigNumberish,
    swapFee: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  decimals(overrides?: CallOverrides): Promise<number>;

  decreaseApproval(
    dst: string,
    amt: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  exitPool(
    poolAmountIn: BigNumberish,
    minAmountsOut: BigNumberish[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  exitswapExternAmountOut(
    tokenOut: string,
    tokenAmountOut: BigNumberish,
    maxPoolAmountIn: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  exitswapPoolAmountIn(
    tokenOut: string,
    poolAmountIn: BigNumberish,
    minAmountOut: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

  getSpotPrice(
    tokenIn: string,
    tokenOut: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getSpotPriceSansFee(
    tokenIn: string,
    tokenOut: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

  increaseApproval(
    dst: string,
    amt: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

  joinPool(
    poolAmountOut: BigNumberish,
    maxAmountsIn: BigNumberish[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  joinswapExternAmountIn(
    tokenIn: string,
    tokenAmountIn: BigNumberish,
    minPoolAmountOut: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  joinswapPoolAmountOut(
    tokenIn: string,
    poolAmountOut: BigNumberish,
    maxAmountIn: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  rebind(
    token: string,
    balance: BigNumberish,
    denorm: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  setPublicSwap(
    public_: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setSwapFee(
    swapFee: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  swapExactAmountOut(
    tokenIn: string,
    maxAmountIn: BigNumberish,
    tokenOut: string,
    tokenAmountOut: BigNumberish,
    maxPrice: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  transfer(
    dst: string,
    amt: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  transferFrom(
    src: string,
    dst: string,
    amt: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    allowance(
      src: string,
      dst: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    approve(
      dst: string,
      amt: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    balanceOf(whom: string, overrides?: CallOverrides): Promise<BigNumber>;

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

    calcInGivenOut(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      tokenAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calcOutGivenIn(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      tokenAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    calcSpotPrice(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    decimals(overrides?: CallOverrides): Promise<number>;

    decreaseApproval(
      dst: string,
      amt: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    exitPool(
      poolAmountIn: BigNumberish,
      minAmountsOut: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    exitswapExternAmountOut(
      tokenOut: string,
      tokenAmountOut: BigNumberish,
      maxPoolAmountIn: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    exitswapPoolAmountIn(
      tokenOut: string,
      poolAmountIn: BigNumberish,
      minAmountOut: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

    getSpotPrice(
      tokenIn: string,
      tokenOut: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getSpotPriceSansFee(
      tokenIn: string,
      tokenOut: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    increaseApproval(
      dst: string,
      amt: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

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

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

    joinswapExternAmountIn(
      tokenIn: string,
      tokenAmountIn: BigNumberish,
      minPoolAmountOut: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    joinswapPoolAmountOut(
      tokenIn: string,
      poolAmountOut: BigNumberish,
      maxAmountIn: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    setController(manager: string, overrides?: CallOverrides): Promise<void>;

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

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

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

    swapExactAmountOut(
      tokenIn: string,
      maxAmountIn: BigNumberish,
      tokenOut: string,
      tokenAmountOut: BigNumberish,
      maxPrice: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber] & {
        tokenAmountIn: BigNumber;
        spotPriceAfter: BigNumber;
      }
    >;

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

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

    transfer(
      dst: string,
      amt: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    transferFrom(
      src: string,
      dst: string,
      amt: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

  filters: {
    "Approval(address,address,uint256)"(
      src?: string | null,
      dst?: string | null,
      amt?: null
    ): ApprovalEventFilter;
    Approval(
      src?: string | null,
      dst?: string | null,
      amt?: null
    ): ApprovalEventFilter;

    "LOG_CALL(bytes4,address,bytes)"(
      sig?: BytesLike | null,
      caller?: string | null,
      data?: null
    ): LOG_CALLEventFilter;
    LOG_CALL(
      sig?: BytesLike | null,
      caller?: string | null,
      data?: null
    ): LOG_CALLEventFilter;

    "LOG_EXIT(address,address,uint256)"(
      caller?: string | null,
      tokenOut?: string | null,
      tokenAmountOut?: null
    ): LOG_EXITEventFilter;
    LOG_EXIT(
      caller?: string | null,
      tokenOut?: string | null,
      tokenAmountOut?: null
    ): LOG_EXITEventFilter;

    "LOG_JOIN(address,address,uint256)"(
      caller?: string | null,
      tokenIn?: string | null,
      tokenAmountIn?: null
    ): LOG_JOINEventFilter;
    LOG_JOIN(
      caller?: string | null,
      tokenIn?: string | null,
      tokenAmountIn?: null
    ): LOG_JOINEventFilter;

    "LOG_SWAP(address,address,address,uint256,uint256)"(
      caller?: string | null,
      tokenIn?: string | null,
      tokenOut?: string | null,
      tokenAmountIn?: null,
      tokenAmountOut?: null
    ): LOG_SWAPEventFilter;
    LOG_SWAP(
      caller?: string | null,
      tokenIn?: string | null,
      tokenOut?: string | null,
      tokenAmountIn?: null,
      tokenAmountOut?: null
    ): LOG_SWAPEventFilter;

    "Transfer(address,address,uint256)"(
      src?: string | null,
      dst?: string | null,
      amt?: null
    ): TransferEventFilter;
    Transfer(
      src?: string | null,
      dst?: string | null,
      amt?: null
    ): TransferEventFilter;
  };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    allowance(
      src: string,
      dst: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    approve(
      dst: string,
      amt: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    balanceOf(whom: string, overrides?: CallOverrides): Promise<BigNumber>;

    bind(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    calcInGivenOut(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      tokenAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    calcOutGivenIn(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      tokenAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    calcSpotPrice(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    decreaseApproval(
      dst: string,
      amt: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    exitPool(
      poolAmountIn: BigNumberish,
      minAmountsOut: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    exitswapExternAmountOut(
      tokenOut: string,
      tokenAmountOut: BigNumberish,
      maxPoolAmountIn: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    exitswapPoolAmountIn(
      tokenOut: string,
      poolAmountIn: BigNumberish,
      minAmountOut: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

    getSpotPrice(
      tokenIn: string,
      tokenOut: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getSpotPriceSansFee(
      tokenIn: string,
      tokenOut: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    increaseApproval(
      dst: string,
      amt: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

    joinPool(
      poolAmountOut: BigNumberish,
      maxAmountsIn: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    joinswapExternAmountIn(
      tokenIn: string,
      tokenAmountIn: BigNumberish,
      minPoolAmountOut: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    joinswapPoolAmountOut(
      tokenIn: string,
      poolAmountOut: BigNumberish,
      maxAmountIn: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    rebind(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    setPublicSwap(
      public_: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setSwapFee(
      swapFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    swapExactAmountOut(
      tokenIn: string,
      maxAmountIn: BigNumberish,
      tokenOut: string,
      tokenAmountOut: BigNumberish,
      maxPrice: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    transfer(
      dst: string,
      amt: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    transferFrom(
      src: string,
      dst: string,
      amt: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    allowance(
      src: string,
      dst: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    approve(
      dst: string,
      amt: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    balanceOf(
      whom: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    bind(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    calcInGivenOut(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      tokenAmountOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    calcOutGivenIn(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      tokenAmountIn: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    calcSpotPrice(
      tokenBalanceIn: BigNumberish,
      tokenWeightIn: BigNumberish,
      tokenBalanceOut: BigNumberish,
      tokenWeightOut: BigNumberish,
      swapFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    decreaseApproval(
      dst: string,
      amt: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    exitPool(
      poolAmountIn: BigNumberish,
      minAmountsOut: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    exitswapExternAmountOut(
      tokenOut: string,
      tokenAmountOut: BigNumberish,
      maxPoolAmountIn: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    exitswapPoolAmountIn(
      tokenOut: string,
      poolAmountIn: BigNumberish,
      minAmountOut: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

    getSpotPrice(
      tokenIn: string,
      tokenOut: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getSpotPriceSansFee(
      tokenIn: string,
      tokenOut: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    increaseApproval(
      dst: string,
      amt: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

    joinPool(
      poolAmountOut: BigNumberish,
      maxAmountsIn: BigNumberish[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    joinswapExternAmountIn(
      tokenIn: string,
      tokenAmountIn: BigNumberish,
      minPoolAmountOut: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    joinswapPoolAmountOut(
      tokenIn: string,
      poolAmountOut: BigNumberish,
      maxAmountIn: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    rebind(
      token: string,
      balance: BigNumberish,
      denorm: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    setPublicSwap(
      public_: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setSwapFee(
      swapFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    swapExactAmountOut(
      tokenIn: string,
      maxAmountIn: BigNumberish,
      tokenOut: string,
      tokenAmountOut: BigNumberish,
      maxPrice: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    transfer(
      dst: string,
      amt: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    transferFrom(
      src: string,
      dst: string,
      amt: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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