@merkl/api 0.10.356 → 0.10.357

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

@@ -1,6 +1,8 @@
-import { decodeCall } from "../../../../utils/decodeCalls";
+import { decodeCall, decodeReturnValue } from "../../../../utils/decodeCalls";
 import { ChainId } from "@sdk";
 import { enzymeFundValueCalculatorRouterMapping, getTypeFromFactoryAddress } from "./helpers/factoryFinder";
+import { getTypeFromAddressChain } from "./helpers/hardcoded";
+import { getTypeFromOwnerAddress } from "./helpers/ownerFinder";
 import { tokenType } from "./helpers/tokenType";
 import { processorMapping } from "./processor/processorMapping";
 function satisfiesNameConditions(name, type) {
@@ -107,9 +109,17 @@ function satisfiesNameConditions(name, type) {
         case tokenType.holdstation:
             return lowerCaseName.startsWith("hs");
         case tokenType.noLinkVault:
-            return lowerCaseName.startsWith("unifi eth");
+            return lowerCaseName.startsWith("unifi");
         case tokenType.vicuna:
             return lowerCaseName.startsWith("vifi");
+        case tokenType.avalon_borrowing:
+            return lowerCaseName.includes("avalon") && lowerCaseName.includes("debt");
+        case tokenType.avalon_lending:
+            return lowerCaseName.includes("avalon");
+        case tokenType.superlend_borrowing:
+            return lowerCaseName.includes("superlend") && lowerCaseName.includes("debt");
+        case tokenType.superlend_lending:
+            return lowerCaseName.includes("superlend");
         default:
             return false;
     }
@@ -141,23 +151,38 @@ function processNamingConditionsInOrder(types, name, targetToken) {
             return result;
     }
 }
