use-frontbacked 5.0.1

package/dist/esm/types/node_modules/web3-types/src/eth_types.d.ts

@@ -0,0 +1,440 @@
+import { Bytes, HexString, Numbers } from './primitives_types.js';
+export type ValueTypes = 'address' | 'bool' | 'string' | 'int256' | 'uint256' | 'bytes' | 'bigint';
+export type HexString32Bytes = HexString;
+export type HexString16Bytes = HexString;
+export type HexString8Bytes = HexString;
+export type HexStringSingleByte = HexString;
+export type HexStringBytes = HexString;
+export type HexString256Bytes = HexString;
+export type Uint = HexString;
+export type Uint256 = HexString;
+export type Address = HexString;
+export type Topic = HexString32Bytes;
+export type TransactionHash = HexString;
+export type Uncles = HexString32Bytes[];
+export declare enum BlockTags {
+    EARLIEST = "earliest",
+    LATEST = "latest",
+    PENDING = "pending",
+    SAFE = "safe",
+    FINALIZED = "finalized"
+}
+export type BlockTag = `${BlockTags}`;
+export type BlockNumberOrTag = Numbers | BlockTag;
+export interface Proof {
+    readonly address: HexString;
+    readonly nonce: string;
+    readonly balance: string;
+}
+export interface TransactionInput {
+    readonly [key: string]: unknown;
+    readonly to?: HexString;
+    readonly from?: HexString;
+    readonly data?: string;
+    readonly input?: string;
+    readonly gas: HexString;
+    readonly gasLimit?: string;
+    readonly gasPrice?: string;
+    readonly maxPriorityFeePerGas?: string;
+    readonly maxFeePerGas?: string;
+    readonly nonce: string;
+    readonly value: string;
+    readonly blockNumber?: HexString;
+    readonly transactionIndex?: HexString;
+    readonly type?: HexString;
+    readonly chainId?: HexString;
+}
+export type TransactionOutput = {
+    readonly [key: string]: unknown;
+    readonly to?: HexString;
+    readonly from?: HexString;
+    readonly input: string;
+    readonly gas?: Numbers;
+    readonly gasLimit?: string;
+    readonly nonce: Numbers;
+    readonly value: Numbers;
+    readonly blockNumber?: Numbers;
+    readonly transactionIndex?: Numbers;
+} & ({
+    maxPriorityFeePerGas: Numbers;
+    maxFeePerGas: Numbers;
+    gasPrice?: never;
+} | {
+    maxPriorityFeePerGas?: never;
+    maxFeePerGas?: never;
+    gasPrice: Numbers;
+});
+export interface LogsInput {
+    readonly blockHash?: HexString;
+    readonly transactionHash?: HexString;
+    readonly logIndex?: HexString;
+    readonly id?: string;
+    readonly blockNumber?: HexString;
+    readonly transactionIndex?: HexString;
+    readonly address: HexString;
+    readonly topics: HexString[];
+    readonly data: HexString;
+}
+export interface LogsOutput {
+    readonly id?: string;
+    readonly removed: boolean;
+    readonly logIndex?: Numbers;
+    readonly transactionIndex?: Numbers;
+    readonly transactionHash?: HexString32Bytes;
+    readonly blockHash?: HexString32Bytes;
+    readonly blockNumber?: Numbers;
+    readonly address: string;
+    readonly topics: HexString[];
+    readonly data: HexString;
+}
+export interface BlockInput {
+    readonly gasLimit: HexString;
+    readonly gasUsed: HexString;
+    readonly size: HexString;
+    readonly timestamp: HexString;
+    readonly number?: HexString;
+    readonly difficulty?: HexString;
+    readonly totalDifficulty?: HexString;
+    readonly transactions?: TransactionInput[];
+    readonly miner?: HexString;
+    readonly baseFeePerGas?: HexString;
+}
+export interface BlockOutput {
+    readonly gasLimit: bigint | number;
+    readonly gasUsed: bigint | number;
+    readonly size: bigint | number;
+    readonly timestamp: bigint | number;
+    readonly number?: bigint | number;
+    readonly difficulty?: bigint | number;
+    readonly totalDifficulty?: bigint | number;
+    readonly transactions?: TransactionOutput[];
+    readonly miner?: HexString;
+    readonly baseFeePerGas?: bigint | number;
+    readonly parentHash?: HexString32Bytes;
+}
+export interface Withdrawals {
+    readonly index: Numbers;
+    readonly validatorIndex: Numbers;
+    readonly address: Address;
+    readonly amount: Numbers;
+}
+export interface BlockHeaderOutput {
+    readonly hash?: HexString32Bytes;
+    readonly parentHash?: HexString32Bytes;
+    readonly receiptsRoot?: HexString32Bytes;
+    readonly miner?: HexString;
+    readonly stateRoot?: HexString32Bytes;
+    readonly transactionsRoot?: HexString32Bytes;
+    readonly withdrawalsRoot?: HexString32Bytes;
+    readonly logsBloom?: Bytes;
+    readonly difficulty?: Numbers;
+    readonly number?: Numbers;
+    readonly gasLimit: Numbers;
+    readonly gasUsed: Numbers;
+    readonly timestamp: Numbers;
+    readonly extraData?: Bytes;
+    readonly nonce?: Numbers;
+    readonly sha3Uncles: HexString32Bytes[];
+    readonly baseFeePerGas?: Numbers;
+    readonly author?: Address;
+    readonly totalDifficulty?: Numbers;
+    readonly size?: Numbers;
+    readonly excessDataGas?: Numbers;
+    readonly mixHash?: HexString32Bytes;
+    readonly transactions?: TransactionOutput[];
+    readonly uncles?: Uncles;
+    readonly withdrawals?: Withdrawals[];
+}
+export interface ReceiptInput {
+    readonly [x: string]: unknown;
+    readonly blockNumber?: HexString;
+    readonly transactionIndex?: HexString;
+    readonly cumulativeGasUsed: HexString;
+    readonly gasUsed: HexString;
+    readonly logs?: LogsInput[];
+    readonly contractAddress?: HexString;
+    readonly status?: string;
+    readonly effectiveGasPrice?: HexString;
+}
+export interface ReceiptOutput {
+    readonly blockNumber?: bigint | number;
+    readonly transactionIndex?: bigint | number;
+    readonly cumulativeGasUsed: bigint | number;
+    readonly gasUsed: bigint | number;
+    readonly logs?: LogsOutput[];
+    readonly contractAddress?: HexString;
+    readonly status: boolean;
+    readonly effectiveGasPrice?: bigint | number;
+}
+export interface PostInput {
+    readonly ttl?: HexString;
+    readonly workToProve?: HexString;
+    readonly priority?: HexString;
+    readonly expiry?: HexString;
+    readonly sent?: HexString;
+    readonly workProved?: HexString;
+    readonly topics?: HexString[];
+}
+export interface PostOutput {
+    readonly ttl?: bigint | number;
+    readonly workToProve?: bigint | number;
+    readonly priority?: bigint | number;
+    readonly expiry?: bigint | number;
+    readonly sent?: bigint | number;
+    readonly workProved?: bigint | number;
+    readonly topics?: string[];
+}
+export interface SyncInput {
+    readonly startingBlock: HexString;
+    readonly currentBlock: HexString;
+    readonly highestBlock: HexString;
+    readonly knownStates?: HexString;
+    readonly pulledStates?: HexString;
+}
+export interface SyncOutput {
+    readonly startingBlock: Numbers;
+    readonly currentBlock: Numbers;
+    readonly highestBlock: Numbers;
+    readonly knownStates?: Numbers;
+    readonly pulledStates?: Numbers;
+}
+export type Receipt = Record<string, unknown>;
+type FilterOption = Record<string, Numbers | Numbers[] | boolean | boolean[]>;
+export interface Filter {
+    readonly fromBlock?: BlockNumberOrTag;
+    readonly toBlock?: BlockNumberOrTag;
+    readonly address?: Address | Address[];
+    readonly blockHash?: Address;
+    readonly topics?: (null | Topic | Topic[])[];
+    readonly filter?: FilterOption;
+}
+export interface AccessListEntry {
+    readonly address?: Address;
+    readonly storageKeys?: HexString32Bytes[];
+}
+export type AccessList = AccessListEntry[];
+export type AccessListResult = {
+    readonly accessList?: AccessList;
+    readonly gasUsed?: Numbers;
+};
+export type ValidChains = 'goerli' | 'kovan' | 'mainnet' | 'rinkeby' | 'ropsten' | 'sepolia';
+export declare enum HardforksOrdered {
+    chainstart = "chainstart",
+    frontier = "frontier",
+    homestead = "homestead",
+    dao = "dao",
+    tangerineWhistle = "tangerineWhistle",
+    spuriousDragon = "spuriousDragon",
+    byzantium = "byzantium",
+    constantinople = "constantinople",
+    petersburg = "petersburg",
+    istanbul = "istanbul",
+    muirGlacier = "muirGlacier",
+    berlin = "berlin",
+    london = "london",
+    altair = "altair",
+    arrowGlacier = "arrowGlacier",
+    grayGlacier = "grayGlacier",
+    bellatrix = "bellatrix",
+    merge = "merge",
+    capella = "capella",
+    shanghai = "shanghai"
+}
+export type Hardfork = `${HardforksOrdered}`;
+export interface LogBase<NumberType, ByteType> {
+    readonly removed?: boolean;
+    readonly logIndex?: NumberType;
+    readonly transactionIndex?: NumberType;
+    readonly transactionHash?: ByteType;
+    readonly blockHash?: ByteType;
+    readonly blockNumber?: NumberType;
+    readonly address?: Address;
+    readonly data?: ByteType;
+    readonly topics?: ByteType[];
+    readonly id?: string;
+}
+export interface Log extends LogBase<Numbers, Bytes> {
+    readonly id?: string;
+}
+export interface EventLog {
+    readonly event: string;
+    readonly id?: string;
+    readonly logIndex?: bigint | number | string;
+    readonly transactionIndex?: bigint | number | string;
+    readonly transactionHash?: HexString32Bytes;
+    readonly blockHash?: HexString32Bytes;
+    readonly blockNumber?: bigint | number | string;
+    readonly address: string;
+    readonly topics: HexString[];
+    readonly data: HexString;
+    readonly raw?: {
+        data: string;
+        topics: unknown[];
+    };
+    readonly returnValues: Record<string, unknown>;
+    readonly signature?: HexString;
+}
+export interface TransactionReceiptBase<numberType, hashByteType, logsBloomByteType, logsType> {
+    readonly transactionHash: hashByteType;
+    readonly transactionIndex: numberType;
+    readonly blockHash: hashByteType;
+    readonly blockNumber: numberType;
+    readonly from: Address;
+    readonly to: Address;
+    readonly cumulativeGasUsed: numberType;
+    readonly gasUsed: numberType;
+    readonly effectiveGasPrice?: numberType;
+    readonly contractAddress?: Address;
+    readonly logs: logsType[];
+    readonly logsBloom: logsBloomByteType;
+    readonly root: hashByteType;
+    readonly status: numberType;
+    readonly type?: numberType;
+    events?: {
+        [key: string]: EventLog;
+    };
+}
+export type TransactionReceipt = TransactionReceiptBase<Numbers, Bytes, Bytes, Log>;
+export interface CustomChain {
+    name?: string;
+    networkId: Numbers;
+    chainId: Numbers;
+}
+export interface Common {
+    customChain: CustomChain;
+    baseChain?: ValidChains;
+    hardfork?: Hardfork;
+}
+interface TransactionBase {
+    value?: Numbers;
+    accessList?: AccessList;
+    common?: Common;
+    gas?: Numbers;
+    gasPrice?: Numbers;
+    type?: Numbers;
+    maxFeePerGas?: Numbers;
+    maxPriorityFeePerGas?: Numbers;
+    data?: Bytes;
+    input?: Bytes;
+    nonce?: Numbers;
+    chain?: ValidChains;
+    hardfork?: Hardfork;
+    chainId?: Numbers;
+    networkId?: Numbers;
+    gasLimit?: Numbers;
+    yParity?: Uint;
+    v?: Numbers;
+    r?: Bytes;
+    s?: Bytes;
+}
+export interface Transaction extends TransactionBase {
+    from?: Address;
+    to?: Address | null;
+}
+export interface TransactionForAccessList extends Transaction {
+    from: Address;
+}
+export interface TransactionCall extends Transaction {
+    to: Address;
+}
+export interface TransactionWithFromLocalWalletIndex extends Omit<Transaction, 'from'> {
+    from: Numbers;
+}
+export interface TransactionWithToLocalWalletIndex extends Omit<Transaction, 'to'> {
+    to: Numbers;
+}
+export interface TransactionWithFromAndToLocalWalletIndex extends Omit<Transaction, 'from' | 'to'> {
+    from: Numbers;
+    to: Numbers;
+}
+export interface TransactionInfo extends Transaction {
+    readonly blockHash?: Bytes;
+    readonly blockNumber?: Numbers;
+    readonly from: Address;
+    readonly hash: Bytes;
+    readonly transactionIndex?: Numbers;
+}
+export interface PopulatedUnsignedBaseTransaction {
+    from: Address;
+    to?: Address;
+    value: Numbers;
+    gas?: Numbers;
+    gasPrice: Numbers;
+    type: Numbers;
+    input?: Bytes;
+    data?: Bytes;
+    nonce: Numbers;
+    networkId: Numbers;
+    chain: ValidChains;
+    hardfork: Hardfork;
+    chainId: Numbers;
+    common: Common;
+    gasLimit: Numbers;
+}
+export interface PopulatedUnsignedEip2930Transaction extends PopulatedUnsignedBaseTransaction {
+    accessList: AccessList;
+}
+export interface PopulatedUnsignedEip1559Transaction extends PopulatedUnsignedEip2930Transaction {
+    gasPrice: never;
+    maxFeePerGas: Numbers;
+    maxPriorityFeePerGas: Numbers;
+}
+export type PopulatedUnsignedTransaction = PopulatedUnsignedBaseTransaction | PopulatedUnsignedEip2930Transaction | PopulatedUnsignedEip1559Transaction;
+export interface BlockBase<ByteType, HexStringType, NumberType, extraDataType, TransactionTypes, logsBloomType> {
+    readonly parentHash: ByteType;
+    readonly sha3Uncles: ByteType;
+    readonly miner: HexStringType;
+    readonly stateRoot: ByteType;
+    readonly transactionsRoot: ByteType;
+    readonly receiptsRoot: ByteType;
+    readonly logsBloom?: logsBloomType;
+    readonly difficulty?: NumberType;
+    readonly number: NumberType;
+    readonly gasLimit: NumberType;
+    readonly gasUsed: NumberType;
+    readonly timestamp: NumberType;
+    readonly extraData: extraDataType;
+    readonly mixHash: ByteType;
+    readonly nonce: NumberType;
+    readonly totalDifficulty: NumberType;
+    readonly baseFeePerGas?: NumberType;
+    readonly size: NumberType;
+    readonly transactions: TransactionTypes;
+    readonly uncles: Uncles;
+    readonly hash?: ByteType;
+}
+export type Block = BlockBase<Bytes, Bytes, Numbers, Bytes, TransactionHash[] | TransactionInfo[], Bytes>;
+export interface FeeHistoryBase<NumberType> {
+    readonly oldestBlock: NumberType;
+    readonly baseFeePerGas: NumberType;
+    readonly reward: NumberType[][];
+    readonly gasUsedRatio: NumberType[];
+}
+export type FeeHistory = FeeHistoryBase<Numbers>;
+export interface StorageProof {
+    readonly key: Bytes;
+    readonly value: Numbers;
+    readonly proof: Bytes[];
+}
+export interface AccountObject {
+    readonly balance: Numbers;
+    readonly codeHash: Bytes;
+    readonly nonce: Numbers;
+    readonly storageHash: Bytes;
+    readonly accountProof: Bytes[];
+    readonly storageProof: StorageProof[];
+}
+export interface Eip712TypeDetails {
+    name: string;
+    type: string;
+}
+export interface Eip712TypedData {
+    readonly types: {
+        EIP712Domain: Eip712TypeDetails[];
+        [key: string]: Eip712TypeDetails[];
+    };
+    readonly primaryType: string;
+    readonly domain: Record<string, string | number>;
+    readonly message: Record<string, unknown>;
+}
+export {};

