@reef-chain/react-lib 4.0.4 → 4.0.6

package/dist/components/AccountSelector/AccountListModal.d.ts

@@ -1 +1,11 @@
+import { ReactElement } from 'react';
+import { ReefSigner } from '../../state';
+interface AccountListModal {
+    id: string;
+    accounts: ReefSigner[];
+    selectAccount: (index: number, signer: ReefSigner) => void;
+    backButtonModalId?: string;
+    title?: string | ReactElement;
+}
 export declare const AccountListModal: ({ id, accounts, selectAccount, backButtonModalId, title, }: AccountListModal) => JSX.Element;
+export {};

package/dist/components/AccountSelector/AccountSelector.d.ts

@@ -1,4 +1,32 @@
 import "./AccountSelector.css";
+import { AccountCreationData, Extension } from "@reef-chain/ui-kit/dist/ui-kit/components/organisms/AccountSelector/AccountSelector";
+import { ReefSigner } from "../../state";
 export type Network = "mainnet" | "testnet";
 export type Language = "en" | "hi";
+interface AccountSelector {
+    availableExtensions?: Extension[];
+    selExtName?: string;
+    selectExtension?: (name: string) => void;
+    accounts: ReefSigner[];
+    selectedSigner?: ReefSigner;
+    selectAccount: (index: number, signer: ReefSigner) => void;
+    selectedNetwork?: Network;
+    onNetworkSelect?: (network: Network) => any;
+    onLanguageSelect?: (language: Language) => any;
+    isBalanceHidden?: boolean;
+    showBalance?: (...args: any[]) => any;
+    availableNetworks: Network[];
+    showSnapOptions?: boolean;
+    onRename?: (address: string, newName: string) => any;
+    onExport?: (address: string, password: string) => any;
+    onImport?: (...args: any[]) => any;
+    onForget?: (address: string) => any;
+    onUpdateMetadata?: (network: Network) => any;
+    onStartAccountCreation?: () => Promise<AccountCreationData>;
+    onConfirmAccountCreation?: (seed: string, name: string) => any;
+    handleWalletConnect?: () => Promise<void>;
+    open?: boolean;
+    setOpen?: (val: boolean) => void;
+}
 export declare const AccountSelector: ({ selectedSigner, availableExtensions, selExtName, selectExtension, accounts, selectAccount, selectedNetwork, onNetworkSelect, onLanguageSelect, isBalanceHidden, showBalance, availableNetworks, showSnapOptions, onRename, onExport, onImport, onForget, onUpdateMetadata, onStartAccountCreation, onConfirmAccountCreation, handleWalletConnect, open, setOpen }: AccountSelector) => JSX.Element;
+export {};

package/dist/components/EvmBind/EvmBindComponent.d.ts

@@ -1,6 +1,15 @@
+import { ReefSigner } from '../../state';
+import { TxStatusHandler } from '../../utils';
 import './bind.css';
 export declare enum EvmBindComponentTxType {
     TRANSFER = "TRANSFER",
     BIND = "BIND"
 }
+interface EvmBindComponent {
+    bindSigner: ReefSigner;
+    signers: ReefSigner[];
+    onTxUpdate?: TxStatusHandler;
+    onComplete?: () => void;
+}
 export declare const EvmBindComponent: ({ bindSigner, onTxUpdate, signers, onComplete, }: EvmBindComponent) => JSX.Element;
+export {};

package/dist/components/Overlays/OverlayNFT.d.ts

@@ -1,2 +1,18 @@
 import './overlay.css';
+interface OverlayNFT {
+    nftName?: string;
+    isOpen: boolean;
+    isVideoNFT?: boolean;
+    iconUrl?: string;
+    onClose: () => void;
+    balance: string;
+    address: string;
+    contractType: string;
+    nftId: string;
+    accounts: any;
+    selectedSigner: any;
+    provider: any;
+    isDarkMode?: boolean;
+}
 export declare const OverlayNFT: ({ nftName, isOpen, isVideoNFT, iconUrl, onClose, balance, address, contractType, nftId, accounts, selectedSigner, provider, isDarkMode, }: OverlayNFT) => JSX.Element;
+export {};

package/dist/components/Overlays/OverlaySendNft.d.ts

@@ -1,2 +1,17 @@
 import './overlay.css';
+interface OverlaySendNFT {
+    nftName?: string;
+    isOpen: boolean;
+    onClose: () => void;
+    balance: string;
+    address: string;
+    nftId: string;
+    iconUrl?: string;
+    isVideoNFT?: boolean;
+    accounts: any;
+    selectedSigner: any;
+    provider: any;
+    isDarkMode?: boolean;
+}
 export declare const OverlaySendNFT: ({ nftName, isOpen, onClose, balance, isVideoNFT, iconUrl, address, nftId, accounts, selectedSigner, provider, isDarkMode }: OverlaySendNFT) => JSX.Element;
