@reef-chain/react-lib 2.0.0

package/dist/rpc/accounts.d.ts

@@ -0,0 +1,16 @@
+import type { InjectedAccountWithMeta, InjectedExtension } from '@polkadot/extension-inject/types';
+import { Provider, Signer } from '@reef-chain/evm-provider';
+import type { Signer as InjectedSigner } from '@polkadot/api/types';
+import type { InjectedAccount, InjectedAccountWithMeta as InjectedAccountWithMetaReef, InjectedExtension as InjectedExtensionReef } from '@reef-defi/extension-inject/types';
+import { BigNumber } from 'ethers';
+import { AccountJson } from '@reef-defi/extension-base/background/types';
+import { ReefSigner } from '../state/types';
+export declare const getAccountSigner: (address: string, source: string, provider: Provider, injSigner?: InjectedSigner) => Promise<Signer | undefined>;
+export declare const getReefCoinBalance: (address: string, provider: Provider) => Promise<BigNumber>;
+export declare const metaAccountToSigner: (account: InjectedAccountWithMeta | InjectedAccountWithMetaReef, provider: Provider, injSigner: InjectedSigner) => Promise<ReefSigner | undefined>;
+export declare const metaAccountsToSigners: (accounts: (InjectedAccountWithMeta | InjectedAccountWithMetaReef)[], provider: Provider, sign: InjectedSigner) => Promise<ReefSigner[]>;
+export declare const accountToSigner: (account: InjectedAccount, provider: Provider, sign: InjectedSigner, source: string) => Promise<ReefSigner>;
+export declare function accountJsonToMeta(acc: AccountJson, source?: string): InjectedAccountWithMeta;
+export declare const getExtensionSigners: (extensions: InjectedExtension[] | InjectedExtensionReef[], provider: Provider) => Promise<ReefSigner[]>;
+export declare const bindSigner: (signer: Signer) => Promise<void>;
+export declare const getSignerIdent: (signer: ReefSigner) => string;

package/dist/rpc/index.d.ts

@@ -0,0 +1,3 @@
+export * from './rpc';
+export * from './tokens';
+export * from './accounts';

package/dist/rpc/rpc.d.ts

@@ -0,0 +1,20 @@
+import { Signer } from '@reef-chain/evm-provider';
+import { BigNumber, Contract } from 'ethers';
+import { ReefSigner, Token } from '../state';
+export declare const checkIfERC20ContractExist: (address: string, signer: Signer) => Promise<{
+    name: string;
+    symbol: string;
+    decimals: number;
+} | undefined>;
+export declare const getREEF20Contract: (address: string, signer: Signer) => Promise<{
+    contract: Contract;
+    values: {
+        name: string;
+        symbol: string;
+        decimals: number;
+    };
+} | null>;
+export declare const contractToToken: (tokenContract: Contract, signer: ReefSigner) => Promise<Token>;
+export declare const balanceOf: (address: string, balanceAddress: string, signer: Signer) => Promise<BigNumber | null>;
+export declare const getReefswapRouter: (address: string, signer: Signer) => Contract;
+export declare const getReefswapFactory: (address: string, signer: Signer) => Contract;

package/dist/rpc/tokens.d.ts

@@ -0,0 +1,7 @@
+import { Signer } from '@reef-chain/evm-provider';
+import { BasicToken, Token, TokenWithAmount } from '../state';
+export declare const retrieveTokenAddresses: (tokens: Token[]) => string[];
+export declare const approveTokenAmount: (token: TokenWithAmount, routerAddress: string, signer: Signer) => Promise<void>;
+export declare const approveAmount: (from: string, to: string, amount: string, signer: Signer) => Promise<void>;
+export declare const loadToken: (address: string, signer: Signer, iconUrl?: string) => Promise<Token | null>;
+export declare const loadTokens: (addresses: BasicToken[], signer: Signer) => Promise<(Token | null)[]>;

