@augmentedfinance/protocol-v1/dist/types/IGovernance.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,
  PayableOverrides,
  CallOverrides,
} from "@ethersproject/contracts";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";

interface IGovernanceInterface extends ethers.utils.Interface {
  functions: {
    "cancel(uint256)": FunctionFragment;
    "create(address,address[],uint256[],string[],bytes[],bool[],bytes32)": FunctionFragment;
    "execute(uint256)": FunctionFragment;
    "getGuardian()": FunctionFragment;
    "getProposalState(uint256)": FunctionFragment;
    "getProposalsCount()": FunctionFragment;
    "queue(uint256)": FunctionFragment;
    "submitVote(uint256,bool)": FunctionFragment;
    "submitVoteBySignature(uint256,bool,uint8,bytes32,bytes32)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "cancel",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "create",
    values: [
      string,
      string[],
      BigNumberish[],
      string[],
      BytesLike[],
      boolean[],
      BytesLike
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "execute",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getGuardian",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getProposalState",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getProposalsCount",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "queue", values: [BigNumberish]): string;
  encodeFunctionData(
    functionFragment: "submitVote",
    values: [BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "submitVoteBySignature",
    values: [BigNumberish, boolean, BigNumberish, BytesLike, BytesLike]
  ): string;

  decodeFunctionResult(functionFragment: "cancel", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "create", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getGuardian",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getProposalState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getProposalsCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "queue", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "submitVote", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "submitVoteBySignature",
    data: BytesLike
  ): Result;

  events: {};
}

export class IGovernance 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: IGovernanceInterface;

  functions: {
    cancel(
      proposalId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "cancel(uint256)"(
      proposalId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    create(
      executor: string,
      targets: string[],
      values: BigNumberish[],
      signatures: string[],
      calldatas: BytesLike[],
      withDelegatecalls: boolean[],
      ipfsHash: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "create(address,address[],uint256[],string[],bytes[],bool[],bytes32)"(
      executor: string,
      targets: string[],
      values: BigNumberish[],
      signatures: string[],
      calldatas: BytesLike[],
      withDelegatecalls: boolean[],
      ipfsHash: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    execute(
      proposalId: BigNumberish,
      overrides?: PayableOverrides
    ): Promise<ContractTransaction>;

    "execute(uint256)"(
      proposalId: BigNumberish,
      overrides?: PayableOverrides
    ): Promise<ContractTransaction>;

    getGuardian(overrides?: CallOverrides): Promise<{
      0: string;
    }>;

    "getGuardian()"(overrides?: CallOverrides): Promise<{
      0: string;
    }>;

    getProposalState(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      0: number;
    }>;

    "getProposalState(uint256)"(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      0: number;
    }>;

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

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

    queue(
      proposalId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "queue(uint256)"(
      proposalId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    submitVote(
      proposalId: BigNumberish,
      support: boolean,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "submitVote(uint256,bool)"(
      proposalId: BigNumberish,
      support: boolean,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    submitVoteBySignature(
      proposalId: BigNumberish,
      support: boolean,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "submitVoteBySignature(uint256,bool,uint8,bytes32,bytes32)"(
      proposalId: BigNumberish,
      support: boolean,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;
  };

  cancel(
    proposalId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "cancel(uint256)"(
    proposalId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  create(
    executor: string,
    targets: string[],
    values: BigNumberish[],
    signatures: string[],
    calldatas: BytesLike[],
    withDelegatecalls: boolean[],
    ipfsHash: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "create(address,address[],uint256[],string[],bytes[],bool[],bytes32)"(
    executor: string,
    targets: string[],
    values: BigNumberish[],
    signatures: string[],
    calldatas: BytesLike[],
    withDelegatecalls: boolean[],
    ipfsHash: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  execute(
    proposalId: BigNumberish,
    overrides?: PayableOverrides
  ): Promise<ContractTransaction>;

  "execute(uint256)"(
    proposalId: BigNumberish,
    overrides?: PayableOverrides
  ): Promise<ContractTransaction>;

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

  "getGuardian()"(overrides?: CallOverrides): Promise<string>;

  getProposalState(
    proposalId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

  "getProposalState(uint256)"(
    proposalId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

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

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

  queue(
    proposalId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "queue(uint256)"(
    proposalId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  submitVote(
    proposalId: BigNumberish,
    support: boolean,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "submitVote(uint256,bool)"(
    proposalId: BigNumberish,
    support: boolean,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  submitVoteBySignature(
    proposalId: BigNumberish,
    support: boolean,
    v: BigNumberish,
    r: BytesLike,
    s: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "submitVoteBySignature(uint256,bool,uint8,bytes32,bytes32)"(
    proposalId: BigNumberish,
    support: boolean,
    v: BigNumberish,
    r: BytesLike,
    s: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  callStatic: {
    cancel(proposalId: BigNumberish, overrides?: CallOverrides): Promise<void>;

    "cancel(uint256)"(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    create(
      executor: string,
      targets: string[],
      values: BigNumberish[],
      signatures: string[],
      calldatas: BytesLike[],
      withDelegatecalls: boolean[],
      ipfsHash: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "create(address,address[],uint256[],string[],bytes[],bool[],bytes32)"(
      executor: string,
      targets: string[],
      values: BigNumberish[],
      signatures: string[],
      calldatas: BytesLike[],
      withDelegatecalls: boolean[],
      ipfsHash: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    execute(proposalId: BigNumberish, overrides?: CallOverrides): Promise<void>;

    "execute(uint256)"(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    "getGuardian()"(overrides?: CallOverrides): Promise<string>;

    getProposalState(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    "getProposalState(uint256)"(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

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

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

    queue(proposalId: BigNumberish, overrides?: CallOverrides): Promise<void>;

    "queue(uint256)"(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    submitVote(
      proposalId: BigNumberish,
      support: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    "submitVote(uint256,bool)"(
      proposalId: BigNumberish,
      support: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    submitVoteBySignature(
      proposalId: BigNumberish,
      support: boolean,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    "submitVoteBySignature(uint256,bool,uint8,bytes32,bytes32)"(
      proposalId: BigNumberish,
      support: boolean,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {};

  estimateGas: {
    cancel(proposalId: BigNumberish, overrides?: Overrides): Promise<BigNumber>;

    "cancel(uint256)"(
      proposalId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    create(
      executor: string,
      targets: string[],
      values: BigNumberish[],
      signatures: string[],
      calldatas: BytesLike[],
      withDelegatecalls: boolean[],
      ipfsHash: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "create(address,address[],uint256[],string[],bytes[],bool[],bytes32)"(
      executor: string,
      targets: string[],
      values: BigNumberish[],
      signatures: string[],
      calldatas: BytesLike[],
      withDelegatecalls: boolean[],
      ipfsHash: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;

    execute(
      proposalId: BigNumberish,
      overrides?: PayableOverrides
    ): Promise<BigNumber>;

    "execute(uint256)"(
      proposalId: BigNumberish,
      overrides?: PayableOverrides
    ): Promise<BigNumber>;

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

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

    getProposalState(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getProposalState(uint256)"(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    queue(proposalId: BigNumberish, overrides?: Overrides): Promise<BigNumber>;

    "queue(uint256)"(
      proposalId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    submitVote(
      proposalId: BigNumberish,
      support: boolean,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "submitVote(uint256,bool)"(
      proposalId: BigNumberish,
      support: boolean,
      overrides?: Overrides
    ): Promise<BigNumber>;

    submitVoteBySignature(
      proposalId: BigNumberish,
      support: boolean,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "submitVoteBySignature(uint256,bool,uint8,bytes32,bytes32)"(
      proposalId: BigNumberish,
      support: boolean,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    cancel(
      proposalId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "cancel(uint256)"(
      proposalId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    create(
      executor: string,
      targets: string[],
      values: BigNumberish[],
      signatures: string[],
      calldatas: BytesLike[],
      withDelegatecalls: boolean[],
      ipfsHash: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "create(address,address[],uint256[],string[],bytes[],bool[],bytes32)"(
      executor: string,
      targets: string[],
      values: BigNumberish[],
      signatures: string[],
      calldatas: BytesLike[],
      withDelegatecalls: boolean[],
      ipfsHash: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    execute(
      proposalId: BigNumberish,
      overrides?: PayableOverrides
    ): Promise<PopulatedTransaction>;

    "execute(uint256)"(
      proposalId: BigNumberish,
      overrides?: PayableOverrides
    ): Promise<PopulatedTransaction>;

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

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

    getProposalState(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getProposalState(uint256)"(
      proposalId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    queue(
      proposalId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "queue(uint256)"(
      proposalId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    submitVote(
      proposalId: BigNumberish,
      support: boolean,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "submitVote(uint256,bool)"(
      proposalId: BigNumberish,
      support: boolean,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    submitVoteBySignature(
      proposalId: BigNumberish,
      support: boolean,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "submitVoteBySignature(uint256,bool,uint8,bytes32,bytes32)"(
      proposalId: BigNumberish,
      support: boolean,
      v: BigNumberish,
      r: BytesLike,
      s: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;
  };
}