@ref-finance/ref-sdk 1.1.3

package/dist/ref.d.ts

@@ -0,0 +1,19 @@
+import { Near } from 'near-api-js';
+import { TokenMetadata, FTStorageBalance, RefFiViewFunctionOptions } from './types';
+import { Transaction } from './types';
+export declare const REPLACE_TOKENS: string[];
+export declare const near: Near;
+export declare const refFiViewFunction: ({ methodName, args, }: RefFiViewFunctionOptions) => Promise<any>;
+export declare const ftViewFunction: (tokenId: string, { methodName, args }: RefFiViewFunctionOptions) => Promise<any>;
+export declare const ftGetStorageBalance: (tokenId: string, AccountId: string) => Promise<FTStorageBalance | null>;
+export declare const ftGetBalance: (tokenId: string, AccountId: string) => Promise<any>;
+export declare const getTotalPools: () => Promise<any>;
+export declare const ftGetTokenMetadata: (id: string, tag?: string | undefined) => Promise<TokenMetadata>;
+export declare const ftGetTokensMetadata: (tokenIds: string[], allTokens: Record<string, TokenMetadata>) => Promise<Record<string, TokenMetadata>>;
+export declare const getGlobalWhitelist: () => Promise<string[]>;
+export declare const getUserRegisteredTokens: (AccountId?: string | undefined) => Promise<string[]>;
+export declare const getAccountNearBalance: (accountId: string) => Promise<string>;
+export declare const nearDepositTransaction: (amount: string) => Transaction;
+export declare const nearWithdrawTransaction: (amount: string) => Transaction;
+export declare const refDCLSwapViewFunction: ({ methodName, args, }: RefFiViewFunctionOptions) => Promise<any>;
+export declare const DCLSwapGetStorageBalance: (tokenId: string, AccountId: string) => Promise<any>;

package/dist/stable-swap.d.ts

@@ -0,0 +1,5 @@
+import { StablePool } from './types';
+export declare const calc_d: (amp: number, c_amounts: number[]) => number;
+export declare const calc_y: (amp: number, x_c_amount: number, current_c_amounts: number[], index_x: number, index_y: number) => number;
+export declare const calc_swap: (amp: number, in_token_idx: number, in_c_amount: number, out_token_idx: number, old_c_amounts: number[], trade_fee: number) => number[];
+export declare const getSwappedAmount: (tokenInId: string, tokenOutId: string, amountIn: string, stablePool: StablePool, STABLE_LP_TOKEN_DECIMALS: number) => number[];

package/dist/swap-widget/components.d.ts

