@merkl/api 0.21.47 → 1.0.0

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

@@ -1,73 +0,0 @@
-import { CacheService } from "@/modules/v4/cache/cache.service";
-import { ChainService } from "@/modules/v4/chain/chain.service";
-import { TokenService } from "@/modules/v4/token/token.service";
-import { log } from "@/utils/logger";
-import { BucketService } from "../bucket/bucket.service";
-import { TTLPresets } from "../cache/cache.model";
-import { IconService } from "../icon/icon.service";
-import { ProtocolRepository } from "./protocol.repository";
-// ─── Protocols Services ──────────────────────────────────────────────────────
-export class ProtocolService {
-    static async #findMany(query) {
-        const protocols = await ProtocolRepository.findMany(query);
-        const enrichedProtocols = protocols.map(({ MainOpportunities, ...protocol }) => ({
-            ...protocol,
-            dailyRewards: MainOpportunities.reduce((sum, opportunity) => sum + opportunity.dailyRewards, 0),
-            numberOfLiveCampaigns: MainOpportunities.reduce((sum, opportunity) => sum + opportunity.Campaigns.length, 0),
-            opportunityLiveTags: [...new Set(MainOpportunities.flatMap(opportunity => opportunity.action))], // ensure uniqness of tags
-        }));
-        return enrichedProtocols;
-    }
-    static async findMany(query) {
-        if (query.test)
-            return await ProtocolRepository.findMany(query);
-        return await CacheService.wrap(TTLPresets.MIN_10, ProtocolService.#findMany, query);
-    }
-    static async countMany(query) {
-        return ProtocolRepository.countMany(query);
-    }
-    static async findUnique(id) {
-        return ProtocolRepository.findUnique(id);
-    }
-    static async create(data) {
-        return await ProtocolRepository.create(data);
-    }
-    static async upsert(data) {
-        const env = process.env.ENV === "prod" ? "production" : process.env.ENV;
-        const iconUri = await IconService.pullPush(data.icon, new BucketService("merkl-static-assets", `angle-${env}-1`), {
-            name: `protocols/${data.id}`,
-        });
-        return await ProtocolRepository.upsert({
-            ...data,
-            icon: `${iconUri}`,
-        });
-    }
-    static async update(id, data) {
-        return await ProtocolRepository.update(id, data);
-    }
-    static async changeLogoUrls() {
-        const oldUrl = "https://storage.googleapis.com/merkl-assets/";
-        const newUrl = "https://raw.githubusercontent.com/AngleProtocol/angle-token-list/main/src/assets/";
-        const protocols = await ProtocolService.findMany({ items: 10_000 });
-        for (const protocol of protocols) {
-            if (protocol.icon.includes(oldUrl)) {
-                await ProtocolService.update(protocol.id, { icon: protocol.icon.replace(oldUrl, newUrl) });
-                log.info(`Updated protocol ${protocol.id} icon`);
-            }
-        }
-        const chains = await ChainService.findMany({});
-        for (const chain of chains) {
-            if (chain.icon.includes(oldUrl)) {
-                await ChainService.update(chain.id, { icon: chain.icon.replace(oldUrl, newUrl) });
-                log.info(`Updated chain ${chain.id} icon`);
-            }
-        }
-        const tokens = await TokenService.findMany({});
-        for (const token of tokens) {
-            if (token.icon.includes(oldUrl)) {
-                await TokenService.update(token.id, { icon: token.icon.replace(oldUrl, newUrl) });
-                log.info(`Updated token ${token.id} icon`);
-            }
-        }
-    }
-}

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

