Elytro Wallet

Ethereum EIP-4337 smart contract wallet for agents. Supports gasless transactions, 2FA security hooks, and email OTP.

• Repo: https://github.com/Elytro-eth/Elytro
• Install: npm install -g @elytro/cli (requires Node >=24)

RULES — Read before every action

1. Never guess on-chain data. Always run the appropriate elytro query command to fetch balances, transaction status, token holdings, etc. Do NOT infer or assume values.
2. Always ask the user before confirming interactive prompts using Inline Buttons. When any command outputs (y/N) or similar, STOP and present the user with Telegram Inline Buttons for confirmation (e.g., "Confirm", "Cancel" or "Approve", "Reject"). Example: elytro tx send shows "Sign and send this transaction? (y/N)" — pause and send an Inline Button message to the user with callback options instead of asking for text input. ALL confirmations must use Inline Buttons, never text input.
3. Use Inline Buttons for all list displays. Whenever displaying lists (account list, token list, balance details, transaction history, etc.), render each item as a clickable Inline Button with callback_data pointing to that item's action. Example: for account selection, create buttons like [{"text": "myWallet (0x...)", "callback_data": "account_select_myWallet"}] instead of showing plain text and asking the user to type.
4. Chain IDs are hex or decimal. Common values: Ethereum mainnet=1, Sepolia testnet=0xaa36a7 (=11155111), Base=8453, Arbitrum=42161.
5. value in tx specs is always in ETH, not wei.
6. Smart accounts must be deployed before sending transactions. Check elytro account info <account> → "Deployed: Yes" before sending. If not deployed, run elytro account activate <account> first.
7. Use alias or address interchangeably wherever <account> appears.
8. Inline Button Convention for Other Agents: All agents reading this skill must adhere to the following callback_data naming scheme for consistency:

• Confirmations: confirm_yes, confirm_no, confirm_cancel
• Account selection: account_select_<alias_or_address>
• Token selection: token_select_<tokenAddress>
• Transaction approval: tx_approve, tx_reject, tx_simulate
• Action menu: action_<action_name> (e.g., action_send, action_swap, action_balance_check)
• This ensures all agents can parse and understand callbacks across the entire Elytro workflow ecosystem.

1. Default Menu on Ambiguous Intent. When the user opens or mentions the wallet without a specific action (e.g., "打开钱包", "open wallet", "show elytro", "check my wallet"), do NOT ask what they want. Instead, immediately display the Main Menu as Inline Buttons. Each button leads to a sub-menu or action flow as defined in the Navigation Flow Map below.

Navigation Flow Map (Inline Button UI)

All navigation screens below must be rendered using Inline Buttons. When the user clicks a button, the agent proceeds to the corresponding sub-screen. Every sub-screen includes a "⬅️ Back" button to return to the parent menu.

Level 0 — Main Menu (default entry point)

Trigger: user says anything ambiguous like "open wallet", "打开钱包", "elytro", "我的钱包", etc.

Agent must first run elytro account list silently in the background, then render:

json
{
  "text": "💎 Elytro Wallet\n\nWelcome! What would you like to do?",
  "reply_markup": {
    "inline_keyboard": [
      [
        { "text": "👛 My Accounts", "callback_data": "menu_accounts" },
        { "text": "💰 Check Balance", "callback_data": "menu_balance" }
      ],
      [
        { "text": "💸 Send", "callback_data": "menu_send" },
        { "text": "🔄 Swap", "callback_data": "menu_swap" }
      ],
      [
        { "text": "🔐 Security / 2FA", "callback_data": "menu_security" },
        { "text": "⚙️ Settings", "callback_data": "menu_settings" }
      ],
      [
        { "text": "➕ Create New Account", "callback_data": "action_create_account" }
      ]
    ]
  }
}

Level 1 — Sub-menus

menu_accounts → Run elytro account list, render each account as a button:

json
{
  "text": "👛 Your Accounts:",
  "reply_markup": {
    "inline_keyboard": [
      [{ "text": "myWallet (0x1234...5678) - Sepolia ✅", "callback_data": "account_select_myWallet" }],
      [{ "text": "tradingBot (0x8765...4321) - Base ⏳", "callback_data": "account_select_tradingBot" }],
      [{ "text": "➕ Create New Account", "callback_data": "action_create_account" }],
      [{ "text": "⬅️ Back", "callback_data": "menu_main" }]
    ]
  }
}

• ✅ = deployed, ⏳ = not yet deployed
• Upon account_select_<alias> callback → run elytro account info <alias> and display account detail with action buttons:

json
{
  "text": "👛 myWallet\n📍 Sepolia (0xaa36a7)\n🏷 0x1234...5678\n✅ Deployed\n💎 0.5 ETH",
  "reply_markup": {
    "inline_keyboard": [
      [
        { "text": "💸 Send", "callback_data": "action_send_from_myWallet" },
        { "text": "💰 Tokens", "callback_data": "action_tokens_myWallet" }
      ],
      [
        { "text": "🔄 Swap", "callback_data": "action_swap_from_myWallet" },
        { "text": "🔐 Security", "callback_data": "menu_security" }
      ],
      [{ "text": "⬅️ Back", "callback_data": "menu_accounts" }]
    ]
  }
}

menu_balance → If multiple accounts, show account selector first (same as menu_accounts but callback leads to balance view). If only one account, go straight to balance display with action buttons (as defined in the "Query" section below).

menu_send → If multiple accounts, show account selector (callback: action_send_from_<alias>). Then prompt for recipient address and amount using the confirmation Inline Button flow (tx summary → Approve / Reject / Simulate).

menu_swap → Invoke the Uniswap swap-planner skill. If multiple accounts, show account selector first.

menu_security → Run elytro security status, display:

json
{
  "text": "🔐 Security Status\n\n2FA: Installed ✅\nEmail OTP: user@example.com\nSpending Limit: $100/day",
  "reply_markup": {
    "inline_keyboard": [
      [
        { "text": "Install/Uninstall 2FA", "callback_data": "action_2fa_toggle" },
        { "text": "Change Email", "callback_data": "action_email_change" }
      ],
      [
        { "text": "Set Spending Limit", "callback_data": "action_spending_limit" }
      ],
      [{ "text": "⬅️ Back", "callback_data": "menu_main" }]
    ]
  }
}

menu_settings → Run elytro config show, display:

json
{
  "text": "⚙️ Configuration\n\nAlchemy Key: ✅ Set\nPimlico Key: ❌ Not set\nActive Account: myWallet",
  "reply_markup": {
    "inline_keyboard": [
      [
        { "text": "Set Alchemy Key", "callback_data": "action_set_alchemy" },
        { "text": "Set Pimlico Key", "callback_data": "action_set_pimlico" }
      ],
      [
        { "text": "Switch Account", "callback_data": "menu_accounts" }
      ],
      [{ "text": "⬅️ Back", "callback_data": "menu_main" }]
    ]
  }
}

menu_main → Return to Level 0 Main Menu.

Navigation Rules for Agents

1. Always show the Main Menu when user intent is ambiguous. Do not ask "what do you want to do?" — show the menu.
2. Every sub-screen must include a "⬅️ Back" button (callback_data: parent menu ID, e.g., menu_main, menu_accounts).
3. Fetching real data is mandatory before rendering. Run the corresponding elytro CLI command to get live data (accounts, balances, security status, config), then render buttons with actual values. Never use placeholder data in production.
4. Multi-step flows (e.g., Send ETH): guide the user through each step using successive Inline Button screens: account selection → recipient input → amount input → tx summary with Approve/Reject/Simulate.
5. Callback routing: parse the callback_data prefix to determine the handler:

• menu_* → render the corresponding sub-menu
• account_select_* → fetch and show account details
• token_select_* → fetch and show token details
• action_* → execute the corresponding action or start an action flow
• tx_* → handle transaction lifecycle (approve, reject, simulate)
• confirm_* → handle generic yes/no/cancel prompts