@@ -0,0 +1,90 @@
+/// <reference types="react" />
+import { TokenMetadata, EstimateSwapView, Pool } from '../types';
+import './style.css';
+interface TokenAmountProps {
+    balance?: string;
+    reloading?: JSX.Element;
+    token?: TokenMetadata;
+    onSelectToken: () => void;
+    amount: string;
+    onChangeAmount?: (amount: string) => void;
+    price?: string;
+    onForceUpdate?: () => void;
+    poolFetchingState?: 'loading' | 'end';
+}
+export declare const getPriceImpact: (value: string, tokenIn: TokenMetadata, tokenInAmount: string) => JSX.Element;
+export declare const SmartRouteV2: ({ tokens: tokensRaw, p, pools, }: {
+    tokens: TokenMetadata[];
+    p: string;
+    pools: Pool[];
+}) => JSX.Element | null;
+export declare const DetailView: ({ tokenIn, tokenOut, rate, fee, minReceived, amountIn, amountOut, priceImpact, estimates, }: {
+    tokenIn: TokenMetadata | undefined;
+    tokenOut: TokenMetadata | undefined;
+    rate: string;
+    fee: number;
+    minReceived: string;
+    amountIn: string;
+    amountOut: string;
+    priceImpact: string;
+    estimates: EstimateSwapView[];
+}) => JSX.Element | null;
+export declare const HalfAndMaxAmount: ({ max, onChangeAmount, token, amount, }: {
+    max: string;
+    token: TokenMetadata;
+    onChangeAmount: (amount: string) => void;
+    amount: string;
+}) => JSX.Element;
+export declare const TokenAmount: (props: TokenAmountProps) => JSX.Element;
+export declare const SlippageSelector: ({ slippageTolerance, onChangeSlippageTolerance, showSlip, setShowSlip, }: {
+    slippageTolerance: number;
+    onChangeSlippageTolerance: (slippageTolerance: number) => void;
+    showSlip: boolean;
+    setShowSlip: (showSlip: boolean) => void;
+}) => JSX.Element | null;
+interface TokenListProps {
+    tokens: TokenMetadata[];
+    onClick: (token: TokenMetadata) => void;
+    balances: {
+        [tokenId: string]: string;
+    };
+    tokenPriceList: Record<string, any> | null;
+    starList: string[];
+    setStarList: (starList: string[]) => void;
+    onDelete: (token: TokenMetadata) => void;
+}
+export declare const TokenListTable: ({ tokens, onClick, balances, tokenPriceList, starList, setStarList, onDelete, }: TokenListProps) => JSX.Element | null;
+export declare const TokenSelector: ({ onSelect, width, tokens, onClose, AccountId, balances, className, }: {
+    onSelect: (token: TokenMetadata) => void;
+    width: string;
+    tokens: TokenMetadata[];
+    onClose: () => void;
+    AccountId: string;
+    balances: {
+        [tokenId: string]: string;
+    };
+    className?: string | undefined;
+}) => JSX.Element;
+export declare const Slider: ({ showSlip, setShowSlip, }: {
+    showSlip: boolean;
+    setShowSlip: (show: boolean) => void;
+}) => JSX.Element;
+export declare const RefIcon: (props: any) => JSX.Element;
+export declare const Loading: () => JSX.Element;
+export declare const Warning: () => JSX.Element;
+export declare const Success: () => JSX.Element;
+export declare const RouterIcon: () => JSX.Element;
+export declare const Notification: ({ state, tx, detail, open, setOpen, setState, }: {
+    state?: "success" | "fail" | null | undefined;
+    setState?: ((state: 'success' | 'fail' | null) => void) | undefined;
+    tx?: string | undefined;
+    detail?: string | undefined;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+}) => JSX.Element | null;
+export declare const ArrowRight: () => JSX.Element;
+export declare const AccountButton: ({ AccountId, onDisConnect, }: {
+    AccountId: string;
+    onDisConnect: () => void;
+}) => JSX.Element | null;
+export {};

package/dist/swap-widget/constant.d.ts

@@ -0,0 +1,25 @@
+export declare const REF_WIDGET_STAR_TOKEN_LIST_KEY = "REF_WIDGET_STAR_TOKEN_LIST_VALUE";
+export declare const REF_WIDGET_ALL_TOKENS_LIST_KEY = "REF_WIDGET_ALL_TOKENS_LIST_VALUE";
+export declare const REF_WIDGET_SWAP_IN_KEY = "REF_WIDGET_SWAP_IN_VALUE";
+export declare const REF_WIDGET_SWAP_OUT_KEY = "REF_WIDGET_SWAP_OUT_VALUE";
+export declare const REF_WIDGET_SWAP_DETAIL_KEY = "REF_WIDGET_SWAP_DETAIL_VALUE";
+export declare const DEFAULT_START_TOKEN_LIST_TESTNET: string[];
+export declare const DEFAULT_START_TOKEN_LIST_MAINNET: string[];
+export declare const DEFAULT_START_TOKEN_LIST: string[];
+export interface Theme {
+    container: string;
+    buttonBg: string;
+    primary: string;
+    secondary: string;
+    borderRadius: string;
+    fontFamily: string;
+    hover: string;
+    active: string;
+    secondaryBg: string;
+    borderColor: string;
+    iconDefault: string;
+    iconHover: string;
+    refIcon?: string;
+}
+export declare const defaultTheme: Theme;
+export declare const defaultDarkModeTheme: Theme;

package/dist/swap-widget/defaultTokenList.d.ts

