edwin-sdk/dist/index.d.mts

SDK for integrating AI agents with DeFi protocols

import { Chain as Chain$1, Address, PublicClient, HttpTransport, Account, WalletClient, PrivateKeyAccount } from 'viem';
import * as viemChains from 'viem/chains';
import { providers, ethers } from 'ethers';
import * as zod from 'zod';
import { ZodSchema, z } from 'zod';
import { PublicKey, Commitment, Connection, Transaction, VersionedTransaction, Keypair, Finality } from '@solana/web3.js';
import { LbPosition, PositionInfo, BinLiquidity } from '@meteora-ag/dlmm';
import { QuoteResponse } from '@jup-ag/api';
import * as _langchain_core_tools from '@langchain/core/tools';

declare abstract class EdwinWallet {
    abstract getAddress(): string;
    /**
     * Get balance of current wallet
     */
    abstract getBalance(): Promise<number>;
    /**
     * Get balance of any wallet address
     * @param walletAddress Address of the wallet to check
     */
    abstract getBalanceOfWallet(walletAddress: string, ...args: unknown[]): Promise<number>;
}

declare const _SupportedEVMChainList: Array<keyof typeof viemChains>;
/**
 * EVM wallet with read-only capabilities (no signing)
 */
declare class EdwinEVMPublicKeyWallet extends EdwinWallet {
    private currentChain;
    chains: Record<string, Chain$1>;
    protected walletAddress: Address;
    constructor(publicKey: Address);
    getAddress(): Address;
    getCurrentChain(): Chain$1;
    getPublicClient(chainName: SupportedEVMChain): PublicClient<HttpTransport, Chain$1, Account | undefined>;
    getChainConfigs(chainName: SupportedEVMChain): Chain$1;
    getBalance(): Promise<number>;
    getWalletBalanceForChain(chainName: SupportedEVMChain): Promise<string | null>;
    addChain(chain: Record<string, Chain$1>): void;
    switchChain(chainName: SupportedEVMChain, customRpcUrl?: string): void;
    private setChains;
    private setCurrentChain;
    protected createHttpTransport: (chainName: SupportedEVMChain) => HttpTransport<undefined, false>;
    static genChainFromName(chainName: string, customRpcUrl?: string | null): Chain$1;
    /**
     * Get token balance for a specific token address on a given chain
     * @param chainName The chain name (e.g., 'base', 'mainnet')
     * @param tokenAddress The token contract address or symbol
     * @returns Formatted token balance as a string
     */
    getTokenBalance(chainName: SupportedEVMChain, tokenAddress: `0x${string}`): Promise<string>;
    /**
     * Get balance of any wallet address on any EVM chain
     * @param walletAddress The wallet address to check
     * @param chainName The chain to query (e.g., 'mainnet', 'base', etc)
     * @param tokenAddress Optional ERC20 token address (if not provided, returns native token balance)
     * @returns Balance of the wallet
     */
    getBalanceOfWallet(walletAddress: Address, chainName?: SupportedEVMChain, tokenAddress?: `0x${string}`): Promise<number>;
}

/**
 * @param type
 * @param id - Chain ID, optional for EVM
 */
type Chain = EvmChain | SolanaChain;
type EvmChain = {
    type: 'evm';
    id: number;
};
type SolanaChain = {
    type: 'solana';
};

type SupportedEVMChain = (typeof _SupportedEVMChainList)[number];
type SupportedChain = SupportedEVMChain | 'solana';

interface EdwinTool<TSchema extends ZodSchema = ZodSchema> {
    name: string;
    description: string;
    schema: TSchema;
    execute: (params: TSchema['_output']) => Promise<unknown>;
}

/**
 * EVM wallet that has full capabilities including transaction signing
 */
declare class EdwinEVMWallet extends EdwinEVMPublicKeyWallet {
    private account;
    private evmPrivateKey;
    constructor(privateKey: `0x${string}`);
    /**
     * Get the wallet client for a specific chain
     */
    getWalletClient(chainName: SupportedEVMChain): WalletClient;
    /**
     * Get an ethers.js wallet instance
     */
    getEthersWallet(walletClient: WalletClient, provider: providers.JsonRpcProvider): ethers.Wallet;
    /**
     * Get the account (private key)
     */
    getSigner(): PrivateKeyAccount;
}

/**
 * Interface for a signing capable Solana wallet client in Edwin
 */
