Bankr Twitter bot guide

This guide will walk through building a Twitter bot on top of the Clanker protocol similar to Bankr, Dealr, Beamr, and others. This bot will use an LLM to interpret user requests, Privy wallets to manage EVM accounts, and the Clanker protocol to deploy tokens on Base.

Resources

Clanker API docs

Learn how to deploy tokens on Base using the Clanker API.

Privy Wallets

Privy wallets for secure EVM wallet management.

Twitter API

Reference for building bots on Twitter.

Set up your Twitter bot

To interact with users, you’ll need a Twitter developer account and a bot. Learn more here.

Show Set up Twitter bot (pseudocode)

Go to the Twitter Developer Portal.
Create a new project and app.
Generate API keys and access tokens.
Safely store your credentials.

Set up Node.js Twitter bot server

Use a library like twitter-api-v2 to interact with Twitter.
Install the library:

npm install twitter-api-v2

pnpm install twitter-api-v2

yarn add twitter-api-v2

Create a basic Twitter client setup:

import { TwitterApi } from 'twitter-api-v2';

// Initialize the Twitter client with your credentials
const client = new TwitterApi({
  appKey: process.env.TWITTER_API_KEY!,
  appSecret: process.env.TWITTER_API_SECRET!,
  accessToken: process.env.TWITTER_ACCESS_TOKEN!,
  accessSecret: process.env.TWITTER_ACCESS_SECRET!,
});

// Get the read/write client
const rwClient = client.readWrite;

Example Node.js code to poll for mentions and robustly parse commands:

Show Example Twitter API mention payload

{
  "data": {
    "id": "1234567890123456789",
    "text": "@bankr_bot send @elonmusk 1 eth from my wallet",
    "author_id": "09876543210987654321",
    "entities": {
      "mentions": [
        { "start": 0, "end": 10, "username": "bankr_bot" },
        { "start": 16, "end": 25, "username": "elonmusk" }
      ]
    }
  },
  "includes": {
    "users": [
      { "id": "09876543210987654321", "username": "sender_username", "name": "Sender Name" },
      { "id": "12345678909876543210", "username": "bankr_bot", "name": "Bankr Bot" },
      { "id": "11223344556677889900", "username": "elonmusk", "name": "Elon Musk" }
    ]
  }
}

async function pollMentions() {
  let sinceId: string | undefined = undefined;
  while (true) {
    const mentions = await rwClient.v2.userMentionTimeline('YOUR_BOT_USER_ID', {
      since_id: sinceId,
      expansions: ['author_id', 'entities.mentions.username'],
      'user.fields': ['username', 'name'],
      max_results: 5,
    });
    for (const tweet of mentions.data?.data || []) {
      const parsed = processTweet(tweet, mentions);
      if (parsed) {
        // Call your LLM or transaction logic here
        // e.g. handleCommand(parsed)
      }
      sinceId = tweet.id;
    }
    await new Promise(res => setTimeout(res, 10000)); // poll every 10s
  }
}

function processTweet(tweet, mentionsResponse) {
  // Extract basic tweet information
  const text = tweet.text;
  const authorId = tweet.author_id;
  const tweetId = tweet.id;
  const mentions = tweet.entities?.mentions || [];

  // Extract all mentioned users
  const mentionedUsers = mentions.map(mention => {
    const username = mention.username;
    const user = mentionsResponse.includes?.users.find(u => u.username === username);
    return {
      username,
      userId: user?.id,
      isBot: username === 'bankr_bot' // Identify if this is our bot
    };
  });

  // Pass the structured data to the LLM for intent detection
  return {
    text,
    authorId,
    tweetId,
    mentions: mentionedUsers,
    // Additional context can be added here
  };
}

This code polls for new mentions, parses the tweet for sender, recipient, amount, and currency, and passes the result to your LLM or transaction logic.
For production, consider using the filtered stream for real-time events.

Set up Privy wallets

Privy wallets let you create and control EVM wallets programmatically. Learn more about getting started with wallets.

Using wallets

In our example application, we will build two basic interactions with Privy wallets:

Create a wallet
Get a user’s wallet

Using these core building blocks, we can allow our bot to seamlessly and securely create and manage wallets for users.

Create a wallet for a user

This function creates a new wallet for a user and saves the wallet ID to the database.

/**
 * Creates a new wallet for a user
 * @param userId - The Twitter user ID
 * @returns The wallet object with id, address, and other properties
 */
async function createUserWallet(userId) {
  // Create a new wallet for the user
  const wallet = await privy.wallets().create({chain_type: 'ethereum'});

  // EXAMPLE: Save the wallet ID to the database to save the mapping between the user and their wallet
  await db.wallets.set(userId, wallet.id);

  return wallet;
}

Get a user wallet

This function checks if a user has a wallet and returns it if it exists.

/**
 * Gets a user's wallet if it exists
 * @param userId - The Twitter user ID
 * @returns The wallet object or null if no wallet exists
 */
async function getUserWallet(userId) {
  // EXAMPLE: Check if user already has a wallet
  const walletId = await db.wallets.get(userId);

  // If wallet exists, retrieve and return the wallet
  if (walletId) {
    const wallet = await privy.wallets().get(walletId);
    return wallet;
  }

  return null;
}

Get or create a wallet

A higher level function that uses the getUserWallet and createUserWallet functions to get or create a wallet for a user.

/**
 * Gets a user's wallet or creates one if they don't have one
 * @param userId - The Twitter user ID
 * @returns The wallet object with id, address, and other properties
 */
async function getOrCreateUserWallet(userId) {
  // Try to get existing wallet
  const existingWallet = await getUserWallet(userId);

  // Return existing wallet if found
  if (existingWallet) {
    return existingWallet;
  }

  // Create a new wallet if none exists
  return createUserWallet(userId);
}

// Example usage:
const wallet = await getOrCreateUserWallet(parsed.authorId);

Integrate LLM for intent detection

Use an LLM to interpret user messages and decide what action to take. Treat the LLM as a black box that receives a prompt and returns a structured intent.

Show Pseudocode for LLM integration

Sample LLM prompt and response

Prompt:

User: Launch a token called $CAT with 1B supply
System: Extract the intent and parameters for a token launch on Base.
Output format: { action: string, params: object }

LLM Response:

{
  "action": "launch_token",
  "params": {
    "name": "CAT",
    "symbol": "$CAT",
    "supply": "1000000000"
  }
}

Pseudocode for LLM integration

// Pseudocode: send user message to LLM and parse response
const llmResponse = await llm.query({ prompt: userMessage });
if (llmResponse.action === 'launch_token') {
  // Proceed to Clanker integration
}

Getting set up with Clanker API

To deploy tokens via the Clanker API, you first need to obtain an API key.

Request API access

Visit the Clanker API documentation.
Follow the instructions or contact the Clanker team via their documentation or contact page to request API access.
Once approved, you’ll receive an x-api-key to use in your API requests.

Next: Deploy a token

Once you have your API key, you can use it to deploy tokens via the Clanker API. See the next section for a full deployment code example.

Example Interactions

Deploy a token

Let users deploy tokens on Base by simply messaging the bot. The LLM interprets the intent, and the bot handles wallet lookup/creation and token deployment.

Show Pseudocode for deploying a token

Sample LLM prompt and response

Prompt:

User: create a new $Example token
System: Extract the intent and parameters for a token launch on Base.
Output format: { action: string, params: object }

LLM Response:

{
  "action": "launch_token",
  "params": {
    "name": "Example",
    "symbol": "$Example"
  }
}

Parse Twitter message for command

// Example incoming tweet
const tweet = {
  text: "@YOUR_BOT_HANDLE create a new $Example token",
  author_id: "1234567890",
  id: "9876543210",
  // ...other fields
};
// Remove bot mention to get user command
const userMessage = tweet.text.replace(/@YOUR_BOT_HANDLE\s*/i, "").trim();

Use LLM to extract intent and parameters