@@ -0,0 +1,120 @@
+export declare const DefaultTestnetTokenList: ({
+    spec: string;
+    name: string;
+    symbol: string;
+    icon: null;
+    reference: null;
+    reference_hash: null;
+    decimals: number;
+    id: string;
+} | {
+    spec: string;
+    name: string;
+    symbol: string;
+    icon: string;
+    reference: null;
+    reference_hash: null;
+    decimals: number;
+    id: string;
+} | {
+    spec: string;
+    name: string;
+    symbol: string;
+    icon: string;
+    reference: string;
+    reference_hash: null;
+    decimals: number;
+    id: string;
+})[];
+export declare const DefaultMainnetTokenList: ({
+    spec: string;
+    name: string;
+    symbol: string;
+    icon: null;
+    reference: null;
+    reference_hash: null;
+    decimals: number;
+    id: string;
+} | {
+    spec: string;
+    name: string;
+    symbol: string;
+    icon: string;
+    reference: string;
+    reference_hash: string;
+    decimals: number;
+    id: string;
+} | {
+    spec: string;
+    name: string;
+    symbol: string;
+    icon: null;
+    reference: string;
+    reference_hash: string;
+    decimals: number;
+    id: string;
+} | {
+    spec: string;
+    name: string;
+    symbol: string;
+    icon: string;
+    reference: null;
+    reference_hash: null;
+    decimals: number;
+    id: string;
+} | {
+    spec: string;
+    name: string;
+    symbol: string;
+    icon: string;
+    reference: string;
+    reference_hash: null;
+    decimals: number;
+    id: string;
+})[];
+export declare function getDefaultTokenList(env?: string | undefined): ({
+    spec: string;
+    name: string;
+    symbol: string;
+    icon: null;
+    reference: null;
+    reference_hash: null;
+    decimals: number;
+    id: string;
+} | {
+    spec: string;
+    name: string;
+    symbol: string;
+    icon: string;
+    reference: string;
+    reference_hash: string;
+    decimals: number;
+    id: string;
+} | {
+    spec: string;
+    name: string;
+    symbol: string;
+    icon: null;
+    reference: string;
+    reference_hash: string;
+    decimals: number;
+    id: string;
+} | {
+    spec: string;
+    name: string;
+    symbol: string;
+    icon: string;
+    reference: null;
+    reference_hash: null;
+    decimals: number;
+    id: string;
+} | {
+    spec: string;
+    name: string;
+    symbol: string;
+    icon: string;
+    reference: string;
+    reference_hash: null;
+    decimals: number;
+    id: string;
+})[];

package/dist/swap-widget/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { SwapWidgetProps } from './types';
+import './style.css';
+export declare const SwapWidget: (props: SwapWidgetProps) => JSX.Element;

package/dist/swap-widget/state.d.ts

@@ -0,0 +1,49 @@
+import React from 'react';
+import { EstimateSwapView, Pool, StablePool, TokenMetadata, Transaction } from '../types';
+import { SwapOptions } from '../v1-swap/swap';
+import { SwapOutParams } from './types';
+import { Theme } from './constant';
+export declare const ThemeContext: React.Context<Theme>;
+export declare const ThemeContextProvider: React.FC<{
+    customTheme: Theme | undefined;
+}>;
+export declare const estimateValidator: (swapTodos: EstimateSwapView[], tokenIn: TokenMetadata, parsedAmountIn: string, tokenOut: TokenMetadata) => boolean;
+export declare const useAllTokens: ({ reload }: {
+    reload?: boolean | undefined;
+}) => {
+    tokens: Record<string, TokenMetadata> | undefined;
+    tokensLoading: boolean;
+};
+export declare const useTokensIndexer: ({ defaultTokenList, AccountId, }: {
+    defaultTokenList?: TokenMetadata[] | undefined;
+    AccountId?: string | undefined;
+}) => {
+    tokens: TokenMetadata[];
+    tokenLoading: boolean;
+};
+export declare const useRefPools: (refreshTrigger: boolean) => {
+    allPools: {
+        simplePools: Pool[];
+        ratedPools: Pool[];
+        unRatedPools: Pool[];
+    };
+    allStablePools: StablePool[];
+    poolFetchingState: "loading" | "end";
+};
+export declare const useSwap: (params: {
+    tokenIn?: TokenMetadata | undefined;
+    tokenOut?: TokenMetadata | undefined;
+    amountIn: string;
+    simplePools: Pool[];
+    options?: SwapOptions | undefined;
+} & {
+    slippageTolerance: number;
+    refreshTrigger: boolean;
+    onSwap: (transactionsRef: Transaction[]) => void;
+    AccountId?: string | undefined;
+    poolFetchingState?: "loading" | "end" | undefined;
+}) => SwapOutParams;
+export declare const TokenPriceContext: React.Context<Record<string, any> | null>;
+export declare const useTokenPriceList: () => Record<string, any>;
+export declare const TokenPriceContextProvider: React.FC;
+export declare const useTokenBalnces: (tokens: TokenMetadata[], AccountId: string) => Record<string, string>;