-function parseForFactory(calls, index, targetToken) {
+function parseForFactory(calls, targetToken) {
     try {
-        const factory = decodeCall(calls, index, "factory");
-        const name = decodeCall(calls, index + 2, "name");
+        const factory = decodeReturnValue(calls.factory, "factory");
+        const name = decodeReturnValue(calls.name, "name");
         const type = getTypeFromFactoryAddress(factory);
+        console.log("factory: ", factory);
         if (type !== tokenType.unknown)
             return generateResult(type, name, targetToken, { factory });
     }
     catch (e) {
         // No factory on this token
+        // console.log(e);
     }
 }
-function parseForEnzyme(calls, index, targetToken) {
+function parseForOwner(calls, targetToken) {
+    try {
+        const owner = decodeReturnValue(calls.owner, "owner");
+        const name = decodeReturnValue(calls.name, "name");
+        const type = getTypeFromOwnerAddress(owner);
+        if (type !== tokenType.unknown)
+            return generateResult(type, name, targetToken, { owner: owner });
+    }
+    catch (e) {
+        // No factory on this token
+        // console.log(e);
+    }
+}
+function parseForEnzyme(calls, targetToken) {
     // Enzyme check
     try {
-        const dispatcher = decodeCall(calls, index + 4, "getCreator");
-        const name = decodeCall(calls, index + 2, "name");
+        const dispatcher = decodeReturnValue(calls.creator, "getCreator");
+        const name = decodeReturnValue(calls.name, "name");
         const type = getTypeFromFactoryAddress(dispatcher);
         const fundValueCalculator = enzymeFundValueCalculatorRouterMapping[dispatcher];
         const typeInfo = {
@@ -172,35 +197,47 @@ function parseForEnzyme(calls, index, targetToken) {
         // No factory on this token
     }
 }
-function parseForMetamorpho(calls, index, targetToken) {
+function parseForMetamorpho(calls, targetToken) {
     // MetaMorpho check
     try {
-        decodeCall(calls, index + 1, "MORPHO");
-        const name = decodeCall(calls, index + 2, "name");
+        decodeReturnValue(calls.metamorpho, "MORPHO");
+        const name = decodeReturnValue(calls.name, "name");
         return generateResult(tokenType.metamorpho, name, targetToken, {});
     }
     catch (e) {
         // Not a metamorpho token
     }
 }
-function parseForBalancer(calls, index, targetToken, name) {
+function parseForBalancer(calls, targetToken, name) {
     // Check for balancer pools
     try {
-        decodeCall(calls, index + 3, "getPoolId");
+        decodeReturnValue(calls.poolId, "getPoolId");
         return generateResult(tokenType.balancerPool, name, targetToken, {});
     }
     catch (e) {
         // Not a balancer pool
     }
 }
-function parseForStaking(campaign, calls, index, targetToken) {
+function checkAgainstHardcoded(calls, chainId, targetToken) {
+    // Check for balancer pools
+    try {
+        const name = decodeReturnValue(calls.name, "name");
+        const type = getTypeFromAddressChain(chainId, targetToken);
+        if (type !== tokenType.unknown)
+            return generateResult(type, name, targetToken, {});
+    }
+    catch (e) {
+        // Not a hardcoded address
+    }
+}
+function parseForStaking(campaign, calls, targetToken) {
     try {
         const whitelist = campaign.campaignParameters.whitelist;
         if (whitelist.length === 1 && campaign.chainId !== ChainId.ARBITRUM) {
             const forwarders = campaign.campaignParameters.forwarders;
             if (forwarders.length === 1) {
                 if (forwarders[0].sender === whitelist[0]) {
-                    const name = decodeCall(calls, index + 2, "name");
+                    const name = decodeReturnValue(calls.name, "name");
                     return generateResult(tokenType.staking, name, targetToken, { stakingContract: whitelist[0] });
                 }
             }
@@ -213,16 +250,30 @@ function parseForStaking(campaign, calls, index, targetToken) {
 }
 export function getTokenTypeRound1(calls, targetToken, index, campaign) {
     const returnValueOfCalls = calls.map(call => call.returnData);
-    let result = parseForFactory(returnValueOfCalls, index, targetToken);
+    const returnValue = {
+        factory: returnValueOfCalls[index],
+        metamorpho: returnValueOfCalls[index + 1],
+        name: returnValueOfCalls[index + 2],
+        poolId: returnValueOfCalls[index + 3],
+        creator: returnValueOfCalls[index + 4],
+        owner: returnValueOfCalls[index + 5],
+    };
+    let result = parseForFactory(returnValue, targetToken);
+    if (result)
+        return result;
+    result = parseForOwner(returnValue, targetToken);
+    if (result)
+        return result;
+    result = checkAgainstHardcoded(returnValue, campaign.computeChainId, targetToken);
     if (result)
         return result;
-    result = parseForEnzyme(returnValueOfCalls, index, targetToken);
+    result = parseForEnzyme(returnValue, targetToken);
     if (result)
         return result;
-    result = parseForMetamorpho(returnValueOfCalls, index, targetToken);
+    result = parseForMetamorpho(returnValue, targetToken);
     if (result)
         return result;
-    result = parseForStaking(campaign, returnValueOfCalls, index, targetToken);
+    result = parseForStaking(campaign, returnValue, targetToken);
     if (result)
         return result;
     let name;
@@ -232,7 +283,7 @@ export function getTokenTypeRound1(calls, targetToken, index, campaign) {
     catch (e) {
         return generateResult(tokenType.unknown, "Unknown", targetToken, {});
     }
-    result = parseForBalancer(returnValueOfCalls, index, targetToken, name);
+    result = parseForBalancer(returnValue, targetToken, name);
     if (result)
         return result;
     // Order matters

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

@@ -0,0 +1,116 @@
+import Elysia from "elysia";
+export declare const computedValueController: Elysia<"/value", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    value: {
+        campaign: {
+            ":campaignId": {
+                ":field": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            campaignId: string;
+                            field: string;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                [x: string]: File;
+                                [x: number]: File;
+                            } | null;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    value: {
+        user: {
+            ":address": {
+                ":field": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            address: string;
+                            field: string;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                [x: string]: never;
+                                [x: number]: never;
+                            }[];
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    value: {
+        engine: {
+            campaign: {
+                post: {
+                    body: {
+                        value: number;
+                        campaignId: string;
+                        field: string;
+                    };
+                    params: {};
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    value: {
+        engine: {
+            user: {
+                post: {
+                    body: {
+                        reason: string;
+                        value: number;
+                        address: string;
+                        campaignId: string;
+                        field: string;
+                    }[];
+                    params: {};
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,43 @@
+import { AuthorizationHeadersDto, EngineGuard } from "../../../guards/Engine.guard";
+import { throwOnInvalidRequiredAddress } from "../../../utils/throw";
+import Elysia from "elysia";
+import { GetCampaignComputedValue, GetUserComputedValues, UpsertCampaignComputedValue, UpsertUserComputedValues, } from "./computedValue.model";
+import { ComputedValueService } from "./computedValue.service";
+export const computedValueController = new Elysia({
+    prefix: "/value",
+    detail: { tags: ["Engine"], hide: true },
+})
+    // ─── Get a Campaign Value ──────────────────────────────────────
+    .get("/campaign/:campaignId/:field", async ({ params }) => ComputedValueService.findCampaignValue(params), {
+    params: GetCampaignComputedValue,
+    detail: { hide: true },
+})
+    // ─── Get user Values ──────────────────────────────────────
+    .get("/user/:address/:field", async ({ params }) => ComputedValueService.findUserValues(params), {
+    params: GetUserComputedValues,
+    beforeHandle: ({ params }) => {
+        throwOnInvalidRequiredAddress(params.address);
+    },
+    detail: { hide: true },
+})
+    // ─── Update a Campaign Value ──────────────────────────────────────
+    .post("/engine/campaign", async ({ body }) => await ComputedValueService.upsertCampaignComputedValue(body), {
+    headers: AuthorizationHeadersDto,
+    body: UpsertCampaignComputedValue,
+    beforeHandle: ({ headers }) => {
+        EngineGuard({ headers });
+    },
+    detail: { hide: true },
+})
+    // ─── Update some User Values ──────────────────────────────────────
+    .post("/engine/user", async ({ body }) => await ComputedValueService.upsertUserComputedValues(body), {
+    headers: AuthorizationHeadersDto,
+    body: UpsertUserComputedValues,
+    beforeHandle: ({ headers, body }) => {
+        EngineGuard({ headers });
+        for (const item of body) {
+            throwOnInvalidRequiredAddress(item.address);
+        }
+    },
+    detail: { hide: true },
+});

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

@@ -0,0 +1,27 @@
+import type { Resource } from "../prisma";
+export type CampaignComputedFields = keyof Resource<"CampaignComputedValue", "campaignId">["model"];
+export type UserComputedFields = keyof Resource<"UserComputedValue", "campaignId" | "address" | "reason">["model"];
+export declare const GetCampaignComputedValue: import("@sinclair/typebox").TObject<{
+    campaignId: import("@sinclair/typebox").TString;
+    field: import("@sinclair/typebox").TString;
+}>;
+export declare const UpsertCampaignComputedValue: import("@sinclair/typebox").TObject<{
+    campaignId: import("@sinclair/typebox").TString;
+    value: import("@sinclair/typebox").TNumber;
+    field: import("@sinclair/typebox").TString;
+}>;
+export declare const GetUserComputedValues: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+    field: import("@sinclair/typebox").TString;
+}>;
+export declare const UpsertUserComputedValues: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+    campaignId: import("@sinclair/typebox").TString;
+    address: import("@sinclair/typebox").TString;
+    reason: import("@sinclair/typebox").TString;
+    value: import("@sinclair/typebox").TNumber;
+    field: import("@sinclair/typebox").TString;
+}>>;
+export type GetCampaignComputedValueModel = typeof GetCampaignComputedValue.static;
+export type UpsertCampaignComputedValueModel = typeof UpsertCampaignComputedValue.static;
+export type GetUserComputedValuesModel = typeof GetUserComputedValues.static;
+export type UpsertUserComputedValuesModel = typeof UpsertUserComputedValues.static;

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

@@ -0,0 +1,22 @@
+import { t } from "elysia";
+// ─── DTOs ────────────────────────────────────────────────────────────────────
+export const GetCampaignComputedValue = t.Object({
+    campaignId: t.String(),
+    field: t.String(),
+});
+export const UpsertCampaignComputedValue = t.Object({
+    campaignId: t.String(),
+    value: t.Number(),
+    field: t.String(),
+});
+export const GetUserComputedValues = t.Object({
+    address: t.String(),
+    field: t.String(),
+});
+export const UpsertUserComputedValues = t.Array(t.Object({
+    campaignId: t.String(),
+    address: t.String(),
+    reason: t.String(),
+    value: t.Number(),
+    field: t.String(),
+}));

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

@@ -0,0 +1,13 @@
+import type { GetCampaignComputedValueModel, GetUserComputedValuesModel, UpsertCampaignComputedValueModel, UpsertUserComputedValuesModel } from "./computedValue.model";
+export declare class ComputedValueRepository {
+    static findCampaignValue(params: GetCampaignComputedValueModel): Promise<{
+        [x: string]: never;
+        [x: number]: never;
+    } | null>;
+    static upsertCampaignComputedValue(data: UpsertCampaignComputedValueModel): Promise<void>;
+    static findUserValues(params: GetUserComputedValuesModel): Promise<{
+        [x: string]: never;
+        [x: number]: never;
+    }[]>;
+    static upsertUserComputedValues(data: UpsertUserComputedValuesModel): Promise<void>;
+}

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

@@ -0,0 +1,41 @@
+import { apiDbClient } from "../../../utils/prisma";
+export class ComputedValueRepository {
+    static async findCampaignValue(params) {
+        return await apiDbClient.campaignComputedValue.findUnique({
+            where: { campaignId: params.campaignId },
+            select: { [params.field]: true },
+        });
+    }
+    static async upsertCampaignComputedValue(data) {
+        await apiDbClient.campaignComputedValue.upsert({
+            where: { campaignId: data.campaignId },
+            update: { [data.field]: data.value },
+            create: {
+                campaignId: data.campaignId,
+                [data.field]: data.value,
+            },
+        });
+    }
+    static async findUserValues(params) {
+        return await apiDbClient.userComputedValue.findMany({
+            where: { address: params.address },
+            select: { [params.field]: true },
+        });
+    }
+    static async upsertUserComputedValues(data) {
+        await apiDbClient.$transaction(data.map(item => {
+            return apiDbClient.userComputedValue.upsert({
+                where: {
+                    campaignId_address_reason: { campaignId: item.campaignId, address: item.address, reason: item.reason },
+                },
+                update: { [item.field]: item.value },
+                create: {
+                    campaignId: item.campaignId,
+                    address: item.address,
+                    reason: item.reason,
+                    [item.field]: item.value,
+                },
+            });
+        }));
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { GetCampaignComputedValueModel, GetUserComputedValuesModel, UpsertCampaignComputedValueModel, UpsertUserComputedValuesModel } from "./computedValue.model";
+export declare class ComputedValueService {
+    static findCampaignValue(params: GetCampaignComputedValueModel): Promise<{
+        [x: string]: never;
+        [x: number]: never;
+    } | null>;
+    static upsertCampaignComputedValue(data: UpsertCampaignComputedValueModel): Promise<void>;
+    static findUserValues(params: GetUserComputedValuesModel): Promise<{
+        [x: string]: never;
+        [x: number]: never;
+    }[]>;
+    static upsertUserComputedValues(data: UpsertUserComputedValuesModel): Promise<void>;
+}

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

@@ -0,0 +1,15 @@
+import { ComputedValueRepository } from "./computedValue.repository";
+export class ComputedValueService {
+    static async findCampaignValue(params) {
+        return await ComputedValueRepository.findCampaignValue(params);
+    }
+    static async upsertCampaignComputedValue(data) {
+        await ComputedValueRepository.upsertCampaignComputedValue(data);
+    }
+    static async findUserValues(params) {
+        return await ComputedValueRepository.findUserValues(params);
+    }
+    static async upsertUserComputedValues(data) {
+        await ComputedValueRepository.upsertUserComputedValues(data);
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from "./computedValue.model";
+export * from "./computedValue.controller";
+export * from "./computedValue.service";

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

@@ -0,0 +1,3 @@
+export * from "./computedValue.model";
+export * from "./computedValue.controller";
+export * from "./computedValue.service";

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

@@ -18,6 +18,7 @@ export declare const DynamicDataController: Elysia<"/dynamic-data", false, {
                 body: unknown;
                 params: {};
                 query: {
+                    decimals?: number | undefined;
                     chainId: number;
                     tokenAddress: string;
                 };

package/dist/src/modules/v4/dynamicData/dynamicData.controller.js

@@ -10,7 +10,7 @@ export const DynamicDataController = new Elysia({
     detail: { tags: ["DynamicData"], hide: true },
 })
     // ─── Get type Info By Token Address ───────────────────────────────────────
-    .get("/", async ({ query }) => await DynamicDataService.queryERC20DynamicData(query.chainId, query.tokenAddress), {
+    .get("/", async ({ query }) => await DynamicDataService.queryERC20DynamicData(query.chainId, query.tokenAddress, query.decimals), {
     query: DynamicDataSourceIdentifier,
     headers: AuthorizationHeadersDto,
     beforeHandle: ({ query, headers }) => {

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

@@ -2,6 +2,7 @@ import type { SinglePayloadInputDto } from "../programPayload";
 export declare const DynamicDataSourceIdentifier: import("@sinclair/typebox").TObject<{
     chainId: import("@sinclair/typebox").TNumber;
     tokenAddress: import("@sinclair/typebox").TString;
+    decimals: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
 }>;
 export declare const DynamicDataExtendedDto: import("@sinclair/typebox").TObject<{
     targetTokenSymbol: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;

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

@@ -4,6 +4,7 @@ import { t } from "elysia";
 export const DynamicDataSourceIdentifier = t.Object({
     chainId: t.Numeric(),
     tokenAddress: t.String(),
+    decimals: t.Optional(t.Numeric()),
 });
 export const DynamicDataExtendedDto = t.Object({
     targetTokenSymbol: t.Optional(t.String()),

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

@@ -13,7 +13,7 @@ type output = {
 export declare class DynamicDataService {
     #private;
     /** Fetches a single price */
-    static queryERC20DynamicData(chainId: ChainId, tokenAddress: string): Promise<output>;
+    static queryERC20DynamicData(chainId: ChainId, tokenAddress: string, decimals?: number): Promise<output>;
     static queryDynamicData(campaign: SimplifiedCampaignDtoModel): Promise<any>;
     static queryDynamicDataFromCampaignId(query: GetCampaignQueryModel): Promise<any>;
     /**

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

@@ -8,7 +8,7 @@ import { CampaignRepository } from "../campaign/campaign.repository";
 export class DynamicDataService {
     // ─── DynamicDatas ──────────────────────────────────────────────────────────
     /** Fetches a single price */
-    static async queryERC20DynamicData(chainId, tokenAddress) {
+    static async queryERC20DynamicData(chainId, tokenAddress, decimals = 18) {
         const campaigns = [
             {
                 campaignId: tokenAddress,
@@ -26,7 +26,7 @@ export class DynamicDataService {
                 campaignParameters: {
                     blacklist: [],
                     decimalsRewardToken: 18,
-                    decimalsTargetToken: 18,
+                    decimalsTargetToken: decimals,
                     duration: 30,
                     whitelist: [],
                     forwarders: [],

package/dist/src/modules/v4/opportunity/opportunity.controller.js

@@ -91,7 +91,7 @@ export const OpportunityController = new Elysia({
     .get("/:id/campaigns", async ({ query, params }) => {
     try {
         if (!params.id.includes("-"))
-            return await OpportunityService.getUniqueWithCampaignsOrThrow(params.id);
+            return await OpportunityService.getUniqueWithCampaignsOrThrow(params.id, query.test ?? false);
         const [chainId, type, identifier] = params.id.split("-");
         const oppWithCampaigns = await OpportunityService.getUniqueWithCampaignsOrThrow({
             chainId: +chainId,

package/dist/src/modules/v4/router.d.ts

@@ -2656,6 +2656,7 @@ export declare const v4: Elysia<"/v4", false, {
                     body: unknown;
                     params: {};
                     query: {
+                        decimals?: number | undefined;
                         chainId: number;
                         tokenAddress: string;
                     };

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

@@ -1,2 +1,3 @@
 import { tokenType } from "../libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType";
 export declare function decodeCall(calls: string[], index: number, key: string, type?: tokenType): any;
+export declare function decodeReturnValue(returnData: string, key: string, type?: tokenType): any;

package/dist/src/utils/decodeCalls.js

@@ -1,9 +1,14 @@
 import { AaveInterface, AccountantWithRateProvidersInterface, AuraInterface, AuraOperatorInterface, BalancerGaugeInterface, BalancerPoolInterface, BalancerVaultInterface, BeefyInterface, CPMMGammaPoolMainInterface, CompoundInterface, CurveInterface, CurveStableSwapNGInterface, DefutureVaultInterface, ERC20Interface, EnzymeInterface, EulerInterface, FactoryInterface, FluidInterface, FraxlendInterface, GearboxVaultInterface, IonicInterface, LayerBankInterface, MaverickBPLensInterface, MetamorphoInterface, MoonwellInterface, OneInchStakingInterface, PendleInterface, PendleYTInterface, RadiantInterface, RfxInterface, RswEthStrategyInterface, SturdyInterface, SymetricAmbientStrategyInterface, TorosInterface, UniswapV2PoolInterface, VePufferInterface, ZFStableLPINterface, ZFStableSwapThreePoolInterface, } from "@sdk";
-import { SyncSwapClassicPoolInterface } from "libs/sdk/src/merkl/interface";
+import { LayerBankERC20Interface, SyncSwapClassicPoolInterface } from "libs/sdk/src/merkl/interface";
 import { tokenType } from "../libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType";
 export function decodeCall(calls, index, key, type) {
     const returnData = calls[index];
+    return decodeReturnValue(returnData, key, type);
+}
+export function decodeReturnValue(returnData, key, type) {
     switch (key) {
+        case "domain":
+            return CurveStableSwapNGInterface.decodeFunctionResult("DOMAIN_SEPARATOR", returnData)[0];
         case "SY":
             return PendleYTInterface.decodeFunctionResult("SY", returnData)[0];
         case "symbol":
@@ -24,6 +29,8 @@ export function decodeCall(calls, index, key, type) {
             return EnzymeInterface.decodeFunctionResult("getCreator", returnData)[0];
         case "factory":
             return FactoryInterface.decodeFunctionResult("factory", returnData)[0];
+        case "owner":
+            return LayerBankERC20Interface.decodeFunctionResult("owner", returnData)[0];
         case "token0":
             return UniswapV2PoolInterface.decodeFunctionResult("token0", returnData)[0];
         case "token1":
@@ -69,6 +76,10 @@ export function decodeCall(calls, index, key, type) {
                 case tokenType.ironclad_borrowing:
                 case tokenType.zerolend_lending:
                 case tokenType.zerolend_borrowing:
+                case tokenType.avalon_lending:
+                case tokenType.avalon_borrowing:
+                case tokenType.superlend_lending:
+                case tokenType.superlend_borrowing:
                 case tokenType.yei_borrowing:
                 case tokenType.yei_lending:
                     return AaveInterface.decodeFunctionResult("UNDERLYING_ASSET_ADDRESS", returnData)[0];

package/dist/src/utils/encodeCalls.js

@@ -130,6 +130,10 @@ export function createCall(target, key, type, metaData) {
                 case tokenType.ironclad_borrowing:
                 case tokenType.zerolend_lending:
                 case tokenType.zerolend_borrowing:
+                case tokenType.avalon_lending:
+                case tokenType.avalon_borrowing:
+                case tokenType.superlend_lending:
+                case tokenType.superlend_borrowing:
                 case tokenType.yei_borrowing:
                 case tokenType.yei_lending:
                     return { allowFailure: true, callData: AaveInterface.encodeFunctionData("UNDERLYING_ASSET_ADDRESS"), target };

package/dist/src/utils/generateCardName.js

@@ -49,6 +49,8 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""]) {
         case tokenType.yei_borrowing:
         case tokenType.ironclad_borrowing:
         case tokenType.zerolend_borrowing:
+        case tokenType.avalon_borrowing:
+        case tokenType.superlend_borrowing:
         case tokenType.euler_borrow:
             return `Borrow ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
         case tokenType.ionic:
@@ -59,6 +61,8 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""]) {
         case tokenType.yei_lending:
         case tokenType.ironclad_lending:
         case tokenType.zerolend_lending:
+        case tokenType.avalon_lending:
+        case tokenType.superlend_lending:
         case tokenType.fraxlend:
         case tokenType.venus:
         case tokenType.reactor_fusion:
@@ -117,6 +121,10 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""]) {
             const parsedNameForCard = parsedName.join(" ");
             return `Deposit liquidity on ${parsedNameForCard} vault on Vicuna Finance`;
         }
+        case tokenType.satlayer:
+            return `Restake ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
+        case tokenType.veda:
+            return `Deposit into ${typeInfo.name.replace("Ether.Fi", "Veda")}`;
         default:
             return `Hold ${typeInfo.name} (${campaign.campaignParameters.symbolTargetToken})`;
     }