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

React component library with shared providers for 0xFutbol ID

import * as React from 'react';
import React__default, { JSX } 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';

interface AuthUIOrchestratorProps {
    claimComponent: (props: {
        error?: string;
        isLoading: boolean;
        isTakingLong: boolean;
        onClaimClick: (username: string) => Promise<void>;
        onDisconnectClick: (walletKey: string) => void;
    }) => JSX.Element;
    connectComponent: (props: {
        WALLET_OPTIONS: typeof WALLET_OPTIONS$1;
        isWaitingForSignature: boolean;
        onConnectClick: (walletKey: string) => void;
    }) => JSX.Element;
}
declare function AuthUIOrchestrator({ claimComponent, connectComponent }: 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 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;
    claim: (username: 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;
    claim: (username: string) => Promise<void>;
};

type OxFutbolIdProviderProps = {
    backendUrl: string;
    chains: Array<ChainName>;
    children: React.ReactNode;
};
type OxFutbolIdState = {
    address?: string;
    defaultChain?: ChainName;
    signer?: Record<ChainName, Signer>;
    status: string;
    userDetails?: Web3ContextState$1["userDetails"];
    walletProvider: "matchain_id" | "thirdweb" | "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) => Promise<void>;
};
declare const OxFutbolIdContext: React.Context<OxFutbolIdState | undefined>;
declare function OxFutbolIdProvider({ backendUrl, chains, children }: OxFutbolIdProviderProps): React.JSX.Element;

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

declare const useOxFutbolIdContext: () => {
    address?: string;
    defaultChain?: _0xfutbol_constants.ChainName;
    signer?: Record<_0xfutbol_constants.ChainName, ethers.Signer>;
    status: string;
    userDetails?: __providers.Web3ContextState["userDetails"];
    walletProvider: "matchain_id" | "thirdweb" | "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) => Promise<void>;
};

declare const WALLET_OPTIONS: ({
    key: string;
    label: string;
    description: string;
    icon: React.JSX.Element;
    provider: string;
    component: () => React.JSX.Element;
    wallet: () => thirdweb_wallets.Wallet<"inApp">;
} | {
    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: () => 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 Web3ContextProviderProps = {
    chains: Array<ChainName>;
    children: React.ReactNode;
};
type Web3ContextState = {
    address?: string;
    defaultChain?: ChainName;
    signer?: Record<ChainName, Signer>;
    status: "disconnected" | "connecting" | "connected" | "unknown";
    userDetails?: Array<{
        provider: string;
    } & Record<string, any>>;
    walletProvider: "matchain_id" | "thirdweb" | "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>;
};
declare const Web3Context: React.Context<Web3ContextState | undefined>;
declare function Web3ContextProvider({ chains, children }: 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>): Promise<void>;
    getJWT(username: string, message: string, expiration: number): Promise<string>;
    pre(address: string): Promise<{
        claimed: boolean;
        username?: string;
    }>;
    sign(username: string, owner: string): Promise<{
        claimed: boolean;
        signature: string;
        signatureExpiration: bigint;
    }>;
}

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 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, MatchIdSigner, MatchainConnect, OxFUTBOL_ID_REFERRER, OxFutbolIdContext, OxFutbolIdProvider, WALLET_OPTIONS, Web3Context, Web3ContextProvider, chains, createEmitter, createThirdwebWalletButton, decodeJWT, getChainName, getSavedJWT, setSavedJWT, thirdwebClient, useAuthContext, useOxFutbolIdContext, useReferrerParam, useWeb3Context };
export type { Emitter, Web3ContextState };