package/dist/swap-widget/types.d.ts

@@ -0,0 +1,40 @@
+import { EstimateSwapView } from '../types';
+import { Transaction } from '../types';
+import { TokenMetadata } from '../../dist/types';
+import { Theme } from './constant';
+export interface SwapWidgetProps {
+    theme?: Theme;
+    defaultTokenList?: TokenMetadata[];
+    onSwap: (transactionsRef: Transaction[]) => void;
+    onDisConnect: () => void;
+    width: string;
+    height?: string;
+    enableSmartRouting?: boolean;
+    className?: string;
+    darkMode?: boolean;
+    connection: {
+        AccountId: string;
+        isSignedIn: boolean;
+    };
+    defaultTokenIn?: string;
+    defaultTokenOut?: string;
+    transactionState?: {
+        state: 'success' | 'fail' | null;
+        setState: (state: 'success' | 'fail' | null) => void;
+        tx?: string;
+        detail?: string;
+    };
+    onConnect: () => void;
+}
+export interface SwapOutParams {
+    amountOut: string;
+    minAmountOut: string;
+    rate: string;
+    fee: number;
+    estimates: EstimateSwapView[];
+    makeSwap: () => void;
+    canSwap: boolean;
+    swapError: Error | null;
+    setAmountOut: (amount: string) => void;
+    isEstimating: boolean;
+}

package/dist/types.d.ts

@@ -0,0 +1,129 @@
+import Big from 'big.js';
+import { PoolMode } from './v1-swap/swap';
+export interface TokenMetadata {
+    id: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    icon: string;
+}
+export declare type PoolKind = 'SIMPLE_POOL' | 'STABLE_SWAP' | 'RATED_SWAP';
+export declare type StablePoolKind = 'STABLE_SWAP' | 'RATED_SWAP';
+export interface PoolRPCView {
+    id: number;
+    token_account_ids: string[];
+    token_symbols: string[];
+    amounts: string[];
+    total_fee: number;
+    shares_total_supply: string;
+    tvl: number;
+    token0_ref_price: string;
+    share: string;
+    decimalsHandled?: boolean;
+    tokens_meta_data?: TokenMetadata[];
+    pool_kind?: PoolKind;
+}
+export interface Pool {
+    id: number;
+    tokenIds: string[];
+    supplies: {
+        [key: string]: string;
+    };
+    fee: number;
+    total_fee?: number;
+    shareSupply: string;
+    tvl: number;
+    token0_ref_price: string;
+    partialAmountIn?: string;
+    Dex?: string;
+    pool_kind?: PoolKind;
+    rates?: {
+        [id: string]: string;
+    };
+}
+export interface StablePool {
+    id: number;
+    token_account_ids: string[];
+    decimals: number[];
+    amounts: string[];
+    c_amounts: string[];
+    total_fee: number;
+    shares_total_supply: string;
+    amp: number;
+    rates: string[];
+    pool_kind: StablePoolKind;
+    partialAmountIn?: string;
+}
+export interface SmartRoutingInputPool {
+    id: number;
+    token1Id: string;
+    token2Id: string;
+    token1Supply: string;
+    token2Supply: string;
+    fee: number;
+    shares: string;
+    token0_price: string;
+}
+export interface RoutePool {
+    amounts: string[];
+    fee: number;
+    id: number;
+    shares: string;
+    token0_ref_price: string;
+    token1Id: string;
+    token1Supply: string;
+    token2Id: string;
+    token2Supply: string;
+    updateTime: number;
+    partialAmountIn?: string | number | Big;
+    gamma_bps?: Big;
+    tokenIds?: string[];
+    x?: string;
+    y?: string;
+}
+export interface EstimateSwapView {
+    estimate: string;
+    pool: Pool;
+    intl?: any;
+    dy?: string;
+    status?: PoolMode;
+    noFeeAmountOut?: string;
+    inputToken?: string;
+    outputToken?: string;
+    nodeRoute?: string[];
+    tokens?: TokenMetadata[];
+    routeInputToken?: string;
+    route?: RoutePool[];
+    allRoutes?: RoutePool[][];
+    allNodeRoutes?: string[][];
+    totalInputAmount?: string;
+}
+export interface RefFiViewFunctionOptions {
+    methodName: string;
+    args?: object;
+}
+export interface RefFiFunctionCallOptions extends RefFiViewFunctionOptions {
+    gas?: string;
+    amount?: string;
+}
+export interface Transaction {
+    receiverId: string;
+    functionCalls: RefFiFunctionCallOptions[];
+}
+export interface TransformedTransaction {
+    signerId: string;
+    receiverId: string;
+    actions: {
+        type: string;
+        params: {
+            methodName: string;
+            args: object;
+            gas: string;
+            deposit: string;
+        };
+    }[];
+}
+export interface FTStorageBalance {
+    total: string;
+    available: string;
+}

