@0xfutbol/id/dist/index.d.ts

React component library with shared providers for 0xFutbol ID

export { AutoConnect, ConnectButton, PayEmbed } from 'thirdweb/react';
import * as React from 'react';
import React__default, { JSX, ReactNode } from 'react';
import * as __providers from '@/providers';
import { WALLET_OPTIONS as WALLET_OPTIONS$1 } from '@/providers';
import * as thirdweb_chains from 'thirdweb/chains';
import * as thirdweb from 'thirdweb';
export { getContract } from 'thirdweb';
import * as _0xfutbol_constants from '@0xfutbol/constants';
import { ChainName } from '@0xfutbol/constants';
import { AuthStatus as AuthStatus$1 } from '@/providers/types';
import * as ethers from 'ethers';
import { Signer, BigNumber, Contract, ethers as ethers$1, TypedDataDomain, TypedDataField } from 'ethers';
import { Web3ContextState as Web3ContextState$1 } from '@/providers/Web3Context';
import * as thirdweb_wallets from 'thirdweb/wallets';
import { Wallet } from 'thirdweb/wallets';
import { Provider, TransactionRequest, BlockTag, TransactionResponse, FeeData } from '@ethersproject/abstract-provider';
import { Hooks } from '@matchain/matchid-sdk-react';
import { Deferrable } from 'ethers/lib/utils';
import { WaasService as WaasService$1 } from '@/services/WaasService';

interface AuthUIOrchestratorProps {
    claimComponent: (props: {
        error?: string;
        isLoading: boolean;
        isTakingLong: boolean;
        onClaimClick: (username: string, email?: string) => Promise<void>;
        onDisconnectClick: (walletKey: string) => void;
    }) => JSX.Element;
    waasComponent: (props: {
        isWaitingForSignature: boolean;
        onShowOtherOptions: () => void;
        onHideOtherOptions: () => void;
        showOtherOptions: boolean;
    }) => JSX.Element;
    otherOptionsComponent: (props: {
        WALLET_OPTIONS: typeof WALLET_OPTIONS$1;
        isWaitingForSignature: boolean;
        onConnectClick: (walletKey: string) => void;
        onHide: () => void;
    }) => JSX.Element;
}
declare function AuthUIOrchestrator({ claimComponent, waasComponent, otherOptionsComponent }: AuthUIOrchestratorProps): JSX.Element;

declare const MatchainConnect: React__default.FC;

declare const chains: {
    base: {
        name: string;
        ref: Readonly<thirdweb_chains.ChainOptions & {
            rpc: string;
        }>;
    };
    boba: {
        name: string;
        ref: Readonly<thirdweb_chains.ChainOptions & {
            rpc: string;
        }>;
    };
    matchain: {
        name: string;
        ref: Readonly<thirdweb_chains.ChainOptions & {
            rpc: string;
        }>;
    };
    polygon: {
        name: string;
        ref: Readonly<thirdweb_chains.ChainOptions & {
            rpc: string;
        }>;
    };
    skaleNebula: {
        name: string;
        ref: Readonly<thirdweb_chains.ChainOptions & {
            rpc: string;
        }>;
    };
    xdc: {
        name: string;
        ref: Readonly<thirdweb_chains.ChainOptions & {
            rpc: string;
        }>;
    };
};

declare const thirdwebClient: thirdweb.ThirdwebClient;

declare const OxFUTBOL_ID_REFERRER = "OxFUTBOL_ID_REFERRER";
declare const useReferrerParam: () => void;

type UseWaasPasswordFlowParams = {
    waasBaseUrl?: string;
    initialUsername?: string;
    onUsernameChange?: (username: string) => void;
};
declare function useWaasPasswordFlow({ waasBaseUrl, initialUsername, onUsernameChange }: UseWaasPasswordFlowParams): {
    checking: boolean;
    error: string | undefined;
    exists: boolean | undefined;
    hint: string;
    introCopy: string;
    loading: boolean;
    password: string;
    passwordConfirm: string;
    setPassword: React.Dispatch<React.SetStateAction<string>>;
    setPasswordConfirm: React.Dispatch<React.SetStateAction<string>>;
    setUsername: (value: string) => void;
    stage: "username" | "password";
    reset: () => void;
    submit: () => Promise<void>;
    username: string;
};

