@merkl/api 0.13.15 → 0.14.1

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/GenericProcessor.d.ts

@@ -1,5 +1,6 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type CallDto, type Campaign, type CampaignParameters } from "@sdk";
+import type { ERC20SupportedCampaignType } from "../../ERC20DynamicData";
 import { type tokenType, type tokenTypeStruct } from "../helpers/tokenType";
 export declare enum roundType {
     one = "round1",
@@ -51,8 +52,8 @@ export declare class GenericProcessor<Input extends callKeys, DataRaw extends da
         round4: callType[];
     };
     debug: boolean;
-    processingRound1(typeInfo: DataRaw, type?: tokenType): void;
-    processingRound2(typeInfo: DataRaw): void;
+    processingRound1(typeInfo: DataRaw): void;
+    processingRound2(typeInfo: DataRaw, campaign?: CampaignParameters<ERC20SupportedCampaignType>): void;
     processingRound3(typeInfo: DataRaw): void;
     processingRound4(typeInfo: DataRaw): void;
     handleWhiteListBlacklistRound5(typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): {
@@ -62,10 +63,10 @@ export declare class GenericProcessor<Input extends callKeys, DataRaw extends da
     };
     processingRound5(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<Output>;
     computeRound1(type: tokenType, typeInfo: DataRaw): tokenTypeStruct;
-    computeRound2(index: number, type: tokenType, typeInfo: DataRaw, calls: string[]): tokenTypeStruct;
+    computeRound2(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign?: CampaignParameters<ERC20SupportedCampaignType>): tokenTypeStruct;
     computeRound3(index: number, type: tokenType, typeInfo: DataRaw, calls: string[]): tokenTypeStruct;
-    computeRound4(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;
-    computeRound5(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;
+    computeRound4(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<ERC20SupportedCampaignType>): tokenTypeStruct;
+    computeRound5(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<ERC20SupportedCampaignType>, pricer: Pricer): Promise<tokenTypeStruct>;
     generateWhitelistCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): CallDto[];
     generateBlackListCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): CallDto[];
     decodeListedSupply(index: number, decimals: number, list: string[], calls: string[]): string;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/GenericProcessor.js

@@ -18,8 +18,8 @@ export class GenericProcessor {
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
     };
     debug = false;
-    processingRound1(typeInfo, type) { }
-    processingRound2(typeInfo) { }
+    processingRound1(typeInfo) { }
+    processingRound2(typeInfo, campaign) { }
     processingRound3(typeInfo) { }
     processingRound4(typeInfo) { }
     handleWhiteListBlacklistRound5(typeInfo, campaign) {
@@ -65,9 +65,9 @@ export class GenericProcessor {
             typeInfo,
         };
     }
-    computeRound2(index, type, typeInfo, calls) {
+    computeRound2(index, type, typeInfo, calls, campaign) {
         this.decodePreviousRound(roundType.one, calls, typeInfo, type, index);
-        this.processingRound2(typeInfo);
+        this.processingRound2(typeInfo, campaign);
         if (this.debug) {
             console.log("Round 2", {
                 type: type,

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/MaverickBPProcessor.d.ts

@@ -43,7 +43,7 @@ export declare class MaverickBPProcessor extends GenericProcessor<callKeysMaveri
         round3: callType[];
         round4: callType[];
     };
-    processingRound1(typeInfo: dataRawMaverickBP, type: tokenType): void;
+    processingRound1(typeInfo: dataRawMaverickBP): void;
     processingRound2(typeInfo: dataRawMaverickBP): void;
     processingRound5(_index: number, type: tokenType, typeInfo: dataRawMaverickBP, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeMaverickBP>;
 }

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/MaverickBPProcessor.js

@@ -37,7 +37,7 @@ export class MaverickBPProcessor extends GenericProcessor {
         round3: [],
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
     };
-    processingRound1(typeInfo, type) {
+    processingRound1(typeInfo) {
         typeInfo.lensAddress = MAVERICK_ZKSYNC_BP_LENS_ADDRESS;
     }
     processingRound2(typeInfo) {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/NoLinkVaultProcessor.d.ts

@@ -27,7 +27,7 @@ export declare class NoLinkVaultProcessor extends GenericProcessor<callKeysNoLin
         round3: callType[];
         round4: callType[];
     };
-    processingRound1(typeInfo: dataRawNoLinkVault, type: tokenType): void;
+    processingRound1(typeInfo: dataRawNoLinkVault): void;
     processingRound5(index: number, type: tokenType, typeInfo: dataRawNoLinkVault, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeNoLinkVault>;
     computeRound1(type: tokenType, typeInfo: dataRawNoLinkVault): tokenTypeStruct;
     computeRound2(index: number, type: tokenType, typeInfo: dataRawNoLinkVault, calls: string[]): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/NoLinkVaultProcessor.js

@@ -12,7 +12,7 @@ export class NoLinkVaultProcessor extends GenericProcessor {
         round3: [{ key: "baseSymbol", call: "symbol", target: "base" }],
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
     };
-    processingRound1(typeInfo, type) {
+    processingRound1(typeInfo) {
         if (typeInfo.tokenAddress === "0x196ead472583Bc1e9aF7A05F860D9857e1Bd3dCc") {
             typeInfo.protocol = "Unifi";
             typeInfo.rateAccountant = "0xA9fB7e2922216deBE3Fd5E1bBE7591eE446Dc21c";
@@ -25,7 +25,7 @@ export class NoLinkVaultProcessor extends GenericProcessor {
             typeInfo.protocol = "Unifi";
             typeInfo.rateAccountant = "0xe0bDb7b9225A2CeB42998dc2E51D4D3CDeb7e3Be";
         }
-        if (type === tokenType.veda) {
+        if (typeInfo.type === tokenType.veda) {
             // To retrieve the rateAccountant, look at a transaction, find the teller, then find the accountant.
             if (typeInfo.tokenAddress === "0x08c6F91e2B681FaF5e17227F2a44C307b3C1364C")
                 typeInfo.rateAccountant = "0xc315D6e14DDCDC7407784e2Caf815d131Bc1D3E7";

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/RfxProcessor.d.ts

@@ -34,7 +34,7 @@ export declare class RfxProcessor extends GenericProcessor<callKeysRfx, dataRawT
         round3: callType[];
         round4: callType[];
     };
-    processingRound1(typeInfo: dataRawTemplate, type: tokenType): void;
+    processingRound1(typeInfo: dataRawTemplate): void;
     processingRound5(index: number, type: tokenType, typeInfo: dataRawTemplate, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeRfx>;
 }
 export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/RfxProcessor.js

@@ -32,7 +32,7 @@ export class RfxProcessor extends GenericProcessor {
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
     };
     // override computeRound1(): void {}
-    processingRound1(typeInfo, type) {
+    processingRound1(typeInfo) {
         const hexShortToken = ethers.utils.keccak256(ethers.utils.defaultAbiCoder.encode(["string"], ["SHORT_TOKEN"]));
         const hexLongToken = ethers.utils.keccak256(ethers.utils.defaultAbiCoder.encode(["string"], ["LONG_TOKEN"]));
         typeInfo.RFX_DATASTORE = RFX_DATASTORE;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound2.d.ts

@@ -1,3 +1,4 @@
-import type { ResultDto } from "@sdk";
+import type { CampaignParameters, ResultDto } from "@sdk";
+import type { ERC20SupportedCampaignType } from "../ERC20DynamicData";
 import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
-export declare function getTokenTypeRound2(index: number, type: tokenType, typeInfo: any, calls: ResultDto[]): tokenTypeStruct;
+export declare function getTokenTypeRound2(index: number, type: tokenType, typeInfo: any, calls: ResultDto[], campaign?: CampaignParameters<ERC20SupportedCampaignType>): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound2.js

@@ -1,5 +1,5 @@
 import { processorMapping } from "./processor/processorMapping";
-export function getTokenTypeRound2(index, type, typeInfo, calls) {
+export function getTokenTypeRound2(index, type, typeInfo, calls, campaign) {
     try {
         const returnValueOfCalls = calls.map(call => call.returnData);
         const ProcessorClass = processorMapping[type];
@@ -7,7 +7,7 @@ export function getTokenTypeRound2(index, type, typeInfo, calls) {
             throw new Error(`Processor not found for key: ${type}`);
         }
         const processorObject = new ProcessorClass();
-        return processorObject.computeRound2(index, type, typeInfo, returnValueOfCalls);
+        return processorObject.computeRound2(index, type, typeInfo, returnValueOfCalls, campaign);
     }
     catch (error) {
         console.error(error);

package/dist/src/libs/campaigns/campaignsDynamicData.js

@@ -9,7 +9,6 @@ import { DolomiteDynamicData } from "./campaignTypes/DolomiteDynamicData";
 import { ERC20DynamicData } from "./campaignTypes/ERC20DynamicData";
 import { ERC20_SNAPSHOTDynamicData } from "./campaignTypes/ERC20_SNAPSHOTDynamicData";
 import { EigenLayerDynamicData } from "./campaignTypes/EigenLayerDynamicData";
-import { EulerDynamicData } from "./campaignTypes/EulerDynamicData";
 import { HyperdriveDynamicData } from "./campaignTypes/HyperdriveDynamicData";
 import { JSON_AIRDROPDynamicData } from "./campaignTypes/JSON_AIRDROPDynamicData";
 import { MORPHODynamicData } from "./campaignTypes/MORPHODynamicData";
@@ -53,7 +52,7 @@ export async function campaignsDynamicData(chainId, campaigns, type) {
             return MORPHODynamicData(chainId, campaigns);
         }
         case Campaign.EULER: {
-            return EulerDynamicData(chainId, campaigns);
+            return ERC20DynamicData(chainId, campaigns);
         }
         case Campaign.DOLOMITE: {
             return DolomiteDynamicData(chainId, campaigns);

package/dist/src/libs/campaigns/utils/getEulerV2Vaults.d.ts

@@ -1,22 +1,8 @@
-import { type MerklChainId } from "@sdk";
+import { type EulerVaultType } from "@sdk";
 export declare enum LoggedEntityType {
     EULER = "EULER_VAULT",
     UNISWAP_V4 = "UNISWAP_V4"
 }
-export type EulerVaultType = {
-    address: string;
-    asset: string;
-    chainId: MerklChainId;
-    debtTokenAddress: string;
-    name: string;
-    fetchedAtBlock: number;
-    collaterals: {
-        address: string;
-        borrowLTV: string;
-        nameCollateral: string;
-        symbolCollateral: string;
-        symbolUnderlying: string;
-    }[];
-};
 export declare function getEulerV2Vaults(): Promise<EulerVaultType[]>;
 export declare const getEulerV2VaultsWithCache: () => Promise<EulerVaultType[]>;
+export declare function updateEulerVaultsCollatInDatabase(): Promise<void>;

package/dist/src/libs/campaigns/utils/getEulerV2Vaults.js

@@ -5,6 +5,7 @@ import { apiDbClient } from "../../../utils/prisma";
 import { providers } from "../../../utils/providers";
 import { ChainInteractionService, ERC20Interface, EULER_ADDRESSES, EulerEVKInterface, EulerVaultLensInterface, EulerVault__factory, NETWORK_LABELS, eulerChainIds, getContractCreationBlock, } from "@sdk";
 import { getAddress } from "ethers/lib/utils";
+import _ from "lodash";
 import { fetchEulerVaultName } from "../campaignTypes/ERC20SubTypes/helpers/eulerVaultNames";
 import { safeFetchLogs } from "./fetchLogs";
 export var LoggedEntityType;
@@ -12,6 +13,79 @@ export var LoggedEntityType;
     LoggedEntityType["EULER"] = "EULER_VAULT";
     LoggedEntityType["UNISWAP_V4"] = "UNISWAP_V4";
 })(LoggedEntityType || (LoggedEntityType = {}));
+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 getEulerV2Vaults() {
     let vaults = [];
     // 0_ Fetch all euler vaults from database
@@ -53,61 +127,7 @@ export async function getEulerV2Vaults() {
                 };
             }));
             log.local(`fetched ${decodedVaults.length} vaults(s) on ${NETWORK_LABELS[chainId]} between blocks ${fromBlock} and ${toBlock}`);
-            /** Extra calls batch to get the collateral addresses */
-            const resCollat = await batchMulticallCallWithRetry(chainId, {
-                calls: decodedVaults.map(vault => {
-                    return {
-                        allowFailure: true,
-                        callData: EulerVaultLensInterface.encodeFunctionData("getRecognizedCollateralsLTVInfo", [vault.address]),
-                        target: EULER_ADDRESSES[chainId].VAULT_LENS,
-                    };
-                }),
-            });
-            const callsCollatUnderlying = [];
-            const callsCollatUnderlyingSymbol = [];
-            for (const [index, _] of decodedVaults.entries()) {
-                const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
-                for (const collat of collatArray) {
-                    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(decodedVaults.map(async (decodedVault, index) => {
-                const collatArray = EulerVaultLensInterface.decodeFunctionResult("getRecognizedCollateralsLTVInfo", resCollat[index].returnData)[0];
-                const collaterals = [];
-                for (const [_index, collat] of collatArray.entries()) {
-                    const symbolUnderlying = ERC20Interface.decodeFunctionResult("symbol", resCollatUnderlyingSymbol[_index].returnData)[0];
-                    collaterals.push({
-                        address: collat.collateral,
-                        symbolCollateral: EulerEVKInterface.decodeFunctionResult("symbol", resCollatUnderlying[2 * _index + 1].returnData)[0],
-                        symbolUnderlying,
-                        borrowLTV: collat.borrowLTV.toString(),
-                        nameCollateral: (await fetchEulerVaultName(collat.collateral, chainId)) ?? symbolUnderlying,
-                    });
-                }
-                return { ...decodedVault, collaterals };
-            }))));
+            vaultsPerChain = await computeCollatListAndReturnVaults(chainId, decodedVaults);
             return vaultsPerChain;
         }
         catch (e) {
@@ -140,8 +160,7 @@ export async function getEulerV2Vaults() {
             throw new Error("Error while saving vaults to API database (`Logged` table)");
         }
     }
-    log.info("✅ successfully fetched vaults on Euler V2");
-    // FIXME _ Merge previoulsy stored vaults with newly fetched ones
+    log.info("✅ successfully fetched new vaults on Euler V2");
     if (storedVaults.length > 0) {
         vaults = vaults.concat(storedVaults.map(v => v.entityData));
     }
@@ -149,3 +168,42 @@ export async function 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({
+        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)");
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+export declare const mimeTypes: readonly ["audio/aac", "application/x-abiword", "image/apng", "application/x-freearc", "image/avif", "video/x-msvideo", "application/vnd.amazon.ebook", "application/octet-stream", "image/bmp", "application/x-bzip", "application/x-bzip2", "application/x-cdf", "application/x-csh", "text/css", "text/csv", "application/msword", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "application/vnd.ms-fontobject", "application/epub+zip", "application/gzip", "application/x-gzip", "image/gif", "text/html", "image/vnd.microsoft.icon", "text/calendar", "application/java-archive", "image/jpeg", "text/javascript", "application/json", "application/ld+json", "audio/midi", "audio/x-midi", "text/javascript", "audio/mpeg", "video/mp4", "video/mpeg", "application/vnd.apple.installer+xml", "application/vnd.oasis.opendocument.presentation", "application/vnd.oasis.opendocument.spreadsheet", "application/vnd.oasis.opendocument.text", "audio/ogg", "video/ogg", "application/ogg", "audio/ogg", "font/otf", "image/png", "application/pdf", "application/x-httpd-php", "application/vnd.ms-powerpoint", "application/vnd.openxmlformats-officedocument.presentationml.presentation", "application/vnd.rar", "application/rtf", "application/x-sh", "image/svg+xml", "application/x-tar", "image/tiff", "video/mp2t", "font/ttf", "text/plain", "application/vnd.visio", "audio/wav", "audio/webm", "video/webm", "image/webp", "font/woff", "font/woff2", "application/xhtml+xml", "application/vnd.ms-excel", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "application/xml", "text/xml", "application/atom+xml", "application/xml", "application/vnd.mozilla.xul+xml", "application/zip", "application/x-zip-compressed", "audio/video", "video/3gpp", "audio/3gpp", "audio/video", "video/3gpp2", "audio/3gpp2", "application/x-7z-compressed"];
+export type MimeType = (typeof mimeTypes)[number];
+export type UploadOptions<T> = {
+    type?: MimeType;
+    compression?: boolean;
+    overwrite?: boolean;
+    isPublic?: boolean;
+    transform?: (obj: T) => string;
+    separator?: string;
+};

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

@@ -0,0 +1,85 @@
+export const mimeTypes = [
+    "audio/aac",
+    "application/x-abiword",
+    "image/apng",
+    "application/x-freearc",
+    "image/avif",
+    "video/x-msvideo",
+    "application/vnd.amazon.ebook",
+    "application/octet-stream",
+    "image/bmp",
+    "application/x-bzip",
+    "application/x-bzip2",
+    "application/x-cdf",
+    "application/x-csh",
+    "text/css",
+    "text/csv",
+    "application/msword",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/vnd.ms-fontobject",
+    "application/epub+zip",
+    "application/gzip",
+    "application/x-gzip",
+    "image/gif",
+    "text/html",
+    "image/vnd.microsoft.icon",
+    "text/calendar",
+    "application/java-archive",
+    "image/jpeg",
+    "text/javascript",
+    "application/json",
+    "application/ld+json",
+    "audio/midi",
+    "audio/x-midi",
+    "text/javascript",
+    "audio/mpeg",
+    "video/mp4",
+    "video/mpeg",
+    "application/vnd.apple.installer+xml",
+    "application/vnd.oasis.opendocument.presentation",
+    "application/vnd.oasis.opendocument.spreadsheet",
+    "application/vnd.oasis.opendocument.text",
+    "audio/ogg",
+    "video/ogg",
+    "application/ogg",
+    "audio/ogg",
+    "font/otf",
+    "image/png",
+    "application/pdf",
+    "application/x-httpd-php",
+    "application/vnd.ms-powerpoint",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "application/vnd.rar",
+    "application/rtf",
+    "application/x-sh",
+    "image/svg+xml",
+    "application/x-tar",
+    "image/tiff",
+    "video/mp2t",
+    "font/ttf",
+    "text/plain",
+    "application/vnd.visio",
+    "audio/wav",
+    "audio/webm",
+    "video/webm",
+    "image/webp",
+    "font/woff",
+    "font/woff2",
+    "application/xhtml+xml",
+    "application/vnd.ms-excel",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "application/xml",
+    "text/xml",
+    "application/atom+xml",
+    "application/xml",
+    "application/vnd.mozilla.xul+xml",
+    "application/zip",
+    "application/x-zip-compressed",
+    "audio/video",
+    "video/3gpp",
+    "audio/3gpp",
+    "audio/video",
+    "video/3gpp2",
+    "audio/3gpp2",
+    "application/x-7z-compressed",
+];

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

@@ -1,8 +1,10 @@
-import type { SaveData } from "node_modules/@google-cloud/storage/build/esm/src/file";
+import type { UploadOptions } from "./bucket.model";
 export declare class BucketService {
-    static upload(bucketName: string, filename: string, data: SaveData, isPublic: boolean): Promise<string>;
-    static writeStreamToBucket<T>(data: T[], fileName: string, bucketName: string, projectID?: string, hook?: (data: T) => string, isPublic?: boolean, withLog?: boolean): Promise<void>;
-    static readStreamFromBucket<T>(fileName: string, bucketName: string, projectID?: string, hook?: (line: string) => T, withLog?: boolean): Promise<T[]>;
-    static deleteFile(fileName: string, bucketName: string, projectID: string): Promise<void>;
-    static exists(fileName: string, bucketName: string, projectID: string): Promise<boolean>;
+    #private;
+    defaultUploadOptions: UploadOptions<unknown>;
+    constructor(bucket: string);
+    pushArray<T>(filename: string, arr: T[], options?: UploadOptions<T>): Promise<number>;
+    push(filename: string, text: string, options?: Omit<UploadOptions<never>, "transform">): Promise<number>;
+    pullArray<T>(filename: string, callback: (elem: string) => T, separator?: string): Promise<T[]>;
+    pull(filename: string): Promise<string>;
 }