gotake-contracts/dist/typechain/contracts/TokenPurchase.d.ts

TypeChain generated types and ABIs for GoTake contracts

import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, 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 interface TokenPurchaseInterface extends utils.Interface {
    functions: {
        "currentPrice()": FunctionFragment;
        "getPrice()": FunctionFragment;
        "minPurchaseAmount()": FunctionFragment;
        "owner()": FunctionFragment;
        "paymentReceiver()": FunctionFragment;
        "paymentToken()": FunctionFragment;
        "purchase(uint256)": FunctionFragment;
        "renounceOwnership()": FunctionFragment;
        "setMinPurchaseAmount(uint256)": FunctionFragment;
        "setPaymentReceiver(address)": FunctionFragment;
        "setPaymentToken(address)": FunctionFragment;
        "setPrice(uint256)": FunctionFragment;
        "setToken(address)": FunctionFragment;
        "token()": FunctionFragment;
        "transferOwnership(address)": FunctionFragment;
        "withdrawTokens(uint256)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "currentPrice" | "getPrice" | "minPurchaseAmount" | "owner" | "paymentReceiver" | "paymentToken" | "purchase" | "renounceOwnership" | "setMinPurchaseAmount" | "setPaymentReceiver" | "setPaymentToken" | "setPrice" | "setToken" | "token" | "transferOwnership" | "withdrawTokens"): FunctionFragment;
    encodeFunctionData(functionFragment: "currentPrice", values?: undefined): string;
    encodeFunctionData(functionFragment: "getPrice", values?: undefined): string;
    encodeFunctionData(functionFragment: "minPurchaseAmount", values?: undefined): string;
    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
    encodeFunctionData(functionFragment: "paymentReceiver", values?: undefined): string;
    encodeFunctionData(functionFragment: "paymentToken", values?: undefined): string;
    encodeFunctionData(functionFragment: "purchase", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
    encodeFunctionData(functionFragment: "setMinPurchaseAmount", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "setPaymentReceiver", values: [string]): string;
    encodeFunctionData(functionFragment: "setPaymentToken", values: [string]): string;
    encodeFunctionData(functionFragment: "setPrice", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "setToken", values: [string]): string;
    encodeFunctionData(functionFragment: "token", values?: undefined): string;
    encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
    encodeFunctionData(functionFragment: "withdrawTokens", values: [BigNumberish]): string;
    decodeFunctionResult(functionFragment: "currentPrice", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getPrice", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "minPurchaseAmount", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "paymentReceiver", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "paymentToken", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "purchase", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setMinPurchaseAmount", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setPaymentReceiver", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setPaymentToken", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setPrice", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setToken", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawTokens", data: BytesLike): Result;
    events: {
        "MinPurchaseAmountUpdated(uint256)": EventFragment;
        "OwnershipTransferred(address,address)": EventFragment;
        "PriceUpdated(uint256)": EventFragment;
        "TokensPurchased(address,uint256,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "MinPurchaseAmountUpdated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PriceUpdated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "TokensPurchased"): EventFragment;
}
export interface MinPurchaseAmountUpdatedEventObject {
    newMinAmount: BigNumber;
}
export type MinPurchaseAmountUpdatedEvent = TypedEvent<[
    BigNumber
], MinPurchaseAmountUpdatedEventObject>;
export type MinPurchaseAmountUpdatedEventFilter = TypedEventFilter<MinPurchaseAmountUpdatedEvent>;
export interface OwnershipTransferredEventObject {
    previousOwner: string;
    newOwner: string;
}
export type OwnershipTransferredEvent = TypedEvent<[
    string,
    string
], OwnershipTransferredEventObject>;
export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
export interface PriceUpdatedEventObject {
    newPrice: BigNumber;
}
export type PriceUpdatedEvent = TypedEvent<[
    BigNumber
], PriceUpdatedEventObject>;
export type PriceUpdatedEventFilter = TypedEventFilter<PriceUpdatedEvent>;
export interface TokensPurchasedEventObject {
    buyer: string;
    amount: BigNumber;
    totalCost: BigNumber;
}
export type TokensPurchasedEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber
], TokensPurchasedEventObject>;
export type TokensPurchasedEventFilter = TypedEventFilter<TokensPurchasedEvent>;
export interface TokenPurchase extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: TokenPurchaseInterface;
    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: {
        currentPrice(overrides?: CallOverrides): Promise<[BigNumber]>;
        getPrice(overrides?: CallOverrides): Promise<[BigNumber]>;
        minPurchaseAmount(overrides?: CallOverrides): Promise<[BigNumber]>;
        owner(overrides?: CallOverrides): Promise<[string]>;
        paymentReceiver(overrides?: CallOverrides): Promise<[string]>;
        paymentToken(overrides?: CallOverrides): Promise<[string]>;
        purchase(_amount: BigNumberish, overrides?: PayableOverrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setMinPurchaseAmount(_minAmount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setPaymentReceiver(_paymentReceiver: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setPaymentToken(_paymentToken: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setPrice(_price: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setToken(_token: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        token(overrides?: CallOverrides): Promise<[string]>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        withdrawTokens(_amount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
    };
    currentPrice(overrides?: CallOverrides): Promise<BigNumber>;
    getPrice(overrides?: CallOverrides): Promise<BigNumber>;
    minPurchaseAmount(overrides?: CallOverrides): Promise<BigNumber>;
    owner(overrides?: CallOverrides): Promise<string>;
    paymentReceiver(overrides?: CallOverrides): Promise<string>;
    paymentToken(overrides?: CallOverrides): Promise<string>;
    purchase(_amount: BigNumberish, overrides?: PayableOverrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    renounceOwnership(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setMinPurchaseAmount(_minAmount: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setPaymentReceiver(_paymentReceiver: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setPaymentToken(_paymentToken: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setPrice(_price: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setToken(_token: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    token(overrides?: CallOverrides): Promise<string>;
    transferOwnership(newOwner: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    withdrawTokens(_amount: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    callStatic: {
        currentPrice(overrides?: CallOverrides): Promise<BigNumber>;
        getPrice(overrides?: CallOverrides): Promise<BigNumber>;
        minPurchaseAmount(overrides?: CallOverrides): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<string>;
        paymentReceiver(overrides?: CallOverrides): Promise<string>;
        paymentToken(overrides?: CallOverrides): Promise<string>;
        purchase(_amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
        renounceOwnership(overrides?: CallOverrides): Promise<void>;
        setMinPurchaseAmount(_minAmount: BigNumberish, overrides?: CallOverrides): Promise<void>;
        setPaymentReceiver(_paymentReceiver: string, overrides?: CallOverrides): Promise<void>;
        setPaymentToken(_paymentToken: string, overrides?: CallOverrides): Promise<void>;
        setPrice(_price: BigNumberish, overrides?: CallOverrides): Promise<void>;
        setToken(_token: string, overrides?: CallOverrides): Promise<void>;
        token(overrides?: CallOverrides): Promise<string>;
        transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
        withdrawTokens(_amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
    };
    filters: {
        "MinPurchaseAmountUpdated(uint256)"(newMinAmount?: null): MinPurchaseAmountUpdatedEventFilter;
        MinPurchaseAmountUpdated(newMinAmount?: null): MinPurchaseAmountUpdatedEventFilter;
        "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        "PriceUpdated(uint256)"(newPrice?: null): PriceUpdatedEventFilter;
        PriceUpdated(newPrice?: null): PriceUpdatedEventFilter;
        "TokensPurchased(address,uint256,uint256)"(buyer?: string | null, amount?: null, totalCost?: null): TokensPurchasedEventFilter;
        TokensPurchased(buyer?: string | null, amount?: null, totalCost?: null): TokensPurchasedEventFilter;
    };
    estimateGas: {
        currentPrice(overrides?: CallOverrides): Promise<BigNumber>;
        getPrice(overrides?: CallOverrides): Promise<BigNumber>;
        minPurchaseAmount(overrides?: CallOverrides): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<BigNumber>;
        paymentReceiver(overrides?: CallOverrides): Promise<BigNumber>;
        paymentToken(overrides?: CallOverrides): Promise<BigNumber>;
        purchase(_amount: BigNumberish, overrides?: PayableOverrides & {
            from?: string;
        }): Promise<BigNumber>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setMinPurchaseAmount(_minAmount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setPaymentReceiver(_paymentReceiver: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setPaymentToken(_paymentToken: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setPrice(_price: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setToken(_token: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        token(overrides?: CallOverrides): Promise<BigNumber>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        withdrawTokens(_amount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        currentPrice(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getPrice(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        minPurchaseAmount(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        paymentReceiver(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        paymentToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        purchase(_amount: BigNumberish, overrides?: PayableOverrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setMinPurchaseAmount(_minAmount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setPaymentReceiver(_paymentReceiver: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setPaymentToken(_paymentToken: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setPrice(_price: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setToken(_token: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        token(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        withdrawTokens(_amount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
    };
}