@dodoex/widgets 3.0.4-ve33.10 → 3.0.4-ve33.12

package/dist/types/hooks/Token/usePoolTokenSort.d.ts

@@ -0,0 +1,24 @@
+import { ChainId } from '@dodoex/api';
+import { TokenInfo } from './type';
+export declare function usePoolTokenSort({ baseToken, quoteToken, }: {
+    baseToken: TokenInfo | undefined;
+    quoteToken: TokenInfo | undefined;
+}): {
+    chainId: undefined;
+    isRearTokenA: boolean;
+    token0: undefined;
+    token1: undefined;
+    token0Wrapped: undefined;
+    token1Wrapped: undefined;
+    isBaseTokenNative: boolean;
+    isQuoteTokenNative: boolean;
+} | {
+    chainId: ChainId;
+    isRearTokenA: boolean;
+    token0: TokenInfo;
+    token1: TokenInfo;
+    token0Wrapped: TokenInfo;
+    token1Wrapped: TokenInfo;
+    isBaseTokenNative: boolean;
+    isQuoteTokenNative: boolean;
+};

package/dist/types/index.d.ts

@@ -33,6 +33,10 @@ export type { PoolOperateProps } from './widgets/PoolWidget/PoolOperate';
 export { Ve33PoolDetail } from './widgets/ve33/Ve33PoolDetail';
 export { Ve33PoolList } from './widgets/ve33/Ve33PoolList';
 export { VotePoolList } from './widgets/ve33/VotePoolList';
+export { default as Ve33LockOperate } from './widgets/ve33/Ve33LockOperate';
+export { default as Ve33LockList } from './widgets/ve33/Ve33LockList';
+export { default as Ve33IncentiveList } from './widgets/ve33/Ve33IncentiveList';
+export { default as Ve33IncentiveDetail } from './widgets/ve33/Ve33IncentiveDetail';
 export type SwapWidgetProps = WidgetProps & SwapProps;
 export { EmptyList } from './components/List/EmptyList';
 export { FailedList } from './components/List/FailedList';

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/ve33/Ve33IncentiveDetail/AddIncentiveDialog.d.ts

@@ -0,0 +1,13 @@
+import { BoxProps } from '@dodoex/components';
+import { TokenInfo } from '../../../hooks/Token';
+import { ChainId } from '@dodoex/api';
+interface AddIncentiveProps {
+    data?: {
+        chainId: ChainId;
+        token: TokenInfo;
+    };
+    onClose: () => void;
+    sx?: BoxProps['sx'];
+}
+export default function AddIncentiveDialog(props: AddIncentiveProps): JSX.Element;
+export {};

package/dist/types/widgets/ve33/Ve33IncentiveDetail/Dashboard.d.ts

@@ -0,0 +1 @@
+export default function Dashboard(): JSX.Element;

package/dist/types/widgets/ve33/Ve33IncentiveDetail/PoolInfo.d.ts

@@ -0,0 +1,5 @@
+import { Ve33PoolInfoI } from '../types';
+export default function PoolInfo({ poolInfo, isLoading, }: {
+    poolInfo?: Ve33PoolInfoI;
+    isLoading?: boolean;
+}): JSX.Element;

package/dist/types/widgets/ve33/Ve33IncentiveDetail/index.d.ts

@@ -0,0 +1,7 @@
+import { ChainId } from '@dodoex/api';
+export interface Ve33IncentiveDetailProps {
+    id: string;
+    chainId: ChainId;
+    onClickGoBack: () => void;
+}
+export default function Ve33IncentiveDetail({ id, chainId, onClickGoBack, }: Ve33IncentiveDetailProps): JSX.Element;

package/dist/types/widgets/ve33/Ve33IncentiveList/CardList.d.ts

@@ -0,0 +1,10 @@
+import { Ve33PoolInfoI } from '../types';
+export interface CardListProps {
+    poolList: Ve33PoolInfoI[];
+    onAdd: (pool: Ve33PoolInfoI) => void;
+}
+export declare const CardList: ({ poolList, ...props }: CardListProps) => JSX.Element;
+export declare function CardItem({ item, onAdd, }: {
+    item?: Ve33PoolInfoI;
+    onAdd?: (pool: Ve33PoolInfoI) => void;
+}): JSX.Element;