type AuthContextProviderProps = {
    backendUrl: string;
    chainToSign: ChainName;
    children: React__default.ReactNode;
};
declare const AuthContext: React__default.Context<{
    authStatus: AuthStatus$1;
    isClaimPending: boolean;
    isWaitingForSignature: boolean;
    username: any;
    userClaims: any;
    backendUrl: string;
    claim: (username: string, email?: string) => Promise<void>;
    loginWithWaas: (params: {
        jwt: string;
        walletId: string;
        walletAddress: string;
        waasBaseUrl: string;
        waasSessionToken: string;
    }) => Promise<void>;
} | undefined>;
declare const AuthContextProvider: ({ backendUrl, chainToSign, children }: AuthContextProviderProps) => React__default.JSX.Element;
declare const useAuthContext: () => {
    authStatus: AuthStatus$1;
    isClaimPending: boolean;
    isWaitingForSignature: boolean;
    username: any;
    userClaims: any;
    backendUrl: string;
    claim: (username: string, email?: string) => Promise<void>;
    loginWithWaas: (params: {
        jwt: string;
        walletId: string;
        walletAddress: string;
        waasBaseUrl: string;
        waasSessionToken: string;
    }) => Promise<void>;
};

declare const META_SOCCER_WAAS_SESSION = "META_SOCCER_WAAS_SESSION";
type MetaSoccerWaaSSession = {
    walletId: string;
    walletAddress: string;
    waasBaseUrl: string;
    waasSessionToken: string;
    chainId?: number;
};
declare const loadMetaSoccerWaaSSession: () => MetaSoccerWaaSSession | undefined;
declare const saveMetaSoccerWaaSSession: (session: MetaSoccerWaaSSession) => void;
declare const clearMetaSoccerWaaSSession: () => void;
type MetaSoccerWaaSContextProviderProps = {
    chains: Array<ChainName>;
    children: ReactNode;
};
type ConnectParams = {
    walletId: string;
    walletAddress: string;
    waasBaseUrl: string;
    waasSessionToken: string;
    chainId?: number;
};
declare const MetaSoccerWaaSContext: React__default.Context<{
    address: string | undefined;
    chainId: number | undefined;
    signer: Record<"base" | "boba" | "matchain" | "polygon" | "skaleNebula" | "xdc", Signer> | undefined;
    status: "unknown" | "connected" | "connecting" | "disconnected";
    web3Ready: boolean;
    connect: (params: ConnectParams) => Promise<void>;
    disconnect: () => Promise<void>;
    nativeBalanceOf: (_address: string, _chainId: number) => Promise<BigNumber>;
    switchChain: (_chain: ChainName) => Promise<void>;
} | undefined>;
declare function MetaSoccerWaaSContextProvider({ chains, children }: MetaSoccerWaaSContextProviderProps): React__default.JSX.Element;
declare const useMetaSoccerWaaSContext: () => {
    address: string | undefined;
    chainId: number | undefined;
    signer: Record<"base" | "boba" | "matchain" | "polygon" | "skaleNebula" | "xdc", Signer> | undefined;
    status: "unknown" | "connected" | "connecting" | "disconnected";
    web3Ready: boolean;
    connect: (params: ConnectParams) => Promise<void>;
    disconnect: () => Promise<void>;
    nativeBalanceOf: (_address: string, _chainId: number) => Promise<BigNumber>;
    switchChain: (_chain: ChainName) => Promise<void>;
};

