@dodoex/widgets 3.1.2 → 3.1.3-bartio.1

package/dist/types/utils/address.d.ts

@@ -1,5 +1,11 @@
 import { ChainId } from '@dodoex/api';
 import { TokenInfo } from '../hooks/Token';
+export declare const ALGEBRA_POOL_DEPLOYER_ADDRESSES: {
+    [chainId in ChainId]?: string;
+};
+export declare const ALGEBRA_POOL_INIT_CODE_HASH: {
+    [chainId in ChainId]?: string;
+};
 export declare const isSameAddress: (tokenAddress1: string, tokenAddress2: string) => boolean;
 export declare function isAddress(value: any): boolean;
 export declare function isETHAddress(addr: string): boolean;
@@ -25,9 +31,38 @@ export declare function openEtherscanPage(path: string | undefined, chainId: Cha
  */
 export declare const getUniInitCodeHash: (chainId: number) => "0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f" | "0x007722521498f3d29a63d1eb6ab35e202874706c77ce73d45c1ad9da88174a3f" | "0x67a372377cf6d7f78cfdcc9df0bc21e1139bd49e5a47c33ee0de5389a4396410" | "0x2ebf1082215ab683deab4ee8ff50d42205db2059829b641717ab3f61f18d481a";
 export declare function sortsBefore(tokenA: TokenInfo, tokenB: TokenInfo): boolean;
+export declare function sortsBeforeTokenAddress(tokenA: string, tokenB: string): boolean;
 export declare const computePairAddress: ({ factoryAddress, tokenA, tokenB, fee, }: {
     factoryAddress: string;
     tokenA: TokenInfo;
     tokenB: TokenInfo;
     fee: number;
 }) => string;
+/**
+ * Computes a pool address
+ * @param poolDeployer The Algebra Pool Deployer address
+ * @param tokenA The first token of the pair, irrespective of sort order
+ * @param tokenB The second token of the pair, irrespective of sort order
+ * @param initCodeHashManualOverride The initial code hash override
+ * @returns The pool address
+ */
+export declare function computePoolAddress({ tokenA, tokenB, poolDeployer, initCodeHashManualOverride, }: {
+    tokenA: TokenInfo;
+    tokenB: TokenInfo;
+    poolDeployer: string;
+    initCodeHashManualOverride: string;
+}): string;
+/**
+ * Computes a pool address
+ * @param poolDeployer The Algebra Pool Deployer address
+ * @param tokenA The first token of the pair, irrespective of sort order
+ * @param tokenB The second token of the pair, irrespective of sort order
+ * @param initCodeHashManualOverride The initial code hash override
+ * @returns The pool address
+ */
+export declare function computePoolAddressByAddress({ tokenA, tokenB, initCodeHashManualOverride, poolDeployer, }: {
+    tokenA: string;
+    tokenB: string;
+    initCodeHashManualOverride: string;
+    poolDeployer: string;
+}): string;

package/dist/types/utils/fractions/fraction.d.ts

@@ -0,0 +1,24 @@
+import JSBI from 'jsbi';
+import { BigintIsh, Rounding } from './types';
+export declare class Fraction {
+    readonly numerator: JSBI;
+    readonly denominator: JSBI;
+    constructor(numerator: BigintIsh, denominator?: BigintIsh);
+    private static tryParseFraction;
+    get quotient(): JSBI;
+    get remainder(): Fraction;
+    invert(): Fraction;
+    add(other: Fraction | BigintIsh): Fraction;
+    subtract(other: Fraction | BigintIsh): Fraction;
+    lessThan(other: Fraction | BigintIsh): boolean;
+    equalTo(other: Fraction | BigintIsh): boolean;
+    greaterThan(other: Fraction | BigintIsh): boolean;
+    multiply(other: Fraction | BigintIsh): Fraction;
+    divide(other: Fraction | BigintIsh): Fraction;
+    toSignificant(significantDigits: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces: number, format?: object, rounding?: Rounding): string;
+    /**
+     * Helper method for converting any super class back to a fraction
+     */
+    get asFraction(): Fraction;
+}

package/dist/types/utils/fractions/index.d.ts

@@ -0,0 +1,3 @@
+export { Fraction } from './fraction';
+export { Percent } from './percent';
+export { Price } from './price';

package/dist/types/utils/fractions/percent.d.ts

@@ -0,0 +1,14 @@
+import { BigintIsh, Rounding } from './types';
+import { Fraction } from './fraction';
+export declare class Percent extends Fraction {
+    /**
+     * This boolean prevents a fraction from being interpreted as a Percent
+     */
+    readonly isPercent: true;
+    add(other: Fraction | BigintIsh): Percent;
+    subtract(other: Fraction | BigintIsh): Percent;
+    multiply(other: Fraction | BigintIsh): Percent;
+    divide(other: Fraction | BigintIsh): Percent;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+}

package/dist/types/utils/fractions/price.d.ts

@@ -0,0 +1,29 @@
+import { BigintIsh, Rounding } from './types';
+import { Fraction } from './fraction';
+import { TokenInfo } from '../../hooks/Token';
+export declare class Price extends Fraction {
+    readonly baseCurrency: TokenInfo;
+    readonly quoteCurrency: TokenInfo;
+    readonly scalar: Fraction;
+    /**
+     * Construct a price, either with the base and quote currency amount, or the
+     * @param args
+     */
+    constructor(...args: [TokenInfo, TokenInfo, BigintIsh, BigintIsh]);
+    /**
+     * Flip the price, switching the base and quote currency
+     */
+    invert(): Price;
+    /**
+     * Multiply the price by another price, returning a new price. The other price must have the same base currency as this price's quote currency
+     * @param other the other price
+     */
+    multiply(other: Price): Price;
+    /**
+     * Get the value scaled by decimals for formatting
+     * @private
+     */
+    private get adjustedForDecimals();
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+}

package/dist/types/utils/fractions/types.d.ts

@@ -0,0 +1,7 @@
+import JSBI from 'jsbi';
+export type BigintIsh = JSBI | string | number;
+export declare enum Rounding {
+    ROUND_DOWN = 0,
+    ROUND_HALF_UP = 1,
+    ROUND_UP = 2
+}

package/dist/types/widgets/PoolWidget/AMMV2Create/Ratio.d.ts

@@ -1,7 +1,6 @@
 import { BoxProps } from '@dodoex/components';
 import BigNumber from 'bignumber.js';
 import { TokenInfo } from '../../../hooks/Token';
-import { useSlipper } from '../PoolOperate/components/SlippageSetting';
 export declare function RatioPrice({ baseToken, quoteToken, midPrice, loading, disabled, }: {
     baseToken?: TokenInfo;
     quoteToken?: TokenInfo;
@@ -9,13 +8,11 @@ export declare function RatioPrice({ baseToken, quoteToken, midPrice, loading, d
     loading?: boolean;
     disabled?: boolean;
 }): JSX.Element;
-export default function Ratio({ baseToken, quoteToken, loading, midPrice, shareOfPool, sx, slippage, setSlippage, }: {
+export default function Ratio({ baseToken, quoteToken, loading, midPrice, shareOfPool, sx, }: {
     baseToken?: TokenInfo;
     quoteToken?: TokenInfo;
     loading?: boolean;
     midPrice?: BigNumber | null;
     shareOfPool?: string;
     sx?: BoxProps['sx'];
-    slippage: ReturnType<typeof useSlipper>['slipper'];
-    setSlippage: ReturnType<typeof useSlipper>['setSlipper'];
 }): JSX.Element;

package/dist/types/widgets/PoolWidget/AMMV2Create/Setting.d.ts

@@ -0,0 +1,16 @@
+import { BoxProps } from '@dodoex/components';
+import { AUTO_SWAP_SLIPPAGE_PROTECTION } from '../../../constants/pool';
+export declare const useSlipper: ({ address }: {
+    address?: string;
+}) => {
+    slipper: number | "auto";
+    setSlipper: import("react").Dispatch<import("react").SetStateAction<number | "auto">>;
+    slipperValue: number;
+    resetSlipper: () => void;
+};
+export default function Setting({ sx, disabled, slippage, onChangeSlippage, }: {
+    sx?: BoxProps['sx'];
+    disabled?: boolean;
+    slippage: number | typeof AUTO_SWAP_SLIPPAGE_PROTECTION;
+    onChangeSlippage: (val: number | typeof AUTO_SWAP_SLIPPAGE_PROTECTION) => void;
+}): JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/AddLiquidity.d.ts

@@ -0,0 +1,14 @@
+import { TokenInfo } from '../../../hooks/Token';
+import { FetchTicks } from './hooks/usePoolActiveLiquidityChartData';
+export default function AddLiquidity({ params, border, fetchTicks, onBaseTokenChange, onQuoteTokenChange, }: {
+    params?: {
+        from?: string;
+        to?: string;
+        fee?: string;
+    };
+    border?: boolean;
+    fetchTicks?: FetchTicks;
+    ticksErrorRefetch?: () => void;
+    onBaseTokenChange?: (token: TokenInfo | undefined) => void;
+    onQuoteTokenChange?: (token: TokenInfo | undefined) => void;
+}): JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/AlgebraPositionManage.d.ts

@@ -0,0 +1,11 @@
+import { TokenInfo } from '../../../hooks/Token';
+import { ChainId } from '@dodoex/api';
+export interface AlgebraPositionManageProps {
+    chainId: ChainId;
+    baseToken: TokenInfo;
+    quoteToken: TokenInfo;
+    tokenId: string;
+    border?: boolean;
+    successBack?: () => void;
+}
+export declare const AlgebraPositionManage: ({ chainId, baseToken, quoteToken, tokenId, border, successBack: successBackProps, }: AlgebraPositionManageProps) => JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/Badge/RangeBadge.d.ts

@@ -0,0 +1,4 @@
+export default function RangeBadge({ removed, inRange, }: {
+    removed?: boolean;
+    inRange?: boolean;
+}): JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/ClaimButton.d.ts

@@ -0,0 +1,9 @@
+import { ChainId } from '@dodoex/api';
+export interface ClaimButtonProps {
+    chainId: ChainId;
+    disabled: boolean;
+    isLoading: boolean;
+    border?: boolean;
+    onConfirm: () => void;
+}
+export declare const ClaimButton: ({ chainId, disabled, isLoading, border, onConfirm, }: ClaimButtonProps) => JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/InRangeDot.d.ts

@@ -0,0 +1,4 @@
+export interface InRangeDotProps {
+    outOfRange: boolean;
+}
+export declare const InRangeDot: ({ outOfRange }: InRangeDotProps) => JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/InputStepCounter.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+interface StepCounterProps {
+    value: string;
+    onUserInput: (value: string) => void;
+    decrement: () => string;
+    increment: () => string;
+    decrementDisabled?: boolean;
+    incrementDisabled?: boolean;
+    label?: string;
+    locked?: boolean;
+    title: ReactNode;
+    tokenA?: string;
+    tokenB?: string;
+    border?: boolean;
+}
+declare const StepCounter: ({ value, decrement, increment, decrementDisabled, incrementDisabled, locked, onUserInput, title, tokenA, tokenB, border, }: StepCounterProps) => JSX.Element;
+export default StepCounter;

package/dist/types/widgets/PoolWidget/Algebra/components/LiquidityChartRangeInput/Area.d.ts

@@ -0,0 +1,10 @@
+import { ScaleLinear } from 'd3';
+import { ChartEntry } from './types';
+export declare const Area: ({ series, xScale, yScale, xValue, yValue, fill, }: {
+    series: ChartEntry[];
+    xScale: ScaleLinear<number, number>;
+    yScale: ScaleLinear<number, number>;
+    xValue: (d: ChartEntry) => number;
+    yValue: (d: ChartEntry) => number;
+    fill?: string;
+}) => JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/LiquidityChartRangeInput/AxisBottom.d.ts

@@ -0,0 +1,6 @@
+import { ScaleLinear } from 'd3';
+export declare const AxisBottom: ({ xScale, innerHeight, offset, }: {
+    xScale: ScaleLinear<number, number>;
+    innerHeight: number;
+    offset?: number;
+}) => JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/LiquidityChartRangeInput/Brush.d.ts

@@ -0,0 +1,13 @@
+import { ScaleLinear } from 'd3';
+export declare const Brush: ({ id, xScale, interactive, brushLabelValue, brushExtent, setBrushExtent, innerWidth, innerHeight, westHandleColor, eastHandleColor, }: {
+    id: string;
+    xScale: ScaleLinear<number, number>;
+    interactive: boolean;
+    brushLabelValue: (d: "w" | "e", x: number) => string;
+    brushExtent: [number, number];
+    setBrushExtent: (extent: [number, number], mode: string | undefined) => void;
+    innerWidth: number;
+    innerHeight: number;
+    westHandleColor: string;
+    eastHandleColor: string;
+}) => JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/LiquidityChartRangeInput/Chart.d.ts

@@ -0,0 +1,2 @@
+import { LiquidityChartRangeInputProps } from './types';
+export declare function Chart({ id, data: { series, current }, ticksAtLimit, styles, dimensions: { width, height }, margins, interactive, brushDomain, brushLabels, onBrushDomainChange, zoomLevels, }: LiquidityChartRangeInputProps): JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/LiquidityChartRangeInput/Line.d.ts

@@ -0,0 +1,6 @@
+import { ScaleLinear } from 'd3';
+export declare const Line: ({ value, xScale, innerHeight, }: {
+    value: number;
+    xScale: ScaleLinear<number, number>;
+    innerHeight: number;
+}) => JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/LiquidityChartRangeInput/Zoom.d.ts

@@ -0,0 +1,12 @@
+import { ScaleLinear, ZoomTransform } from 'd3';
+import { ZoomLevels } from './types';
+export default function Zoom({ svg, xScale, setZoom, width, height, resetBrush, showResetButton, zoomLevels, }: {
+    svg: SVGElement | null;
+    xScale: ScaleLinear<number, number>;
+    setZoom: (transform: ZoomTransform) => void;
+    width: number;
+    height: number;
+    resetBrush: () => void;
+    showResetButton: boolean;
+    zoomLevels: ZoomLevels;
+}): JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/LiquidityChartRangeInput/index.d.ts

@@ -0,0 +1,19 @@
+import { Bound } from '../../types';
+import { TokenInfo } from '../../../../../hooks/Token';
+import { Price } from '../../../../../utils/fractions';
+import { usePoolActiveLiquidityChartData } from '../../hooks/usePoolActiveLiquidityChartData';
+export default function LiquidityChartRangeInput({ currencyA, currencyB, isSorted, ticksAtLimit, price, priceLower, priceUpper, onLeftRangeInput, onRightRangeInput, interactive, chartData, }: {
+    currencyA?: TokenInfo;
+    currencyB?: TokenInfo;
+    isSorted: boolean;
+    ticksAtLimit: {
+        [bound in Bound]?: boolean | undefined;
+    };
+    price?: number;
+    priceLower?: Price;
+    priceUpper?: Price;
+    onLeftRangeInput: (typedValue: string) => void;
+    onRightRangeInput: (typedValue: string) => void;
+    interactive: boolean;
+    chartData: ReturnType<typeof usePoolActiveLiquidityChartData>;
+}): JSX.Element | null;

package/dist/types/widgets/PoolWidget/Algebra/components/LiquidityChartRangeInput/svg.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Generates an SVG path for the east brush handle.
+ * Apply `scale(-1, 1)` to generate west brush handle.
+ *
+ *    |```````\
+ *    |  | |  |
+ *    |______/
+ *    |
+ *    |
+ *    |
+ *    |
+ *    |
+ *
+ * https://medium.com/@dennismphil/one-side-rounded-rectangle-using-svg-fb31cf318d90
+ */
+export declare const brushHandlePath: (height: number) => string;
+export declare const brushHandleAccentPath: () => string;
+export declare const OffScreenHandle: ({ color, size, margin, }: {
+    color: string;
+    size?: number;
+    margin?: number;
+}) => JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/LiquidityChartRangeInput/types.d.ts

@@ -0,0 +1,50 @@
+import { Bound } from '../../types';
+export interface ChartEntry {
+    activeLiquidity: number;
+    price0: number;
+}
+interface Dimensions {
+    width: number;
+    height: number;
+}
+interface Margins {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface ZoomLevels {
+    initialMin: number;
+    initialMax: number;
+    min: number;
+    max: number;
+}
+export interface LiquidityChartRangeInputProps {
+    id?: string;
+    data: {
+        series: ChartEntry[];
+        current: number;
+    };
+    ticksAtLimit: {
+        [bound in Bound]?: boolean | undefined;
+    };
+    styles: {
+        area: {
+            selection: string;
+        };
+        brush: {
+            handle: {
+                west: string;
+                east: string;
+            };
+        };
+    };
+    dimensions: Dimensions;
+    margins: Margins;
+    interactive?: boolean;
+    brushLabels: (d: 'w' | 'e', x: number) => string;
+    brushDomain?: [number, number];
+    onBrushDomainChange: (domain: [number, number], mode: string | undefined) => void;
+    zoomLevels: ZoomLevels;
+}
+export {};

package/dist/types/widgets/PoolWidget/Algebra/components/LiquidityChartRangeInput/usePrevious.d.ts

@@ -0,0 +1 @@
+export default function usePrevious<T>(value: T): T | undefined;

package/dist/types/widgets/PoolWidget/Algebra/components/LiquidityChartRangeInput/utils.d.ts

@@ -0,0 +1,14 @@
+export declare const themeColor: {
+    neutral1: string;
+    neutral2: string;
+    accent1: string;
+    critical: string;
+    white: string;
+    surface3: string;
+    opacity: {
+        hover: number;
+        click: number;
+        disabled: number;
+        enabled: number;
+    };
+};

package/dist/types/widgets/PoolWidget/Algebra/components/MyLiquidity.d.ts

@@ -0,0 +1,10 @@
+import { BoxProps } from '@dodoex/components';
+import { TokenInfo } from '../../../../hooks/Token';
+export default function MyLiquidity({ border, token0, token1, amount0, amount1, sx, }: {
+    border?: boolean;
+    token0: TokenInfo | undefined;
+    token1: TokenInfo | undefined;
+    amount0: string | undefined;
+    amount1: string | undefined;
+    sx?: BoxProps['sx'];
+}): JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/PositionPreview.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { TokenInfo } from '../../../../hooks/Token';
+import { Price } from '../../../../utils/fractions';
+export declare const PositionPreview: ({ token0, token1, liquidity, amount0, amount1, price, tickLower, tickUpper, title, inRange, }: {
+    token0: TokenInfo | undefined;
+    token1: TokenInfo | undefined;
+    liquidity: number | undefined;
+    amount0: string | undefined;
+    amount1: string | undefined;
+    title?: ReactNode;
+    price: Price | undefined;
+    tickLower: number | undefined;
+    tickUpper: number | undefined;
+    inRange: boolean;
+}) => JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/PositionSelectedRangePreview.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { TokenInfo } from '../../../../hooks/Token';
+import { Price } from '../../../../utils/fractions';
+export declare const PositionSelectedRangePreview: ({ token0, token1, token0Price, tickLower, tickUpper, title, border, }: {
+    token0: TokenInfo;
+    token1: TokenInfo;
+    token0Price: Price | undefined;
+    tickLower: number | undefined;
+    tickUpper: number | undefined;
+    title?: ReactNode;
+    border?: boolean;
+}) => JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/RangeSelector.d.ts

@@ -0,0 +1,21 @@
+import { Bound } from '../types';
+import { TokenInfo } from '../../../../hooks/Token';
+import { Price } from '../../../../utils/fractions';
+export interface RangeSelectorProps {
+    priceLower?: Price;
+    priceUpper?: Price;
+    getDecrementLower: () => string;
+    getIncrementLower: () => string;
+    getDecrementUpper: () => string;
+    getIncrementUpper: () => string;
+    onLeftRangeInput: (typedValue: string) => void;
+    onRightRangeInput: (typedValue: string) => void;
+    tokenA?: TokenInfo | null;
+    tokenB?: TokenInfo | null;
+    ticksAtLimit: {
+        [bound in Bound]?: boolean | undefined;
+    };
+    isSorted: boolean;
+    border?: boolean;
+}
+export declare const RangeSelector: ({ priceLower, priceUpper, onLeftRangeInput, onRightRangeInput, getDecrementLower, getIncrementLower, getDecrementUpper, getIncrementUpper, tokenA, tokenB, ticksAtLimit, isSorted, border, }: RangeSelectorProps) => JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/RateToggle.d.ts

@@ -0,0 +1,9 @@
+import { BoxProps } from '@dodoex/components';
+import { TokenInfo } from '../../../../hooks/Token';
+export interface RateToggleProps {
+    baseToken: TokenInfo | undefined;
+    quoteToken: TokenInfo | undefined;
+    handleRateToggle: () => void;
+    sx?: BoxProps['sx'];
+}
+export declare const RateToggle: ({ baseToken, quoteToken, handleRateToggle, sx, }: RateToggleProps) => JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/RemoveButton.d.ts

@@ -0,0 +1,11 @@
+import { ChainId } from '@dodoex/api';
+export interface ButtonsProps {
+    chainId: ChainId;
+    disabled: boolean;
+    removed: boolean | undefined;
+    isLoading: boolean;
+    error?: React.ReactNode;
+    onConfirm: () => void;
+    border?: boolean;
+}
+export declare const RemoveButton: ({ chainId, disabled, removed, isLoading, error, onConfirm, border, }: ButtonsProps) => JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/ReviewModal.d.ts

@@ -0,0 +1,19 @@
+import { TokenInfo } from '../../../../hooks/Token';
+import { Price } from '../../../../utils/fractions';
+export interface ReviewModalProps {
+    on: boolean;
+    onClose: () => void;
+    onConfirm: () => void;
+    loading?: boolean;
+    token0: TokenInfo | undefined;
+    token1: TokenInfo | undefined;
+    liquidity: number | undefined;
+    amount0: string | undefined;
+    amount1: string | undefined;
+    title?: React.ReactNode;
+    price: Price | undefined;
+    tickLower: number | undefined;
+    tickUpper: number | undefined;
+    inRange: boolean;
+}
+export declare const ReviewModal: ({ on, onClose, onConfirm, loading, token0, token1, liquidity, amount0, amount1, price, tickLower, tickUpper, title, inRange, }: ReviewModalProps) => JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/TokenAndEtherscan.d.ts

@@ -0,0 +1,4 @@
+import { TokenInfo } from '../../../../hooks/Token';
+export default function TokenAndEtherscan({ token }: {
+    token: TokenInfo;
+}): JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/TokenPairSelect.d.ts

@@ -0,0 +1,7 @@
+import { Actions, StateProps } from '../reducer';
+export interface TokenPairSelectProps {
+    baseToken: StateProps['baseToken'];
+    quoteToken: StateProps['quoteToken'];
+    dispatch: React.Dispatch<Actions>;
+}
+export declare const TokenPairSelect: ({ baseToken, quoteToken, dispatch, }: TokenPairSelectProps) => JSX.Element;

package/dist/types/widgets/PoolWidget/Algebra/components/shared.d.ts

@@ -0,0 +1,4 @@
+import { FeeAmount } from '../sdks/v3-sdk/constants';
+export declare const FEE_AMOUNT_DETAIL: Record<FeeAmount, {
+    label: string;
+}>;

package/dist/types/widgets/PoolWidget/Algebra/components/widgets.d.ts

@@ -0,0 +1,56 @@
+import { BoxProps } from '@dodoex/components';
+declare const gapValues: {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+};
+export type Gap = keyof typeof gapValues;
+export interface YellowCardProps {
+    children?: React.ReactNode;
+}
+export declare const Card: ({ children, sx, }: {
+    sx?: BoxProps["sx"];
+    children?: React.ReactNode;
+}) => JSX.Element;
+export declare const LightCard: ({ children, border, sx, }: {
+    sx?: BoxProps["sx"];
+    border?: boolean;
+    children?: React.ReactNode;
+}) => JSX.Element;
+export declare const YellowCard: ({ children }: YellowCardProps) => JSX.Element;
+export declare function ColumnCenter({ gap, flex, children, style, }: {
+    gap?: Gap | string;
+    flex?: string;
+    children: React.ReactNode;
+    style?: BoxProps['sx'];
+}): JSX.Element;
+export declare function AutoColumn({ gap, justify, grow, children, style, }: {
+    gap?: Gap | string;
+    justify?: 'stretch' | 'center' | 'start' | 'end' | 'flex-start' | 'flex-end' | 'space-between';
+    grow?: true;
+    children: React.ReactNode;
+    style?: BoxProps['sx'];
+}): JSX.Element;
+export declare function Row({ gap, children, sx, }: {
+    gap?: Gap | string;
+    children: React.ReactNode;
+    sx?: BoxProps['sx'];
+}): JSX.Element;
+export declare function RowBetween({ children, style, }: {
+    children: React.ReactNode;
+    style?: BoxProps['sx'];
+}): JSX.Element;
+export declare function RowFixed({ gap, justify, children, sx, }: {
+    gap?: string;
+    justify?: string;
+    children: React.ReactNode;
+    sx?: BoxProps['sx'];
+}): JSX.Element;
+export declare function DynamicSection({ children, disabled, sx, }: {
+    children: React.ReactNode;
+    disabled?: boolean;
+    sx?: BoxProps['sx'];
+}): JSX.Element;
+export {};

package/dist/types/widgets/PoolWidget/Algebra/constants/misc.d.ts

@@ -0,0 +1,17 @@
+import JSBI from 'jsbi';
+import { Percent } from '../../../../utils/fractions';
+export declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare const DEFAULT_DEADLINE_FROM_NOW: number;
+export declare const L2_DEADLINE_FROM_NOW: number;
+export declare const DEFAULT_TXN_DISMISS_MS = 10000;
+export declare const L2_TXN_DISMISS_MS = 5000;
+export declare const BIG_INT_ZERO: JSBI;
+export declare const BIPS_BASE = 10000;
+export declare const ONE_BIPS: Percent;
+export declare const ALLOWED_PRICE_IMPACT_LOW: Percent;
+export declare const ALLOWED_PRICE_IMPACT_MEDIUM: Percent;
+export declare const ALLOWED_PRICE_IMPACT_HIGH: Percent;
+export declare const PRICE_IMPACT_WITHOUT_FEE_CONFIRM_MIN: Percent;
+export declare const BLOCKED_PRICE_IMPACT_NON_EXPERT: Percent;
+export declare const ZERO_PERCENT: Percent;
+export declare const ONE_HUNDRED_PERCENT: Percent;

package/dist/types/widgets/PoolWidget/Algebra/hooks/useAddAlgebraLiquidity.d.ts

@@ -0,0 +1,15 @@
+import { useAlgebraPair } from './useAlgebraPair';
+export declare function useAddAlgebraLiquidity(): import("@tanstack/react-query").UseMutationResult<import("../../../../hooks/Submission/types").ExecutionResult | undefined, Error, {
+    createPool?: boolean;
+    recipient?: string;
+    deployer?: string;
+    pool?: ReturnType<typeof useAlgebraPair>;
+    tokenId?: number | string;
+    amount0: string;
+    amount1: string;
+    tickLower: number;
+    tickUpper: number;
+    amount0Min: string;
+    amount1Min: string;
+    successBack?: () => void;
+}, unknown>;