interface SolanaWalletClient {
    /**
     * The wallet's public key
     */
    readonly publicKey: PublicKey;
    /**
     * Get a Solana connection instance
     * @param customRpcUrl Optional custom RPC URL
     * @param commitment Optional commitment level
     * @returns Connection instance
     */
    getConnection(customRpcUrl?: string, commitment?: Commitment): Connection;
    /**
     * Get the wallet address as a string
     * @returns Wallet address as base58 string
     */
    getAddress(): string;
    /**
     * Get balance of the wallet in SOL or a specific token
     * @param mintAddress Optional token mint address. If not provided, returns SOL balance.
     * @param commitment Optional commitment level
     * @returns The balance as a number
     */
    getBalance(mintAddress?: string, commitment?: Commitment): Promise<number>;
    /**
     * Get balance of any wallet address
     * @param walletAddress Address of the wallet to check
     * @param mintAddress Optional token mint address. If not provided, returns SOL balance.
     * @param commitment Optional commitment level
     * @returns The balance as a number
     */
    getBalanceOfWallet(walletAddress: string, mintAddress?: string, commitment?: Commitment): Promise<number>;
    /**
     * Get token mint address by symbol
     * @param symbol Token symbol to look up
     * @returns Token mint address or null if not found
     */
    getTokenAddress?(symbol: string): Promise<string | null>;
    /**
     * Sign a transaction
     * @param transaction Transaction to sign
     * @returns Signed transaction
     */
    signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T>;
    /**
     * Sign multiple transactions
     * @param transactions Transactions to sign
     * @returns Signed transactions
     */
    signAllTransactions<T extends Transaction | VersionedTransaction>(transactions: T[]): Promise<T[]>;
    /**
     * Sign a message
     * @param message Message to sign as Uint8Array
     * @returns Signature as Uint8Array
     */
    signMessage(message: Uint8Array): Promise<Uint8Array>;
    /**
     * Send a transaction
     * @param connection Solana connection to use
     * @param transaction Transaction to send (can be Transaction or VersionedTransaction)
     * @param signers Optional additional signers
     * @returns Transaction signature
     */
    sendTransaction<T extends Transaction | VersionedTransaction>(connection: Connection, transaction: T, signers?: Keypair[]): Promise<string>;
    /**
     * Get balance changes for a token from a transaction
     * @param signature Transaction signature
     * @param mint Token mint address
     * @param commitment Optional commitment level
     * @returns The balance change as a number
     */
    getTransactionTokenBalanceChange(signature: string, mint: string, commitment?: Commitment): Promise<number>;
}

/**
 * Base class for Solana wallet clients with common functionality
 */
declare abstract class BaseSolanaWalletClient implements SolanaWalletClient {
    /**
     * The wallet's public key
     */
    readonly publicKey: PublicKey;
    constructor(publicKey: string | PublicKey);
    /**
     * Get wallet address as string
     */
    getAddress(): string;
    /**
     * Get Solana connection
     */
    getConnection(customRpcUrl?: string, commitment?: Commitment): Connection;
    /**
     * Get token address by symbol
     */
    getTokenAddress(symbol: string): Promise<string | null>;
    /**
     * Get balance of the current wallet
     */
    getBalance(mintAddress?: string, commitment?: Commitment): Promise<number>;
    /**
     * Get balance of any wallet
     */
    getBalanceOfWallet(walletAddress: string, mintAddress?: string, commitment?: Commitment): Promise<number>;
    /**
     * Get token balance change from a transaction
     */
    getTransactionTokenBalanceChange(signature: string, mint: string, commitment?: Finality): Promise<number>;
    abstract signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T>;
    abstract signAllTransactions<T extends Transaction | VersionedTransaction>(transactions: T[]): Promise<T[]>;
    abstract signMessage(message: Uint8Array): Promise<Uint8Array>;
    abstract sendTransaction<T extends Transaction | VersionedTransaction>(connection: Connection, transaction: T, signers?: Keypair[]): Promise<string>;
    abstract waitForConfirmationGracefully(connection: Connection, signature: string, timeout?: number): Promise<{
        err: unknown;
        confirmationStatus?: 'confirmed' | 'finalized' | 'processed';
    }>;
}

interface SignatureStatus {
    err: unknown;
    confirmationStatus?: 'confirmed' | 'finalized' | 'processed';
}
/**
 * Solana wallet client that uses a Keypair for signing
 */
declare class KeypairClient extends BaseSolanaWalletClient {
    private keypair;
    constructor(privateKey: string);
    /**
     * Get the underlying Keypair
     */
    getKeypair(): Keypair;
    /**
     * Sign a transaction with the wallet's keypair
     */
    signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T>;
    /**
     * Sign multiple transactions with the wallet's keypair
     */
    signAllTransactions<T extends Transaction | VersionedTransaction>(transactions: T[]): Promise<T[]>;
    /**
     * Sign a message with the wallet's keypair
     * Note: This is a simplified implementation for compatibility
     */
    signMessage(_message: Uint8Array): Promise<Uint8Array>;
    /**
     * Wait for transaction confirmation
     */
    waitForConfirmationGracefully(connection: Connection, signature: string, timeout?: number): Promise<SignatureStatus>;
    /**
     * Send a transaction using Jito's low latency transaction send API.
     * Supports both legacy Transaction and VersionedTransaction.
     */
    sendTransaction<T extends Transaction | VersionedTransaction>(connection: Connection, transaction: T, signers?: Keypair[]): Promise<string>;
    /**
     * Prepare a versioned transaction for sending
     */
    private prepareVersionedTransaction;
    /**
     * Prepare a legacy transaction for sending
     */
    private prepareLegacyTransaction;
    /**
     * Send transaction via Jito API
     */
    private sendViaJito;
}

/**
 * Phantom provider interface
 */
interface PhantomProvider {
    solana: {
        publicKey: PublicKey;
        signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T>;
        signAllTransactions<T extends Transaction | VersionedTransaction>(transactions: T[]): Promise<T[]>;
        signMessage(message: Uint8Array): Promise<{
            signature: Uint8Array;
        }>;
        sendTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<string>;
        connect(): Promise<{
            publicKey: PublicKey;
        }>;
        disconnect(): Promise<void>;
    };
    isConnected: boolean;
    show(): void;
}
/**
 * Client for interacting with Solana through Phantom wallet
 */