Setup (first-time)

bash
# 1. Initialize wallet (once per machine)
elytro init

# 2. Create a smart account on a chain
elytro account create --chain <chainId> --alias <alias>
# Example: elytro account create --chain 0xaa36a7 --alias myWallet

# 3. Deploy the smart contract on-chain (gasless by default)
elytro account activate <alias-or-address>

Account Management

bash
elytro account list                        # List all accounts
elytro account list --chain <chainId>      # Filter by chain
elytro account info <account>              # On-chain details (balance, deployed status, etc.)
elytro account switch <account>            # Set active account

Inline Button Display for Account List: After running elytro account list, render results as Inline Buttons instead of plain text. Example:

json
{
  "text": "Select an account to manage:",
  "reply_markup": {
    "inline_keyboard": [
      [
        { "text": "myWallet (0x1234...5678) - Sepolia", "callback_data": "account_select_myWallet" },
        { "text": "tradingBot (0x8765...4321) - Base", "callback_data": "account_select_tradingBot" }
      ],
      [
        { "text": "➕ Create New Account", "callback_data": "action_create_account" }
      ]
    ]
  }
}

Upon callback (e.g., account_select_myWallet), fetch account details via elytro account info and present next actions (send, check balance, swap, etc.) also as Inline Buttons.

Query (read-only, no confirmation needed)

bash
# ETH balance — ALWAYS run this; never guess the balance
elytro query balance <account>

# ERC-20 token balance
elytro query balance --token <tokenAddress> <account>

# All ERC-20 holdings
elytro query tokens <account>

# Transaction status by hash
elytro query tx <hash>

# Current chain info
elytro query chain

Inline Button Display for Balance & Token Lists:

When displaying balances or token holdings, format as Inline Buttons for quick action:

Example balance display with action buttons:

json
{
  "text": "💰 Account: myWallet\n\n💎 ETH: 0.5 ETH (~$1,200)\n🪙 USDC: 2,000 USDC\n🌈 DAI: 1,500 DAI",
  "reply_markup": {
    "inline_keyboard": [
      [
        { "text": "💸 Send ETH", "callback_data": "action_send_eth" },
        { "text": "🔄 Swap", "callback_data": "action_swap" }
      ],
      [
        { "text": "🪙 Select Token", "callback_data": "action_select_token" },
        { "text": "📊 History", "callback_data": "action_history" }
      ],
      [
        { "text": "🔐 Security", "callback_data": "action_security" }
      ]
    ]
  }
}

Token selection example:

json
{
  "text": "Select a token to view or manage:",
  "reply_markup": {
    "inline_keyboard": [
      [
        { "text": "ETH (0.5)", "callback_data": "token_select_ETH" },
        { "text": "USDC (2000)", "callback_data": "token_select_0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" }
      ],
      [
        { "text": "DAI (1500)", "callback_data": "token_select_0x6B175474E89094C44Da98b954EedeAC495271d0F" }
      ]
    ]
  }
}

Multi-Step Action Flows

Send ETH / Token Flow (Inline Button Driven)

Step 1: Account Selection (if multiple accounts exist)

• Render menu_accounts buttons.
• Upon account_select_<alias> callback, proceed to Step 2.

Step 2: Recipient Input

• Send a message to the user requesting recipient address.
• User replies with address.
• Agent validates the address and proceeds to Step 3.

Step 3: Amount Input

• Send a message requesting the amount to send.
• User replies with amount.
• Agent validates the amount against account balance and proceeds to Step 4.

Step 4: Transaction Summary & Approval

• Render the tx summary as Inline Buttons (Approve, Reject, Simulate):