package/dist/esm/types/node_modules/web3-types/src/primitives_types.d.ts

@@ -0,0 +1,4 @@
+export type HexString = string;
+export type Bytes = Uint8Array | HexString;
+export type Numbers = number | bigint | string | HexString;
+export declare const TypedArray: any;

package/dist/esm/types/src/components/CreditTransfer/index.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import { User } from "firebase/auth";
+import { Config } from "../../theme.type";
+interface CreditTransfer {
+    usdBalance: number;
+    config: Config;
+    transferCredit: (recipientEmail: string, amount: number, user?: User | null) => Promise<void>;
+    onClose: () => void;
+    isDarkMode?: boolean;
+}
+declare const CreditTransfer: React.FC<CreditTransfer>;
+export default CreditTransfer;

package/dist/esm/types/src/components/DownloadType/index.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import { DownloadTypeProps, DownloadTypeResult, Tool } from "../PayFlow/types";
+import { Config } from "../../theme.type";
+interface DownloadType extends DownloadTypeProps {
+    config: Config;
+    onSuccess: (result: DownloadTypeResult) => void;
+    onError: (error: Error) => void;
+    onGetTool: (id: string) => Tool | null;
+    isDarkMode?: boolean;
+}
+declare const DownloadType: React.FC<DownloadType>;
+export default DownloadType;