declare class PhantomClient extends BaseSolanaWalletClient {
    private provider;
    constructor(provider: PhantomProvider);
    /**
     * Sign a transaction using Phantom wallet
     */
    signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T>;
    /**
     * Sign multiple transactions using Phantom wallet
     */
    signAllTransactions<T extends Transaction | VersionedTransaction>(transactions: T[]): Promise<T[]>;
    /**
     * Sign a message using Phantom wallet
     */
    signMessage(message: Uint8Array): Promise<Uint8Array>;
    /**
     * Send a transaction using Phantom wallet
     * Note: In Phantom's case, we don't need Connection or additional signers
     * as Phantom handles the sending internally
     */
    sendTransaction<T extends Transaction | VersionedTransaction>(_connection: Connection, transaction: T, _signers?: Keypair[]): Promise<string>;
    /**
     * Wait for transaction confirmation
     */
    waitForConfirmationGracefully(connection: Connection, signature: string, timeout?: number): Promise<{
        err: unknown;
        confirmationStatus?: 'confirmed' | 'finalized' | 'processed';
    }>;
}

/**
 * Read-only Solana wallet client that can only perform operations that don't require signing
 */
declare class PublicKeyClient extends BaseSolanaWalletClient {
    constructor(publicKey: string | PublicKey);
    /**
     * Not supported in public key client - throws error
     */
    signTransaction<T extends Transaction | VersionedTransaction>(_transaction: T): Promise<T>;
    /**
     * Not supported in public key client - throws error
     */
    signAllTransactions<T extends Transaction | VersionedTransaction>(_transactions: T[]): Promise<T[]>;
    /**
     * Not supported in public key client - throws error
     */
    signMessage(_message: Uint8Array): Promise<Uint8Array>;
    /**
     * Not supported in public key client - throws error
     */
    sendTransaction<T extends Transaction | VersionedTransaction>(_connection: Connection, _transaction: T, _signers?: Keypair[]): Promise<string>;
    /**
     * Not supported in public key client - throws error
     */
    waitForConfirmationGracefully(_connection: Connection, _signature: string, _timeout?: number): Promise<{
        err: unknown;
        confirmationStatus?: 'confirmed' | 'finalized' | 'processed';
    }>;
}

/**
 * Factory functions for creating Solana wallet clients
 */
declare const SolanaWalletFactory: {
    /**
     * Create a KeypairClient from a private key
     * @param privateKey Base58-encoded private key string
     * @returns Keypair wallet client instance
     */
    fromPrivateKey(privateKey: string): KeypairClient;
    /**
     * Create a PublicKeyClient from a public key
     * @param publicKey PublicKey object or base58-encoded string
     * @returns PublicKey wallet client for read-only operations
     */
    fromPublicKey(publicKey: string | PublicKey): PublicKeyClient;
    /**
     * Create a PhantomClient from a Phantom provider
     * @param provider Phantom wallet provider instance
     * @returns Phantom wallet client instance
     */
    fromPhantom(provider: PhantomProvider): PhantomClient;
};

declare abstract class EdwinService {
}

declare abstract class EdwinPlugin {
    protected name: string;
    protected toolProviders: EdwinService[];
    private tools;
    constructor(name: string, toolProviders: EdwinService[]);
    protected getToolsArray(): EdwinTool[];
    /**
     * Get all tools provided by this plugin
     */
    abstract getTools(): Record<string, EdwinTool>;
    /**
     * Get tools that don't require signing capabilities
     */
    abstract getPublicTools(): Record<string, EdwinTool>;
    /**
     * Get tools that require signing capabilities
     */
    abstract getPrivateTools(): Record<string, EdwinTool>;
}

declare class AavePlugin extends EdwinPlugin {
    constructor(wallet: EdwinEVMWallet);
    getTools(): Record<string, EdwinTool>;
    getPublicTools(): Record<string, EdwinTool>;
    getPrivateTools(): Record<string, EdwinTool>;
    supportsChain: (chain: Chain) => chain is EvmChain;
}
declare const aave: (wallet: EdwinEVMWallet) => AavePlugin;

/**
 * Represents a parameter schema with both validation and type information
 */
interface ParameterSchema<T extends z.ZodSchema> {
    /** The Zod schema for validation */
    schema: T;
    /** Type information for TypeScript (used for type inference) */
    type: z.infer<T>;
}

declare const SupplyParametersSchema$1: ParameterSchema<z.ZodObject<{
    chain: z.ZodString;
    asset: z.ZodString;
    amount: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    chain: string;
    asset: string;
    amount: number;
}, {
    chain: string;
    asset: string;
    amount: number;
}>>;
declare const WithdrawParametersSchema$1: ParameterSchema<z.ZodObject<{
    chain: z.ZodString;
    asset: z.ZodString;
    amount: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    chain: string;
    asset: string;
    amount: number;
}, {
    chain: string;
    asset: string;
    amount: number;
}>>;
type SupplyParameters$1 = typeof SupplyParametersSchema$1.type;
type WithdrawParameters$2 = typeof WithdrawParametersSchema$1.type;

declare class AaveService extends EdwinService {
    supportedChains: SupportedChain[];
    private wallet;
    constructor(wallet: EdwinEVMWallet);
    getPortfolio(): Promise<string>;
    private getAaveChain;
    /**
     * Set up the Aave pool and necessary wallet connections
     */
    private setupPool;
    /**
     * Execute transactions and handle results
     */
    private executeTransactions;
    private getAddressBook;
    private submitTransaction;
    supply(params: SupplyParameters$1): Promise<string>;
    withdraw(params: WithdrawParameters$2): Promise<string>;
}

declare class LidoPlugin extends EdwinPlugin {
    constructor(wallet: EdwinEVMWallet);
    getTools(): Record<string, EdwinTool>;
    getPublicTools(): Record<string, EdwinTool>;
    getPrivateTools(): Record<string, EdwinTool>;
    supportsChain: (chain: Chain) => chain is EvmChain;
}
declare const lido: (wallet: EdwinEVMWallet) => LidoPlugin;