+export {};

package/dist/components/Overlays/OverlaySwap.d.ts

@@ -1,2 +1,19 @@
+import { network as libNet } from '@reef-chain/util-lib';
 import './overlay.css';
+import { Notify, PoolWithReserves, ReefSigner, Token, TokenPrices } from '../../state';
+import { network as nw } from '@reef-chain/util-lib';
+interface OverlaySwap {
+    isOpen: boolean;
+    tokenAddress: string;
+    onPoolsLoaded: (hasPools: boolean) => void;
+    onClose?: () => void;
+    tokens: Token[];
+    signer: ReefSigner | undefined;
+    nw: nw.Network;
+    tokenPrices: TokenPrices;
+    pools: PoolWithReserves[];
+    network: libNet.DexProtocolv2 | undefined;
+    notify: (message: string, type?: Notify) => void;
+}
 export declare const OverlaySwap: ({ tokenAddress, isOpen, onPoolsLoaded, onClose, signer, tokens, nw, tokenPrices, pools, network, notify }: OverlaySwap) => JSX.Element;
+export {};

package/dist/components/PoolActions/Provide.d.ts

@@ -1 +1,19 @@
+import { AddLiquidityState } from '../../store';
+import { SelectToken } from './TokenField';
+import { Token } from '../../state';
+interface ProvideActions {
+    onAddLiquidity: () => Promise<void>;
+    setToken1Amount: (amount: string) => void;
+    setToken2Amount: (amount: string) => void;
+    setPercentage: (amount: number) => void;
+    selectToken1?: SelectToken;
+    selectToken2?: SelectToken;
+}
+interface Provide {
+    tokens: Token[];
+    state: AddLiquidityState;
+    actions: ProvideActions;
+    confirmText?: string;
+}
 export declare const Provide: ({ state, tokens, actions: { onAddLiquidity, setPercentage, setToken1Amount, setToken2Amount, selectToken1, selectToken2, }, }: Provide) => JSX.Element;
+export {};

package/dist/components/PoolActions/Trade.d.ts

@@ -1 +1,23 @@
+import { SwapState } from '../../store';
+import { SelectToken } from './TokenField';
+import { LastPoolReserves, Token } from '../../state';
+interface TradeActions {
+    onSwitch: () => void;
+    onSwap: () => Promise<void>;
+    setToken1Amount: (amount: string) => void;
+    setToken2Amount: (amount: string) => void;
+    setPercentage: (amount: number) => void;
+    selectToken1?: SelectToken;
+    selectToken2?: SelectToken;
+    setSlippage?: (slippage: number) => void;
+}
+interface Trade {
+    pools: LastPoolReserves[];
+    tokens: Token[];
+    state: SwapState;
+    actions: TradeActions;
+    maxSlippage?: number;
+    confirmText?: string;
+}
 export declare const Trade: ({ state: { token1, percentage, token2, focus, isLoading, isValid, pool, settings, status, }, actions: { onSwap, onSwitch, setPercentage, setToken1Amount, setToken2Amount, selectToken1, selectToken2, setSlippage, }, pools, tokens, maxSlippage, }: Trade) => JSX.Element;
+export {};

package/dist/components/PoolActions/Withdraw.d.ts

@@ -1 +1,12 @@
+import { RemoveLiquidityState } from '../../store';
+interface WithdrawActions {
+    onRemoveLiquidity: () => Promise<void>;
+    setPercentage: (percentage: number) => void;
+}
+interface Withdraw {
+    state: RemoveLiquidityState;
+    actions: WithdrawActions;
+    confirmText?: string;
+}
 export declare const Withdraw: ({ state: { pool, isLoading, isValid, percentage, status, token1, token2, }, actions: { onRemoveLiquidity, setPercentage, }, }: Withdraw) => JSX.Element;
+export {};

package/dist/components/RemoveLiquidity/index.d.ts

@@ -1 +1,7 @@
+import { RemoveLiquidityComponentActions, RemoveLiquidityState } from '../../store';
+interface RemoveLiquidityComponent {
+    state: RemoveLiquidityState;
+    actions: RemoveLiquidityComponentActions;
+}
 export declare const RemoveLiquidityComponent: ({ state: { settings, pool, isLoading, isValid, percentage: percentageAmount, status, token1, token2, }, actions: { back, onRemoveLiquidity, setPercentage, setSettings, }, }: RemoveLiquidityComponent) => JSX.Element;
+export {};

package/dist/components/SelectToken/index.d.ts