package/dist/esm/types/src/components/Firebase/AccessTokenDoor.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { User } from 'firebase/auth';
+import { Config } from '../../theme.type';
+interface AccessTokenDoor {
+    show: boolean;
+    onSuccess: (accessToken: string, User: User) => void;
+    onError: (error: any) => void;
+    config: Config;
+    isDarkMode?: boolean;
+}
+declare const AccessTokenDoor: React.FC<any>;
+export default AccessTokenDoor;

package/dist/esm/types/src/components/Firebase/AuthView.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { User } from 'firebase/auth';
+import { Config } from '../../theme.type';
+interface AuthView {
+    show: boolean;
+    setUser: (user: User) => void;
+    signInTitle: string;
+    signUpTitle: string;
+    onSuccess: (user: User) => void;
+    onError: (error: any) => void;
+    config: Config;
+    isDarkMode?: boolean;
+}
+declare const AuthView: React.FC<any>;
+export default AuthView;

package/dist/esm/types/src/components/Firebase/SignInView.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import { User } from "firebase/auth";
+import { Config } from "../../theme.type";
+export interface SignView {
+    setUser: (user: User) => void;
+    config: Config;
+    onAuthDone?: (user: User) => void;
+    [x: string]: any;
+}
+declare const SignInView: React.FC<SignView>;
+export default SignInView;