json
{
  "text": "📋 Transaction Summary\n\n💰 Account: myWallet\n📤 To: 0xabcd...ef01\n💵 Amount: 0.1 ETH\n⛽ Gas: ~0.001 ETH (sponsored)\n\nProceed?",
  "reply_markup": {
    "inline_keyboard": [
      [
        { "text": "✅ Approve", "callback_data": "tx_approve" },
        { "text": "❌ Reject", "callback_data": "tx_reject" }
      ],
      [
        { "text": "🔍 Simulate First", "callback_data": "tx_simulate" }
      ],
      [
        { "text": "⬅️ Back", "callback_data": "menu_send" }
      ]
    ]
  }
}

Step 5: Execution

• Upon tx_approve callback, run elytro tx send and report result.
• Upon tx_reject callback, abort and return to Main Menu.
• Upon tx_simulate callback, run elytro tx simulate, show gas estimate and paymaster availability, then re-display approval buttons.

Swap Flow (Inline Button Driven)

Step 1: Account Selection (if multiple accounts exist)

• Render menu_accounts buttons.
• Upon account_select_<alias> callback, proceed to Step 2.

Step 2: Token Pair Selection

• Render token list as Inline Buttons for "From" token.
• Upon token_select_<fromToken> callback, render list for "To" token.
• Upon second token_select_<toToken> callback, proceed to Step 3.

Step 3: Amount Input

• Request swap amount from user (text input).
• User replies with amount.
• Proceed to Step 4.

Step 4: Price & Route Preview (via swap-planner)

• Invoke Uniswap swap-planner skill to fetch live price.
• Display swap route and estimated output:

json
{
  "text": "🔄 Swap Preview\n\n💵 From: 0.5 ETH\n💎 To: ~1,200 USDC\n📊 Price: 1 ETH = 2400 USDC\n⛽ Gas: ~0.001 ETH (sponsored)\n\nReady to swap?",
  "reply_markup": {
    "inline_keyboard": [
      [
        { "text": "✅ Confirm Swap", "callback_data": "tx_approve" },
        { "text": "❌ Cancel", "callback_data": "tx_reject" }
      ],
      [
        { "text": "⬅️ Adjust Amount", "callback_data": "menu_swap" }
      ]
    ]
  }
}

Step 5: Execution

• Upon tx_approve callback, open the Uniswap link (via open command) for user to confirm in-wallet.
• Report completion or error.

Transactions

Send (requires user confirmation)

bash
# ⚠ STOP before confirming — ask the user first!
elytro tx send --tx "to:<address>,value:<ethAmount>,data:<hex>"

# Multiple calls in one UserOp (batched)
elytro tx send --tx "to:0xA,value:0.1,data:0x" --tx "to:0xB,value:0,data:0xcafe"

# Skip sponsorship (user pays gas)
elytro tx send --no-sponsor --tx "to:<address>,value:<ethAmount>,data:0x"

# Skip 2FA hook check
elytro tx send --no-hook --tx "to:<address>,value:<ethAmount>,data:0x"

# Send a pre-built UserOp
elytro tx send --userop '<userOpJson>'

Simulate (safe, no confirmation)

bash
# Preview gas estimate and sponsor check without sending
elytro tx simulate --tx "to:<address>,value:<ethAmount>,data:<hex>"

Build unsigned UserOp (no send)

bash
elytro tx build --tx "to:<address>,value:<ethAmount>,data:<hex>" <account>

Token Swaps (via Uniswap)

Elytro does not have a built-in swap command. To swap tokens, use the Uniswap swap-planner skill to generate a deep link, then open it — the user connects their Elytro wallet inside the Uniswap interface to confirm.

Required skill

skill: uniswap-driver / swap-planner
source: https://github.com/Uniswap/uniswap-ai/blob/main/packages/plugins/uniswap-driver/skills/swap-planner/SKILL.md

Invoke it via slash command or describe the intent:

/swap-planner

or simply say (contextual activation):

Swap 0.1 ETH for USDC on Base

Swap workflow

1. Invoke swap-planner skill — gather token pair, amount, and chain.
2. Skill generates a Uniswap deep link, e.g.:

https://app.uniswap.org/swap?chain=base&inputCurrency=NATIVE&outputCurrency=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913&value=0.1&field=INPUT

