@skalenetwork/fair-manager-types/ethers-v5/contracts/DKG.ts

TypeScript typings for SKALE Fair Manager smart contracts

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

export declare namespace IDkg {
  export type Fp2PointStruct = { a: BigNumberish; b: BigNumberish };

  export type Fp2PointStructOutput = [BigNumber, BigNumber] & {
    a: BigNumber;
    b: BigNumber;
  };

  export type G2PointStruct = {
    x: IDkg.Fp2PointStruct;
    y: IDkg.Fp2PointStruct;
  };

  export type G2PointStructOutput = [
    IDkg.Fp2PointStructOutput,
    IDkg.Fp2PointStructOutput
  ] & { x: IDkg.Fp2PointStructOutput; y: IDkg.Fp2PointStructOutput };

  export type KeyShareStruct = {
    publicKey: [BytesLike, BytesLike];
    share: BytesLike;
  };

  export type KeyShareStructOutput = [[string, string], string] & {
    publicKey: [string, string];
    share: string;
  };

  export type RoundStruct = {
    id: BigNumberish;
    status: BigNumberish;
    nodes: BigNumberish[];
    publicKey: IDkg.G2PointStruct;
    startingBlockNumber: BigNumberish;
    numberOfBroadcasted: BigNumberish;
    hashedData: BytesLike[];
    numberOfCompleted: BigNumberish;
    completed: boolean[];
  };

  export type RoundStructOutput = [
    BigNumber,
    number,
    BigNumber[],
    IDkg.G2PointStructOutput,
    BigNumber,
    BigNumber,
    string[],
    BigNumber,
    boolean[]
  ] & {
    id: BigNumber;
    status: number;
    nodes: BigNumber[];
    publicKey: IDkg.G2PointStructOutput;
    startingBlockNumber: BigNumber;
    numberOfBroadcasted: BigNumber;
    hashedData: string[];
    numberOfCompleted: BigNumber;
    completed: boolean[];
  };
}