package/dist/utils.d.ts

@@ -0,0 +1,92 @@
+import { Pool, PoolRPCView, StablePool, SmartRoutingInputPool, Transaction, EstimateSwapView } from './types';
+import BN from 'bn.js';
+import * as math from 'mathjs';
+import Big from 'big.js';
+import { SignAndSendTransactionsParams } from '@near-wallet-selector/core/lib/wallet';
+import { TokenMetadata } from './types';
+export declare const parsePool: (pool: PoolRPCView, id?: number | undefined) => Pool;
+export declare const poolFormatter: (pool: Pool) => SmartRoutingInputPool;
+export declare const isStablePoolToken: (stablePools: StablePool[], tokenId: string | Number) => boolean;
+export declare const isStablePool: (stablePools: StablePool[], poolId: string | number) => boolean;
+export declare const getStablePoolDecimal: (stablePool: StablePool) => 18 | 24;
+export declare const round: (decimals: number, minAmountOut: string) => string;
+export declare const convertToPercentDecimal: (percent: number) => number;
+export declare const percentOf: (percent: number, num: number | string) => any;
+export declare const percentLess: (percent: number, num: number | string) => string;
+export declare const getGas: (gas: string | undefined) => BN;
+export declare const getAmount: (amount: string) => BN;
+export declare const ONLY_ZEROS: RegExp;
+export declare const toReadableNumber: (decimals: number, number?: string) => string;
+export declare const toNonDivisibleNumber: (decimals: number, number: string) => string;
+export declare const scientificNotationToString: (strParam: string) => string;
+export declare const formatWithCommas: (value: string) => string;
+export declare const toPrecision: (number: string, precision: number, withCommas?: boolean, atLeastOne?: boolean) => string;
+export declare const transformTransactions: (transactions: Transaction[], AccountId: string) => {
+    signerId: string;
+    receiverId: string;
+    actions: {
+        type: string;
+        params: {
+            methodName: string;
+            args: object;
+            gas: string;
+            deposit: string;
+        };
+    }[];
+}[];
+export declare const WalletSelectorTransactions: (transactions: Transaction[], AccountId: string) => SignAndSendTransactionsParams;
+export declare const separateRoutes: (actions: EstimateSwapView[], outputToken: string) => EstimateSwapView[][];
+export declare const calculateExchangeRate: (from: string, to: string, precision?: number | undefined) => string;
+export declare const getAvgFee: (estimates: EstimateSwapView[], outputToken: string, parsedAmountIn: string) => number;
+export declare const getAccountName: (AccountId: string) => string;
+export declare const symbolsArr: string[];
+export declare const multiply: (factor1: string, factor2: string) => string;
+export declare const toInternationalCurrencySystemLongString: (labelValue: string, percent?: number | undefined) => string;
+export declare const percentOfBigNumber: (percent: number, num: number | string, precision: number) => string;
+export declare const toRealSymbol: (symbol: string) => string;
+export declare const calculateFeeCharge: (fee: number, total: string) => number | number[] | number[][] | math.Matrix | math.Fraction | math.BigNumber | math.Complex;
+export declare const calculateFeePercent: (fee: number) => number;
+export declare function getExpectedOutputFromSwapTodos(estimates: EstimateSwapView[], outputToken: string): Big;
+export declare const calculateAmountReceived: (pool: Pool, amountIn: string, tokenIn: TokenMetadata, tokenOut: TokenMetadata) => import("decimal.js").default;
+export declare const calculateMarketPrice: (pool: Pool, tokenIn: TokenMetadata, tokenOut: TokenMetadata) => any;
+export declare const calculateSmartRoutingPriceImpact: (tokenInAmount: string, swapTodos: EstimateSwapView[], tokenIn: TokenMetadata, tokenMid: TokenMetadata, tokenOut: TokenMetadata, stablePools: StablePool[]) => string;
+export declare const percent: (numerator: string, denominator: string) => any;
+export declare const calcStableSwapPriceImpact: (from: string, to: string, marketPrice?: string) => string;
+export declare const calculatePriceImpact: (pools: Pool[], tokenIn: TokenMetadata, tokenOut: TokenMetadata, tokenInAmount: string) => string;
+export declare function calculateSmartRoutesV2PriceImpact(actions: any, outputToken: string, tokenInPara: TokenMetadata, stablePools: StablePool[]): string;
+export declare const getPriceImpact: ({ estimates, tokenIn, tokenOut, amountIn, amountOut, stablePools, }: {
+    estimates: EstimateSwapView[];
+    tokenIn: TokenMetadata;
+    tokenOut: TokenMetadata;
+    amountIn: string;
+    amountOut: string;
+    stablePools: StablePool[];
+}) => string;
+export declare const subtraction: (initialValue: string, toBeSubtract: string) => string;
+export declare function getPoolAllocationPercents(pools: Pool[]): string[];
+export declare const isMobile: () => boolean;
+export declare function divide(numerator: string, denominator: string): string;
+export declare const getMax: (id: string, amount: string) => string;
+export declare function getPointByPrice(pointDelta: number, price: string, decimalRate: number, noNeedSlot?: boolean): number;
+export declare const feeToPointDelta: (fee: number) => 1 | 8 | 40 | 200;
+export declare const priceToPoint: ({ tokenA, tokenB, amountA, amountB, fee, }: {
+    tokenA: TokenMetadata;
+    tokenB: TokenMetadata;
+    amountA: string;
+    amountB: string;
+    fee: number;
+}) => number;
+export declare const pointToPrice: ({ tokenA, tokenB, point, }: {
+    tokenA: TokenMetadata;
+    tokenB: TokenMetadata;
+    point: number;
+}) => string;
+export declare const registerAccountOnToken: (AccountId: string) => {
+    methodName: string;
+    args: {
+        registration_only: boolean;
+        account_id: string;
+    };
+    gas: string;
+    amount: string;
+};

