@q-dev/gdk-sdk/lib/ethers-contracts/IDAOVault.d.ts

Typescript Library to interact with GDK 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 declare namespace IDAOVault {
    type TomeLockInfoStruct = {
        withdrawalAmount: BigNumberish;
        lockedAmount: BigNumberish;
        unlockTime: BigNumberish;
    };
    type TomeLockInfoStructOutput = [BigNumber, BigNumber, BigNumber] & {
        withdrawalAmount: BigNumber;
        lockedAmount: BigNumber;
        unlockTime: BigNumber;
    };
    type ConstitutionDataInfoStruct = {
        isSigned: boolean;
        signedAt: BigNumberish;
    };
    type ConstitutionDataInfoStructOutput = [boolean, BigNumber] & {
        isSigned: boolean;
        signedAt: BigNumber;
    };
}
export interface IDAOVaultInterface extends utils.Interface {
    functions: {
        "authorizeBySBT(address)": FunctionFragment;
        "depositERC20(address,uint256)": FunctionFragment;
        "depositNFT(address,uint256)": FunctionFragment;
        "depositNative()": FunctionFragment;
        "getConstitutionSignHash(address)": FunctionFragment;
        "getTimeLockInfo(address,address)": FunctionFragment;
        "getTokenSupply(address)": FunctionFragment;
        "getUserConstitutionData(address)": FunctionFragment;
        "getUserNFTs(address,address)": FunctionFragment;
        "getUserTokens(address)": FunctionFragment;
        "getUserVotingPower(address,address)": FunctionFragment;
        "isAuthorizedBySBT(address,address)": FunctionFragment;
        "isSupportedNFT(address)": FunctionFragment;
        "isSupportedSBT(address)": FunctionFragment;
        "lock(address,address,uint256,uint256)": FunctionFragment;
        "lockAndGetUserVotingPower(address,address,uint256)": FunctionFragment;
        "revokeSBTAuthorization(address)": FunctionFragment;
        "signConstitution(address,bytes)": FunctionFragment;
        "withdrawERC20(address,uint256)": FunctionFragment;
        "withdrawNFT(address,uint256)": FunctionFragment;
        "withdrawNative(uint256)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "authorizeBySBT" | "depositERC20" | "depositNFT" | "depositNative" | "getConstitutionSignHash" | "getTimeLockInfo" | "getTokenSupply" | "getUserConstitutionData" | "getUserNFTs" | "getUserTokens" | "getUserVotingPower" | "isAuthorizedBySBT" | "isSupportedNFT" | "isSupportedSBT" | "lock" | "lockAndGetUserVotingPower" | "revokeSBTAuthorization" | "signConstitution" | "withdrawERC20" | "withdrawNFT" | "withdrawNative"): FunctionFragment;
    encodeFunctionData(functionFragment: "authorizeBySBT", values: [string]): string;
    encodeFunctionData(functionFragment: "depositERC20", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "depositNFT", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "depositNative", values?: undefined): string;
    encodeFunctionData(functionFragment: "getConstitutionSignHash", values: [string]): string;
    encodeFunctionData(functionFragment: "getTimeLockInfo", values: [string, string]): string;
    encodeFunctionData(functionFragment: "getTokenSupply", values: [string]): string;
    encodeFunctionData(functionFragment: "getUserConstitutionData", values: [string]): string;
    encodeFunctionData(functionFragment: "getUserNFTs", values: [string, string]): string;
    encodeFunctionData(functionFragment: "getUserTokens", values: [string]): string;
    encodeFunctionData(functionFragment: "getUserVotingPower", values: [string, string]): string;
    encodeFunctionData(functionFragment: "isAuthorizedBySBT", values: [string, string]): string;
    encodeFunctionData(functionFragment: "isSupportedNFT", values: [string]): string;
    encodeFunctionData(functionFragment: "isSupportedSBT", values: [string]): string;
    encodeFunctionData(functionFragment: "lock", values: [string, string, BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "lockAndGetUserVotingPower", values: [string, string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "revokeSBTAuthorization", values: [string]): string;
    encodeFunctionData(functionFragment: "signConstitution", values: [string, BytesLike]): string;
    encodeFunctionData(functionFragment: "withdrawERC20", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "withdrawNFT", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "withdrawNative", values: [BigNumberish]): string;
    decodeFunctionResult(functionFragment: "authorizeBySBT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "depositERC20", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "depositNFT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "depositNative", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getConstitutionSignHash", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getTimeLockInfo", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getTokenSupply", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getUserConstitutionData", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getUserNFTs", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getUserTokens", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getUserVotingPower", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isAuthorizedBySBT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isSupportedNFT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isSupportedSBT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lock", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lockAndGetUserVotingPower", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "revokeSBTAuthorization", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "signConstitution", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawERC20", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawNFT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawNative", data: BytesLike): Result;
    events: {
        "AuthenticatedBySBT(address,address)": EventFragment;
        "AuthorizedBySBT(address,address)": EventFragment;
        "ConstitutionSigned(address)": EventFragment;
        "NFTDeposited(address,address,uint256)": EventFragment;
        "NFTLocked(address,address,uint256,uint256)": EventFragment;
        "NFTWithdrew(address,address,uint256)": EventFragment;
        "SBTAuthorizationRevoked(address,address)": EventFragment;
        "TokensDeposited(address,address,uint256)": EventFragment;
        "TokensLocked(address,address,uint256,uint256)": EventFragment;
        "TokensWithdrew(address,address,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "AuthenticatedBySBT"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "AuthorizedBySBT"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ConstitutionSigned"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "NFTDeposited"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "NFTLocked"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "NFTWithdrew"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SBTAuthorizationRevoked"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "TokensDeposited"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "TokensLocked"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "TokensWithdrew"): EventFragment;
}
export interface AuthenticatedBySBTEventObject {
    tokenAddress: string;
    sender: string;
}
export type AuthenticatedBySBTEvent = TypedEvent<[
    string,
    string
], AuthenticatedBySBTEventObject>;
export type AuthenticatedBySBTEventFilter = TypedEventFilter<AuthenticatedBySBTEvent>;
export interface AuthorizedBySBTEventObject {
    tokenAddress: string;
    sender: string;
}
export type AuthorizedBySBTEvent = TypedEvent<[
    string,
    string
], AuthorizedBySBTEventObject>;
export type AuthorizedBySBTEventFilter = TypedEventFilter<AuthorizedBySBTEvent>;
export interface ConstitutionSignedEventObject {
    user: string;
}
export type ConstitutionSignedEvent = TypedEvent<[
    string
], ConstitutionSignedEventObject>;
export type ConstitutionSignedEventFilter = TypedEventFilter<ConstitutionSignedEvent>;
export interface NFTDepositedEventObject {
    tokenAddress: string;
    sender: string;
    tokenId: BigNumber;
}
export type NFTDepositedEvent = TypedEvent<[
    string,
    string,
    BigNumber
], NFTDepositedEventObject>;
export type NFTDepositedEventFilter = TypedEventFilter<NFTDepositedEvent>;
export interface NFTLockedEventObject {
    tokenAddress: string;
    sender: string;
    tokenId: BigNumber;
    unlockTime: BigNumber;
}
export type NFTLockedEvent = TypedEvent<[
    string,
    string,
    BigNumber,
    BigNumber
], NFTLockedEventObject>;
export type NFTLockedEventFilter = TypedEventFilter<NFTLockedEvent>;
export interface NFTWithdrewEventObject {
    tokenAddress: string;
    sender: string;
    tokenId: BigNumber;
}
export type NFTWithdrewEvent = TypedEvent<[
    string,
    string,
    BigNumber
], NFTWithdrewEventObject>;
export type NFTWithdrewEventFilter = TypedEventFilter<NFTWithdrewEvent>;
export interface SBTAuthorizationRevokedEventObject {
    tokenAddress: string;
    sender: string;
}
export type SBTAuthorizationRevokedEvent = TypedEvent<[
    string,
    string
], SBTAuthorizationRevokedEventObject>;
export type SBTAuthorizationRevokedEventFilter = TypedEventFilter<SBTAuthorizationRevokedEvent>;
export interface TokensDepositedEventObject {
    tokenAddress: string;
    sender: string;
    amount: BigNumber;
}
export type TokensDepositedEvent = TypedEvent<[
    string,
    string,
    BigNumber
], TokensDepositedEventObject>;
export type TokensDepositedEventFilter = TypedEventFilter<TokensDepositedEvent>;
export interface TokensLockedEventObject {
    tokenAddress: string;
    sender: string;
    amount: BigNumber;
    unlockTime: BigNumber;
}
export type TokensLockedEvent = TypedEvent<[
    string,
    string,
    BigNumber,
    BigNumber
], TokensLockedEventObject>;
export type TokensLockedEventFilter = TypedEventFilter<TokensLockedEvent>;
export interface TokensWithdrewEventObject {
    tokenAddress: string;
    sender: string;
    amount: BigNumber;
}
export type TokensWithdrewEvent = TypedEvent<[
    string,
    string,
    BigNumber
], TokensWithdrewEventObject>;
export type TokensWithdrewEventFilter = TypedEventFilter<TokensWithdrewEvent>;
export interface IDAOVault extends BaseContract {
    contractName: "IDAOVault";
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: IDAOVaultInterface;
    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: {
        authorizeBySBT(tokenAddress_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        depositERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        depositNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        depositNative(overrides?: PayableOverrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        getConstitutionSignHash(signer_: string, overrides?: CallOverrides): Promise<[string]>;
        getTimeLockInfo(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<[
            IDAOVault.TomeLockInfoStructOutput
        ] & {
            info_: IDAOVault.TomeLockInfoStructOutput;
        }>;
        getTokenSupply(tokenAddress_: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        getUserConstitutionData(userAddress_: string, overrides?: CallOverrides): Promise<[IDAOVault.ConstitutionDataInfoStructOutput]>;
        getUserNFTs(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<[BigNumber[]]>;
        getUserTokens(userAddress_: string, overrides?: CallOverrides): Promise<[string[]]>;
        getUserVotingPower(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        isAuthorizedBySBT(sender_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<[boolean]>;
        isSupportedNFT(tokenAddress_: string, overrides?: CallOverrides): Promise<[boolean]>;
        isSupportedSBT(tokenAddress_: string, overrides?: CallOverrides): Promise<[boolean]>;
        lock(sender_: string, tokenAddress_: string, amount_: BigNumberish, timeToLock_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        lockAndGetUserVotingPower(userAddress_: string, tokenAddress_: string, timeToLock_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        revokeSBTAuthorization(tokenAddress_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        signConstitution(signer_: string, signature_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        withdrawERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        withdrawNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        withdrawNative(amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
    };
    authorizeBySBT(tokenAddress_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    depositERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    depositNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    depositNative(overrides?: PayableOverrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    getConstitutionSignHash(signer_: string, overrides?: CallOverrides): Promise<string>;
    getTimeLockInfo(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<IDAOVault.TomeLockInfoStructOutput>;
    getTokenSupply(tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
    getUserConstitutionData(userAddress_: string, overrides?: CallOverrides): Promise<IDAOVault.ConstitutionDataInfoStructOutput>;
    getUserNFTs(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber[]>;
    getUserTokens(userAddress_: string, overrides?: CallOverrides): Promise<string[]>;
    getUserVotingPower(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
    isAuthorizedBySBT(sender_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<boolean>;
    isSupportedNFT(tokenAddress_: string, overrides?: CallOverrides): Promise<boolean>;
    isSupportedSBT(tokenAddress_: string, overrides?: CallOverrides): Promise<boolean>;
    lock(sender_: string, tokenAddress_: string, amount_: BigNumberish, timeToLock_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    lockAndGetUserVotingPower(userAddress_: string, tokenAddress_: string, timeToLock_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    revokeSBTAuthorization(tokenAddress_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    signConstitution(signer_: string, signature_: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    withdrawERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    withdrawNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    withdrawNative(amount_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    callStatic: {
        authorizeBySBT(tokenAddress_: string, overrides?: CallOverrides): Promise<void>;
        depositERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        depositNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        depositNative(overrides?: CallOverrides): Promise<void>;
        getConstitutionSignHash(signer_: string, overrides?: CallOverrides): Promise<string>;
        getTimeLockInfo(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<IDAOVault.TomeLockInfoStructOutput>;
        getTokenSupply(tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        getUserConstitutionData(userAddress_: string, overrides?: CallOverrides): Promise<IDAOVault.ConstitutionDataInfoStructOutput>;
        getUserNFTs(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber[]>;
        getUserTokens(userAddress_: string, overrides?: CallOverrides): Promise<string[]>;
        getUserVotingPower(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        isAuthorizedBySBT(sender_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<boolean>;
        isSupportedNFT(tokenAddress_: string, overrides?: CallOverrides): Promise<boolean>;
        isSupportedSBT(tokenAddress_: string, overrides?: CallOverrides): Promise<boolean>;
        lock(sender_: string, tokenAddress_: string, amount_: BigNumberish, timeToLock_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        lockAndGetUserVotingPower(userAddress_: string, tokenAddress_: string, timeToLock_: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        revokeSBTAuthorization(tokenAddress_: string, overrides?: CallOverrides): Promise<void>;
        signConstitution(signer_: string, signature_: BytesLike, overrides?: CallOverrides): Promise<void>;
        withdrawERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        withdrawNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        withdrawNative(amount_: BigNumberish, overrides?: CallOverrides): Promise<void>;
    };
    filters: {
        "AuthenticatedBySBT(address,address)"(tokenAddress?: string | null, sender?: string | null): AuthenticatedBySBTEventFilter;
        AuthenticatedBySBT(tokenAddress?: string | null, sender?: string | null): AuthenticatedBySBTEventFilter;
        "AuthorizedBySBT(address,address)"(tokenAddress?: string | null, sender?: string | null): AuthorizedBySBTEventFilter;
        AuthorizedBySBT(tokenAddress?: string | null, sender?: string | null): AuthorizedBySBTEventFilter;
        "ConstitutionSigned(address)"(user?: string | null): ConstitutionSignedEventFilter;
        ConstitutionSigned(user?: string | null): ConstitutionSignedEventFilter;
        "NFTDeposited(address,address,uint256)"(tokenAddress?: string | null, sender?: string | null, tokenId?: null): NFTDepositedEventFilter;
        NFTDeposited(tokenAddress?: string | null, sender?: string | null, tokenId?: null): NFTDepositedEventFilter;
        "NFTLocked(address,address,uint256,uint256)"(tokenAddress?: string | null, sender?: string | null, tokenId?: null, unlockTime?: null): NFTLockedEventFilter;
        NFTLocked(tokenAddress?: string | null, sender?: string | null, tokenId?: null, unlockTime?: null): NFTLockedEventFilter;
        "NFTWithdrew(address,address,uint256)"(tokenAddress?: string | null, sender?: string | null, tokenId?: null): NFTWithdrewEventFilter;
        NFTWithdrew(tokenAddress?: string | null, sender?: string | null, tokenId?: null): NFTWithdrewEventFilter;
        "SBTAuthorizationRevoked(address,address)"(tokenAddress?: string | null, sender?: string | null): SBTAuthorizationRevokedEventFilter;
        SBTAuthorizationRevoked(tokenAddress?: string | null, sender?: string | null): SBTAuthorizationRevokedEventFilter;
        "TokensDeposited(address,address,uint256)"(tokenAddress?: string | null, sender?: string | null, amount?: null): TokensDepositedEventFilter;
        TokensDeposited(tokenAddress?: string | null, sender?: string | null, amount?: null): TokensDepositedEventFilter;
        "TokensLocked(address,address,uint256,uint256)"(tokenAddress?: string | null, sender?: string | null, amount?: null, unlockTime?: null): TokensLockedEventFilter;
        TokensLocked(tokenAddress?: string | null, sender?: string | null, amount?: null, unlockTime?: null): TokensLockedEventFilter;
        "TokensWithdrew(address,address,uint256)"(tokenAddress?: string | null, sender?: string | null, amount?: null): TokensWithdrewEventFilter;
        TokensWithdrew(tokenAddress?: string | null, sender?: string | null, amount?: null): TokensWithdrewEventFilter;
    };
    estimateGas: {
        authorizeBySBT(tokenAddress_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        depositERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        depositNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        depositNative(overrides?: PayableOverrides & {
            from?: string;
        }): Promise<BigNumber>;
        getConstitutionSignHash(signer_: string, overrides?: CallOverrides): Promise<BigNumber>;
        getTimeLockInfo(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        getTokenSupply(tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        getUserConstitutionData(userAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        getUserNFTs(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        getUserTokens(userAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        getUserVotingPower(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        isAuthorizedBySBT(sender_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        isSupportedNFT(tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        isSupportedSBT(tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        lock(sender_: string, tokenAddress_: string, amount_: BigNumberish, timeToLock_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        lockAndGetUserVotingPower(userAddress_: string, tokenAddress_: string, timeToLock_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        revokeSBTAuthorization(tokenAddress_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        signConstitution(signer_: string, signature_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        withdrawERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        withdrawNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        withdrawNative(amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        authorizeBySBT(tokenAddress_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        depositERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        depositNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        depositNative(overrides?: PayableOverrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        getConstitutionSignHash(signer_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getTimeLockInfo(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getTokenSupply(tokenAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getUserConstitutionData(userAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getUserNFTs(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getUserTokens(userAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getUserVotingPower(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isAuthorizedBySBT(sender_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isSupportedNFT(tokenAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isSupportedSBT(tokenAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lock(sender_: string, tokenAddress_: string, amount_: BigNumberish, timeToLock_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        lockAndGetUserVotingPower(userAddress_: string, tokenAddress_: string, timeToLock_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        revokeSBTAuthorization(tokenAddress_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        signConstitution(signer_: string, signature_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        withdrawERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        withdrawNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        withdrawNative(amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
    };
}