@@ -1,25 +0,0 @@
-import { throwOnUnsupportedChainId } from "@/utils/throw";
-import Elysia from "elysia";
-import { ReferralCodeDto, ReferralRedeemCodeDto } from "./referral.model";
-import { ReferralService } from "./referral.service";
-// ─── Rewards Controller ──────────────────────────────────────────────────────
-export const ReferralController = new Elysia({ prefix: "/referral", detail: { tags: ["Referral"] } })
-    // ─── Get Reward Breakdowns For Campaign Ids ──────────────────────────
-    .get("/code", async ({ query: { chainId, referralKey, address } }) => await ReferralService.getCodeOrTransaction(chainId, referralKey, address), {
-    query: ReferralCodeDto,
-    beforeHandle: ({ query: { chainId } }) => {
-        throwOnUnsupportedChainId(chainId);
-    },
-    detail: {
-        description: "Returns the transaction to register user as a referrer on-chain and some additional state",
-    },
-})
-    .get("/redeem", async ({ query: { chainId, referralKey, code } }) => await ReferralService.getReferralTransaction(chainId, referralKey, code), {
-    query: ReferralRedeemCodeDto,
-    beforeHandle: ({ query: { chainId } }) => {
-        throwOnUnsupportedChainId(chainId);
-    },
-    detail: {
-        description: "Returns the transaction to redeem a referral code on-chain and some additional state",
-    },
-});

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

@@ -1,12 +0,0 @@
-import { t } from "elysia";
-// ─── DTOs ────────────────────────────────────────────────────────────────────
-export const ReferralCodeDto = t.Object({
-    chainId: t.Number(),
-    referralKey: t.String(),
-    address: t.String(),
-});
-export const ReferralRedeemCodeDto = t.Object({
-    chainId: t.Number(),
-    referralKey: t.String(),
-    code: t.String(),
-});

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

