@raac/rpc 1.0.0 → 1.0.1

package/dist/types/typechain-types/contracts/mocks/tests/VotingPowerFuzzHelper.sol/IVMTimeControl.d.ts

@@ -0,0 +1,25 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
+export interface IVMTimeControlInterface extends Interface {
+    getFunction(nameOrSignature: "warp"): FunctionFragment;
+    encodeFunctionData(functionFragment: "warp", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "warp", data: BytesLike): Result;
+}
+export interface IVMTimeControl extends BaseContract {
+    connect(runner?: ContractRunner | null): IVMTimeControl;
+    waitForDeployment(): Promise<this>;
+    interface: IVMTimeControlInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    warp: TypedContractMethod<[arg0: BigNumberish], [void], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "warp"): TypedContractMethod<[arg0: BigNumberish], [void], "nonpayable">;
+    filters: {};
+}

package/dist/types/typechain-types/contracts/mocks/tests/VotingPowerFuzzHelper.sol/VotingPowerFuzzHelper.d.ts

@@ -0,0 +1,100 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../common";
+export interface VotingPowerFuzzHelperInterface extends Interface {
+    getFunction(nameOrSignature: "generatePowerScenario" | "simulatePowerDecay" | "votingPower"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "ScenarioGenerated"): EventFragment;
+    encodeFunctionData(functionFragment: "generatePowerScenario", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "simulatePowerDecay", values: [AddressLike, BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "votingPower", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "generatePowerScenario", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "simulatePowerDecay", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "votingPower", data: BytesLike): Result;
+}
+export declare namespace ScenarioGeneratedEvent {
+    type InputTuple = [
+        user: AddressLike,
+        amount: BigNumberish,
+        duration: BigNumberish,
+        timestamp: BigNumberish
+    ];
+    type OutputTuple = [
+        user: string,
+        amount: bigint,
+        duration: bigint,
+        timestamp: bigint
+    ];
+    interface OutputObject {
+        user: string;
+        amount: bigint;
+        duration: bigint;
+        timestamp: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface VotingPowerFuzzHelper extends BaseContract {
+    connect(runner?: ContractRunner | null): VotingPowerFuzzHelper;
+    waitForDeployment(): Promise<this>;
+    interface: VotingPowerFuzzHelperInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    generatePowerScenario: TypedContractMethod<[
+        seed: BigNumberish
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            amount: bigint;
+            duration: bigint;
+            unlockTime: bigint;
+        }
+    ], "view">;
+    simulatePowerDecay: TypedContractMethod<[
+        user: AddressLike,
+        amount: BigNumberish,
+        duration: BigNumberish,
+        steps: BigNumberish
+    ], [
+        bigint[]
+    ], "nonpayable">;
+    votingPower: TypedContractMethod<[], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "generatePowerScenario"): TypedContractMethod<[
+        seed: BigNumberish
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            amount: bigint;
+            duration: bigint;
+            unlockTime: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "simulatePowerDecay"): TypedContractMethod<[
+        user: AddressLike,
+        amount: BigNumberish,
+        duration: BigNumberish,
+        steps: BigNumberish
+    ], [
+        bigint[]
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "votingPower"): TypedContractMethod<[], [string], "view">;
+    getEvent(key: "ScenarioGenerated"): TypedContractEvent<ScenarioGeneratedEvent.InputTuple, ScenarioGeneratedEvent.OutputTuple, ScenarioGeneratedEvent.OutputObject>;
+    filters: {
+        "ScenarioGenerated(address,uint256,uint256,uint256)": TypedContractEvent<ScenarioGeneratedEvent.InputTuple, ScenarioGeneratedEvent.OutputTuple, ScenarioGeneratedEvent.OutputObject>;
+        ScenarioGenerated: TypedContractEvent<ScenarioGeneratedEvent.InputTuple, ScenarioGeneratedEvent.OutputTuple, ScenarioGeneratedEvent.OutputObject>;
+    };
+}

package/dist/types/typechain-types/contracts/mocks/tests/VotingPowerFuzzHelper.sol/index.d.ts

@@ -0,0 +1,2 @@
+export type { IVMTimeControl } from "./IVMTimeControl";
+export type { VotingPowerFuzzHelper } from "./VotingPowerFuzzHelper";

package/dist/types/typechain-types/contracts/mocks/tests/index.d.ts

@@ -0,0 +1,5 @@
+import type * as votingPowerFuzzHelperSol from "./VotingPowerFuzzHelper.sol";
+export type { votingPowerFuzzHelperSol };
+export type { MaliciousDeposit } from "./MaliciousDeposit";
+export type { MaliciousWithdraw } from "./MaliciousWithdraw";
+export type { VeRAACFuzzHelper } from "./VeRAACFuzzHelper";

package/dist/types/typechain-types/contracts/zeno/Auction.d.ts

@@ -0,0 +1,215 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../common";
+export declare namespace IAuction {
+    type AuctionDetailsStruct = {
+        auctionAddress: AddressLike;
+        zenoAddress: AddressLike;
+        businessAddress: AddressLike;
+        auctionEndTime: BigNumberish;
+        startingPrice: BigNumberish;
+        reservePrice: BigNumberish;
+        auctionStartTime: BigNumberish;
+        totalZENOAllocated: BigNumberish;
+        totalZENORemaining: BigNumberish;
+        lastBidTime: BigNumberish;
+        lastBidder: AddressLike;
+        lastBidAmount: BigNumberish;
+        price: BigNumberish;
+    };
+    type AuctionDetailsStructOutput = [
+        auctionAddress: string,
+        zenoAddress: string,
+        businessAddress: string,
+        auctionEndTime: bigint,
+        startingPrice: bigint,
+        reservePrice: bigint,
+        auctionStartTime: bigint,
+        totalZENOAllocated: bigint,
+        totalZENORemaining: bigint,
+        lastBidTime: bigint,
+        lastBidder: string,
+        lastBidAmount: bigint,
+        price: bigint
+    ] & {
+        auctionAddress: string;
+        zenoAddress: string;
+        businessAddress: string;
+        auctionEndTime: bigint;
+        startingPrice: bigint;
+        reservePrice: bigint;
+        auctionStartTime: bigint;
+        totalZENOAllocated: bigint;
+        totalZENORemaining: bigint;
+        lastBidTime: bigint;
+        lastBidder: string;
+        lastBidAmount: bigint;
+        price: bigint;
+    };
+}
+export interface AuctionInterface extends Interface {
+    getFunction(nameOrSignature: "bidAmounts" | "businessAddress" | "buy" | "checkAuctionEnded" | "getDetails" | "getPrice" | "owner" | "renounceOwnership" | "state" | "transferOwnership" | "usdc" | "zeno"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "AuctionEnded" | "OwnershipTransferred" | "ZENOPurchased"): EventFragment;
+    encodeFunctionData(functionFragment: "bidAmounts", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "businessAddress", values?: undefined): string;
+    encodeFunctionData(functionFragment: "buy", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "checkAuctionEnded", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getDetails", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getPrice", values?: undefined): string;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "state", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "usdc", values?: undefined): string;
+    encodeFunctionData(functionFragment: "zeno", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "bidAmounts", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "businessAddress", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "buy", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "checkAuctionEnded", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getDetails", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getPrice", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "state", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "usdc", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "zeno", data: BytesLike): Result;
+}
+export declare namespace AuctionEndedEvent {
+    type InputTuple = [price: BigNumberish];
+    type OutputTuple = [price: bigint];
+    interface OutputObject {
+        price: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace OwnershipTransferredEvent {
+    type InputTuple = [previousOwner: AddressLike, newOwner: AddressLike];
+    type OutputTuple = [previousOwner: string, newOwner: string];
+    interface OutputObject {
+        previousOwner: string;
+        newOwner: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace ZENOPurchasedEvent {
+    type InputTuple = [
+        buyer: AddressLike,
+        amount: BigNumberish,
+        price: BigNumberish
+    ];
+    type OutputTuple = [buyer: string, amount: bigint, price: bigint];
+    interface OutputObject {
+        buyer: string;
+        amount: bigint;
+        price: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface Auction extends BaseContract {
+    connect(runner?: ContractRunner | null): Auction;
+    waitForDeployment(): Promise<this>;
+    interface: AuctionInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    bidAmounts: TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
+    businessAddress: TypedContractMethod<[], [string], "view">;
+    buy: TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    checkAuctionEnded: TypedContractMethod<[], [void], "nonpayable">;
+    getDetails: TypedContractMethod<[
+    ], [
+        IAuction.AuctionDetailsStructOutput
+    ], "view">;
+    getPrice: TypedContractMethod<[], [bigint], "view">;
+    owner: TypedContractMethod<[], [string], "view">;
+    renounceOwnership: TypedContractMethod<[], [void], "nonpayable">;
+    state: TypedContractMethod<[
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            string
+        ] & {
+            endTime: bigint;
+            startTime: bigint;
+            startingPrice: bigint;
+            reservePrice: bigint;
+            totalAllocated: bigint;
+            totalRemaining: bigint;
+            lastBidTime: bigint;
+            lastBidder: string;
+        }
+    ], "view">;
+    transferOwnership: TypedContractMethod<[
+        newOwner: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    usdc: TypedContractMethod<[], [string], "view">;
+    zeno: TypedContractMethod<[], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "bidAmounts"): TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "businessAddress"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "buy"): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "checkAuctionEnded"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "getDetails"): TypedContractMethod<[], [IAuction.AuctionDetailsStructOutput], "view">;
+    getFunction(nameOrSignature: "getPrice"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "owner"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "renounceOwnership"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "state"): TypedContractMethod<[
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            string
+        ] & {
+            endTime: bigint;
+            startTime: bigint;
+            startingPrice: bigint;
+            reservePrice: bigint;
+            totalAllocated: bigint;
+            totalRemaining: bigint;
+            lastBidTime: bigint;
+            lastBidder: string;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "transferOwnership"): TypedContractMethod<[newOwner: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "usdc"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "zeno"): TypedContractMethod<[], [string], "view">;
+    getEvent(key: "AuctionEnded"): TypedContractEvent<AuctionEndedEvent.InputTuple, AuctionEndedEvent.OutputTuple, AuctionEndedEvent.OutputObject>;
+    getEvent(key: "OwnershipTransferred"): TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+    getEvent(key: "ZENOPurchased"): TypedContractEvent<ZENOPurchasedEvent.InputTuple, ZENOPurchasedEvent.OutputTuple, ZENOPurchasedEvent.OutputObject>;
+    filters: {
+        "AuctionEnded(uint256)": TypedContractEvent<AuctionEndedEvent.InputTuple, AuctionEndedEvent.OutputTuple, AuctionEndedEvent.OutputObject>;
+        AuctionEnded: TypedContractEvent<AuctionEndedEvent.InputTuple, AuctionEndedEvent.OutputTuple, AuctionEndedEvent.OutputObject>;
+        "OwnershipTransferred(address,address)": TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+        OwnershipTransferred: TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+        "ZENOPurchased(address,uint256,uint256)": TypedContractEvent<ZENOPurchasedEvent.InputTuple, ZENOPurchasedEvent.OutputTuple, ZENOPurchasedEvent.OutputObject>;
+        ZENOPurchased: TypedContractEvent<ZENOPurchasedEvent.InputTuple, ZENOPurchasedEvent.OutputTuple, ZENOPurchasedEvent.OutputObject>;
+    };
+}

package/dist/types/typechain-types/contracts/zeno/AuctionFactory.d.ts

@@ -0,0 +1,177 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../common";
+export declare namespace IAuction {
+    type AuctionDetailsStruct = {
+        auctionAddress: AddressLike;
+        zenoAddress: AddressLike;
+        businessAddress: AddressLike;
+        auctionEndTime: BigNumberish;
+        startingPrice: BigNumberish;
+        reservePrice: BigNumberish;
+        auctionStartTime: BigNumberish;
+        totalZENOAllocated: BigNumberish;
+        totalZENORemaining: BigNumberish;
+        lastBidTime: BigNumberish;
+        lastBidder: AddressLike;
+        lastBidAmount: BigNumberish;
+        price: BigNumberish;
+    };
+    type AuctionDetailsStructOutput = [
+        auctionAddress: string,
+        zenoAddress: string,
+        businessAddress: string,
+        auctionEndTime: bigint,
+        startingPrice: bigint,
+        reservePrice: bigint,
+        auctionStartTime: bigint,
+        totalZENOAllocated: bigint,
+        totalZENORemaining: bigint,
+        lastBidTime: bigint,
+        lastBidder: string,
+        lastBidAmount: bigint,
+        price: bigint
+    ] & {
+        auctionAddress: string;
+        zenoAddress: string;
+        businessAddress: string;
+        auctionEndTime: bigint;
+        startingPrice: bigint;
+        reservePrice: bigint;
+        auctionStartTime: bigint;
+        totalZENOAllocated: bigint;
+        totalZENORemaining: bigint;
+        lastBidTime: bigint;
+        lastBidder: string;
+        lastBidAmount: bigint;
+        price: bigint;
+    };
+}
+export interface AuctionFactoryInterface extends Interface {
+    getFunction(nameOrSignature: "auctions" | "createAuction" | "getAuction" | "getAuctionCount" | "getAuctionDetails" | "getAuctions" | "owner" | "renounceOwnership" | "transferOwnership"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "AuctionCreated" | "OwnershipTransferred"): EventFragment;
+    encodeFunctionData(functionFragment: "auctions", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "createAuction", values: [
+        AddressLike,
+        AddressLike,
+        AddressLike,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "getAuction", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getAuctionCount", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getAuctionDetails", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getAuctions", values?: undefined): string;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [AddressLike]): string;
+    decodeFunctionResult(functionFragment: "auctions", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "createAuction", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getAuction", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getAuctionCount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getAuctionDetails", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getAuctions", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
+}
+export declare namespace AuctionCreatedEvent {
+    type InputTuple = [auctionAddress: AddressLike];
+    type OutputTuple = [auctionAddress: string];
+    interface OutputObject {
+        auctionAddress: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace OwnershipTransferredEvent {
+    type InputTuple = [previousOwner: AddressLike, newOwner: AddressLike];
+    type OutputTuple = [previousOwner: string, newOwner: string];
+    interface OutputObject {
+        previousOwner: string;
+        newOwner: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface AuctionFactory extends BaseContract {
+    connect(runner?: ContractRunner | null): AuctionFactory;
+    waitForDeployment(): Promise<this>;
+    interface: AuctionFactoryInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    auctions: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    createAuction: TypedContractMethod<[
+        _zenoAddress: AddressLike,
+        _usdcAddress: AddressLike,
+        _businessAddress: AddressLike,
+        _auctionStartTime: BigNumberish,
+        _auctionEndTime: BigNumberish,
+        _startingPrice: BigNumberish,
+        _reservePrice: BigNumberish,
+        _totalZENOAllocated: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getAuction: TypedContractMethod<[index: BigNumberish], [string], "view">;
+    getAuctionCount: TypedContractMethod<[], [bigint], "view">;
+    getAuctionDetails: TypedContractMethod<[
+        index: BigNumberish
+    ], [
+        IAuction.AuctionDetailsStructOutput
+    ], "view">;
+    getAuctions: TypedContractMethod<[], [string[]], "view">;
+    owner: TypedContractMethod<[], [string], "view">;
+    renounceOwnership: TypedContractMethod<[], [void], "nonpayable">;
+    transferOwnership: TypedContractMethod<[
+        newOwner: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "auctions"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "createAuction"): TypedContractMethod<[
+        _zenoAddress: AddressLike,
+        _usdcAddress: AddressLike,
+        _businessAddress: AddressLike,
+        _auctionStartTime: BigNumberish,
+        _auctionEndTime: BigNumberish,
+        _startingPrice: BigNumberish,
+        _reservePrice: BigNumberish,
+        _totalZENOAllocated: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "getAuction"): TypedContractMethod<[index: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "getAuctionCount"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "getAuctionDetails"): TypedContractMethod<[
+        index: BigNumberish
+    ], [
+        IAuction.AuctionDetailsStructOutput
+    ], "view">;
+    getFunction(nameOrSignature: "getAuctions"): TypedContractMethod<[], [string[]], "view">;
+    getFunction(nameOrSignature: "owner"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "renounceOwnership"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "transferOwnership"): TypedContractMethod<[newOwner: AddressLike], [void], "nonpayable">;
+    getEvent(key: "AuctionCreated"): TypedContractEvent<AuctionCreatedEvent.InputTuple, AuctionCreatedEvent.OutputTuple, AuctionCreatedEvent.OutputObject>;
+    getEvent(key: "OwnershipTransferred"): TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+    filters: {
+        "AuctionCreated(address)": TypedContractEvent<AuctionCreatedEvent.InputTuple, AuctionCreatedEvent.OutputTuple, AuctionCreatedEvent.OutputObject>;
+        AuctionCreated: TypedContractEvent<AuctionCreatedEvent.InputTuple, AuctionCreatedEvent.OutputTuple, AuctionCreatedEvent.OutputObject>;
+        "OwnershipTransferred(address,address)": TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+        OwnershipTransferred: TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+    };
+}