@mycelium-sdk/core 0.1.0

package/dist/index.js

@@ -0,0 +1,2481 @@
+// src/wallet/DefaultSmartWallet.ts
+import {
+  encodeFunctionData,
+  erc20Abi as erc20Abi2,
+  pad
+} from "viem";
+import { toCoinbaseSmartAccount } from "viem/account-abstraction";
+
+// src/abis/smartWalletFactory.ts
+var smartWalletFactoryAbi = [
+  {
+    type: "constructor",
+    inputs: [
+      { name: "implementation_", type: "address", internalType: "address" }
+    ],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "createAccount",
+    inputs: [
+      { name: "owners", type: "bytes[]", internalType: "bytes[]" },
+      { name: "nonce", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "contract CoinbaseSmartWallet"
+      }
+    ],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "getAddress",
+    inputs: [
+      { name: "owners", type: "bytes[]", internalType: "bytes[]" },
+      { name: "nonce", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "implementation",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "initCodeHash",
+    inputs: [],
+    outputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "AccountCreated",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "owners",
+        type: "bytes[]",
+        indexed: false,
+        internalType: "bytes[]"
+      },
+      {
+        name: "nonce",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  { type: "error", name: "ImplementationUndeployed", inputs: [] },
+  { type: "error", name: "OwnerRequired", inputs: [] }
+];
+
+// src/constants/addresses.ts
+var smartWalletFactoryAddress = "0xBA5ED110eFDBa3D005bfC882d75358ACBbB85842";
+
+// src/tools/TokenBalance.ts
+import { erc20Abi, formatEther, formatUnits } from "viem";
+
+// src/constants/tokens.ts
+import { mainnet, unichain, base, baseSepolia, sepolia } from "viem/chains";
+var SUPPORTED_TOKENS = {
+  ETH: {
+    symbol: "ETH",
+    name: "Ethereum",
+    decimals: 18,
+    addresses: {
+      [mainnet.id]: "0x0000000000000000000000000000000000000000",
+      [unichain.id]: "0x0000000000000000000000000000000000000000",
+      [base.id]: "0x0000000000000000000000000000000000000000",
+      [baseSepolia.id]: "0x0000000000000000000000000000000000000000",
+      [sepolia.id]: "0x0000000000000000000000000000000000000000"
+    }
+  },
+  USDC: {
+    symbol: "USDC",
+    name: "USDC",
+    decimals: 6,
+    addresses: {
+      [mainnet.id]: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+      [unichain.id]: "0x078d782b760474a361dda0af3839290b0ef57ad6",
+      [baseSepolia.id]: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+      [sepolia.id]: "0xf08A50178dfcDe18524640EA6618a1f965821715",
+      [base.id]: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+    }
+  }
+};
+
+// src/utils/tokens.ts
+function getTokenAddress(symbol, chainId) {
+  const token = SUPPORTED_TOKENS[symbol];
+  return token?.addresses[chainId] || null;
+}
+
+// src/tools/TokenBalance.ts
+async function fetchETHBalance(chainManager, walletAddress) {
+  const supportedChain = chainManager.getSupportedChain();
+  const publicClient = chainManager.getPublicClient(supportedChain);
+  const balance = await publicClient.getBalance({
+    address: walletAddress
+  });
+  return {
+    symbol: "ETH",
+    totalBalance: balance,
+    totalFormattedBalance: formatEther(balance),
+    chainBalances: [
+      {
+        chainId: supportedChain,
+        balance,
+        formattedBalance: formatEther(balance)
+      }
+    ]
+  };
+}
+async function fetchERC20Balance(chainManager, walletAddress, token) {
+  const supportedChain = chainManager.getSupportedChain();
+  const balance = await fetchERC20BalanceForChain(
+    token,
+    supportedChain,
+    walletAddress,
+    chainManager
+  );
+  return {
+    symbol: token.symbol,
+    totalBalance: balance,
+    totalFormattedBalance: formatUnits(balance, token.decimals),
+    chainBalances: [
+      {
+        chainId: supportedChain,
+        balance,
+        formattedBalance: formatUnits(balance, token.decimals)
+      }
+    ]
+  };
+}
+async function fetchERC20BalanceForChain(token, chainId, walletAddress, chainManager) {
+  const tokenAddress = getTokenAddress(token.symbol, chainId);
+  if (!tokenAddress) {
+    throw new Error(`${token.symbol} not supported on chain ${chainId}`);
+  }
+  const publicClient = chainManager.getPublicClient(chainId);
+  if (token.symbol === "ETH") {
+    return publicClient.getBalance({
+      address: walletAddress
+    });
+  }
+  return publicClient.readContract({
+    address: tokenAddress,
+    abi: erc20Abi,
+    functionName: "balanceOf",
+    args: [walletAddress]
+  });
+}
+
+// src/utils/assets.ts
+import { parseUnits } from "viem";
+function resolveAsset(asset, chainId) {
+  if (asset.startsWith("0x")) {
+    const address2 = asset;
+    for (const [, tokenInfo2] of Object.entries(SUPPORTED_TOKENS)) {
+      const tokenAddress = tokenInfo2.addresses[chainId];
+      if (tokenAddress && tokenAddress.toLowerCase() === address2.toLowerCase()) {
+        return {
+          address: tokenAddress,
+          symbol: tokenInfo2.symbol,
+          decimals: tokenInfo2.decimals
+        };
+      }
+    }
+    throw new Error(
+      `Unknown asset address: ${address2}. Please use a supported asset symbol like 'usdc' or add the token to SUPPORTED_TOKENS.`
+    );
+  }
+  const normalizedSymbol = asset.toUpperCase();
+  const tokenInfo = SUPPORTED_TOKENS[normalizedSymbol];
+  if (!tokenInfo) {
+    const availableSymbols = Object.keys(SUPPORTED_TOKENS).join(", ");
+    throw new Error(`Unsupported asset symbol: ${asset}. Supported assets: ${availableSymbols}`);
+  }
+  const address = getTokenAddress(normalizedSymbol, chainId);
+  if (!address) {
+    throw new Error(
+      `Asset ${asset} is not supported on chain ${chainId}. Available chains: ${Object.keys(tokenInfo.addresses).join(", ")}`
+    );
+  }
+  return {
+    address,
+    symbol: tokenInfo.symbol,
+    decimals: tokenInfo.decimals
+  };
+}
+function parseAssetAmount(amount, decimals) {
+  const amountStr = amount.toString();
+  return parseUnits(amountStr, decimals);
+}
+
+// src/wallet/base/wallets/SmartWallet.ts
+var SmartWallet = class {
+};
+
+// src/wallet/DefaultSmartWallet.ts
+var DefaultSmartWallet = class extends SmartWallet {
+  /**
+   * Creates a smart wallet instance
+   *
+   * @internal
+   * @param owners Owners (addresses or WebAuthn accounts)
+   * @param signer Local account used to sign
+   * @param chainManager Chain/client manager
+   * @param protocolProvider Protocol provider instance (selected upstream)
+   * @param deploymentAddress Optional known deployment address
+   * @param signerOwnerIndex Optional index of `signer` in owners (default 0)
+   * @param nonce Optional salt for deterministic address calc (default 0)
+   */
+  constructor(owners, signer, chainManager, protocolProvider, coinbaseCDP, deploymentAddress, signerOwnerIndex, nonce) {
+    super();
+    this.owners = owners;
+    this._signer = signer;
+    this.signerOwnerIndex = signerOwnerIndex;
+    this.deploymentAddress = deploymentAddress;
+    this.chainManager = chainManager;
+    this.nonce = nonce;
+    this.protocolProvider = protocolProvider;
+    this.coinbaseCDP = coinbaseCDP;
+  }
+  /**
+   * Returns the signer account for this smart wallet
+   *
+   * @public
+   * @category Account
+   * @remarks
+   * Used to authorize UserOperations and on-chain transactions
+   */
+  get signer() {
+    return this._signer;
+  }
+  /**
+   * Resolves the smart wallet address
+   *
+   * @public
+   * @category Account
+   * @remarks
+   * If `deploymentAddress` is known, returns it. Otherwise derives a deterministic address
+   * via the factory (`getAddress`) using owners and `nonce` (CREATE2-style)
+   *
+   * @returns Promise that resolves to the wallet address
+   * @throws Error if no supported chains are configured
+   * @throws Error if an owner has an invalid type
+   */
+  async getAddress() {
+    if (this.deploymentAddress) {
+      return this.deploymentAddress;
+    }
+    const owners_bytes = this.owners.map((owner) => {
+      if (typeof owner === "string") {
+        return pad(owner);
+      }
+      if (owner.type === "webAuthn") {
+        return owner.publicKey;
+      }
+      throw new Error("invalid owner type");
+    });
+    const supportedChain = this.chainManager.getSupportedChain();
+    if (!supportedChain) {
+      throw new Error("No supported chains configured");
+    }
+    const publicClient = this.chainManager.getPublicClient(supportedChain);
+    const smartWalletAddress = await publicClient.readContract({
+      abi: smartWalletFactoryAbi,
+      address: smartWalletFactoryAddress,
+      functionName: "getAddress",
+      args: [owners_bytes, this.nonce || 0n]
+    });
+    return smartWalletAddress;
+  }
+  /**
+   * Builds a Coinbase Smart Account for a specific chain
+   *
+   * @internal
+   * @category Account
+   * @param chainId Target chain ID
+   * @returns Viem Coinbase Smart Account for the given chain
+   */
+  async getCoinbaseSmartAccount(chainId) {
+    return toCoinbaseSmartAccount({
+      address: this.deploymentAddress,
+      ownerIndex: this.signerOwnerIndex,
+      client: this.chainManager.getPublicClient(chainId),
+      owners: [this.signer],
+      nonce: this.nonce,
+      version: "1.1"
+    });
+  }
+  /**
+   * Fetches balances (ETH + ERC-20) for a smart account across supported chains
+   *
+   * @public
+   * @category Account
+   * @returns Promise resolving to a list of {@link TokenBalance}
+   */
+  async getBalance() {
+    const address = await this.getAddress();
+    const tokenBalancePromises = Object.values(SUPPORTED_TOKENS).map(async (token) => {
+      return fetchERC20Balance(this.chainManager, address, token);
+    });
+    const ethBalancePromise = fetchETHBalance(this.chainManager, address);
+    return Promise.all([ethBalancePromise, ...tokenBalancePromises]);
+  }
+  /**
+   * Deposits into the selected protocol’s vault to start earning yield
+   * @public
+   * @category Earn
+   * @remarks
+   * The protocol is selected on the SDK initialization step
+   * @param amount Human-readable amount string
+   * @returns Transaction result for the deposit
+   */
+  async earn(amount) {
+    this.chainManager.getSupportedChain();
+    const depositTransactionResult = this.protocolProvider.deposit(amount, this);
+    return depositTransactionResult;
+  }
+  /**
+   * Reads current deposit balance from the selected protocol’s vault
+   * Method to read the current deposit balance from the selected protocol’s vault for a smart account
+   *
+   * @public
+   * @category Earn
+   * @returns Vault balance or `null` if nothing deposited
+   */
+  async getEarnBalance() {
+    const depositedVault = await this.protocolProvider.fetchDepositedVaults(this);
+    if (!depositedVault) {
+      return null;
+    }
+    const userAddress = await this.getAddress();
+    return this.protocolProvider.getBalance(depositedVault, userAddress);
+  }
+  /**
+   * Withdraws from the selected protocol’s vault
+   * @public
+   * @category Earn
+   * @param amount Human-readable amount string
+   * @returns Transaction result for the withdrawal
+   * @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);
+    return withdrawTransactionResult;
+  }
+  /**
+     * Builds a UserOperation and submits via the bundler, then waits for inclusion
+  
+     *
+     * @public
+     * @category Transactions
+     *
+     * @param transactionData Transaction details (`to`, `value`, `data`)
+     * @param chainId Target chain ID
+     * @returns Promise that resolves to the UserOperation hash
+     * @throws Error with a readable message if submission or inclusion fails
+     */
+  async send(transactionData, chainId) {
+    try {
+      const account = await this.getCoinbaseSmartAccount(chainId);
+      const bundlerClient = this.chainManager.getBundlerClient(chainId, account);
+      const bump = (x, pct = 40n) => x + x * pct / 100n;
+      const gas = await bundlerClient.estimateUserOperationGas({
+        account,
+        calls: [transactionData]
+      });
+      const hash = await bundlerClient.sendUserOperation({
+        account,
+        calls: [transactionData],
+        callGasLimit: bump(gas.callGasLimit),
+        verificationGasLimit: bump(gas.verificationGasLimit),
+        preVerificationGas: bump(gas.preVerificationGas)
+      });
+      await bundlerClient.waitForUserOperationReceipt({
+        hash
+      });
+      return hash;
+    } catch (error) {
+      throw new Error(
+        `Failed to send transaction: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Builds a UserOperation from several onchain transactions and submits via the bundler, then waits for inclusion
+   *
+   * @public
+   * @category Transactions
+   *
+   * @param transactionData An array of calls to execute
+   * @param chainId Target chain ID
+   * @returns Promise that resolves to the UserOperation hash for the batch
+   * @throws Error with a readable message if submission or inclusion fails
+   */
+  async sendBatch(transactionData, chainId) {
+    try {
+      const account = await this.getCoinbaseSmartAccount(chainId);
+      const bundlerClient = this.chainManager.getBundlerClient(chainId, account);
+      const bump = (x, pct = 40n) => x + x * pct / 100n;
+      const gas = await bundlerClient.estimateUserOperationGas({
+        account,
+        calls: transactionData
+      });
+      const hash = await bundlerClient.sendUserOperation({
+        account,
+        calls: transactionData,
+        callGasLimit: bump(gas.callGasLimit),
+        verificationGasLimit: bump(gas.verificationGasLimit),
+        preVerificationGas: bump(gas.preVerificationGas)
+      });
+      await bundlerClient.waitForUserOperationReceipt({
+        hash
+      });
+      return hash;
+    } catch (error) {
+      throw new Error(
+        `Failed to send transaction: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Funds the smart wallet with the specified amount of the specified token via Coinbase CDP on-ramp service
+   *
+   * @public
+   * @category Ramp
+   *
+   * @remarks
+   * If Coinbase CDP is not initialized, the method will throw an error. For more details, visit @see {@link https://docs.cdp.coinbase.com/api-reference/v2/rest-api/onramp/create-an-onramp-session}
+   *
+   * @param amount Amount of token that a user wants to purchase and top up his account with (e.g., `"100"`, `"1.5"`)
+   * @param redirectUrl URL to redirect to after the on-ramp is complete. It's required to be a valid URL
+   * @param purchaseCurrency Purchase currency (e.g., `"USDC"`, `"ETH"`)
+   * @param paymentCurrency Payment currency (e.g., `"USD"`, `"EUR"`)
+   * @param paymentMethod Payment method (e.g., `"CARD"`)
+   * @param chain Chain name (e.g., `"base"`)
+   * @param country Country code (e.g., `"US"`)
+   *
+   *
+   * @returns @see {@link OnRampUrlResponse}
+   */
+  async topUp(amount, redirectUrl, purchaseCurrency, paymentCurrency, paymentMethod, country) {
+    if (!this.coinbaseCDP) {
+      throw new Error(
+        "Coinbase CDP is not initialized. Please, provide the configuration in the SDK initialization"
+      );
+    }
+    const address = await this.getAddress();
+    const onRampLink = await this.coinbaseCDP.getOnRampLink(
+      address,
+      redirectUrl,
+      amount,
+      purchaseCurrency,
+      paymentCurrency,
+      paymentMethod,
+      country
+    );
+    return onRampLink;
+  }
+  /**
+   * Cashout token from smart wallet to fiat currency via Coinbase CDP off-ramp service
+   *
+   * @public
+   * @category Ramp
+   *
+   * @remarks
+   * If Coinbase CDP is not initialized, the method will throw an error. For more details, visit @see {@link https://docs.cdp.coinbase.com/api-reference/rest-api/onramp-offramp/create-sell-quote}
+   *
+   * @param country Country code (e.g., `"US"`)
+   * @param paymentMethod Payment method (e.g., `"CARD"`). To get the ful list, visit ""
+   * @param redirectUrl URL to redirect to after the off-ramp is complete. It's required to be a valid URL
+   * @param sellAmount Amount of token that a user wants to sell (e.g., `"100"`, `"1.5"`)
+   * @param cashoutCurrency Cashout currency (e.g., `"USD"`, `"EUR"`). To get the ful list, visit ""
+   * @param sellCurrency Sell currency (e.g., `"USDC"`, `"ETH"`). To get the ful list, visit ""
+   *
+   *
+   * @returns @see {@link OffRampUrlResponse}
+   */
+  async cashOut(country, paymentMethod, redirectUrl, sellAmount, cashoutCurrency, sellCurrency) {
+    if (!this.coinbaseCDP) {
+      throw new Error(
+        "Coinbase CDP is not initialized. Please, provide the configuration in the SDK initialization"
+      );
+    }
+    const address = await this.getAddress();
+    const offRampLink = await this.coinbaseCDP.getOffRampLink(
+      address,
+      country,
+      paymentMethod,
+      redirectUrl,
+      sellAmount,
+      cashoutCurrency,
+      sellCurrency
+    );
+    return offRampLink;
+  }
+  /**
+   * Send tokens from a smart account to another address
+   *
+   * @public
+   * @category Transactions
+   *
+   * @param amount Human-readable amount (e.g., `1.5`)
+   * @param asset Asset symbol (e.g., `"usdc"`, `"eth"`) or token address
+   * @param recipientAddress Destination address
+   * @returns Transaction data suitable for inclusion in a UserOperation/call
+   * @throws Error if `recipientAddress` is missing, `amount` ≤ 0, or asset cannot be resolved
+   */
+  async sendTokens(amount, asset, recipientAddress) {
+    if (!recipientAddress) {
+      throw new Error("Recipient address is required");
+    }
+    if (amount <= 0) {
+      throw new Error("Amount must be greater than 0");
+    }
+    const chainId = this.chainManager.getSupportedChain();
+    if (asset.toLowerCase() === "eth") {
+      const parsedAmount2 = parseAssetAmount(amount, 18);
+      return {
+        to: recipientAddress,
+        value: parsedAmount2,
+        data: "0x"
+      };
+    }
+    const resolvedAsset = resolveAsset(asset, chainId);
+    const parsedAmount = parseAssetAmount(amount, resolvedAsset.decimals);
+    const transferData = encodeFunctionData({
+      abi: erc20Abi2,
+      functionName: "transfer",
+      args: [recipientAddress, parsedAmount]
+    });
+    return {
+      to: resolvedAsset.address,
+      value: 0n,
+      data: transferData
+    };
+  }
+};
+
+// src/tools/ChainManager.ts
+import { createPublicClient, http } from "viem";
+import {
+  createBundlerClient
+} from "viem/account-abstraction";
+
+// src/constants/chains.ts
+import { base as base2, baseSepolia as baseSepolia2 } from "viem/chains";
+var CHAINS_MAP = {
+  base: base2,
+  baseSepolia: baseSepolia2
+};
+var SUPPORTED_CHAIN_IDS = Object.values(CHAINS_MAP).map((c) => c.id);
+
+// src/utils/chains.ts
+import "viem";
+import * as viemChains from "viem/chains";
+var chainById = Object.values(viemChains).reduce(
+  (acc, maybeChain) => {
+    if (maybeChain && typeof maybeChain === "object" && "id" in maybeChain && typeof maybeChain.id === "number" && "name" in maybeChain) {
+      const chain = maybeChain;
+      acc[chain.id] = chain;
+    }
+    return acc;
+  },
+  {}
+);
+
+// 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 {
+  /**
+   * Initializes the chain manager with the given configuration
+   *
+   * @internal
+   * @param chains Configuration object for a supported chain
+   */
+  constructor(chains) {
+    this.chainConfigs = chains;
+    this.publicClient = this.createPublicClient(chains);
+    this.chainNames = CHAINS_MAP;
+  }
+  /**
+   * Utility to validate if a string is a valid HTTP(S) URL
+   *
+   * @internal
+   * @param url Candidate URL
+   * @returns True if valid, false otherwise
+   */
+  isValidUrl(url) {
+    return /^https?:\/\/.+$/.test(url);
+  }
+  /**
+   * Returns a {@link PublicClient} for the given chain ID
+   *
+   * @internal
+   * @category Clients
+   * @param chainId Target chain ID
+   * @returns {@link PublicClient} instance
+   * @throws Error if client is not configured
+   */
+  getPublicClient(chainId) {
+    const client = this.publicClient;
+    if (!client) {
+      throw new Error(`No public client configured for chain ID: ${chainId}`);
+    }
+    return client;
+  }
+  /**
+   * Returns a {@link BundlerClient} for the given chain ID
+   *
+   * @internal
+   * @category Clients
+   * @param chainId Target chain ID
+   * @param account SmartAccount to bind to the bundler client
+   * @returns {@link BundlerClient} instance
+   * @throws Error if no bundler URL is configured
+   */
+  getBundlerClient(chainId, account) {
+    const rpcUrl = this.getRpcUrl(chainId);
+    const bundlerUrl = this.getBundlerUrl(chainId);
+    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)
+    });
+    return createBundlerClient({
+      account,
+      client,
+      transport: http(bundlerUrl),
+      chain: this.getChain(chainId)
+    });
+  }
+  /**
+   * Returns the RPC URL for the given chain ID
+   *
+   * @internal
+   * @category URLs
+   * @param chainId Target chain ID
+   * @returns RPC URL string
+   * @throws Error if chain config is missing or URL is invalid
+   */
+  getRpcUrl(chainId) {
+    const chainConfig = this.chainConfigs;
+    if (!chainConfig) {
+      throw new Error(`No chain config found for chain ID: ${chainId}`);
+    }
+    if (!this.isValidUrl(chainConfig.rpcUrl)) {
+      throw new Error(`Invalid RPC URL for chain ID: ${chainId}`);
+    }
+    return chainConfig.rpcUrl;
+  }
+  /**
+   * Returns the bundler URL for the given chain ID
+   *
+   * @internal
+   * @category URLs
+   * @param chainId Target chain ID
+   * @returns Bundler URL string
+   * @throws Error if chain config is missing or URL is invalid
+   */
+  getBundlerUrl(chainId) {
+    const chainConfig = this.chainConfigs;
+    if (!chainConfig) {
+      throw new Error(`No chain config found for chain ID: ${chainId}`);
+    }
+    if (!this.isValidUrl(chainConfig.bundlerUrl)) {
+      throw new Error(`Invalid bundler URL for chain ID: ${chainId}`);
+    }
+    return chainConfig.bundlerUrl;
+  }
+  /**
+   * Returns the {@link Chain} object for the given chain ID
+   *
+   * @internal
+   * @category Info
+   * @param chainId Target chain ID
+   * @returns Chain metadata
+   * @throws Error if chain is not found
+   */
+  getChain(chainId) {
+    const chain = chainById[chainId];
+    if (!chain) {
+      throw new Error(`Chain not found for ID: ${chainId}`);
+    }
+    return chain;
+  }
+  /**
+   * Returns the currently configured supported chain ID
+   *
+   * @internal
+   * @category Info
+   * @returns Supported chain ID
+   */
+  getSupportedChain() {
+    return this.chainConfigs.chainId;
+  }
+  /**
+   * Creates a {@link PublicClient} for a chain
+   *
+   * @internal
+   * @category Clients
+   * @param chain Chain configuration
+   * @returns PublicClient instance
+   */
+  createPublicClient(chain) {
+    const chainObject = chainById[chain.chainId];
+    const client = createPublicClient({
+      chain: chainObject,
+      transport: http(chain.rpcUrl)
+    });
+    return client;
+  }
+};
+
+// src/wallet/WalletNamespace.ts
+var WalletNamespace = class {
+  /**
+   * Creates a wallet namespace to manage embedded and smart wallets
+   * @param provider Unified provider that composes embedded & smart providers
+   */
+  constructor(provider) {
+    this.provider = provider;
+  }
+  /**
+   * Direct access to the underlying embedded wallet provider
+   *
+   * @public
+   * @category Providers
+   * @remarks
+   * Useful when you need advanced functionality beyond the unified namespace. By default, you should use the unified namespace
+   *
+   * @returns The configured embedded wallet provider instance
+   */
+  get embeddedWalletProvider() {
+    return this.provider.embeddedWalletProvider;
+  }
+  /**
+   * Direct access to the underlying smart wallet provider
+   *
+   * @public
+   * @category Providers
+   * @remarks
+   * Useful when you need advanced functionality beyond the unified namespace. By default, you should use the unified namespace
+   *
+   * @returns The configured smart wallet provider instance
+   */
+  get smartWalletProvider() {
+    return this.provider.smartWalletProvider;
+  }
+  /**
+   * Creates an embedded wallet
+   *
+   * @public
+   * @category Creation
+   * @remarks
+   * Thin wrapper around the embedded wallet provider’s `createWallet`
+   *
+   * @returns Promise that resolves to the newly created {@link EmbeddedWallet}
+   */
+  async createEmbeddedWallet() {
+    return this.provider.createEmbeddedWallet();
+  }
+  /**
+   * Creates a smart wallet (you provide signer and owners)
+   *
+   * @public
+   * @category Creation
+   * @remarks
+   * Use this when you already control a signer (e.g., `LocalAccount`) and want to
+   * create a smart wallet without creating an embedded wallet
+   *
+   * @param params Smart wallet creation parameters
+   * @param params.owners Owners for the smart wallet (addresses or WebAuthn public keys)
+   * @param params.signer Local account used for signing transactions
+   * @param params.nonce Optional nonce/salt for deterministic address generation (defaults to 0)
+   * @returns Promise that resolves to the created {@link SmartWallet}
+   */
+  async createSmartWallet(params) {
+    return this.provider.createSmartWallet(params);
+  }
+  /**
+   * Creates a smart wallet with an embedded wallet as signer
+   *
+   * @public
+   * @category Creation
+   * @remarks
+   * Creates an embedded wallet first, inserts its address into the owners array,
+   * and uses its account as the signer for the smart wallet
+   *
+   * @param params Optional creation parameters
+   * @param params.owners Optional additional owners. The embedded wallet address is inserted at the specified index
+   * @param params.embeddedWalletIndex Optional index at which to insert the embedded wallet address (defaults to end)
+   * @param params.nonce Optional nonce/salt for deterministic address generation (defaults to 0)
+   * @returns Promise that resolves to the created {@link SmartWallet}
+   */
+  async createWalletWithEmbeddedSigner(params) {
+    return this.provider.createWalletWithEmbeddedSigner(params);
+  }
+  /**
+   * Gets a smart wallet using an embedded wallet as the signer
+   *
+   * @public
+   * @category Retrieval
+   * @remarks
+   * Looks up an embedded wallet by `walletId` and uses it as signer
+   * If neither `walletAddress` nor `deploymentOwners` is provided, defaults to using
+   * the embedded wallet as the single owner for deterministic address calculation
+   *
+   * @param params Retrieval parameters
+   * @param params.walletId Embedded wallet ID used to locate the signer wallet
+   * @param params.deploymentOwners Optional original deployment owners used for address calculation
+   * @param params.signerOwnerIndex Index of the signer within the **current** owners set (defaults to 0)
+   * @param params.walletAddress Optional explicit smart wallet address (skips calculation)
+   * @param params.nonce Optional nonce used during original creation
+   * @returns Promise that resolves to the {@link SmartWallet}
+   * @throws Error if the embedded wallet cannot be found
+   */
+  async getSmartWalletWithEmbeddedSigner(params) {
+    return this.provider.getSmartWalletWithEmbeddedSigner(params);
+  }
+  /**
+   * Gets an existing embedded wallet by ID
+   *
+   * @public
+   * @category Retrieval
+   * @param params Retrieval parameters
+   * @param params.walletId Embedded wallet ID to retrieve
+   * @returns Promise that resolves to the {@link EmbeddedWallet} (or `null/undefined` per provider contract)
+   */
+  async getEmbeddedWallet(params) {
+    return this.provider.getEmbeddedWallet(params);
+  }
+  /**
+   * Gets a smart wallet using a provided signer
+   *
+   * @public
+   * @category Retrieval
+   * @remarks
+   * Use when you already control a signer. Requires either:
+   * - `walletAddress`, or
+   * - `deploymentOwners` (+ optional `nonce`) to derive the address
+   *
+   * @param params Retrieval parameters
+   * @param params.signer Signer (local account)
+   * @param params.deploymentOwners Original deployment owners (required if `walletAddress` is not provided)
+   * @param params.signerOwnerIndex Index of the signer within the **current** owners set (defaults to 0)
+   * @param params.walletAddress Explicit smart wallet address (skips calculation)
+   * @param params.nonce Optional nonce used during original creation
+   * @returns Promise that resolves to the {@link SmartWallet}
+   * @throws Error if neither `walletAddress` nor `deploymentOwners` is provided
+   */
+  async getSmartWallet(params) {
+    return this.provider.getSmartWallet(params);
+  }
+};
+
+// src/index.ts
+import { base as base3 } from "viem/chains";
+
+// src/wallet/providers/DefaultSmartWalletProvider.ts
+import { pad as pad2 } from "viem";
+import "viem/account-abstraction";
+
+// src/wallet/base/providers/SmartWalletProvider.ts
+var SmartWalletProvider = class {
+};
+
+// src/wallet/providers/DefaultSmartWalletProvider.ts
+var DefaultSmartWalletProvider = class extends SmartWalletProvider {
+  /**
+   * Initializes the smart wallet provider
+   *
+   * @internal
+   * @param chainManager Manager for chains and viem clients
+   * @param protocol Selected protocol descriptor that exposes an initialized instance
+   */
+  constructor(chainManager, protocol, coinbaseCDP) {
+    super();
+    this.chainManager = chainManager;
+    this.protocolProvider = protocol.instance;
+    this.coinbaseCDP = coinbaseCDP;
+  }
+  /**
+   * Creates a new smart wallet instance that deploys on first use
+   *
+   * @internal
+   * @category Creation
+   * @remarks
+   * Address is derived deterministically from `owners` and `nonce`
+   *
+   * @param params Parameters for wallet creation
+   * @param params.owners Owners as EVM addresses or WebAuthn owners
+   * @param params.signer Local account used to sign UserOperations and transactions
+   * @param params.nonce Optional salt for deterministic address calculation, default 0
+   * @returns Promise that resolves to a {@link DefaultSmartWallet} instance
+   */
+  async createWallet(params) {
+    const { owners, signer, nonce } = params;
+    return new DefaultSmartWallet(
+      owners,
+      signer,
+      this.chainManager,
+      this.protocolProvider,
+      this.coinbaseCDP,
+      void 0,
+      void 0,
+      nonce
+    );
+  }
+  /**
+   * Predicts the deterministic smart wallet address for the given owners and nonce
+   *
+   * @internal
+   * @category Addressing
+   * @remarks
+   * Uses the smart wallet factory `getAddress` to compute the CREATE2 address
+   *
+   * @param params Address prediction parameters
+   * @param params.owners Owners as EVM addresses or WebAuthn owners
+   * @param params.nonce Optional salt for deterministic address calculation, default 0
+   * @returns Promise that resolves to the predicted wallet address
+   * @throws Error if no supported chains are configured
+   * @throws Error if an owner has an invalid type
+   */
+  async getWalletAddress(params) {
+    const { owners, nonce = 0n } = params;
+    const owners_bytes = owners.map((owner) => {
+      if (typeof owner === "string") {
+        return pad2(owner);
+      }
+      if (owner.type === "webAuthn") {
+        return owner.publicKey;
+      }
+      throw new Error("invalid owner type");
+    });
+    const supportedChain = this.chainManager.getSupportedChain();
+    if (!supportedChain) {
+      throw new Error("No supported chains configured");
+    }
+    const publicClient = this.chainManager.getPublicClient(supportedChain);
+    const smartWalletAddress = await publicClient.readContract({
+      abi: smartWalletFactoryAbi,
+      address: smartWalletFactoryAddress,
+      functionName: "getAddress",
+      args: [owners_bytes, nonce]
+    });
+    return smartWalletAddress;
+  }
+  /**
+   * Returns a smart wallet instance for an already deployed address
+   *
+   * @internal
+   * @category Retrieval
+   * @remarks
+   * Use when you already know the deployment address and want an instance bound to a signer
+   *
+   * @param params Retrieval parameters
+   * @param params.walletAddress Deployed smart wallet address
+   * @param params.signer Local account to operate the wallet
+   * @param params.ownerIndex Optional index of `signer` within the current owners set, default 0
+   * @returns A {@link DefaultSmartWallet} instance
+   */
+  getWallet(params) {
+    const { walletAddress, signer, ownerIndex } = params;
+    return new DefaultSmartWallet(
+      [signer.address],
+      signer,
+      this.chainManager,
+      this.protocolProvider,
+      this.coinbaseCDP,
+      walletAddress,
+      ownerIndex
+    );
+  }
+  /**
+   * Funds a wallet via a faucet if supported by the selected chain
+   *
+   * @internal
+   * @category Funding
+   * @remarks
+   * Placeholder for testnet faucet integration
+   *
+   * @returns Future transaction hash or provider response
+   */
+  fundViaFaucet() {
+  }
+};
+
+// src/wallet/WalletProvider.ts
+var WalletProvider = class {
+  /**
+   * Creates a unified wallet provider
+   *
+   * @internal
+   * @param embeddedWalletProvider Provider for embedded wallet operations
+   * @param smartWalletProvider Provider for smart wallet operations
+   */
+  constructor(embeddedWalletProvider, smartWalletProvider) {
+    this.embeddedWalletProvider = embeddedWalletProvider;
+    this.smartWalletProvider = smartWalletProvider;
+  }
+  /**
+   * Creates an embedded wallet
+   *
+   * @internal
+   * @remarks
+   * Thin wrapper around the embedded wallet provider’s `createWallet`
+   *
+   * @returns Promise that resolves to the newly created {@link EmbeddedWallet}
+   */
+  async createEmbeddedWallet() {
+    return this.embeddedWalletProvider.createWallet();
+  }
+  /**
+   * Creates a smart wallet (you provide signer and owners)
+   *
+   * @internal
+   * @remarks
+   * Use when you already control a signer and want to create a smart
+   * wallet without creating an embedded wallet
+   *
+   * @param params Smart wallet creation parameters
+   * @param params.owners Owners array for the smart wallet (EVM addresses or WebAuthn owners)
+   * @param params.signer Signer (local account) used for transactions
+   * @param params.nonce Optional salt/nonce for deterministic address calculation (defaults to 0)
+   * @returns Promise that resolves to the created {@link SmartWallet}
+   */
+  async createSmartWallet(params) {
+    const { owners, signer, nonce } = params;
+    return this.smartWalletProvider.createWallet({
+      owners,
+      signer,
+      nonce
+    });
+  }
+  /**
+   * Creates a smart wallet with an embedded wallet as signer
+   *
+   * @internal
+   * @remarks
+   * Creates an embedded wallet first, then inserts its address into the owners array
+   * and uses its account as the signer for the smart wallet. Default SDK option, embedded wallets manager is necessary to be provided
+   *
+   * @param params Optional creation parameters
+   * @param params.owners Optional additional owners. The embedded wallet address is inserted at the specified index
+   * @param params.embeddedWalletIndex Optional index where the embedded wallet address should be inserted (defaults to the end)
+   * @param params.nonce Optional salt/nonce for deterministic address calculation (defaults to 0)
+   * @returns Promise that resolves to the created {@link SmartWallet}
+   */
+  async createWalletWithEmbeddedSigner(params) {
+    const { owners: ownersParam, embeddedWalletIndex, nonce } = params || {};
+    const embeddedWallet = await this.embeddedWalletProvider.createWallet();
+    const account = await embeddedWallet.account();
+    let owners;
+    if (ownersParam) {
+      owners = [...ownersParam];
+      const insertIndex = embeddedWalletIndex ?? owners.length;
+      owners.splice(insertIndex, 0, embeddedWallet.address);
+    } else {
+      owners = [embeddedWallet.address];
+    }
+    return this.smartWalletProvider.createWallet({
+      owners,
+      signer: account,
+      nonce
+    });
+  }
+  /**
+   * Gets a smart wallet using an embedded wallet as the signer
+   *
+   * @internal
+   * @remarks
+   * Fetches an embedded wallet by `walletId` and uses it as signer.
+   * If neither `walletAddress` nor `deploymentOwners` is provided, defaults to using
+   * the embedded wallet as the single owner for deterministic address calculation
+   *
+   * @param params Retrieval parameters
+   * @param params.walletId Embedded wallet ID used to locate the signer wallet
+   * @param params.deploymentOwners Optional original deployment owners used for address calculation
+   * @param params.signerOwnerIndex Index of the signer in the **current** owners set (defaults to 0)
+   * @param params.walletAddress Optional explicit smart wallet address (skips calculation)
+   * @param params.nonce Optional nonce used during original creation
+   * @returns Promise that resolves to the {@link SmartWallet}
+   * @throws Error if the embedded wallet cannot be found
+   */
+  async getSmartWalletWithEmbeddedSigner(params) {
+    const { walletId, deploymentOwners, walletAddress } = params;
+    const embeddedWallet = await this.embeddedWalletProvider.getWallet({
+      walletId
+    });
+    if (!embeddedWallet) {
+      throw new Error("Embedded wallet not found");
+    }
+    const account = await embeddedWallet.account();
+    const finalDeploymentOwners = deploymentOwners || (walletAddress ? void 0 : [embeddedWallet.address]);
+    return this.getSmartWallet({
+      signer: account,
+      ...params,
+      deploymentOwners: finalDeploymentOwners
+    });
+  }
+  /**
+   * Gets an existing embedded wallet by ID
+   *
+   * @internal
+   * @param params Retrieval parameters
+   * @param params.walletId Embedded wallet ID
+   * @returns Promise that resolves to the {@link EmbeddedWallet}, or `null/undefined` per provider’s contract
+   */
+  async getEmbeddedWallet(params) {
+    const { walletId } = params;
+    return this.embeddedWalletProvider.getWallet({
+      walletId
+    });
+  }
+  /**
+   * Gets a smart wallet using a provided signer
+   *
+   * @internal
+   * @remarks
+   * Use when you already control a `LocalAccount` signer
+   * Requires either:
+   * - `walletAddress`, or
+   * - `deploymentOwners` (+ optional `nonce`) to deterministically derive the address
+   *
+   * @param params Retrieval parameters
+   * @param params.signer Signer (local account)
+   * @param params.deploymentOwners Original deployment owners (required if `walletAddress` is not provided)
+   * @param params.signerOwnerIndex Index of `signer` within the **current** owners set (defaults to 0)
+   * @param params.walletAddress Explicit smart wallet address (skips calculation)
+   * @param params.nonce Optional nonce used during original creation
+   * @returns Promise that resolves to the {@link SmartWallet}
+   * @throws Error if neither `walletAddress` nor `deploymentOwners` is provided
+   */
+  async getSmartWallet(params) {
+    const {
+      signer,
+      deploymentOwners,
+      signerOwnerIndex,
+      walletAddress: walletAddressParam,
+      nonce
+    } = params;
+    if (!walletAddressParam && !deploymentOwners) {
+      try {
+        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");
+        throw new Error(
+          "Either walletAddress or deploymentOwners array must be provided to locate the smart wallet"
+        );
+      }
+    }
+    const ownerIndex = signerOwnerIndex ?? 0;
+    const walletAddress = walletAddressParam || await this.smartWalletProvider.getWalletAddress({
+      // Safe to use ! since we validated above
+      owners: deploymentOwners,
+      nonce
+    });
+    return this.smartWalletProvider.getWallet({
+      walletAddress,
+      signer,
+      ownerIndex
+    });
+  }
+};
+
+// src/wallet/providers/PrivyEmbeddedWalletProvider.ts
+import { getAddress } from "viem";
+
+// src/wallet/PrivyWallet.ts
+import { createViemAccount } from "@privy-io/server-auth/viem";
+import {
+  createWalletClient,
+  http as http2
+} from "viem";
+import { unichain as unichain2 } from "viem/chains";
+
+// src/wallet/base/wallets/EmbeddedWallet.ts
+var EmbeddedWallet = class {
+  /**
+   * Creates an embedded wallet instance
+   *
+   * @internal
+   * @param address Ethereum address of the wallet
+   * @param walletId Optional provider-specific identifier
+   */
+  constructor(address, walletId) {
+    this.address = address;
+    this.walletId = walletId;
+  }
+};
+
+// src/wallet/PrivyWallet.ts
+var PrivyWallet = class extends EmbeddedWallet {
+  /**
+   * Creates a Privy-backed embedded wallet
+   *
+   * @internal
+   * @param privyClient Privy client used to access wallet and signing APIs
+   * @param walletId Privy wallet identifier
+   * @param address Wallet EVM address
+   * @param chainManager Chain and client manager
+   */
+  constructor(privyClient, walletId, address, chainManager) {
+    super(address, walletId);
+    this.privyClient = privyClient;
+    this.walletId = walletId;
+    this.chainManager = chainManager;
+  }
+  /**
+   * Returns a viem-compatible {@link LocalAccount} for this Privy wallet
+   *
+   * @internal
+   * @category Accounts
+   * @remarks
+   * Uses Privy’s signing infra under the hood while exposing the standard viem interface
+   *
+   * @returns Promise that resolves to a {@link LocalAccount}
+   * @throws Error if wallet retrieval or account construction fails
+   */
+  async account() {
+    const account = await createViemAccount({
+      walletId: this.walletId,
+      address: this.address,
+      privy: this.privyClient
+    });
+    return account;
+  }
+  /**
+   * Creates a viem {@link WalletClient} for a given chain
+   *
+   * @internal
+   * @category Accounts
+   * @param chainId Target chain ID
+   * @returns Promise that resolves to a {@link WalletClient}
+   * @throws Error if the chain is unsupported or client creation fails
+   */
+  async walletClient(chainId) {
+    const account = await this.account();
+    return createWalletClient({
+      account,
+      chain: this.chainManager.getChain(chainId),
+      transport: http2(this.chainManager.getRpcUrl(chainId))
+    });
+  }
+  /**
+   * Signs a transaction without broadcasting it
+   *
+   * @internal
+   * @category Signing
+   * @param transactionData Transaction payload to sign
+   * @returns Promise that resolves to a signed transaction hex string
+   */
+  async sign(transactionData) {
+    return await this.signOnly(transactionData);
+  }
+  /**
+   * Produces a signed transaction using Privy’s wallet API without sending it
+   *
+   * @internal
+   * @category Signing
+   * @remarks
+   * Estimates gas, fees, and nonce to build a complete EIP-1559 transaction
+   * Per Privy docs, if any gas field is set, all must be set
+   *
+   * @param transactionData Transaction payload to sign
+   * @returns Promise that resolves to a signed transaction string
+   * @throws Error if signing fails
+   */
+  async signOnly(transactionData) {
+    try {
+      const privyWallet = await this.privyClient.walletApi.getWallet({
+        id: this.walletId
+      });
+      const publicClient = this.chainManager.getPublicClient(unichain2.id);
+      const gasLimit = await publicClient.estimateGas({
+        account: privyWallet.address,
+        to: transactionData.to,
+        data: transactionData.data,
+        value: BigInt(transactionData.value || 0)
+      });
+      const feeData = await publicClient.estimateFeesPerGas();
+      const nonce = await publicClient.getTransactionCount({
+        address: privyWallet.address,
+        blockTag: "pending"
+        // Use pending to get the next nonce including any pending txs
+      });
+      const txParams = {
+        to: transactionData.to,
+        data: transactionData.data,
+        value: transactionData.value,
+        chainId: 130,
+        // Unichain
+        type: 2,
+        // EIP-1559
+        gasLimit: `0x${gasLimit.toString(16)}`,
+        maxFeePerGas: `0x${(feeData.maxFeePerGas || BigInt(1e9)).toString(16)}`,
+        // fallback to 1 gwei
+        maxPriorityFeePerGas: `0x${(feeData.maxPriorityFeePerGas || BigInt(1e8)).toString(16)}`,
+        // fallback to 0.1 gwei
+        nonce: `0x${nonce.toString(16)}`
+        // Explicitly provide the correct nonce
+      };
+      logger.info(
+        "Complete tx params: ",
+        {
+          txParamsType: txParams.type,
+          txParamsNonce: nonce,
+          txParamsLimit: gasLimit,
+          txParamsMaxFee: feeData.maxFeePerGas || "fallback",
+          txParamsPriority: feeData.maxPriorityFeePerGas || "fallback"
+        },
+        "PrivyWallet"
+      );
+      const response = await this.privyClient.walletApi.ethereum.signTransaction({
+        walletId: this.walletId,
+        transaction: txParams
+      });
+      return response.signedTransaction;
+    } catch (error) {
+      throw new Error(
+        `Failed to sign transaction for wallet ${this.walletId}: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Broadcasts a previously-signed transaction
+   *
+   * @internal
+   * @category Sending
+   * @param signedTransaction Signed transaction hex
+   * @param publicClient Viem public client to send the transaction
+   * @returns Promise that resolves to the transaction {@link Hash}
+   * @throws Error if submission fails
+   */
+  async send(signedTransaction, publicClient) {
+    try {
+      const hash = await publicClient.sendRawTransaction({
+        serializedTransaction: signedTransaction
+      });
+      return hash;
+    } catch (error) {
+      throw new Error(
+        `Failed to send transaction: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+};
+
+// src/wallet/base/providers/EmbeddedWalletProvider.ts
+var EmbeddedWalletProvider = class {
+};
+
+// src/wallet/providers/PrivyEmbeddedWalletProvider.ts
+var PrivyEmbeddedWalletProvider = class extends EmbeddedWalletProvider {
+  /**
+   * Creates a new Privy-backed embedded wallet provider
+   *
+   * @internal
+   * @param privyClient Privy client instance
+   * @param chainManager Chain and client manager
+   */
+  constructor(privyClient, chainManager) {
+    super();
+    this.privy = privyClient;
+    this.chainManager = chainManager;
+  }
+  /**
+   * Creates a new wallet using Privy’s wallet API
+   *
+   * @internal
+   * @category Creation
+   * @returns Promise that resolves to a new {@link PrivyWallet} instance
+   * @throws Error if wallet creation fails
+   */
+  async createWallet() {
+    try {
+      const wallet = await this.privy.walletApi.createWallet({
+        chainType: "ethereum"
+      });
+      const walletInstance = new PrivyWallet(
+        this.privy,
+        wallet.id,
+        getAddress(wallet.address),
+        this.chainManager
+      );
+      return walletInstance;
+    } catch (error) {
+      logger.error("Failed to create wallet: ", error, "PrivyEmbeddedWalletProvider");
+      throw new Error(`Failed to create wallet: ${error}`);
+    }
+  }
+  /**
+   * Retrieves a wallet by its ID via Privy
+   *
+   * @internal
+   * @category Retrieval
+   * @param params Parameters containing walletId
+   * @returns Promise that resolves to a {@link PrivyWallet} instance
+   * @throws Error if the wallet cannot be retrieved
+   */
+  async getWallet(params) {
+    try {
+      const wallet = await this.privy.walletApi.getWallet({
+        id: params.walletId
+      });
+      const walletInstance = new PrivyWallet(
+        this.privy,
+        wallet.id,
+        getAddress(wallet.address),
+        this.chainManager
+      );
+      return walletInstance;
+    } catch {
+      throw new Error(`Failed to get wallet with id: ${params.walletId}`);
+    }
+  }
+  /**
+   * Retrieves all wallets from Privy with optional filtering and pagination
+   *
+   * @internal
+   * @category Retrieval
+   * @param options Optional filtering and pagination parameters
+   * @returns Promise that resolves to an array of {@link PrivyWallet} instances
+   * @throws Error if wallets cannot be retrieved
+   */
+  async getAllWallets(options) {
+    try {
+      const response = await this.privy.walletApi.getWallets({
+        limit: options?.limit,
+        cursor: options?.cursor
+      });
+      return response.data.map((wallet) => {
+        const walletInstance = new PrivyWallet(
+          this.privy,
+          wallet.id,
+          getAddress(wallet.address),
+          this.chainManager
+        );
+        return walletInstance;
+      });
+    } catch {
+      throw new Error("Failed to retrieve wallets");
+    }
+  }
+};
+
+// src/index.ts
+import { PrivyClient } from "@privy-io/server-auth";
+
+// src/protocols/base/BaseProtocol.ts
+import {
+  erc20Abi as erc20Abi3,
+  createWalletClient as createWalletClient2,
+  http as http3,
+  parseGwei
+} from "viem";
+var BaseProtocol = class {
+  /**
+   * Ensure the protocol has been initialized
+   * @throws Error if `init()` has not been called
+   */
+  ensureInitialized() {
+    if (!this.chainManager) {
+      throw new Error("Protocol must be initialized before use. Call init() first.");
+    }
+  }
+  /**
+   * Approve a token for protocol use
+   * @param tokenAddress Token address
+   * @param spenderAddress Spender address
+   * @param amount Allowance amount in wei
+   * @param chainId Target chain ID
+   * @param account Account authorizing the approval
+   * @returns Transaction hash
+   */
+  async approveToken(tokenAddress, spenderAddress, amount, chainId, account) {
+    this.ensureInitialized();
+    const walletClient = createWalletClient2({
+      account,
+      chain: this.chainManager.getChain(chainId),
+      transport: http3(this.chainManager.getRpcUrl(chainId))
+    });
+    const hash = await walletClient.writeContract({
+      address: tokenAddress,
+      abi: erc20Abi3,
+      functionName: "approve",
+      args: [spenderAddress, amount],
+      gas: 100000n,
+      maxFeePerGas: parseGwei("20"),
+      maxPriorityFeePerGas: parseGwei("2")
+    });
+    return hash;
+  }
+  /**
+   * Check token allowance for a spender
+   * @param tokenAddress Token address
+   * @param spenderAddress Spender address
+   * @param walletAddress Wallet address granting allowance
+   * @param chainId Target chain ID
+   * @returns Current allowance amount
+   */
+  async checkAllowance(tokenAddress, spenderAddress, walletAddress, chainId) {
+    this.ensureInitialized();
+    const publicClient = this.chainManager.getPublicClient(chainId);
+    return await publicClient.readContract({
+      address: tokenAddress,
+      abi: erc20Abi3,
+      functionName: "allowance",
+      args: [walletAddress, spenderAddress]
+    });
+  }
+};
+
+// src/protocols/implementations/SparkProtocol.ts
+import {
+  encodeFunctionData as encodeFunctionData2,
+  erc20Abi as erc20Abi4,
+  formatUnits as formatUnits2,
+  parseUnits as parseUnits2
+} from "viem";
+
+// src/abis/protocols/spark.ts
+var SPARK_VAULT_ABI = [
+  { type: "function", name: "asset", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+  { type: "function", name: "totalAssets", stateMutability: "view", inputs: [], outputs: [{ type: "uint256" }] },
+  { type: "function", name: "convertToShares", stateMutability: "view", inputs: [{ name: "assets", type: "uint256" }], outputs: [{ type: "uint256" }] },
+  { type: "function", name: "convertToAssets", stateMutability: "view", inputs: [{ name: "shares", type: "uint256" }], outputs: [{ type: "uint256" }] },
+  { type: "function", name: "balanceOf", stateMutability: "view", inputs: [{ name: "owner", type: "address" }], outputs: [{ type: "uint256" }] },
+  { type: "function", name: "deposit", stateMutability: "nonpayable", inputs: [
+    { name: "assets", type: "uint256" },
+    { name: "receiver", type: "address" }
+  ], outputs: [{ type: "uint256" }] },
+  { type: "function", name: "withdraw", stateMutability: "nonpayable", inputs: [
+    { name: "assets", type: "uint256" },
+    { name: "receiver", type: "address" },
+    { name: "owner", type: "address" }
+  ], outputs: [{ type: "uint256" }] },
+  { type: "function", name: "redeem", stateMutability: "nonpayable", inputs: [
+    { name: "shares", type: "uint256" },
+    { name: "receiver", type: "address" },
+    { name: "owner", type: "address" }
+  ], outputs: [{ type: "uint256" }] }
+];
+var SPARK_SSR_ORACLE_ABI = [
+  { "inputs": [], "stateMutability": "nonpayable", "type": "constructor" },
+  { "inputs": [], "name": "AccessControlBadConfirmation", "type": "error" },
+  { "inputs": [{ "internalType": "address", "name": "account", "type": "address" }, { "internalType": "bytes32", "name": "neededRole", "type": "bytes32" }], "name": "AccessControlUnauthorizedAccount", "type": "error" },
+  { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "bytes32", "name": "role", "type": "bytes32" }, { "indexed": true, "internalType": "bytes32", "name": "previousAdminRole", "type": "bytes32" }, { "indexed": true, "internalType": "bytes32", "name": "newAdminRole", "type": "bytes32" }], "name": "RoleAdminChanged", "type": "event" },
+  { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "bytes32", "name": "role", "type": "bytes32" }, { "indexed": true, "internalType": "address", "name": "account", "type": "address" }, { "indexed": true, "internalType": "address", "name": "sender", "type": "address" }], "name": "RoleGranted", "type": "event" },
+  { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "bytes32", "name": "role", "type": "bytes32" }, { "indexed": true, "internalType": "address", "name": "account", "type": "address" }, { "indexed": true, "internalType": "address", "name": "sender", "type": "address" }], "name": "RoleRevoked", "type": "event" },
+  { "anonymous": false, "inputs": [{ "indexed": false, "internalType": "uint256", "name": "maxSSR", "type": "uint256" }], "name": "SetMaxSSR", "type": "event" },
+  { "anonymous": false, "inputs": [{ "components": [{ "internalType": "uint96", "name": "ssr", "type": "uint96" }, { "internalType": "uint120", "name": "chi", "type": "uint120" }, { "internalType": "uint40", "name": "rho", "type": "uint40" }], "indexed": false, "internalType": "struct ISSROracle.SUSDSData", "name": "nextData", "type": "tuple" }], "name": "SetSUSDSData", "type": "event" },
+  { "inputs": [], "name": "DATA_PROVIDER_ROLE", "outputs": [{ "internalType": "bytes32", "name": "", "type": "bytes32" }], "stateMutability": "view", "type": "function" },
+  { "inputs": [], "name": "DEFAULT_ADMIN_ROLE", "outputs": [{ "internalType": "bytes32", "name": "", "type": "bytes32" }], "stateMutability": "view", "type": "function" },
+  { "inputs": [], "name": "getAPR", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" },
+  { "inputs": [], "name": "getChi", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" },
+  { "inputs": [{ "internalType": "uint256", "name": "timestamp", "type": "uint256" }], "name": "getConversionRate", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" },
+  { "inputs": [], "name": "getConversionRate", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" },
+  { "inputs": [{ "internalType": "uint256", "name": "timestamp", "type": "uint256" }], "name": "getConversionRateBinomialApprox", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" },
+  { "inputs": [], "name": "getConversionRateBinomialApprox", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" },
+  { "inputs": [{ "internalType": "uint256", "name": "timestamp", "type": "uint256" }], "name": "getConversionRateLinearApprox", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" },
+  { "inputs": [], "name": "getConversionRateLinearApprox", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" },
+  { "inputs": [], "name": "getRho", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" },
+  { "inputs": [{ "internalType": "bytes32", "name": "role", "type": "bytes32" }], "name": "getRoleAdmin", "outputs": [{ "internalType": "bytes32", "name": "", "type": "bytes32" }], "stateMutability": "view", "type": "function" },
+  { "inputs": [], "name": "getSSR", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" },
+  { "inputs": [], "name": "getSUSDSData", "outputs": [{ "components": [{ "internalType": "uint96", "name": "ssr", "type": "uint96" }, { "internalType": "uint120", "name": "chi", "type": "uint120" }, { "internalType": "uint40", "name": "rho", "type": "uint40" }], "internalType": "struct ISSROracle.SUSDSData", "name": "", "type": "tuple" }], "stateMutability": "view", "type": "function" },
+  { "inputs": [{ "internalType": "bytes32", "name": "role", "type": "bytes32" }, { "internalType": "address", "name": "account", "type": "address" }], "name": "grantRole", "outputs": [], "stateMutability": "nonpayable", "type": "function" },
+  { "inputs": [{ "internalType": "bytes32", "name": "role", "type": "bytes32" }, { "internalType": "address", "name": "account", "type": "address" }], "name": "hasRole", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "view", "type": "function" },
+  { "inputs": [], "name": "maxSSR", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" },
+  { "inputs": [{ "internalType": "bytes32", "name": "role", "type": "bytes32" }, { "internalType": "address", "name": "callerConfirmation", "type": "address" }], "name": "renounceRole", "outputs": [], "stateMutability": "nonpayable", "type": "function" },
+  { "inputs": [{ "internalType": "bytes32", "name": "role", "type": "bytes32" }, { "internalType": "address", "name": "account", "type": "address" }], "name": "revokeRole", "outputs": [], "stateMutability": "nonpayable", "type": "function" },
+  { "inputs": [{ "internalType": "uint256", "name": "_maxSSR", "type": "uint256" }], "name": "setMaxSSR", "outputs": [], "stateMutability": "nonpayable", "type": "function" },
+  { "inputs": [{ "components": [{ "internalType": "uint96", "name": "ssr", "type": "uint96" }, { "internalType": "uint120", "name": "chi", "type": "uint120" }, { "internalType": "uint40", "name": "rho", "type": "uint40" }], "internalType": "struct ISSROracle.SUSDSData", "name": "nextData", "type": "tuple" }], "name": "setSUSDSData", "outputs": [], "stateMutability": "nonpayable", "type": "function" },
+  { "inputs": [{ "internalType": "bytes4", "name": "interfaceId", "type": "bytes4" }], "name": "supportsInterface", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "view", "type": "function" }
+];
+
+// src/protocols/constants/spark.ts
+var SPARK_SSR_ORACLE_ADDRESS = "0x65d946e533748A998B1f0E430803e39A6388f7a1";
+var SPARK_VAULT = [
+  {
+    id: "sUSDC",
+    chain: "base",
+    vaultAddress: "0x3128a0f7f0ea68e7b7c9b00afa7e41045828e858",
+    depositTokenAddress: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+    depositTokenDecimals: 6,
+    depositTokenSymbol: "USDC",
+    earnTokenAddress: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+    earnTokenDecimals: 18,
+    earnTokenSymbol: "sUSDC",
+    metadata: {}
+  }
+];
+var SECONDS_PER_YEAR = 60 * 60 * 24 * 365;
+var RAY = BigInt("1000000000000000000000000000");
+
+// src/protocols/implementations/SparkProtocol.ts
+var SparkProtocol = class extends BaseProtocol {
+  constructor() {
+    super(...arguments);
+    this.allVaults = [];
+  }
+  /**
+   * Initialize the Spark protocol with the provided chain manager
+   * @param chainManager Chain manager instance used for network operations
+   */
+  async init(chainManager) {
+    this.chainManager = chainManager;
+    this.selectedChainId = chainManager.getSupportedChain();
+    this.publicClient = chainManager.getPublicClient(this.selectedChainId);
+    this.allVaults = this.getVaults();
+  }
+  /**
+   * Get the SSR (Sky Saving Rate) of the Spark protocol
+   * @remarks
+   * The parameter ius necessary to calculate the APY of a vault
+   * @returns
+   */
+  async getSSR() {
+    if (!this.publicClient) {
+      throw new Error("Public client not initialized");
+    }
+    const ssrRaw = await this.publicClient.readContract({
+      address: SPARK_SSR_ORACLE_ADDRESS,
+      abi: SPARK_SSR_ORACLE_ABI,
+      functionName: "getSSR"
+    });
+    const ssr = Number(ssrRaw) / Number(RAY);
+    return ssr;
+  }
+  /**
+   * Get the APY of the Spark protocol
+   * @remarks
+   * Calculation based on the formula from the documentation:
+   * https://docs.spark.fi/dev/integration-guides/susds-lending-market#rates
+   * @returns The APY of the Spark protocol in percentage
+   */
+  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;
+  }
+  /**
+   * Get the best available Spark vault
+   * @returns The top-ranked Spark vault
+   * @throws Error if no vaults found
+   */
+  async getBestVault() {
+    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;
+  }
+  /**
+   * Deposit funds into a Spark vault
+   * @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");
+    }
+    const owner = await smartWallet.getAddress();
+    const assets = parseUnits2(amount, vaultInfoToDeposit.depositTokenDecimals);
+    logger.info("Raw deposit amount:", { amount, assets }, "SparkProtocol");
+    const allowance = await this.checkAllowance(
+      vaultInfoToDeposit.depositTokenAddress,
+      vaultInfoToDeposit.vaultAddress,
+      owner,
+      this.selectedChainId
+    );
+    logger.info("Current vault contract allowance:", { allowance }, "SparkProtocol");
+    const ops = [];
+    if (allowance < assets) {
+      ops.push({
+        to: vaultInfoToDeposit.depositTokenAddress,
+        data: encodeFunctionData2({
+          abi: erc20Abi4,
+          functionName: "approve",
+          args: [vaultInfoToDeposit.vaultAddress, assets]
+        })
+      });
+    }
+    ops.push({
+      to: vaultInfoToDeposit.vaultAddress,
+      data: encodeFunctionData2({
+        abi: SPARK_VAULT_ABI,
+        functionName: "deposit",
+        args: [assets, owner]
+      })
+    });
+    const hash = await smartWallet.sendBatch(ops, this.selectedChainId);
+    return { success: true, hash };
+  }
+  /**
+   * Withdraw funds from a Spark vault
+   * @param amountInUnderlying 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");
+    }
+    const owner = await smartWallet.getAddress();
+    let withdrawData;
+    if (amountInUnderlying) {
+      const assets = parseUnits2(amountInUnderlying, depositedVault.depositTokenDecimals);
+      logger.info("Withdraw amount:", { amountInUnderlying, assets }, "SparkProtocol");
+      withdrawData = {
+        to: depositedVault.vaultAddress,
+        data: encodeFunctionData2({
+          abi: SPARK_VAULT_ABI,
+          functionName: "withdraw",
+          args: [assets, owner, owner]
+        })
+      };
+    } else {
+      const maxShares = await this.getMaxRedeemableShares(depositedVault, owner);
+      logger.info("Withdrawing all funds:", { maxShares }, "SparkProtocol");
+      withdrawData = {
+        to: depositedVault.vaultAddress,
+        data: encodeFunctionData2({
+          abi: SPARK_VAULT_ABI,
+          functionName: "redeem",
+          args: [maxShares, owner, owner]
+        })
+      };
+    }
+    const hash = await smartWallet.send(withdrawData, this.selectedChainId);
+    logger.info("Withdraw transaction sent:", { hash }, "SparkProtocol");
+    return { success: true, hash };
+  }
+  /**
+   * Get the maximum redeemable shares for a wallet
+   * @param vaultInfo Vault information
+   * @param walletAddress Wallet address to check
+   * @returns Maximum redeemable shares as bigint
+   */
+  async getMaxRedeemableShares(vaultInfo, walletAddress) {
+    if (!this.publicClient) {
+      throw new Error("Public client not initialized");
+    }
+    const shares = await this.publicClient.readContract({
+      address: vaultInfo.vaultAddress,
+      abi: SPARK_VAULT_ABI,
+      functionName: "balanceOf",
+      args: [walletAddress]
+    });
+    return shares;
+  }
+  /**
+   * 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
+   */
+  async getBalance(vaultInfo, walletAddress) {
+    if (!this.publicClient) {
+      throw new Error("Public client not initialized");
+    }
+    const shares = await this.publicClient.readContract({
+      address: vaultInfo.vaultAddress,
+      abi: SPARK_VAULT_ABI,
+      functionName: "balanceOf",
+      args: [walletAddress]
+    });
+    if (shares === 0n) {
+      return { shares: "0", depositedAmount: "0", vaultInfo };
+    }
+    const assets = await this.publicClient.readContract({
+      address: vaultInfo.vaultAddress,
+      abi: SPARK_VAULT_ABI,
+      functionName: "convertToAssets",
+      args: [shares]
+    });
+    return {
+      shares: formatUnits2(shares, vaultInfo.earnTokenDecimals),
+      depositedAmount: formatUnits2(assets, vaultInfo.depositTokenDecimals),
+      vaultInfo
+    };
+  }
+};
+
+// src/constants/protocols.ts
+var availableProtocols = [
+  {
+    info: {
+      id: "spark",
+      name: "Spark",
+      website: "https://spark.fi/",
+      logo: "/logos/spark.png",
+      supportedChains: [1, 8453, 42161],
+      riskLevel: "low",
+      isPremium: false
+    },
+    instance: new SparkProtocol()
+  }
+];
+
+// src/tools/ApiKeysValidator.ts
+var ApiKeysValidator = class {
+  // TODO: Implement the validation logic
+  /**
+   * 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
+   */
+  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;
+    this.chainManager = chainManager;
+  }
+};
+
+// src/router/ProtocolRouter.ts
+var ProtocolRouter = class extends ProtocolRouterBase {
+  /**
+   * 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);
+  }
+  /**
+   * Get all protocols available for the current configuration
+   *
+   * 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);
+    const allAvailableProtocols = availableProtocols.filter((protocol) => {
+      if (!protocol.info.isPremium) {
+        return true;
+      }
+      return protocol.info.isPremium && isKeyValid;
+    });
+    return allAvailableProtocols;
+  }
+  /**
+   * Check if any protocol supports a given set of chains
+   * @param chainIds List of chain IDs to validate
+   * @returns True if at least one chain is supported by the router
+   */
+  isProtocolSupportedChain(chainIds) {
+    return chainIds.some((chainId) => this.chainManager.getSupportedChain() === chainId);
+  }
+  /**
+   * Recommend the best protocol for the current router configuration
+   *
+   * Filters available protocols by risk level and supported chains. More criteria will be added later on
+   *
+   *
+   * @remarks
+   * Currently returns the first match. Future improvements will add
+   * smarter sorting and pool-based APY checks
+   *
+   * @throws Error if no protocols are available for the current risk level
+   * @returns Protocol instance considered the best match
+   */
+  recommend() {
+    const protocols = this.getProtocols();
+    const eligibleProtocols = protocols.filter((protocol) => {
+      const riskMatches = protocol.info.riskLevel === this.riskLevel;
+      const isSupportedChain = this.isProtocolSupportedChain(protocol.info.supportedChains);
+      return riskMatches && isSupportedChain;
+    });
+    if (eligibleProtocols.length === 0) {
+      throw new Error(`No protocols available for risk level: ${this.riskLevel}`);
+    }
+    const bestProtocol = eligibleProtocols[0];
+    return bestProtocol;
+  }
+};
+
+// src/tools/CoinbaseCDP.ts
+import { generateJwt } from "@coinbase/cdp-sdk/auth";
+import axios from "axios";
+
+// src/utils/urls.ts
+var checkValidUrl = (url) => {
+  return /^https?:\/\/.+$/.test(url);
+};
+
+// src/tools/CoinbaseCDP.ts
+var CoinbaseCDP = class {
+  constructor(apiKeyId, apiKeySecret, integratorId, chainManager) {
+    this.coinbaseCdpV2Hostname = "https://api.cdp.coinbase.com";
+    this.coinbaseCdpV1Hostname = "https://api.developer.coinbase.com";
+    this.onRampUrlAuthParams = {
+      requestMethod: "POST",
+      requestHost: "api.cdp.coinbase.com",
+      requestPath: "/platform/v2/onramp/sessions",
+      expiresIn: 120
+    };
+    this.onRampConfigAuthParams = {
+      requestMethod: "GET",
+      requestHost: "api.developer.coinbase.com",
+      requestPath: "/onramp/v1/buy/config",
+      expiresIn: 120
+    };
+    this.offRampUrlAuthParams = {
+      requestMethod: "POST",
+      requestHost: "api.developer.coinbase.com",
+      requestPath: "/onramp/v1/sell/quote",
+      expiresIn: 120
+    };
+    this.offRampConfigAuthParams = {
+      requestMethod: "GET",
+      requestHost: "api.developer.coinbase.com",
+      requestPath: "/onramp/v1/sell/config",
+      expiresIn: 120
+    };
+    this.clientV2 = axios.create({
+      baseURL: this.coinbaseCdpV2Hostname
+    });
+    this.clientV1 = axios.create({
+      baseURL: this.coinbaseCdpV1Hostname
+    });
+    this.apiKeyId = apiKeyId;
+    this.apiKeySecret = apiKeySecret;
+    this.chainManager = chainManager;
+    this.integratorId = integratorId;
+    this.verifyParameters();
+  }
+  verifyParameters() {
+    if (!this.apiKeyId || !this.apiKeySecret || !this.integratorId) {
+      throw new Error("API key ID, secret and integrator ID are required");
+    }
+  }
+  /**
+   * @internal
+   * Generate a JWT token for a provided API endpoint and hostname to make a request after
+   * @category Ramp
+   *
+   * @param authParams Authentication parameters
+   * @returns JWT token
+   * @throws Error if the JWT token generation fails
+   */
+  async auth(authParams) {
+    const jwtToken = await generateJwt({
+      apiKeyId: this.apiKeyId,
+      apiKeySecret: this.apiKeySecret,
+      ...authParams
+    });
+    return jwtToken;
+  }
+  /**
+   * @internal
+   * Return a on-ramp URL for the given parameters via Coinbase CDP V2 API
+   * @category Ramp
+   *
+   * @param receiverAddress
+   * @param redirectUrl
+   * @param amount
+   * @param purchaseCurrency
+   * @param paymentCurrency
+   * @param paymentMethod
+   * @param country
+   * @returns OnRampUrlResponse
+   * @throws Error if redirect URL is not a valid URL
+   * @throws CoinbaseCDPError if the request fails
+   */
+  async getOnRampLink(receiverAddress, redirectUrl, amount, purchaseCurrency = "USDC", paymentCurrency = "USD", paymentMethod = "CARD", country) {
+    if (!checkValidUrl(redirectUrl)) {
+      throw new Error("Redirect URL is not a valid URL");
+    }
+    const chainId = this.chainManager.getSupportedChain();
+    const chainName = chainById[chainId]?.name.toLowerCase();
+    const authJwtToken = await this.auth(this.onRampUrlAuthParams);
+    const response = await this.clientV2.post(
+      this.onRampUrlAuthParams.requestPath,
+      {
+        destinationAddress: receiverAddress,
+        destinationNetwork: chainName,
+        redirectUrl,
+        paymentAmount: amount,
+        purchaseCurrency,
+        paymentCurrency,
+        paymentMethod,
+        country
+      },
+      {
+        method: this.onRampUrlAuthParams.requestMethod,
+        headers: { Authorization: `Bearer ${authJwtToken}`, "Content-Type": "application/json" }
+      }
+    );
+    if (response.status !== 200 && response.status !== 201) {
+      const error = response.data;
+      throw error;
+    }
+    const onRampResponse = response.data;
+    return onRampResponse;
+  }
+  /**
+   * @internal
+   * Current method return all supported countries and payment methods for on-ramp by Coinbase CDP
+   * @category Ramp
+   *
+   * @returns Config with supported countries and payment methods for on-ramp
+   * @throws If API returned an error
+   */
+  async getOnRampConfig() {
+    const authJwtToken = await this.auth(this.onRampConfigAuthParams);
+    const response = await this.clientV1.get(
+      this.onRampConfigAuthParams.requestPath,
+      {
+        headers: { Authorization: `Bearer ${authJwtToken}` }
+      }
+    );
+    if (response.status !== 200) {
+      const error = response.data;
+      throw error;
+    }
+    const onRampConfigResponse = response.data;
+    return onRampConfigResponse;
+  }
+  /**
+   * @internal
+   * Return a off-ramp URL for the given parameters via Coinbase CDP V1 API
+   * @remarks
+   * Use an integratorId as a partnerUserId  in Coinbase CDP API
+   * @category Ramp
+   *
+   * @param address
+   * @param country
+   * @param paymentMethod
+   * @param redirectUrl
+   * @param sellAmount
+   * @param cashoutCurrency
+   * @param sellCurrency
+   * @returns OffRampUrlResponse
+   * @throws Error if redirect URL is not a valid URL
+   * @throws CoinbaseCDPError if the request fails
+   */
+  async getOffRampLink(address, country, paymentMethod, redirectUrl, sellAmount, cashoutCurrency = "USD", sellCurrency = "USDC") {
+    if (!checkValidUrl(redirectUrl)) {
+      throw new Error("Redirect URL is not a valid URL");
+    }
+    const chainId = this.chainManager.getSupportedChain();
+    const chainName = chainById[chainId]?.name.toLowerCase();
+    const authJwtToken = await this.auth(this.offRampUrlAuthParams);
+    const response = await this.clientV1.post(
+      this.offRampUrlAuthParams.requestPath,
+      {
+        sourceAddress: address,
+        country,
+        paymentMethod,
+        partnerUserId: this.integratorId,
+        redirectUrl,
+        sellAmount,
+        sellNetwork: chainName,
+        cashoutCurrency,
+        sellCurrency
+      },
+      {
+        method: this.offRampUrlAuthParams.requestMethod,
+        headers: { Authorization: `Bearer ${authJwtToken}`, "Content-Type": "application/json" }
+      }
+    );
+    if (response.status !== 200 && response.status !== 201) {
+      const error = response.data;
+      throw error;
+    }
+    const offRampResponse = response.data;
+    return offRampResponse;
+  }
+  /**
+   * @internal
+   * Current method return all supported countries and payment methods for off-ramp by Coinbase CDP
+   * @category Ramp
+   * @returns Config with supported countries and payment methods for off-ramp
+   * @throws If API returned an error
+   */
+  async getOffRampConfig() {
+    const authJwtToken = await this.auth(this.offRampConfigAuthParams);
+    const response = await this.clientV1.get(
+      this.offRampConfigAuthParams.requestPath,
+      {
+        headers: { Authorization: `Bearer ${authJwtToken}` }
+      }
+    );
+    if (response.status !== 200) {
+      const error = response.data;
+      throw error;
+    }
+    const offRampConfigResponse = response.data;
+    return offRampConfigResponse;
+  }
+};
+
+// src/index.ts
+var MyceliumSDK = class {
+  /**
+   * Creates a new SDK instance
+   *
+   * @param config SDK configuration (networks, wallets, protocol router settings)
+   * @throws Throws if an unsupported wallet provider is given
+   * @see MyceliumSDKConfig
+   */
+  constructor(config) {
+    /**
+     * Coinbase CDP instance to Coinbase related and onchain operations using Coinbase CDP API
+     * @remarks
+     * If the configuration is not provided, the Coinbase CDP functionality will be disabled.
+     * Calling the respective method will throw an error.
+     * @internal
+     */
+    this.coinbaseCDP = null;
+    /**
+     * Coinbase CDP configuration methods for ramp operations
+     * @public
+     * @category Tools
+     */
+    this.rampConfig = {
+      /**
+       * Return all supported countries and payment methods for on-ramp by Coinbase CDP
+       * @public
+       * @category Ramp
+       *
+       * @returns @see {@link RampConfigResponse} with supported countries and payment methods for top-up
+       * @throws If API returned an error
+       */
+      getTopUpConfig: async () => {
+        if (!this.coinbaseCDP) {
+          throw new Error(
+            "Coinbase CDP is not initialized. Please, provide the configuration in the SDK initialization"
+          );
+        }
+        return await this.coinbaseCDP.getOnRampConfig();
+      },
+      /**
+       * Return all supported countries and payment methods for off-ramp by Coinbase CDP
+       * @public
+       * @category Ramp
+       *
+       *
+       * @returns @see {@link RampConfigResponse} with supported countries and payment methods for cash out
+       * @throws If API returned an error
+       */
+      getCashOutConfig: async () => {
+        if (!this.coinbaseCDP) {
+          throw new Error(
+            "Coinbase CDP is not initialized. Please, provide the configuration in the SDK initialization"
+          );
+        }
+        return await this.coinbaseCDP.getOffRampConfig();
+      }
+    };
+    this._chainManager = new ChainManager(
+      config.chain || {
+        chainId: base3.id,
+        rpcUrl: base3.rpcUrls.default.http[0],
+        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.coinbaseCDPConfig) {
+      this.coinbaseCDP = new CoinbaseCDP(
+        config.coinbaseCDPConfig.apiKeyId,
+        config.coinbaseCDPConfig.apiKeySecret,
+        config.integratorId,
+        this.chainManager
+      );
+    }
+    const protocolsRouterConfig = config.protocolsRouterConfig || {
+      riskLevel: "low"
+    };
+    this.protocol = this.findProtocol(protocolsRouterConfig);
+    this.wallet = this.createWalletNamespace(config.walletsConfig);
+  }
+  /**
+   * Returns the chain manager instance for multi-chain operations
+   * @public
+   * @category Tools
+   *
+   * @returns ChainManager instance of the type {@link ChainManager}
+   */
+  get chainManager() {
+    return this._chainManager;
+  }
+  /**
+   * Recommends and initializes a protocol based on router settings
+   *
+   * @internal
+   * @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);
+    return protocol;
+  }
+  /**
+   * Creates a wallet provider (embedded + smart) and combines them
+   *
+   * @internal
+   * @param config Wallet configuration
+   * @returns Configured {@link WalletProvider}
+   * @throws If an unsupported wallet provider type is specified
+   */
+  createWalletProvider(config) {
+    if (config.embeddedWalletConfig.provider.type === "privy") {
+      const privyClient = new PrivyClient(
+        config.embeddedWalletConfig.provider.providerConfig.appId,
+        config.embeddedWalletConfig.provider.providerConfig.appSecret
+      );
+      this.embeddedWalletProvider = new PrivyEmbeddedWalletProvider(
+        privyClient,
+        this._chainManager
+      );
+    } else {
+      throw new Error(
+        `Unsupported embedded wallet provider: ${config.embeddedWalletConfig.provider.type}`
+      );
+    }
+    if (!config.smartWalletConfig || config.smartWalletConfig.provider.type === "default") {
+      this.smartWalletProvider = new DefaultSmartWalletProvider(
+        this.chainManager,
+        this.protocol,
+        this.coinbaseCDP
+      );
+    } else {
+      throw new Error(
+        `Unsupported smart wallet provider: ${config.smartWalletConfig.provider.type}`
+      );
+    }
+    const walletProvider = new WalletProvider(
+      this.embeddedWalletProvider,
+      this.smartWalletProvider
+    );
+    return walletProvider;
+  }
+  /**
+   * Creates the public wallet namespace
+   *
+   * @internal
+   * @param config Wallet configuration.
+   * @returns A {@link WalletNamespace} instance
+   */
+  createWalletNamespace(config) {
+    const walletProvider = this.createWalletProvider(config);
+    return new WalletNamespace(walletProvider);
+  }
+};
+export {
+  DefaultSmartWallet,
+  MyceliumSDK
+};
+//# sourceMappingURL=index.js.map