package/dist/types/widgets/ve33/Ve33IncentiveList/TableList.d.ts

@@ -0,0 +1,11 @@
+import { ChainId } from '@dodoex/api';
+import { Ve33PoolInfoI } from '../types';
+export interface TableListProps {
+    chainId: ChainId;
+    poolList: Ve33PoolInfoI[];
+    hasMore?: boolean;
+    loadMore?: () => void;
+    loadMoreLoading?: boolean;
+    onAdd: (pool: Ve33PoolInfoI) => void;
+}
+export declare const TableList: ({ chainId, poolList, hasMore, loadMore, loadMoreLoading, onAdd, }: TableListProps) => JSX.Element;

package/dist/types/widgets/ve33/Ve33IncentiveList/index.d.ts

@@ -0,0 +1,7 @@
+import { TokenInfo } from '../../../hooks/Token';
+import { Ve33PoolInfoI } from '../types';
+export default function Ve33IncentiveList({ aToken: aTokenProps, bToken: bTokenProps, onGoIncentiveDetail, }: {
+    aToken?: TokenInfo | null;
+    bToken?: TokenInfo | null;
+    onGoIncentiveDetail: (pool: Ve33PoolInfoI) => void;
+}): JSX.Element;

package/dist/types/widgets/ve33/Ve33LockList/CardList.d.ts

@@ -0,0 +1,11 @@
+import { Lock, useFetchUserLocks } from './hooks/useFetchUserLocks';
+import React from 'react';
+export interface CardListProps {
+    inSelected: boolean;
+    selectedId: number[];
+    setSelectedId: React.Dispatch<React.SetStateAction<number[]>>;
+    fetchUserLocks: ReturnType<typeof useFetchUserLocks>;
+    onManage: (lock: Lock) => void;
+    onClaim: (lock: Lock) => void;
+}
+export declare const CardList: ({ inSelected, selectedId, setSelectedId, fetchUserLocks, onManage, onClaim, }: CardListProps) => JSX.Element;

package/dist/types/widgets/ve33/Ve33LockList/ClaimLockDialog.d.ts

@@ -0,0 +1,6 @@
+import { Lock } from './hooks/useFetchUserLocks';
+export default function ClaimLockDialog({ open, onClose, lock, }: {
+    open: boolean;
+    onClose: () => void;
+    lock: Lock | null;
+}): JSX.Element;

package/dist/types/widgets/ve33/Ve33LockList/LockManageDialog.d.ts

@@ -0,0 +1,7 @@
+import { Lock } from './hooks/useFetchUserLocks';
+export default function LockManageDialog({ open, onClose, lock: lockProps, refetch: refetchProps, }: {
+    open: boolean;
+    onClose: () => void;
+    lock?: Lock | null;
+    refetch?: () => void;
+}): JSX.Element;

package/dist/types/widgets/ve33/Ve33LockList/MergeDialog.d.ts

@@ -0,0 +1,7 @@
+import { Lock } from './hooks/useFetchUserLocks';
+export default function MergeDialog({ open, onClose, locks, refetch, }: {
+    open: boolean;
+    onClose: () => void;
+    locks: [Lock | undefined, Lock | undefined];
+    refetch?: () => void;
+}): JSX.Element;

package/dist/types/widgets/ve33/Ve33LockList/TableList.d.ts

@@ -0,0 +1,10 @@
+import { Lock, useFetchUserLocks } from './hooks/useFetchUserLocks';
+export interface TableListProps {
+    inSelected: boolean;
+    selectedId: number[];
+    setSelectedId: React.Dispatch<React.SetStateAction<number[]>>;
+    fetchUserLocks: ReturnType<typeof useFetchUserLocks>;
+    onManage: (lock: Lock) => void;
+    onClaim: (lock: Lock) => void;
+}
+export declare const TableList: ({ inSelected, selectedId, setSelectedId, fetchUserLocks, onManage, onClaim, }: TableListProps) => JSX.Element;