package/dist/esm/types/src/components/Firebase/SignUpView.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { User } from "firebase/auth";
+import { Config } from "../../theme.type";
+interface SignUpView {
+    setUser: (user: User) => void;
+    config: Config;
+    onAuthDone?: (user: User) => void;
+}
+declare const SignUpView: React.FC<SignUpView>;
+export default SignUpView;

package/dist/esm/types/src/components/Firebase/data.type.d.ts

@@ -0,0 +1,23 @@
+import { Auth as A, User as U } from "firebase/auth";
+import { Firestore } from "firebase/firestore";
+export interface AdminInfo {
+    uid: string;
+    permissions: string[];
+}
+export interface User extends U {
+    metadata: {
+        [x: string]: any;
+    };
+    [x: string]: any;
+}
+export interface Auth extends A {
+    [x: string]: any;
+}
+export interface AuthResource {
+    uploadFile: (file: Blob | Uint8Array | ArrayBuffer, pathToFile: string) => Promise<string>;
+    auth: Auth | null | undefined;
+    user?: User | null | undefined;
+    adminInfo?: AdminInfo | null;
+    authLoading?: boolean;
+    db?: Firestore | null;
+}

package/dist/esm/types/src/components/Firebase/index.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { Firestore } from "firebase/firestore";
+import { AdminInfo, Auth, User } from './data.type';
+import { Config } from '../../theme.type';
+declare const useFirebase: (config: Config) => {
+    auth: Auth | null | undefined;
+    db: Firestore | null | undefined;
+    user: User | null | undefined;
+    setUser: import("react").Dispatch<import("react").SetStateAction<User | null | undefined>>;
+    adminInfo: AdminInfo | null | undefined;
+    authLoading: boolean;
+    uploadFile: (file: Blob | Uint8Array | ArrayBuffer, pathToFile: string) => Promise<string>;
+};
+export default useFirebase;

