@mycelium-sdk/core 1.0.0-alpha.0 → 1.0.0-alpha.2

package/dist/index.js

@@ -348,9 +348,9 @@ var DefaultSmartWallet = class extends SmartWallet {
    * @param amount Human-readable amount string
    * @returns Transaction result for the deposit
    */
-  async earn(amount) {
+  async earn(vaultInfo, amount) {
     this.chainManager.getSupportedChain();
-    const depositTransactionResult = this.protocolProvider.deposit(amount, this);
+    const depositTransactionResult = this.protocolProvider.deposit(vaultInfo, amount, this);
     return depositTransactionResult;
   }
   /**
@@ -361,13 +361,9 @@ var DefaultSmartWallet = class extends SmartWallet {
    * @category Earn
    * @returns Vault balance or `null` if nothing deposited
    */
-  async getEarnBalance() {
-    const depositedVault = await this.protocolProvider.fetchDepositedVaults(this);
-    if (!depositedVault) {
-      return null;
-    }
+  async getEarnBalances() {
     const userAddress = await this.getAddress();
-    return this.protocolProvider.getBalance(depositedVault, userAddress);
+    return this.protocolProvider.getBalances(userAddress);
   }
   /**
    * Withdraws from the selected protocol’s vault
@@ -378,8 +374,8 @@ var DefaultSmartWallet = class extends SmartWallet {
    * @throws Error if the withdrawal fails
    * @throws Error a user didn't deposit anything
    */
-  async withdraw(amount) {
-    const withdrawTransactionResult = await this.protocolProvider.withdraw(amount, this);
+  async withdraw(vaultInfo, amount) {
+    const withdrawTransactionResult = await this.protocolProvider.withdraw(vaultInfo, amount, this);
     return withdrawTransactionResult;
   }
   /**
@@ -416,7 +412,7 @@ var DefaultSmartWallet = class extends SmartWallet {
       return hash;
     } catch (error) {
       throw new Error(
-        `Failed to send transaction: ${error instanceof Error ? error.message : "Unknown error"}`
+        `Failed to send transaction: ${error instanceof Error ? error.message.toString().slice(0, 100) : "Unknown error"}`
       );
     }
   }
@@ -639,127 +635,6 @@ var chainById = Object.values(viemChains).reduce(
   {}
 );
 
-// src/types/logger.ts
-var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
-  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
-  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
-  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
-  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
-  return LogLevel2;
-})(LogLevel || {});
-
-// src/tools/Logger.ts
-var Logger = class _Logger {
-  /**
-   * Create a new logger instance
-   * @param logLevel Initial log level, defaults to DEBUG
-   */
-  constructor(logLevel = 0 /* DEBUG */) {
-    this.logs = [];
-    this.maxLogs = 1e3;
-    this.logLevel = logLevel;
-  }
-  /**
-   * Get singleton instance of the logger
-   * @param logLevel Optional log level to initialize if instance not yet created
-   * @returns Logger instance
-   */
-  static getInstance(logLevel) {
-    if (!_Logger.instance) {
-      _Logger.instance = new _Logger(logLevel);
-    }
-    return _Logger.instance;
-  }
-  /** Set the log level */
-  setLogLevel(level) {
-    this.logLevel = level;
-  }
-  /** Get the current log level */
-  getLogLevel() {
-    return this.logLevel;
-  }
-  /** Internal check if a message should be logged */
-  shouldLog(level) {
-    return level >= this.logLevel;
-  }
-  /** Format log message into a readable string */
-  formatMessage(level, message, data, context) {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const levelName = LogLevel[level];
-    const contextStr = context ? `[${context}]` : "";
-    return `${timestamp} ${levelName}${contextStr}: ${message}`;
-  }
-  /** Add a log entry and output to console */
-  addLog(level, message, data, context) {
-    if (!this.shouldLog(level)) {
-      return;
-    }
-    const logEntry = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      level,
-      message,
-      data,
-      context
-    };
-    this.logs.push(logEntry);
-    if (this.logs.length > this.maxLogs) {
-      this.logs = this.logs.slice(-this.maxLogs);
-    }
-    const formattedMessage = this.formatMessage(level, message, data, context);
-    switch (level) {
-      case 0 /* DEBUG */:
-        console.debug(`\u{1F50D} ${formattedMessage}`, data || "");
-        break;
-      case 1 /* INFO */:
-        console.info(`\u2139\uFE0F ${formattedMessage}`, data || "");
-        break;
-      case 2 /* WARN */:
-        console.warn(`\u26A0\uFE0F ${formattedMessage}`, data || "");
-        break;
-      case 3 /* ERROR */:
-        console.error(`\u274C ${formattedMessage}`, data || "");
-        break;
-    }
-  }
-  /** Log a debug message */
-  debug(message, data, context) {
-    this.addLog(0 /* DEBUG */, message, data, context);
-  }
-  /** Log an info message */
-  info(message, data, context) {
-    this.addLog(1 /* INFO */, message, data, context);
-  }
-  /** Log a warning message */
-  warn(message, data, context) {
-    this.addLog(2 /* WARN */, message, data, context);
-  }
-  /** Log an error message */
-  error(message, data, context) {
-    this.addLog(3 /* ERROR */, message, data, context);
-  }
-  /** Get all logs */
-  getLogs() {
-    return [...this.logs];
-  }
-  /** Get logs by level */
-  getLogsByLevel(level) {
-    return this.logs.filter((log) => log.level === level);
-  }
-  /** Clear all logs */
-  clearLogs() {
-    this.logs = [];
-  }
-  /** Export logs as a JSON string */
-  exportLogs() {
-    return JSON.stringify(this.logs, null, 2);
-  }
-  /** Set maximum number of logs to retain in memory */
-  setMaxLogs(max) {
-    this.maxLogs = max;
-  }
-};
-var logger = Logger.getInstance();
-
 // src/tools/ChainManager.ts
 var ChainManager = class {
   /**
@@ -815,7 +690,6 @@ var ChainManager = class {
     if (!bundlerUrl) {
       throw new Error(`No bundler URL configured for chain ID: ${chainId}`);
     }
-    logger.info("Public client setup:", { bundlerUrl, chainId }, "ChainManager");
     const client = createPublicClient({
       chain: this.getChain(chainId),
       transport: http(rpcUrl)
@@ -1048,7 +922,7 @@ var DefaultSmartWalletProvider = class extends SmartWalletProvider {
   constructor(chainManager, protocol, coinbaseCDP) {
     super();
     this.chainManager = chainManager;
-    this.protocolProvider = protocol.instance;
+    this.protocolProvider = protocol;
     this.coinbaseCDP = coinbaseCDP;
   }
   /**
@@ -1311,8 +1185,7 @@ var WalletProvider = class {
         throw new Error(
           "Either walletAddress or deploymentOwners array must be provided to locate the smart wallet"
         );
-      } catch (error) {
-        logger.error("Error getting smart wallet", error, "WalletProvider");
+      } catch {
         throw new Error(
           "Either walletAddress or deploymentOwners array must be provided to locate the smart wallet"
         );
@@ -1358,6 +1231,127 @@ var EmbeddedWallet = class {
   }
 };
 
+// src/types/logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+
+// src/tools/Logger.ts
+var Logger = class _Logger {
+  /**
+   * Create a new logger instance
+   * @param logLevel Initial log level, defaults to DEBUG
+   */
+  constructor(logLevel = 0 /* DEBUG */) {
+    this.logs = [];
+    this.maxLogs = 1e3;
+    this.logLevel = logLevel;
+  }
+  /**
+   * Get singleton instance of the logger
+   * @param logLevel Optional log level to initialize if instance not yet created
+   * @returns Logger instance
+   */
+  static getInstance(logLevel) {
+    if (!_Logger.instance) {
+      _Logger.instance = new _Logger(logLevel);
+    }
+    return _Logger.instance;
+  }
+  /** Set the log level */
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  /** Get the current log level */
+  getLogLevel() {
+    return this.logLevel;
+  }
+  /** Internal check if a message should be logged */
+  shouldLog(level) {
+    return level >= this.logLevel;
+  }
+  /** Format log message into a readable string */
+  formatMessage(level, message, data, context) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const levelName = LogLevel[level];
+    const contextStr = context ? `[${context}]` : "";
+    return `${timestamp} ${levelName}${contextStr}: ${message}`;
+  }
+  /** Add a log entry and output to console */
+  addLog(level, message, data, context) {
+    if (!this.shouldLog(level)) {
+      return;
+    }
+    const logEntry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      message,
+      data,
+      context
+    };
+    this.logs.push(logEntry);
+    if (this.logs.length > this.maxLogs) {
+      this.logs = this.logs.slice(-this.maxLogs);
+    }
+    const formattedMessage = this.formatMessage(level, message, data, context);
+    switch (level) {
+      case 0 /* DEBUG */:
+        console.debug(`\u{1F50D} ${formattedMessage}`, data || "");
+        break;
+      case 1 /* INFO */:
+        console.info(`\u2139\uFE0F ${formattedMessage}`, data || "");
+        break;
+      case 2 /* WARN */:
+        console.warn(`\u26A0\uFE0F ${formattedMessage}`, data || "");
+        break;
+      case 3 /* ERROR */:
+        console.error(`\u274C ${formattedMessage}`, data || "");
+        break;
+    }
+  }
+  /** Log a debug message */
+  debug(message, data, context) {
+    this.addLog(0 /* DEBUG */, message, data, context);
+  }
+  /** Log an info message */
+  info(message, data, context) {
+    this.addLog(1 /* INFO */, message, data, context);
+  }
+  /** Log a warning message */
+  warn(message, data, context) {
+    this.addLog(2 /* WARN */, message, data, context);
+  }
+  /** Log an error message */
+  error(message, data, context) {
+    this.addLog(3 /* ERROR */, message, data, context);
+  }
+  /** Get all logs */
+  getLogs() {
+    return [...this.logs];
+  }
+  /** Get logs by level */
+  getLogsByLevel(level) {
+    return this.logs.filter((log) => log.level === level);
+  }
+  /** Clear all logs */
+  clearLogs() {
+    this.logs = [];
+  }
+  /** Export logs as a JSON string */
+  exportLogs() {
+    return JSON.stringify(this.logs, null, 2);
+  }
+  /** Set maximum number of logs to retain in memory */
+  setMaxLogs(max) {
+    this.maxLogs = max;
+  }
+};
+var logger = Logger.getInstance();
+
 // src/wallet/PrivyWallet.ts
 var PrivyWallet = class extends EmbeddedWallet {
   /**
@@ -1681,12 +1675,7 @@ var BaseProtocol = class {
 };
 
 // src/protocols/implementations/SparkProtocol.ts
-import {
-  encodeFunctionData as encodeFunctionData2,
-  erc20Abi as erc20Abi4,
-  formatUnits as formatUnits2,
-  parseUnits as parseUnits2
-} from "viem";
+import { encodeFunctionData as encodeFunctionData2, erc20Abi as erc20Abi4, formatUnits as formatUnits2, parseUnits as parseUnits2 } from "viem";
 
 // src/abis/protocols/spark.ts
 var SPARK_VAULT_ABI = [
@@ -1748,14 +1737,14 @@ var SPARK_SSR_ORACLE_ADDRESS = "0x65d946e533748A998B1f0E430803e39A6388f7a1";
 var SPARK_VAULT = [
   {
     id: "sUSDC",
+    protocolId: "spark",
+    name: "sUSDC",
+    type: "stable",
     chain: "base",
     vaultAddress: "0x3128a0f7f0ea68e7b7c9b00afa7e41045828e858",
-    depositTokenAddress: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
-    depositTokenDecimals: 6,
-    depositTokenSymbol: "USDC",
-    earnTokenAddress: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
-    earnTokenDecimals: 18,
-    earnTokenSymbol: "sUSDC",
+    tokenAddress: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+    tokenDecimals: 6,
+    tokenSymbol: "USDC",
     metadata: {}
   }
 ];
@@ -1766,6 +1755,7 @@ var RAY = BigInt("1000000000000000000000000000");
 var SparkProtocol = class extends BaseProtocol {
   constructor() {
     super(...arguments);
+    /** All Spark vaults */
     this.allVaults = [];
   }
   /**
@@ -1776,7 +1766,7 @@ var SparkProtocol = class extends BaseProtocol {
     this.chainManager = chainManager;
     this.selectedChainId = chainManager.getSupportedChain();
     this.publicClient = chainManager.getPublicClient(this.selectedChainId);
-    this.allVaults = this.getVaults();
+    this.allVaults = SPARK_VAULT;
   }
   /**
    * Get the SSR (Sky Saving Rate) of the Spark protocol
@@ -1806,88 +1796,54 @@ var SparkProtocol = class extends BaseProtocol {
   async getAPY() {
     const ssr = await this.getSSR();
     const apy = Math.exp(Math.log(ssr) * SECONDS_PER_YEAR) - 1;
-    return Number((apy * 100).toFixed(2));
-  }
-  /**
-   *
-   *  Get all vault info from a Spark protocol
-   * @returns The list of vaults
-   */
-  getVaults() {
-    return SPARK_VAULT;
+    return apy;
   }
   /**
-   * Get the best available Spark vault
-   * @returns The top-ranked Spark vault
+   * Get the best available Spark vaults
+   * @remarks Currently, the vault is only one and relates to sUSDC. Currently return only one stable vault
+   * @returns Best Spark vaults in 2 groups: stable and non-stable
    * @throws Error if no vaults found
    */
