@eulerxyz/euler-v2-sdk 0.1.2-beta → 0.2.0-beta

package/dist/src/sdk/buildSDK.js

@@ -22,42 +22,238 @@ import { PriceService, PricingBackendClient, } from "../services/priceService/in
 import { RewardsDirectAdapter, RewardsService, RewardsV3Adapter, } from "../services/rewardsService/index.js";
 import { IntrinsicApyService, IntrinsicApyV3Adapter, } from "../services/intrinsicApyService/index.js";
 import { OracleAdapterService, } from "../services/oracleAdapterService/index.js";
-import { SimulationService, } from "../services/simulationService/index.js";
-import { defaultAccountV3AdapterConfig, defaultAccountVaultsAdapterConfig, defaultBackendConfig, defaultDeploymentServiceConfig, defaultEulerEarnV3AdapterConfig, defaultEulerLabelsURLAdapterConfig, defaultIntrinsicApyV3AdapterConfig, defaultRewardsV3AdapterConfig, defaultSwapServiceConfig, defaultTokenlistServiceConfig, defaultVaultTypeAdapterConfig, } from "./defaultConfig.js";
+import { DEFAULT_EULER_LABELS_BASE_URL, DEFAULT_TOKENLIST_API_BASE_URL, defaultAccountV3AdapterConfig, defaultAccountVaultsAdapterConfig, defaultDeploymentServiceConfig, defaultEulerEarnV3AdapterConfig, defaultEulerLabelsURLAdapterConfig, defaultIntrinsicApyV3AdapterConfig, defaultPricingServiceConfig, defaultRewardsV3AdapterConfig, defaultSwapServiceConfig, defaultTokenlistServiceConfig, defaultVaultTypeAdapterConfig, } from "./defaultConfig.js";
 import { defaultEVaultV3AdapterConfig } from "./defaultConfig.js";
 import { FeeFlowService, } from "../services/feeFlowService/index.js";
+import { readEulerSDKEnvConfig, } from "./config.js";
 import { EVaultOnchainAdapter } from "../services/vaults/eVaultService/adapters/eVaultOnchainAdapter/eVaultOnchainAdapter.js";
 import { EVaultV3Adapter } from "../services/vaults/eVaultService/adapters/eVaultV3Adapter/eVaultV3Adapter.js";
 import { VaultMetaService, VaultTypeSubgraphAdapter, VaultTypeV3Adapter, } from "../services/vaults/vaultMetaService/index.js";
 import { VaultType } from "../utils/types.js";
 import { createQueryCacheBuildQuery, } from "../utils/buildQuery.js";
 import { BatchSimulationAdapter } from "../plugins/batchSimulation.js";