package/dist/esm/types/src/components/PayFlow/AmountEditor.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface AmountEditor {
+    amount: number;
+    minAmount: number;
+    onAmountValid: (amount: number) => void;
+    onSubmit: () => void;
+}
+declare const AmountEditor: React.FC<AmountEditor>;
+export default AmountEditor;

package/dist/esm/types/src/components/PayFlow/CryptoDeposit/index.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { AllCoinsBalanceInfo } from '../types';
+interface CryptoDeposit {
+    isDarkMode?: boolean;
+    amount: number;
+    coin: string;
+    setCoin: (coin: string) => void;
+    coinAmount: number;
+    coinSymbol: string;
+    wallet: string | null | undefined;
+    setWallet: (wallet: string | null | undefined) => void;
+    walletListenerResult: AllCoinsBalanceInfo;
+    [x: string]: any;
+}
+declare const CryptoDeposit: React.FC<CryptoDeposit>;
+export default CryptoDeposit;

package/dist/esm/types/src/components/PayFlow/FiatDeposit/index.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { Vendor } from '../types';
+interface WhatsappDeposit {
+    contactLink?: string | null;
+    vendors?: Vendor[] | null;
+    coinAmount: number;
+    coinSymbol: string;
+    wallet: string | null | undefined;
+    usdAmount: number;
+    fiatSymbol: string;
+    fiatName: string;
+    fiatLogo: any;
+    minVendorCoinAmount: number;
+    minVendorUSDAmount: number;
+    isDarkMode?: boolean;
+}
+declare const WhatsappDeposit: React.FC<WhatsappDeposit>;
+interface FiatDeposit extends WhatsappDeposit {
+    [x: string]: any;
+}
+declare const FiatDeposit: React.FC<FiatDeposit>;
+export default FiatDeposit;