declare const StakeParametersSchema: ParameterSchema<z.ZodObject<{
    asset: z.ZodString;
    amount: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    asset: string;
    amount: number;
}, {
    asset: string;
    amount: number;
}>>;
type StakeParameters = typeof StakeParametersSchema.type;

declare class LidoProtocol extends EdwinService {
    private wallet;
    constructor(wallet: EdwinEVMWallet);
    supportedChains: SupportedChain[];
    getPortfolio(): Promise<string>;
    stake(params: StakeParameters): Promise<string>;
    unstake(params: StakeParameters): Promise<string>;
    claimRewards(params: StakeParameters): Promise<string>;
}

declare class LuloPlugin extends EdwinPlugin {
    constructor(wallet: SolanaWalletClient);
    getTools(): Record<string, EdwinTool>;
    getPublicTools(): Record<string, EdwinTool>;
    getPrivateTools(): Record<string, EdwinTool>;
    supportsChain: (chain: Chain) => chain is SolanaChain;
}
declare const lulo: (wallet: SolanaWalletClient) => LuloPlugin;

declare const SupplyParametersSchema: ParameterSchema<z.ZodObject<{
    asset: z.ZodString;
    amount: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    asset: string;
    amount: number;
}, {
    asset: string;
    amount: number;
}>>;
declare const WithdrawParametersSchema: ParameterSchema<z.ZodObject<{
    asset: z.ZodString;
    amount: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    asset: string;
    amount: number;
}, {
    asset: string;
    amount: number;
}>>;
type SupplyParameters = typeof SupplyParametersSchema.type;
type WithdrawParameters$1 = typeof WithdrawParametersSchema.type;

declare class LuloProtocol {
    supportedChains: SupportedChain[];
    private wallet;
    constructor(wallet: SolanaWalletClient);
    getPortfolio(): Promise<string>;
    supply(params: SupplyParameters): Promise<string>;
    withdraw(params: WithdrawParameters$1): Promise<string>;
}

declare class MeteoraPlugin extends EdwinPlugin {
    constructor(wallet: SolanaWalletClient);
    getTools(): Record<string, EdwinTool>;
    getPublicTools(): Record<string, EdwinTool>;
    getPrivateTools(): Record<string, EdwinTool>;
    supportsChain: (chain: Chain) => chain is SolanaChain;
}
declare const meteora: (wallet: SolanaWalletClient) => MeteoraPlugin;

declare const AddLiquidityParametersSchema: ParameterSchema<z.ZodObject<{
    amount: z.ZodString;
    amountB: z.ZodString;
    poolAddress: z.ZodString;
    rangeInterval: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
}, "strip", z.ZodTypeAny, {
    amount: string;
    amountB: string;
    poolAddress: string;
    rangeInterval?: number | null | undefined;
}, {
    amount: string;
    amountB: string;
    poolAddress: string;
    rangeInterval?: number | null | undefined;
}>>;
declare const RemoveLiquidityParametersSchema: ParameterSchema<z.ZodObject<{
    poolAddress: z.ZodString;
    positionAddress: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    shouldClosePosition: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
}, "strip", z.ZodTypeAny, {
    poolAddress: string;
    positionAddress?: string | null | undefined;
    shouldClosePosition?: boolean | null | undefined;
}, {
    poolAddress: string;
    positionAddress?: string | null | undefined;
    shouldClosePosition?: boolean | null | undefined;
}>>;
declare const PoolParametersSchema: ParameterSchema<z.ZodObject<{
    poolAddress: z.ZodString;
}, "strip", z.ZodTypeAny, {
    poolAddress: string;
}, {
    poolAddress: string;
}>>;
declare const GetPoolsParametersSchema: ParameterSchema<z.ZodObject<{
    asset: z.ZodString;
    assetB: z.ZodString;
}, "strip", z.ZodTypeAny, {
    asset: string;
    assetB: string;
}, {
    asset: string;
    assetB: string;
}>>;
type AddLiquidityParameters = typeof AddLiquidityParametersSchema.type;
type RemoveLiquidityParameters = typeof RemoveLiquidityParametersSchema.type;
type PoolParameters = typeof PoolParametersSchema.type;
type GetPoolsParameters = typeof GetPoolsParametersSchema.type;

interface MeteoraPoolOutput {
    address: string;
    name: string;
    bin_step: number;
    base_fee_percentage: string;
    max_fee_percentage: string;
    protocol_fee_percentage: string;
    liquidity: string;
    fees_24h: number;
    trade_volume_24h: number;
    current_price: number;
    apr_percentage: number;
}
interface Position {
    address: string;
    pair_address: string;
}
declare class MeteoraProtocol {
    private static readonly BASE_URL;
    private wallet;
    constructor(wallet: SolanaWalletClient);
    getPortfolio(): Promise<string>;
    getPositionInfo(positionAddress: string): Promise<Position>;
    getPools(params: GetPoolsParameters): Promise<MeteoraPoolOutput[]>;
    getPositionsFromPool(params: PoolParameters): Promise<Array<LbPosition>>;
    getPositions(): Promise<Map<string, PositionInfo>>;
    getActiveBin(params: PoolParameters): Promise<BinLiquidity>;
    /**
     * Helper method for adding liquidity to a Meteora pool
     * @returns Transaction signature
     */
    private innerAddLiquidity;
    addLiquidity(params: AddLiquidityParameters): Promise<string>;
    /**
     * Get position information from a transaction hash
     * @param txHash The transaction hash/signature from the addLiquidity operation
     * @returns Position address and liquidity added
     */
    getPositionInfoFromTransaction(txHash: string): Promise<{
        positionAddress: string;
        liquidityAdded: [number, number];
    }>;
    claimFees(params: PoolParameters): Promise<string>;
    removeLiquidity(params: RemoveLiquidityParameters): Promise<{
        liquidityRemoved: [number, number];
        feesClaimed: [number, number];
    }>;
}