@@ -1,171 +0,0 @@
-import { ChainId, ChainInteractionService } from "@sdk";
-import { decodeFunctionResult, encodeFunctionData, parseAbi, } from "viem";
-export class ReferralService {
-    static abi = parseAbi([
-        "function getReferralKeys() external view returns (string[] memory)",
-        "function getReferrerStatus(string calldata key, address user) external view returns (bytes32)",
-        "function referrerCodeMapping(string key, address user) external view returns (string)",
-        "function codeToReferrer(string key, string user) external view returns (address)",
-        "function getReferrer(string calldata key, address user) external view returns (address)",
-        "function getReferredUsers(string calldata key, address user) external view returns (address[] memory)",
-        "function acknowledgeReferrerByKey(string calldata key, string calldata referrerCode) external",
-        "function getCostOfReferral(string calldata key) external view returns (uint256)",
-        "function getPaymentToken(string calldata key) external view returns (address)",
-        "function getReferrerStatusByKey(string calldata key, address referrer) external view returns (uint8)",
-        "function requiresAuthorization(string calldata key) external view returns (bool)",
-        "function requiresRefererToBeSet(string calldata key) external view returns (bool)",
-        "function becomeReferrer(string calldata key, string calldata referrerCode) external payable",
-    ]);
-    static getReferralContract(chainId) {
-        if (chainId === ChainId.ETHERLINK)
-            return "0xF39CC381B91f36238c77f42B9fF4D45376F80E5b";
-        return;
-    }
-    /**
-     * Makes an on-chain call to the referral contract
-     * @param chainId
-     * @param functionName
-     * @param args
-     * @returns
-     */
-    static async #call(chainId, functionName, args) {
-        const referralContractAddress = ReferralService.getReferralContract(chainId);
-        if (!referralContractAddress)
-            throw new Error(`Referral contract not deployed on chain ${chainId}`);
-        return await ChainInteractionService(chainId).fetchAndDecode({
-            target: referralContractAddress,
-            allowFailure: true,
-            callData: encodeFunctionData({
-                abi: ReferralService.abi,
-                functionName,
-                args,
-            }),
-        }, (r) => decodeFunctionResult({
-            abi: ReferralService.abi,
-            functionName,
-            data: r?.returnData,
-        }));
-    }
-    static async isKeyAvailable(key, chainId) {
-        const referralKeys = await ReferralService.#call(chainId, "getReferralKeys", []);
-        return referralKeys.includes(key);
-    }
-    static async getReferredUsers(chainId, key, address) {
-        const isReferralKeyAvailable = ReferralService.isKeyAvailable(key, chainId);
-        if (!isReferralKeyAvailable)
-            throw new Error(`Referral key ${key} not available on ${chainId}`);
-        return await ReferralService.#call(chainId, "getReferredUsers", [key, address]);
-    }
-    static async getReferralStatus(chainId, key, address) {
-        const referralContractAddress = ReferralService.getReferralContract(chainId);
-        const isReferralKeyAvailable = ReferralService.isKeyAvailable(key, chainId);
-        if (!referralContractAddress)
-            throw new Error(`Referral contract not deployed on chain ${chainId}`);
-        if (!isReferralKeyAvailable)
-            throw new Error(`Referral key ${key} not available on ${chainId}`);
-        const shouldCheckStatus = await ReferralService.#call(chainId, "requiresAuthorization", [key]);
-        if (!shouldCheckStatus)
-            return true;
-        const referralStatus = await ReferralService.#call(chainId, "getReferrerStatusByKey", [
-            key,
-            address,
-        ]);
-        return referralStatus === 1;
-    }
-    static generateCode(chainId, key, address) {
-        const digits = [chainId, key, address, 4, 5, 6].map(() => Math.floor(Math.random() * 10)).join("");
-        return `${key.toUpperCase()}-${digits}`;
-    }
-    static async getCode(chainId, key, address) {
-        const referralContractAddress = ReferralService.getReferralContract(chainId);
-        if (!referralContractAddress)
-            throw new Error(`Referral contract not deployed on chain ${chainId}`);
-        const code = await ReferralService.#call(chainId, "referrerCodeMapping", [key, address]);
-        return code === "" ? undefined : code;
-    }
-    /**
-     * Get state & transaction for creating a referral code
-     * @param chainId of the referral contract
-     * @param key of referral
-     * @param address of the creator
-     */
-    static async getCodeOrTransaction(chainId, key, address) {
-        const referralContractAddress = ReferralService.getReferralContract(chainId);
-        const isReferralKeyAvailable = ReferralService.isKeyAvailable(key, chainId);
-        if (!referralContractAddress)
-            throw new Error(`Referral contract not deployed on chain ${chainId}`);
-        if (!isReferralKeyAvailable)
-            throw new Error(`Referral key ${key} not available on ${chainId}`);
-        const contractCode = await ReferralService.getCode(chainId, key, address);
-        if (!contractCode) {
-            const code = ReferralService.generateCode(chainId, key, address);
-            return {
-                code,
-                referrer: false,
-                referredUsers: [],
-                transaction: {
-                    to: referralContractAddress,
-                    data: encodeFunctionData({
-                        abi: ReferralService.abi,
-                        functionName: "becomeReferrer",
-                        args: [key, code],
-                    }),
-                },
-            };
-        }
-        const code = await ReferralService.getCode(chainId, key, address);
-        const referredUsers = await ReferralService.getReferredUsers(chainId, key, address);
-        return {
-            code,
-            referrer: true,
-            referredUsers,
-        };
-    }
-    /**
-     * Checks if code exists in the contracts
-     * @param chainId of the referral contract
-     * @param key of referral
-     * @param code user referral code
-     * @returns referrerAddress if code exitst
-     */
-    static async isCodeRegistered(chainId, key, code) {
-        const referralContractAddress = ReferralService.getReferralContract(chainId);
-        if (!referralContractAddress)
-            throw new Error(`Referral contract not deployed on chain ${chainId}`);
-        const referrerAddress = await ReferralService.#call(chainId, "codeToReferrer", [key, code]);
-        return referrerAddress === "" ? undefined : referrerAddress;
-    }
-    /**
-     * Get state & transaction for redeeming a referral code
-     * @param chainId of the referral contract
-     * @param key of referral
-     * @param code user referral code
-     */
-    static async getReferralTransaction(chainId, key, code) {
-        const referralContractAddress = ReferralService.getReferralContract(chainId);
-        const isReferralKeyAvailable = ReferralService.isKeyAvailable(key, chainId);
-        if (!referralContractAddress)
-            throw new Error(`Referral contract not deployed on chain ${chainId}`);
-        if (!isReferralKeyAvailable)
-            throw new Error(`Referral key ${key} not available on ${chainId}`);
-        const referrerAddress = await ReferralService.isCodeRegistered(chainId, key, code);
-        if (!referrerAddress) {
-            return {
-                code,
-                referrer: referrerAddress,
-            };
-        }
-        return {
-            code,
-            referrer: referrerAddress,
-            transaction: {
-                to: referralContractAddress,
-                data: encodeFunctionData({
-                    abi: ReferralService.abi,
-                    functionName: "acknowledgeReferrerByKey",
-                    args: [key, code],
-                }),
-            },
-        };
-    }
-}

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

