@merkl/api 0.20.3 → 0.20.5

package/dist/src/engine/dynamicData/utils/getEulerV2Vaults.js

@@ -1,7 +1,6 @@
-import { Redis } from "@/cache";
 import { fetchEulerVaultName } from "@/engine/erc20SubTypeProcessors/helpers/eulerVaultNames";
 import { batchMulticallCallWithRetry } from "@/utils/generic";
-import { log } from "@/utils/logger";
+import { log, logger } from "@/utils/logger";
 import { providers } from "@/utils/providers";
 import { apiDbClient } from "@db";
 import { ChainInteractionService, ERC20Interface, EULER_ADDRESSES, EulerEVKInterface, EulerVaultLensInterface, EulerVault__factory, NETWORK_LABELS, eulerChainIds, getContractCreationBlock, } from "@sdk";
@@ -27,59 +26,93 @@ async function computeCollatListAndReturnVaults(chainId, vaults) {
             };
         }),
     });
-    const callsCollatUnderlying = [];
-    const callsCollatUnderlyingSymbol = [];
+    const callsToCollat = [];
+    const callsToCollatUnderlying = [];
+    // To keep track of all collat data
+    const collateralDataArray = [];
+    let k = 0;
     for (const [index, vault] of vaults.entries()) {
         const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
         for (const collat of collatArray) {
+            // FIXME
             if (!!vault.collaterals &&
-                vault.collaterals.map(c => c.address.toLowerCase()).includes(collat.collateral.toLowerCase()))
+                vault.collaterals.map(c => c.address.toLowerCase()).includes(collat.collateral.toLowerCase())) {
                 continue;
+            }
             log.info(`🦭 found new collateral ${collat.collateral} for vault ${vault.address} (${NETWORK_LABELS[chainId]})`);
-            callsCollatUnderlying.push({
+            collateralDataArray.push({ vaultAddress: vault.address, address: collat.collateral, callsToCollatIndex: k });
+            k++;
+            callsToCollat.push({
                 allowFailure: true,
-                callData: EulerEVKInterface.encodeFunctionData("asset"),
+                callData: EulerEVKInterface.encodeFunctionData("symbol"),
                 target: collat.collateral,
             }, {
                 allowFailure: true,
-                callData: EulerEVKInterface.encodeFunctionData("symbol"),
+                callData: EulerEVKInterface.encodeFunctionData("asset"),
                 target: collat.collateral,
             });
         }
     }
-    const resCollatUnderlying = await batchMulticallCallWithRetry(chainId, {
-        calls: callsCollatUnderlying,
+    const resCallsToCollat = await batchMulticallCallWithRetry(chainId, {
+        calls: callsToCollat,
     });
-    for (let i = 0; i < resCollatUnderlying.length; i = i + 2) {
-        const underlyingToken = EulerEVKInterface.decodeFunctionResult("asset", resCollatUnderlying[i].returnData)[0];
-        callsCollatUnderlyingSymbol.push({
-            allowFailure: true,
-            callData: ERC20Interface.encodeFunctionData("symbol"),
-            target: underlyingToken,
+    let j = 0;
+    for (let i = 0; i < resCallsToCollat.length; i = i + 2) {
+        const collatData = collateralDataArray.find(collat => collat.callsToCollatIndex === i / 2);
+        try {
+            // 1_ Collat symbol
+            const symbolCollateral = EulerEVKInterface.decodeFunctionResult("symbol", resCallsToCollat[i].returnData)[0];
+            collatData.symbolCollateral = symbolCollateral;
+            // 2_ Underlying asset => warning it can be undefined and throw an error
+            const underlyingToken = EulerEVKInterface.decodeFunctionResult("asset", resCallsToCollat[i + 1].returnData)[0];
+            callsToCollatUnderlying.push({
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("symbol"),
+                target: underlyingToken,
+            });
+            collatData.callsToCollatUnderlyingIndex = j;
+            j++;
+        }
+        catch {
+            logger.warn(`🦭 error while decoding underlying token address for collat ${JSON.stringify(collatData)}`);
+        }
+    }
+    let resCallsToCollatUnderlying;
+    if (callsToCollatUnderlying.length > 0) {
+        resCallsToCollatUnderlying = await batchMulticallCallWithRetry(chainId, {
+            calls: callsToCollatUnderlying,
         });
     }
-    const resCollatUnderlyingSymbol = await batchMulticallCallWithRetry(chainId, {
-        calls: callsCollatUnderlyingSymbol,
-    });
     vaultsPerChain = vaultsPerChain.concat((await Promise.all(vaults.map(async (vault, index) => {
         const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
         if (!vault.collaterals)
             vault.collaterals = [];
-        let offset = 0;
         for (const [_index, collat] of collatArray.entries()) {
             // _ Check whether the collat was already registered
             if (!!vault.collaterals &&
                 vault.collaterals.map(c => c.address.toLowerCase()).includes(collat.collateral.toLowerCase())) {
-                offset += 1;
                 continue;
             }
-            const symbolUnderlying = ERC20Interface.decodeFunctionResult("symbol", resCollatUnderlyingSymbol[_index - offset].returnData)[0];
+            const collatData = collateralDataArray.find(c => c.vaultAddress?.toLowerCase() === vault.address?.toLowerCase() && c.address === collat.collateral);
+            if (!collatData || collatData.address !== collat.collateral) {
+                logger.warn(`🦭 issue when fetching data for collat ${collat.collateral} on vault ${vault.address}`);
+                console.log(collatData, collat.collateral);
+                process.exit(1);
+            }
+            // Collateral symbol
+            const symbolCollateral = collatData.symbolCollateral ?? "Unknown";
+            // Collat underlying symbol
+            let symbolUnderlying = "Unknown";
+            try {
+                symbolUnderlying = ERC20Interface.decodeFunctionResult("symbol", resCallsToCollatUnderlying[collatData.callsToCollatUnderlyingIndex ?? -1].returnData)[0];
+            }
+            catch { }
             vault.collaterals.push({
                 address: collat.collateral,
-                symbolCollateral: EulerEVKInterface.decodeFunctionResult("symbol", resCollatUnderlying[2 * (_index - offset) + 1].returnData)[0],
-                symbolUnderlying,
+                symbolCollateral: symbolCollateral,
+                symbolUnderlying: symbolUnderlying,
                 borrowLTV: collat.borrowLTV.toString(),
-                nameCollateral: (await fetchEulerVaultName(collat.collateral, chainId)) ?? symbolUnderlying,
+                nameCollateral: (await fetchEulerVaultName(collat.collateral, chainId)) ?? symbolCollateral,
             });
         }
         return { ...vault };
@@ -113,20 +146,26 @@ export async function getEulerV2Vaults() {
             }
             const logs = await safeFetchLogs(chainId, [EulerEVKInterface.getEventTopic("EVaultCreated")], [], fromBlock, toBlock);
             const decodedVaults = await Promise.all(logs.map(async (log) => {
-                const aux = EulerEVKInterface.decodeEventLog("EVaultCreated", log.data, log.topics);
-                const name = (await EulerVault__factory.connect(log.address, providers[chainId]).name()).split(" ");
-                const vaultName = (await fetchEulerVaultName(getAddress(log.address), chainId)) ?? name[name.length - 1];
-                /** Respect the previous typing */
-                return {
-                    address: log.address.toString(),
-                    asset: aux[1].toString(),
-                    fetchedAtBlock: Number(log.blockNumber),
-                    chainId: chainId,
-                    debtTokenAddress: aux[2].toString(),
-                    name: vaultName,
-                };
+                try {
+                    const aux = EulerEVKInterface.decodeEventLog("EVaultCreated", log.data, log.topics);
+                    const name = (await EulerVault__factory.connect(log.address, providers[chainId]).name()).split(" ");
+                    const vaultName = (await fetchEulerVaultName(getAddress(log.address), chainId)) ?? name[name.length - 1];
+                    /** Respect the previous typing */
+                    return {
+                        address: log.address.toString(),
+                        asset: aux[1].toString(),
+                        fetchedAtBlock: Number(log.blockNumber),
+                        chainId: chainId,
+                        debtTokenAddress: aux[2].toString(),
+                        name: vaultName,
+                    };
+                }
+                catch {
+                    logger.warn(`issue when fetching data on ${NETWORK_LABELS[chainId]} for vault ${log.address}`);
+                    process.exit(1);
+                }
             }));
-            log.local(`fetched ${decodedVaults.length} vaults(s) on ${NETWORK_LABELS[chainId]} between blocks ${fromBlock} and ${toBlock}`);
+            log.info(`fetched ${decodedVaults.length} vaults(s) on ${NETWORK_LABELS[chainId]} between blocks ${fromBlock} and ${toBlock}`);
             vaultsPerChain = await computeCollatListAndReturnVaults(chainId, decodedVaults);
             return vaultsPerChain;
         }
@@ -160,14 +199,12 @@ export async function getEulerV2Vaults() {
             throw new Error("Error while saving vaults to API database (`Logged` table)");
         }
     }
-    log.info("✅ successfully fetched new vaults on Euler V2");
     if (storedVaults.length > 0) {
         vaults = vaults.concat(storedVaults.map(v => v.entityData));
     }
     log.info("👋 exiting getEulerV2Vaults");
     return vaults;
 }
-export const getEulerV2VaultsWithCache = async () => await Redis.getOrSet("EulerV2Vaults", getEulerV2Vaults);
 export async function updateEulerVaultsCollatInDatabase() {
     // 0_ Fetch all euler vaults from database
     const vaults = await apiDbClient.logged.findMany({

package/dist/src/engine/erc20SubTypeProcessors/implementations/EulerLendProcessor.js

@@ -1,4 +1,5 @@
 import { generateCardName } from "@/utils/generateCardName";
+import { log } from "@/utils/logger";
 import { BN2Number } from "@sdk";
 import { GenericProcessor } from "../GenericProcessor";
 import { fetchEulerVaultName } from "../helpers/eulerVaultNames";
@@ -18,8 +19,12 @@ export class EulerLendProcessor extends GenericProcessor {
     async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
         const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
         const symbolAsset = campaign.campaignParameters.symbolAsset;
-        const decimalsAsset = Number(campaign.campaignParameters.decimalsAsset);
+        let decimalsAsset = Number(campaign.campaignParameters.decimalsAsset) ?? 18;
         const priceAsset = (await pricer.get({ symbol: symbolAsset })) ?? 1;
+        if (Number.isNaN(decimalsAsset)) {
+            log.warn(`decimalsAsset is NaN for ${symbolAsset} on campaign ${campaign.campaignId}`);
+            decimalsAsset = 18;
+        }
         const totalAssets = BN2Number(typeInfo.totalAssets, decimalsAsset);
         typeInfo.symbolUnderlyingToken = symbolAsset;
         let cardName = generateCardName(type, typeInfo, campaign);

package/dist/src/index.d.ts

@@ -285,9 +285,8 @@ declare const app: Elysia<"", false, {
                                 cumulated: number;
                                 timestamp: bigint;
                                 breakdowns: {
-                                    id: number;
+                                    id: string;
                                     type: import("@db/api").$Enums.AprType;
-                                    uuid: string;
                                     identifier: string;
                                     value: number;
                                     aprRecordId: string;
@@ -298,9 +297,8 @@ declare const app: Elysia<"", false, {
                                 total: number;
                                 timestamp: bigint;
                                 breakdowns: {
-                                    id: number;
+                                    id: string;
                                     type: import("@db/api").$Enums.TvlType;
-                                    uuid: string;
                                     identifier: string;
                                     value: number;
                                     tvlRecordId: string;
@@ -311,8 +309,7 @@ declare const app: Elysia<"", false, {
                                 total: number;
                                 timestamp: bigint;
                                 breakdowns: {
-                                    id: number;
-                                    uuid: string;
+                                    id: string;
                                     value: number;
                                     campaignId: string;
                                     dailyRewardsRecordId: string;
@@ -513,7 +510,7 @@ declare const app: Elysia<"", false, {
                                 timestamp: string | bigint;
                                 cumulated: number;
                                 breakdowns: {
-                                    id: number;
+                                    id: string;
                                     type: "CAMPAIGN" | "TOKEN" | "PROTOCOL";
                                     identifier: string;
                                     value: number;
@@ -524,7 +521,7 @@ declare const app: Elysia<"", false, {
                                 total: number;
                                 timestamp: string | bigint;
                                 breakdowns: {
-                                    id: number;
+                                    id: string;
                                     type: "TOKEN" | "PROTOCOL";
                                     identifier: string;
                                     value: number;
@@ -536,7 +533,7 @@ declare const app: Elysia<"", false, {
                                 total: number;
                                 timestamp: string | bigint;
                                 breakdowns: {
-                                    id: number;
+                                    id: string;
                                     token: {
                                         price?: number | null | undefined;
                                         symbol: string;
@@ -644,7 +641,7 @@ declare const app: Elysia<"", false, {
                                 timestamp: string | bigint;
                                 cumulated: number;
                                 breakdowns: {
-                                    id: number;
+                                    id: string;
                                     type: "CAMPAIGN" | "TOKEN" | "PROTOCOL";
                                     identifier: string;
                                     value: number;
@@ -655,7 +652,7 @@ declare const app: Elysia<"", false, {
                                 total: number;
                                 timestamp: string | bigint;
                                 breakdowns: {
-                                    id: number;
+                                    id: string;
                                     type: "TOKEN" | "PROTOCOL";
                                     identifier: string;
                                     value: number;
@@ -667,7 +664,7 @@ declare const app: Elysia<"", false, {
                                 total: number;
                                 timestamp: string | bigint;
                                 breakdowns: {
-                                    id: number;
+                                    id: string;
                                     token: {
                                         price?: number | null | undefined;
                                         symbol: string;
@@ -809,7 +806,7 @@ declare const app: Elysia<"", false, {
                                     timestamp: string | bigint;
                                     cumulated: number;
                                     breakdowns: {
-                                        id: number;
+                                        id: string;
                                         type: "CAMPAIGN" | "TOKEN" | "PROTOCOL";
                                         identifier: string;
                                         value: number;
@@ -820,7 +817,7 @@ declare const app: Elysia<"", false, {
                                     total: number;
                                     timestamp: string | bigint;
                                     breakdowns: {
-                                        id: number;
+                                        id: string;
                                         type: "TOKEN" | "PROTOCOL";
                                         identifier: string;
                                         value: number;
@@ -832,7 +829,7 @@ declare const app: Elysia<"", false, {
                                     total: number;
                                     timestamp: string | bigint;
                                     breakdowns: {
-                                        id: number;
+                                        id: string;
                                         token: {
                                             price?: number | null | undefined;
                                             symbol: string;
@@ -4588,11 +4585,9 @@ declare const app: Elysia<"", false, {
                             headers: unknown;
                             response: {
                                 200: {
-                                    id: number;
+                                    id: string;
                                     reason: string;
-                                    uuid: string;
                                     campaignId: string;
-                                    stringId: string;
                                     boost: number | null;
                                 }[];
                             };

package/dist/src/jobs/update-euler-vaults.d.ts

@@ -1 +1 @@
-export declare function updateEulerVaultsCollatInDatabase(): Promise<void>;
+export {};

package/dist/src/jobs/update-euler-vaults.js

@@ -1,122 +1,6 @@
 import { Redis } from "@/cache";
-import { LoggedEntityType, getEulerV2Vaults } from "@/engine/dynamicData/utils/getEulerV2Vaults";
-import { fetchEulerVaultName } from "@/engine/erc20SubTypeProcessors/helpers/eulerVaultNames";
-import { batchMulticallCallWithRetry } from "@/utils/generic";
-import { log } from "@/utils/logger";
-import { apiDbClient } from "@db";
-import { ERC20Interface, EULER_ADDRESSES, EulerEVKInterface, EulerVaultLensInterface, NETWORK_LABELS, eulerChainIds, } from "@sdk";
-import _ from "lodash";
-async function computeCollatListAndReturnVaults(chainId, vaults) {
-    let vaultsPerChain = [];
-    /** Extra calls batch to get the collateral addresses */
-    const resCollat = await batchMulticallCallWithRetry(chainId, {
-        calls: vaults
-            .map(vault => vault.address)
-            .map(vaultAddress => {
-            return {
-                allowFailure: true,
-                callData: EulerVaultLensInterface.encodeFunctionData("getRecognizedCollateralsLTVInfo", [vaultAddress]),
-                target: EULER_ADDRESSES[chainId].VAULT_LENS,
-            };
-        }),
-    });
-    const callsCollatUnderlying = [];
-    const callsCollatUnderlyingSymbol = [];
-    for (const [index, vault] of vaults.entries()) {
-        const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
-        for (const collat of collatArray) {
-            if (!!vault.collaterals &&
-                vault.collaterals.map(c => c.address.toLowerCase()).includes(collat.collateral.toLowerCase()))
-                continue;
-            log.info(`🦭 found new collateral ${collat.collateral} for vault ${vault.address} (${NETWORK_LABELS[chainId]})`);
-            callsCollatUnderlying.push({
-                allowFailure: true,
-                callData: EulerEVKInterface.encodeFunctionData("asset"),
-                target: collat.collateral,
-            }, {
-                allowFailure: true,
-                callData: EulerEVKInterface.encodeFunctionData("symbol"),
-                target: collat.collateral,
-            });
-        }
-    }
-    const resCollatUnderlying = await batchMulticallCallWithRetry(chainId, {
-        calls: callsCollatUnderlying,
-    });
-    for (let i = 0; i < resCollatUnderlying.length; i = i + 2) {
-        const underlyingToken = EulerEVKInterface.decodeFunctionResult("asset", resCollatUnderlying[i].returnData)[0];
-        callsCollatUnderlyingSymbol.push({
-            allowFailure: true,
-            callData: ERC20Interface.encodeFunctionData("symbol"),
-            target: underlyingToken,
-        });
-    }
-    const resCollatUnderlyingSymbol = await batchMulticallCallWithRetry(chainId, {
-        calls: callsCollatUnderlyingSymbol,
-    });
-    vaultsPerChain = vaultsPerChain.concat((await Promise.all(vaults.map(async (vault, index) => {
-        const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
-        if (!vault.collaterals)
-            vault.collaterals = [];
-        let offset = 0;
-        for (const [_index, collat] of collatArray.entries()) {
-            // _ Check whether the collat was already registered
-            if (!!vault.collaterals &&
-                vault.collaterals.map(c => c.address.toLowerCase()).includes(collat.collateral.toLowerCase())) {
-                offset += 1;
-                continue;
-            }
-            const symbolUnderlying = ERC20Interface.decodeFunctionResult("symbol", resCollatUnderlyingSymbol[_index - offset].returnData)[0];
-            vault.collaterals.push({
-                address: collat.collateral,
-                symbolCollateral: EulerEVKInterface.decodeFunctionResult("symbol", resCollatUnderlying[2 * (_index - offset) + 1].returnData)[0],
-                symbolUnderlying,
-                borrowLTV: collat.borrowLTV.toString(),
-                nameCollateral: (await fetchEulerVaultName(collat.collateral, chainId)) ?? symbolUnderlying,
-            });
-        }
-        return { ...vault };
-    }))));
-    return vaultsPerChain;
-}
-export async function updateEulerVaultsCollatInDatabase() {
-    // 0_ Fetch all euler vaults from database
-    const vaults = await apiDbClient.logged.findMany({
-        where: { type: LoggedEntityType.EULER },
-    });
-    const clonedVaults = _.cloneDeep(vaults);
-    let toUpdateVaults = [];
-    // 1_ Return all vaults already stored with their collateral updated
-    const res = await Promise.all(eulerChainIds.map(async (chainId) => computeCollatListAndReturnVaults(chainId, clonedVaults.filter(entity => entity.chainId === chainId).map(entity => entity.entityData))));
-    for (const resPerChain of res) {
-        if (!!resPerChain && resPerChain.length > 0) {
-            toUpdateVaults = toUpdateVaults.concat(resPerChain.filter(updatedVault => {
-                return (updatedVault.collaterals.length >
-                    vaults.find(vault => vault.address?.toLowerCase() === updatedVault.address.toLowerCase())
-                        ?.entityData?.collaterals.length);
-            }));
-        }
-    }
-    // 2_ Update the API database
-    if (toUpdateVaults.length > 0) {
-        try {
-            for (const vault of toUpdateVaults) {
-                await apiDbClient.logged.updateMany({
-                    where: {
-                        address: vault.address,
-                        chainId: vault.chainId,
-                    },
-                    data: {
-                        entityData: vault,
-                    },
-                });
-            }
-            log.info(`✅ successfully updated ${toUpdateVaults.length} vault(s) collaterals in API database ('Logged' table)`);
-        }
-        catch {
-            throw new Error("Error while updating vaults to API database (`Logged` table)");
-        }
-    }
-}
-await updateEulerVaultsCollatInDatabase();
-await Redis.safeSet("EulerV2Vaults", await getEulerV2Vaults());
+import { getEulerV2Vaults, updateEulerVaultsCollatInDatabase } from "@/engine/dynamicData/utils/getEulerV2Vaults";
+(async () => {
+    await Redis.safeSet("EulerV2Vaults", await getEulerV2Vaults());
+    await updateEulerVaultsCollatInDatabase();
+})();

package/dist/src/modules/v4/apr/apr.model.d.ts

@@ -12,9 +12,9 @@ export type AprRecord = Resource<"AprRecord", "id" | "opportunityId", {
  * @description Describes one apr fraction of record
  * @see {@link Resource}
  */
-export type AprBreakdown = Resource<"AprBreakdown", "id" | "aprRecordId" | "uuid">;
+export type AprBreakdown = Resource<"AprBreakdown", "id" | "aprRecordId">;
 export declare const AprBreakdownResourceDto: import("@sinclair/typebox").TObject<{
-    id: import("@sinclair/typebox").TNumber;
+    id: import("@sinclair/typebox").TString;
     type: import("@sinclair/typebox").TEnum<{
         CAMPAIGN: "CAMPAIGN";
         TOKEN: "TOKEN";
@@ -28,7 +28,7 @@ export declare const AprRecordResourceDto: import("@sinclair/typebox").TObject<{
     cumulated: import("@sinclair/typebox").TNumber;
     timestamp: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TBigInt, import("@sinclair/typebox").TString]>;
     breakdowns: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-        id: import("@sinclair/typebox").TNumber;
+        id: import("@sinclair/typebox").TString;
         type: import("@sinclair/typebox").TEnum<{
             CAMPAIGN: "CAMPAIGN";
             TOKEN: "TOKEN";

package/dist/src/modules/v4/apr/apr.model.js

@@ -2,7 +2,7 @@ import { AprType } from "@db/api";
 import { t } from "elysia";
 // ─── Dtos ────────────────────────────────────────────────────────────────────
 export const AprBreakdownResourceDto = t.Object({
-    id: t.Number(),
+    id: t.String(),
     type: t.Enum(AprType),
     identifier: t.String(),
     value: t.Number(),

package/dist/src/modules/v4/computedValue/computedValue.controller.d.ts

@@ -51,11 +51,9 @@ export declare const ComputedValueController: Elysia<"/value", false, {
                         headers: unknown;
                         response: {
                             200: {
-                                id: number;
+                                id: string;
                                 reason: string;
-                                uuid: string;
                                 campaignId: string;
-                                stringId: string;
                                 boost: number | null;
                             }[];
                         };

package/dist/src/modules/v4/computedValue/computedValue.repository.d.ts

@@ -7,11 +7,9 @@ export declare abstract class ComputedValueRepository {
     } | null>;
     static upsertCampaignComputedValue(data: UpsertCampaignComputedValueModel): Promise<void>;
     static findUserValues(data: GetUserComputedValuesModel): Promise<{
-        id: number;
+        id: string;
         reason: string;
-        uuid: string;
         campaignId: string;
-        stringId: string;
         boost: number | null;
     }[]>;
     static upsertUserComputedValues(data: UpsertUserComputedValuesModel): Promise<void>;

package/dist/src/modules/v4/computedValue/computedValue.repository.js

@@ -1,6 +1,5 @@
 import { apiDbClient } from "@db";
 import { UserRepository } from "../user/user.repository";
-import { ComputedValueService } from "./computedValue.service";
 export class ComputedValueRepository {
     static async findCampaignValue(params) {
         return await apiDbClient.campaignComputedValue.findUnique({
@@ -38,7 +37,6 @@ export class ComputedValueRepository {
                 },
                 update: { [item.field]: item.value },
                 create: {
-                    stringId: ComputedValueService.hashUserComputedValueId(item.campaignId, item.address, item.reason),
                     campaignId: item.campaignId,
                     address: item.address,
                     reason: item.reason,

package/dist/src/modules/v4/computedValue/computedValue.service.d.ts

@@ -8,11 +8,9 @@ export declare abstract class ComputedValueService {
     } | null>;
     static upsertCampaignComputedValue(data: UpsertCampaignComputedValueModel): Promise<void>;
     static findUserValues(params: GetUserComputedValuesModel): Promise<{
-        id: number;
+        id: string;
         reason: string;
-        uuid: string;
         campaignId: string;
-        stringId: string;
         boost: number | null;
     }[]>;
     static upsertUserComputedValues(data: UpsertUserComputedValuesModel): Promise<void>;

package/dist/src/modules/v4/icon/icon.model.d.ts

@@ -0,0 +1,4 @@
+export type FileMetadata = {
+    name?: string;
+    extension?: string;
+};

package/dist/src/modules/v4/icon/icon.model.js

@@ -0,0 +1 @@
+export {};

package/dist/src/modules/v4/icon/icon.service.d.ts

@@ -0,0 +1,5 @@
+import type { BucketService } from "../bucket/bucket.service";
+import type { FileMetadata } from "./icon.model";
+export declare abstract class IconService {
+    static pullPush(url: string, bucket: BucketService, metadata?: FileMetadata): Promise<number>;
+}

package/dist/src/modules/v4/icon/icon.service.js

@@ -0,0 +1,15 @@
+export class IconService {
+    static async pullPush(url, bucket, metadata) {
+        const filename = metadata?.name ?? url;
+        const iconFile = await fetch(url);
+        const mimeType = iconFile.headers.get("content-type");
+        const extension = metadata?.extension ? metadata.extension : mimeType.split("/")[1].split("+")[0];
+        const byteArray = await iconFile.bytes();
+        return await bucket.pushRaw(`${filename}.${extension}`, byteArray, {
+            type: mimeType,
+            isPublic: true,
+            compression: true,
+            overwrite: true,
+        });
+    }
+}