-export async function buildEulerSDK(options) {
-    const { rpcUrls, v3ApiKey, accountServiceConfig, eVaultServiceConfig, eulerEarnServiceConfig, accountVaultsAdapterConfig, vaultTypeAdapterConfig, additionalVaultServices, eulerLabelsAdapterConfig, tokenlistServiceConfig, swapServiceConfig, backendConfig, rewardsServiceConfig, intrinsicApyServiceConfig, oracleAdapterServiceConfig, queryCacheConfig, buildQuery, plugins, servicesOverrides, feeFlowServiceConfig, } = options;
-    const resolvedBuildQuery = buildQuery ?? createQueryCacheBuildQuery(queryCacheConfig);
+function pickConfigValue(configValue, explicitValue, envValue, defaultValue) {
+    return configValue ?? explicitValue ?? envValue ?? defaultValue;
+}
+function mergeNumberRecords(defaultRecord, envRecord, explicitRecord, configRecord) {
+    return {
+        ...(defaultRecord ?? {}),
+        ...(envRecord ?? {}),
+        ...(explicitRecord ?? {}),
+        ...(configRecord ?? {}),
+    };
+}
+function mergeStringRecords(envRecord, explicitRecord, configRecord) {
+    const merged = {
+        ...(envRecord ?? {}),
+        ...(explicitRecord ?? {}),
+        ...(configRecord ?? {}),
+    };
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+function maybeField(key, value) {
+    return value === undefined
+        ? {}
+        : { [key]: value };
+}
+function resolveV3AdapterConfig(defaultConfig, args) {
+    const { explicitConfig, explicitV3ApiKey, envConfig, config, envEndpoint, configEndpoint, envApiKey, configApiKey, envExtra, configExtra, } = args;
+    return {
+        ...defaultConfig,
+        ...maybeField("endpoint", envConfig.v3ApiUrl),
+        ...maybeField("apiKey", envConfig.v3ApiKey),
+        ...maybeField("endpoint", envEndpoint),
+        ...maybeField("apiKey", envApiKey),
+        ...(envExtra ?? {}),
+        ...maybeField("apiKey", explicitV3ApiKey),
+        ...(explicitConfig ?? {}),
+        ...maybeField("endpoint", config?.v3ApiUrl),
+        ...maybeField("apiKey", config?.v3ApiKey),
+        ...maybeField("endpoint", configEndpoint),
+        ...maybeField("apiKey", configApiKey),
+        ...(configExtra ?? {}),
+    };
+}
+function applyTemplate(template, values) {
+    return Object.entries(values).reduce((result, [key, value]) => result.replaceAll(`{${key}}`, String(value)), template);
+}
+function makeEulerLabelsConfig(config) {
+    if (!config)
+        return {};
+    const baseUrl = config.eulerLabelsBaseUrl ?? DEFAULT_EULER_LABELS_BASE_URL;
+    const hasBaseOverride = config.eulerLabelsBaseUrl !== undefined;
+    return {
+        ...(hasBaseOverride || config.eulerLabelsEntitiesUrlTemplate
+            ? {
+                getEulerLabelsEntitiesUrl: (chainId) => config.eulerLabelsEntitiesUrlTemplate
+                    ? applyTemplate(config.eulerLabelsEntitiesUrlTemplate, {
+                        base: baseUrl,
+                        chainId,
+                    })
+                    : `${baseUrl}/${chainId}/entities.json`,
+            }
+            : {}),
+        ...(hasBaseOverride || config.eulerLabelsProductsUrlTemplate
+            ? {
+                getEulerLabelsProductsUrl: (chainId) => config.eulerLabelsProductsUrlTemplate
+                    ? applyTemplate(config.eulerLabelsProductsUrlTemplate, {
+                        base: baseUrl,
+                        chainId,
+                    })
+                    : `${baseUrl}/${chainId}/products.json`,
+            }
+            : {}),
+        ...(hasBaseOverride || config.eulerLabelsPointsUrlTemplate
+            ? {
+                getEulerLabelsPointsUrl: (chainId) => config.eulerLabelsPointsUrlTemplate
+                    ? applyTemplate(config.eulerLabelsPointsUrlTemplate, {
+                        base: baseUrl,
+                        chainId,
+                    })
+                    : `${baseUrl}/${chainId}/points.json`,
+            }
+            : {}),
+        ...(hasBaseOverride || config.eulerLabelsEarnVaultsUrlTemplate
+            ? {
+                getEulerLabelsEarnVaultsUrl: (chainId) => config.eulerLabelsEarnVaultsUrlTemplate
+                    ? applyTemplate(config.eulerLabelsEarnVaultsUrlTemplate, {
+                        base: baseUrl,
+                        chainId,
+                    })
+                    : `${baseUrl}/${chainId}/earn-vaults.json`,
+            }
+            : {}),
+        ...(hasBaseOverride || config.eulerLabelsAssetsUrlTemplate
+            ? {
+                getEulerLabelsAssetsUrl: (chainId) => config.eulerLabelsAssetsUrlTemplate
+                    ? applyTemplate(config.eulerLabelsAssetsUrlTemplate, {
+                        base: baseUrl,
+                        chainId,
+                    })
+                    : `${baseUrl}/${chainId}/assets.json`,
+            }
+            : {}),
+        ...(hasBaseOverride || config.eulerLabelsGlobalAssetsUrl
+            ? {
+                getEulerLabelsGlobalAssetsUrl: () => config.eulerLabelsGlobalAssetsUrl ?? `${baseUrl}/all/assets.json`,
+            }
+            : {}),
+        ...(hasBaseOverride || config.eulerLabelsLogoUrlTemplate
+            ? {
+                getEulerLabelsLogoUrl: (filename) => config.eulerLabelsLogoUrlTemplate
+                    ? applyTemplate(config.eulerLabelsLogoUrlTemplate, {
+                        base: baseUrl,
+                        filename,
+                    })
+                    : `${baseUrl}/logo/${filename}`,
+            }
+            : {}),
+    };
+}
+function makeTokenlistConfig(config) {
+    if (!config?.tokenlistApiBaseUrl && !config?.tokenlistUrlTemplate)
+        return {};
+    const baseUrl = config.tokenlistApiBaseUrl ?? DEFAULT_TOKENLIST_API_BASE_URL;
+    return {
+        getTokenListUrl: (chainId) => config.tokenlistUrlTemplate
+            ? applyTemplate(config.tokenlistUrlTemplate, { base: baseUrl, chainId })
+            : `${baseUrl}/v1/tokens?chainId=${chainId}`,
+    };
+}
+function resolveRewardsDirectAdapterConfig(explicitConfig, envConfig, config) {
+    return {
+        ...maybeField("merklApiUrl", envConfig.rewardsMerklApiUrl),
+        ...maybeField("brevisApiUrl", envConfig.rewardsBrevisApiUrl),
+        ...maybeField("brevisProofsApiUrl", envConfig.rewardsBrevisProofsApiUrl),
+        ...maybeField("fuulApiUrl", envConfig.rewardsFuulApiUrl),
+        ...maybeField("fuulTotalsUrl", envConfig.rewardsFuulTotalsUrl),
+        ...maybeField("fuulClaimChecksUrl", envConfig.rewardsFuulClaimChecksUrl),
+        ...maybeField("brevisChainIds", envConfig.rewardsBrevisChainIds),
+        ...maybeField("merklDistributorAddress", envConfig.rewardsMerklDistributorAddress),
+        ...maybeField("fuulManagerAddress", envConfig.rewardsFuulManagerAddress),
+        ...maybeField("fuulFactoryAddress", envConfig.rewardsFuulFactoryAddress),
+        ...maybeField("enableMerkl", envConfig.rewardsEnableMerkl),
+        ...maybeField("enableBrevis", envConfig.rewardsEnableBrevis),
+        ...maybeField("enableFuul", envConfig.rewardsEnableFuul),
+        ...maybeField("merklApiUrl", explicitConfig?.merklApiUrl),
+        ...maybeField("brevisApiUrl", explicitConfig?.brevisApiUrl),
+        ...maybeField("brevisProofsApiUrl", explicitConfig?.brevisProofsApiUrl),
+        ...maybeField("fuulApiUrl", explicitConfig?.fuulApiUrl),
+        ...maybeField("fuulTotalsUrl", explicitConfig?.fuulTotalsUrl),
+        ...maybeField("fuulClaimChecksUrl", explicitConfig?.fuulClaimChecksUrl),
+        ...maybeField("brevisChainIds", explicitConfig?.brevisChainIds),
+        ...maybeField("merklDistributorAddress", explicitConfig?.merklDistributorAddress),
+        ...maybeField("fuulManagerAddress", explicitConfig?.fuulManagerAddress),
+        ...maybeField("fuulFactoryAddress", explicitConfig?.fuulFactoryAddress),
+        ...maybeField("enableMerkl", explicitConfig?.enableMerkl),
+        ...maybeField("enableBrevis", explicitConfig?.enableBrevis),
+        ...maybeField("enableFuul", explicitConfig?.enableFuul),
+        ...(explicitConfig?.directAdapterConfig ?? {}),
+        ...maybeField("merklApiUrl", config?.rewardsMerklApiUrl),
+        ...maybeField("brevisApiUrl", config?.rewardsBrevisApiUrl),
+        ...maybeField("brevisProofsApiUrl", config?.rewardsBrevisProofsApiUrl),
+        ...maybeField("fuulApiUrl", config?.rewardsFuulApiUrl),
+        ...maybeField("fuulTotalsUrl", config?.rewardsFuulTotalsUrl),
+        ...maybeField("fuulClaimChecksUrl", config?.rewardsFuulClaimChecksUrl),
+        ...maybeField("brevisChainIds", config?.rewardsBrevisChainIds),
+        ...maybeField("merklDistributorAddress", config?.rewardsMerklDistributorAddress),
+        ...maybeField("fuulManagerAddress", config?.rewardsFuulManagerAddress),
+        ...maybeField("fuulFactoryAddress", config?.rewardsFuulFactoryAddress),
+        ...maybeField("enableMerkl", config?.rewardsEnableMerkl),
+        ...maybeField("enableBrevis", config?.rewardsEnableBrevis),
+        ...maybeField("enableFuul", config?.rewardsEnableFuul),
+    };
+}
+export async function buildEulerSDK(options = {}) {
+    const { config, v3ApiKey, accountServiceConfig, eVaultServiceConfig, eulerEarnServiceConfig, accountVaultsAdapterConfig, vaultTypeAdapterConfig, additionalVaultServices, eulerLabelsAdapterConfig, tokenlistServiceConfig, swapServiceConfig, pricingServiceConfig, rewardsServiceConfig, intrinsicApyServiceConfig, oracleAdapterServiceConfig, queryCacheConfig, buildQuery, plugins, servicesOverrides, feeFlowServiceConfig, } = options;
+    const envConfig = readEulerSDKEnvConfig();
+    const resolvedRpcUrls = mergeNumberRecords(undefined, envConfig.rpcUrls, undefined, config?.rpcUrls);
+    const resolvedQueryCacheConfig = {
+        ...maybeField("enabled", envConfig.queryCacheEnabled),
+        ...maybeField("ttlMs", envConfig.queryCacheTtlMs),
+        ...(queryCacheConfig ?? {}),
+        ...maybeField("enabled", config?.queryCacheEnabled),
+        ...maybeField("ttlMs", config?.queryCacheTtlMs),
+    };
+    const resolvedBuildQuery = buildQuery ?? createQueryCacheBuildQuery(resolvedQueryCacheConfig);
+    const resolvedDeploymentServiceConfig = {
+        ...defaultDeploymentServiceConfig,
+        ...maybeField("deploymentsUrl", envConfig.deploymentsUrl),
+        ...maybeField("deploymentsUrl", config?.deploymentsUrl),
+    };
     // Build core services (these may be needed for adapters even if overridden)
     const abiService = servicesOverrides?.abiService ?? new ABIService(resolvedBuildQuery);
     const deploymentService = servicesOverrides?.deploymentService ??
-        (await DeploymentService.build(defaultDeploymentServiceConfig, resolvedBuildQuery));
-    const providerService = servicesOverrides?.providerService ?? new ProviderService(rpcUrls);
+        (await DeploymentService.build(resolvedDeploymentServiceConfig, resolvedBuildQuery));
+    const providerService = servicesOverrides?.providerService ?? new ProviderService(resolvedRpcUrls);
     // Account adapter is built early so it can be used when building account service (after vault meta service)
     const resolvedAccountServiceConfig = accountServiceConfig ?? {};
+    const resolvedAccountServiceAdapter = pickConfigValue(config?.accountServiceAdapter, resolvedAccountServiceConfig.adapter, envConfig.accountServiceAdapter);
     let accountOnchainAdapter;
-    const accountAdapter = resolvedAccountServiceConfig.adapter === "onchain"
+    const accountAdapter = resolvedAccountServiceAdapter === "onchain"
         ? (() => {
-            const accountVaultsAdapter = new AccountVaultsSubgraphAdapter(accountVaultsAdapterConfig || defaultAccountVaultsAdapterConfig, resolvedBuildQuery);
+            const accountVaultsAdapter = new AccountVaultsSubgraphAdapter({
+                subgraphURLs: mergeNumberRecords(defaultAccountVaultsAdapterConfig.subgraphURLs, envConfig.accountVaultsSubgraphUrls, accountVaultsAdapterConfig?.subgraphURLs, config?.accountVaultsSubgraphUrls),
+            }, resolvedBuildQuery);
             accountOnchainAdapter = new AccountOnchainAdapter(providerService, deploymentService, accountVaultsAdapter, resolvedBuildQuery);
             return accountOnchainAdapter;
         })()
-        : new AccountV3Adapter({
-            ...(resolvedAccountServiceConfig.v3AdapterConfig ??
-                defaultAccountV3AdapterConfig),
-            ...(v3ApiKey !== undefined ? { apiKey: v3ApiKey } : {}),
-            ...(resolvedAccountServiceConfig.v3AdapterConfig?.apiKey !==
-                undefined
-                ? { apiKey: resolvedAccountServiceConfig.v3AdapterConfig.apiKey }
-                : {}),
-        }, resolvedBuildQuery);
+        : new AccountV3Adapter(resolveV3AdapterConfig(defaultAccountV3AdapterConfig, {
+            explicitConfig: resolvedAccountServiceConfig.v3AdapterConfig,
+            explicitV3ApiKey: v3ApiKey,
+            envConfig,
+            config,
+            envEndpoint: envConfig.accountV3ApiUrl,
+            configEndpoint: config?.accountV3ApiUrl,
+            envApiKey: envConfig.accountV3ApiKey,
+            configApiKey: config?.accountV3ApiKey,
+            envExtra: {
+                ...maybeField("forceFresh", envConfig.accountV3ForceFresh),
+            },
+            configExtra: {
+                ...maybeField("forceFresh", config?.accountV3ForceFresh),
+            },
+        }), resolvedBuildQuery);
     // Build wallet service if not overridden
     let walletService;
     if (servicesOverrides?.walletService) {
@@ -75,20 +271,28 @@ export async function buildEulerSDK(options) {
     }
     else {
         const resolvedEVaultServiceConfig = eVaultServiceConfig ?? {};
-        const selectedEVaultAdapter = resolvedEVaultServiceConfig.adapter === "onchain"
+        const resolvedEVaultServiceAdapter = pickConfigValue(config?.eVaultServiceAdapter, resolvedEVaultServiceConfig.adapter, envConfig.eVaultServiceAdapter);
+        const selectedEVaultAdapter = resolvedEVaultServiceAdapter === "onchain"
             ? (() => {
                 eVaultAdapter = new EVaultOnchainAdapter(providerService, deploymentService, resolvedBuildQuery);
                 return eVaultAdapter;
             })()
-            : new EVaultV3Adapter({
-                ...(resolvedEVaultServiceConfig.v3AdapterConfig ??
-                    defaultEVaultV3AdapterConfig),
-                ...(v3ApiKey !== undefined ? { apiKey: v3ApiKey } : {}),
-                ...(resolvedEVaultServiceConfig.v3AdapterConfig?.apiKey !==
-                    undefined
-                    ? { apiKey: resolvedEVaultServiceConfig.v3AdapterConfig.apiKey }
-                    : {}),
-            }, resolvedBuildQuery);
+            : new EVaultV3Adapter(resolveV3AdapterConfig(defaultEVaultV3AdapterConfig, {
+                explicitConfig: resolvedEVaultServiceConfig.v3AdapterConfig,
+                explicitV3ApiKey: v3ApiKey,
+                envConfig,
+                config,
+                envEndpoint: envConfig.eVaultV3ApiUrl,
+                configEndpoint: config?.eVaultV3ApiUrl,
+                envApiKey: envConfig.eVaultV3ApiKey,
+                configApiKey: config?.eVaultV3ApiKey,
+                envExtra: {
+                    ...maybeField("batchSize", envConfig.eVaultV3BatchSize),
+                },
+                configExtra: {
+                    ...maybeField("batchSize", config?.eVaultV3BatchSize),
+                },
+            }), providerService, resolvedBuildQuery);
         eVaultService = new EVaultService(selectedEVaultAdapter, deploymentService);
     }
     // Build eulerEarn service if not overridden
@@ -98,19 +302,19 @@ export async function buildEulerSDK(options) {
     }
     else {
         const resolvedEulerEarnServiceConfig = eulerEarnServiceConfig ?? {};
-        const eulerEarnAdapter = resolvedEulerEarnServiceConfig.adapter === "onchain"
+        const resolvedEulerEarnServiceAdapter = pickConfigValue(config?.eulerEarnServiceAdapter, resolvedEulerEarnServiceConfig.adapter, envConfig.eulerEarnServiceAdapter);
+        const eulerEarnAdapter = resolvedEulerEarnServiceAdapter === "onchain"
             ? new EulerEarnOnchainAdapter(providerService, deploymentService, resolvedBuildQuery)
-            : new EulerEarnV3Adapter({
-                ...(resolvedEulerEarnServiceConfig.v3AdapterConfig ??
-                    defaultEulerEarnV3AdapterConfig),
-                ...(v3ApiKey !== undefined ? { apiKey: v3ApiKey } : {}),
-                ...(resolvedEulerEarnServiceConfig.v3AdapterConfig?.apiKey !==
-                    undefined
-                    ? {
-                        apiKey: resolvedEulerEarnServiceConfig.v3AdapterConfig.apiKey,
-                    }
-                    : {}),
-            }, resolvedBuildQuery);
+            : new EulerEarnV3Adapter(resolveV3AdapterConfig(defaultEulerEarnV3AdapterConfig, {
+                explicitConfig: resolvedEulerEarnServiceConfig.v3AdapterConfig,
+                explicitV3ApiKey: v3ApiKey,
+                envConfig,
+                config,
+                envEndpoint: envConfig.eulerEarnV3ApiUrl,
+                configEndpoint: config?.eulerEarnV3ApiUrl,
+                envApiKey: envConfig.eulerEarnV3ApiKey,
+                configApiKey: config?.eulerEarnV3ApiKey,
+            }), resolvedBuildQuery);
         eulerEarnService = new EulerEarnService(eulerEarnAdapter, deploymentService, eVaultService);
     }
     // Build securitizeVault service if not overridden
@@ -128,17 +332,37 @@ export async function buildEulerSDK(options) {
         vaultMetaService = servicesOverrides.vaultMetaService;
     }
     else {
-        const resolvedVaultTypeAdapterConfig = vaultTypeAdapterConfig ?? defaultVaultTypeAdapterConfig;
-        const vaultTypeAdapter = "subgraphURLs" in resolvedVaultTypeAdapterConfig
-            ? new VaultTypeSubgraphAdapter(resolvedVaultTypeAdapterConfig, resolvedBuildQuery)
-            : new VaultTypeV3Adapter({
-                ...resolvedVaultTypeAdapterConfig,
-                ...(v3ApiKey !== undefined ? { apiKey: v3ApiKey } : {}),
-                ...("apiKey" in resolvedVaultTypeAdapterConfig &&
-                    resolvedVaultTypeAdapterConfig.apiKey !== undefined
-                    ? { apiKey: resolvedVaultTypeAdapterConfig.apiKey }
-                    : {}),
-            }, resolvedBuildQuery);
+        const explicitVaultTypeAdapterKind = vaultTypeAdapterConfig
+            ? "subgraphURLs" in vaultTypeAdapterConfig
+                ? "subgraph"
+                : "v3"
+            : undefined;
+        const resolvedVaultTypeAdapterKind = pickConfigValue(config?.vaultTypeAdapter, explicitVaultTypeAdapterKind, envConfig.vaultTypeAdapter, "v3");
+        const vaultTypeAdapter = resolvedVaultTypeAdapterKind === "subgraph"
+            ? new VaultTypeSubgraphAdapter({
+                subgraphURLs: mergeNumberRecords(defaultAccountVaultsAdapterConfig.subgraphURLs, envConfig.vaultTypeSubgraphUrls, vaultTypeAdapterConfig &&
+                    "subgraphURLs" in vaultTypeAdapterConfig
+                    ? vaultTypeAdapterConfig.subgraphURLs
+                    : undefined, config?.vaultTypeSubgraphUrls),
+            }, resolvedBuildQuery)
+            : new VaultTypeV3Adapter(resolveV3AdapterConfig(defaultVaultTypeAdapterConfig, {
+                explicitConfig: vaultTypeAdapterConfig &&
+                    !("subgraphURLs" in vaultTypeAdapterConfig)
+                    ? {
+                        ...vaultTypeAdapterConfig,
+                        ...maybeField("typeMap", mergeStringRecords(envConfig.vaultTypeV3TypeMap, vaultTypeAdapterConfig.typeMap, config?.vaultTypeV3TypeMap)),
+                    }
+                    : {
+                        ...maybeField("typeMap", mergeStringRecords(envConfig.vaultTypeV3TypeMap, undefined, config?.vaultTypeV3TypeMap)),
+                    },
+                explicitV3ApiKey: v3ApiKey,
+                envConfig,
+                config,
+                envEndpoint: envConfig.vaultTypeV3ApiUrl,
+                configEndpoint: config?.vaultTypeV3ApiUrl,
+                envApiKey: envConfig.vaultTypeV3ApiKey,
+                configApiKey: config?.vaultTypeV3ApiKey,
+            }), resolvedBuildQuery);
         const allVaultServices = [
             {
                 type: VaultType.EVault,
@@ -189,7 +413,12 @@ export async function buildEulerSDK(options) {
     const portfolioService = servicesOverrides?.portfolioService ??
         new PortfolioService(accountService);
     // Build eulerLabels service if not overridden
-    const eulerLabelsConfig = eulerLabelsAdapterConfig || defaultEulerLabelsURLAdapterConfig;
+    const eulerLabelsConfig = {
+        ...defaultEulerLabelsURLAdapterConfig,
+        ...makeEulerLabelsConfig(envConfig),
+        ...(eulerLabelsAdapterConfig ?? {}),
+        ...makeEulerLabelsConfig(config),
+    };
     const eulerLabelsService = servicesOverrides?.eulerLabelsService ??
         (() => {
             const eulerLabelsAdapter = new EulerLabelsURLAdapter(eulerLabelsConfig, resolvedBuildQuery);
@@ -197,14 +426,26 @@ export async function buildEulerSDK(options) {
         })();
     // Build tokenlist service if not overridden
     const tokenlistService = servicesOverrides?.tokenlistService ??
-        new TokenlistService(tokenlistServiceConfig || defaultTokenlistServiceConfig, resolvedBuildQuery);
+        new TokenlistService({
+            ...defaultTokenlistServiceConfig,
+            ...makeTokenlistConfig(envConfig),
+            ...(tokenlistServiceConfig ?? {}),
+            ...makeTokenlistConfig(config),
+        }, resolvedBuildQuery);
     // Build swap service if not overridden
     const swapService = servicesOverrides?.swapService ??
-        new SwapService(swapServiceConfig || defaultSwapServiceConfig, deploymentService, resolvedBuildQuery);
+        new SwapService({
+            ...defaultSwapServiceConfig,
+            ...maybeField("swapApiUrl", envConfig.swapApiUrl),
+            ...maybeField("defaultDeadline", envConfig.swapDefaultDeadline),
+            ...(swapServiceConfig ?? {}),
+            ...maybeField("swapApiUrl", config?.swapApiUrl),
+            ...maybeField("defaultDeadline", config?.swapDefaultDeadline),
+        }, deploymentService, resolvedBuildQuery);
     // Build execution service if not overridden
     const executionService = servicesOverrides?.executionService ??
         (() => {
-            const svc = new ExecutionService(deploymentService, walletService);
+            const svc = new ExecutionService(deploymentService, walletService, providerService, vaultMetaService);
             if (plugins?.length)
                 svc.setPlugins(plugins);
             return svc;
@@ -212,56 +453,38 @@ export async function buildEulerSDK(options) {
     // Build price service if not overridden
     const priceService = servicesOverrides?.priceService ??
         (() => {
-            const resolvedBackendConfig = backendConfig ?? defaultBackendConfig;
-            const backendClient = new PricingBackendClient({
-                ...resolvedBackendConfig,
-                ...(v3ApiKey !== undefined ? { apiKey: v3ApiKey } : {}),
-                ...(resolvedBackendConfig.apiKey !== undefined
-                    ? { apiKey: resolvedBackendConfig.apiKey }
-                    : {}),
-            }, resolvedBuildQuery);
+            const resolvedPricingServiceConfig = resolveV3AdapterConfig(defaultPricingServiceConfig, {
+                explicitConfig: pricingServiceConfig,
+                explicitV3ApiKey: v3ApiKey,
+                envConfig,
+                config,
+                envEndpoint: envConfig.pricingApiUrl,
+                configEndpoint: config?.pricingApiUrl,
+                envApiKey: envConfig.pricingApiKey,
+                configApiKey: config?.pricingApiKey,
+            });
+            const backendClient = new PricingBackendClient(resolvedPricingServiceConfig, resolvedBuildQuery);
             return new PriceService(providerService, deploymentService, backendClient, resolvedBuildQuery);
         })();
     // Build rewards service if not overridden
     const rewardsService = servicesOverrides?.rewardsService ??
         (() => {
-            const resolvedRewardsServiceConfig = rewardsServiceConfig ?? {};
-            const legacyDirectAdapterConfig = {
-                merklApiUrl: resolvedRewardsServiceConfig.merklApiUrl,
-                brevisApiUrl: resolvedRewardsServiceConfig.brevisApiUrl,
-                brevisProofsApiUrl: resolvedRewardsServiceConfig.brevisProofsApiUrl,
-                fuulApiUrl: resolvedRewardsServiceConfig.fuulApiUrl,
-                fuulTotalsUrl: resolvedRewardsServiceConfig.fuulTotalsUrl,
-                fuulClaimChecksUrl: resolvedRewardsServiceConfig.fuulClaimChecksUrl,
-                brevisChainIds: resolvedRewardsServiceConfig.brevisChainIds,
-                merklDistributorAddress: resolvedRewardsServiceConfig.merklDistributorAddress,
-                fuulManagerAddress: resolvedRewardsServiceConfig.fuulManagerAddress,
-                fuulFactoryAddress: resolvedRewardsServiceConfig.fuulFactoryAddress,
-                enableMerkl: resolvedRewardsServiceConfig.enableMerkl,
-                enableBrevis: resolvedRewardsServiceConfig.enableBrevis,
-                enableFuul: resolvedRewardsServiceConfig.enableFuul,
-            };
-            const directAdapterConfig = {
-                ...legacyDirectAdapterConfig,
-                ...(resolvedRewardsServiceConfig.directAdapterConfig ?? {}),
-            };
+            const resolvedRewardsServiceAdapter = pickConfigValue(config?.rewardsServiceAdapter, rewardsServiceConfig?.adapter, envConfig.rewardsServiceAdapter, "v3");
+            const directAdapterConfig = resolveRewardsDirectAdapterConfig(rewardsServiceConfig, envConfig, config);
             const directAdapter = new RewardsDirectAdapter(directAdapterConfig, resolvedBuildQuery);
-            const rewardsAdapter = resolvedRewardsServiceConfig.adapter === "direct"
+            const rewardsAdapter = resolvedRewardsServiceAdapter === "direct"
                 ? directAdapter
-                : new RewardsV3Adapter({
-                    ...(resolvedRewardsServiceConfig.v3AdapterConfig ??
-                        defaultRewardsV3AdapterConfig),
-                    ...(v3ApiKey !== undefined ? { apiKey: v3ApiKey } : {}),
-                    ...(resolvedRewardsServiceConfig.v3AdapterConfig?.apiKey !==
-                        undefined
-                        ? {
-                            apiKey: resolvedRewardsServiceConfig.v3AdapterConfig.apiKey,
-                        }
-                        : {}),
-                }, resolvedBuildQuery);
-            return new RewardsService(rewardsAdapter, resolvedRewardsServiceConfig.adapter === "direct"
-                ? undefined
-                : directAdapter, {
+                : new RewardsV3Adapter(resolveV3AdapterConfig(defaultRewardsV3AdapterConfig, {
+                    explicitConfig: rewardsServiceConfig?.v3AdapterConfig,
+                    explicitV3ApiKey: v3ApiKey,
+                    envConfig,
+                    config,
+                    envEndpoint: envConfig.rewardsV3ApiUrl,
+                    configEndpoint: config?.rewardsV3ApiUrl,
+                    envApiKey: envConfig.rewardsV3ApiKey,
+                    configApiKey: config?.rewardsV3ApiKey,
+                }), resolvedBuildQuery);
+            return new RewardsService(rewardsAdapter, resolvedRewardsServiceAdapter === "direct" ? undefined : directAdapter, {
                 merklDistributorAddress: directAdapter.getMerklDistributorAddress(),
                 fuulManagerAddress: directAdapter.getFuulManagerAddress(),
                 fuulFactoryAddress: directAdapter.getFuulFactoryAddress(),
@@ -271,26 +494,53 @@ export async function buildEulerSDK(options) {
     const intrinsicApyService = servicesOverrides?.intrinsicApyService ??
         (() => {
             const resolvedIntrinsicApyServiceConfig = intrinsicApyServiceConfig ?? {};
-            const intrinsicApyAdapter = new IntrinsicApyV3Adapter({
-                ...(resolvedIntrinsicApyServiceConfig.v3AdapterConfig ??
-                    defaultIntrinsicApyV3AdapterConfig),
-                ...(v3ApiKey !== undefined ? { apiKey: v3ApiKey } : {}),
-                ...(resolvedIntrinsicApyServiceConfig.v3AdapterConfig?.apiKey !==
-                    undefined
-                    ? {
-                        apiKey: resolvedIntrinsicApyServiceConfig.v3AdapterConfig.apiKey,
-                    }
-                    : {}),
-            }, resolvedBuildQuery);
+            const intrinsicApyAdapter = new IntrinsicApyV3Adapter(resolveV3AdapterConfig(defaultIntrinsicApyV3AdapterConfig, {
+                explicitConfig: resolvedIntrinsicApyServiceConfig.v3AdapterConfig,
+                explicitV3ApiKey: v3ApiKey,
+                envConfig,
+                config,
+                envEndpoint: envConfig.intrinsicApyV3ApiUrl,
+                configEndpoint: config?.intrinsicApyV3ApiUrl,
+                envApiKey: envConfig.intrinsicApyV3ApiKey,
+                configApiKey: config?.intrinsicApyV3ApiKey,
+                envExtra: {
+                    ...maybeField("pageSize", envConfig.intrinsicApyV3PageSize),
+                    ...maybeField("maxAssetsPerRequest", envConfig.intrinsicApyV3MaxAssetsPerRequest),
+                },
+                configExtra: {
+                    ...maybeField("pageSize", config?.intrinsicApyV3PageSize),
+                    ...maybeField("maxAssetsPerRequest", config?.intrinsicApyV3MaxAssetsPerRequest),
+                },
+            }), resolvedBuildQuery);
             return new IntrinsicApyService(intrinsicApyAdapter);
         })();
     const oracleAdapterService = servicesOverrides?.oracleAdapterService ??
-        new OracleAdapterService(oracleAdapterServiceConfig, resolvedBuildQuery);
+        new OracleAdapterService({
+            ...maybeField("baseUrl", envConfig.oracleAdaptersBaseUrl),
+            ...maybeField("cacheMs", envConfig.oracleAdaptersCacheMs),
+            ...(oracleAdapterServiceConfig ?? {}),
+            ...maybeField("baseUrl", config?.oracleAdaptersBaseUrl),
+            ...maybeField("cacheMs", config?.oracleAdaptersCacheMs),
+        }, resolvedBuildQuery);
     const feeFlowService = servicesOverrides?.feeFlowService ??
-        new FeeFlowService(feeFlowServiceConfig, resolvedBuildQuery);
-    // Build simulation service if not overridden
-    const simulationService = servicesOverrides?.simulationService ??
-        new SimulationService(providerService, deploymentService, vaultMetaService, executionService, priceService, rewardsService, intrinsicApyService, eulerLabelsService, walletService);
+        new FeeFlowService({
+            ...maybeField("feeFlowControllerAddress", envConfig.feeFlowControllerAddress),
+            ...maybeField("feeFlowControllerUtilAddress", envConfig.feeFlowControllerUtilAddress),
+            ...maybeField("defaultBuyDeadlineSeconds", envConfig.feeFlowDefaultBuyDeadlineSeconds),
+            ...(feeFlowServiceConfig ?? {}),
+            ...maybeField("feeFlowControllerAddress", config?.feeFlowControllerAddress),
+            ...maybeField("feeFlowControllerUtilAddress", config?.feeFlowControllerUtilAddress),
+            ...maybeField("defaultBuyDeadlineSeconds", config?.feeFlowDefaultBuyDeadlineSeconds),
+        }, resolvedBuildQuery);
+    if (executionService instanceof ExecutionService) {
+        executionService.setProviderService(providerService);
+        executionService.setVaultMetaService(vaultMetaService);
+        executionService.setWalletService(walletService);
+        executionService.setPriceService(priceService);
+        executionService.setRewardsService(rewardsService);
+        executionService.setIntrinsicApyService(intrinsicApyService);
+        executionService.setEulerLabelsService(eulerLabelsService);
+    }
     // Wire priceService and rewardsService into account service
     if (accountService instanceof AccountService) {
         accountService.setPriceService(priceService);
@@ -343,7 +593,7 @@ export async function buildEulerSDK(options) {
     if (securitizeVaultService instanceof SecuritizeVaultService) {
         securitizeVaultService.setEulerLabelsService(eulerLabelsService);
     }
-    return new EulerSDK({
+    const sdk = new EulerSDK({
         accountService,
         portfolioService,
         walletService,
@@ -358,7 +608,6 @@ export async function buildEulerSDK(options) {
         tokenlistService,
         swapService,
         executionService,
-        simulationService,
         priceService,
         rewardsService,
         intrinsicApyService,
@@ -366,5 +615,9 @@ export async function buildEulerSDK(options) {
         feeFlowService,
         plugins,
     });
+    if (executionService instanceof ExecutionService) {
+        executionService.setPluginProcessor((plan, account, chainId) => sdk.processPlugins(plan, account, chainId));
+    }
+    return sdk;
 }
 //# sourceMappingURL=buildSDK.js.map