package/dist/types/widgets/ve33/Ve33LockList/hooks/useClaimBribes.d.ts

@@ -0,0 +1,7 @@
+export declare function useClaimBribes({ refetch, }: {
+    refetch?: () => Promise<void> | void;
+}): import("@tanstack/react-query").UseMutationResult<void, Error, {
+    tokenId: number;
+    bribes: string[];
+    tokens: string[];
+}, unknown>;

package/dist/types/widgets/ve33/Ve33LockList/hooks/useClaimRebases.d.ts

@@ -0,0 +1,5 @@
+export declare function useClaimRebases({ refetch, }: {
+    refetch?: () => Promise<void> | void;
+}): import("@tanstack/react-query").UseMutationResult<void, Error, {
+    tokenId: number;
+}, unknown>;

package/dist/types/widgets/ve33/Ve33LockList/hooks/useExtendLock.d.ts

@@ -0,0 +1,6 @@
+export declare function useExtendLock({ refetch, }: {
+    refetch?: () => Promise<void> | void;
+}): import("@tanstack/react-query").UseMutationResult<void, Error, {
+    tokenId: number;
+    lockDuration: number;
+}, unknown>;

package/dist/types/widgets/ve33/Ve33LockList/hooks/useFetchUserLocks.d.ts

@@ -0,0 +1,282 @@
+import { getFetchVE33VotingEscrowUserPointHistoryQueryOptions } from '@dodoex/dodo-contract-request';
+export declare function useFetchUserLocks({ account, chainId, }: {
+    account: string | undefined;
+    chainId?: number;
+}): {
+    userLocks: {
+        tokenId: number;
+        value: string;
+        votingPower: any;
+        lockedEnd: number;
+        isPermanent: boolean;
+        isVoted: boolean;
+        chainId: number | undefined;
+        token: {
+            symbol: string;
+            address: string;
+            name: string;
+            decimals: number;
+            balance: import("bignumber.js").BigNumber;
+            allowance: import("bignumber.js").BigNumber;
+            account: string;
+            spender: string | undefined;
+            chainId: number;
+        } | {
+            address: string;
+            decimals: number;
+            symbol: string;
+            name: string;
+            balance: import("bignumber.js").BigNumber;
+            spender: string | undefined;
+            allowance: import("bignumber.js").BigNumber;
+            chainId: number;
+            account?: undefined;
+        } | null | undefined;
+    }[] | undefined;
+    data: import("@dodoex/api/dist/types/gql/graphql").Ve33_GetUserLockQuery;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@dodoex/api/dist/types/gql/graphql").Ve33_GetUserLockQuery, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    userLocks: {
+        tokenId: number;
+        value: string;
+        votingPower: any;
+        lockedEnd: number;
+        isPermanent: boolean;
+        isVoted: boolean;
+        chainId: number | undefined;
+        token: {
+            symbol: string;
+            address: string;
+            name: string;
+            decimals: number;
+            balance: import("bignumber.js").BigNumber;
+            allowance: import("bignumber.js").BigNumber;
+            account: string;
+            spender: string | undefined;
+            chainId: number;
+        } | {
+            address: string;
+            decimals: number;
+            symbol: string;
+            name: string;
+            balance: import("bignumber.js").BigNumber;
+            spender: string | undefined;
+            allowance: import("bignumber.js").BigNumber;
+            chainId: number;
+            account?: undefined;
+        } | null | undefined;
+    }[] | undefined;
+    data: import("@dodoex/api/dist/types/gql/graphql").Ve33_GetUserLockQuery;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@dodoex/api/dist/types/gql/graphql").Ve33_GetUserLockQuery, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    userLocks: {
+        tokenId: number;
+        value: string;
+        votingPower: any;
+        lockedEnd: number;
+        isPermanent: boolean;
+        isVoted: boolean;
+        chainId: number | undefined;
+        token: {
+            symbol: string;
+            address: string;
+            name: string;
+            decimals: number;
+            balance: import("bignumber.js").BigNumber;
+            allowance: import("bignumber.js").BigNumber;
+            account: string;
+            spender: string | undefined;
+            chainId: number;
+        } | {
+            address: string;
+            decimals: number;
+            symbol: string;
+            name: string;
+            balance: import("bignumber.js").BigNumber;
+            spender: string | undefined;
+            allowance: import("bignumber.js").BigNumber;
+            chainId: number;
+            account?: undefined;
+        } | null | undefined;
+    }[] | undefined;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@dodoex/api/dist/types/gql/graphql").Ve33_GetUserLockQuery, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    userLocks: {
+        tokenId: number;
+        value: string;
+        votingPower: any;
+        lockedEnd: number;
+        isPermanent: boolean;
+        isVoted: boolean;
+        chainId: number | undefined;
+        token: {
+            symbol: string;
+            address: string;
+            name: string;
+            decimals: number;
+            balance: import("bignumber.js").BigNumber;
+            allowance: import("bignumber.js").BigNumber;
+            account: string;
+            spender: string | undefined;
+            chainId: number;
+        } | {
+            address: string;
+            decimals: number;
+            symbol: string;
+            name: string;
+            balance: import("bignumber.js").BigNumber;
+            spender: string | undefined;
+            allowance: import("bignumber.js").BigNumber;
+            chainId: number;
+            account?: undefined;
+        } | null | undefined;
+    }[] | undefined;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@dodoex/api/dist/types/gql/graphql").Ve33_GetUserLockQuery, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    userLocks: {
+        tokenId: number;
+        value: string;
+        votingPower: any;
+        lockedEnd: number;
+        isPermanent: boolean;
+        isVoted: boolean;
+        chainId: number | undefined;
+        token: {
+            symbol: string;
+            address: string;
+            name: string;
+            decimals: number;
+            balance: import("bignumber.js").BigNumber;
+            allowance: import("bignumber.js").BigNumber;
+            account: string;
+            spender: string | undefined;
+            chainId: number;
+        } | {
+            address: string;
+            decimals: number;
+            symbol: string;
+            name: string;
+            balance: import("bignumber.js").BigNumber;
+            spender: string | undefined;
+            allowance: import("bignumber.js").BigNumber;
+            chainId: number;
+            account?: undefined;
+        } | null | undefined;
+    }[] | undefined;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@dodoex/api/dist/types/gql/graphql").Ve33_GetUserLockQuery, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+};
+export type Lock = NonNullable<ReturnType<typeof useFetchUserLocks>['userLocks']>['0'];
+export type Point = Awaited<ReturnType<ReturnType<typeof getFetchVE33VotingEscrowUserPointHistoryQueryOptions>['queryFn']>>;