1. Open the link in the browser (open <url> on macOS, xdg-open <url> on Linux).
2. User connects their Elytro wallet in the Uniswap interface (WalletConnect or injected provider).
3. User reviews and confirms the swap inside Uniswap — do NOT auto-confirm on their behalf.

Rules for swaps

• Never guess swap output amounts. The swap-planner skill fetches live prices via DexScreener/DefiLlama — always use it.
• Always verify token addresses before building the link. Scam tokens often mimic legitimate names.
• Disclose slippage and liquidity risk surfaced by the swap-planner skill before opening the URL.
• Elytro is ERC-4337 compatible with the Uniswap interface — no special configuration needed.

Example

bash
# 1. User: "Swap 0.5 ETH for USDC on Arbitrum"
# 2. Invoke swap-planner — it resolves addresses, fetches price, generates link
# 3. Open link
open "https://app.uniswap.org/swap?chain=arbitrum&inputCurrency=NATIVE&outputCurrency=0xaf88d065e77c8cC2239327C5EDb3A432268e5831&value=0.5&field=INPUT"
# 4. Tell user: connect Elytro wallet in the Uniswap tab, review, and confirm.

Security / 2FA

bash
# View current security status
elytro security status

# Install SecurityHook (2FA)
elytro security 2fa install --capability 2     # 1=SIGNATURE_ONLY, 2=USER_OP_ONLY, 3=BOTH

# Uninstall SecurityHook
elytro security 2fa uninstall
elytro security 2fa uninstall --force          # Start force-uninstall countdown
elytro security 2fa uninstall --execute        # Execute after safety delay

# Email OTP
elytro security email bind <email>             # Bind email for OTP delivery
elytro security email change <email>           # Change bound email

# Spending limit (USD/day)
elytro security spending-limit                 # View current limit
elytro security spending-limit 100             # Set to $100/day

Configuration

bash
elytro config show                             # Show current endpoint config
elytro config set alchemy-key <apiKey>         # Set Alchemy API key
elytro config set pimlico-key <apiKey>         # Set Pimlico API key
elytro config remove alchemy-key               # Remove key, revert to public endpoint
elytro config remove pimlico-key

Common Workflows

Check ETH balance

bash
elytro query balance <account>
# Returns JSON: { "result": { "balance": "0.01", "symbol": "ETH", ... } }

Send ETH to an address

bash
# Step 1: Simulate first (optional but recommended)
elytro tx simulate --tx "to:<toAddress>,value:<amount>,data:0x"

# Step 2: Send — PAUSE at confirmation prompt, ask user before proceeding
elytro tx send --tx "to:<toAddress>,value:<amount>,data:0x"

First-time full setup on Sepolia

bash
elytro init
elytro account create --chain 0xaa36a7 --alias myWallet
elytro account activate myWallet
elytro account info myWallet    # Verify Deployed: Yes

Confirmation Prompt Protocol (Inline Button Version)

Some commands are interactive and will pause for user input. All confirmations MUST use Telegram Inline Buttons, never plain text prompts.

| Command | Prompt | Action | |---------|--------|--------| | tx send | Sign and send this transaction? (y/N) | Send Inline Buttons: Approve (callback_data: tx_approve), Reject (callback_data: tx_reject), Simulate First (callback_data: tx_simulate) | | account activate | activation confirmation | Send Inline Buttons: Activate Now (callback_data: confirm_yes), Cancel (callback_data: confirm_cancel) | | security 2fa uninstall | uninstall confirmation | Send Inline Buttons: Uninstall 2FA (callback_data: confirm_yes), Keep 2FA (callback_data: confirm_no) |

Inline Button Template for Confirmations:

json
{
  "text": "Transaction Summary:\n• To: 0x1234...5678\n• Amount: 0.5 ETH\n• Gas: ~0.001 ETH (sponsorship available)\n\nDo you approve this transaction?",
  "reply_markup": {
    "inline_keyboard": [
      [
        { "text": "✅ Approve", "callback_data": "tx_approve" },
        { "text": "❌ Reject", "callback_data": "tx_reject" }
      ],
      [
        { "text": "🔍 Simulate First", "callback_data": "tx_simulate" }
      ]
    ]
  }
}