package/dist/state/index.d.ts

@@ -0,0 +1,6 @@
+export * from './network';
+export * from './settings';
+export * from './token';
+export * from './nft';
+export * from './pool';
+export * from './types';

package/dist/state/network.d.ts

@@ -0,0 +1,26 @@
+import { Token } from './token';
+export type AvailableNetworks = 'mainnet' | 'testnet' | 'localhost';
+export interface Bond {
+    name: string;
+    description: string;
+    contractAddress: string;
+    validatorAddress: string;
+    stake: Token;
+    farm: Token;
+    apy: string;
+}
+export interface Network {
+    rpcUrl: string;
+    reefscanUrl: string;
+    verificationApiUrl: string;
+    factoryAddress: string;
+    routerAddress: string;
+    name: AvailableNetworks;
+    graphqlExplorerUrl: string;
+    graphqlDexsUrl: string;
+    genesisHash: string;
+    bonds: Bond[];
+}
+export declare const SS58_REEF = 42;
+export type Networks = Record<AvailableNetworks, Network>;
+export declare const availableNetworks: Networks;

package/dist/state/nft.d.ts

@@ -0,0 +1,14 @@
+import { ContractType, Token } from './token';
+export interface ERC721ContractData {
+    type: ContractType.ERC721;
+    name: string;
+    symbol: string;
+}
+export interface ERC1155ContractData {
+    type: ContractType.ERC1155;
+}
+export interface NFT extends Token {
+    nftId: string;
+    contractType: ContractType;
+    mimetype?: string;
+}

package/dist/state/pool.d.ts

@@ -0,0 +1,33 @@
+import { Token } from './token';
+export interface Pool {
+    token1: Token;
+    token2: Token;
+    decimals: number;
+    reserve1: string;
+    reserve2: string;
+    totalSupply: string;
+    poolAddress: string;
+    userPoolBalance: string;
+}
+export interface BasicPoolInfo {
+    address: string;
+    token1: string;
+    token2: string;
+    symbol1: string;
+    symbol2: string;
+    decimals1: number;
+    decimals2: number;
+}
+export interface LastPoolReserves extends BasicPoolInfo {
+    reserved1: string;
+    reserved2: string;
+}
+export interface PoolWithReserves extends LastPoolReserves {
+    name1: string;
+    name2: string;
+    iconUrl1: string;
+    iconUrl2: string;
+}
+export type TokenPrices = {
+    [tokenAddress: string]: number;
+};

package/dist/state/settings.d.ts

@@ -0,0 +1,15 @@
+export interface Settings {
+    gasLimit: string;
+    percentage: number;
+    deadline: number;
+}
+export declare const DEFAULT_SLIPPAGE_TOLERANCE = 0.8;
+export declare const MAX_SLIPPAGE_TOLERANCE = 0.5;
+export declare const DEFAULT_DEADLINE = 1;
+export declare const DEFAULT_GAS_LIMIT = "0.000003";
+export declare const REMOVE_DEFAULT_SLIPPAGE_TOLERANCE = 5;
+export declare const defaultSettings: () => Settings;
+export declare const resolveSettings: ({ deadline, gasLimit, percentage }: Settings, defaultPercentage?: number) => Settings;
+export declare const toGasLimitObj: (gasLimit: string) => {
+    gasLimit: string;
+};

package/dist/state/token.d.ts