type OxFutbolIdProviderProps = {
    backendUrl: string;
    chains: Array<ChainName>;
    children: React.ReactNode;
    sponsorGas?: boolean;
};
type OxFutbolIdState = {
    address?: string;
    chainId?: number;
    defaultChain?: ChainName;
    signer?: Record<ChainName, Signer>;
    status: string;
    userDetails?: Web3ContextState$1["userDetails"];
    walletProvider: "matchain_id" | "thirdweb" | "metasoccer-waas" | "unknown";
    web3Ready: boolean;
    connect: (walletKey: string) => Promise<void>;
    disconnect: () => Promise<void>;
    nativeBalanceOf: (address: string, chainId: number) => Promise<BigNumber>;
    newContract: (chain: ChainName, contractAddress: string, contractAbi: any) => Contract;
    switchChain: (chain: ChainName) => Promise<void>;
    authStatus: AuthStatus$1;
    isClaimPending: boolean;
    isWaitingForSignature: boolean;
    username?: string;
    userClaims?: Record<string, any>;
    claim: (username: string, email?: string) => Promise<void>;
    loginWithWaas?: (params: {
        jwt: string;
        walletId: string;
        walletAddress: string;
        waasBaseUrl: string;
        waasSessionToken: string;
    }) => Promise<void>;
};
declare const OxFutbolIdContext: React.Context<OxFutbolIdState | undefined>;
declare function OxFutbolIdProvider({ backendUrl, chains, children, sponsorGas }: OxFutbolIdProviderProps): React.JSX.Element;

type AuthStatus = "unknown" | "authenticated" | "unauthenticated";

declare const useOxFutbolIdContext: () => {
    address?: string;
    chainId?: number;
    defaultChain?: _0xfutbol_constants.ChainName;
    signer?: Record<_0xfutbol_constants.ChainName, ethers.Signer>;
    status: string;
    userDetails?: __providers.Web3ContextState["userDetails"];
    walletProvider: "matchain_id" | "thirdweb" | "metasoccer-waas" | "unknown";
    web3Ready: boolean;
    connect: (walletKey: string) => Promise<void>;
    disconnect: () => Promise<void>;
    nativeBalanceOf: (address: string, chainId: number) => Promise<ethers.BigNumber>;
    newContract: (chain: _0xfutbol_constants.ChainName, contractAddress: string, contractAbi: any) => ethers.Contract;
    switchChain: (chain: _0xfutbol_constants.ChainName) => Promise<void>;
    authStatus: AuthStatus;
    isClaimPending: boolean;
    isWaitingForSignature: boolean;
    username?: string;
    userClaims?: Record<string, any>;
    claim: (username: string, email?: string) => Promise<void>;
    loginWithWaas?: (params: {
        jwt: string;
        walletId: string;
        walletAddress: string;
        waasBaseUrl: string;
        waasSessionToken: string;
    }) => Promise<void>;
};

declare const WALLET_OPTIONS: ({
    key: string;
    label: string;
    description: string;
    icon: React.JSX.Element;
    provider: string;
    wallet: () => undefined;
    component?: undefined;
} | {
    key: string;
    label: string;
    description: string;
    icon: React.JSX.Element;
    provider: string;
    component: () => React.JSX.Element;
    wallet: ({ sponsorGas }: {
        sponsorGas?: boolean;
    }) => thirdweb_wallets.Wallet<"inApp">;
} | {
    key: string;
    label: string;
    description: string;
    icon: React.JSX.Element;
    provider: string;
    component: () => React.JSX.Element;
    wallet: () => thirdweb_wallets.Wallet<"io.metamask">;
} | {
    key: string;
    label: string;
    description: string;
    icon: React.JSX.Element;
    provider: string;
    wallet: () => thirdweb_wallets.Wallet<"walletConnect">;
    component?: undefined;
})[];
type WalletProvider = "matchain_id" | "thirdweb" | "metasoccer-waas" | "unknown";
type Web3ContextProviderProps = {
    chains: Array<ChainName>;
    children: React.ReactNode;
    sponsorGas?: boolean;
};
type Web3ContextState = {
    address?: string;
    chainId?: number;
    defaultChain?: ChainName;
    signer?: Record<ChainName, Signer>;
    status: "disconnected" | "connecting" | "connected" | "unknown";
    userDetails?: Array<{
        provider: string;
    } & Record<string, any>>;
    walletProvider: WalletProvider;
    web3Ready: boolean;
    connect: (walletKey: string) => Promise<void>;
    disconnect: () => Promise<void>;
    nativeBalanceOf: (address: string, chainId: number) => Promise<BigNumber>;
    newContract: (chain: ChainName, contractAddress: string, contractAbi: any) => Contract;
    switchChain: (chain: ChainName) => Promise<void>;
};
declare const Web3Context: React.Context<Web3ContextState | undefined>;
declare function Web3ContextProvider({ chains, children, sponsorGas }: Web3ContextProviderProps): React.JSX.Element;
declare const useWeb3Context: () => Web3ContextState;

