@mycelium-sdk/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1568 @@
+import { PublicClient, Chain, Address, Hex, LocalAccount, Hash, WalletClient } from 'viem';
+import { SmartAccount, BundlerClient, WebAuthnAccount, toCoinbaseSmartAccount } from 'viem/account-abstraction';
+
+declare const SUPPORTED_CHAIN_IDS: number[];
+type SupportedChainId = (typeof SUPPORTED_CHAIN_IDS)[number];
+
+/**
+ * @internal
+ * @category Types
+ *  Detailed token balance information
+ *
+ */
+interface TokenBalance {
+    symbol: string;
+    totalBalance: bigint;
+    totalFormattedBalance: string;
+    chainBalances: Array<{
+        chainId: SupportedChainId;
+        balance: bigint;
+        formattedBalance: string;
+    }>;
+}
+
+/**
+ * Chain configuration
+ *  Configuration for each supported chain
+ */
+interface ChainConfig {
+    /** Chain ID */
+    chainId: (typeof SUPPORTED_CHAIN_IDS)[number];
+    /** RPC URL for the chain */
+    rpcUrl: string;
+    /** Bundler URL for the chain */
+    bundlerUrl: string;
+}
+
+/**
+ * Service for managing supported blockchain networks and their clients
+ *
+ * @internal
+ * @category Infrastructure
+ * @remarks
+ * Provides RPC and bundler URL access, creates {@link PublicClient} and {@link BundlerClient} instances
+ * Central point for chain-level configuration in the SDK
+ */
+declare class ChainManager {
+    /** Public client for the configured chain */
+    private publicClient;
+    /** Chain configuration */
+    private chainConfigs;
+    /** Map of chain names to chain metadata */
+    private chainNames;
+    /**
+     * Initializes the chain manager with the given configuration
+     *
+     * @internal
+     * @param chains Configuration object for a supported chain
+     */
+    constructor(chains: ChainConfig);
+    /**
+     * Utility to validate if a string is a valid HTTP(S) URL
+     *
+     * @internal
+     * @param url Candidate URL
+     * @returns True if valid, false otherwise
+     */
+    private isValidUrl;
+    /**
+     * 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: (typeof SUPPORTED_CHAIN_IDS)[number]): PublicClient;
+    /**
+     * 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: (typeof SUPPORTED_CHAIN_IDS)[number], account: SmartAccount): BundlerClient;
+    /**
+     * 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: (typeof SUPPORTED_CHAIN_IDS)[number]): string;
+    /**
+     * 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: (typeof SUPPORTED_CHAIN_IDS)[number]): string | undefined;
+    /**
+     * 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: (typeof SUPPORTED_CHAIN_IDS)[number]): Chain;
+    /**
+     * Returns the currently configured supported chain ID
+     *
+     * @internal
+     * @category Info
+     * @returns Supported chain ID
+     */
+    getSupportedChain(): number;
+    /**
+     * Creates a {@link PublicClient} for a chain
+     *
+     * @internal
+     * @category Clients
+     * @param chain Chain configuration
+     * @returns PublicClient instance
+     */
+    private createPublicClient;
+}
+
+/**
+ * Asset identifier - can be a symbol (like 'usdc') or address
+ */
+type AssetIdentifier = string | Address;
+
+/**
+ * Transaction data for execution
+ *  Raw transaction data for wallet execution
+ */
+interface TransactionData {
+    /** Target contract address */
+    to: Address;
+    /** Encoded function call data */
+    data: Hex;
+    /** ETH value to send */
+    value?: bigint;
+}
+
+interface CoinbaseCDPAuthParams {
+    requestMethod: string;
+    requestHost: string;
+    requestPath: string;
+    expiresIn?: number;
+}
+/**
+ * The quote and session URL for a valid on-ramp operation
+ * @public
+ * @category Types
+ */
+interface OnRampUrlResponse {
+    quote?: {
+        destinationNetwork: string;
+        exchangeRate: string;
+        fees: Array<{
+            amount: string;
+            currency: string;
+            type: string;
+        }>;
+        paymentCurrency: string;
+        paymentSubtotal: string;
+        paymentTotal: string;
+        purchaseAmount: string;
+        purchaseCurrency: string;
+    };
+    session?: {
+        onrampUrl: string;
+    };
+}
+interface OffRampUrlResponseSellingParams {
+    value: string;
+    currency: string;
+}
+/**
+ * Details and a URL link for a valid off-ramp operation
+ * @public
+ * @category Types
+ */
+interface OffRampUrlResponse {
+    cashout_total: OffRampUrlResponseSellingParams;
+    cashout_subtotal: OffRampUrlResponseSellingParams;
+    sell_amount: OffRampUrlResponseSellingParams;
+    coinbase_fee: OffRampUrlResponseSellingParams;
+    quote_id: string;
+    offramp_url: string;
+}
+interface RampConfigPaymentMethod {
+    id: string;
+}
+interface RampConfigCountryWithMethods {
+    id: string;
+    subdivisions?: string[];
+    payment_methods?: RampConfigPaymentMethod[];
+}
+/**
+ * The list of countries and payment methods for on/off-ramp
+ * @public
+ * @category Types
+ */
+interface RampConfigResponse {
+    countries: RampConfigCountryWithMethods[];
+}
+
+/**
+ * Abstract base class for smart wallet implementations
+ *
+ * @internal
+ * @category Wallets
+ * @remarks
+ * Provides the interface for ERC-4337 compatible wallets
+ * Extended by concrete classes such as {@link DefaultSmartWallet}
+ */
+declare abstract class SmartWallet {
+    /** LocalAccount used for signing transactions on behalf of this smart wallet */
+    abstract signer: LocalAccount;
+    /**
+     * Returns the deployed or predicted address of this smart wallet
+     *
+     * @internal
+     * @category Addressing
+     * @remarks
+     * For undeployed wallets this returns the deterministic CREATE2 address
+     *
+     * @returns Promise resolving to the wallet Ethereum address
+     */
+    abstract getAddress(): Promise<Address>;
+    /**
+     * Retrieves balances for all supported tokens held by this smart wallet
+     *
+     * @internal
+     * @category Balances
+     * @returns Promise resolving to an array of {@link TokenBalance} entries
+     */
+    abstract getBalance(): Promise<TokenBalance[]>;
+    /**
+     * Executes a transaction through the smart wallet
+     *
+     * @internal
+     * @category Transactions
+     * @remarks
+     * Handles gas sponsorship and ERC-4337 UserOperation creation automatically
+     *
+     * @param transactionData Transaction data to execute
+     * @param chainId Target blockchain chain ID
+     * @returns Promise resolving to the transaction {@link Hash}
+     */
+    abstract send(transactionData: TransactionData, chainId: SupportedChainId): Promise<Hash>;
+    /**
+     * Executes a batch of transactions through the smart wallet
+     *
+     * @internal
+     * @category Transactions
+     * @remarks
+     * Transactions are executed in the order they are provided
+     * Handles gas sponsorship and ERC-4337 UserOperation creation automatically
+     *
+     * @param transactionData Array of transaction data objects
+     * @param chainId Target blockchain chain ID
+     * @returns Promise resolving to the transaction {@link Hash}
+     */
+    abstract sendBatch(transactionData: TransactionData[], chainId: SupportedChainId): Promise<Hash>;
+    /**
+     * Prepares transaction data for sending tokens to another address
+     *
+     * @internal
+     * @category Transactions
+     * @param amount Human-readable amount to send
+     * @param asset Token or asset identifier
+     * @param recipientAddress Destination address
+     * @returns Promise resolving to prepared {@link TransactionData}
+     */
+    abstract sendTokens(amount: number, asset: AssetIdentifier, recipientAddress: Address): Promise<TransactionData>;
+    /**
+     * Deposits funds into a selected protocol vault to start earning yield
+     *
+     * @internal
+     * @category Yield
+     * @param amount Amount to deposit in human-readable format
+     * @returns Promise resolving to a {@link VaultTxnResult}
+     */
+    abstract earn(amount: string): Promise<VaultTxnResult>;
+    /**
+     * Retrieves the balance of deposited funds in the selected protocol vault
+     *
+     * @internal
+     * @category Yield
+     * @returns Promise resolving to a {@link VaultBalance} or null if none
+     */
+    abstract getEarnBalance(): Promise<VaultBalance | null>;
+    /**
+     * Withdraws a specific amount of shares from the protocol vault
+     *
+     * @internal
+     * @category Yield
+     * @param amount Human-readable amount of shares to withdraw
+     * @returns Promise resolving to a {@link VaultTxnResult}
+     */
+    abstract withdraw(amount: string): Promise<VaultTxnResult>;
+    /**
+     * Funds the smart wallet with the specified amount of the specified token via Coinbase CDP on-ramp service
+     *
+     * @internal
+     * @category Ramp
+     *
+     * @remarks
+     * If Coinbase CDP is not initialized, the method will throw an error
+     *
+     * @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"`). To get the ful list, visit ""
+     * @param paymentCurrency Payment currency (e.g., `"USD"`, `"EUR"`). To get the ful list, visit ""
+     * @param paymentMethod Payment method (e.g., `"CARD"`). To get the ful list, visit ""
+     * @param chain Chain name (e.g., `"base"`)
+     * @param country Country code (e.g., `"US"`)
+     *
+     *
+     * @returns A URL string to the on-ramp service
+     */
+    abstract topUp(amount: string, redirectUrl: string, purchaseCurrency?: string, paymentCurrency?: string, paymentMethod?: string, country?: string): Promise<OnRampUrlResponse>;
+    /**
+     * @internal
+     * Cash out funds from the smart wallet to a specified currency via Coinbase CDP off-ramp service
+     * @category Ramp
+     *
+     * @param country
+     * @param paymentMethod
+     * @param redirectUrl
+     * @param sellAmount
+     * @param cashoutCurrency
+     * @param sellCurrency
+     * @returns A URL string to the off-ramp service
+     *
+     */
+    abstract cashOut(country: string, paymentMethod: string, redirectUrl: string, sellAmount: string, cashoutCurrency?: string, sellCurrency?: string): Promise<OffRampUrlResponse>;
+}
+
+/**
+ * Base Protocol
+ *
+ * @internal
+ * @abstract
+ * @category Protocols
+ * @remarks
+ * Abstract class defining the contract for protocol integrations (e.g. Spark, Beefy, Aave, Morpho)
+ * Provides lifecycle hooks (`init`) and required methods for vault discovery, deposit, withdrawal,
+ * and balance tracking
+ *
+ * Generic parameters allow protocol-specific typing for vault info, balances, and transaction results
+ */
+declare abstract class BaseProtocol<TVaultInfo extends VaultInfo = VaultInfo, TVaultBalance extends VaultBalance = VaultBalance, TVaultTxnResult extends VaultTxnResult = VaultTxnResult> {
+    /** Chain manager instance injected during initialization */
+    chainManager: ChainManager | undefined;
+    /**
+     * Initialize the protocol
+     * @param chainManager Chain manager for accessing RPC and bundler clients
+     */
+    abstract init(chainManager: ChainManager): Promise<void>;
+    /**
+     * Ensure the protocol has been initialized
+     * @throws Error if `init()` has not been called
+     */
+    protected ensureInitialized(): void;
+    /**
+     * Get all available vaults
+     * @returns List of vaults that support deposits
+     */
+    abstract getVaults(): Promise<TVaultInfo[]> | TVaultInfo[];
+    /**
+     * Get the best vault for deposits
+     * @returns Single vault considered optimal for deposit
+     */
+    abstract getBestVault(): Promise<TVaultInfo> | TVaultInfo;
+    /**
+     * Get a vault where funds may already be deposited
+     * @param smartWallet Wallet to check for existing deposits
+     * @returns Vault info if deposits exist, otherwise null
+     */
+    abstract fetchDepositedVaults(smartWallet: SmartWallet): Promise<TVaultInfo | null>;
+    /**
+     * Deposit funds into a vault
+     * @param amount Amount in human-readable format
+     * @param smartWallet Wallet executing the deposit
+     * @returns Result of the deposit transaction
+     */
+    abstract deposit(amount: string, smartWallet: SmartWallet): Promise<TVaultTxnResult>;
+    /**
+     * Withdraw funds from a vault
+     * @param amountInShares Amount of shares to withdraw
+     * @param smartWallet Wallet executing the withdrawal
+     * @returns Result of the withdrawal transaction
+     */
+    abstract withdraw(amountInShares: string, smartWallet: SmartWallet): Promise<TVaultTxnResult>;
+    /**
+     * Get deposited balance in a vault
+     * @param vaultInfo Vault info for a selected protocol
+     * @param walletAddress Wallet address to check the balance of
+     * @returns Balance of deposited funds
+     */
+    abstract getBalance(vaultInfo: TVaultInfo, walletAddress: Address): Promise<TVaultBalance>;
+    /**
+     * 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
+     */
+    protected approveToken(tokenAddress: Address, spenderAddress: Address, amount: bigint, chainId: SupportedChainId, account: LocalAccount): Promise<string>;
+    /**
+     * 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
+     */
+    protected checkAllowance(tokenAddress: Address, spenderAddress: Address, walletAddress: Address, chainId: SupportedChainId): Promise<bigint>;
+}
+
+/**
+ * Base information that can be used to identify a protocol
+ */
+interface ProtocolInfo {
+    id: string;
+    name: string;
+    website: string;
+    logo: string;
+    supportedChains: number[];
+    riskLevel: 'low' | 'medium' | 'high';
+    isPremium: boolean;
+}
+/**
+ * Interface with protocol information and instance object
+ */
+interface Protocol {
+    instance: BaseProtocol;
+    info: ProtocolInfo;
+}
+/**
+ * The protocols router config that defines which protocols should be used for an integrator
+ */
+interface ProtocolsRouterConfig {
+    riskLevel: 'low' | 'medium' | 'high';
+    minApy?: number;
+    apiKey?: string;
+}
+/**
+ * @internal
+ * The info about a protocol vault
+ * @category Types
+ * @remarks
+ * Generic type that shows the whole list of optional and mandatory fields for a protocol vault
+ */
+interface VaultInfo {
+    id: string;
+    chain: string;
+    chainId?: number;
+    depositTokenAddress: Address;
+    depositTokenDecimals: number;
+    depositTokenSymbol?: string;
+    vaultAddress: Address;
+    earnTokenAddress?: Address;
+    earnTokenDecimals?: number;
+    earnTokenSymbol?: string;
+    metadata?: Record<string, number | string>;
+}
+/**
+ * @public
+ * The info about current user's balance in a protocol vault
+ * @category Types
+ * @remarks
+ * The generic type that shows fields that should be present in a protocol vault balance
+ */
+interface VaultBalance {
+    /** amount of shares in a protocol vault based on a deposited amount */
+    shares: string;
+    /** amount of deposited tokens in a protocol vault (e.g. sUSDC)*/
+    depositedAmount: string;
+    /** info about a protocol vault where a user deposited funds */
+    vaultInfo: VaultInfo;
+}
+/**
+ * @public
+ * The result fields of a protocol vault related transaction
+ * @category Types
+ * @remarks
+ * The generic type that shows fields that should be present for each protocol vault related transaction
+ */
+interface VaultTxnResult {
+    /** hash of the operation */
+    hash: string;
+    /** if an operation is successful or not */
+    success: boolean;
+    /** error message if an operation is not successful */
+    error?: string;
+}
+
+interface SparkVaultInfo extends VaultInfo {
+    id: string;
+    chain: string;
+    earnTokenAddress: Address;
+    earnTokenDecimals: number;
+    depositTokenSymbol: string;
+    earnTokenSymbol: string;
+    metadata?: {
+        apy?: number;
+    };
+}
+/**
+ * @public
+ * The result of a Spark vault deposit or withdrawal transaction
+ * @category Types
+ */
+interface SparkVaultTxnResult {
+    /** the boolean value that indicates if the transaction was successful */
+    success: boolean;
+    /** hash of the operation */
+    hash: string;
+}
+/**
+ * @public
+ * The info about current user's balance in a Spark vault
+ * @category Types
+ */
+interface SparkVaultBalance {
+    /** amount of shares in sUSDC token that user has in the Spark vault */
+    shares: string;
+    /**
+     *  amount of deposited tokens + earned tokens
+     * @remarks
+     * To get the amount of earned tokens, you need to store all user's deposits and withdrawals
+     * on your side and then subtract the amount of deposited tokens from the `depositedAmount` */
+    depositedAmount: string;
+    /** detailed info about a Spark vault where a user deposited funds */
+    vaultInfo: SparkVaultInfo;
+}
+
+/**
+ * Abstract base class for smart wallet providers
+ *
+ * @internal
+ * @category Wallet Providers
+ * @remarks
+ * Defines the interface for factories that create and manage {@link SmartWallet} instances
+ * Extended by implementations such as {@link DefaultSmartWalletProvider}
+ */
+declare abstract class SmartWalletProvider$1 {
+    /**
+     * Creates a new smart wallet instance that will be deployed on first transaction
+     *
+     * @internal
+     * @category Creation
+     * @remarks
+     * Address is calculated deterministically using owners and nonce
+     *
+     * @param params Wallet creation parameters
+     * @param params.owners Array of wallet owners (addresses or WebAuthn accounts)
+     * @param params.signer Local account used for signing
+     * @param params.nonce Optional nonce for address derivation, default 0
+     * @returns Promise resolving to a {@link SmartWallet} instance
+     */
+    abstract createWallet(params: {
+        owners: Array<Address | WebAuthnAccount>;
+        signer: LocalAccount;
+        nonce?: bigint;
+    }): Promise<SmartWallet>;
+    /**
+     * Returns a smart wallet instance for an already deployed contract
+     *
+     * @internal
+     * @category Retrieval
+     * @remarks
+     * Use when the wallet address is already known
+     *
+     * @param params Wallet 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 in the owners list, default 0
+     * @returns A {@link SmartWallet} instance
+     */
+    abstract getWallet(params: {
+        walletAddress: Address;
+        signer: LocalAccount;
+        ownerIndex?: number;
+    }): SmartWallet;
+    /**
+     * Predicts the deterministic address of a smart wallet
+     *
+     * @internal
+     * @category Addressing
+     * @remarks
+     * Uses CREATE2 with owners and nonce to calculate the wallet address
+     *
+     * @param params Prediction parameters
+     * @param params.owners Array of wallet owners (addresses or WebAuthn accounts)
+     * @param params.nonce Optional nonce, default 0
+     * @returns Promise resolving to the predicted {@link Address}
+     */
+    abstract getWalletAddress(params: {
+        owners: Array<Address | WebAuthnAccount>;
+        nonce?: bigint;
+    }): Promise<Address>;
+}
+
+/**
+ * Abstract base class for embedded wallet implementations
+ *
+ * @internal
+ * @category Wallets
+ * @remarks
+ * Provides a standard interface for embedded wallets (Privy, Dynamic, etc.)
+ * Can be used as a signer for smart wallets when the embedded wallet is an owner
+ */
+declare abstract class EmbeddedWallet {
+    /** Ethereum address of the wallet */
+    readonly address: Address;
+    /** Optional provider-specific wallet identifier */
+    readonly walletId?: string;
+    /**
+     * Creates an embedded wallet instance
+     *
+     * @internal
+     * @param address Ethereum address of the wallet
+     * @param walletId Optional provider-specific identifier
+     */
+    constructor(address: Address, walletId?: string);
+    /**
+     * Returns a {@link LocalAccount} that can sign transactions and messages
+     *
+     * @internal
+     * @category Accounts
+     * @remarks
+     * Useful for smart wallet operations if the embedded wallet is included as an owner
+     *
+     * @returns Promise resolving to a {@link LocalAccount}
+     */
+    abstract account(): Promise<LocalAccount>;
+    /**
+     * Returns a {@link WalletClient} for interacting with contracts on a specific chain
+     *
+     * @internal
+     * @category Accounts
+     * @param chainId Target chain ID
+     * @returns Promise resolving to a {@link WalletClient} configured for the given chain
+     */
+    abstract walletClient(chainId: SupportedChainId): Promise<WalletClient>;
+}
+
+/**
+ * Abstract base class for embedded wallet providers
+ *
+ * @internal
+ * @category Wallet Providers
+ * @remarks
+ * Defines the interface for providers that manage {@link EmbeddedWallet} instances
+ * Extended by implementations such as {@link PrivyEmbeddedWalletProvider}
+ */
+declare abstract class EmbeddedWalletProvider {
+    /**
+     * Creates a new embedded wallet instance
+     *
+     * @internal
+     * @category Creation
+     * @remarks
+     * Uses the provider’s infrastructure to provision a new embedded wallet ready for signing
+     *
+     * @returns Promise resolving to a new {@link EmbeddedWallet}
+     */
+    abstract createWallet(): Promise<EmbeddedWallet>;
+    /**
+     * Retrieves an existing embedded wallet by its unique identifier
+     *
+     * @internal
+     * @category Retrieval
+     * @remarks
+     * The wallet must have been created previously through this provider
+     *
+     * @param params Wallet retrieval parameters
+     * @param params.walletId Unique identifier for the embedded wallet
+     * @returns Promise resolving to an {@link EmbeddedWallet}
+     * @throws Error if no wallet with the specified ID exists
+     */
+    abstract getWallet(params: {
+        walletId: string;
+    }): Promise<EmbeddedWallet>;
+}
+
+/**
+ * Options for creating a smart wallet
+ *  Parameters for creating a new smart wallet with specified owners and signer
+ */
+type CreateSmartWalletOptions = {
+    owners: Array<Address | WebAuthnAccount>;
+    signer: LocalAccount;
+    nonce?: bigint;
+};
+/**
+ * Options for creating a wallet with embedded signer
+ *  Parameters for creating both embedded and smart wallets, with embedded wallet automatically added as signer
+ */
+type CreateWalletWithEmbeddedSignerOptions = {
+    owners?: Array<Address | WebAuthnAccount>;
+    embeddedWalletIndex?: number;
+    nonce?: bigint;
+};
+/**
+ * Options for retrieving a smart wallet with provided signer
+ *  Parameters for getting an existing smart wallet using a provided LocalAccount signer
+ */
+type GetSmartWalletOptions = {
+    signer: LocalAccount;
+    deploymentOwners?: Array<Address | WebAuthnAccount>;
+    signerOwnerIndex?: number;
+    walletAddress?: Address;
+    nonce?: bigint;
+};
+/**
+ * Options for retrieving an embedded wallet
+ *  Parameters for getting an existing embedded wallet
+ */
+type GetEmbeddedWalletOptions = {
+    walletId: string;
+};
+/**
+ * Options for retrieving a smart wallet with embedded wallet signer
+ *  Parameters for getting an existing smart wallet using an embedded wallet as signer.
+ * If neither walletAddress nor deploymentOwners is provided, defaults to using the embedded wallet as single owner.
+ */
+type GetSmartWalletWithEmbeddedSignerOptions = Omit<GetSmartWalletOptions, 'signer'> & GetEmbeddedWalletOptions;
+
+/**
+ * Unified Wallet Provider class
+ *
+ * @internal
+ * @category Wallets
+ * @remarks
+ * Internal facade that composes an embedded wallet provider and a smart wallet provider
+ * and exposes higher-level creation/retrieval flows. Not exported from user's usage
+ *
+ * Used in a higher level class - {@link WalletNamespace}
+ *
+ * Typical flows:
+ * - Create embedded wallet only: {@link createEmbeddedWallet}
+ * - Create smart wallet only (you provide signer/owners): {@link createSmartWallet}
+ * - Create smart wallet with embedded wallet as signer: {@link createWalletWithEmbeddedSigner}
+ * - Get smart wallet using embedded wallet as signer: {@link getSmartWalletWithEmbeddedSigner}
+ * - Get smart wallet using a provided signer: {@link getSmartWallet}
+ */
+declare class WalletProvider {
+    /**
+     * Embedded wallet provider instance
+     * @internal
+     */
+    readonly embeddedWalletProvider: EmbeddedWalletProvider;
+    /**
+     * Smart wallet provider instance
+     * @internal
+     */
+    readonly smartWalletProvider: SmartWalletProvider$1;
+    /**
+     * Creates a unified wallet provider
+     *
+     * @internal
+     * @param embeddedWalletProvider Provider for embedded wallet operations
+     * @param smartWalletProvider Provider for smart wallet operations
+     */
+    constructor(embeddedWalletProvider: EmbeddedWalletProvider, smartWalletProvider: SmartWalletProvider$1);
+    /**
+     * 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}
+     */
+    createEmbeddedWallet(): Promise<EmbeddedWallet>;
+    /**
+     * 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}
+     */
+    createSmartWallet(params: CreateSmartWalletOptions): Promise<SmartWallet>;
+    /**
+     * 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}
+     */
+    createWalletWithEmbeddedSigner(params?: CreateWalletWithEmbeddedSignerOptions): Promise<SmartWallet>;
+    /**
+     * 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
+     */
+    getSmartWalletWithEmbeddedSigner(params: GetSmartWalletWithEmbeddedSignerOptions): Promise<SmartWallet>;
+    /**
+     * 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
+     */
+    getEmbeddedWallet(params: GetEmbeddedWalletOptions): Promise<EmbeddedWallet>;
+    /**
+     * 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
+     */
+    getSmartWallet(params: GetSmartWalletOptions): Promise<SmartWallet>;
+}
+
+/**
+ * Public wallet namespace that exposes unified wallet operations
+ *
+ * @public
+ * @category Wallets creation and retrieval
+ * @remarks
+ * This class is returned by {@link MyceliumSDK} and provides a simplified
+ * interface for wallet creation and retrieval. Advanced functionality can be accessed through
+ * the underlying providers via the getters {@link embeddedWalletProvider} and
+ * {@link smartWalletProvider}
+ *
+ * Typical flows:
+ * - Create embedded wallet only: {@link createEmbeddedWallet}
+ * - Create smart wallet only (you provide signer/owners): {@link createSmartWallet}
+ * - Create smart wallet with embedded as signer: {@link createWalletWithEmbeddedSigner}
+ * - Get smart wallet using embedded as signer: {@link getSmartWalletWithEmbeddedSigner}
+ * - Get smart wallet using a provided signer: {@link getSmartWallet}
+ */
+declare class WalletNamespace {
+    /**
+     * Internal provider facade that implements the actual logic
+     * @internal
+     */
+    private provider;
+    /**
+     * Creates a wallet namespace to manage embedded and smart wallets
+     * @param provider Unified provider that composes embedded & smart providers
+     */
+    constructor(provider: WalletProvider);
+    /**
+     * 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(): 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(): SmartWalletProvider$1;
+    /**
+     * 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}
+     */
+    createEmbeddedWallet(): Promise<EmbeddedWallet>;
+    /**
+     * 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}
+     */
+    createSmartWallet(params: CreateSmartWalletOptions): Promise<SmartWallet>;
+    /**
+     * 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}
+     */
+    createWalletWithEmbeddedSigner(params?: CreateWalletWithEmbeddedSignerOptions): Promise<SmartWallet>;
+    /**
+     * 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
+     */
+    getSmartWalletWithEmbeddedSigner(params: GetSmartWalletWithEmbeddedSignerOptions): Promise<SmartWallet>;
+    /**
+     * 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)
+     */
+    getEmbeddedWallet(params: GetEmbeddedWalletOptions): Promise<EmbeddedWallet>;
+    /**
+     * 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
+     */
+    getSmartWallet(params: GetSmartWalletOptions): Promise<SmartWallet>;
+}
+
+/**
+ * Mycelium SDK configuration
+ * Configuration object for initializing the Mycelium SDK
+ * @category Types
+ * @example
+ * ```ts
+ * {
+ *   walletsConfig: {
+ *     embeddedWalletConfig: {
+ *       provider: {
+ *         type: 'privy',
+ *         providerConfig: {
+ *           appId: process.env.NEXT_PUBLIC_PRIVY_APP_ID!,
+ *           appSecret: process.env.NEXT_PUBLIC_PRIVY_APP_SECRET!,
+ *         },
+ *       },
+ *     },
+ *     smartWalletConfig: {
+ *       provider: {
+ *         type: 'default',
+ *       },
+ *     },
+ *   },
+ *   chain: {
+ *     chainId: parseInt(process.env.NEXT_PUBLIC_CHAIN_ID!),
+ *     rpcUrl: process.env.NEXT_PUBLIC_RPC_URL!,
+ *     bundlerUrl: process.env.NEXT_PUBLIC_BUNDLER_URL!,
+ *   },
+ *   protocolsRouterConfig: {
+ *     riskLevel: 'low',
+ *   },
+ *   coinbaseCDPConfig: {
+ *     apiKeyId: process.env.NEXT_PUBLIC_COINBASE_CDP_API_KEY_ID!,
+ *     apiKeySecret: process.env.NEXT_PUBLIC_COINBASE_CDP_API_KEY_SECRET!,
+ *   },
+ * }
+ * ```
+ */
+interface MyceliumSDKConfig {
+    /**
+     * Wallet configuration
+     * @remarks
+     * Settings for embedded wallets and smart account providers. Currently support only Privy provider with their API keys
+     * */
+    walletsConfig: WalletConfig;
+    /**
+     * Unique identifier for the SDK integrator
+     * @remarks
+     * Used for Coinbase CDP API, and internally for tracking the usage of the SDK
+     */
+    integratorId: string;
+    /**
+     * Chains to use for the SDK
+     * @remarks
+     * If no rpcUrl, bundlerUrl and chain id are not provided, the SDK will use Base chain by default and its public RPC and Bundler URLs
+     * */
+    chain?: ChainConfig;
+    /**
+     * Protocols router configuration with different protocol based params
+     * @remarks
+     * If an integrator is not provided any requirements, `low` risk level protocols will be used by default
+     */
+    protocolsRouterConfig?: ProtocolsRouterConfig;
+    /**
+     * Coinbase CDP configuration
+     * @remarks
+     * The configuration is used to interact with Coinbase CDP API
+     * If the configuration is not provided, the Coinbase CDP functionality will be disabled.
+     * Calling all Coinbase CDP related methods will throw an error
+     * Currently used for on/off ramp functionality for a wallet
+     */
+    coinbaseCDPConfig?: CoinbaseCDPConfig;
+}
+/**
+ * Coinbase CDP configuration
+ * Configuration for Coinbase CDP API
+ * @see {@link https://docs.cdp.coinbase.com/api-reference/v2/introduction} Coinbase CDP API documentation
+ */
+interface CoinbaseCDPConfig {
+    /**
+     * Coinbase CDP API key ID   */
+    apiKeyId: string;
+    /**
+     * Coinbase CDP API key secret
+     */
+    apiKeySecret: string;
+}
+/**
+ * Wallet configuration
+ *  Configuration for wallet providers
+ */
+type WalletConfig = {
+    /** Embedded wallet configuration */
+    embeddedWalletConfig: EmbeddedWalletConfig;
+    /** Smart wallet configuration for ERC-4337 infrastructure */
+    smartWalletConfig: SmartWalletConfig;
+};
+/**
+ * Embedded wallet configuration
+ *  Configuration for embedded wallets / signers
+ */
+interface EmbeddedWalletConfig {
+    /** Wallet provider for account creation, management, and signing */
+    provider: EmbeddedWalletProviderConfig;
+}
+/**
+ * Smart Wallet configuration
+ *  Configuration for ERC-4337 smart wallets.
+ */
+interface SmartWalletConfig {
+    /** Wallet provider for smart wallet management */
+    provider: SmartWalletProvider;
+}
+/**
+ * Smart wallet provider configurations
+ *  Union type supporting multiple wallet provider implementations
+ */
+type SmartWalletProvider = DefaultSmartWalletProvider;
+/**
+ * Default smart wallet provider configuration
+ *  Built-in provider smart wallet provider.
+ */
+interface DefaultSmartWalletProvider {
+    type: 'default';
+}
+/**
+ * Embedded wallet provider configurations
+ *  Union type supporting multiple embedded wallet providers
+ */
+type EmbeddedWalletProviderConfig = PrivyEmbeddedWalletProviderConfig;
+/** Privy embedded wallet provider configuration */
+interface PrivyEmbeddedWalletProviderConfig {
+    /** Embedded wallet provider type */
+    type: 'privy';
+    /** Privy client provider config */
+    providerConfig: {
+        /** Privy params */
+        appId: string;
+        /** Privy party app secret */
+        appSecret: string;
+    };
+}
+
+declare class CoinbaseCDP {
+    private readonly apiKeyId;
+    private readonly apiKeySecret;
+    private readonly chainManager;
+    private readonly integratorId;
+    private readonly coinbaseCdpV2Hostname;
+    private readonly coinbaseCdpV1Hostname;
+    private readonly onRampUrlAuthParams;
+    private readonly onRampConfigAuthParams;
+    private readonly offRampUrlAuthParams;
+    private readonly offRampConfigAuthParams;
+    private readonly clientV2;
+    private readonly clientV1;
+    constructor(apiKeyId: string, apiKeySecret: string, integratorId: string, chainManager: ChainManager);
+    private verifyParameters;
+    /**
+     * @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
+     */
+    auth(authParams: CoinbaseCDPAuthParams): Promise<string>;
+    /**
+     * @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
+     */
+    getOnRampLink(receiverAddress: Address, redirectUrl: string, amount: string, purchaseCurrency?: string, paymentCurrency?: string, paymentMethod?: string, country?: string): Promise<OnRampUrlResponse>;
+    /**
+     * @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
+     */
+    getOnRampConfig(): Promise<RampConfigResponse>;
+    /**
+     * @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
+     */
+    getOffRampLink(address: Address, country: string, paymentMethod: string, redirectUrl: string, sellAmount: string, cashoutCurrency?: string, sellCurrency?: string): Promise<OffRampUrlResponse>;
+    /**
+     * @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
+     */
+    getOffRampConfig(): Promise<RampConfigResponse>;
+}
+
+/**
+ * Default ERC-4337 smart wallet implementation. Implements main methods that a user can use to interact with DeFi protocols and use all related functionalities
+ *
+ * @public
+ * @category Wallets operations
+ * @remarks
+ * Backed by Coinbase Smart Account and compatible with ERC-4337 UserOperations
+ * Supports multi-owner wallets (EVM addresses or WebAuthn owners), gas-sponsored flows,
+ * and cross-chain operations via {@link ChainManager}
+ */
+declare class DefaultSmartWallet extends SmartWallet {
+    /** Owners (EVM addresses or WebAuthn public keys) */
+    private owners;
+    /** Signer for transactions and UserOperations */
+    private _signer;
+    /** Index of signer within the owners array (undefined → default 0) */
+    private signerOwnerIndex?;
+    /** Known deployment address (if already deployed) */
+    private deploymentAddress?;
+    /** Network and client management */
+    private chainManager;
+    /** Nonce (salt) for deterministic address calculation */
+    private nonce?;
+    /** Selected protocol provider instance */
+    private protocolProvider;
+    /** Coinbase CDP instance to interact with Coinbase CDP API */
+    private coinbaseCDP;
+    /**
+     * 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: Array<Address | WebAuthnAccount>, signer: LocalAccount, chainManager: ChainManager, protocolProvider: Protocol['instance'], coinbaseCDP: CoinbaseCDP | null, deploymentAddress?: Address, signerOwnerIndex?: number, nonce?: bigint);
+    /**
+     * Returns the signer account for this smart wallet
+     *
+     * @public
+     * @category Account
+     * @remarks
+     * Used to authorize UserOperations and on-chain transactions
+     */
+    get signer(): LocalAccount;
+    /**
+     * 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
+     */
+    getAddress(): Promise<`0x${string}`>;
+    /**
+     * 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
+     */
+    getCoinbaseSmartAccount(chainId: SupportedChainId): ReturnType<typeof toCoinbaseSmartAccount>;
+    /**
+     * Fetches balances (ETH + ERC-20) for a smart account across supported chains
+     *
+     * @public
+     * @category Account
+     * @returns Promise resolving to a list of {@link TokenBalance}
+     */
+    getBalance(): Promise<TokenBalance[]>;
+    /**
+     * 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
+     */
+    earn(amount: string): Promise<VaultTxnResult>;
+    /**
+     * 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
+     */
+    getEarnBalance(): Promise<VaultBalance | null>;
+    /**
+     * 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
+     */
+    withdraw(amount: string): Promise<VaultTxnResult>;
+    /**
+     * 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
+     */
+    send(transactionData: TransactionData, chainId: SupportedChainId): Promise<Hash>;
+    /**
+     * 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
+     */
+    sendBatch(transactionData: TransactionData[], chainId: SupportedChainId): Promise<Hash>;
+    /**
+     * 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}
+     */
+    topUp(amount: string, redirectUrl: string, purchaseCurrency?: string, paymentCurrency?: string, paymentMethod?: string, country?: string): Promise<OnRampUrlResponse>;
+    /**
+     * 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}
+     */
+    cashOut(country: string, paymentMethod: string, redirectUrl: string, sellAmount: string, cashoutCurrency?: string, sellCurrency?: string): Promise<OffRampUrlResponse>;
+    /**
+     * 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
+     */
+    sendTokens(amount: number, asset: AssetIdentifier, recipientAddress: Address): Promise<TransactionData>;
+}
+
+/**
+ * Main SDK facade for integrating wallets and protocols.
+ *
+ * @public
+ * @category Get started
+ * @remarks
+ * This class encapsulates:
+ * - protocol selection and initialization (`Smart Router`),
+ * - chain/network management (`ChainManager`),
+ * - public wallet namespace (accessible through {@link MyceliumSDK.wallet | wallet}).
+ *
+ * By default, if no chain config is provided, it uses the public RPC
+ * and Bundler for the Base chain
+ *
+ * @example
+ * ```ts
+ * import { MyceliumSDK, type MyceliumSDKConfig } from '@mycelium-sdk/core';
+ *
+ * const config: MyceliumSDKConfig = {
+ *   walletsConfig: { /* ... *\/ },
+ *   protocolsRouterConfig: { /* ... *\/ },
+ *   chain: { /* ... *\/ },
+ *   coinbaseCDPConfig: { /* ... *\/ },
+ *   integratorId: 'MyceliumApp',
+ * };
+ *
+ * const sdk = new MyceliumSDK(config);
+ *
+ * const embeddedWallet = await sdk.wallet.createEmbeddedWallet();
+ * const wallet = await sdk.wallet.createSmartWallet({
+ *     owners: [embeddedWallet.address],
+ *     signer: await embeddedWallet.account(),
+ * })
+ * const balance = await wallet.getBalance();
+ * ```
+ */
+declare class MyceliumSDK {
+    /**
+     * Unified wallet namespace to manage embedded/smart wallets and related operations
+     * @public
+     * @category Wallets
+     */
+    readonly wallet: WalletNamespace;
+    /**
+     * Chain manager instance to manage chain related entities
+     * @internal
+     */
+    private _chainManager;
+    /** @internal */
+    private embeddedWalletProvider;
+    /** @internal */
+    private smartWalletProvider;
+    /**
+     * Protocol instance to perform earn related operations with a selected protocol
+     * @internal
+     */
+    private protocol;
+    /**
+     * 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
+     */
+    private coinbaseCDP;
+    /**
+     * 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: MyceliumSDKConfig);
+    /**
+     * Returns the chain manager instance for multi-chain operations
+     * @public
+     * @category Tools
+     *
+     * @returns ChainManager instance of the type {@link ChainManager}
+     */
+    get chainManager(): ChainManager;
+    /**
+     * Coinbase CDP configuration methods for ramp operations
+     * @public
+     * @category Tools
+     */
+    readonly 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: () => Promise<RampConfigResponse>;
+        /**
+         * 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: () => Promise<RampConfigResponse>;
+    };
+    /**
+     * 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}
+     */
+    private findProtocol;
+    /**
+     * 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
+     */
+    private createWalletProvider;
+    /**
+     * Creates the public wallet namespace
+     *
+     * @internal
+     * @param config Wallet configuration.
+     * @returns A {@link WalletNamespace} instance
+     */
+    private createWalletNamespace;
+}
+
+export { type OffRampUrlResponse as CashOutUrlResponse, DefaultSmartWallet, EmbeddedWallet, MyceliumSDK, type MyceliumSDKConfig, type RampConfigResponse, SmartWallet, type SparkVaultBalance, type SparkVaultTxnResult, type TokenBalance, type OnRampUrlResponse as TopUpUrlResponse, type VaultBalance, type VaultTxnResult, WalletNamespace };