@@ -0,0 +1,71 @@
+import { BigNumber } from 'ethers';
+import { BigNumber as BN } from 'bignumber.js';
+import { TokenPrices } from './pool';
+import { NFT } from './nft';
+export declare enum ContractType {
+    ERC20 = "ERC20",
+    ERC721 = "ERC721",
+    ERC1155 = "ERC1155",
+    other = "other"
+}
+export interface ERC20ContractData {
+    name: string;
+    symbol: string;
+    decimals: number;
+}
+export interface BasicToken {
+    name: string;
+    address: string;
+    iconUrl: string;
+}
+export interface Token extends BasicToken {
+    symbol: string;
+    balance: BigNumber;
+    decimals: number;
+}
+export interface TokenWithAmount extends Token {
+    amount: string;
+    price: number;
+    isEmpty: boolean;
+}
+export interface TokenState {
+    index: number;
+    amount: string;
+    price: number;
+}
+export interface NFTMetadata {
+    image?: string;
+    iconUrl?: string;
+    name?: string;
+    mimetype?: string;
+}
+export interface TransferExtrinsic {
+    blockId: string;
+    index: number;
+    hash: string;
+}
+export interface TokenTransfer {
+    from: string;
+    to: string;
+    inbound: boolean;
+    timestamp: number;
+    token: Token | NFT;
+    extrinsic: TransferExtrinsic;
+    url: string;
+}
+export declare const defaultTokenState: (index?: number) => TokenState;
+export declare const createEmptyToken: () => Token;
+export declare const createEmptyTokenWithAmount: (isEmpty?: boolean) => TokenWithAmount;
+export declare const toTokenAmount: (token: Token, state: TokenState) => TokenWithAmount;
+export declare function isNativeTransfer(token: Token): boolean;
+export declare const checkMinExistentialReefAmount: (token: TokenWithAmount, reefBalance: BigNumber) => {
+    valid: boolean;
+    message?: string | undefined;
+    maxTransfer: BigNumber;
+};
+export declare const ensureTokenAmount: (token: TokenWithAmount) => void;
+export declare const ensureExistentialReefAmount: (token: TokenWithAmount, reefBalance: BigNumber) => void;
+export declare const REEF_TOKEN: Token;
+export declare const reefTokenWithAmount: () => TokenWithAmount;
+export declare const getTokenPrice: (address: string, prices: TokenPrices) => BN;
+export declare const isNativeAddress: (toAddress: string) => boolean;

package/dist/state/types.d.ts

@@ -0,0 +1,76 @@
+import { Signer } from '@reef-chain/evm-provider';
+import { BigNumber } from 'ethers';
+import type { Signer as InjectedSigner } from '@polkadot/api/types';
+export interface ReefSigner {
+    name: string;
+    signer: Signer;
+    balance: BigNumber;
+    address: string;
+    evmAddress: string;
+    isEvmClaimed: boolean;
+    source: string;
+    genesisHash?: string;
+    sign: InjectedSigner;
+}
+export type Color = 'success' | 'danger' | 'warning';
+export type Notify = 'success' | 'error' | 'warning' | 'info';
+export type TokenSelector = 'token1' | 'token2';
+export type NotifyFun = (message: string, type?: Notify) => void;
+type OnTokenSelect = (address: string, type?: TokenSelector) => void;
+export type OptionalPick<T, K extends keyof T> = {
+    [P in keyof Pick<T, K>]?: T[P];
+};
+export type SelectPartial<T, K extends keyof T> = OptionalPick<T, K> | Pick<T, Exclude<keyof T, K>>;
+export interface DefaultOptions {
+    back: () => void;
+    notify: NotifyFun;
+    onTokenSelect: OnTokenSelect;
+    updateTokenState: () => Promise<void>;
+    onAddressChange: (address: string) => Promise<void>;
+}
+export type PartialOptions = Partial<DefaultOptions>;
+export type AddressToNumber<T> = {
+    [address: string]: T;
+};
+export declare const defaultOptions: DefaultOptions;
+interface Timeframe {
+    timeframe: string;
+}
+export interface BaseCandlestickData {
+    close: number;
+    high: number;
+    low: number;
+    open: number;
+}
+export interface BaseFeeData {
+    fee1: number;
+    fee2: number;
+}
+export interface BaseVolumeData {
+    amount1: number;
+    amount2: number;
+}
+export interface BaseReservedData {
+    reserved1: number;
+    reserved2: number;
+}
+export interface BasePriceData {
+    price: number;
+}
+export interface CandlestickData extends BaseCandlestickData, Timeframe {
+}
+export interface FeeData extends BaseFeeData, Timeframe {
+}
+export interface VolumeData extends BaseVolumeData, Timeframe {
+}
+export interface ReservedData extends BaseReservedData, Timeframe {
+}
+export interface PriceData extends BasePriceData, Timeframe {
+}
+export interface PoolData {
+    fee: FeeData[];
+    volume: VolumeData[];
+    reserves: ReservedData[];
+    price: PriceData[];
+}
+export {};