declare class AccountService {
    private readonly httpClient;
    constructor(backendUrl: string);
    getInfo(): Promise<{
        discord: any;
        pip: string | null;
        referralCount: number;
    }>;
    linkDiscord(code: string, redirectUri: string): Promise<void>;
    ping(address: string, referrer?: string): Promise<{
        message: string;
    }>;
    updatePiP(tokenId: string): Promise<void>;
}

declare class AuthService {
    private readonly httpClient;
    constructor(backendUrl: string);
    claim(username: string, owner: string, message: string, signatureExpiration: number, userDetails?: Record<string, any>, userEmail?: string): Promise<void>;
    getJWT(username: string, message: string, expiration: number): Promise<string>;
    pre(params: string | {
        address?: string;
        username?: string;
    }): Promise<{
        claimed?: boolean;
        username?: string;
        exists?: boolean;
    }>;
    sign(username: string, owner: string): Promise<{
        claimed: boolean;
        signature: string;
        signatureExpiration: bigint;
    }>;
    registerPassword(username: string, password: string): Promise<{
        token: string;
        address: string;
        walletId: string;
        walletAddress: string;
        waasSessionToken?: string;
        waasSessionExpiresAt?: number;
    }>;
    loginPassword(username: string, password: string): Promise<{
        token: string;
        address: string;
        walletId?: string;
        walletAddress?: string;
        waasSessionToken?: string;
        waasSessionExpiresAt?: number;
    }>;
}

declare class WaasService {
    private readonly baseUrl;
    private readonly sessionToken;
    constructor(baseUrl: string, sessionToken: string);
    private post;
    signMessage(walletId: string, message: string): Promise<{
        signature: string;
    }>;
    signTypedData(walletId: string, domain: any, types: any, value: any): Promise<{
        signature: string;
    }>;
    sendNative(walletId: string, toAddress: string, amountWei: string, memo?: string): Promise<{
        txHash: string;
    }>;
    callContract(walletId: string, contractAddress: string, data: string, valueWei?: string, memo?: string): Promise<{
        txHash: string;
    }>;
    getNativeBalance(walletId: string, chainId: number): Promise<{
        balanceWei: string;
    }>;
    switchChain(walletId: string, chainId: number): Promise<{
        chainId: number;
    }>;
}

type GenericEmitterType = {
    [key: string]: unknown;
};
type Emitter<T extends GenericEmitterType> = {
    subscribe<K extends keyof T>(event: K, cb: (data: T[K]) => void): () => void;
    emit<K extends keyof T>(event: K, data: T[K]): void;
};
/**
 * Creates an emitter object that allows subscribing to events and emitting events.
 * @returns An emitter object with `subscribe` and `emit` methods.
 * @template TEmitter - The type of the emitter.
 * @example
 * ```ts
 * const emitter = createEmitter<{
 *  event1: string;
 * event2: number;
 * }>();
 *
 * emitter.subscribe("event1", (data) => {
 * console.log(data); // "hello"
 * });
 *
 * emitter.emit("event1", "hello");
 * ```
 */
declare function createEmitter<const TEmitter extends GenericEmitterType>(): Emitter<TEmitter>;