declare class UniswapPlugin extends EdwinPlugin {
    constructor(wallet: EdwinEVMWallet);
    getTools(): Record<string, EdwinTool>;
    getPublicTools(): Record<string, EdwinTool>;
    getPrivateTools(): Record<string, EdwinTool>;
    supportsChain: (chain: Chain) => chain is EvmChain;
}
declare const uniswap: (wallet: EdwinEVMWallet) => UniswapPlugin;

declare const LiquidityParametersSchema: ParameterSchema<z.ZodObject<{
    chain: z.ZodString;
    asset: z.ZodString;
    assetB: z.ZodString;
    amount: z.ZodNumber;
    amountB: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    chain: string;
    asset: string;
    amount: number;
    amountB: number;
    assetB: string;
}, {
    chain: string;
    asset: string;
    amount: number;
    amountB: number;
    assetB: string;
}>>;
type LiquidityParameters = typeof LiquidityParametersSchema.type;

declare class UniswapProtocol extends EdwinService {
    supportedChains: SupportedChain[];
    private wallet;
    constructor(wallet: EdwinEVMWallet);
    getPortfolio(): Promise<string>;
    swap(params: LiquidityParameters): Promise<number>;
    addLiquidity(params: LiquidityParameters): Promise<{
        liquidityAdded: [number, number];
    }>;
    removeLiquidity(params: LiquidityParameters): Promise<{
        liquidityRemoved: [number, number];
        feesClaimed: [number, number];
    }>;
    getQuote(params: LiquidityParameters): Promise<string>;
}

declare class JupiterPlugin extends EdwinPlugin {
    constructor(wallet: SolanaWalletClient);
    getTools(): Record<string, EdwinTool>;
    getPublicTools(): Record<string, EdwinTool>;
    getPrivateTools(): Record<string, EdwinTool>;
    supportsChain: (chain: Chain) => chain is SolanaChain;
}
declare const jupiter: (wallet: SolanaWalletClient) => JupiterPlugin;

declare const SwapParametersSchema: ParameterSchema<z.ZodObject<{
    inputMint: z.ZodString;
    outputMint: z.ZodString;
    amount: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
}, "strip", z.ZodTypeAny, {
    amount: string | number;
    inputMint: string;
    outputMint: string;
}, {
    amount: string | number;
    inputMint: string;
    outputMint: string;
}>>;
type SwapParameters = typeof SwapParametersSchema.type;

interface JupiterQuoteParameters {
    inputMint: string;
    outputMint: string;
    amount: string | number;
    slippageBps?: number;
}
declare class JupiterService {
    supportedChains: SupportedChain[];
    TOKEN_LIST_URL: string;
    JUPITER_QUOTE_API_URL: string;
    private wallet;
    constructor(wallet: SolanaWalletClient);
    swap(params: SwapParameters): Promise<string>;
    getQuote(params: JupiterQuoteParameters): Promise<QuoteResponse>;
    getSerializedTransaction(quote: QuoteResponse, walletAddress: string): Promise<{
        swapTransaction: string;
    }>;
    /**
     * Get swap details from transaction hash
     * @param txHash The transaction hash/signature
     * @param outputMint The output token mint address
     * @returns Amount of output tokens received
     */
    getSwapDetailsFromTransaction(txHash: string, outputMint: string): Promise<number>;
    /**
     * Gets the token mint address for a given ticker symbol
     * @param ticker The token ticker/symbol to lookup (case-sensitive)
     * @returns The mint address or null if not found
     */
    getTokenAddressFromTicker(ticker: string): Promise<string | null>;
}

declare class CookiePlugin extends EdwinPlugin {
    constructor(apiKey: string);
    getTools(): Record<string, EdwinTool>;
    getPublicTools(): Record<string, EdwinTool>;
    getPrivateTools(): Record<string, EdwinTool>;
    supportsChain: (_: Chain) => boolean;
}
declare const cookie: (apiKey: string) => CookiePlugin;

declare const AgentParametersSchema: ParameterSchema<z.ZodObject<{
    username: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    contractAddress: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    interval: z.ZodEnum<["_3Days", "_7Days"]>;
    page: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    pageSize: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
}, "strip", z.ZodTypeAny, {
    interval: "_3Days" | "_7Days";
    contractAddress?: string | null | undefined;
    username?: string | null | undefined;
    page?: number | null | undefined;
    pageSize?: number | null | undefined;
}, {
    interval: "_3Days" | "_7Days";
    contractAddress?: string | null | undefined;
    username?: string | null | undefined;
    page?: number | null | undefined;
    pageSize?: number | null | undefined;
}>>;
type AgentParameters = typeof AgentParametersSchema.type;

declare class CookieSwarmClient {
    private apiKey;
    private baseUrl;
    supportedChains: SupportedChain[];
    constructor(apiKey: string);
    private fetch;
    getAgentByTwitter(params: AgentParameters): Promise<string>;
    getAgentByContract(params: AgentParameters): Promise<string>;
    getAgentsPaged(params: AgentParameters): Promise<string>;
}