package/dist/store/actionTypes.d.ts

@@ -0,0 +1,16 @@
+export declare const SET_POOL = "SET_POOL";
+export declare const SET_FOCUS = "SET_FOCUS";
+export declare const SET_TOKEN1 = "SET_TOKEN1";
+export declare const SET_TOKEN2 = "SET_TOKEN2";
+export declare const SET_SETTINGS = "SET_SETTINGS";
+export declare const SWITCH_TOKENS = "SWITCH_TOKENS";
+export declare const SET_TOKEN1_AMOUNT = "SET_TOKEN1_AMOUNT";
+export declare const SET_TOKEN2_AMOUNT = "SET_TOKEN2_AMOUNT";
+export declare const SET_TOKEN_PRICES = "SET_TOKEN_PRICES";
+export declare const CLEAR_TOKEN_AMOUNTS = "CLEAR_TOKEN_AMOUNTS";
+export declare const SET_STATUS = "SET_STATUS";
+export declare const SET_COMPLETE_STATUS = "SET_COMPLETE_STATUS";
+export declare const SET_LOADING = "SET_LOADING";
+export declare const SET_VALIDITY = "SET_VALIDITY";
+export declare const SET_NEW_POOL_SUPPLY = "SET_NEW_POOL_SUPPLY";
+export declare const SET_PERCENTAGE = "SET_PERCENTAGE";

package/dist/store/actions/addLiquidity.d.ts

@@ -0,0 +1,21 @@
+import { Settings, Token } from '../../state';
+import { SET_NEW_POOL_SUPPLY } from '../actionTypes';
+import { ClearTokenAmounts, SetCompleteStatus, SetLoading, SetPercentage, SetPool, SetSettings, SetStatus, SetToken1, SetToken1Amount, SetToken2, SetToken2Amount, SetValidity } from './defaultActions';
+type SetNewPoolSupply = {
+    type: typeof SET_NEW_POOL_SUPPLY;
+    supply: string;
+};
+export declare const SetNewPoolSupplyAction: (supply: string) => SetNewPoolSupply;
+export type AddLiquidityActions = SetPool | SetStatus | SetLoading | SetToken1 | SetToken2 | SetSettings | SetPercentage | SetToken1Amount | SetToken2Amount | SetNewPoolSupply | SetCompleteStatus | ClearTokenAmounts | SetValidity;
+export interface AddLiquidityComponentActions {
+    back: () => void;
+    onAddLiquidity: () => Promise<void>;
+    selectToken1: (token: Token) => void;
+    selectToken2: (token: Token) => void;
+    setPercentage: (amount: number) => void;
+    setSettings: (settings: Settings) => void;
+    setToken1Amount: (amount: string) => void;
+    setToken2Amount: (amount: string) => void;
+    onAddressChange: (address: string) => Promise<void>;
+}
+export {};

package/dist/store/actions/defaultActions.d.ts