@@ -1,140 +0,0 @@
-import { BackOfficeGuard } from "@/guards/BackOffice.guard";
-import { AuthorizationHeadersDto, EngineGuard } from "@/guards/Engine.guard";
-import { ChainDto } from "@/modules/v4/accounting/accounting.model";
-import { CacheService } from "@/modules/v4/cache/cache.service";
-import { CampaignService } from "@/modules/v4/campaign/campaign.service";
-import { TokenService } from "@/modules/v4/token/token.service";
-import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
-import Elysia, { t } from "elysia";
-import { TTLPresets } from "../cache/cache.model";
-import { CampaignIdDto, CampaignIdWithoutPageDto, CampaignRewardsDto, CreateManyBreakdownDto, CreateManyRewardDto, RegisterClaimsDto, TokenIdDto, } from "./reward.model";
-import { RewardService } from "./reward.service";
-// ─── Rewards Controller ──────────────────────────────────────────────────────
-export const RewardController = new Elysia({ prefix: "/rewards", detail: { tags: ["Rewards"] } })
-    // ─── Get Reward Breakdowns For Campaign Ids ──────────────────────────
-    .get("/", async ({ query }) => await RewardService.breakdownForCampaign(query), {
-    query: CampaignIdDto,
-    beforeHandle: ({ query }) => {
-        throwOnUnsupportedChainId(query.chainId);
-    },
-    detail: {
-        description: "Returns the all the address that received rewards for a given campaign, sorted by descending amounts",
-    },
-})
-    // ─── Get Total Amount Rewarded For Campaign Id ──────────────────────
-    .get("/total", async ({ query }) => await RewardService.totalForCampaign(query), {
-    query: CampaignIdDto,
-    beforeHandle: ({ query }) => {
-        throwOnUnsupportedChainId(query.chainId);
-    },
-    detail: { description: "Returns the total amount distributed for a given campaign" },
-})
-    // ─── Get Reward Count By Chain And Root For Campaign Id ─────────────
-    .get("/count", async ({ query }) => await RewardService.countForCampaign(query), {
-    query: CampaignIdDto,
-    beforeHandle: ({ query }) => {
-        throwOnUnsupportedChainId(query.chainId);
-    },
-    detail: { hide: true },
-})
-    // ─── Get Reward by campaign ─────────────
-    .group("/campaign/:campaignId", app => {
-    return app
-        .resolve(async ({ params: { campaignId } }) => {
-        const campaign = await CampaignService.findUniqueOrThrow(CampaignService.splitIdOrThrow(campaignId));
-        const token = await TokenService.findUniqueOrThrow(campaign.rewardTokenId);
-        const rewardQuery = {
-            chainId: token.chainId,
-            address: token.address,
-            campaignIds: [campaign.campaignId],
-        };
-        return { campaign, token, rewardQuery };
-    })
-        .guard({
-        query: CampaignRewardsDto,
-        detail: { hide: true },
-    })
-        .get("/", async ({ query, rewardQuery }) => await RewardService.breakdownForToken({ ...query, ...rewardQuery }))
-        .get("/total", async ({ query, rewardQuery }) => await RewardService.totalForToken({ ...query, ...rewardQuery }))
-        .get("/count", async ({ query, rewardQuery }) => await RewardService.countForToken({ ...query, ...rewardQuery }));
-})
-    // ─── Get Reward Breakdowns For Token ───────────────────────────────
-    .group("/token", app => {
-    return app
-        .guard({
-        query: TokenIdDto,
-        beforeHandle: ({ query }) => {
-            query.address = throwOnInvalidRequiredAddress(query.address);
-            query.campaignIds = query?.campaignIds?.flatMap(x => x.split(","));
-            throwOnUnsupportedChainId(query.chainId);
-        },
-    })
-        .get("/", async ({ query }) => await RewardService.breakdownForToken(query), {
-        detail: {
-            description: "Returns the all the address that received rewards of a given token, sorted by descending amounts",
-        },
-    })
-        .get("/total", async ({ query }) => await RewardService.totalForToken(query), {
-        detail: { description: "Returns the total amount distributed for a given token" },
-    })
-        .get("/count", async ({ query }) => await RewardService.countForToken(query), {
-        detail: {
-            description: "Returns the number of recipients that earned rewards in a given token",
-        },
-    });
-})
-    .group("/engine", {
-    headers: AuthorizationHeadersDto,
-    beforeHandle: EngineGuard,
-    detail: { hide: true },
-}, app => {
-    return (app
-        // ─── Create Many Rewards ─────────────────────────────────────────────
-        .post("/", async ({ body }) => await RewardService.createManyReward(body), {
-        body: CreateManyRewardDto,
-    })
-        // ─── Create Many Reward Breakdowns ───────────────────────────────────
-        .post("/breakdowns", async ({ body }) => await RewardService.createManyBreakdown(body), {
-        body: CreateManyBreakdownDto,
-    })
-        // ─── Register new claims ──────────────────────────────────────────────
-        .post("/claims", async ({ body }) => await RewardService.registerClaims(body), {
-        body: RegisterClaimsDto,
-        beforeHandle: ({ headers, body }) => {
-            EngineGuard({ headers });
-            for (const claim of body) {
-                throwOnUnsupportedChainId(claim.chainId);
-                claim.token = throwOnInvalidRequiredAddress(claim.token);
-                claim.recipient = throwOnInvalidRequiredAddress(claim.recipient);
-            }
-        },
-    }));
-})
-    // ─── Get Reward Count By Chain And Root ──────────────────────────────
-    .get("/count/chain", async ({ query }) => await RewardService.countOnChain(query.chainId), {
-    query: ChainDto,
-    headers: AuthorizationHeadersDto,
-    beforeHandle: ({ headers, query }) => {
-        BackOfficeGuard({ headers });
-        throwOnUnsupportedChainId(query.chainId);
-    },
-    detail: { hide: true },
-})
-    // ─── Unclaimed Data routes ───────────────────────────────────────────
-    .group("/unclaim", app => {
-    return app.get("/", async ({ query }) => await RewardService.getUnclaimed(query), {
-        query: CampaignIdWithoutPageDto,
-        beforeHandle: ({ query }) => {
-            throwOnUnsupportedChainId(query.chainId);
-        },
-        detail: { description: "Returns the total of unclaimed rewards for given campaigns" },
-    });
-})
-    .guard({
-    query: t.Object({ since: t.Date() }),
-    detail: { hide: true },
-})
-    .get("/total/distributed", async ({ query }) => await RewardService.getTotalDistributed(query.since.getTime() / 1000))
-    .get("/total/distributed/by-chains", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, RewardService.getTotalDistributedByChain, query.since.getTime() / 1000))
-    .get("/total/distributed/by-types", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, RewardService.getTotalDistributedByType, query.since.getTime() / 1000))
-    .get("/total/distributed/by-protocols", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, RewardService.getTotalDistributedByProtocol, query.since.getTime() / 1000));

