@dodoex/api 0.0.1 → 3.0.0-beta.0

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

@@ -0,0 +1,72 @@
+/** 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",
+    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/cjs/helper/ContractRequests/abi/index.d.ts

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

package/dist/cjs/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 declare type BatchThunk<T> = RequestThunk<T>[];
+declare type BatchThunkAll<Ts extends any[]> = {
+    [Tidx in keyof Ts]: Ts[Tidx] extends Ts[number] ? BatchThunk<Ts[Tidx]> : never;
+};
+declare 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/cjs/helper/ContractRequests/batchProvider.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+declare type Params = [
+    {
+        to: string;
+        data: string;
+    },
+    string
+];
+export declare class BatchProvider extends StaticJsonRpcProvider {
+    _pendingBatchAggregator: NodeJS.Timer | 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/cjs/helper/ContractRequests/contractConfig.d.ts

@@ -0,0 +1,26 @@
+export declare enum ChainId {
+    MAINNET = 1,
+    GOERLI = 5,
+    BSC = 56,
+    POLYGON = 137,
+    ARBITRUM_ONE = 42161,
+    AURORA = 1313161554,
+    OKCHAIN = 66,
+    OPTIMISM = 10,
+    AVALANCHE = 43114,
+    CONFLUX = 1030,
+    BASE = 8453,
+    LINEA = 59144,
+    SCROLL = 534352,
+    MANTA = 169,
+    MANTLE = 5000
+}
+declare const contractMap: {
+    [key in ChainId]: {
+        MULTI_CALL: string;
+        DODO_APPROVE: string;
+        ERC20_HELPER: string;
+        ROUTE_V1_DATA_FETCH: string;
+    };
+};
+export default contractMap;

package/dist/cjs/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/cjs/helper/ContractRequests/index.d.ts

@@ -0,0 +1,56 @@
+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 BigNumber from 'bignumber.js';
+export type { Query } from './type';
+export { ABIName } from './abi/abiName';
+declare 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): JsonRpcProvider;
+    /**
+     * 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/cjs/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/cjs/helper/GraphQLRequests.d.ts

@@ -0,0 +1,26 @@
+import crossFetch from 'cross-fetch';
+import { RequestDocument, Variables } from 'graphql-request';
+import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
+import { TypedDocumentString } from '../gql/graphql';
+declare type Fetch = typeof crossFetch;
+export interface GraphQLRequestsConfig {
+    url?: string;
+    fetch?: Fetch;
+}
+export default class GraphQLRequests {
+    private url;
+    private client;
+    constructor(configProps?: GraphQLRequestsConfig);
+    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 [TypedDocumentString<TResult, TVariables>, TVariables | undefined];
+        queryFn: () => Promise<TResult>;
+    };
+    getInfiniteQuery<TResult, TVariables>(document: TypedDocumentString<TResult, TVariables>, ...[variables]: TVariables extends Record<string, never> ? [] : [TVariables]): {
+        queryKey: readonly [TypedDocumentString<TResult, TVariables>, TVariables | undefined];
+        queryFn: ({ pageParam }: {
+            pageParam: number;
+        }) => Promise<TResult>;
+    };
+}
+export {};