Rules:

1. Never auto-confirm. Always surface the transaction summary and wait for explicit Inline Button approval.
2. Callback handling: Upon receiving a callback (e.g., tx_approve), execute the corresponding action and report the result via another message (or update the existing message with the result).
3. Audit logging: Log every confirmation decision (approve/reject/simulate) with timestamp, callback_data, and user ID for compliance and troubleshooting.

Agent Implementation Checklist

When implementing Elytro wallet interactions, ensure:

• ] Ambiguous intent detection: When user says "open wallet", "打开钱包", "elytro", etc., immediately show Main Menu (Level 0) without asking.
• ] Real-time data fetching: Always run elytro account list, elytro query balance, etc. before rendering UI. Never use placeholder data.
• ] Inline Button rendering: All menus, lists, confirmations, and action flows use Telegram Inline Buttons exclusively.
• ] Back button on all sub-menus: Every screen below Main Menu includes a "⬅️ Back" button.
• ] Callback routing: Parse callback_data prefixes (menu_, account_select_, action_, tx_, confirm_) and route to correct handler.
• ] Multi-step action flows: For Send and Swap, guide user through account → input → summary → approval steps using Inline Buttons.
• ] Audit logging: Log all callback events (callback_data, timestamp, user_id, action taken, result).
• ] Error handling: If a command fails (e.g., elytro tx send returns error), display error message with a "⬅️ Back" button to retry or return to menu.

Inter-Agent Communication & Inline Button Convention

All agents using the Elytro skill must follow this Inline Button standard to ensure seamless integration and user experience consistency.

Callback Data Naming Convention

Agents must adhere to the following callback_data format for cross-agent compatibility:

| Use Case | Callback Format | Example | |----------|-----------------|---------| | Confirmations | confirm_yes, confirm_no, confirm_cancel | { "text": "Approve", "callback_data": "confirm_yes" } | | Account Selection | account_select_<alias_or_address> | { "text": "myWallet", "callback_data": "account_select_myWallet" } | | Token Selection | token_select_<tokenAddress_or_symbol> | { "text": "USDC", "callback_data": "token_select_0xA0b8..." } | | Transaction Actions | tx_approve, tx_reject, tx_simulate | { "text": "Send", "callback_data": "tx_approve" } | | Action Menu | action_<action_name> | { "text": "Send ETH", "callback_data": "action_send_eth" } |

For Other AI Agents Reading This Skill

Important: If you are another AI agent tasked with Elytro wallet operations:

1. Always use Inline Buttons for confirmations and list displays — never fall back to text input prompts.
2. Follow the callback_data naming convention above — this ensures consistency across all agents using Elytro.
3. When displaying lists (accounts, tokens, transactions, etc.), render each item as a clickable button with the appropriate callback format.
4. Upon receiving a callback, parse the callback_data and execute the corresponding action (e.g., confirm_yes → proceed with tx, account_select_<alias> → fetch account details).
5. Log all callback events for audit purposes: timestamp, user_id, callback_data, action taken, result.
6. Update this section if you introduce new callback patterns — keep the standard extensible and well-documented for future agents.

Notes

• Elytro uses EIP-4337 (Account Abstraction) — transactions are submitted as UserOps via a Bundler, not regular EOA transactions.
• Sponsored transactions are gasless by default when a paymaster is available.
• The wallet data directory is ~/.elytro.
• --chain accepts both hex (0xaa36a7) and decimal (11155111) chain IDs.
• data field in tx spec must be a valid hex string; use 0x for plain ETH transfers.
• Inline Button usage is mandatory for all user-facing confirmations and list displays in Elytro workflows. This ensures a consistent, modern UX across all agents and reduces friction in high-stakes wallet operations.