@astonic-io/astonic-bindings-ts/dist/Airgrab.d.ts

Astonic type generation and npm package deployment repo

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, PromiseOrValue } from "./common";
export interface AirgrabInterface extends utils.Interface {
    functions: {
        "MAX_CLIFF_PERIOD()": FunctionFragment;
        "MAX_SLOPE_PERIOD()": FunctionFragment;
        "airdropVerifier()": FunctionFragment;
        "astonicTreasury()": FunctionFragment;
        "claim(address)": FunctionFragment;
        "claimCosmos(bytes32,uint256[2],uint256[2],address,string)": FunctionFragment;
        "cliffPeriod()": FunctionFragment;
        "drain(address)": FunctionFragment;
        "endTimestamp()": FunctionFragment;
        "locking()": FunctionFragment;
        "setAirdropVerifier(address)": FunctionFragment;
        "slopePeriod()": FunctionFragment;
        "token()": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "MAX_CLIFF_PERIOD" | "MAX_SLOPE_PERIOD" | "airdropVerifier" | "astonicTreasury" | "claim" | "claimCosmos" | "cliffPeriod" | "drain" | "endTimestamp" | "locking" | "setAirdropVerifier" | "slopePeriod" | "token"): FunctionFragment;
    encodeFunctionData(functionFragment: "MAX_CLIFF_PERIOD", values?: undefined): string;
    encodeFunctionData(functionFragment: "MAX_SLOPE_PERIOD", values?: undefined): string;
    encodeFunctionData(functionFragment: "airdropVerifier", values?: undefined): string;
    encodeFunctionData(functionFragment: "astonicTreasury", values?: undefined): string;
    encodeFunctionData(functionFragment: "claim", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "claimCosmos", values: [
        PromiseOrValue<BytesLike>,
        [
            PromiseOrValue<BigNumberish>,
            PromiseOrValue<BigNumberish>
        ],
        [
            PromiseOrValue<BigNumberish>,
            PromiseOrValue<BigNumberish>
        ],
        PromiseOrValue<string>,
        PromiseOrValue<string>
    ]): string;
    encodeFunctionData(functionFragment: "cliffPeriod", values?: undefined): string;
    encodeFunctionData(functionFragment: "drain", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "endTimestamp", values?: undefined): string;
    encodeFunctionData(functionFragment: "locking", values?: undefined): string;
    encodeFunctionData(functionFragment: "setAirdropVerifier", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "slopePeriod", values?: undefined): string;
    encodeFunctionData(functionFragment: "token", values?: undefined): string;
    decodeFunctionResult(functionFragment: "MAX_CLIFF_PERIOD", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MAX_SLOPE_PERIOD", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "airdropVerifier", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "astonicTreasury", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "claimCosmos", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "cliffPeriod", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "drain", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "endTimestamp", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "locking", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setAirdropVerifier", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "slopePeriod", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
    events: {
        "TokensClaimed(address,uint256,uint256)": EventFragment;
        "TokensDrained(address,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "TokensClaimed"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "TokensDrained"): EventFragment;
}
export interface TokensClaimedEventObject {
    claimer: string;
    amount: BigNumber;
    lockId: BigNumber;
}
export type TokensClaimedEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber
], TokensClaimedEventObject>;
export type TokensClaimedEventFilter = TypedEventFilter<TokensClaimedEvent>;
export interface TokensDrainedEventObject {
    token: string;
    amount: BigNumber;
}
export type TokensDrainedEvent = TypedEvent<[
    string,
    BigNumber
], TokensDrainedEventObject>;
export type TokensDrainedEventFilter = TypedEventFilter<TokensDrainedEvent>;
export interface Airgrab extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: AirgrabInterface;
    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: {
        MAX_CLIFF_PERIOD(overrides?: CallOverrides): Promise<[number]>;
        MAX_SLOPE_PERIOD(overrides?: CallOverrides): Promise<[number]>;
        airdropVerifier(overrides?: CallOverrides): Promise<[string]>;
        astonicTreasury(overrides?: CallOverrides): Promise<[string]>;
        claim(delegate: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        claimCosmos(message: PromiseOrValue<BytesLike>, signature: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>], pubkey: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>], destinationAddress: PromiseOrValue<string>, bech32Address: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        cliffPeriod(overrides?: CallOverrides): Promise<[number]>;
        drain(tokenToDrain: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        endTimestamp(overrides?: CallOverrides): Promise<[BigNumber]>;
        locking(overrides?: CallOverrides): Promise<[string]>;
        setAirdropVerifier(_airdropVerifier: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        slopePeriod(overrides?: CallOverrides): Promise<[number]>;
        token(overrides?: CallOverrides): Promise<[string]>;
    };
    MAX_CLIFF_PERIOD(overrides?: CallOverrides): Promise<number>;
    MAX_SLOPE_PERIOD(overrides?: CallOverrides): Promise<number>;
    airdropVerifier(overrides?: CallOverrides): Promise<string>;
    astonicTreasury(overrides?: CallOverrides): Promise<string>;
    claim(delegate: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    claimCosmos(message: PromiseOrValue<BytesLike>, signature: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>], pubkey: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>], destinationAddress: PromiseOrValue<string>, bech32Address: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    cliffPeriod(overrides?: CallOverrides): Promise<number>;
    drain(tokenToDrain: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    endTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
    locking(overrides?: CallOverrides): Promise<string>;
    setAirdropVerifier(_airdropVerifier: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    slopePeriod(overrides?: CallOverrides): Promise<number>;
    token(overrides?: CallOverrides): Promise<string>;
    callStatic: {
        MAX_CLIFF_PERIOD(overrides?: CallOverrides): Promise<number>;
        MAX_SLOPE_PERIOD(overrides?: CallOverrides): Promise<number>;
        airdropVerifier(overrides?: CallOverrides): Promise<string>;
        astonicTreasury(overrides?: CallOverrides): Promise<string>;
        claim(delegate: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        claimCosmos(message: PromiseOrValue<BytesLike>, signature: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>], pubkey: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>], destinationAddress: PromiseOrValue<string>, bech32Address: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        cliffPeriod(overrides?: CallOverrides): Promise<number>;
        drain(tokenToDrain: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        endTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
        locking(overrides?: CallOverrides): Promise<string>;
        setAirdropVerifier(_airdropVerifier: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        slopePeriod(overrides?: CallOverrides): Promise<number>;
        token(overrides?: CallOverrides): Promise<string>;
    };
    filters: {
        "TokensClaimed(address,uint256,uint256)"(claimer?: PromiseOrValue<string> | null, amount?: null, lockId?: null): TokensClaimedEventFilter;
        TokensClaimed(claimer?: PromiseOrValue<string> | null, amount?: null, lockId?: null): TokensClaimedEventFilter;
        "TokensDrained(address,uint256)"(token?: PromiseOrValue<string> | null, amount?: null): TokensDrainedEventFilter;
        TokensDrained(token?: PromiseOrValue<string> | null, amount?: null): TokensDrainedEventFilter;
    };
    estimateGas: {
        MAX_CLIFF_PERIOD(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_SLOPE_PERIOD(overrides?: CallOverrides): Promise<BigNumber>;
        airdropVerifier(overrides?: CallOverrides): Promise<BigNumber>;
        astonicTreasury(overrides?: CallOverrides): Promise<BigNumber>;
        claim(delegate: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        claimCosmos(message: PromiseOrValue<BytesLike>, signature: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>], pubkey: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>], destinationAddress: PromiseOrValue<string>, bech32Address: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        cliffPeriod(overrides?: CallOverrides): Promise<BigNumber>;
        drain(tokenToDrain: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        endTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
        locking(overrides?: CallOverrides): Promise<BigNumber>;
        setAirdropVerifier(_airdropVerifier: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        slopePeriod(overrides?: CallOverrides): Promise<BigNumber>;
        token(overrides?: CallOverrides): Promise<BigNumber>;
    };
    populateTransaction: {
        MAX_CLIFF_PERIOD(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MAX_SLOPE_PERIOD(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        airdropVerifier(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        astonicTreasury(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        claim(delegate: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        claimCosmos(message: PromiseOrValue<BytesLike>, signature: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>], pubkey: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>], destinationAddress: PromiseOrValue<string>, bech32Address: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        cliffPeriod(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        drain(tokenToDrain: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        endTimestamp(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        locking(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        setAirdropVerifier(_airdropVerifier: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        slopePeriod(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        token(overrides?: CallOverrides): Promise<PopulatedTransaction>;
    };
}