@@ -0,0 +1,70 @@
+import { AddressToNumber, Pool, Settings, Token, TokenWithAmount } from '../../state';
+import { CLEAR_TOKEN_AMOUNTS, SET_COMPLETE_STATUS, SET_LOADING, SET_PERCENTAGE, SET_POOL, SET_SETTINGS, SET_STATUS, SET_TOKEN1, SET_TOKEN1_AMOUNT, SET_TOKEN2, SET_TOKEN2_AMOUNT, SET_VALIDITY, SWITCH_TOKENS, SET_TOKEN_PRICES } from '../actionTypes';
+type SetAmount<T> = {
+    type: T;
+    amount: string;
+};
+type SetToken<T> = {
+    type: T;
+    token: TokenWithAmount;
+};
+type SetPrices<T> = {
+    type: T;
+    tokenPrices: AddressToNumber<number>;
+};
+export type SetToken1 = SetToken<typeof SET_TOKEN1>;
+export type SetToken2 = SetToken<typeof SET_TOKEN2>;
+export type SetToken1Amount = SetAmount<typeof SET_TOKEN1_AMOUNT>;
+export type SetToken2Amount = SetAmount<typeof SET_TOKEN2_AMOUNT>;
+export type SetTokenPrices = SetPrices<typeof SET_TOKEN_PRICES>;
+export type SetSettings = {
+    type: typeof SET_SETTINGS;
+    settings: Settings;
+};
+export type SwitchTokens = {
+    type: typeof SWITCH_TOKENS;
+};
+export type SetPool = {
+    type: typeof SET_POOL;
+    pool?: Pool;
+};
+export type SetLoading = {
+    type: typeof SET_LOADING;
+    loading: boolean;
+};
+export type SetCompleteStatus = {
+    type: typeof SET_COMPLETE_STATUS;
+    status: string;
+    isValid: boolean;
+    isLoading: boolean;
+};
+export type SetStatus = {
+    type: typeof SET_STATUS;
+    status: string;
+};
+export type SetValidity = {
+    type: typeof SET_VALIDITY;
+    isValid: boolean;
+};
+export type ClearTokenAmounts = {
+    type: typeof CLEAR_TOKEN_AMOUNTS;
+};
+export type SetPercentage = {
+    type: typeof SET_PERCENTAGE;
+    percentage: number;
+};
+export declare const setPercentageAction: (percentage: number) => SetPercentage;
+export declare const setPoolAction: (pool?: Pool) => SetPool;
+export declare const setToken1Action: (token: Token) => SetToken1;
+export declare const setToken2Action: (token: Token) => SetToken2;
+export declare const setSettingsAction: (settings: Settings) => SetSettings;
+export declare const setToken1AmountAction: (amount: string) => SetToken1Amount;
+export declare const setToken2AmountAction: (amount: string) => SetToken2Amount;
+export declare const setTokenPricesAction: (tokenPrices: AddressToNumber<number>) => SetTokenPrices;
+export declare const switchTokensAction: () => SwitchTokens;
+export declare const setLoadingAction: (loading: boolean) => SetLoading;
+export declare const setStatusAction: (status: string) => SetStatus;
+export declare const setCompleteStatusAction: (status: string, isValid: boolean, isLoading: boolean) => SetCompleteStatus;
+export declare const setValidityAction: (isValid: boolean) => SetValidity;
+export declare const clearTokenAmountsAction: () => ClearTokenAmounts;
+export {};

package/dist/store/actions/index.d.ts

@@ -0,0 +1,4 @@
+export * from './addLiquidity';
+export * from './defaultActions';
+export * from './swap';
+export * from './removeLiquidity';

package/dist/store/actions/removeLiquidity.d.ts

@@ -0,0 +1,9 @@
+import { Settings } from '../../state';
+import { SetCompleteStatus, SetLoading, SetPercentage, SetPool, SetSettings, SetStatus, SetToken1, SetToken2, SetValidity } from './defaultActions';
+export type RemoveLiquidityActions = SetLoading | SetPool | SetToken1 | SetToken2 | SetStatus | SetValidity | SetCompleteStatus | SetPercentage | SetSettings;
+export interface RemoveLiquidityComponentActions {
+    back: () => void;
+    onRemoveLiquidity: () => Promise<void>;
+    setPercentage: (percentage: number) => void;
+    setSettings: (settings: Settings) => void;
+}