@@ -1 +1,14 @@
+import { ReefSigner, Token } from '../../state';
+interface SelectToken {
+    id: string;
+    iconUrl: string;
+    fullWidth?: boolean;
+    selectedTokenName: string;
+    tokens: Token[];
+    onTokenSelect: (newToken: Token) => void;
+    onAddressChange?: (address: string) => Promise<void>;
+    hideCommonBaseView?: boolean;
+    signer: ReefSigner;
+}
 export declare const SelectToken: ({ id, tokens, selectedTokenName, onTokenSelect, fullWidth, iconUrl, onAddressChange, hideCommonBaseView, signer, }: SelectToken) => JSX.Element;
+export {};

package/dist/components/SwapComponent/index.d.ts

@@ -1 +1,11 @@
+import { ReefSigner, Token } from '../../state';
+import { SwapComponentActions } from '../../store/actions/swap';
+import { SwapState } from '../../store/reducers/swap';
+interface SwapComponent {
+    tokens: Token[];
+    account: ReefSigner;
+    state: SwapState;
+    actions: SwapComponentActions;
+}
 export declare const SwapComponent: ({ tokens, account, state: { token2: buy, token1: sell, status, isValid, settings, isLoading, }, actions: { onSwap, onSwitch, setSettings, selectToken1, selectToken2, setToken1Amount, setToken2Amount, onAddressChange, }, }: SwapComponent) => JSX.Element;
+export {};

