@dodoex/api 0.0.1 → 1.0.0

package/dist/types/helper/ContractRequests/abi/ABIs/v3MiningABI.d.ts

@@ -0,0 +1,29 @@
+declare const _default: ({
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    outputs?: undefined;
+    stateMutability?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[];
+export default _default;

package/dist/types/helper/ContractRequests/abi/ABIs/vdodo.d.ts

@@ -0,0 +1,3 @@
+import type { ContractInterface } from '@ethersproject/contracts';
+declare const abi: ContractInterface;
+export default abi;

package/dist/types/helper/ContractRequests/abi/ABIs/vdodoTokenABI.d.ts

@@ -0,0 +1,40 @@
+declare const _default: ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+    name?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[];
+export default _default;

package/dist/types/helper/ContractRequests/abi/ABIs/weth.d.ts

@@ -0,0 +1,3 @@
+import type { ContractInterface } from '@ethersproject/contracts';
+declare const abis: ContractInterface;
+export default abis;

package/dist/types/helper/ContractRequests/abi/abiName.d.ts

@@ -0,0 +1,74 @@
+/** value needs to be consistent with the name of the json file under the ABI before it can be dynamically imported. */
+export declare enum ABIName {
+    customERC20IsMintable = "customERC20IsMintable",
+    customMultiCallAggregate = "customMultiCallAggregate",
+    erc20Helper = "erc20Helper",
+    erc20ABI = "erc20ABI",
+    erc20Mock = "erc20Mock",
+    dodoERC20V3Factory = "dodoERC20V3Factory",
+    dodoCustomMintableERC20 = "dodoCustomMintableERC20",
+    multicallABI = "multicallABI",
+    dppPoolABI = "dppPoolABI",
+    dvmPoolABI = "DVM",
+    classicalPoolABI = "classicalPoolABI",
+    v3MiningABI = "v3MiningABI",
+    dodoMiningABI = "dodoMiningABI",
+    dodoCP = "dodoCP",
+    dodoCPABI = "dodoCPABI",
+    dodoCPABIV2 = "dodoCPABIV2",
+    dodoCpProxyV2 = "dodoCpProxyV2",
+    dodoCpProxyV202 = "dodoCpProxyV202",
+    dodoFeeImpl = "dodoFeeImpl",
+    feeABI = "feeABI",
+    vdodo = "vdodo",
+    vdodoTokenABI = "vdodoTokenABI",
+    dodoPreminingABI = "dodoPreminingABI",
+    MerkleDistributorABI = "MerkleDistributorABI",
+    DODOCirculationHelperABI = "DODOCirculationHelperABI",
+    FundingABI = "FundingABI",
+    dodoStarterProxy = "dodoStarterProxy",
+    MarginTrading = "MarginTrading",
+    MarginTradingFactory = "MarginTradingFactory",
+    DODORouteProxy = "DODORouteProxy",
+    dodoProxyV2 = "dodoProxyV2",
+    AaveLendingPoolABI = "AaveLendingPoolABI",
+    AaveProtocolDataProviderABI = "AaveProtocolDataProviderABI",
+    AaveLendingPoolAddressesProvider = "AaveLendingPoolAddressesProvider",
+    AavePriceOracleABI = "AavePriceOracleABI",
+    spaceIdABI = "spaceIdABI",
+    spaceIdResolverABI = "spaceIdResolverABI",
+    /** classical pool */
+    dodoABI = "dodoABI",
+    /** pancake pair pool */
+    PancakePairABI = "PancakePairABI",
+    NonfungiblePositionManager = "NonfungiblePositionManager",
+    UniswapV3Pool = "UniswapV3Pool",
+    dodoDspProxy = "dodoDspProxy",
+    dodoDppProxy = "dodoDppProxy",
+    IdodoV2 = "IdodoV2",
+    dodoDPPAdmin = "dodoDPPAdmin",
+    dodoDSP = "dodoDSP",
+    dodoDVM = "dodoDVM",
+    dodoDSPFactory = "dodoDSPFactory",
+    dodoDVMFactory = "dodoDVMFactory",
+    D3Proxy = "D3Proxy",
+    dodoNftERC721 = "dodoNftERC721",
+    dodoNftERC1155 = "dodoNftERC1155",
+    dodoDropsProxy = "dodoDropsProxy",
+    dodoNftVault = "dodoNftVault",
+    dodoNftProxy = "dodoNftProxy",
+    dodoFragment = "dodoFragment",
+    dodoBuyoutModel = "dodoBuyoutModel",
+    dodoNftPoolProxy = "dodoNftPoolProxy",
+    nftFilterAdmin = "nftFilterAdmin",
+    baseFilterV1 = "baseFilterV1",
+    FilterERC721V1 = "FilterERC721V1",
+    FilterERC1155V1 = "FilterERC1155V1",
+    dodoV1PairProxy = "dodoV1PairProxy",
+    dodoPair = "dodoPair",
+    dodoMineV3Proxy = "dodoMineV3Proxy",
+    dodoMineV3ProxyOld = "dodoMineV3ProxyOld",
+    LockedTokenVaultABI = "LockedTokenVaultABI",
+    DODOV1PmmHelperABI = "DODOV1PmmHelperABI",
+    D3MM_READ_ABI = "D3MM_READ_ABI"
+}

package/dist/types/helper/ContractRequests/abi/index.d.ts

@@ -0,0 +1,2 @@
+import { ABIName } from './abiName';
+export declare function getABI(abiName: ABIName): Promise<any>;

package/dist/types/helper/ContractRequests/batch.d.ts

@@ -0,0 +1,18 @@
+import { Contract } from '@ethersproject/contracts';
+interface Web3CallData {
+    to: string;
+    data: string;
+}
+interface RequestThunk<T> {
+    callData: Web3CallData | null;
+    processor: (_: any, index: number) => T;
+}
+export type BatchThunk<T> = RequestThunk<T>[];
+type BatchThunkAll<Ts extends any[]> = {
+    [Tidx in keyof Ts]: Ts[Tidx] extends Ts[number] ? BatchThunk<Ts[Tidx]> : never;
+};
+type BatchThunkAllResult<Ts extends any[]> = {
+    [Tidx in keyof Ts]: Ts[Tidx] extends Ts[number] ? Array<Ts[Tidx]> : never;
+};
+export declare function runAll<Ts extends any[]>(contract: Contract, contractAddress: string, ...batches: BatchThunkAll<Ts>): Promise<BatchThunkAllResult<Ts>>;
+export {};

package/dist/types/helper/ContractRequests/batchProvider.d.ts

@@ -0,0 +1,25 @@
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+type Params = [
+    {
+        to: string;
+        data: string;
+    },
+    string
+];
+export declare class BatchProvider extends StaticJsonRpcProvider {
+    _pendingBatchAggregator: any | null;
+    _pendingBatch: Array<{
+        request: {
+            method: string;
+            params: Params;
+            id: number;
+            jsonrpc: '2.0';
+        };
+        resolve: (result: any) => void;
+        reject: (error: Error) => void;
+    }> | null;
+    _provider: StaticJsonRpcProvider | null;
+    setProvider(provider: StaticJsonRpcProvider | null): void;
+    send(method: string, params: Params): Promise<any>;
+}
+export {};

package/dist/types/helper/ContractRequests/encode.d.ts

@@ -0,0 +1,6 @@
+import { Interface } from '@ethersproject/abi';
+import type { BytesLike } from '@ethersproject/bytes';
+import { ABIName } from './abi/abiName';
+export declare const encodeFunctionData: (abiName: ABIName, functionFragment: string, values: ReadonlyArray<any>) => Promise<string>;
+export declare const encodeFunctionDataByFragments: (fragments: ConstructorParameters<typeof Interface>[0], functionFragment: string, values: ReadonlyArray<any>) => string;
+export declare const decodeFunctionResult: (abiName: ABIName, functionFragment: string, data: BytesLike) => Promise<import("@ethersproject/abi").Result>;

package/dist/types/helper/ContractRequests/index.d.ts

@@ -0,0 +1,58 @@
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import type { JsonRpcProvider } from '@ethersproject/providers';
+import { Contract, ContractInterface as ContractInterfaceSource } from '@ethersproject/contracts';
+import { ChainId } from '../../chainConfig';
+import { ABIName } from './abi/abiName';
+import type { Query } from './type';
+import { Interface } from '@ethersproject/abi';
+import { BatchProvider } from './batchProvider';
+import BigNumber from 'bignumber.js';
+export declare const CONTRACT_QUERY_KEY = "contract-query";
+export type { Query } from './type';
+export { ABIName } from './abi/abiName';
+type ContractInterface = Exclude<ContractInterfaceSource, Interface>;
+export interface ContractRequestsConfig {
+    debugQuery?: boolean;
+    debugProvider?: boolean;
+    rpc?: {
+        [chainId: number]: string;
+    };
+    getProvider?: (chainId: number) => JsonRpcProvider | StaticJsonRpcProvider | null;
+}
+export default class ContractRequests {
+    private debugQuery?;
+    private debugProvider?;
+    private rpc?;
+    private getConfigProvider?;
+    private staticJsonRpcProviderMap;
+    private batchStaticJsonRpcProviderMap;
+    private batchContractMap;
+    /** Used to maintain different batches of requests */
+    private subContractRequestsList;
+    constructor(config?: ContractRequestsConfig);
+    setRpc(rpc: ContractRequestsConfig['rpc']): void;
+    setGetConfigProvider(getProvider: ContractRequestsConfig['getProvider']): void;
+    getProvider(chainId: number): JsonRpcProvider;
+    getBatchProvider(chainId: number): BatchProvider;
+    /**
+     * Create ContractRequests of the same configuration.
+     * Updating the configuration of the current ContractRequests will also update the created ContractRequests.
+     * Mainly used for different batches of requests
+     */
+    createContractRequests(): ContractRequests;
+    getContract(chainId: number, contractAddress: string, contractInterface: ContractInterface): Contract;
+    getBatchContract(chainId: number, contractAddress: string, contractInterface: ContractInterface): Contract;
+    getBatchContractByAbiName(chainId: number, contractAddress: string, abiName: ABIName): Promise<Contract>;
+    getContractInterface(abiName: ABIName): Promise<any>;
+    /**
+     * Use multiCall contract request
+     */
+    callMultiQuery<T = any>(chainId: ChainId, queryList: Array<Query<T>>): Promise<T>;
+    callQuery<T = any>(chainId: ChainId, query: Query<T>): Promise<T>;
+    /**
+     * Multiple requests within a short period of time will be packaged for batch processing.
+     */
+    batchCallQuery<T = any>(chainId: ChainId, query: Query<T>): Promise<T>;
+    getBlockNumber(chainId: ChainId): Promise<number>;
+    getETHBalance(chainId: ChainId, account: string): Promise<BigNumber>;
+}

package/dist/types/helper/ContractRequests/type.d.ts

@@ -0,0 +1,8 @@
+import { ABIName } from './abi/abiName';
+export interface Query<T = any> {
+    abiName: ABIName;
+    contractAddress: string;
+    method: string;
+    params: readonly any[];
+    callback?: (res: T) => T | undefined;
+}

package/dist/types/helper/GraphQLRequests.d.ts

@@ -0,0 +1,30 @@
+import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
+import crossFetch from 'cross-fetch';
+import { RequestDocument, Variables } from 'graphql-request';
+import { GraphQLClientRequestHeaders } from 'graphql-request/build/esm/types';
+import { TypedDocumentString } from '../gql/graphql';
+type Fetch = typeof crossFetch;
+export interface GraphQLRequestsConfig {
+    url?: string;
+    fetch?: Fetch;
+    getHeaders?: () => GraphQLClientRequestHeaders | Promise<GraphQLClientRequestHeaders>;
+}
+export default class GraphQLRequests {
+    private url;
+    private client;
+    private getHeaders?;
+    constructor(configProps?: GraphQLRequestsConfig);
+    setHeaders(): Promise<void>;
+    getData<T, V extends Variables = Variables>(document: RequestDocument | TypedDocumentNode<T, V>, variables?: V): Promise<T>;
+    getQuery<TResult, TVariables>(document: TypedDocumentString<TResult, TVariables>, ...[variables]: TVariables extends Record<string, never> ? [] : [TVariables]): {
+        queryKey: readonly ["graphql", "getQuery", TypedDocumentString<TResult, TVariables>, TVariables | undefined];
+        queryFn: () => Promise<TResult>;
+    };
+    getInfiniteQuery<TResult, TVariables>(document: TypedDocumentString<TResult, TVariables>, pageKey: string, ...[variables]: TVariables extends Record<string, never> ? [] : [TVariables]): {
+        queryKey: readonly ["graphql", "getInfiniteQuery", string, TypedDocumentString<TResult, TVariables>, TVariables | undefined];
+        queryFn: ({ pageParam }: {
+            pageParam: number;
+        }) => Promise<TResult>;
+    };
+}
+export {};

package/dist/{cjs → types}/helper/RestApiRequests.d.ts

@@ -1,5 +1,5 @@
 import crossFetch from 'cross-fetch';
-declare type Fetch = typeof crossFetch;
+type Fetch = typeof crossFetch;
 export interface RestApiRequestConfig {
     host?: string;
     fetch?: Fetch;
@@ -17,7 +17,7 @@ export default class RestApiRequest {
             data: T | null;
         };
     }>;
-    getJson<T>(path: string, params?: Record<string, any>): Promise<{
+    getJson<T>(path: string, params?: Record<string, any>, init?: RequestInit): Promise<{
         response: Response;
         result: {
             code: number;
@@ -25,7 +25,7 @@ export default class RestApiRequest {
             data: T | null;
         };
     }>;
-    postJson<T = any>(path: string, body?: Record<string, any>, params?: Record<string, any>): Promise<{
+    postJson<T = any>(path: string, body?: Record<string, any>, params?: Record<string, any>, init?: RequestInit): Promise<{
         response: Response;
         result: {
             code: number;

package/dist/types/index.d.ts

@@ -0,0 +1,17 @@
+export { setContractRequests } from '@dodoex/dodo-contract-request';
+export { ChainId, basicTokenMap, contractConfig, etherTokenAddress, platformIdMap, } from './chainConfig';
+export { ABIName, CONTRACT_QUERY_KEY, default as ContractRequests, } from './helper/ContractRequests';
+export type { ContractRequestsConfig, Query } from './helper/ContractRequests';
+export { default as GraphQLRequests } from './helper/GraphQLRequests';
+export { default as RestApiRequests } from './helper/RestApiRequests';
+export { AMMV3Api } from './services/ammv3';
+export type { TickData, Ticks } from './services/ammv3';
+export { PMMHelper, PMMModel, PMMState, PoolApi, getPmmModel, solveQuadraticFunctionForTarget, } from './services/pool';
+export type { PmmModelParams, PoolType } from './services/pool';
+export { SwapWidgetApi } from './services/SwapWidgetApi';
+export { MiningApi, MiningStatusE } from './services/mining';
+export type { MiningMiningInfo } from './services/mining';
+export { TokenApi } from './services/TokenApi';
+export { SwapApi } from './services/swap/SwapApi';
+export { SystemApi } from './services/system/SystemApi';
+export type ExcludeNone<T> = NonNullable<T>;

package/dist/{services → types/services}/SwapWidgetApi.d.ts

@@ -1,4 +1,4 @@
-import RestApiRequest, { RestApiRequestConfig } from '../helper/RestApiRequests';
+import RestApiRequest from '../helper/RestApiRequests';
 interface WidgetConfigBasis {
     crossChainSupport: boolean;
     swapSlippage?: string;
@@ -57,13 +57,29 @@ export interface ConfigTokenList {
     }>;
     rebateAddress: string | null;
     rebateRatio: number | null;
-    swapSlippage: number | null;
+    swapSlippage: number | null | undefined;
     crossChainSlippage: number | null;
     basis?: WidgetConfigBasis;
     style?: WidgetConfigColor;
 }
-export declare class SwapWidgetApi extends RestApiRequest {
-    constructor(configProps?: RestApiRequestConfig);
+interface TokenInfo {
+    readonly chainId: number;
+    readonly address: string;
+    readonly name: string;
+    readonly decimals: number;
+    readonly symbol: string;
+    readonly logoURI?: string;
+    readonly tags?: string[];
+    readonly extensions?: any;
+    readonly side?: 'from' | 'to';
+}
+type TokenList = TokenInfo[];
+export interface SwapWidgetApiProps {
+    restApiRequest?: RestApiRequest;
+}
+export declare class SwapWidgetApi {
+    restApiRequest: RestApiRequest;
+    constructor(configProps?: SwapWidgetApiProps);
     getWidgetTokenListConfig(projectId: string, apikey: string): Promise<{
         response: Response;
         result: {
@@ -72,9 +88,39 @@ export declare class SwapWidgetApi extends RestApiRequest {
             data: ConfigTokenList | null;
         };
     }>;
-    convertConfigToSwapWidgetProps(configTokenList: ConfigTokenList): import("@dodoex/widgets/dist/src/components/Widget").WidgetProps;
+    convertConfigToSwapWidgetProps(configTokenList: ConfigTokenList): {
+        tokenList: TokenList;
+        theme: any;
+        rebateAddress: string | null;
+        rebateRatio: number | null;
+        swapSlippage: number | null | undefined;
+        bridgeSlippage: number | null;
+        width: string | undefined;
+        height: string | undefined;
+        locale: "en-US" | "zh-CN" | undefined;
+        crossChain: boolean;
+        jsonRpcUrlMap: {
+            [key: number]: string[];
+        } | undefined;
+        noPowerBy: boolean | undefined;
+    };
     getConfigSwapWidgetProps(projectId: string, apikey: string): Promise<{
-        swapWidgetProps: import("@dodoex/widgets/dist/src/components/Widget").WidgetProps;
+        swapWidgetProps: {
+            tokenList: TokenList;
+            theme: any;
+            rebateAddress: string | null;
+            rebateRatio: number | null;
+            swapSlippage: number | null | undefined;
+            bridgeSlippage: number | null;
+            width: string | undefined;
+            height: string | undefined;
+            locale: "en-US" | "zh-CN" | undefined;
+            crossChain: boolean;
+            jsonRpcUrlMap: {
+                [key: number]: string[];
+            } | undefined;
+            noPowerBy: boolean | undefined;
+        };
         configTokenList: ConfigTokenList;
     }>;
 }

package/dist/types/services/TokenApi/graphqlQuery.d.ts

@@ -0,0 +1,8 @@
+export declare const tokenGraphqlQuery: {
+    fetchErc20SwapCrossList: import("../../gql/graphql").TypedDocumentString<import("../../gql/graphql").FetchErc20SwapCrossChainListQuery, import("../../gql/graphql").Exact<{
+        where?: import("../../gql/graphql").InputMaybe<import("../../gql/graphql").Erc20listV2Filter>;
+    }>>;
+    fetchErc20ForecastSlippage: import("../../gql/graphql").TypedDocumentString<import("../../gql/graphql").FetchErc20ForecastSlippageQuery, import("../../gql/graphql").Exact<{
+        where?: import("../../gql/graphql").InputMaybe<import("../../gql/graphql").Erc20_Extenderc20ExtendV2Filter>;
+    }>>;
+};

package/dist/types/services/TokenApi/index.d.ts

@@ -0,0 +1,71 @@
+import ContractRequests, { ContractRequestsConfig } from '../../helper/ContractRequests';
+import BigNumber from 'bignumber.js';
+import { ChainId } from '../../chainConfig';
+import RestApiRequest from '../../helper/RestApiRequests';
+export interface TokenApiProps {
+    contractRequests?: ContractRequests;
+    contractRequestsConfig?: ContractRequestsConfig;
+    restApiRequest?: RestApiRequest;
+}
+export declare class TokenApi {
+    contractRequests: ContractRequests;
+    restApiRequest: RestApiRequest;
+    constructor(config: TokenApiProps);
+    static graphql: {
+        fetchErc20SwapCrossList: import("../../gql/graphql").TypedDocumentString<import("../../gql/graphql").FetchErc20SwapCrossChainListQuery, import("../../gql/graphql").Exact<{
+            where?: import("../../gql/graphql").InputMaybe<import("../../gql/graphql").Erc20listV2Filter>;
+        }>>;
+        fetchErc20ForecastSlippage: import("../../gql/graphql").TypedDocumentString<import("../../gql/graphql").FetchErc20ForecastSlippageQuery, import("../../gql/graphql").Exact<{
+            where?: import("../../gql/graphql").InputMaybe<import("../../gql/graphql").Erc20_Extenderc20ExtendV2Filter>;
+        }>>;
+    };
+    static utils: {
+        isSameAddress: (tokenAddress1: string, tokenAddress2: string) => boolean;
+    };
+    static encode: {
+        approveABI(contractAddress: string, allowance: BigNumber): Promise<string>;
+        transferEncodeABI(receiverAddress: string, amount: string): Promise<string>;
+    };
+    getTokenDecimals(chainId: number | undefined, address: string | undefined): {
+        queryKey: (string | number | undefined)[];
+        enabled: boolean;
+        queryFn: () => Promise<number | null>;
+    };
+    getFiatPriceBatch(tokens: Array<{
+        chainId: ChainId;
+        address: string;
+        symbol: string;
+    }>, token: string): Promise<{
+        response: Response;
+        result: {
+            code: number;
+            msg: string | null;
+            data: any;
+        };
+    }>;
+    getFetchTokenQuery(chainId: number | undefined, address: string | undefined, account: string | undefined, spender?: string): {
+        queryKey: (string | number | undefined)[];
+        enabled: boolean;
+        queryFn: () => Promise<{
+            symbol: string;
+            address: string;
+            name: string;
+            decimals: number;
+            balance: BigNumber;
+            allowance: BigNumber;
+            account: string;
+            spender: string | undefined;
+            chainId: number;
+        } | {
+            address: string;
+            decimals: number;
+            symbol: string;
+            name: string;
+            balance: BigNumber;
+            spender: string | undefined;
+            allowance: BigNumber;
+            chainId: number;
+            account?: undefined;
+        } | null>;
+    };
+}

package/dist/types/services/TokenApi/tokenBlackList/bsc.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/dist/types/services/TokenApi/tokenBlackList/eth.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/dist/types/services/TokenApi/tokenBlackList/index.d.ts

@@ -0,0 +1 @@
+export declare const getTokenBlackList: (chainId: number) => Promise<string[]>;

package/dist/types/services/TokenApi/utils.d.ts

@@ -0,0 +1 @@
+export declare const isSameAddress: (tokenAddress1: string, tokenAddress2: string) => boolean;

package/dist/types/services/ammv3/AMMV3Api.d.ts

@@ -0,0 +1,58 @@
+import BigNumber from 'bignumber.js';
+import ContractRequests, { ContractRequestsConfig } from '../../helper/ContractRequests';
+export interface AMMV3ApiProps {
+    contractRequests?: ContractRequests;
+    contractRequestsConfig?: ContractRequestsConfig;
+}
+export declare class AMMV3Api {
+    contractRequests: ContractRequests;
+    constructor(config: AMMV3ApiProps);
+    static graphql: {
+        AllV3TicksDocument: import("../../gql/graphql").TypedDocumentString<import("../../gql/graphql").TicksQuery, import("../../gql/graphql").Exact<{
+            where?: import("../../gql/graphql").InputMaybe<import("../../gql/graphql").Tick_Filter>;
+            skip?: import("../../gql/graphql").InputMaybe<import("../../gql/graphql").Scalars["Int"]["input"]>;
+            first?: import("../../gql/graphql").InputMaybe<import("../../gql/graphql").Scalars["Int"]["input"]>;
+        }>>;
+    };
+    static utils: {
+        getIsV3Mining(type: import("../pool").PoolType): boolean;
+        singleSideLp(type: import("../pool").PoolType): boolean;
+        canOperateLiquidity(type?: import("../pool").PoolType, owner?: string, creator?: string, account?: string): boolean;
+    };
+    static encode: {};
+    getPositions(chainId: number | undefined, contractAddress: string | undefined, inputs: string[][]): {
+        queryKey: any[];
+        enabled: boolean;
+        queryFn: () => Promise<any>;
+    };
+    getOwner(chainId: number | undefined, contractAddress: string | undefined, tokenId: string): {
+        queryKey: any[];
+        enabled: boolean;
+        queryFn: () => Promise<any>;
+    };
+    getBalanceOf(chainId: number | undefined, contractAddress: string | undefined, account: string | undefined): {
+        queryKey: any[];
+        enabled: boolean;
+        queryFn: () => Promise<BigNumber | null>;
+    };
+    getTokenOfOwnerByIndex(chainId: number | undefined, contractAddress: string | undefined, tokenIdsArgs: (string | number)[][]): {
+        queryKey: any[];
+        enabled: boolean;
+        queryFn: () => Promise<any>;
+    };
+    getV3PoolSlot0(chainId: number | undefined, poolAddress: string | undefined): {
+        queryKey: any[];
+        enabled: boolean;
+        queryFn: () => Promise<any>;
+    };
+    getV3PoolLiquidity(chainId: number | undefined, poolAddress: string | undefined): {
+        queryKey: any[];
+        enabled: boolean;
+        queryFn: () => Promise<any>;
+    };
+    getCollect(chainId: number | undefined, contractAddress: string | undefined, tokenId: string, recipient: string): {
+        queryKey: any[];
+        enabled: boolean;
+        queryFn: () => Promise<any>;
+    };
+}

package/dist/types/services/ammv3/index.d.ts

@@ -0,0 +1,4 @@
+import { TicksQuery } from '../../gql/graphql';
+export { AMMV3Api } from './AMMV3Api';
+export type Ticks = NonNullable<TicksQuery['ticks']>;
+export type TickData = Ticks[number];

package/dist/types/services/ammv3/queries.d.ts

@@ -0,0 +1,5 @@
+export declare const AllV3TicksDocument: import("../../gql/graphql").TypedDocumentString<import("../../gql/graphql").TicksQuery, import("../../gql/graphql").Exact<{
+    where?: import("../../gql/graphql").InputMaybe<import("../../gql/graphql").Tick_Filter>;
+    skip?: import("../../gql/graphql").InputMaybe<import("../../gql/graphql").Scalars["Int"]["input"]>;
+    first?: import("../../gql/graphql").InputMaybe<import("../../gql/graphql").Scalars["Int"]["input"]>;
+}>>;