Add camelot config url

README.md

@@ -25,6 +25,9 @@ https://balance-api.beefy.finance/api/v1/config/arbitrum/bundles
 http://localhost:4000/api/v1/config/arbitrum/bundles
 
 
+https://balance-api.beefy.finance/api/v1/partner/camelot/config/arbitrum/bundles
+http://localhost:4000/api/v1/partner/camelot/config/arbitrum/bundles
+
 https://balance-api.beefy.finance/api/v1/vault/base/baseswap-cow-weth-cbbtc/20449610/bundle-holder-share
 http://localhost:4000/api/v1/vault/base/baseswap-cow-weth-cbbtc/20449610/bundle-holder-share
 https://balance-api.beefy.finance/api/v1/vault/arbitrum/camelot-order-weth/279181618/bundle-holder-share

src/routes/v1/index.ts

@@ -2,6 +2,7 @@ import type { FastifyInstance, FastifyPluginOptions } from 'fastify';
 import config from './config';
 import contract from './contract';
 import holders from './holders';
+import partner from './partner';
 import status from './status';
 import vault from './vault';
 
@@ -15,5 +16,6 @@ export default async function (
   instance.register(vault, { prefix: '/vault' });
   instance.register(config, { prefix: '/config' });
   instance.register(contract, { prefix: '/contract' });
+  instance.register(partner, { prefix: '/partner' });
   done();
 }

src/routes/v1/partner/camelot.ts

@@ -0,0 +1,78 @@
+import { type Static, Type } from '@sinclair/typebox';
+import type { FastifyInstance, FastifyPluginOptions, FastifySchema } from 'fastify';
+import { chainIdSchema } from '../../../config/chains';
+import { getAsyncCache } from '../../../utils/async-lock';
+import { getBeefyVaultConfig } from '../../../vault-breakdown/vault/getBeefyVaultConfig';
+
+export default async function (
+  instance: FastifyInstance,
+  _opts: FastifyPluginOptions,
+  done: (err?: Error) => void
+) {
+  const asyncCache = getAsyncCache();
+
+  // all configs with point structure id of some chain
+  {
+    const urlParamsSchema = Type.Object({
+      chain: chainIdSchema,
+    });
+    type UrlParams = Static<typeof urlParamsSchema>;
+    const responseSchema = Type.Object({
+      vaults: Type.Array(Type.Any()),
+    });
+
+    const queryParamsSchema = Type.Object({
+      include_eol: Type.Optional(Type.Boolean({ default: false })),
+    });
+    type QueryParams = Static<typeof queryParamsSchema>;
+
+    const schema: FastifySchema = {
+      tags: ['camelot'],
+      params: urlParamsSchema,
+      querystring: queryParamsSchema,
+      response: {
+        200: responseSchema,
+      },
+    };
+
+    instance.get<{ Params: UrlParams; Querystring: QueryParams }>(
+      '/config/:chain/bundles',
+      { schema },
+      async (request, reply) => {
+        const { chain } = request.params;
+        const { include_eol } = request.query;
+
+        const result = await asyncCache.wrap(`config:${chain}`, 5 * 60 * 1000, async () => {
+          const configs = await getBeefyVaultConfig(
+            chain,
+            vault =>
+              (include_eol ? true : vault.status === 'active') &&
+              vault.underlyingPlatform === 'camelot'
+          );
+
+          // remove clm vault from top levels if a vault exists on top
+          const clmVaultAddresses = new Set(
+            configs
+              .map(vault =>
+                vault.protocol_type === 'beefy_clm_vault'
+                  ? vault.beefy_clm_manager.vault_address
+                  : null
+              )
+              .map(address => address?.toLowerCase())
+              .filter(Boolean)
+          );
+
+          console.log(clmVaultAddresses);
+
+          const filteredConfigs = configs.filter(
+            vault => !clmVaultAddresses.has(vault.vault_address.toLowerCase())
+          );
+          return filteredConfigs;
+        });
+        reply.send(result);
+      }
+    );
+  }
+
+  done();
+}

src/routes/v1/partner/index.ts

@@ -0,0 +1,10 @@
+import type { FastifyInstance, FastifyPluginOptions } from 'fastify';
+import camelot from './camelot';
+export default async function (
+  instance: FastifyInstance,
+  _opts: FastifyPluginOptions,
+  done: (err?: Error) => void
+) {
+  instance.register(camelot, { prefix: '/camelot' });
+  done();
+}

src/vault-breakdown/vault/getBeefyVaultConfig.ts

@@ -24,6 +24,7 @@ export type BeefyVault = {
   pointStructureIds: string[];
   platformId: ApiPlatformId;
   status: 'active' | 'eol';
+  underlyingPlatform: string | null;
 } & (
   | {
       protocol_type: 'beefy_clm_vault';
@@ -109,6 +110,7 @@ export type ApiClmManager = {
   earnContractAddress: string; // reward pool address
   earnedTokenAddress: string; // clm manager address
   pointStructureIds?: string[];
+  tokenProviderId?: string;
 };
 
 export type ApiClmRewardPool = {
@@ -246,6 +248,7 @@ const getAllConfigs = async (chain: ChainId): Promise<BeefyVault[]> => {
     const reward_pools = clmRewardPoolDataPerClmAddress[vault_address] ?? [];
 
     const boosts = boostPerUnderlyingAddress[vault_address] ?? [];
+    const underlyingPlatform = vault.tokenProviderId ?? null;
 
     return {
       id: vault.id,
@@ -257,6 +260,7 @@ const getAllConfigs = async (chain: ChainId): Promise<BeefyVault[]> => {
       status: vault.status,
       strategy_address: vault.strategy.toLocaleLowerCase() as Hex,
       undelying_lp_address,
+      underlyingPlatform,
       reward_pools: reward_pools.map(pool => ({
         id: pool.id,
         clm_address: pool.tokenAddress.toLocaleLowerCase() as Hex,
@@ -305,12 +309,16 @@ const getAllConfigs = async (chain: ChainId): Promise<BeefyVault[]> => {
         : { protocol_type, platformId: vault.platformId };
     const reward_pools = vaultRewardPoolDataPerVaultAddress[vault_address] ?? [];
     const boosts = boostPerUnderlyingAddress[vault_address] ?? [];
+
+    const underlyingPlatform = vault.platformId ?? null;
+
     return {
       id: vault.id,
       vault_address,
       chain: vault.chain,
       vault_token_symbol: vault.earnedToken,
       ...additionalConfig,
+      underlyingPlatform,
       strategy_address: vault.strategy.toLocaleLowerCase() as Hex,
       undelying_lp_address: underlying_lp_address,
       status: vault.status,