declare class EOraclePlugin extends EdwinPlugin {
    constructor(apiKey: string);
    getTools(): Record<string, EdwinTool>;
    getPublicTools(): Record<string, EdwinTool>;
    getPrivateTools(): Record<string, EdwinTool>;
    supportsChain: (chain: Chain) => chain is EvmChain;
}
declare const eoracle: (apiKey: string) => EOraclePlugin;

declare class EOracleService extends EdwinService {
    private apiKey;
    private baseUrl;
    private feedCache;
    supportedChains: SupportedChain[];
    constructor(apiKey: string);
    private fetch;
    private getFeedId;
    getPrice(symbol: string): Promise<string>;
}

declare class StoryProtocolPlugin extends EdwinPlugin {
    constructor(wallet: EdwinEVMWallet);
    getTools(): Record<string, EdwinTool>;
    getPublicTools(): Record<string, EdwinTool>;
    getPrivateTools(): Record<string, EdwinTool>;
    supportsChain: (chain: Chain) => chain is EvmChain;
}
declare const storyprotocol: (wallet: EdwinEVMWallet) => StoryProtocolPlugin;

declare const RegisterIPAssetParametersSchema: ParameterSchema<z.ZodObject<{
    name: z.ZodString;
    description: z.ZodString;
    mediaUrl: z.ZodString;
    contentHash: z.ZodString;
    externalUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    name: string;
    description: string;
    mediaUrl: string;
    contentHash: string;
    externalUrl?: string | null | undefined;
}, {
    name: string;
    description: string;
    mediaUrl: string;
    contentHash: string;
    externalUrl?: string | null | undefined;
}>>;
declare const AttachTermsParametersSchema: ParameterSchema<z.ZodObject<{
    ipId: z.ZodString;
    termsUrl: z.ZodString;
    termsHash: z.ZodString;
    royaltyPercentage: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    ipId: string;
    termsUrl: string;
    termsHash: string;
    royaltyPercentage: number;
}, {
    ipId: string;
    termsUrl: string;
    termsHash: string;
    royaltyPercentage: number;
}>>;
declare const MintLicenseTokenParametersSchema: ParameterSchema<z.ZodObject<{
    ipId: z.ZodString;
    licenseTermsUrl: z.ZodString;
    licenseTermsHash: z.ZodString;
    mintTo: z.ZodString;
}, "strip", z.ZodTypeAny, {
    ipId: string;
    licenseTermsUrl: string;
    licenseTermsHash: string;
    mintTo: string;
}, {
    ipId: string;
    licenseTermsUrl: string;
    licenseTermsHash: string;
    mintTo: string;
}>>;
declare const RegisterDerivativeParametersSchema: ParameterSchema<z.ZodObject<{
    parentIpId: z.ZodString;
    name: z.ZodString;
    description: z.ZodString;
    mediaUrl: z.ZodString;
    contentHash: z.ZodString;
    externalUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    isCommercial: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    name: string;
    description: string;
    mediaUrl: string;
    contentHash: string;
    parentIpId: string;
    isCommercial: boolean;
    externalUrl?: string | null | undefined;
}, {
    name: string;
    description: string;
    mediaUrl: string;
    contentHash: string;
    parentIpId: string;
    isCommercial: boolean;
    externalUrl?: string | null | undefined;
}>>;
declare const PayIPAssetParametersSchema: ParameterSchema<z.ZodObject<{
    ipId: z.ZodString;
    amount: z.ZodString;
}, "strip", z.ZodTypeAny, {
    amount: string;
    ipId: string;
}, {
    amount: string;
    ipId: string;
}>>;
declare const ClaimRevenueParametersSchema: ParameterSchema<z.ZodObject<{
    ipId: z.ZodString;
}, "strip", z.ZodTypeAny, {
    ipId: string;
}, {
    ipId: string;
}>>;
type RegisterIPAssetParameters = typeof RegisterIPAssetParametersSchema.type;
type AttachTermsParameters = typeof AttachTermsParametersSchema.type;
type MintLicenseTokenParameters = typeof MintLicenseTokenParametersSchema.type;
type RegisterDerivativeParameters = typeof RegisterDerivativeParametersSchema.type;
type PayIPAssetParameters = typeof PayIPAssetParametersSchema.type;
type ClaimRevenueParameters = typeof ClaimRevenueParametersSchema.type;

declare class StoryProtocolService {
    supportedChains: SupportedChain[];
    private wallet;
    private client;
    private nftContractAddress;
    private spgNftContractAddress;
    constructor(wallet: EdwinEVMWallet);
    registerIPAsset(params: RegisterIPAssetParameters): Promise<string>;
    attachTerms(params: AttachTermsParameters): Promise<{
        success: boolean;
        txHash: string;
    }>;
    mintLicenseToken(params: MintLicenseTokenParameters): Promise<{
        success: boolean;
        txHash: string;
        tokenId: string;
    }>;
    registerDerivative(params: RegisterDerivativeParameters): Promise<string>;
    payIPAsset(params: PayIPAssetParameters): Promise<string>;
    claimRevenue(params: ClaimRevenueParameters): Promise<string>;
}

/**
 * HyperLiquid plugin for Edwin
 */
declare class HyperLiquidPlugin extends EdwinPlugin {
    constructor();
    getTools(): Record<string, EdwinTool>;
    getPublicTools(): Record<string, EdwinTool>;
    getPrivateTools(): Record<string, EdwinTool>;
}
declare const hyperliquid: HyperLiquidPlugin;