package/dist/components/TokenFields/TokenAmountField.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { ReactElement } from 'react';
 import { ReefSigner, Token, TokenWithAmount } from '../../state';
 interface TokenAmountFieldProps extends React.PropsWithChildren<{}> {
     id?: string;
@@ -12,6 +12,10 @@ interface TokenAmountFieldProps extends React.PropsWithChildren<{}> {
     signer: ReefSigner;
 }
 export declare const TokenAmountField: ({ id, token, tokens, signer, placeholder, onTokenSelect, onAmountChange, onAddressChange, }: TokenAmountFieldProps) => JSX.Element;
+interface TokenAmountFieldMax extends TokenAmountFieldProps {
+    afterBalanceEl?: ReactElement;
+    hideSelectTokenCommonBaseView?: boolean;
+}
 export declare const TokenAmountFieldMax: ({ id, token, tokens, signer, placeholder, onTokenSelect, onAmountChange, onAddressChange, afterBalanceEl, hideSelectTokenCommonBaseView, }: TokenAmountFieldMax) => JSX.Element;
 interface TokenAmountFieldImpactPriceProps extends TokenAmountFieldProps {
     percentage: number;

package/dist/components/TokenFields/TokenAmountView.d.ts

@@ -1 +1,8 @@
+interface TokenAmountView {
+    name: string;
+    amount: string;
+    usdAmount: number;
+    placeholder: string;
+}
 export declare const TokenAmountView: ({ name, amount, usdAmount, placeholder, }: TokenAmountView) => JSX.Element;
+export {};

package/dist/components/Transfer/Send.d.ts

@@ -1,3 +1,16 @@
+import { Provider } from "@reef-chain/evm-provider";
+import { NotifyFun, ReefSigner, Token } from "../../state";
 import "../PoolActions/pool-actions.css";
 import "./Send.css";
+interface Send {
+    tokens: Token[];
+    signer: ReefSigner;
+    provider: Provider;
+    accounts: ReefSigner[];
+    notify: NotifyFun;
+    tokenAddress?: string;
+    isWalletConnect?: boolean;
+    handleWalletConnectModal?: (val: boolean) => void;
+}
 export declare const Send: ({ signer, tokens, accounts, provider, tokenAddress, isWalletConnect, handleWalletConnectModal }: Send) => JSX.Element;
+export {};

package/dist/components/Transfer/TransferComponent.d.ts

@@ -1 +1,14 @@
+import { Provider } from '@reef-chain/evm-provider';
+import { ReefSigner, Token, TokenWithAmount } from '../../state';
+import { TxStatusHandler } from '../../utils/transactionUtil';
+interface TransferComponent {
+    tokens: Token[];
+    from: ReefSigner;
+    token?: TokenWithAmount;
+    provider: Provider;
+    onTxUpdate?: TxStatusHandler;
+    accounts: ReefSigner[];
+    currentAccount: ReefSigner;
+}
 export declare const TransferComponent: ({ tokens, from, token, provider, onTxUpdate, currentAccount, accounts, }: TransferComponent) => JSX.Element;
+export {};

package/dist/components/common/Button/index.d.ts

@@ -7,6 +7,11 @@ interface ButtonProps extends React.PropsWithChildren<{}> {
 export declare const Button: React.FC<ButtonProps>;
 export declare const EmptyButton: React.FC<ButtonProps>;
 export declare const BackButton: ({ onClick }: ButtonProps) => JSX.Element;
+interface SwitchTokenButton extends React.PropsWithChildren<{}> {
+    addIcon?: boolean;
+    disabled?: boolean;
+    onClick?: () => void;
+}
 interface IconButton extends React.PropsWithChildren<{}> {
     onClick?: () => void;
 }

package/dist/components/common/Card/index.d.ts

@@ -6,6 +6,9 @@ interface Title {
     title: string;
 }
 export declare const CardTitle: React.FC<Title>;
+interface CardBack {
+    onBack: () => void;
+}
 export declare const CardBack: ({ onBack }: CardBack) => JSX.Element;
 interface ErrorCardProps {
     title: string;

package/dist/components/common/Icons/index.d.ts

@@ -21,6 +21,10 @@ export declare const CloseIcon: ({ small }: BaseIcon) => JSX.Element;
 export declare const ExploreIcon: ({ small }: BaseIcon) => JSX.Element;
 export declare const CopyIcon: ({ small }: BaseIcon) => JSX.Element;
 export declare const PlusIcon: ({ small }: BaseIcon) => JSX.Element;
+interface TokenIcon extends BaseIcon {
+    src: string;
+    address?: string;
+}
 /**
  *  Returns icon url if exists, otherwise return sample icon based on calculated
  *  checksum from provided address. Returned sample icon is svg encoded to base64
@@ -28,4 +32,7 @@ export declare const PlusIcon: ({ small }: BaseIcon) => JSX.Element;
  */
 export declare const getIconUrl: (tokenAddress?: string) => string;
 export declare const TokenIcon: ({ src, address }: TokenIcon) => JSX.Element;
+interface ReefAddressIcon {
+    address: string;
+}
 export declare const ReefAddressIcon: ({ address }: ReefAddressIcon) => JSX.Element;

package/dist/components/common/Input/index.d.ts

@@ -1,5 +1,22 @@
 import React from 'react';
+interface Input {
+    value?: string;
+    disabled?: boolean;
+    maxLength?: number;
+    placeholder?: string;
+    className?: string;
+    onChange?: (value: string) => void;
+}
 export declare const Input: ({ value, disabled, maxLength, placeholder, className, onChange, }: Input) => JSX.Element;
+interface InputAmount {
+    amount: string;
+    disabled?: boolean;
+    min?: number;
+    max?: number;
+    placeholder?: string;
+    onAmountChange: (value: string) => void;
+    onValidityChange?: (error: InputAmountValidity) => void;
+}
 export interface InputAmountValidity {
     valid: boolean;
     errorMessage?: string;
@@ -7,6 +24,29 @@ export interface InputAmountValidity {
 export declare const InputAmount: ({ amount, onAmountChange, min, max, placeholder, disabled, onValidityChange, }: InputAmount) => JSX.Element;
 export declare const InputGroup: React.FC<React.PropsWithChildren<{}>>;
 export declare const InputTextGroup: React.FC<React.PropsWithChildren<{}>>;
+interface NumberInput {
+    min?: number;
+    max?: number;
+    step?: number;
+    value: string;
+    className?: string;
+    placeholder?: string;
+    onChange: (value: string) => void;
+    disableDecimals?: boolean;
+}
 export declare const NumberInput: ({ value, min, max, step, placeholder, onChange, disableDecimals, className, }: NumberInput) => JSX.Element;
+interface PercentageRangeAmount {
+    value: number;
+    disabled?: boolean;
+    onChange: (value: number) => void;
+}
 export declare const PercentageRangeAmount: ({ value, disabled, onChange, }: PercentageRangeAmount) => JSX.Element;
+interface CheckboxInput {
+    checked: boolean;
+    disabled?: boolean;
+    onChange: (value: any) => void;
+    id: string;
+    labelText?: string;
+}
 export declare const CheckboxInput: ({ checked, disabled, onChange, id, labelText, }: CheckboxInput) => JSX.Element;
+export {};

package/dist/components/common/Label/index.d.ts

@@ -1,5 +1,12 @@
 import React from 'react';
 export declare const Label: React.FC<React.PropsWithChildren<{}>>;
+interface ConfirmLabel {
+    title: string;
+    value: string;
+    titleSize?: string;
+    valueSize?: string;
+}
 export declare const ConfirmLabel: ({ title, value, titleSize, valueSize, }: ConfirmLabel) => JSX.Element;
 export declare const FormLabel: React.FC<React.PropsWithChildren<{}>>;
 export declare const TransactionWarningLabel: React.FC<React.PropsWithChildren<{}>>;
+export {};

package/dist/components/common/Loading/index.d.ts

@@ -1,5 +1,9 @@
 export declare const Loading: () => JSX.Element;
 export declare const LoadingButtonIcon: () => JSX.Element;
+interface LoadingWithText {
+    text: string;
+}
 export declare const LoadingWithText: ({ text }: LoadingWithText) => JSX.Element;
 export declare const LoadingComponent: ({ text }: LoadingWithText) => JSX.Element;
 export declare const LoadingButtonIconWithText: ({ text, }: LoadingWithText) => JSX.Element;
+export {};