@merkl/api 0.18.9 → 0.18.10

package/dist/src/routes/v3/router.d.ts

@@ -57,8 +57,8 @@ export declare const v3: Elysia<"/v3", false, {
                 params: {};
                 query: {
                     byReason?: boolean | undefined;
-                    chainId: number;
                     campaignId: string;
+                    chainId: number;
                 };
                 headers: unknown;
                 response: {
@@ -82,8 +82,9 @@ export declare const v3: Elysia<"/v3", false, {
                 };
                 headers: unknown;
                 response: {
-                    [x: string]: any;
-                    200: any;
+                    200: {
+                        [x: string]: Record<string, any>;
+                    };
                 };
             };
         };
@@ -391,8 +392,8 @@ export declare const v3: Elysia<"/v3", false, {
                 query: {
                     type?: number | undefined;
                     tag?: string | undefined;
-                    chainId?: number | undefined;
                     action?: string | undefined;
+                    chainId?: number | undefined;
                     campaigns?: boolean | undefined;
                     mainParameter?: string | undefined;
                     testTokens?: boolean | undefined;
@@ -446,8 +447,8 @@ export declare const v3: Elysia<"/v3", false, {
                 params: {};
                 query: {
                     index?: number | undefined;
-                    chainId: number;
                     campaign: any;
+                    chainId: number;
                 };
                 headers: unknown;
                 response: {
@@ -552,8 +553,8 @@ export declare const v3: Elysia<"/v3", false, {
                 body: unknown;
                 params: {};
                 query: {
-                    chainId: number;
                     campaignId: string;
+                    chainId: number;
                 };
                 headers: unknown;
                 response: {
@@ -621,8 +622,8 @@ export declare const v3: Elysia<"/v3", false, {
                     from?: number | undefined;
                     mainParameter?: string | undefined;
                     to?: number | undefined;
-                    chainId: number;
                     campaignId: string;
+                    chainId: number;
                 };
                 headers: unknown;
                 response: {
@@ -661,8 +662,8 @@ export declare const v3: Elysia<"/v3", false, {
                 body: unknown;
                 params: {};
                 query: {
-                    chainId: number;
                     address: string;
+                    chainId: number;
                 };
                 headers: unknown;
                 response: {

package/dist/src/routes/v3/token.d.ts

@@ -26,8 +26,8 @@ declare const _default: (app: Elysia) => Elysia<"", false, {
             body: unknown;
             params: {};
             query: {
-                chainId: number;
                 address: string;
+                chainId: number;
             };
             headers: unknown;
             response: {

package/dist/src/utils/execute.d.ts

@@ -1,12 +1,12 @@
-import type { TTLType } from "../cache/redis";
 import type { MultiCallDataType } from "../types";
 /**
  * Types
  */
-export type CachedResult<T> = {
+type CachedResult<T> = {
     cached: true;
     result: T;
 };
+type ComponentReturnType<T> = Promise<CachedResult<T> | UncachedResult<T>>;
 export type UncachedResult<T> = {
     cached: false;
     call: {
@@ -15,18 +15,8 @@ export type UncachedResult<T> = {
         handler: () => void;
     };
 };
-export type ComponentReturnType<T> = Promise<CachedResult<T> | UncachedResult<T>>;
-export type ComponentCallWithFallback<T> = {
-    call: ComponentReturnType<T>;
-    fallback: (args: T) => void;
-};
-export type BatchedMulticallComponentType = {
-    args: any[];
-    call: (...args: any[]) => Promise<UncachedResult<any>>;
-    fallback: (args: any) => void;
-    ttl: TTLType;
-};
 /**
  * Functions
  */
 export declare function executeSimple<T>(chainId: number, componentCall: ComponentReturnType<T>): Promise<T>;
+export {};

package/dist/src/utils/execute.js

@@ -1,4 +1,7 @@
-import { batchMulticallCall, multicallContractCall } from "./generic";
+// @ts-nocheck
+import { MAX_NUM_SUBCALLS } from "@/constants";
+import { withRetry } from "@sdk";
+import { constants } from "ethers";
 import { log } from "./logger";
 import { archiveMulticalls, multicalls } from "./providers";
 /**
@@ -39,3 +42,76 @@ const execute = async (chainId, callList, shouldRetry, blockNumber) => {
     }
     return [];
 };
+async function multicallContractCall(contract, args) {
+    let result;
+    try {
+        // TO SIMULATE - USE CAUTIOUSLY AS IT USES CREDITS
+        // console.log(
+        //   await callTenderly(
+        //     {
+        //       chainId: (await contract.provider.getNetwork()).chainId.toString(),
+        //       data: contract.interface.encodeFunctionData('aggregate', [args.data]),
+        //       from: !!args.from ? args.from : constants.AddressZero,
+        //       saveSimulation: true,
+        //       to: contract.address,
+        //       value: '0',
+        //     },
+        //     undefined,
+        //     true
+        //   )
+        // );
+        result = await contract.provider.call({
+            data: contract.interface.encodeFunctionData("aggregate3", [
+                args.data.map(c => {
+                    return {
+                        allowFailure: !!c.allowFailure,
+                        callData: c.callData,
+                        target: c.target,
+                    };
+                }),
+            ]),
+            from: !!args.from ? args.from : constants.AddressZero,
+            to: contract.address,
+        }, !!args.blockNumber ? args.blockNumber : undefined);
+    }
+    catch (e) {
+        log.error("multicallContractCall failed", e);
+        throw new Error("❌ failed to decode multicall data");
+    }
+    return contract.interface.decodeFunctionResult("aggregate3", result)[0].map((r) => r?.returnData);
+}
+async function batchMulticallCall(func, contract, args, shouldRetry = true) {
+    let callsLeft = args.data.length;
+    let lowerIdx = 0;
+    let upperIdx = Math.min(args.data.length, MAX_NUM_SUBCALLS);
+    const multicallBatch = [];
+    while (callsLeft !== 0) {
+        multicallBatch.push(shouldRetry
+            ? withRetry(func, [
+                // TODO: fix typing
+                contract,
+                {
+                    blockNumber: args.blockNumber,
+                    data: args.data.slice(lowerIdx, upperIdx),
+                },
+            ])
+            : func(contract, args));
+        callsLeft -= upperIdx - lowerIdx;
+        lowerIdx = upperIdx;
+        upperIdx = Math.min(args.data.length, upperIdx + MAX_NUM_SUBCALLS);
+    }
+    /** Executing batched multicall */
+    const results = await Promise.allSettled(multicallBatch);
+    let fetchedData = [];
+    for (let k = 0; k < results.length; k++) {
+        const res = results[k];
+        if (res.status === "fulfilled") {
+            fetchedData = fetchedData.concat(res.value);
+        }
+        else {
+            log.error(`batchMulticallCall failed to ${args.data[k].target}, data: ${args.data[k].callData}`, res);
+            fetchedData.concat("0x");
+        }
+    }
+    return fetchedData;
+}

package/dist/src/utils/generic.d.ts

@@ -1,23 +1,6 @@
-import { type MerklChainId, type Multicall } from "@sdk";
+import { type MerklChainId } from "@sdk";
 import { type BigNumberish } from "ethers";
 import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
-import type { MultiCallDataType } from "../types";
-export declare function multicallContractCall(contract: Multicall, args: {
-    data: MultiCallDataType;
-    blockNumber?: number | undefined;
-    from?: string;
-}): Promise<string[]>;
-export declare function batchMulticallCall(func: (contract: Multicall, args: {
-    data: Multicall3.Call3Struct[];
-    blockNumber?: number;
-}) => Promise<string[]>, contract: Multicall, args: {
-    data: Multicall3.Call3Struct[];
-    blockNumber?: number;
-}, shouldRetry?: boolean): Promise<string[]>;
-export declare function archiveContractMethodCall(contract: Multicall, args: {
-    calls: Multicall3.Call3Struct[];
-    blockNumber?: BigNumberish;
-}): Promise<Multicall3.ResultStructOutput[]>;
 export declare function batchMulticallCallWithRetry(chainId: MerklChainId, args: {
     calls: Multicall3.Call3Struct[];
     blockNumber?: BigNumberish;

package/dist/src/utils/generic.js

@@ -1,82 +1,8 @@
 import { withRetry } from "@sdk";
-import { constants, BigNumber } from "ethers";
+import { BigNumber } from "ethers";
 import { MAX_NUM_SUBCALLS } from "../constants";
-import { log } from "./logger";
 import { multicalls } from "./providers";
-export async function multicallContractCall(contract, args) {
-    let result;
-    try {
-        // TO SIMULATE - USE CAUTIOUSLY AS IT USES CREDITS
-        // console.log(
-        //   await callTenderly(
-        //     {
-        //       chainId: (await contract.provider.getNetwork()).chainId.toString(),
-        //       data: contract.interface.encodeFunctionData('aggregate', [args.data]),
-        //       from: !!args.from ? args.from : constants.AddressZero,
-        //       saveSimulation: true,
-        //       to: contract.address,
-        //       value: '0',
-        //     },
-        //     undefined,
-        //     true
-        //   )
-        // );
-        result = await contract.provider.call({
-            data: contract.interface.encodeFunctionData("aggregate3", [
-                args.data.map(c => {
-                    return {
-                        allowFailure: !!c.allowFailure,
-                        callData: c.callData,
-                        target: c.target,
-                    };
-                }),
-            ]),
-            from: !!args.from ? args.from : constants.AddressZero,
-            to: contract.address,
-        }, !!args.blockNumber ? args.blockNumber : undefined);
-    }
-    catch (e) {
-        log.error("multicallContractCall failed", e);
-        throw new Error("❌ failed to decode multicall data");
-    }
-    return contract.interface.decodeFunctionResult("aggregate3", result)[0].map((r) => r?.returnData);
-}
-export async function batchMulticallCall(func, contract, args, shouldRetry = true) {
-    let callsLeft = args.data.length;
-    let lowerIdx = 0;
-    let upperIdx = Math.min(args.data.length, MAX_NUM_SUBCALLS);
-    const multicallBatch = [];
-    while (callsLeft !== 0) {
-        multicallBatch.push(shouldRetry
-            ? withRetry(func, [
-                // TODO: fix typing
-                contract,
-                {
-                    blockNumber: args.blockNumber,
-                    data: args.data.slice(lowerIdx, upperIdx),
-                },
-            ])
-            : func(contract, args));
-        callsLeft -= upperIdx - lowerIdx;
-        lowerIdx = upperIdx;
-        upperIdx = Math.min(args.data.length, upperIdx + MAX_NUM_SUBCALLS);
-    }
-    /** Executing batched multicall */
-    const results = await Promise.allSettled(multicallBatch);
-    let fetchedData = [];
-    for (let k = 0; k < results.length; k++) {
-        const res = results[k];
-        if (res.status === "fulfilled") {
-            fetchedData = fetchedData.concat(res.value);
-        }
-        else {
-            log.error(`batchMulticallCall failed to ${args.data[k].target}, data: ${args.data[k].callData}`, res);
-            fetchedData.concat("0x");
-        }
-    }
-    return fetchedData;
-}
-export async function archiveContractMethodCall(contract, args) {
+async function archiveContractMethodCall(contract, args) {
     return contract.interface.decodeFunctionResult("aggregate3", !!args.blockNumber
         ? await contract.provider.call({
             data: contract.interface.encodeFunctionData("aggregate3", [args.calls]),

package/dist/src/utils/hashArray.d.ts

@@ -1 +1,2 @@
+export declare function sha256(x: string): string;
 export declare function hashArray(...args: any[]): string;

package/dist/src/utils/hashArray.js

@@ -1,4 +1,7 @@
-import { sha256 } from "../utils/crypto";
+import crypto from "node:crypto";
+export function sha256(x) {
+    return crypto.createHash("sha256").update(x).digest("hex");
+}
 export function hashArray(...args) {
     return args.length > 0 ? sha256(JSON.stringify(args.map(a => a.toString()))) : "";
 }

package/dist/src/utils/queries/allCampaigns.d.ts

@@ -1,6 +1,2 @@
 import { Prisma } from "@db/engine";
 export declare const ALL_CAMPAIGNS_FOR_CHAIN_AFTER: (chainId: number, after: number) => Prisma.Sql;
-export declare const ALL_CAMPAIGNS_FOR_CHAIN_BEFORE: (chainId: number, before: number) => Prisma.Sql;
-export declare const ALL_CAMPAIGNS_FOR_CHAIN: (chainId: number) => Prisma.Sql;
-export declare const ALL_CAMPAIGNS: () => Prisma.Sql;
-export declare const ALL_CAMPAIGNS_FOR_CHAINS_AND_CREATOR_TAG: (chainIds: number[], creatorTag: string) => Prisma.Sql;

package/dist/src/utils/queries/allCampaigns.js

@@ -10,42 +10,3 @@ export const ALL_CAMPAIGNS_FOR_CHAIN_AFTER = (chainId, after) => Prisma.sql `
         ("campaignParameters"->>'shouldIgnore' is null OR "campaignParameters"->>'shouldIgnore'='false')
         
     `;
-export const ALL_CAMPAIGNS_FOR_CHAIN_BEFORE = (chainId, before) => Prisma.sql `
-    SELECT
-        *
-    FROM "Campaigns"
-    WHERE
-        (("chainId" = ${chainId} AND "computeChainId" = 0) OR "computeChainId" = ${chainId}) AND
-        "campaignType" != 0 AND
-        "endTimestamp" < ${before} AND
-        ("campaignParameters"->>'shouldIgnore' is null OR "campaignParameters"->>'shouldIgnore'='false')
-    `;
-export const ALL_CAMPAIGNS_FOR_CHAIN = (chainId) => Prisma.sql `
-    SELECT
-        *
-    FROM "Campaigns"
-    WHERE
-        (("chainId" = ${chainId} AND "computeChainId" = 0) OR "computeChainId" = ${chainId}) AND
-        "campaignType" != 0 AND
-        ("campaignParameters"->>'shouldIgnore' is null OR "campaignParameters"->>'shouldIgnore'='false')
-    `;
-export const ALL_CAMPAIGNS = () => Prisma.sql `
-    SELECT
-        *
-    FROM "Campaigns"
-    WHERE
-        "campaignType" != 0 AND
-        ("campaignParameters"->>'shouldIgnore' is null OR "campaignParameters"->>'shouldIgnore'='false')
-    `;
-export const ALL_CAMPAIGNS_FOR_CHAINS_AND_CREATOR_TAG = (chainIds, creatorTag) => Prisma.sql `
-    SELECT
-        "chainId", "campaignId"
-    FROM "Campaigns"
-    WHERE
-        "campaignType" != 0 AND
-        (("chainId" IN (${Prisma.join(chainIds)}) AND "computeChainId" = 0) OR "computeChainId" IN (${Prisma.join(chainIds)})) AND
-        creator IN (
-            SELECT address from "CampaignCreators" WHERE tags LIKE ${`%${creatorTag}%`}
-        ) AND
-        ("campaignParameters"->>'shouldIgnore' is null OR "campaignParameters"->>'shouldIgnore'='false')
-    `;