/**
 * Supported order types for HyperLiquid
 */
declare enum OrderType {
    MARKET = "market",
    LIMIT = "limit"
}
/**
 * Supported position types for HyperLiquid
 */
declare enum PositionType {
    LONG = "long",
    SHORT = "short"
}
/**
 * Parameters for depositing funds to HyperLiquid
 */
declare const DepositParameters: z.ZodObject<{
    /**
     * Amount to deposit
     */
    amount: z.ZodNumber;
    /**
     * Asset to deposit (e.g., 'ETH', 'USDC')
     */
    asset: z.ZodString;
}, "strip", z.ZodTypeAny, {
    asset: string;
    amount: number;
}, {
    asset: string;
    amount: number;
}>;
/**
 * Type definition for deposit parameters
 */
type DepositParametersType = z.infer<typeof DepositParameters>;
/**
 * Parameters for withdrawing funds from HyperLiquid
 */
declare const WithdrawParameters: z.ZodObject<{
    /**
     * Amount to withdraw
     */
    amount: z.ZodNumber;
    /**
     * Asset to withdraw (e.g., 'ETH', 'USDC')
     */
    asset: z.ZodString;
}, "strip", z.ZodTypeAny, {
    asset: string;
    amount: number;
}, {
    asset: string;
    amount: number;
}>;
/**
 * Type definition for withdraw parameters
 */
type WithdrawParametersType = z.infer<typeof WithdrawParameters>;
/**
 * Parameters for opening a position on HyperLiquid
 */
declare const OpenPositionParameters: z.ZodObject<{
    /**
     * Asset to trade (e.g., 'BTC', 'ETH')
     */
    asset: z.ZodString;
    /**
     * Position type (long or short)
     */
    positionType: z.ZodNativeEnum<typeof PositionType>;
    /**
     * Order type (market or limit)
     */
    orderType: z.ZodNativeEnum<typeof OrderType>;
    /**
     * Size of the position in USD
     */
    size: z.ZodNumber;
    /**
     * Leverage to use (e.g., 1, 2, 5, 10, 20)
     */
    leverage: z.ZodDefault<z.ZodNumber>;
    /**
     * Limit price (required for limit orders)
     */
    price: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    /**
     * Whether to reduce only (close position)
     */
    reduceOnly: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    size: number;
    asset: string;
    positionType: PositionType;
    orderType: OrderType;
    leverage: number;
    reduceOnly: boolean;
    price?: number | null | undefined;
}, {
    size: number;
    asset: string;
    positionType: PositionType;
    orderType: OrderType;
    leverage?: number | undefined;
    price?: number | null | undefined;
    reduceOnly?: boolean | undefined;
}>;
/**
 * Type definition for open position parameters
 */
type OpenPositionParametersType = z.infer<typeof OpenPositionParameters>;
/**
 * Parameters for closing a position on HyperLiquid
 */
declare const ClosePositionParameters: z.ZodObject<{
    /**
     * Asset to close position for (e.g., 'BTC', 'ETH')
     */
    asset: z.ZodString;
    /**
     * Order type (market or limit)
     */
    orderType: z.ZodNativeEnum<typeof OrderType>;
    /**
     * Percentage of position to close (0-100)
     */
    percentage: z.ZodDefault<z.ZodNumber>;
    /**
     * Limit price (required for limit orders)
     */
    price: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
}, "strip", z.ZodTypeAny, {
    asset: string;
    orderType: OrderType;
    percentage: number;
    price?: number | null | undefined;
}, {
    asset: string;
    orderType: OrderType;
    price?: number | null | undefined;
    percentage?: number | undefined;
}>;
/**
 * Type definition for close position parameters
 */
type ClosePositionParametersType = z.infer<typeof ClosePositionParameters>;

/**
 * Service for interacting with the HyperLiquid protocol
 */
declare class HyperLiquidService extends EdwinService {
    private wallet;
    private exchange;
    private hyperliquid;
    /**
     * Creates a new HyperLiquidService
     * @param wallet - The EVM wallet to use for transactions
     */
    constructor(wallet: EdwinEVMWallet);
    /**
     * Deposits funds to HyperLiquid
     * @param params - Deposit parameters
     * @returns Transaction result
     */
    deposit(params: DepositParametersType): Promise<Record<string, unknown>>;
    /**
     * Withdraws funds from HyperLiquid
     * @param params - Withdrawal parameters
     * @returns Transaction result
     */
    withdraw(params: WithdrawParametersType): Promise<Record<string, unknown>>;
    /**
     * Opens a position on HyperLiquid
     * @param params - Open position parameters
     * @returns Order result
     */
    openPosition(params: OpenPositionParametersType): Promise<Record<string, unknown>>;
    /**
     * Closes a position on HyperLiquid
     * @param params - Close position parameters
     * @returns Order result
     */
    closePosition(params: ClosePositionParametersType): Promise<Record<string, unknown>>;
    /**
     * Gets the current balance on HyperLiquid
     * @returns Balance information
     */
    getBalance(): Promise<Record<string, unknown>>;
    /**
     * Gets open positions on HyperLiquid
     * @returns List of open positions
     */
    getPositions(): Promise<Record<string, unknown>[]>;
    /**
     * Sets up authentication for the exchange
     * @param privateKey - The private key to use for authentication
     */
    private setupAuthentication;
}

declare class MendiPlugin extends EdwinPlugin {
    constructor(wallet: EdwinEVMWallet);
    getTools(): Record<string, EdwinTool>;
    getPublicTools(): Record<string, EdwinTool>;
    getPrivateTools(): Record<string, EdwinTool>;
    supportsChain: (chain: Chain) => chain is EvmChain;
}