package/dist/types/widgets/ve33/Ve33LockList/hooks/useIncreaseLock.d.ts

@@ -0,0 +1,6 @@
+export declare function useIncreaesLock({ refetch, }: {
+    refetch?: () => Promise<void> | void;
+}): import("@tanstack/react-query").UseMutationResult<void, Error, {
+    amount: string;
+    tokenId: number;
+}, unknown>;

package/dist/types/widgets/ve33/Ve33LockList/hooks/useMergeLock.d.ts

@@ -0,0 +1,5 @@
+export declare function useMergeLock({ fromTokenId, toTokenId, refetch, }: {
+    fromTokenId: number | undefined;
+    toTokenId: number | undefined;
+    refetch?: () => Promise<void> | void;
+}): import("@tanstack/react-query").UseMutationResult<void, Error, void, unknown>;

package/dist/types/widgets/ve33/Ve33LockList/hooks/useTransferLock.d.ts

@@ -0,0 +1,7 @@
+export declare function useTransferLock({ refetch, }: {
+    refetch?: () => Promise<void> | void;
+}): import("@tanstack/react-query").UseMutationResult<void, Error, {
+    tokenId: number;
+    fromAddress: string;
+    toAddress: string;
+}, unknown>;

package/dist/types/widgets/ve33/Ve33LockList/index.d.ts