declare function getChainConfig(chainId: number): {
    config: {
        id: number;
        name: string;
        nativeCurrency: {
            name: string;
            symbol: string;
            decimals: number;
        };
        rpcUrls: {
            default: {
                http: string[];
            };
        };
    };
    provider: ethers$1.providers.JsonRpcProvider;
};
declare class MatchIdSigner implements Signer {
    private chainId;
    private wallet;
    _isSigner: boolean;
    chain: ReturnType<typeof getChainConfig>["config"];
    provider?: Provider;
    constructor(chainId: number, wallet: ReturnType<typeof Hooks.useWallet>);
    getAddress(): Promise<string>;
    signMessage(message: string): Promise<string>;
    signTransaction(transaction: Deferrable<TransactionRequest>): Promise<string>;
    connect(provider: Provider): Signer;
    getBalance(blockTag?: BlockTag): Promise<BigNumber>;
    getTransactionCount(blockTag?: BlockTag): Promise<number>;
    estimateGas(transaction: Deferrable<TransactionRequest>): Promise<BigNumber>;
    call(transaction: Deferrable<TransactionRequest>, blockTag?: BlockTag): Promise<string>;
    sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionResponse>;
    getChainId(): Promise<number>;
    getGasPrice(): Promise<BigNumber>;
    getFeeData(): Promise<FeeData>;
    resolveName(name: string): Promise<string>;
    checkTransaction(transaction: Deferrable<TransactionRequest>): Deferrable<TransactionRequest>;
    populateTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionRequest>;
    _checkProvider(operation?: string): void;
    signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;
}

declare class MetaSoccerWaaSSigner extends Signer {
    readonly waas: WaasService$1;
    readonly walletId: string;
    readonly address: string;
    readonly chain: ChainName;
    readonly chainId?: number | undefined;
    constructor(waas: WaasService$1, walletId: string, address: string, chain: ChainName, chainId?: number | undefined);
    getAddress(): Promise<string>;
    signMessage(message: string): Promise<string>;
    signTransaction(_transaction: Deferrable<TransactionRequest>): Promise<string>;
    connect(provider: any): Signer;
    getBalance(_blockTag?: BlockTag): Promise<BigNumber>;
    getTransactionCount(_blockTag?: BlockTag): Promise<number>;
    estimateGas(_transaction: Deferrable<TransactionRequest>): Promise<BigNumber>;
    call(_transaction: Deferrable<TransactionRequest>, _blockTag?: BlockTag): Promise<string>;
    sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionResponse>;
    getChainId(): Promise<number>;
    getGasPrice(): Promise<BigNumber>;
    getFeeData(): Promise<FeeData>;
    resolveName(_name: string): Promise<string>;
    checkTransaction(transaction: Deferrable<TransactionRequest>): Deferrable<TransactionRequest>;
    populateTransaction(_transaction: Deferrable<TransactionRequest>): Promise<TransactionRequest>;
    signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;
}
type CreateMetaSoccerWaaSSignerParams = {
    waasBaseUrl: string;
    waasSessionToken: string;
    walletId: string;
    walletAddress: string;
    chain: ChainName;
    chainId?: number;
    waasService?: WaasService$1;
};
declare function createMetaSoccerWaaSSigner(params: CreateMetaSoccerWaaSSignerParams): Signer;

declare const createThirdwebWalletButton: (key: string, label: string, wallet: Wallet) => React__default.JSX.Element;

declare const getChainName: (chainId: number) => ChainName | undefined;

declare function decodeJWT(token: string): {
    header: any;
    payload: any;
};
declare const getSavedJWT: () => string | undefined;
declare const setSavedJWT: (jwt: string | undefined) => void;

export { AccountService, AuthContext, AuthContextProvider, AuthService, AuthUIOrchestrator, META_SOCCER_WAAS_SESSION, MatchIdSigner, MatchainConnect, MetaSoccerWaaSContext, MetaSoccerWaaSContextProvider, MetaSoccerWaaSSigner, OxFUTBOL_ID_REFERRER, OxFutbolIdContext, OxFutbolIdProvider, WALLET_OPTIONS, WaasService, Web3Context, Web3ContextProvider, chains, clearMetaSoccerWaaSSession, createEmitter, createMetaSoccerWaaSSigner, createThirdwebWalletButton, decodeJWT, getChainName, getSavedJWT, loadMetaSoccerWaaSSession, saveMetaSoccerWaaSSession, setSavedJWT, thirdwebClient, useAuthContext, useMetaSoccerWaaSContext, useOxFutbolIdContext, useReferrerParam, useWaasPasswordFlow as useWaasPassword, useWaasPasswordFlow, useWeb3Context };
export type { Emitter, MetaSoccerWaaSSession, Web3ContextState };