export interface DKGInterface extends utils.Interface {
  functions: {
    "alright(uint256)": FunctionFragment;
    "authority()": FunctionFragment;
    "broadcast(uint256,((uint256,uint256),(uint256,uint256))[],(bytes32[2],bytes32)[])": FunctionFragment;
    "committee()": FunctionFragment;
    "generate(uint256[])": FunctionFragment;
    "getParticipants(uint256)": FunctionFragment;
    "getPublicKey(uint256)": FunctionFragment;
    "getRound(uint256)": FunctionFragment;
    "initialize(address,address,address)": FunctionFragment;
    "isConsumingScheduledOp()": FunctionFragment;
    "isNodeBroadcasted(uint256,uint256)": FunctionFragment;
    "lastDkgId()": FunctionFragment;
    "nodes()": FunctionFragment;
    "setAuthority(address)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "alright"
      | "authority"
      | "broadcast"
      | "committee"
      | "generate"
      | "getParticipants"
      | "getPublicKey"
      | "getRound"
      | "initialize"
      | "isConsumingScheduledOp"
      | "isNodeBroadcasted"
      | "lastDkgId"
      | "nodes"
      | "setAuthority"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "alright",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "authority", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "broadcast",
    values: [BigNumberish, IDkg.G2PointStruct[], IDkg.KeyShareStruct[]]
  ): string;
  encodeFunctionData(functionFragment: "committee", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "generate",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(
    functionFragment: "getParticipants",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getPublicKey",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getRound",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [string, string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "isConsumingScheduledOp",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isNodeBroadcasted",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "lastDkgId", values?: undefined): string;
  encodeFunctionData(functionFragment: "nodes", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "setAuthority",
    values: [string]
  ): string;

  decodeFunctionResult(functionFragment: "alright", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "authority", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "broadcast", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "committee", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "generate", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getParticipants",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPublicKey",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getRound", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isConsumingScheduledOp",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isNodeBroadcasted",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "lastDkgId", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "nodes", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setAuthority",
    data: BytesLike
  ): Result;

  events: {
    "AllDataReceived(uint256,uint256)": EventFragment;
    "AuthorityUpdated(address)": EventFragment;
    "BroadcastAndKeyShare(uint256,uint256,((uint256,uint256),(uint256,uint256))[],(bytes32[2],bytes32)[])": EventFragment;
    "DkgRoundCreated(uint256,uint256[],uint256)": EventFragment;
    "Initialized(uint64)": EventFragment;
    "SuccessfulDkg(uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "AllDataReceived"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "AuthorityUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "BroadcastAndKeyShare"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DkgRoundCreated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SuccessfulDkg"): EventFragment;
}

export interface AllDataReceivedEventObject {
  dkg: BigNumber;
  node: BigNumber;
}
export type AllDataReceivedEvent = TypedEvent<
  [BigNumber, BigNumber],
  AllDataReceivedEventObject
>;

export type AllDataReceivedEventFilter = TypedEventFilter<AllDataReceivedEvent>;

export interface AuthorityUpdatedEventObject {
  authority: string;
}
export type AuthorityUpdatedEvent = TypedEvent<
  [string],
  AuthorityUpdatedEventObject
>;

export type AuthorityUpdatedEventFilter =
  TypedEventFilter<AuthorityUpdatedEvent>;

export interface BroadcastAndKeyShareEventObject {
  dkg: BigNumber;
  node: BigNumber;
  verificationVector: IDkg.G2PointStructOutput[];
  secretKeyContribution: IDkg.KeyShareStructOutput[];
}
export type BroadcastAndKeyShareEvent = TypedEvent<
  [
    BigNumber,
    BigNumber,
    IDkg.G2PointStructOutput[],
    IDkg.KeyShareStructOutput[]
  ],
  BroadcastAndKeyShareEventObject
>;

export type BroadcastAndKeyShareEventFilter =
  TypedEventFilter<BroadcastAndKeyShareEvent>;

export interface DkgRoundCreatedEventObject {
  dkgId: BigNumber;
  participants: BigNumber[];
  startingBlockNumber: BigNumber;
}
export type DkgRoundCreatedEvent = TypedEvent<
  [BigNumber, BigNumber[], BigNumber],
  DkgRoundCreatedEventObject
>;

export type DkgRoundCreatedEventFilter = TypedEventFilter<DkgRoundCreatedEvent>;

export interface InitializedEventObject {
  version: BigNumber;
}
export type InitializedEvent = TypedEvent<[BigNumber], InitializedEventObject>;

export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;

export interface SuccessfulDkgEventObject {
  dkg: BigNumber;
}
export type SuccessfulDkgEvent = TypedEvent<
  [BigNumber],
  SuccessfulDkgEventObject
>;

export type SuccessfulDkgEventFilter = TypedEventFilter<SuccessfulDkgEvent>;

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

  interface: DKGInterface;

  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: {
    alright(
      dkg: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    broadcast(
      dkg: BigNumberish,
      verificationVector: IDkg.G2PointStruct[],
      secretKeyContribution: IDkg.KeyShareStruct[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    generate(
      participants: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    getParticipants(
      dkg: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber[]] & { participants: BigNumber[] }>;

    getPublicKey(
      dkg: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [IDkg.G2PointStructOutput] & { publicKey: IDkg.G2PointStructOutput }
    >;

    getRound(
      dkg: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[IDkg.RoundStructOutput] & { round: IDkg.RoundStructOutput }>;

    initialize(
      initialAuthority: string,
      committeeAddress: string,
      nodesAddress: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    isNodeBroadcasted(
      dkg: BigNumberish,
      node: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean] & { broadcasted: boolean }>;

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

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

    setAuthority(
      newAuthority: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;
  };

  alright(
    dkg: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  broadcast(
    dkg: BigNumberish,
    verificationVector: IDkg.G2PointStruct[],
    secretKeyContribution: IDkg.KeyShareStruct[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  generate(
    participants: BigNumberish[],
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  getParticipants(
    dkg: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber[]>;

  getPublicKey(
    dkg: BigNumberish,
    overrides?: CallOverrides
  ): Promise<IDkg.G2PointStructOutput>;

  getRound(
    dkg: BigNumberish,
    overrides?: CallOverrides
  ): Promise<IDkg.RoundStructOutput>;

  initialize(
    initialAuthority: string,
    committeeAddress: string,
    nodesAddress: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  isNodeBroadcasted(
    dkg: BigNumberish,
    node: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

  setAuthority(
    newAuthority: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  callStatic: {
    alright(dkg: BigNumberish, overrides?: CallOverrides): Promise<void>;

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

    broadcast(
      dkg: BigNumberish,
      verificationVector: IDkg.G2PointStruct[],
      secretKeyContribution: IDkg.KeyShareStruct[],
      overrides?: CallOverrides
    ): Promise<void>;

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

    generate(
      participants: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getParticipants(
      dkg: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

    getPublicKey(
      dkg: BigNumberish,
      overrides?: CallOverrides
    ): Promise<IDkg.G2PointStructOutput>;

    getRound(
      dkg: BigNumberish,
      overrides?: CallOverrides
    ): Promise<IDkg.RoundStructOutput>;

    initialize(
      initialAuthority: string,
      committeeAddress: string,
      nodesAddress: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

    isNodeBroadcasted(
      dkg: BigNumberish,
      node: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

    setAuthority(
      newAuthority: string,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "AllDataReceived(uint256,uint256)"(
      dkg?: null,
      node?: BigNumberish | null
    ): AllDataReceivedEventFilter;
    AllDataReceived(
      dkg?: null,
      node?: BigNumberish | null
    ): AllDataReceivedEventFilter;

    "AuthorityUpdated(address)"(authority?: null): AuthorityUpdatedEventFilter;
    AuthorityUpdated(authority?: null): AuthorityUpdatedEventFilter;

    "BroadcastAndKeyShare(uint256,uint256,((uint256,uint256),(uint256,uint256))[],(bytes32[2],bytes32)[])"(
      dkg?: null,
      node?: BigNumberish | null,
      verificationVector?: null,
      secretKeyContribution?: null
    ): BroadcastAndKeyShareEventFilter;
    BroadcastAndKeyShare(
      dkg?: null,
      node?: BigNumberish | null,
      verificationVector?: null,
      secretKeyContribution?: null
    ): BroadcastAndKeyShareEventFilter;

    "DkgRoundCreated(uint256,uint256[],uint256)"(
      dkgId?: BigNumberish | null,
      participants?: null,
      startingBlockNumber?: null
    ): DkgRoundCreatedEventFilter;
    DkgRoundCreated(
      dkgId?: BigNumberish | null,
      participants?: null,
      startingBlockNumber?: null
    ): DkgRoundCreatedEventFilter;

    "Initialized(uint64)"(version?: null): InitializedEventFilter;
    Initialized(version?: null): InitializedEventFilter;

    "SuccessfulDkg(uint256)"(dkg?: null): SuccessfulDkgEventFilter;
    SuccessfulDkg(dkg?: null): SuccessfulDkgEventFilter;
  };

  estimateGas: {
    alright(
      dkg: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    broadcast(
      dkg: BigNumberish,
      verificationVector: IDkg.G2PointStruct[],
      secretKeyContribution: IDkg.KeyShareStruct[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    generate(
      participants: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    getParticipants(
      dkg: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getPublicKey(
      dkg: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getRound(dkg: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

    initialize(
      initialAuthority: string,
      committeeAddress: string,
      nodesAddress: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    isNodeBroadcasted(
      dkg: BigNumberish,
      node: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    setAuthority(
      newAuthority: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    alright(
      dkg: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    broadcast(
      dkg: BigNumberish,
      verificationVector: IDkg.G2PointStruct[],
      secretKeyContribution: IDkg.KeyShareStruct[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    generate(
      participants: BigNumberish[],
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    getParticipants(
      dkg: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getPublicKey(
      dkg: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getRound(
      dkg: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    initialize(
      initialAuthority: string,
      committeeAddress: string,
      nodesAddress: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    isNodeBroadcasted(
      dkg: BigNumberish,
      node: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    setAuthority(
      newAuthority: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;
  };
}