package/dist/esm/types/src/components/PayFlow/PaymentDetected.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+interface PaymentDetected {
+    amount: number;
+    symbol: string;
+}
+declare const PaymentDetected: React.FC<PaymentDetected>;
+export default PaymentDetected;

package/dist/esm/types/src/components/PayFlow/StatusCoin.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+interface StatusCoinProps {
+    status?: "success" | "timeout" | "error";
+}
+declare const StatusCoin: React.FC<StatusCoinProps>;
+export default StatusCoin;

package/dist/esm/types/src/components/PayFlow/WalletFactory.d.ts

@@ -0,0 +1,21 @@
+import Web3 from "web3";
+import { SaltBalanceInfo } from "./types";
+declare class WalletFactory {
+    private address;
+    private abi;
+    private rpcList;
+    private secondsPerBlock;
+    web3?: Web3 | null;
+    private subscriptions;
+    private stop;
+    private lastRpcIndex;
+    constructor(address: string, abi: any, rpcList: string[], secondsPerBlock?: number);
+    startSubscriptions(): void;
+    stopSubscriptions(): void;
+    private getWeb3;
+    private getContract;
+    getSaltBalance(salt: string, blockNumber?: number): Promise<SaltBalanceInfo>;
+    startBlockListener(callBack: (blockNumber: any) => void, lastBlock: number): void;
+    getCurrentBlockNumber(): Promise<unknown>;
+}
+export default WalletFactory;

package/dist/esm/types/src/components/PayFlow/hooks/useCoinListener.d.ts

@@ -0,0 +1,18 @@
+import { PriceData, SaltBalanceConfirmation } from '../types';
+import { Config } from '../../../theme.type';
+declare const useCoinListener: (coin: string, decimals: number, requiredConfirmations: number, priceData: PriceData, config: Config, disableBlockchainPoll?: boolean) => [
+    boolean,
+    BigInt,
+    number,
+    BigInt,
+    number,
+    SaltBalanceConfirmation[],
+    SaltBalanceConfirmation | null | undefined,
+    string | null | undefined,
+    string | null | undefined,
+    string | null | undefined,
+    boolean,
+    number,
+    number
+];
+export default useCoinListener;

package/dist/esm/types/src/components/PayFlow/hooks/usePriceData.d.ts

@@ -0,0 +1,3 @@
+import { PriceData } from "../types";
+declare const usePriceData: () => PriceData;
+export default usePriceData;

package/dist/esm/types/src/components/PayFlow/hooks/useReferralId.d.ts

@@ -0,0 +1,5 @@
+declare const useReferralId: () => {
+    referralId: string | null | undefined;
+    getReferralId: () => string | null;
+};
+export default useReferralId;