package/dist/v1-swap/instantSwap.d.ts

@@ -0,0 +1,9 @@
+import { TokenMetadata, EstimateSwapView, Transaction } from '../types';
+export declare const instantSwap: ({ tokenIn, tokenOut, amountIn, slippageTolerance, swapTodos, AccountId, }: {
+    tokenIn: TokenMetadata;
+    tokenOut: TokenMetadata;
+    amountIn: string;
+    slippageTolerance: number;
+    swapTodos: EstimateSwapView[];
+    AccountId: string;
+}) => Promise<Transaction[]>;

package/dist/v1-swap/parallelSwapLogic.d.ts

@@ -0,0 +1,84 @@
+import Big from 'big.js';
+import { Pool } from '../types';
+interface FormatedPool extends Pool {
+    x?: string;
+    y?: string;
+    gamma_bps?: Big;
+}
+/** formatPoolNew
+ * This function appends to the existing standard Pool struct and adds attributes that simplify the parallel swap algorithms.
+ * Adds attributes "x" (for input token reserves in pool), "y" (for output token reserves in pool), and "gamma_bps" (for 1- fee in bps)
+ * Our convention for our algorithm has been to use "x" as the input token and "y" as the output token.
+ * @param pool    AMM structure containing reserves of inputToken and outputToken
+ * @param inputToken the name of the inputToken being traded in.
+ * @param outputToken the name of the outputToken being traded out.
+ * @returns newFormatPool
+ */
+export declare function formatPoolNew(pool: Pool, inputToken: string, outputToken: string): FormatedPool;
+/** solveForMuFloat
+ * This function takes the set of token pools, the total input of inputToken, and the names of inputToken and outputToken and
+ * solves for the Lagrange Multiplier "mu". Note that mu must be allowed to be aritrary precision floating point number. Mu will
+ * be used in subsequent function calls to determine the best allocations of intputToken to be made per pool.
+ * For more detailed math on how this function was derived, please see the white paper:
+ * https://github.com/giddyphysicist/ParallelSwapForRefFinance/blob/main/ParallelSwapWhitePaper.pdf
+ * @param pools   list of pools that contain inputToken and outputToken
+ * @param totalDeltaX  total allocation (among all pools) being input of inputToken
+ * @param inputToken   the name of the inputToken being traded in.
+ * @param outputToken   the name of the outputToken being traded out.
+ * @returns mu   the lagrange multiplier value calculated for a set of pools and inputToken amount.
+ */
+export declare function solveForMuFloat(pools: Pool[], totalDeltaX: string, inputToken: string, outputToken: string): number | Big;
+/** calculate_dx_float
+ * Once mu has been calculated for a set of pools and total input amount, the next step is
+ * determining the total allocation per pool. This function evaluates the amount of input Token to be
+ * allocated to the given pool. Note, in our original algorithmic convention, the 'x' variable was for the input token,
+ * and the 'y' variable was for the output token. Here, the value dx is the part of the full amount of input token X.
+ * Again, the detailed formulae for these operations can be found in the white paper referenced above.
+ * @param mu   the lagrange multiplier value calculated for a set of pools and inputToken amount.
+ * @param pool   AMM structure containing reserves of inputToken and outputToken
+ * @param inputToken the name of the inputToken being traded in.
+ * @param outputToken  the name of the outputToken being traded out.
+ * @returns dxFloat   the allocation amount determined for the given pool
+ */
+export declare function calculate_dx_float(mu: number | Big, pool: FormatedPool, inputToken: string, outputToken: string): Big;
+/** calculate_dy_float
+ * Once you have an allocation amount for a given pool, you can use the AMM constant-product formula to determine
+ * the expected output amount of output Token.
+ * Note, here, as earlier, our algorithmic convention uses "y" as the output token, and so "dy" is the fraction of
+ * the total output of output Token, assuming there could be dy contributions from other parallel pools as well.
+ * @param dx_float  input allocation amount of inputToken for the given pool
+ * @param pool   a structure representing the reserves and fees for a given pool.
+ * @param inputToken  the name of the inputToken being traded in.
+ * @param outputToken  the name of the outputToken being traded out.
+ * @returns dyFloat  the expected trade out amount out of outputToken
+ */
+export declare function calculate_dy_float(dx_float: number, pool: FormatedPool, inputToken: string, outputToken: string): Big;
+/** calculateOptimalOutput
+ * This is the main function, which calculates optimal values of inputToken to swap into each pool.
+ * @param pools  list of relevant AMM pools containing inputToken and outputToken
+ * @param inputAmount   the numeric total amount of inputToken to be traded into the group of swap pools.
+ * @param inputToken   the name of the inputToken being traded in.
+ * @param outputToken  the name of the outputToken being traded out.
+ * @returns normalizedDxArray an array containing the amount allocations of inputToken per pool in the list of pools.
+ */
+export declare function calculateOptimalOutput(pools: Pool[], inputAmount: string, inputToken: string, outputToken: string): bigint[];
+/** reducePools
+ * This function is used to implement part of the non-linear slack variables in the lagrange - multiplier
+ * solution for parallel swap. Part of what comes out of the math is that sometimes, the optimal allocation for a pool
+ * can be negative, which makes no physical sense. When this occurs, that particular pool needs to be flagged and the
+ * lagrange constraint applied to force the allocation to be zero.
+ * This function takes an already-solved set of pools, input allocation per pool, the total input amount, and the
+ * inputToken name and outputToken name, and determines which, if any, allocations need to be set to zero.
+ * However, when this occurs, and a pool is essentially ignored from the list, then the calculation for mu must be re-done.
+ * So the calculateOptimalOutput function is then called on the reduced set of pools, and if no negative allocation values remain,
+ * then the allocations on the reduced set is determined, and values of zero are put in for the 'failed' pools.
+ * @param pools  list of pools that contain inputToken and outputToken
+ * @param dxArray  list of input allocation per pool
+ * @param inputAmount   total amount of inputToken to be traded among the pools
+ * @param inputToken    the name of the inputToken
+ * @param outputToken   the name of the outputToken
+ * @returns newFullDxVec  the new full list of input allocations the same length as dxArray, containing zeros for failed pools.
+ */
+export declare function reducePools(pools: Pool[], dxArray: Big[], inputAmount: string, inputToken: string, outputToken: string): any[];
+export declare function checkIntegerSumOfAllocations(allocations: Big[] | string[] | BigInt[], totalInput: Big | string | BigInt): any[];
+export {};