// Send the user message to your LLM
const llmResponse = await llm.query({ prompt: userMessage });
// Example LLM response:
// {
//   action: "launch_token",
//   params: { name: "Example", symbol: "$Example" }
// }
if (llmResponse.action !== 'launch_token') {
  throw new Error('Not a token launch command');
}
const { name, symbol } = llmResponse.params;

Look up or create user's wallet

// Get or create a wallet for the user
const wallet = await getOrCreateUserWallet(tweet.author_id);
// wallet.address will be used as the requestorAddress

Deploy token using Clanker API

import axios from 'axios';
import crypto from 'crypto';

const apiKey = process.env.CLANKER_API_KEY;
const requestKey = crypto.randomBytes(16).toString('hex');
const payload = {
  name,
  symbol,
  image: 'https://example.com/token.png', // Optional: add your image
  requestorAddress: wallet.address,
  requestKey,
  // ...other optional params
};
const response = await axios.post('https://www.clanker.world/api/tokens/deploy', payload, {
  headers: {
    'x-api-key': apiKey,
    'Content-Type': 'application/json'
  }
});
const tokenInfo = response.data;

Notify user of deployment

// Send a DM or reply to the user with the token address
await twitterClient.sendDM({
  userId: tweet.author_id,
  text: `Token deployed! Address: ${tokenInfo.address}`
});

Send tokens to another Twitter user with LLM

Let users send tokens (e.g., ETH on Base) to other Twitter users by simply messaging the bot. The LLM interprets the intent, and the bot handles wallet lookup/creation and transaction sending.

Show Pseudocode for sending tokens

Sample LLM prompt and response

Prompt:

User: Hey bot, send 0.01 ETH from my wallet to @privy_io on twitter
System: Extract the intent and parameters for a token transfer on Base.
Output format: { action: string, params: object }

LLM Response:

{
  "action": "send_token",
  "params": {
    "amount": "0.01",
    "token": "ETH",
    "recipient": "@privy_io"
  }
}

Look up sender and recipient wallets

// 1. Get sender's Twitter ID from the parsed tweet
const senderTwitterId = parsed.authorId;

// 2. Get recipient's Twitter handle from LLM response (e.g., '@privy_io')
const recipientHandle = llmResponse.params.recipient.replace('@', '');

// 3. Look up recipient's Twitter ID from parsed mentions
const recipientMention = parsed.mentions.find(m => m.username === recipientHandle);
if (!recipientMention || !recipientMention.userId) {
  throw new Error('Recipient not found in tweet mentions');
}
const recipientTwitterId = recipientMention.userId;

// 4. Get or create recipient's wallet
const recipientWallet = await getOrCreateUserWallet(recipientTwitterId);

// 5. Get or create sender's wallet
const senderWallet = await getOrCreateUserWallet(senderTwitterId);

Send transaction using Privy wallet (NodeJS)

import { parseEther } from 'viem';

// 1. Parse the amount to wei (ETH uses 18 decimals)
const amountEth = llmResponse.params.amount; // e.g., '1'
const amountWei = parseEther(amountEth); // '1000000000000000000'

// 2. Prepare transaction details
const transaction = {
  to: recipientWallet.address,      // Recipient's EVM address
  value: amountWei,                // Amount in wei
  chainId: 8453,                   // Base chain ID
  // (Optional: add gas, data, etc.)
};

// 3. Send the transaction using Privy wallet
const sendResult = await privy.wallets().ethereum().sendTransaction(senderWallet.id, {
  caip2: 'eip155:8453', // CAIP2 for Base
  params: {
    transaction,
  }
});

​Resources

Clanker API docs

Privy Wallets

Twitter API

​Set up your Twitter bot

​Set up Privy wallets

​Using wallets

​Integrate LLM for intent detection

​Getting set up with Clanker API

​Example Interactions

​Deploy a token

​Send tokens to another Twitter user with LLM

Resources

Set up your Twitter bot

Set up Privy wallets

Using wallets

Integrate LLM for intent detection

Getting set up with Clanker API

Example Interactions

Deploy a token

Send tokens to another Twitter user with LLM