@@ -0,0 +1 @@
+export default function Ve33LockList(): JSX.Element | undefined;

package/dist/types/widgets/ve33/Ve33LockOperate/hooks/useCreateLock.d.ts

@@ -0,0 +1,7 @@
+export declare function useCreateLock({ amount, decimals, symbol, lockDuration, refetch, }: {
+    amount: string;
+    decimals: number | undefined;
+    symbol?: string;
+    lockDuration: number;
+    refetch?: () => Promise<void> | void;
+}): import("@tanstack/react-query").UseMutationResult<void, Error, void, unknown>;

package/dist/types/widgets/ve33/Ve33LockOperate/hooks/useFetchUserTotalVeNFT.d.ts

@@ -0,0 +1,8 @@
+export declare function useFetchUserTotalVeNFT(chainId: number | undefined, account: string | undefined): {
+    totalNFT: bigint;
+    isLoading: boolean;
+    refetch: () => void;
+    fetchBalanceOf: import("@tanstack/react-query").UseQueryResult<bigint, Error>;
+    fetchTokenIds: import("@tanstack/react-query").UseQueryResult<bigint, Error>[];
+    fetchBalanceOfNFT: import("@tanstack/react-query").UseQueryResult<bigint, Error>[];
+};

package/dist/types/widgets/ve33/Ve33LockOperate/index.d.ts

@@ -0,0 +1,4 @@
+import { BoxProps } from '@dodoex/components';
+export default function Ve33LockOperate({ sx }: {
+    sx?: BoxProps['sx'];
+}): JSX.Element;

package/dist/types/widgets/ve33/Ve33LockOperate/utils.d.ts

@@ -0,0 +1,21 @@
+import BigNumber from 'bignumber.js';
+export declare const iMAXTIME: number;
+export declare const WEEK = 604800;
+export declare function getLockDurationRemainder(nowTime: number): number;
+/**
+ * @see https://github.com/velodrome-finance/contracts/blob/main/contracts/VotingEscrow.sol#L589
+ */
+export declare function getCreateLockNftPower(amount: string, lockDuration: number): BigNumber;
+export declare function getLockDurationByPointHistory(bias: string | BigNumber | bigint, slope: string | BigNumber | bigint): BigNumber;
+export declare function getAmountByPointHistory(slope: string | BigNumber | bigint): BigNumber;
+/**
+ * @see https://github.com/velodrome-finance/contracts/blob/main/contracts/libraries/BalanceLogicLibrary.sol#L90
+ */
+export declare function getVotingPowerByPointHistory(point: {
+    bias: bigint;
+    slope: bigint;
+    ts: bigint;
+    permanent: bigint;
+}, nowTime: number): BigNumber;
+export declare function getUnlockTimeTextShort(unlockTime: number): string;
+export declare function getUnlockTimeText(unlockTime: number): string;

package/dist/types/widgets/ve33/Ve33PoolDetail/MyAssets.d.ts

@@ -0,0 +1,5 @@
+import { Ve33PoolInfoI } from '../types';
+export default function MyAssets({ poolInfo, account, }: {
+    poolInfo?: Ve33PoolInfoI;
+    account?: string;
+}): JSX.Element;

package/dist/types/widgets/ve33/Ve33PoolDetail/MyPosition.d.ts

@@ -0,0 +1,5 @@
+import { Ve33PoolInfoI } from '../types';
+export default function MyPosition({ poolInfo, account, }: {
+    poolInfo?: Ve33PoolInfoI;
+    account: string;
+}): JSX.Element;

package/dist/types/widgets/ve33/Ve33PoolDetail/PoolInfo.d.ts

@@ -0,0 +1,5 @@
+import { Ve33PoolInfoI } from '../types';
+export default function PoolInfo({ poolInfo, isLoading, }: {
+    poolInfo?: Ve33PoolInfoI;
+    isLoading?: boolean;
+}): JSX.Element;