declare class DexScreenerPlugin extends EdwinPlugin {
    constructor();
    getTools(): Record<string, EdwinTool>;
    getPublicTools(): Record<string, EdwinTool>;
    getPrivateTools(): Record<string, EdwinTool>;
    supportsChain: (_chain: Chain) => boolean;
}

declare class EVMWalletPlugin extends EdwinPlugin {
    constructor(wallet: EdwinEVMPublicKeyWallet);
    getTools(): Record<string, EdwinTool>;
    getPublicTools(): Record<string, EdwinTool>;
    getPrivateTools(): Record<string, EdwinTool>;
    supportsChain: (chain: Chain) => chain is EvmChain;
}

declare class SolanaWalletPlugin extends EdwinPlugin {
    constructor(wallet: SolanaWalletClient);
    getTools(): Record<string, EdwinTool>;
    getPublicTools(): Record<string, EdwinTool>;
    getPrivateTools(): Record<string, EdwinTool>;
    supportsChain: (chain: Chain) => chain is SolanaChain;
}

/**
 * Plugin for interacting with Silo Finance protocol
 */
declare class SiloPlugin extends EdwinPlugin {
    constructor(wallet: EdwinEVMWallet);
    getTools(): Record<string, EdwinTool>;
    getPublicTools(): Record<string, EdwinTool>;
    getPrivateTools(): Record<string, EdwinTool>;
    supportsChain: (chain: Chain) => chain is EvmChain;
}

interface EdwinConfig {
    evmPrivateKey?: `0x${string}`;
    evmPublicKey?: `0x${string}`;
    solanaClient?: SolanaWalletClient;
}
interface EdwinWallets {
    evm?: EdwinEVMPublicKeyWallet;
    solana?: SolanaWalletClient;
}
interface EdwinPlugins {
    aave?: AavePlugin;
    lido?: LidoPlugin;
    uniswap?: UniswapPlugin;
    lulo?: LuloPlugin;
    meteora?: MeteoraPlugin;
    jupiter?: JupiterPlugin;
    cookie?: CookiePlugin;
    eoracle?: EOraclePlugin;
    storyprotocol?: StoryProtocolPlugin;
    mendi?: MendiPlugin;
    dexscreener?: DexScreenerPlugin;
    evmWallet?: EVMWalletPlugin;
    solanaWallet?: SolanaWalletPlugin;
    silo?: SiloPlugin;
}
declare class Edwin {
    wallets: EdwinWallets;
    plugins: EdwinPlugins;
    constructor(config: EdwinConfig);
    getTools(): Promise<Record<string, EdwinTool>>;
    /**
     * Checks if the wallet has signing capabilities for a specific plugin
     * @param plugin The plugin to check
     * @returns true if the wallet has signing capabilities for the plugin, false otherwise
     */
    private hasSigningCapabilitiesForPlugin;
    getPortfolio(): Promise<string>;
}

/**
 * Generates a tool parameters prompt from a tool and template
 * @param tool - The EdwinTool containing the schema
 * @returns The populated tool parameters prompt
 */
declare function generateToolParametersPrompt(tool: EdwinTool): string;

type GetEdwinToolsParams = {
    edwin: Edwin;
};
/**
 * Creates LangChain tools from a list of Edwin plugins
 */
declare function getLangchainToolsFromPlugins(plugins: EdwinPlugin[]): _langchain_core_tools.DynamicStructuredTool<zod.ZodType<any, zod.ZodTypeDef, any>, any, any, string>[];
/**
 * Converts Edwin actions to Langchain tools
 */
declare function getLangchainToolsFromEdwin({ edwin }: GetEdwinToolsParams): Promise<_langchain_core_tools.DynamicStructuredTool<zod.ZodType<any, zod.ZodTypeDef, any>, any, any, string>[]>;

type GetMcpToolsParams = {
    edwin: Edwin;
};
/**
 * Error class for MCP server errors
 */
declare class McpServerError extends Error {
    readonly statusCode: number;
    readonly details: unknown;
    constructor(message: string, statusCode?: number, details?: unknown);
}
/**
 * Converts Edwin tools to MCP format
 */
declare function getMcpToolsFromEdwin({ edwin }: GetMcpToolsParams): Promise<{
    name: string;
    description: string;
    parameters: any;
    execute: (args: unknown) => Promise<{
        content: {
            type: "text";
            text: string;
        }[];
        isError?: undefined;
    } | {
        isError: boolean;
        content: {
            type: "text";
            text: string;
        }[];
    }>;
}[]>;

export { AaveService, BaseSolanaWalletClient, type Chain, CookieSwarmClient, EOracleService, Edwin, type EdwinConfig, EdwinEVMWallet, type EdwinTool, EdwinWallet, type EvmChain, type GetEdwinToolsParams, type GetMcpToolsParams, HyperLiquidService, JupiterService, KeypairClient, LidoProtocol, LuloProtocol, McpServerError, MeteoraProtocol, PublicKeyClient, type SolanaChain, type SolanaWalletClient, SolanaWalletFactory, StoryProtocolService, type SupportedChain, type SupportedEVMChain, UniswapPlugin, UniswapProtocol, aave, cookie, eoracle, generateToolParametersPrompt, getLangchainToolsFromEdwin, getLangchainToolsFromPlugins, getMcpToolsFromEdwin, hyperliquid, jupiter, lido, lulo, meteora, storyprotocol, uniswap };