package/dist/src/modules/v4/reward/reward.converter.js

@@ -1,124 +0,0 @@
-import { RewardService } from "./reward.service";
-export class RewardConvertorService {
-    /**
-     * Convert the v4 reward data to the v3 model used in the v3/userRewards route
-     */
-    static convertV4toUserRewardV3(data, includeProofs = false) {
-        const res = {};
-        for (const { chain: _chain, rewards } of data) {
-            for (const reward of rewards) {
-                const { token, breakdowns, proofs } = reward;
-                const rewardToken = token.address;
-                res[rewardToken] = {
-                    accumulated: reward.amount.toString(),
-                    decimals: token.decimals,
-                    symbol: token.symbol,
-                    unclaimed: (reward.amount - reward.claimed).toString(),
-                    pending: reward.pending.toString(),
-                    proof: includeProofs ? proofs : undefined,
-                    reasons: {},
-                };
-                for (const breakdown of breakdowns) {
-                    const { amount, claimed, pending, reason } = breakdown;
-                    if (!res[rewardToken].reasons[reason]) {
-                        res[rewardToken].reasons[reason] = {
-                            accumulated: amount,
-                            unclaimed: (BigInt(amount) - BigInt(claimed)).toString(),
-                            pending,
-                        };
-                    }
-                    else {
-                        res[rewardToken].reasons[reason].accumulated = (BigInt(res[rewardToken].reasons[reason].accumulated) + BigInt(amount)).toString();
-                        res[rewardToken].reasons[reason].unclaimed = (BigInt(res[rewardToken].reasons[reason].unclaimed) +
-                            BigInt(amount) -
-                            BigInt(claimed)).toString();
-                        res[rewardToken].reasons[reason].pending = (BigInt(res[rewardToken].reasons[reason].pending ?? "0") + BigInt(pending)).toString();
-                    }
-                }
-            }
-        }
-        return res;
-    }
-    /**
-     * Convert the v4 reward data to the v3 model used in the v3/rewards route
-     */
-    static convertV4toRewardV3(data) {
-        const res = {};
-        for (const { chain, rewards } of data) {
-            res[chain.id] = {
-                campaignData: {},
-                tokenData: {},
-            };
-            for (const reward of rewards) {
-                const { token, breakdowns, proofs } = reward;
-                const rewardToken = token.address;
-                if (!res[chain.id].tokenData[rewardToken]) {
-                    res[chain.id].tokenData[rewardToken] = {
-                        accumulated: reward.amount.toString(),
-                        unclaimed: (reward.amount - reward.claimed).toString(),
-                        pending: reward.pending.toString(),
-                        decimals: token.decimals,
-                        symbol: token.symbol,
-                        proof: proofs,
-                    };
-                }
-                for (const breakdown of breakdowns) {
-                    const { amount, claimed, pending, reason, campaignId } = breakdown;
-                    if (!res[chain.id].campaignData[campaignId]) {
-                        res[chain.id].campaignData[campaignId] = {};
-                    }
-                    if (!res[chain.id].campaignData[campaignId][reason]) {
-                        res[chain.id].campaignData[campaignId][reason] = {
-                            accumulated: "0",
-                            unclaimed: "0",
-                            pending: "0",
-                            decimals: token.decimals,
-                            mainParameter: breakdown.opportunity.identifier,
-                            symbol: token.symbol,
-                            token: rewardToken,
-                        };
-                    }
-                    res[chain.id].campaignData[campaignId][reason].accumulated = (BigInt(res[chain.id].campaignData[campaignId][reason].accumulated) + BigInt(amount)).toString();
-                    res[chain.id].campaignData[campaignId][reason].unclaimed = (BigInt(res[chain.id].campaignData[campaignId][reason].unclaimed) +
-                        BigInt(amount) -
-                        BigInt(claimed)).toString();
-                    res[chain.id].campaignData[campaignId][reason].pending = (BigInt(res[chain.id].campaignData[campaignId][reason].pending ?? "0") + BigInt(pending)).toString();
-                }
-            }
-        }
-        return res;
-    }
-    static async convertV4toMerklV2(user, chainId, data) {
-        const rewardsV4 = await RewardService.getUserRewardsByChain(user, false, [chainId]);
-        if (!!rewardsV4?.[0]?.rewards) {
-            const userType = {
-                transactionData: rewardsV4[0].rewards.reduce((acc, reward) => {
-                    acc[reward.token.address] = {
-                        claim: BigInt(reward.amount).toString(),
-                        leaf: reward.proofs?.[0],
-                        proof: reward.proofs,
-                        token: reward.token.address,
-                    };
-                    return acc;
-                }, {}),
-            };
-            data = { ...data, ...userType };
-        }
-        for (const rewardsPerChain of rewardsV4) {
-            for (const reward of rewardsPerChain.rewards) {
-                for (const breakdown of reward.breakdowns) {
-                    const mainParameter = breakdown?.opportunity?.identifier;
-                    if (!!mainParameter) {
-                        const campaignIndex = data?.pools?.[mainParameter]?.distributionData?.findIndex(d => d.id === breakdown.campaignId);
-                        if (campaignIndex >= 0) {
-                            data.pools[mainParameter].distributionData[campaignIndex].unclaimed =
-                                (data.pools[mainParameter].distributionData[campaignIndex].unclaimed ?? 0) +
-                                    Number.parseInt((BigInt(reward.amount) - BigInt(reward.claimed)).toString());
-                        }
-                    }
-                }
-            }
-        }
-        return data;
-    }
-}