@turtleclub/hooks 0.4.0 → 0.5.0-beta.1

package/dist/index.cjs

@@ -20,12 +20,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AuthProvider: () => AuthProvider,
+  ApiError: () => ApiError,
+  BalanceSourcePriority: () => BalanceSourcePriority,
+  TurtleProvider: () => TurtleProvider,
+  apiClient: () => apiClient,
   approveStep: () => approveStep,
   asset: () => asset,
   assetData: () => assetData,
   assetERC20Data: () => assetERC20Data,
   assetImageData: () => assetImageData,
+  balanceQueries: () => balanceQueries,
   balanceTokenSchema: () => balanceTokenSchema,
   chainSchema: () => chainSchema,
   checkMembership: () => checkMembership,
@@ -48,20 +52,33 @@ __export(index_exports, {
   earnRouteResponseSchema: () => earnRouteResponseSchema,
   ensoBalancesQueries: () => ensoBalancesQueries,
   ensoStep: () => ensoStep,
+  filterBalancesByChains: () => filterBalancesByChains,
+  filterExcludedTokens: () => filterExcludedTokens,
+  filterNonZeroBalances: () => filterNonZeroBalances,
   geocheckQueryOptions: () => geocheckQueryOptions,
   getDeposits: () => getDeposits,
   getEarnOpportunities: () => getEarnOpportunities,
   getEarnRoute: () => getEarnRoute,
   getOpportunities: () => getOpportunities,
   getOpportunityById: () => getOpportunityById,
+  getPortfolioBalance: () => getPortfolioBalance,
   getProducts: () => getProducts,
+  getSourcePriority: () => getSourcePriority,
+  getSupportedChains: () => getSupportedChains,
+  getSupportedTokens: () => getSupportedTokens,
   getWalletBalances: () => getWalletBalances,
   getWidgetOpportunities: () => getWidgetOpportunities,
   incentiveSchema: () => incentiveSchema,
   lendingConfigSchema: () => lendingConfigSchema,
+  mergeBalancesByPriority: () => mergeBalancesByPriority,
   opportunitiesQueries: () => opportunitiesQueries,
   opportunitySchema: () => opportunitySchema,
   organizationSchema: () => organizationSchema,
+  portfolioBalanceResponseSchema: () => portfolioBalanceResponseSchema,
+  portfolioHoldingsSchema: () => portfolioHoldingsSchema,
+  portfolioTokenSchema: () => portfolioTokenSchema,
+  portfolioWalletSchema: () => portfolioWalletSchema,
+  processRouteDetails: () => processRouteDetails,
   productSchema: () => productSchema,
   productsQueries: () => productsQueries,
   queries: () => queries,
@@ -69,9 +86,14 @@ __export(index_exports, {
   routerStep: () => routerStep,
   routerSubstep: () => routerSubstep,
   stepTx: () => stepTx,
+  supportedChainsQueries: () => supportedChainsQueries,
+  supportedChainsResponseSchema: () => supportedChainsResponseSchema,
+  supportedTokenSchema: () => supportedTokenSchema,
+  supportedTokensQueries: () => supportedTokensQueries,
+  supportedTokensResponseSchema: () => supportedTokensResponseSchema,
   swapSubstep: () => swapSubstep,
   tokenSchema: () => tokenSchema,
-  useAuthToken: () => useAuthToken,
+  useBalance: () => useBalance,
   useCheckMembership: () => useCheckMembership,
   useCreateMembership: () => useCreateMembership,
   useCreateMembershipAgreement: () => useCreateMembershipAgreement,
@@ -80,12 +102,18 @@ __export(index_exports, {
   useDeposits: () => useDeposits,
   useEarnOpportunities: () => useEarnOpportunities,
   useEarnRoute: () => useEarnRoute,
+  useEnsoBalances: () => useEnsoBalances,
   useGeocheck: () => useGeocheck,
+  useGetOnChainBalance: () => useGetOnChainBalance,
   useMultiChainBalances: () => useMultiChainBalances,
   useOpportunities: () => useOpportunities,
   useOpportunity: () => useOpportunity,
+  usePortfolioBalance: () => usePortfolioBalance,
   useProduct: () => useProduct,
   useProducts: () => useProducts,
+  useSupportedChains: () => useSupportedChains,
+  useSupportedTokens: () => useSupportedTokens,
+  useSwapRoute: () => useSwapRoute,
   useTokenBalance: () => useTokenBalance,
   useUpdateProduct: () => useUpdateProduct,
   useUploadProductLogo: () => useUploadProductLogo,
@@ -100,14 +128,14 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/v2/index.ts
-var import_query_key_factory9 = require("@lukemorales/query-key-factory");
+var import_query_key_factory12 = require("@lukemorales/query-key-factory");
 
 // src/v2/opportunities/queries.ts
 var import_query_key_factory = require("@lukemorales/query-key-factory");
 
 // src/v2/lib/api-client.ts
-var API_BASE_URL = "https://api.turtle.xyz";
-var EARN_BASE_URL = "https://earn.turtle.xyz";
+var API_BASE_URL = "https://api.turtle.club";
+var EARN_BASE_URL = "https://earn.turtle.club";
 var ApiError = class extends Error {
   constructor(message, status, response) {
     super(message);
@@ -116,81 +144,110 @@ var ApiError = class extends Error {
     this.name = "ApiError";
   }
 };
-var getEarnUrl = () => {
-  return process.env.NEXT_PUBLIC_EARN_URL || process.env.VITE_EARN_URL || EARN_BASE_URL;
-};
-var getApiUrl = () => {
-  return process.env.NEXT_PUBLIC_API_URL || process.env.VITE_API_URL || API_BASE_URL;
-};
-async function apiClient(endpoint, options) {
-  const { debug, domain = "api", baseUrl, ...fetchOptions } = options ?? {};
-  const resolvedBaseUrl = domain === "earn" ? getEarnUrl() : domain === "custom" ? baseUrl : getApiUrl();
-  const url = `${resolvedBaseUrl}${endpoint}`;
-  if (debug) {
-    console.log("[API Request]", {
-      method: fetchOptions.method ?? "GET",
-      url,
-      headers: fetchOptions.headers,
-      body: fetchOptions.body
-    });
+var ApiClient = class _ApiClient {
+  static instance;
+  config = {};
+  static getInstance() {
+    if (!_ApiClient.instance) {
+      _ApiClient.instance = new _ApiClient();
+    }
+    return _ApiClient.instance;
   }
-  try {
-    const response = await fetch(url, {
-      headers: {
-        "Content-Type": "application/json",
-        ...fetchOptions.headers
-      },
-      ...fetchOptions
-    });
-    const data = await response.json();
+  configure(config) {
+    this.config = { ...this.config, ...config };
+  }
+  getConfig() {
+    return this.config;
+  }
+  getBaseUrl(domain) {
+    if (domain === "earn") {
+      return this.config.earnUrl || EARN_BASE_URL;
+    }
+    return this.config.apiUrl || API_BASE_URL;
+  }
+  async fetch(endpoint, options) {
+    const { domain = "api", debug = this.config.debug, body, ...fetchOptions } = options ?? {};
+    const baseUrl = this.getBaseUrl(domain);
+    const url = `${baseUrl}${endpoint}`;
+    const token = this.config.getToken?.();
+    const isFormData = body instanceof FormData;
+    const headers = {
+      // Don't set Content-Type for FormData - browser sets it with boundary
+      ...!isFormData && { "Content-Type": "application/json" },
+      ...fetchOptions.headers
+    };
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
     if (debug) {
-      console.log("[API Response]", {
-        status: response.status,
-        ok: response.ok,
-        data
+      console.log("[ApiClient Request]", {
+        method: fetchOptions.method ?? "GET",
+        url,
+        headers,
+        body: isFormData ? "[FormData]" : body
       });
     }
-    if (!response.ok) {
+    try {
+      const response = await fetch(url, {
+        ...fetchOptions,
+        headers,
+        body: body ? isFormData ? body : JSON.stringify(body) : void 0
+      });
+      const data = await response.json();
+      if (debug) {
+        console.log("[ApiClient Response]", {
+          status: response.status,
+          ok: response.ok,
+          data
+        });
+      }
+      if (!response.ok) {
+        throw new ApiError(
+          `API error: ${response.status} ${response.statusText}`,
+          response.status,
+          data
+        );
+      }
+      return data;
+    } catch (error) {
+      if (debug) {
+        console.error("[ApiClient Error]", error);
+      }
+      if (error instanceof ApiError) {
+        throw error;
+      }
       throw new ApiError(
-        `API error: ${response.status} ${response.statusText}`,
-        response.status,
-        data
+        error instanceof Error ? error.message : "Unknown error",
+        0,
+        error
       );
     }
-    return data;
-  } catch (error) {
-    if (debug) {
-      console.error("[API Error]", error);
-    }
-    if (error instanceof ApiError) {
-      throw error;
-    }
-    throw new ApiError(error instanceof Error ? error.message : "Unknown error", 0, error);
   }
-}
+};
+var apiClient = ApiClient.getInstance();
 
 // src/v2/schemas/shared.ts
 var import_zod = require("zod");
 var chainSchema = import_zod.z.object({
-  id: import_zod.z.string(),
+  id: import_zod.z.string().optional(),
   name: import_zod.z.string(),
-  slug: import_zod.z.string(),
+  slug: import_zod.z.string().optional(),
   chainId: import_zod.z.string(),
-  logoUrl: import_zod.z.string(),
-  ecosystem: import_zod.z.string(),
-  status: import_zod.z.string(),
-  explorerUrl: import_zod.z.string()
+  logoUrl: import_zod.z.string().optional(),
+  ecosystem: import_zod.z.string().optional(),
+  status: import_zod.z.string().optional(),
+  explorerUrl: import_zod.z.string().optional()
 });
 var tokenSchema = import_zod.z.object({
-  id: import_zod.z.string(),
+  id: import_zod.z.string().optional(),
   name: import_zod.z.string(),
   symbol: import_zod.z.string(),
   address: import_zod.z.string(),
   chain: chainSchema,
   decimals: import_zod.z.number(),
-  logoUrl: import_zod.z.string(),
+  logoUrl: import_zod.z.string().optional(),
   isNative: import_zod.z.boolean(),
-  priceUsd: import_zod.z.number()
+  priceUsd: import_zod.z.number().optional()
 });
 var organizationSchema = import_zod.z.object({
   id: import_zod.z.string(),
@@ -229,6 +286,8 @@ var vaultConfigSchema = import_zod.z.object({
   providerMetadata: import_zod.z.any().optional().nullable(),
   performanceFee: import_zod.z.number().min(0).max(100).optional().nullable(),
   managementFee: import_zod.z.number().min(0).max(100).optional().nullable(),
+  depositFee: import_zod.z.number().min(0).max(100).optional().nullable(),
+  withdrawalFee: import_zod.z.number().min(0).max(100).optional().nullable(),
   createdAt: import_zod.z.string().datetime().optional(),
   updatedAt: import_zod.z.string().datetime().optional()
 });
@@ -321,7 +380,7 @@ async function getOpportunities(filters, options) {
   if (filters?.productId) params.append("productId", filters.productId);
   const queryString = params.toString();
   const endpoint = `/turtle/opportunities${queryString ? `?${queryString}` : ""}`;
-  const data = await apiClient(endpoint, {
+  const data = await apiClient.fetch(endpoint, {
     method: "GET",
     debug: options?.debug
   });
@@ -333,7 +392,7 @@ async function getOpportunities(filters, options) {
   return result.data;
 }
 async function getOpportunityById(id, options) {
-  const data = await apiClient(`/turtle/opportunities/${id}`, {
+  const data = await apiClient.fetch(`/turtle/opportunities/${id}`, {
     method: "GET",
     debug: options?.debug
   });
@@ -388,7 +447,7 @@ var earnOpportunitiesResponseSchema = import_zod3.z.object({
 
 // src/v2/earn-opportunities/api.ts
 async function getEarnOpportunities(context) {
-  const data = await apiClient("/v1/opportunities/", {
+  const data = await apiClient.fetch("/v1/opportunities/", {
     method: "GET",
     domain: "earn",
     signal: context?.signal
@@ -505,7 +564,7 @@ async function getEarnRoute(params, context) {
     ...params.referral_code && { referral_code: params.referral_code },
     ...params.id && { id: params.id }
   });
-  const response = await apiClient(`/v1/route/?${searchParams.toString()}`, {
+  const response = await apiClient.fetch(`/v1/route/?${searchParams.toString()}`, {
     method: "GET",
     domain: "earn",
     signal: context?.signal
@@ -564,7 +623,7 @@ async function checkMembership(params, context) {
     address: params.address,
     ...params.walletEcosystem && { walletEcosystem: params.walletEcosystem }
   });
-  const data = await apiClient(`/v1/membership/?${searchParams.toString()}`, {
+  const data = await apiClient.fetch(`/v1/membership/?${searchParams.toString()}`, {
     method: "GET",
     domain: "earn",
     signal: context?.signal
@@ -577,10 +636,10 @@ async function checkMembership(params, context) {
   return result.data;
 }
 async function createMembershipAgreement(request) {
-  const data = await apiClient("/v1/membership/agreement", {
+  const data = await apiClient.fetch("/v1/membership/agreement", {
     method: "POST",
     domain: "earn",
-    body: JSON.stringify(request)
+    body: request
   });
   const result = createAgreementResponseSchema.safeParse(data);
   if (result.success === false) {
@@ -590,10 +649,10 @@ async function createMembershipAgreement(request) {
   return result.data;
 }
 async function createMembership(request) {
-  const data = await apiClient("/v1/membership/", {
+  const data = await apiClient.fetch("/v1/membership/", {
     method: "POST",
     domain: "earn",
-    body: JSON.stringify(request)
+    body: request
   });
   const result = createMembershipResponseSchema.safeParse(data);
   if (result.success === false) {
@@ -645,7 +704,7 @@ async function getDeposits(params, context) {
   });
   const queryString = searchParams.toString();
   const endpoint = `/v1/deposit/${distributor_id}${queryString ? `?${queryString}` : ""}`;
-  const data = await apiClient(endpoint, {
+  const data = await apiClient.fetch(endpoint, {
     method: "GET",
     domain: "earn",
     signal: context?.signal
@@ -669,21 +728,10 @@ var earnDepositsQueries = (0, import_query_key_factory5.createQueryKeys)("earnDe
 // src/v2/products/queries.ts
 var import_query_key_factory6 = require("@lukemorales/query-key-factory");
 
-// src/v2/lib/authenticated-api-client.ts
-async function authenticatedApiClient(endpoint, options, token = null) {
-  return apiClient(endpoint, {
-    ...options,
-    headers: {
-      ...token && { Authorization: `Bearer ${token}` },
-      ...options?.headers
-    }
-  });
-}
-
 // src/v2/products/schema.ts
 var import_zod7 = require("zod");
 var ProductTypeSchema = import_zod7.z.enum(["deal", "campaign"]);
-var ProductStatusSchema = import_zod7.z.enum(["active", "paused", "ended"]);
+var ProductStatusSchema = import_zod7.z.enum(["draft", "active", "paused", "ended"]);
 var TurtleOrganizationSchema = import_zod7.z.object({
   id: import_zod7.z.string().uuid(),
   name: import_zod7.z.string(),
@@ -753,19 +801,14 @@ var ProductFiltersSchema = import_zod7.z.object({
 });
 
 // src/v2/products/api.ts
-async function getProducts(filters, token) {
+async function getProducts(filters) {
   const params = new URLSearchParams();
   if (filters?.organizationId) params.append("organizationId", filters.organizationId);
   const queryString = params.toString();
   const endpoint = `/admin/products${queryString ? `?${queryString}` : ""}`;
-  console.log("endpoint", endpoint, filters);
-  const data = await authenticatedApiClient(
-    endpoint,
-    {
-      method: "GET"
-    },
-    token
-  );
+  const data = await apiClient.fetch(endpoint, {
+    method: "GET"
+  });
   const result = ProductsResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
@@ -773,16 +816,11 @@ async function getProducts(filters, token) {
   }
   return result.data;
 }
-async function getProduct(id, token) {
+async function getProduct(id) {
   const endpoint = `/admin/products/${id}`;
-  const data = await authenticatedApiClient(
-    endpoint,
-    {
-      method: "GET"
-    },
-    token
-  );
-  console.log(data);
+  const data = await apiClient.fetch(endpoint, {
+    method: "GET"
+  });
   const result = ProductResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
@@ -790,19 +828,12 @@ async function getProduct(id, token) {
   }
   return result.data;
 }
-async function createProduct(input, token) {
+async function createProduct(input) {
   const endpoint = `/admin/products`;
-  const data = await authenticatedApiClient(
-    endpoint,
-    {
-      method: "POST",
-      body: JSON.stringify(input),
-      headers: {
-        "Content-Type": "application/json"
-      }
-    },
-    token
-  );
+  const data = await apiClient.fetch(endpoint, {
+    method: "POST",
+    body: input
+  });
   const result = CreateProductResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
@@ -810,19 +841,12 @@ async function createProduct(input, token) {
   }
   return result.data;
 }
-async function updateProduct(input, token) {
+async function updateProduct(input) {
   const endpoint = `/admin/products/${input.product.id}`;
-  const data = await authenticatedApiClient(
-    endpoint,
-    {
-      method: "PUT",
-      body: JSON.stringify(input),
-      headers: {
-        "Content-Type": "application/json"
-      }
-    },
-    token
-  );
+  const data = await apiClient.fetch(endpoint, {
+    method: "PUT",
+    body: input
+  });
   const result = UpdateProductResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
@@ -830,36 +854,28 @@ async function updateProduct(input, token) {
   }
   return result.data;
 }
-async function deleteProduct(id, token) {
+async function deleteProduct(id) {
   const endpoint = `/admin/products/${id}`;
-  const data = await authenticatedApiClient(
-    endpoint,
-    {
-      method: "DELETE",
-      headers: {
-        "Content-Type": "application/json"
-      }
-    },
-    token
-  );
+  const data = await apiClient.fetch(endpoint, {
+    method: "DELETE"
+  });
   const result = ProductResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
     throw new Error(`Failed to delete product: ${result.error.message}`);
   }
 }
-async function uploadProductLogo({ file, filename }, token) {
+async function uploadProductLogo({
+  file,
+  filename
+}) {
   const endpoint = `/admin/products/upload-logo`;
   const formData = new FormData();
   formData.append("file", file, filename || file.name);
-  const data = await authenticatedApiClient(
-    endpoint,
-    {
-      method: "POST",
-      body: formData
-    },
-    token
-  );
+  const data = await apiClient.fetch(endpoint, {
+    method: "POST",
+    body: formData
+  });
   const result = UploadProductLogoResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
@@ -871,17 +887,17 @@ async function uploadProductLogo({ file, filename }, token) {
 // src/v2/products/queries.ts
 var productsQueries = (0, import_query_key_factory6.createQueryKeys)("products", {
   // Get all products (no filters)
-  all: (token) => ({
+  all: () => ({
     queryKey: ["all"],
-    queryFn: () => getProducts(void 0, token)
+    queryFn: () => getProducts()
   }),
-  list: (filters, token) => ({
+  list: (filters) => ({
     queryKey: [{ filters }],
-    queryFn: () => getProducts(filters, token)
+    queryFn: () => getProducts(filters)
   }),
-  byId: (id, token) => ({
+  byId: (id) => ({
     queryKey: [id],
-    queryFn: () => getProduct(id, token)
+    queryFn: () => getProduct(id)
   })
 });
 
@@ -915,10 +931,9 @@ async function getWalletBalances(params, context) {
     chain: chain.toString()
   });
   const endpoint = `/v1/api/wallet_balances?${searchParams.toString()}`;
-  const data = await apiClient(endpoint, {
+  const data = await apiClient.fetch(endpoint, {
     method: "GET",
-    domain: "custom",
-    baseUrl: "https://earn.turtle.vision",
+    domain: "earn",
     signal: context?.signal
   });
   const result = walletBalancesResponseSchema.safeParse(data);
@@ -949,7 +964,7 @@ var widgetOpportunitiesResponseSchema = import_zod9.z.object({
 
 // src/v2/widget/api.ts
 async function getWidgetOpportunities(distributorId, context) {
-  const data = await apiClient(`/widget/${distributorId}/opportunities`, {
+  const data = await apiClient.fetch(`/widget/${distributorId}/opportunities`, {
     method: "GET",
     signal: context?.signal
   });
@@ -969,6 +984,80 @@ var widgetQueries = (0, import_query_key_factory8.createQueryKeys)("widget", {
   })
 });
 
+// src/v2/supported-chains/queries.ts
+var import_query_key_factory9 = require("@lukemorales/query-key-factory");
+
+// src/v2/supported-chains/schema.ts
+var import_zod10 = require("zod");
+var supportedChainsResponseSchema = import_zod10.z.object({
+  chains: import_zod10.z.array(chainSchema)
+});
+
+// src/v2/supported-chains/api.ts
+async function getSupportedChains(options) {
+  const data = await apiClient.fetch("/turtle/chains", {
+    method: "GET",
+    debug: options?.debug
+  });
+  const result = supportedChainsResponseSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse supported chains: ${result.error.message}`);
+  }
+  return result.data;
+}
+
+// src/v2/supported-chains/queries.ts
+var supportedChainsQueries = (0, import_query_key_factory9.createQueryKeys)("supportedChains", {
+  all: {
+    queryKey: null,
+    queryFn: () => getSupportedChains()
+  }
+});
+
+// src/v2/supported-tokens/queries.ts
+var import_query_key_factory10 = require("@lukemorales/query-key-factory");
+
+// src/v2/supported-tokens/schema.ts
+var import_zod11 = require("zod");
+var supportedTokenSchema = tokenSchema.extend({
+  active: import_zod11.z.boolean()
+});
+var supportedTokensResponseSchema = import_zod11.z.object({
+  tokens: import_zod11.z.array(supportedTokenSchema),
+  total: import_zod11.z.number().optional(),
+  limit: import_zod11.z.number().optional(),
+  page: import_zod11.z.number().optional()
+});
+
+// src/v2/supported-tokens/api.ts
+async function getSupportedTokens(filters, options) {
+  const params = new URLSearchParams();
+  if (filters?.page !== void 0) params.append("page", filters.page.toString());
+  if (filters?.limit !== void 0) params.append("limit", filters.limit.toString());
+  if (filters?.search) params.append("search", filters.search);
+  const queryString = params.toString();
+  const endpoint = `/turtle/tokens${queryString ? `?${queryString}` : ""}`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "GET",
+    debug: options?.debug
+  });
+  const result = supportedTokensResponseSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse supported tokens: ${result.error.message}`);
+  }
+  return result.data;
+}
+
+// src/v2/supported-tokens/queries.ts
+var supportedTokensQueries = (0, import_query_key_factory10.createQueryKeys)("supportedTokens", {
+  list: (filters) => ({
+    queryKey: [filters],
+    queryFn: () => getSupportedTokens(filters)
+  })
+});
+
 // src/v2/earn-opportunities/hooks.ts
 var import_react_query = require("@tanstack/react-query");
 
@@ -1120,84 +1209,76 @@ function useOpportunity({ id, ...options }) {
 
 // src/v2/products/hooks.ts
 var import_react_query7 = require("@tanstack/react-query");
-
-// src/v2/lib/auth-provider.tsx
-var import_react2 = require("react");
-var import_jsx_runtime = require("react/jsx-runtime");
-var AuthContext = (0, import_react2.createContext)(null);
-function AuthProvider({ getToken, children }) {
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AuthContext.Provider, { value: { getToken }, children });
-}
-function useAuthToken() {
-  const context = (0, import_react2.useContext)(AuthContext);
-  if (!context) {
-    throw new Error("useAuthToken must be used within AuthProvider");
-  }
-  return context;
-}
-
-// src/v2/products/hooks.ts
 function useProducts({ filters, enabled = true }) {
-  const { getToken } = useAuthToken();
   return (0, import_react_query7.useQuery)({
-    ...productsQueries.list(filters, getToken()),
+    ...productsQueries.list(filters),
     ...queryDefaults,
     enabled
   });
 }
 function useProduct({ id, enabled = true }) {
-  const { getToken } = useAuthToken();
   return (0, import_react_query7.useQuery)({
-    ...productsQueries.byId(id, getToken()),
+    ...productsQueries.byId(id),
     ...queryDefaults,
     enabled
   });
 }
 function useCreateProduct(options) {
-  const { getToken } = useAuthToken();
   return (0, import_react_query7.useMutation)({
-    mutationFn: (input) => createProduct(input, getToken()),
+    mutationFn: (input) => createProduct(input),
     ...options
   });
 }
 function useUpdateProduct(options) {
-  const { getToken } = useAuthToken();
   return (0, import_react_query7.useMutation)({
-    mutationFn: (input) => updateProduct(input, getToken()),
+    mutationFn: (input) => updateProduct(input),
     ...options
   });
 }
 function useDeleteProduct(options) {
-  const { getToken } = useAuthToken();
   return (0, import_react_query7.useMutation)({
-    mutationFn: (id) => deleteProduct(id, getToken()),
+    mutationFn: (id) => deleteProduct(id),
     ...options
   });
 }
 function useUploadProductLogo(options) {
-  const { getToken } = useAuthToken();
   return (0, import_react_query7.useMutation)({
-    mutationFn: (request) => uploadProductLogo(request, getToken()),
+    mutationFn: (request) => uploadProductLogo(request),
     ...options
   });
 }
 
-// src/v2/balance/useTokenBalance.ts
-var import_react3 = require("react");
+// src/v2/balance/hooks/useTokenBalance.ts
+var import_react2 = require("react");
 var import_viem = require("viem");
 var import_utils2 = require("@turtleclub/utils");
-function useTokenBalance({ token, amount, setAmount }) {
-  const usdValue = (0, import_react3.useMemo)(() => (0, import_utils2.calculateUsdValue)(amount, token?.price), [amount, token?.price]);
-  const hasInsufficientBalance = (0, import_react3.useMemo)(
-    () => (0, import_utils2.checkInsufficientBalance)(token, amount),
-    [token, amount]
+function checkInsufficientBalance(tokenBalance, amount) {
+  if (!tokenBalance || !amount) return false;
+  try {
+    const balance = BigInt(tokenBalance.amount);
+    const amountBigInt = (0, import_viem.parseUnits)(amount, tokenBalance.token.decimals);
+    return balance < amountBigInt;
+  } catch (error) {
+    console.error("[Balance Check Error]", error, { tokenBalance, amount });
+    return true;
+  }
+}
+function useTokenBalance({ tokenBalance, amount, setAmount }) {
+  const token = tokenBalance?.token;
+  const usdValue = (0, import_react2.useMemo)(
+    () => (0, import_utils2.calculateUsdValue)(amount, token?.priceUsd),
+    [amount, token?.priceUsd]
+  );
+  const hasInsufficientBalance = (0, import_react2.useMemo)(
+    () => checkInsufficientBalance(tokenBalance, amount),
+    [tokenBalance, amount]
   );
-  const handleMaxClick = (0, import_react3.useCallback)(() => {
-    if (!token) return;
-    const maxAmount = (0, import_utils2.calculateMaxAmount)(token.balance, token.decimals);
+  const handleMaxClick = (0, import_react2.useCallback)(() => {
+    if (!tokenBalance?.token || !tokenBalance.amount) return;
+    const maxAmount = (0, import_utils2.calculateMaxAmount)(tokenBalance.amount, tokenBalance.token.decimals);
     setAmount(maxAmount);
-  }, [token, setAmount]);
-  const amountBigInt = (0, import_react3.useMemo)(() => {
+  }, [tokenBalance, setAmount]);
+  const amountBigInt = (0, import_react2.useMemo)(() => {
     if (!token || !amount) return void 0;
     try {
       return (0, import_viem.parseUnits)(amount, token.decimals);
@@ -1213,10 +1294,454 @@ function useTokenBalance({ token, amount, setAmount }) {
   };
 }
 
-// src/v2/widget/hooks.ts
+// src/v2/balance/types.ts
+var BalanceSourcePriority = /* @__PURE__ */ ((BalanceSourcePriority2) => {
+  BalanceSourcePriority2[BalanceSourcePriority2["ONCHAIN"] = 1] = "ONCHAIN";
+  BalanceSourcePriority2[BalanceSourcePriority2["PORTFOLIO"] = 2] = "PORTFOLIO";
+  BalanceSourcePriority2[BalanceSourcePriority2["ENSO"] = 3] = "ENSO";
+  return BalanceSourcePriority2;
+})(BalanceSourcePriority || {});
+
+// src/v2/balance/schema.ts
+var import_zod12 = require("zod");
+var portfolioTokenSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  address: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  symbol: import_zod12.z.string(),
+  decimals: import_zod12.z.number(),
+  isNative: import_zod12.z.boolean(),
+  logoUrl: import_zod12.z.string().nullable(),
+  amount: import_zod12.z.string(),
+  // Portfolio-specific field (decimal format)
+  price: import_zod12.z.string().nullable().transform((val) => val ? parseFloat(val) : null),
+  // Portfolio-specific field
+  // Chain with optional fields to match Portfolio API response
+  chain: chainSchema.partial().required({ chainId: true })
+});
+var portfolioWalletSchema = import_zod12.z.object({
+  id: import_zod12.z.string().optional(),
+  address: import_zod12.z.string(),
+  blockchain: import_zod12.z.string().optional(),
+  tokens: import_zod12.z.array(portfolioTokenSchema)
+});
+var portfolioHoldingsSchema = import_zod12.z.object({
+  wallets: import_zod12.z.array(portfolioWalletSchema)
+});
+var portfolioBalanceResponseSchema = import_zod12.z.object({
+  portfolio: import_zod12.z.object({
+    holdings: portfolioHoldingsSchema
+  })
+});
+
+// src/v2/balance/api.ts
+async function getPortfolioBalance(address, options) {
+  const data = await apiClient.fetch(`/wallet/${address}/balance`, {
+    method: "GET",
+    domain: "api",
+    debug: options?.debug
+  });
+  const result = portfolioBalanceResponseSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse portfolio balance: ${result.error.message}`);
+  }
+  return result.data;
+}
+
+// src/v2/balance/queries.ts
+var import_query_key_factory11 = require("@lukemorales/query-key-factory");
+var balanceQueries = (0, import_query_key_factory11.createQueryKeys)("balance", {
+  // Portfolio balance by address
+  portfolio: (address) => ({
+    queryKey: [address],
+    queryFn: () => getPortfolioBalance(address)
+  })
+});
+
+// src/v2/balance/hooks/useBalance.ts
+var import_react7 = require("react");
+
+// src/v2/balance/hooks/useGetOnChainBalance.ts
+var import_wagmi = require("wagmi");
+var import_viem2 = require("viem");
+var import_react3 = require("react");
+function useGetOnChainBalance({
+  tokens,
+  chainId,
+  address,
+  enabled = true
+}) {
+  const contracts = (0, import_react3.useMemo)(() => {
+    if (!address || !enabled) return [];
+    return tokens.map((token) => ({
+      address: token.address,
+      abi: import_viem2.erc20Abi,
+      functionName: "balanceOf",
+      args: [address],
+      chainId
+    }));
+  }, [tokens, address, chainId, enabled]);
+  const {
+    data: results,
+    isLoading,
+    error,
+    refetch
+  } = (0, import_wagmi.useReadContracts)({
+    contracts,
+    query: {
+      ...queryDefaults,
+      enabled: enabled && !!address && tokens.length > 0,
+      refetchInterval: 5e3,
+      refetchOnWindowFocus: true
+    }
+  });
+  const balances = (0, import_react3.useMemo)(() => {
+    if (!results || results.length === 0) return [];
+    return tokens.map((token, index) => {
+      const result = results[index];
+      let balance = "0";
+      if (result?.status === "success" && typeof result.result === "bigint") {
+        balance = result.result.toString();
+      }
+      return {
+        token,
+        amount: balance,
+        source: "onchain"
+      };
+    });
+  }, [results, tokens]);
+  return {
+    balances,
+    isLoading,
+    error: error ? error : null,
+    refetch
+  };
+}
+
+// src/v2/balance/hooks/usePortfolioBalance.ts
+var import_react_query10 = require("@tanstack/react-query");
+var import_react5 = require("react");
+
+// src/v2/supported-chains/hooks.ts
 var import_react_query8 = require("@tanstack/react-query");
+function useSupportedChains() {
+  const { data, isLoading, error, refetch } = (0, import_react_query8.useQuery)({
+    ...supportedChainsQueries.all,
+    ...queryDefaults
+  });
+  const chains = data?.chains ?? [];
+  return {
+    chains,
+    getChainByChainId: (chainId) => chains.find((chain) => chain.chainId === chainId),
+    isLoading,
+    error: error ? error : null,
+    refetch
+  };
+}
+
+// src/v2/supported-tokens/hooks.ts
+var import_react_query9 = require("@tanstack/react-query");
+var import_react4 = require("react");
+function useSupportedTokens({
+  page = 0,
+  limit = 20,
+  search,
+  enabled = true
+} = {}) {
+  const { data, isLoading, error, refetch } = (0, import_react_query9.useQuery)({
+    ...supportedTokensQueries.list({ page, limit, search }),
+    ...queryDefaults,
+    staleTime: 5 * 60 * 1e3,
+    // 1 minutes
+    gcTime: 10 * 60 * 1e3,
+    // 10 minutes
+    refetchOnWindowFocus: false,
+    // Don't refetch on tab focus
+    enabled
+  });
+  const tokens = (0, import_react4.useMemo)(() => {
+    if (!data?.tokens) return [];
+    return data.tokens.map(({ active, ...token }) => token);
+  }, [data?.tokens]);
+  return {
+    tokens,
+    total: data?.total ?? 0,
+    limit: data?.limit ?? limit,
+    page: data?.page ?? page,
+    isLoading,
+    error: error ? error : null,
+    refetch,
+    getTokenById: (id) => tokens.find((token) => token.id === id),
+    getToken: (address, chainId) => tokens.find(
+      (token) => token.address.toLowerCase() === address.toLowerCase() && token.chain.chainId === chainId
+    )
+  };
+}
+
+// src/v2/balance/hooks/usePortfolioBalance.ts
+var import_viem3 = require("viem");
+function usePortfolioBalance({
+  address
+}) {
+  const { getChainByChainId } = useSupportedChains();
+  const { getToken } = useSupportedTokens();
+  const {
+    data: portfolioData,
+    isLoading,
+    error,
+    refetch
+  } = (0, import_react_query10.useQuery)({
+    ...balanceQueries.portfolio(address || ""),
+    ...queryDefaults,
+    enabled: !!address,
+    refetchInterval: 1 * 60 * 1e3
+    // 1 minute
+  });
+  const balances = (0, import_react5.useMemo)(() => {
+    if (!portfolioData) return [];
+    const tokenBalances = [];
+    portfolioData.portfolio.holdings.wallets.forEach((wallet) => {
+      wallet.tokens.forEach((portfolioToken) => {
+        const chainId = portfolioToken.chain.chainId;
+        const supportedToken = getToken(portfolioToken.address, chainId);
+        const token = supportedToken ?? {
+          id: portfolioToken.id,
+          symbol: portfolioToken.symbol,
+          name: portfolioToken.name,
+          address: portfolioToken.address,
+          decimals: portfolioToken.decimals,
+          logoUrl: portfolioToken.logoUrl ?? void 0,
+          chain: getChainByChainId(chainId) ?? {
+            id: portfolioToken.chain.id,
+            chainId: portfolioToken.chain.chainId,
+            name: portfolioToken.chain.name ?? "",
+            slug: portfolioToken.chain.slug,
+            status: portfolioToken.chain.status,
+            logoUrl: portfolioToken.chain.logoUrl,
+            ecosystem: portfolioToken.chain.ecosystem,
+            explorerUrl: portfolioToken.chain.explorerUrl
+          },
+          isNative: portfolioToken.isNative,
+          priceUsd: portfolioToken.price ?? void 0
+        };
+        let amountInWei;
+        try {
+          amountInWei = (0, import_viem3.parseUnits)(portfolioToken.amount, token.decimals).toString();
+        } catch (error2) {
+          console.error("[Portfolio Balance] Failed to parse amount:", {
+            amount: portfolioToken.amount,
+            decimals: token.decimals,
+            error: error2
+          });
+          amountInWei = "0";
+        }
+        tokenBalances.push({
+          token,
+          amount: amountInWei,
+          source: "portfolio"
+        });
+      });
+    });
+    return tokenBalances;
+  }, [portfolioData, getChainByChainId, getToken]);
+  return {
+    balances,
+    isLoading,
+    error: error ? error : null,
+    refetch
+  };
+}
+
+// src/v2/balance/hooks/useEnsoBalances.ts
+var import_react6 = require("react");
+function useEnsoBalances({
+  address,
+  chainIds
+}) {
+  const { getToken, isLoading: isSupportedTokensLoading } = useSupportedTokens();
+  const {
+    balances: ensoBalances,
+    isLoading,
+    error,
+    refetchAll
+  } = useMultiChainBalances({
+    chainIds,
+    address
+  });
+  const balances = (0, import_react6.useMemo)(() => {
+    if (isSupportedTokensLoading || isLoading) return [];
+    const tokenBalances = [];
+    Object.entries(ensoBalances).forEach(([, chainBalances]) => {
+      chainBalances.forEach((walletBalance) => {
+        const chainId = walletBalance.token.chain.toString();
+        const token = getToken(walletBalance.token.address, chainId);
+        if (!token) return;
+        tokenBalances.push({
+          token,
+          amount: walletBalance.amount,
+          source: "enso"
+        });
+      });
+    });
+    return tokenBalances;
+  }, [ensoBalances, getToken, isSupportedTokensLoading, isLoading]);
+  return {
+    balances,
+    isLoading,
+    error,
+    refetch: refetchAll
+  };
+}
+
+// src/v2/balance/utils.ts
+var import_viem4 = require("viem");
+
+// src/v2/balance/constants.ts
+var EXCLUDE_TOKEN_ADDRESS_LIST = [
+  "0x7b5a0182e400b241b317e781a4e9dedfc1429822",
+  // kpdUSDC
+  "0x48c03b6ffd0008460f8657db1037c7e09deedfcb",
+  // kpdUSDT
+  "0x92c82f5f771f6a44cfa09357dd0575b81bf5f728",
+  // kpdWBTC
+  "0xcc6a16be713f6a714f68b0e1f4914fd3db15fbef",
+  // kpdWETH
+  "0xf470eb50b4a60c9b069f7fd6032532b8f5cc014d",
+  // kpdUSDC
+  "0xa5dab32dbe68e6fa784e1e50e4f620a0477d3896",
+  // kpdUSDT
+  "0xe1ac97e2616ad80f69f705ff007a4bbb3655544a",
+  // kpdWBTC
+  "0x77570cfecf83bc6bb08e2cd9e8537aea9f97ea2f"
+  // kpdWETH
+];
+
+// src/v2/balance/utils.ts
+function getSourcePriority(source) {
+  switch (source) {
+    case "onchain":
+      return 1 /* ONCHAIN */;
+    case "portfolio":
+      return 2 /* PORTFOLIO */;
+    case "enso":
+      return 3 /* ENSO */;
+  }
+}
+function mergeBalancesByPriority(sources, receiptToken) {
+  const balanceMap = /* @__PURE__ */ new Map();
+  sources.forEach((sourceBalances) => {
+    sourceBalances.forEach((balance) => {
+      const key = `${balance.token.chain}-${balance.token.address.toLowerCase()}`;
+      if (receiptToken) {
+        const receiptKey = `${receiptToken.chain}-${receiptToken.address.toLowerCase()}`;
+        if (key === receiptKey) {
+          return;
+        }
+      }
+      const existingBalance = balanceMap.get(key);
+      if (!existingBalance || getSourcePriority(balance.source) < getSourcePriority(existingBalance.source)) {
+        balanceMap.set(key, balance);
+      }
+    });
+  });
+  return Array.from(balanceMap.values()).sort((a, b) => {
+    if (a.token.chain.chainId !== b.token.chain.chainId) {
+      return Number(a.token.chain.chainId) - Number(b.token.chain.chainId);
+    }
+    const balanceA = Number((0, import_viem4.formatUnits)(BigInt(a.amount), a.token.decimals));
+    const balanceB = Number((0, import_viem4.formatUnits)(BigInt(b.amount), b.token.decimals));
+    return balanceB - balanceA;
+  });
+}
+function filterBalancesByChains(balances, chainIds) {
+  const chainSet = new Set(chainIds);
+  return balances.filter((balance) => chainSet.has(Number(balance.token.chain.chainId)));
+}
+function filterNonZeroBalances(balances) {
+  return balances.filter((balance) => {
+    const amount = BigInt(balance.amount);
+    return amount > 0n;
+  });
+}
+function filterExcludedTokens(balances) {
+  const excludedSet = new Set(EXCLUDE_TOKEN_ADDRESS_LIST.map((addr) => addr.toLowerCase()));
+  return balances.filter((balance) => {
+    const tokenAddress = balance.token.address.toLowerCase();
+    return !excludedSet.has(tokenAddress);
+  });
+}
+
+// src/v2/balance/hooks/useBalance.ts
+function useBalance({
+  address,
+  chainIds,
+  depositOpportunity
+}) {
+  const {
+    balances: onChainBalances,
+    isLoading: isOnChainLoading,
+    error: onChainError,
+    refetch: refetchOnChain
+  } = useGetOnChainBalance({
+    tokens: depositOpportunity?.depositTokens || [],
+    chainId: depositOpportunity?.depositTokens[0] ? Number(depositOpportunity.depositTokens[0].chain.chainId) : chainIds[0],
+    address,
+    enabled: !!depositOpportunity && !!address
+  });
+  const {
+    balances: portfolioBalances,
+    isLoading: isPortfolioLoading,
+    error: portfolioError,
+    refetch: refetchPortfolio
+  } = usePortfolioBalance({
+    address
+  });
+  const {
+    balances: ensoBalances,
+    isLoading: isEnsoLoading,
+    error: ensoError,
+    refetch: refetchEnso
+  } = useEnsoBalances({
+    address,
+    chainIds
+  });
+  const consolidatedBalances = (0, import_react7.useMemo)(() => {
+    const sources = [];
+    if (depositOpportunity && onChainBalances.length > 0) {
+      sources.push(onChainBalances);
+    }
+    if (portfolioBalances.length > 0) {
+      sources.push(portfolioBalances);
+    }
+    if (ensoBalances.length > 0) {
+      sources.push(ensoBalances);
+    }
+    const merged = mergeBalancesByPriority(sources, depositOpportunity?.receiptToken);
+    const nonZero = filterNonZeroBalances(merged);
+    return filterExcludedTokens(nonZero);
+  }, [onChainBalances, portfolioBalances, ensoBalances, depositOpportunity]);
+  const isLoading = isOnChainLoading || isPortfolioLoading || isEnsoLoading;
+  const error = onChainError || portfolioError || ensoError;
+  const refetchAll = () => {
+    if (depositOpportunity) {
+      refetchOnChain();
+    }
+    refetchPortfolio();
+    refetchEnso();
+  };
+  return {
+    balances: consolidatedBalances,
+    isLoading,
+    error,
+    refetchAll
+  };
+}
+
+// src/v2/widget/hooks.ts
+var import_react_query11 = require("@tanstack/react-query");
 function useWidgetOpportunities(distributorId) {
-  return (0, import_react_query8.useQuery)({
+  return (0, import_react_query11.useQuery)({
     ...widgetQueries.opportunities(distributorId),
     ...queryDefaults,
     select: (data) => {
@@ -1240,7 +1765,7 @@ function useWidgetOpportunities(distributorId) {
 }
 
 // src/v2/geocheck/useGeocheck.ts
-var import_react_query9 = require("@tanstack/react-query");
+var import_react_query12 = require("@tanstack/react-query");
 var INDEXER_ENDPOINT = "https://api.turtle.xyz";
 async function fetchGeocheck() {
   const url = `${INDEXER_ENDPOINT}/turtle/geocheck`;
@@ -1256,13 +1781,13 @@ async function fetchGeocheck() {
   }
   return data;
 }
-var geocheckQueryOptions = () => (0, import_react_query9.queryOptions)({
+var geocheckQueryOptions = () => (0, import_react_query12.queryOptions)({
   queryKey: ["geocheck"],
   queryFn: fetchGeocheck
 });
 function useGeocheck(options = {}) {
   const { enabled = true, staleTime, gcTime } = options;
-  return (0, import_react_query9.useQuery)({
+  return (0, import_react_query12.useQuery)({
     ...geocheckQueryOptions(),
     enabled,
     staleTime: staleTime ?? 5 * 60 * 1e3,
@@ -1274,8 +1799,126 @@ function useGeocheck(options = {}) {
   });
 }
 
+// src/v2/swap/useSwapRoute.ts
+var import_react8 = require("react");
+
+// src/v2/swap/route-processor.ts
+var import_utils4 = require("@turtleclub/utils");
+var parseEnsoStep = (kind, fromToken, toToken) => {
+  return {
+    in: {
+      icon: fromToken.logos[0],
+      symbol: fromToken.symbol
+    },
+    out: {
+      icon: toToken.logos[0],
+      symbol: toToken.symbol
+    },
+    amount: void 0,
+    type: kind
+  };
+};
+var parseApproveStep = (token, amount) => {
+  return {
+    in: {
+      icon: token.logos[0],
+      symbol: token.symbol
+    },
+    out: null,
+    amount: (0, import_utils4.formatToken)(amount, { decimals: token.decimals }, true, false, 4),
+    type: "approve"
+  };
+};
+function processRouteDetails(data) {
+  if (!data) return [];
+  const tokens = [];
+  data.steps.forEach((step) => {
+    if (step.kind === "approve" && step.token) {
+      const approveStep2 = parseApproveStep(step.token, step.amount);
+      tokens.push(approveStep2);
+    }
+    if (step.kind === "enso" && step.substeps) {
+      step.substeps.forEach((substep) => {
+        const fromToken = substep.from[0];
+        const toToken = substep.to[0];
+        const step2 = parseEnsoStep(substep.kind, fromToken, toToken);
+        tokens.push(step2);
+      });
+    }
+  });
+  return tokens;
+}
+
+// src/v2/swap/useSwapRoute.ts
+var NATIVE_TOKEN_ADDRESS = "0x0000000000000000000000000000000000000000";
+var ENSO_NATIVE_TOKEN_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+function toEnsoTokenAddress(address) {
+  if (address.toLowerCase() === NATIVE_TOKEN_ADDRESS.toLowerCase()) {
+    return ENSO_NATIVE_TOKEN_ADDRESS;
+  }
+  return address;
+}
+function useSwapRoute(isEnabled, userAddress, distributorId, options, referralCode) {
+  const params = (0, import_react8.useMemo)(() => {
+    if (!options || !isEnabled) return void 0;
+    return {
+      ...options,
+      user: userAddress,
+      distributor_id: distributorId,
+      referral_code: referralCode
+    };
+  }, [options, userAddress, distributorId, referralCode]);
+  const hasRequiredParams = (0, import_react8.useMemo)(() => {
+    return !!(userAddress && params?.token_in && params?.token_out && params?.amount && params?.chain && params?.slippage && params?.distributor_id);
+  }, [options]);
+  const { data, isLoading, error } = useEarnRoute({
+    params: {
+      user: params?.user ?? "",
+      chain: params?.chain ?? 1,
+      slippage: params?.slippage ?? 1,
+      distributor_id: params?.distributor_id ?? "",
+      referral_code: params?.referral_code ?? "",
+      id: params?.id ?? "",
+      amount: params?.amount ?? "",
+      token_in: toEnsoTokenAddress(params?.token_in ?? "") ?? "",
+      token_out: toEnsoTokenAddress(options?.token_out ?? "") ?? ""
+    },
+    enabled: hasRequiredParams && isEnabled
+  });
+  const routeDetails = (0, import_react8.useMemo)(() => processRouteDetails(data ?? null), [data]);
+  return {
+    fetchedRoute: data ?? null,
+    outputAmount: data?.amount_out ?? void 0,
+    isReady: hasRequiredParams && data && !isLoading,
+    hasRequiredParams,
+    routeDetails,
+    routeError: error,
+    isLoadingRoute: isLoading
+  };
+}
+
+// src/v2/lib/turtle-provider.tsx
+var import_react9 = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+function TurtleProvider({
+  children,
+  apiUrl,
+  earnUrl,
+  getToken,
+  debug
+}) {
+  const config = (0, import_react9.useMemo)(
+    () => ({ apiUrl, earnUrl, getToken, debug }),
+    [apiUrl, earnUrl, getToken, debug]
+  );
+  (0, import_react9.useEffect)(() => {
+    apiClient.configure(config);
+  }, [config]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children });
+}
+
 // src/v2/index.ts
-var queries = (0, import_query_key_factory9.mergeQueryKeys)(
+var queries = (0, import_query_key_factory12.mergeQueryKeys)(
   opportunitiesQueries,
   earnOpportunitiesQueries,
   earnRouteQueries,
@@ -1283,16 +1926,22 @@ var queries = (0, import_query_key_factory9.mergeQueryKeys)(
   earnDepositsQueries,
   productsQueries,
   ensoBalancesQueries,
-  widgetQueries
+  widgetQueries,
+  supportedChainsQueries,
+  supportedTokensQueries
 );
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AuthProvider,
+  ApiError,
+  BalanceSourcePriority,
+  TurtleProvider,
+  apiClient,
   approveStep,
   asset,
   assetData,
   assetERC20Data,
   assetImageData,
+  balanceQueries,
   balanceTokenSchema,
   chainSchema,
   checkMembership,
@@ -1315,20 +1964,33 @@ var queries = (0, import_query_key_factory9.mergeQueryKeys)(
   earnRouteResponseSchema,
   ensoBalancesQueries,
   ensoStep,
+  filterBalancesByChains,
+  filterExcludedTokens,
+  filterNonZeroBalances,
   geocheckQueryOptions,
   getDeposits,
   getEarnOpportunities,
   getEarnRoute,
   getOpportunities,
   getOpportunityById,
+  getPortfolioBalance,
   getProducts,
+  getSourcePriority,
+  getSupportedChains,
+  getSupportedTokens,
   getWalletBalances,
   getWidgetOpportunities,
   incentiveSchema,
   lendingConfigSchema,
+  mergeBalancesByPriority,
   opportunitiesQueries,
   opportunitySchema,
   organizationSchema,
+  portfolioBalanceResponseSchema,
+  portfolioHoldingsSchema,
+  portfolioTokenSchema,
+  portfolioWalletSchema,
+  processRouteDetails,
   productSchema,
   productsQueries,
   queries,
@@ -1336,9 +1998,14 @@ var queries = (0, import_query_key_factory9.mergeQueryKeys)(
   routerStep,
   routerSubstep,
   stepTx,
+  supportedChainsQueries,
+  supportedChainsResponseSchema,
+  supportedTokenSchema,
+  supportedTokensQueries,
+  supportedTokensResponseSchema,
   swapSubstep,
   tokenSchema,
-  useAuthToken,
+  useBalance,
   useCheckMembership,
   useCreateMembership,
   useCreateMembershipAgreement,
@@ -1347,12 +2014,18 @@ var queries = (0, import_query_key_factory9.mergeQueryKeys)(
   useDeposits,
   useEarnOpportunities,
   useEarnRoute,
+  useEnsoBalances,
   useGeocheck,
+  useGetOnChainBalance,
   useMultiChainBalances,
   useOpportunities,
   useOpportunity,
+  usePortfolioBalance,
   useProduct,
   useProducts,
+  useSupportedChains,
+  useSupportedTokens,
+  useSwapRoute,
   useTokenBalance,
   useUpdateProduct,
   useUploadProductLogo,