-  async getBestVault() {
+  async getBestVaults() {
     if (this.allVaults.length === 0) {
       throw new Error("No vaults found");
     }
     const selectedVault = this.allVaults[0];
     selectedVault.metadata.apy = await this.getAPY();
-    return selectedVault;
-  }
-  /**
-   * Fetch a vault where the user previously deposited funds
-   * @param smartWallet Smart wallet to inspect
-   * @returns The vault with user deposits, or null if none found
-   */
-  async fetchDepositedVaults(smartWallet) {
-    let depositedVault = void 0;
-    const userAddress = await smartWallet.getAddress();
-    for (const vault of this.allVaults) {
-      const balance = await this.getBalance(vault, userAddress);
-      if (parseInt(balance.depositedAmount) > 0) {
-        depositedVault = vault;
-      }
-    }
-    if (depositedVault) {
-      depositedVault.metadata.apy = await this.getAPY();
-    }
-    logger.info("Deposited vaults:", { depositedVault }, "SparkProtocol");
-    return depositedVault || null;
+    return {
+      stable: [selectedVault],
+      nonStable: []
+    };
   }
   /**
    * Deposit funds into a Spark vault
+   * @param vaultInfo Vault information
    * @param amount Amount to deposit (human-readable)
    * @param smartWallet Smart wallet instance to use
    * @returns Transaction result with hash
    */
-  async deposit(amount, smartWallet) {
-    const depositedVault = await this.fetchDepositedVaults(smartWallet);
-    let vaultInfoToDeposit;
-    logger.info("Previously deposited vault:", { depositedVault }, "SparkProtocol");
-    if (depositedVault) {
-      vaultInfoToDeposit = depositedVault;
-    } else {
-      vaultInfoToDeposit = await this.getBestVault();
-      logger.info("Best vault that found:", { bestVault: vaultInfoToDeposit }, "SparkProtocol");
-    }
+  async deposit(vaultInfo, amount, smartWallet) {
     const owner = await smartWallet.getAddress();
-    const assets = parseUnits2(amount, vaultInfoToDeposit.depositTokenDecimals);
-    logger.info("Raw deposit amount:", { amount, assets }, "SparkProtocol");
+    const assets = parseUnits2(amount, vaultInfo.tokenDecimals);
     const allowance = await this.checkAllowance(
-      vaultInfoToDeposit.depositTokenAddress,
-      vaultInfoToDeposit.vaultAddress,
+      vaultInfo.tokenAddress,
+      vaultInfo.vaultAddress,
       owner,
       this.selectedChainId
     );
-    logger.info("Current vault contract allowance:", { allowance }, "SparkProtocol");
     const ops = [];
     if (allowance < assets) {
       ops.push({
-        to: vaultInfoToDeposit.depositTokenAddress,
+        to: vaultInfo.tokenAddress,
         data: encodeFunctionData2({
           abi: erc20Abi4,
           functionName: "approve",
-          args: [vaultInfoToDeposit.vaultAddress, assets]
+          args: [vaultInfo.vaultAddress, assets]
         })
       });
     }
     ops.push({
-      to: vaultInfoToDeposit.vaultAddress,
+      to: vaultInfo.vaultAddress,
       data: encodeFunctionData2({
         abi: SPARK_VAULT_ABI,
         functionName: "deposit",
@@ -1899,23 +1855,19 @@ var SparkProtocol = class extends BaseProtocol {
   }
   /**
    * Withdraw funds from a Spark vault
-   * @param amountInUnderlying Amount in base token units (or undefined to withdraw all)
+   * @param vaultInfo Vault information
+   * @param amount Amount in base token units (or undefined to withdraw all)
    * @param smartWallet Smart wallet instance to withdraw from
    * @returns Transaction result with hash
    * @throws Error if no deposited vault found
    */
-  async withdraw(amountInUnderlying, smartWallet) {
-    const depositedVault = await this.fetchDepositedVaults(smartWallet);
-    if (!depositedVault) {
-      throw new Error("No vault found to withdraw from");
-    }
+  async withdraw(vaultInfo, amount, smartWallet) {
     const owner = await smartWallet.getAddress();
     let withdrawData;
-    if (amountInUnderlying) {
-      const assets = parseUnits2(amountInUnderlying, depositedVault.depositTokenDecimals);
-      logger.info("Withdraw amount:", { amountInUnderlying, assets }, "SparkProtocol");
+    if (amount) {
+      const assets = parseUnits2(amount, vaultInfo.tokenDecimals);
       withdrawData = {
-        to: depositedVault.vaultAddress,
+        to: vaultInfo.vaultAddress,
         data: encodeFunctionData2({
           abi: SPARK_VAULT_ABI,
           functionName: "withdraw",
@@ -1923,10 +1875,9 @@ var SparkProtocol = class extends BaseProtocol {
         })
       };
     } else {
-      const maxShares = await this.getMaxRedeemableShares(depositedVault, owner);
-      logger.info("Withdrawing all funds:", { maxShares }, "SparkProtocol");
+      const maxShares = await this.getMaxRedeemableShares(vaultInfo, owner);
       withdrawData = {
-        to: depositedVault.vaultAddress,
+        to: vaultInfo.vaultAddress,
         data: encodeFunctionData2({
           abi: SPARK_VAULT_ABI,
           functionName: "redeem",
@@ -1935,7 +1886,6 @@ var SparkProtocol = class extends BaseProtocol {
       };
     }
     const hash = await smartWallet.send(withdrawData, this.selectedChainId);
-    logger.info("Withdraw transaction sent:", { hash }, "SparkProtocol");
     return { success: true, hash };
   }
   /**
@@ -1958,14 +1908,15 @@ var SparkProtocol = class extends BaseProtocol {
   }
   /**
    * Get amount that a wallet has deposited in a vault
-   * @param vaultInfo Vault information
    * @param walletAddress Wallet address to check
-   * @returns Object containing shares and deposited amount
+   * @returns Array of vault balances with vaults info
    */
-  async getBalance(vaultInfo, walletAddress) {
+  async getBalances(walletAddress) {
     if (!this.publicClient) {
       throw new Error("Public client not initialized");
     }
+    const vaultInfo = SPARK_VAULT[0];
+    vaultInfo.metadata.apy = await this.getAPY();
     const shares = await this.publicClient.readContract({
       address: vaultInfo.vaultAddress,
       abi: SPARK_VAULT_ABI,
@@ -1973,7 +1924,7 @@ var SparkProtocol = class extends BaseProtocol {
       args: [walletAddress]
     });
     if (shares === 0n) {
-      return { shares: "0", depositedAmount: "0", vaultInfo };
+      return [{ balance: null, vaultInfo }];
     }
     const assets = await this.publicClient.readContract({
       address: vaultInfo.vaultAddress,
@@ -1981,11 +1932,12 @@ var SparkProtocol = class extends BaseProtocol {
       functionName: "convertToAssets",
       args: [shares]
     });
-    return {
-      shares: formatUnits2(shares, vaultInfo.earnTokenDecimals),
-      depositedAmount: formatUnits2(assets, vaultInfo.depositTokenDecimals),
-      vaultInfo
-    };
+    return [
+      {
+        balance: formatUnits2(assets, vaultInfo.tokenDecimals),
+        vaultInfo
+      }
+    ];
   }
 };
 
@@ -1997,59 +1949,233 @@ var availableProtocols = [
       name: "Spark",
       website: "https://spark.fi/",
       logo: "/logos/spark.png",
-      supportedChains: [1, 8453, 42161],
+      supportedChains: [8453],
       riskLevel: "low",
-      isPremium: false
+      isActive: true
     },
     instance: new SparkProtocol()
   }
 ];
 
-// src/tools/ApiKeysValidator.ts
-var ApiKeysValidator = class {
-  // TODO: Implement the validation logic
+// src/protocols/implementations/ProxyProtocol.ts
+import { encodeFunctionData as encodeFunctionData3, erc20Abi as erc20Abi5, parseUnits as parseUnits3 } from "viem";
+var ProxyProtocol = class extends BaseProtocol {
   /**
-   * Validates whether the provided API key is valid
-   *
-   * @internal
-   * @param apiKey API key from {@link ProtocolsRouterConfig}
-   * @returns True if the API key is considered valid
+   * Initialize the Spark protocol with the provided chain manager
+   * @param chainManager Chain manager instance used for network operations
    */
-  validate(apiKey) {
-    logger.info("Validating api key...", apiKey, "ApiKeysValidator");
-    return true;
-  }
-};
-
-// src/router/base/ProtocolRouterBase.ts
-var ProtocolRouterBase = class {
-  /**
-   * Initialize a base protocol router
-   * @param riskLevel Risk level required by the integrator
-   * @param chainManager Chain manager instance for network operations
-   * @param minApy Optional minimum APY filter
-   * @param apiKey Optional API key for premium protocol access
-   */
-  constructor(riskLevel, chainManager, minApy, apiKey) {
-    // TODO: Add an API key validation
-    /** API key validator instance */
-    this.apiKeyValidator = new ApiKeysValidator();
-    this.riskLevel = riskLevel;
-    this.minApy = minApy;
-    this.apiKey = apiKey;
+  async init(chainManager, protocolsSecurityConfig, apiClient) {
     this.chainManager = chainManager;
+    this.selectedChainId = chainManager.getSupportedChain();
+    this.publicClient = chainManager.getPublicClient(this.selectedChainId);
+    this.apiClient = apiClient;
+    this.protocolsSecurityConfig = protocolsSecurityConfig;
+  }
+  /**
+   * Log a vault-related operation after deposit or withdraw funds
+   * @param userAddress Address of the user who performed the operation
+   * @param hash Hash of the operation
+   * @param vaultInfo Information about the vault where the operation was performed
+   * @param chainId Chain ID where the operation was performed
+   * @param amount Amount of the operation
+   * @param operationType Type of the operation
+   * @param operationStatus Status of the operation
+   */
+  async logOperation(userAddress, hash, vaultInfo, chainId, amount, operationType, operationStatus) {
+    const apiResponse = await this.apiClient.sendRequest("log", void 0, void 0, {
+      userAddress,
+      protocolId: vaultInfo.protocolId,
+      vaultAddress: vaultInfo.vaultAddress,
+      transactionHash: hash,
+      chainId: chainId.toString(),
+      amount,
+      status: operationStatus,
+      operationType
+    });
+    if (!apiResponse.success) {
+      throw new Error(
+        apiResponse.error || `Failed to log operation: ${operationType} for vault: ${vaultInfo}`
+      );
+    }
+  }
+  /**
+   * Get the best vaults to deposit funds
+   * @param stableVaultsLimit Limit of stable vaults to get. Optional, default is 1
+   * @param nonStableVaultsLimit Limit of non-stable vaults to get. Optional, default is 1
+   * @returns Best vaults to deposit funds in 2 groups: stable and non-stable
+   */
+  async getBestVaults(stableVaultsLimit = 1, nonStableVaultsLimit = 1) {
+    const pathParams = {
+      risk_level: this.protocolsSecurityConfig.riskLevel,
+      chain_id: this.selectedChainId.toString(),
+      stable_vaults_limit: stableVaultsLimit.toString(),
+      non_stable_vaults_limit: nonStableVaultsLimit.toString()
+    };
+    const apiResponse = await this.apiClient.sendRequest("vaults", pathParams);
+    if (!apiResponse.success) {
+      throw new Error(apiResponse.error || "Failed to get best vaults");
+    }
+    const vaults = apiResponse.data;
+    return {
+      stable: vaults.stableVaults.map((vault) => {
+        return {
+          ...vault,
+          metadata: {
+            apy: vault.metadata?.apy,
+            poolTvlUsd: vault.metadata?.poolTvlUsd
+          }
+        };
+      }),
+      nonStable: vaults.nonStableVaults.map((vault) => {
+        return {
+          ...vault,
+          metadata: {
+            apy: vault.metadata?.apy,
+            poolTvlUsd: vault.metadata?.poolTvlUsd
+          }
+        };
+      })
+    };
+  }
+  /**
+   * Deposit funds to a provided vault
+   * @param vaultInfo Information about the vault to deposit funds to
+   * @param amount Amount of funds to deposit
+   * @param smartWallet Smart wallet to use for the deposit
+   * @returns Result of the deposit transaction
+   */
+  async deposit(vaultInfo, amount, smartWallet) {
+    const currentAddress = await smartWallet.getAddress();
+    const operationsCallData = [];
+    const depositTokenDecimals = vaultInfo.tokenDecimals;
+    const depositTokenAddress = vaultInfo.tokenAddress;
+    const vaultAddress = vaultInfo.vaultAddress;
+    const rawDepositAmount = parseUnits3(amount, depositTokenDecimals);
+    const allowance = await this.checkAllowance(
+      depositTokenAddress,
+      vaultAddress,
+      currentAddress,
+      this.selectedChainId
+    );
+    if (allowance < rawDepositAmount) {
+      const approveData = {
+        to: depositTokenAddress,
+        data: encodeFunctionData3({
+          abi: erc20Abi5,
+          functionName: "approve",
+          args: [vaultAddress, rawDepositAmount]
+        })
+      };
+      operationsCallData.push(approveData);
+    }
+    if (!vaultInfo.protocolId) {
+      throw new Error("Vault protocol ID is required");
+    }
+    const apiResponse = await this.apiClient.sendRequest(
+      "deposit",
+      void 0,
+      vaultInfo.protocolId,
+      {
+        vaultInfo,
+        amount: amount.toString(),
+        chainId: this.selectedChainId.toString()
+      }
+    );
+    if (!apiResponse.success) {
+      throw new Error(apiResponse.error || "Failed to receive deposit operations call data");
+    }
+    const receivedOperationsCallData = apiResponse.data;
+    operationsCallData.push(receivedOperationsCallData);
+    const hash = await smartWallet.sendBatch(operationsCallData, this.selectedChainId);
+    const operationStatus = hash ? "completed" : "failed";
+    this.logOperation(
+      currentAddress,
+      hash,
+      vaultInfo,
+      this.selectedChainId,
+      amount,
+      "deposit",
+      operationStatus
+    );
+    return { hash, success: true };
+  }
+  /**
+   * Withdraw funds from a provided vault
+   * @param vaultInfo Information about the vault to withdraw funds from
+   * @param amount Amount of funds to withdraw
+   * @param smartWallet Smart wallet to use for the withdrawal
+   * @returns Result of the withdrawal transaction
+   */
+  async withdraw(vaultInfo, amount, smartWallet) {
+    const currentAddress = await smartWallet.getAddress();
+    const earningBalances = await smartWallet.getEarnBalances();
+    if (!earningBalances) {
+      throw new Error("No earning balances found");
+    }
+    const earningBalance = earningBalances.find((balance) => balance.vaultInfo.id === vaultInfo.id);
+    if (!earningBalance) {
+      throw new Error("No earning balance found");
+    }
+    const balanceInfo = earningBalance.balance;
+    const amountToWithdraw = amount ? amount : balanceInfo.currentBalance;
+    const apiResponse = await this.apiClient.sendRequest(
+      "withdraw",
+      void 0,
+      vaultInfo.protocolId,
+      {
+        vaultInfo,
+        amount: amountToWithdraw,
+        chainId: this.selectedChainId.toString()
+      }
+    );
+    if (!apiResponse.success) {
+      throw new Error(apiResponse.error || "Failed to receive withdraw operations call data");
+    }
+    const withdrawOperationCallData = apiResponse.data;
+    const hash = await smartWallet.send(withdrawOperationCallData, this.selectedChainId);
+    const operationStatus = hash ? "completed" : "failed";
+    this.logOperation(
+      currentAddress,
+      hash,
+      vaultInfo,
+      this.selectedChainId,
+      amountToWithdraw,
+      "withdrawal",
+      operationStatus
+    );
+    return { hash, success: true };
+  }
+  /**
+   * Get the balances of a user by a provided address
+   * @param walletAddress Address of the user to get the balances of
+   * @param protocolId Protocol ID to get the balances for. Optional, default is undefined
+   * @returns Balances of the user in the protocol vaults
+   */
+  async getBalances(walletAddress, protocolId) {
+    const pathParams = {
+      chain_id: this.selectedChainId.toString(),
+      protocol_id: protocolId || "",
+      userAddress: walletAddress
+    };
+    const apiResponse = await this.apiClient.sendRequest("balances", pathParams);
+    if (!apiResponse.success) {
+      throw new Error(apiResponse.error || "Failed to get balances");
+    }
+    const balances = apiResponse.data;
+    return balances;
   }
 };
 
 // src/router/ProtocolRouter.ts
-var ProtocolRouter = class extends ProtocolRouterBase {
+var ProtocolRouter = class {
   /**
    * Initialize the protocol router
    * @param config Router configuration including risk level, min APY, and optional API key
    * @param chainManager Chain manager instance for network validation
    */
-  constructor(config, chainManager) {
-    super(config.riskLevel, chainManager, config.minApy, config.apiKey);
+  constructor(chainManager, isApiKeyValid) {
+    this.chainManager = chainManager;
+    this.isApiKeyValid = isApiKeyValid;
   }
   /**
    * Get all protocols available for the current configuration
@@ -2057,13 +2183,9 @@ var ProtocolRouter = class extends ProtocolRouterBase {
    * Includes all non-premium protocols and premium protocols if the API key is valid
    * @returns Array of available protocol definitions
    */
-  getProtocols() {
-    const isKeyValid = this.apiKeyValidator.validate(this.apiKey);
+  getActivePublicProtocols() {
     const allAvailableProtocols = availableProtocols.filter((protocol) => {
-      if (!protocol.info.isPremium) {
-        return true;
-      }
-      return protocol.info.isPremium && isKeyValid;
+      return protocol.info.isActive;
     });
     return allAvailableProtocols;
   }
@@ -2088,18 +2210,20 @@ var ProtocolRouter = class extends ProtocolRouterBase {
    * @throws Error if no protocols are available for the current risk level
    * @returns Protocol instance considered the best match
    */
-  recommend() {
-    const protocols = this.getProtocols();
+  select() {
+    if (this.isApiKeyValid) {
+      return new ProxyProtocol();
+    }
+    const protocols = this.getActivePublicProtocols();
     const eligibleProtocols = protocols.filter((protocol) => {
-      const riskMatches = protocol.info.riskLevel === this.riskLevel;
       const isSupportedChain = this.isProtocolSupportedChain(protocol.info.supportedChains);
-      return riskMatches && isSupportedChain;
+      return isSupportedChain;
     });
     if (eligibleProtocols.length === 0) {
-      throw new Error(`No protocols available for risk level: ${this.riskLevel}`);
+      throw new Error(`No protocols available`);
     }
     const bestProtocol = eligibleProtocols[0];
-    return bestProtocol;
+    return bestProtocol.instance;
   }
 };
 
@@ -2319,8 +2443,161 @@ var CoinbaseCDP = class {
   }
 };
 
+// src/protocols/ProtocolsNamespace.ts
+var ProtocolsNamespace = class {
+  constructor(protocol) {
+    this.protocol = protocol;
+  }
+  /**
+   * Find the best vaults for protocols that were selected based on integrator's settings
+   *
+   * @returns Best vaults for protocols that were selected based on integrator's settings
+   */
+  async getBestVaults(stableVaultsLimit = 1, nonStableVaultsLimit = 1) {
+    return await this.protocol.getBestVaults(stableVaultsLimit, nonStableVaultsLimit);
+  }
+};
+
+// src/constants/general.ts
+var BACKEND_HOSTNAME = process.env.NODE_ENV === "dev" ? "http://localhost:3000" : "https://mycelium-cloud-production.up.railway.app";
+
+// src/tools/ApiClient.ts
+import axios2 from "axios";
+var ApiClient = class {
+  constructor(apiKey) {
+    this.client = axios2.create({
+      baseURL: BACKEND_HOSTNAME
+    });
+    /** URL settings for the endpoint: get the best vaults to deposit funds */
+    this.bestVaultUrlSettings = {
+      method: "GET",
+      path: "api/v1/public/protocols/best"
+    };
+    /** URL settings for the endpoint: deposit funds to a provided vault */
+    this.depositUrlSettings = {
+      method: "POST",
+      path: "api/v1/public/protocols/details/:protocolId/deposit"
+    };
+    /** URL settings for the endpoint: log a vault-related operation after deposit or withdraw funds */
+    this.logOperationSettings = {
+      method: "POST",
+      path: "api/v1/public/log/operation"
+    };
+    /** URL settings for the endpoint: withdraw funds from a provided vault */
+    this.withdrawUrlSettings = {
+      method: "POST",
+      path: "api/v1/public/protocols/details/:protocolId/withdraw"
+    };
+    /** URL settings for the endpoint: get the balances of a user by a provided address */
+    this.balancesUrlSettings = {
+      method: "GET",
+      path: "api/v1/public/user/:userAddress/balances"
+    };
+    /** URL settings for the endpoint: validate the API key */
+    this.apiKeyValidUrlSettings = {
+      method: "GET",
+      path: "api/v1/public/valid"
+    };
+    /** URL settings for the endpoint: get the config for services */
+    this.configUrlSettings = {
+      method: "GET",
+      path: "api/v1/public/config"
+    };
+    /** URL settings mapping with operation types */
+    this.operationTypeToUrlSettings = {
+      deposit: this.depositUrlSettings,
+      withdraw: this.withdrawUrlSettings,
+      log: this.logOperationSettings,
+      vaults: this.bestVaultUrlSettings,
+      balances: this.balancesUrlSettings,
+      apiKeyValidation: this.apiKeyValidUrlSettings,
+      config: this.configUrlSettings
+    };
+    this.apiKey = apiKey;
+    if (!this.validateApiKeyFormat()) {
+      throw new Error("Invalid API key format");
+    }
+  }
+  /**
+   * Send a request to the backend API
+   * @param path Path of the endpoint to send the request to
+   * @param method Method of the request
+   * @param body Body of the request
+   * @returns Response from the backend API
+   */
+  async sendRequest(operationType, params, protocolId, body) {
+    const { path, method } = this.operationTypeToUrlSettings[operationType];
+    let requestPath = path;
+    if (protocolId) {
+      requestPath = requestPath.replace(":protocolId", protocolId);
+    }
+    if (params?.userAddress) {
+      requestPath = requestPath.replace(":userAddress", params.userAddress);
+      delete params.userAddress;
+    }
+    const urlParams = new URLSearchParams(params).toString();
+    if (urlParams) {
+      requestPath += `?${urlParams}`;
+    }
+    const response = await this.client.request({
+      method,
+      url: requestPath,
+      data: body,
+      headers: { Authorization: `Bearer ${this.apiKey}`, "Content-Type": "application/json" }
+    });
+    if (response.status !== 200) {
+      throw new Error(`Failed to send request to ${path}`);
+    }
+    const apiResponse = response.data;
+    return apiResponse;
+  }
+  /**
+   * Validates whether the provided API key is valid
+   *
+   * @internal
+   * @param apiKey API key from {@link ProtocolsRouterConfig}
+   * @returns True if the API key is considered valid
+   */
+  async validate() {
+    if (!this.validateApiKeyFormat()) {
+      throw new Error("Invalid API key format");
+    }
+    const apiResponse = await this.sendRequest("apiKeyValidation");
+    if (!apiResponse.success) {
+      throw new Error(apiResponse.error || "Failed to validate API key");
+    }
+    return true;
+  }
+  /**
+   *
+   * Validates the format of the API key. Must start with 'sk_' and contain only hexadecimal characters
+   *
+   * @internal
+   * @param apiKey API key from {@link ProtocolsRouterConfig}
+   * @returns
+   */
+  validateApiKeyFormat() {
+    if (!this.apiKey) {
+      return false;
+    }
+    const prefix = "sk_";
+    if (!this.apiKey.startsWith(prefix)) {
+      return false;
+    }
+    const keyPart = this.apiKey.slice(prefix.length);
+    if (keyPart.length < 32 || keyPart.length > 128) {
+      return false;
+    }
+    const hexPattern = /^[0-9a-fA-F]+$/;
+    if (!hexPattern.test(keyPart)) {
+      return false;
+    }
+    return true;
+  }
+};
+
 // src/index.ts
-var MyceliumSDK = class {
+var MyceliumSDK = class _MyceliumSDK {
   /**
    * Creates a new SDK instance
    *
@@ -2328,7 +2605,7 @@ var MyceliumSDK = class {
    * @throws Throws if an unsupported wallet provider is given
    * @see MyceliumSDKConfig
    */
-  constructor(config) {
+  constructor(config, isPremiumAvailable, apiClient) {
     /**
      * Ramp namespace to manage ramp operations. Methods are available on {@link RampNamespace}
      * @internal
@@ -2353,11 +2630,14 @@ var MyceliumSDK = class {
         bundlerUrl: "https://public.pimlico.io/v2/8453/rpc"
       }
     );
-    if (!config.chain) {
-      logger.warn(
-        "No chain config provided, using default public RPC and Bundler URLs",
-        "MyceliumSDK"
+    if (config.protocolsSecurityConfig) {
+      this.protocol = this.selectProtocol(
+        config.protocolsSecurityConfig,
+        isPremiumAvailable,
+        apiClient
       );
+    } else {
+      throw new Error("Protocols router config is required");
     }
     if (config.coinbaseCDPConfig) {
       this.coinbaseCDP = new CoinbaseCDP(
@@ -2368,11 +2648,63 @@ var MyceliumSDK = class {
       );
       this.fundingNamespace = new FundingNamespace(this.coinbaseCDP);
     }
-    const protocolsRouterConfig = config.protocolsRouterConfig || {
-      riskLevel: "low"
-    };
-    this.protocol = this.findProtocol(protocolsRouterConfig);
     this.wallet = this.createWalletNamespace(config.walletsConfig);
+    this.protocols = new ProtocolsNamespace(this.protocol);
+  }
+  /**
+   * Initializes the SDK
+   * @param config SDK configuration (networks, wallets, protocol router settings)
+   * @returns SDK instance
+   */
+  static async init(config) {
+    let finalConfig;
+    let isPremiumAvailable = false;
+    if ("apiKey" in config && config.apiKey) {
+      const apiClient = new ApiClient(config.apiKey);
+      isPremiumAvailable = await apiClient.validate();
+      if (isPremiumAvailable) {
+        const apiResponse = await apiClient.sendRequest("config");
+        if (!apiResponse.success) {
+          throw new Error(apiResponse.error || "Failed to get onchain config");
+        }
+        const backendConfig = apiResponse.data;
+        finalConfig = {
+          integratorId: backendConfig.integratorId,
+          walletsConfig: {
+            embeddedWalletConfig: {
+              provider: {
+                type: "privy",
+                providerConfig: {
+                  appId: backendConfig.privyAppId,
+                  appSecret: backendConfig.privyAppSecret
+                }
+              }
+            },
+            smartWalletConfig: {
+              provider: {
+                type: "default"
+              }
+            }
+          },
+          chain: {
+            chainId: config.chainId || backendConfig.chainId,
+            rpcUrl: backendConfig.rpcUrl,
+            bundlerUrl: backendConfig.bundlerUrl
+          },
+          protocolsSecurityConfig: config.protocolsSecurityConfig,
+          coinbaseCDPConfig: {
+            apiKeyId: backendConfig.coinbaseCdpApiKey,
+            apiKeySecret: backendConfig.coinbaseCdpApiKeySecret
+          }
+        };
+        const sdk2 = new _MyceliumSDK(finalConfig, isPremiumAvailable, apiClient);
+        sdk2.apiClient = apiClient;
+        return sdk2;
+      }
+    }
+    finalConfig = config;
+    const sdk = new _MyceliumSDK(finalConfig, isPremiumAvailable);
+    return sdk;
   }
   /**
    * Returns the chain manager instance for multi-chain operations
@@ -2410,10 +2742,13 @@ var MyceliumSDK = class {
    * @param config Protocol router configuration (e.g. risk level)
    * @returns Selected protocol object of the type {@link Protocol}
    */
-  findProtocol(config) {
-    const protocolRouter = new ProtocolRouter(config, this.chainManager);
-    const protocol = protocolRouter.recommend();
-    protocol.instance.init(this.chainManager);
+  selectProtocol(config, isPremiumAvailable, apiClient) {
+    const protocolRouter = new ProtocolRouter(this.chainManager, isPremiumAvailable);
+    const protocol = protocolRouter.select();
+    if (!config) {
+      throw new Error("Protocols security config is required");
+    }
+    protocol.init(this.chainManager, config, apiClient);
     return protocol;
   }
   /**