package/dist/store/actions/swap.d.ts

@@ -0,0 +1,22 @@
+import { Settings, Token } from '../../state';
+import { SET_FOCUS } from '../actionTypes';
+import { ClearTokenAmounts, SetCompleteStatus, SetLoading, SetPercentage, SetPool, SetSettings, SetStatus, SetToken1, SetToken1Amount, SetToken2, SetToken2Amount, SetTokenPrices, SetValidity, SwitchTokens } from './defaultActions';
+export type SwapFocus = 'buy' | 'sell';
+type SetFocus = {
+    type: typeof SET_FOCUS;
+    focus: SwapFocus;
+};
+export type SwapAction = SetToken2 | SetPool | SetToken1 | SetFocus | SetStatus | SetLoading | SetValidity | SetSettings | SetPercentage | SwitchTokens | SetToken2Amount | SetCompleteStatus | ClearTokenAmounts | SetToken1Amount | SetTokenPrices;
+export declare const setFocusAction: (focus: SwapFocus) => SetFocus;
+export interface SwapComponentActions {
+    onSwap: () => Promise<void>;
+    onSwitch: () => void;
+    selectToken1: (token: Token) => void;
+    selectToken2: (token: Token) => void;
+    setSettings: (settings: Settings) => void;
+    setPercentage: (amount: number) => void;
+    setToken1Amount: (amount: string) => void;
+    setToken2Amount: (amount: string) => void;
+    onAddressChange: (address: string) => Promise<void>;
+}
+export {};

package/dist/store/index.d.ts

@@ -0,0 +1,2 @@
+export * from './actions';
+export * from './reducers';

package/dist/store/reducers/addLiquidity.d.ts

@@ -0,0 +1,15 @@
+import { Pool, Settings, TokenWithAmount } from '../../state';
+import { AddLiquidityActions } from '../actions/addLiquidity';
+export interface AddLiquidityState {
+    status: string;
+    percentage: number;
+    isValid: boolean;
+    settings: Settings;
+    isLoading: boolean;
+    token2: TokenWithAmount;
+    token1: TokenWithAmount;
+    pool: Pool | undefined;
+    newPoolSupply: string;
+}
+export declare const initialAddLiquidityState: AddLiquidityState;
+export declare const addLiquidityReducer: (state: AddLiquidityState | undefined, action: AddLiquidityActions) => AddLiquidityState;

package/dist/store/reducers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './addLiquidity';
+export * from './swap';
+export * from './removeLiquidity';

package/dist/store/reducers/removeLiquidity.d.ts

@@ -0,0 +1,14 @@
+import { Pool, Settings, TokenWithAmount } from '../../state';
+import { RemoveLiquidityActions } from '../actions';
+export interface RemoveLiquidityState {
+    token1: TokenWithAmount;
+    token2: TokenWithAmount;
+    status: string;
+    percentage: number;
+    isLoading: boolean;
+    isValid: boolean;
+    pool?: Pool;
+    settings: Settings;
+}
+export declare const initialRemoveLiquidityState: RemoveLiquidityState;
+export declare const removeLiquidityReducer: (state: RemoveLiquidityState | undefined, action: RemoveLiquidityActions) => RemoveLiquidityState;

package/dist/store/reducers/swap.d.ts

@@ -0,0 +1,15 @@
+import { Pool, Settings, TokenWithAmount } from '../../state';
+import { SwapAction, SwapFocus } from '../actions/swap';
+export interface SwapState {
+    status: string;
+    focus: SwapFocus;
+    percentage: number;
+    isValid: boolean;
+    settings: Settings;
+    isLoading: boolean;
+    token2: TokenWithAmount;
+    token1: TokenWithAmount;
+    pool: Pool | undefined;
+}
+export declare const initialSwapState: SwapState;
+export declare const swapReducer: (state: SwapState | undefined, action: SwapAction) => SwapState;

