SendLogz

Posted on Mar 4

Give Your AI Agent a Wallet in 5 Minutes (Without Risking Your Private Key)

#typescript

Every AI agent wallet solution I've seen has the same problem: they give the agent a private key. One prompt injection, one hallucination, one bad tool call — and your funds are gone.

Clanker Wallet takes a different approach: the agent proposes transactions, the human reviews and signs them.

The Problem

You're building an AI agent that needs to:

Swap tokens on a DEX
Transfer funds
Interact with smart contracts

But you don't want to give it a private key. Because:

Prompt injections can trick agents into draining wallets
Agents hallucinate — they might send to the wrong address
You want to review transactions before they execute

The Solution

npm install -g clanker-wallet

Step 1: Connect your wallet

Go to clanker-wallet.xyz, connect your wallet (MetaMask, WalletConnect, etc.), and copy the pairing JSON.

Step 2: Pair your agent

clanker-wallet pair '{"version":1,"pubkey":"...","relay":"wss://...","wallet":"0x..."}'

This establishes an E2E encrypted channel between your agent and your browser. One-time setup.

Step 3: Send transactions

clanker-wallet tx \
  --chain 1 \
  --to 0xRecipientAddress \
  --value 1000000000000000 \
  --reason "Send 0.001 ETH to recipient"

This blocks until you approve or reject the transaction in the web app. You see:

Full transaction details
Simulation results
Risk flags
Decoded calldata

Using with LangChain

import { ClankerWallet } from 'clanker-wallet'
import { DynamicStructuredTool } from '@langchain/core/tools'
import { z } from 'zod'

const wallet = new ClankerWallet({ agentName: 'my-agent' })

const sendTx = new DynamicStructuredTool({
  name: 'send_blockchain_transaction',
  description: 'Send a blockchain transaction (requires human approval)',
  schema: z.object({
    chainId: z.number(),
    to: z.string(),
    value: z.string().default('0'),
    data: z.string().default('0x'),
    reason: z.string(),
  }),
  func: async ({ chainId, to, value, data, reason }) => {
    const txHash = await wallet.requestTx({
      chain_id: chainId,
      transaction: { to, value, data },
      context: { reason },
    })
    return `Approved: ${txHash}`
  },
})

Using with Vercel AI SDK

import { ClankerWallet } from 'clanker-wallet'
import { tool } from 'ai'
import { z } from 'zod'

const wallet = new ClankerWallet({ agentName: 'my-agent' })

const sendTx = tool({
  description: 'Send a human-approved blockchain transaction',
  parameters: z.object({
    chainId: z.number(),
    to: z.string(),
    value: z.string().default('0'),
    reason: z.string(),
  }),
  execute: async ({ chainId, to, value, reason }) => {
    const txHash = await wallet.requestTx({
      chain_id: chainId,
      transaction: { to, value, data: '0x' },
      context: { reason },
    })
    return { txHash }
  },
})

Using with Python

from clanker_wallet import ClankerWallet, Transaction, RequestTxOptions, TxContext

agent = ClankerWallet()
agent.pair(pairing_json)

tx_hash = await agent.request_tx(RequestTxOptions(
    chain_id=1,
    transaction=Transaction(to="0x...", value="1000000000000000", data="0x"),
    context=TxContext(reason="Send 0.001 ETH"),
))

How It Works Under the Hood

Pairing: Agent generates an x25519 keypair. Human's web app generates another. They exchange public keys.
Encryption: All messages use NaCl box (x25519-xsalsa20-poly1305). The WebSocket relay only sees encrypted blobs.
Approval: Human's browser decrypts the tx request, displays it with simulation data, and waits for approve/reject.
Signing: Human's wallet (MetaMask, etc.) signs the transaction. The signed tx is broadcast directly — the agent never sees the private key.

Security Model

Component	Trust Level
Agent	Untrusted (no private key)
Relay server	Untrusted (only sees encrypted data)
Human's browser	Trusted (has wallet access)
Communication	E2E encrypted

DEV Community