package/dist/utils/bindUtil.d.ts

@@ -0,0 +1,10 @@
+import { Provider } from '@reef-chain/evm-provider';
+import { ReefSigner } from '../state';
+import { TxStatusHandler } from './transactionUtil';
+export declare const bindEvmAddress: (signer: ReefSigner, provider: Provider, onTxChange?: TxStatusHandler) => string;
+export declare const bindCustomEvmAddress: (signer: ReefSigner, provider: Provider, evmAddress: string, signature: string, onTxChange?: TxStatusHandler) => string;
+export declare const signBindEvmAddress: (signer: ReefSigner) => Promise<{
+    evmAddress?: string;
+    signature?: string;
+    error?: string;
+}>;

package/dist/utils/dataWithProgress.d.ts

@@ -0,0 +1,8 @@
+export declare enum DataProgress {
+    LOADING = "DataProgress_LOADING",
+    NO_DATA = "DataProgress_NO_DATA"
+}
+export type DataWithProgress<T> = T | DataProgress;
+export declare const isDataSet: (dataOrProgress: DataWithProgress<any>) => boolean;
+export declare const getData: <T>(dataOrProgress: DataWithProgress<T>) => T | undefined;
+export declare const getProgress: (dataOrProgress: DataWithProgress<any>) => DataProgress | undefined;

package/dist/utils/index.d.ts

@@ -0,0 +1,11 @@
+export * from './math';
+export * from './utils';
+export * from './dataWithProgress';
+export * from './rpcErrorMessageHandler';
+export * from '../graphql/gql';
+export * from './tokenUtil';
+export * from './transactionUtil';
+export * from './bindUtil';
+export * from './providerUtil';
+export * from './modalUtil';
+export * from './modalUtil';

package/dist/utils/math.d.ts

@@ -0,0 +1,55 @@
+import { BigNumber } from 'ethers';
+import { NFT, Pool, Token, TokenWithAmount } from '../state';
+export declare const transformAmount: (decimals: number, amount: string) => string;
+export declare const assertAmount: (amount?: string) => string;
+export declare const convert2Normal: (decimals: number, inputAmount: string) => number;
+interface CalculateAmount {
+    decimals: number;
+    amount: string;
+}
+export declare const calculateAmount: ({ decimals, amount, }: CalculateAmount) => string;
+export declare const calculateAmountWithPercentage: ({ amount: oldAmount, decimals }: CalculateAmount, percentage: number) => string;
+export declare const minimumReceiveAmount: ({ amount }: CalculateAmount, percentage: number) => number;
+interface CalculateUsdAmount extends CalculateAmount {
+    price: number;
+}
+export declare const calculateUsdAmount: ({ amount, price, }: CalculateUsdAmount) => number;
+export declare const calculateDeadline: (minutes: number) => number;
+export declare const calculateBalance: ({ balance, decimals }: Token) => string;
+export declare const calculatePoolSupply: (token1: TokenWithAmount, token2: TokenWithAmount, pool?: Pool) => number;
+export declare const removeSupply: (percentage: number, supply?: string, decimals?: number) => number;
+export declare const removePoolTokenShare: (percentage: number, token?: Token) => string;
+export declare const showRemovePoolTokenShare: (percentage: number, token?: Token) => string;
+export declare const removeUserPoolSupply: (percentage: number, pool?: Pool) => number;
+export declare const convertAmount: (amount: string, fromPrice: number, toPrice: number) => number;
+export declare const calculatePoolRatio: (pool?: Pool, first?: boolean) => number;
+export declare const calculatePoolShare: (pool?: Pool) => number;
+interface ToBalance {
+    balance: BigNumber;
+    decimals: number;
+}
+interface ShowBalance extends ToBalance {
+    name: string;
+    symbol?: string;
+}
+export declare const showBalance: ({ decimals, balance, name, symbol, }: ShowBalance | Token | NFT, decimalPoints?: number) => string;
+export declare const toBalance: ({ balance, decimals }: ToBalance) => number;
+export declare const toUnits: ({ balance, decimals }: ToBalance) => string;
+export declare const exponentNrSplit: (numberVal: string) => {
+    isExponent: boolean;
+    split: string[];
+};
+export declare const noExponents: (valueNr: string) => string;
+export declare const toDecimalPlaces: (value: string, maxDecimalPlaces: number) => string;
+export declare const poolRatio: ({ token1, token2 }: Pool) => number;
+export declare const ensureAmount: (token: TokenWithAmount) => void;
+export declare const getOutputAmount: (token: TokenWithAmount, pool: Pool) => number;
+export declare const getInputAmount: (token: TokenWithAmount, pool: Pool) => number;
+export declare const calculateImpactPercentage: (sell: TokenWithAmount, buy: TokenWithAmount) => number;
+export declare const getHashSumLastNr: (address: string) => number;
+export declare const toHumanAmount: (amount: string) => string;
+export declare const formatAmount: (amount: number, decimals: number) => string;
+export declare const mean: (arr: number[]) => number;
+export declare const variance: (arr: number[]) => number;
+export declare const std: (arr: number[]) => number;
+export {};

package/dist/utils/modalUtil.d.ts

@@ -0,0 +1,2 @@
+export declare const openModal: (id: string) => void;
+export declare const closeModal: (id: string) => void;

package/dist/utils/nftUtil.d.ts

@@ -0,0 +1,7 @@
+import { Observable } from 'rxjs';
+import { Signer } from '@reef-chain/evm-provider';
+import { NFT } from '../state';
+export declare const toIpfsProviderUrl: (ipfsUriStr: string, ipfsUrlResolver?: ipfsUrlResolverFn) => string | null;
+export declare const getResolveNftPromise: (nft: NFT | null, signer: Signer, ipfsUrlResolver?: ipfsUrlResolverFn) => Promise<NFT | null>;
+export declare const resolveNftImageLinks: (nfts: (NFT | null)[], signer: Signer, ipfsUrlResolver?: ipfsUrlResolverFn) => Observable<(NFT | null)[]>;
+export type ipfsUrlResolverFn = (ipfsHash: any) => string;

package/dist/utils/providerUtil.d.ts

@@ -0,0 +1,3 @@
+import { Provider } from '@reef-chain/evm-provider';
+export declare function initProvider(providerUrl: string): Promise<Provider>;
+export declare function disconnectProvider(provider: Provider): Promise<void>;

package/dist/utils/rpcErrorMessageHandler.d.ts

@@ -0,0 +1,4 @@
+import { FrameSystemEventRecord } from '@polkadot/types/lookup';
+export type Event = FrameSystemEventRecord;
+export declare const errorHandler: (message: string) => string;
+export declare const captureError: (events: Event[]) => string | undefined;

package/dist/utils/tokenUtil.d.ts

@@ -0,0 +1,12 @@
+import { BigNumber } from 'ethers';
+import { BigNumber as BN } from 'bignumber.js';
+import { DataWithProgress } from './dataWithProgress';
+import { Token, TokenWithAmount } from '../state';
+import { PoolReserves } from '../graphql/pools';
+export declare const calculateTokenPrice: (token: Token, pools: PoolReserves[], reefPrice: DataWithProgress<number>) => DataWithProgress<number>;
+export declare const calculateBalanceValue: ({ price, balance, }: {
+    price: DataWithProgress<number>;
+    balance: BigNumber;
+} | TokenWithAmount) => DataWithProgress<number>;
+export declare const toCurrencyFormat: (value: number, options?: {}) => string;
+export declare const normalize: (amount: string | number, decimals: number) => BN;