Skip to main content

Twitter Module

The twitter module provides comprehensive Twitter bot integration for verification, rewards, mention tracking, and social media engagement with blockchain reward systems.

Import​

const twitter = await brdzSDK.twitter;

Methods Overview (16 methods)​

MethodDescriptionAuth RequiredHTTP Endpoint
initiateVerificationStart Twitter account verification✅POST /twitter/verification/initiate
verifyAccountComplete Twitter account verification✅POST /twitter/verification/verify
getVerificationStatusGet Twitter verification status✅GET /twitter/verification/status/:user_id
mintRewardExecute USDC reward minting✅POST /twitter/mint_reward
processMentionRewardProcess mention/retweet rewards✅POST /twitter/rewards/mention
getRewardsHistoryGet user rewards history✅GET /twitter/rewards/history/:user_id
checkDailyLimitsCheck daily reward limits✅GET /twitter/rewards/limits/:user_id
searchMentionsSearch bot mentions (admin)🔒GET /twitter/mentions/search
getTwitterUserInfoGet Twitter user information✅GET /twitter/user/:username
getHealthStatusCheck service health✅GET /twitter/health
getWebhookStatusGet webhook service status (admin)🔒GET /twitter/webhook/status
testWebhookEventTest webhook processing (admin)🔒POST /twitter/webhook/test
getWebhookLogsGet webhook processing logs (admin)🔒GET /twitter/webhook/logs
getOAuthCallbackTwitter OAuth callback handler❌GET /twitter/callback
getTermsOfServiceGet Terms of Service❌GET /twitter/terms
getPrivacyPolicyGet Privacy Policy❌GET /twitter/privacy

Legend: ✅ = User Auth Required, 🔒 = Admin Auth Required, ❌ = No Auth Required

Example Usage​

// Start Twitter verification process
const verification = await twitter.initiateVerification({
  user_id: 123,
  twitter_username: 'johndoe'
});

// Complete verification with code
const verified = await twitter.verifyAccount({
  user_id: 123,
  verification_code: 'BRDZ-A1B2C'
});

// Mint reward tokens
const reward = await twitter.mintReward({
  chain: 'sepolia',
  address: '0x742d35Cc6634C0532925a3b8D389E2B74e8E8329',
  amount: 10
});

// Process mention rewards
const mentionReward = await twitter.processMentionReward({
  user_id: 123,
  tweet_id: '1234567890123456789',
  tweet_text: 'Hey @BRDZBot, loving the new features!',
  action_type: 'mention'
});

// Get rewards history
const history = await twitter.getRewardsHistory('123', {
  limit: 10,
  status: 'completed'
});

// Check daily limits
const limits = await twitter.checkDailyLimits('123');

🧩 Your Twitter Bot Building Blocks​

✅ Verification Blocks​

  • initiateVerification - Start Twitter account verification process
  • verifyAccount - Complete verification with tweet proof
  • getVerificationStatus - Check user verification status

🎁 Reward System Blocks​

  • mintReward - USDC minting via bridge contracts
  • processMentionReward - Process mention/retweet rewards
  • getRewardsHistory - Reward transaction history
  • checkDailyLimits - Daily reward limit checking

🔍 Twitter Integration Blocks​

  • searchMentions - Search bot mentions (admin only)
  • getTwitterUserInfo - Get Twitter user information
  • getHealthStatus - Service health monitoring

🔗 Webhook Management Blocks​

  • getWebhookStatus - Webhook service status
  • testWebhookEvent - Test webhook processing
  • getWebhookLogs - Webhook processing logs

📄 Static Content Blocks​

  • getOAuthCallback - OAuth callback handling
  • getTermsOfService - Terms of Service
  • getPrivacyPolicy - Privacy Policy

🏗️ Common Twitter Bot Patterns​

Pattern 1: "I want to verify my Twitter account"​

User registration → initiateVerification → Tweet posting → verifyAccount → Reward

Use: initiateVerification → verifyAccount

Pattern 2: "I want to earn rewards from mentions"​

Mention bot → processMentionReward → Blockchain transfer → History tracking

Use: processMentionReward → getRewardsHistory

Pattern 3: "I want to monitor bot activity"​

Admin access → searchMentions → getWebhookLogs → Service monitoring

Use: searchMentions → getWebhookLogs

Pattern 4: "I want to check reward eligibility"​

User status → getVerificationStatus → checkDailyLimits → Reward processing

Use: getVerificationStatus → checkDailyLimits

🔗 Supported Networks​

Twitter bot reward system operates on EVM networks with BRDZ bridge contracts:

NetworkChain IDBridge ContractUSDC Contract
Sepolia111551110x432a3Ab53BEe8657cD5E26Bd9A7251Bbd19B3Fb10x9BF350fBaaA8c7200990B051809334c90778f435
Polygon Amoy800020xb04EBd1cE956E5576c5A7A02f74E3DdCFeE564AF0xC15239B6B9012F3225f9ebC091C7CE85FF31b983
Neon EVM2450229260xF0E6D21447281D3a858B6Bfee045D5c48D2E60650xB5234C0418402775bCA3f73c4B0B5bDd906FCA11

Minting Process: All USDC rewards are minted through bridge contracts which interface with BRDZ custom USDC contracts on each supported EVM network.

✅ Verification Operations​

initiateVerification​

// Start Twitter account verification
const verification = await twitter.initiateVerification({
  user_id: 123,
  twitter_username: 'johndoe'
});

console.log(`Verification code: ${verification.data.verification_code}`);
console.log(`Tweet template: ${verification.data.tweet_template}`);
console.log(`Expires at: ${verification.data.expires_at}`);

Parameters:

  • user_id (number) - User ID (optional, can be from auth middleware)
  • twitter_username (string) - Twitter username to verify (without @)

Returns: Verification details with code and tweet template

verifyAccount​

// Complete Twitter verification
const verified = await twitter.verifyAccount({
  user_id: 123,
  verification_code: 'BRDZ-A1B2C'
});

console.log(`Verification status: ${verified.data.verification.status}`);
console.log(`Welcome reward: ${verified.data.reward.amount} ${verified.data.reward.currency}`);
console.log(`TX Hash: ${verified.data.reward.tx_hash}`);

Parameters:

  • user_id (number) - User ID (optional, can be from auth middleware)
  • verification_code (string) - Verification code from initiate step

Returns: Verification result with welcome reward details

getVerificationStatus​

// Check verification status
const status = await twitter.getVerificationStatus('123');

console.log(`Twitter verified: ${status.data.twitter_verified}`);
console.log(`Username: @${status.data.twitter_username}`);
console.log(`Can start verification: ${status.data.can_start_verification}`);

Parameters:

  • userId (string) - User ID to check status for

Returns: Current verification status and eligibility

🎁 Reward System Operations​

mintReward​

// Mint USDC rewards via bridge contract
const reward = await twitter.mintReward({
  chain: 'sepolia',
  address: '0x742d35Cc6634C0532925a3b8D389E2B74e8E8329',
  amount: 25,
  user_id: 123
});

console.log(`Minted ${reward.data.amount} USDC on ${reward.data.chain}`);
console.log(`TX Hash: ${reward.data.transaction_hash}`);

Parameters:

  • chain (string) - EVM blockchain network (sepolia, amoy, neon)
  • address (string) - Recipient wallet address
  • amount (number, optional) - USDC amount to mint (default: 10)
  • user_id (number, optional) - User ID for tracking

Returns: Transaction details and minting confirmation

processMentionReward​

// Process mention/retweet rewards
const mentionReward = await twitter.processMentionReward({
  user_id: 123,
  tweet_id: '1234567890123456789',
  tweet_text: 'Hey @BRDZBot, loving the new features! #crypto #rewards',
  action_type: 'mention'
});

console.log(`Reward processed: ${mentionReward.data.reward.amount} ${mentionReward.data.reward.currency}`);
console.log(`Daily remaining: ${mentionReward.data.daily_status.remaining}`);
console.log(`TX Hash: ${mentionReward.data.reward.tx_hash}`);

Parameters:

  • user_id (number) - User ID (optional, can be from auth middleware)
  • tweet_id (string) - Twitter tweet ID that mentions the bot
  • tweet_text (string) - Full text content of the tweet
  • action_type (string, optional) - Type of action (mention, retweet)

Returns: Reward details and daily status

getRewardsHistory​

// Get user's rewards history
const history = await twitter.getRewardsHistory('123', {
  limit: 10,
  offset: 0,
  status: 'completed',
  action_type: 'mention',
  chain: 'sepolia'
});

console.log(`Total earned: ${history.data.statistics.total_earned} USDC`);
console.log(`Success rate: ${history.summary.success_rate}`);

history.data.rewards.forEach(reward => {
  console.log(`${reward.created_at}: ${reward.amount} ${reward.currency} (${reward.action_type})`);
});

Parameters:

  • userId (string) - User ID to get history for
  • params (object, optional) - Filtering parameters:
    • limit (number) - Max records (1-100, default: 10)
    • offset (number) - Records to skip (default: 0)
    • status (string) - Filter by status (pending, completed, failed)
    • action_type (string) - Filter by action (verification, mention, retweet)
    • chain (string) - Filter by blockchain (sepolia, amoy, neon)

Returns: Paginated rewards history with statistics

checkDailyLimits​

// Check daily reward limits
const limits = await twitter.checkDailyLimits('123');

console.log(`Daily count: ${limits.data.daily_count}/${limits.data.daily_limit}`);
console.log(`Remaining today: ${limits.data.remaining_today}`);
console.log(`Can receive reward: ${limits.data.can_receive_reward}`);
console.log(`Progress: ${limits.data.progress_percentage}%`);

Parameters:

  • userId (string) - User ID to check limits for

Returns: Daily usage and remaining limits

🔍 Twitter Integration Operations​

searchMentions​

// Search bot mentions (admin only)
const mentions = await twitter.searchMentions({
  bot_username: 'BRDZBot',
  max_results: 10
});

console.log(`Found ${mentions.data.total_found} mentions`);
mentions.data.mentions.forEach(mention => {
  console.log(`@${mention.author_id}: ${mention.text}`);
  console.log(`Engagement: ${mention.engagement.likes} likes, ${mention.engagement.retweets} retweets`);
});

Parameters:

  • params (object) - Search parameters:
    • bot_username (string) - Bot's Twitter username (without @)
    • max_results (number, optional) - Max results (1-50, default: 10)

Returns: Found mentions with engagement metrics

getTwitterUserInfo​

// Get Twitter user information
const userInfo = await twitter.getTwitterUserInfo('johndoe');

console.log(`User: @${userInfo.data.username} (${userInfo.data.display_name})`);
console.log(`Verified: ${userInfo.data.verified}`);
console.log(`Followers: ${userInfo.data.metrics.followers.toLocaleString()}`);
console.log(`Following: ${userInfo.data.metrics.following.toLocaleString()}`);
console.log(`Tweets: ${userInfo.data.metrics.tweets.toLocaleString()}`);

Parameters:

  • username (string) - Twitter username (without @)

Returns: User profile data and metrics

getHealthStatus​

// Check service health
const health = await twitter.getHealthStatus();

console.log(`Service status: ${health.data.status}`);
console.log(`Twitter API configured: ${health.data.environment.twitter_api_configured}`);
console.log(`Supported chains: ${health.data.environment.supported_chains.join(', ')}`);
console.log(`Verification reward: ${health.data.environment.reward_config.verification_reward}`);
console.log(`Daily limit: ${health.data.environment.reward_config.daily_limit}`);

Returns: Service health status and configuration

🔗 Webhook Management Operations (Admin Only)​

getWebhookStatus​

// Get webhook service status (admin only)
const webhookStatus = await twitter.getWebhookStatus();

console.log(`Webhook status: ${webhookStatus.data.status}`);
console.log(`Configured: ${webhookStatus.data.webhook_configured}`);
console.log(`Events processed today: ${webhookStatus.data.events_processed_today}`);
console.log(`Last event: ${webhookStatus.data.last_event_received}`);
console.log(`Supported events: ${webhookStatus.data.supported_events.join(', ')}`);

Returns: Webhook service status and configuration

testWebhookEvent​

// Test webhook processing (admin only)
const testResult = await twitter.testWebhookEvent({
  test_event_type: 'tweet_create_events',
  test_payload: {
    id: '1234567890123456789',
    text: 'Test tweet mentioning @BRDZBot for webhook testing',
    user: {
      id: '9876543210',
      screen_name: 'testuser'
    },
    created_at: '2024-01-15T11:30:00Z'
  }
});

console.log(`Test processed: ${testResult.data.processed_count} events`);
testResult.data.results.forEach(result => {
  console.log(`Event: ${result.event_type}, Result: ${result.processing_result}`);
  console.log(`Actions: ${result.actions_taken.join(', ')}`);
});

Parameters:

  • data (object) - Test event data:
    • test_event_type (string) - Event type to test
    • test_payload (object) - Test event payload

Returns: Test processing results

getWebhookLogs​

// Get webhook processing logs (admin only)
const logs = await twitter.getWebhookLogs({
  limit: 50,
  event_type: 'tweet_create_events',
  status: 'success'
});

console.log(`Total events: ${logs.data.total_events}`);
console.log('Event summary:');
Object.entries(logs.data.event_summary).forEach(([type, count]) => {
  console.log(`  ${type}: ${count}`);
});

Parameters:

  • params (object, optional) - Filter parameters:
    • limit (number) - Max logs (1-100, default: 50)
    • event_type (string) - Filter by event type
    • status (string) - Filter by processing status

Returns: Webhook processing logs with summary

📄 Static Content Operations​

getOAuthCallback​

// Handle Twitter OAuth callback
const callback = await twitter.getOAuthCallback();

console.log(`Service: ${callback.data.service}`);
console.log(`Callback received: ${callback.data.callback_received}`);
console.log(`OAuth token: ${callback.data.query_params.oauth_token}`);

Returns: OAuth callback information

getTermsOfService​

// Get Terms of Service
const terms = await twitter.getTermsOfService();

console.log(`Service: ${terms.data.service_name} v${terms.data.version}`);
console.log(`Title: ${terms.data.terms.title}`);
console.log(`Contact: ${terms.data.terms.contact}`);
console.log('Key points:');
terms.data.terms.key_points.forEach(point => {
  console.log(`  • ${point}`);
});

Returns: Terms of Service content

getPrivacyPolicy​

// Get Privacy Policy
const privacy = await twitter.getPrivacyPolicy();

console.log(`Service: ${privacy.data.service_name} v${privacy.data.version}`);
console.log(`Title: ${privacy.data.privacy.title}`);
console.log(`Contact: ${privacy.data.privacy.contact}`);
console.log('Data collected:');
privacy.data.privacy.data_collected.forEach(item => {
  console.log(`  • ${item}`);
});

Returns: Privacy Policy content

🚀 Complete Twitter Bot Workflows​

Workflow 1: User Verification Flow​

// Complete user Twitter verification workflow
async function completeVerificationFlow(userId, twitterUsername) {
  console.log('Starting Twitter verification...');
  
  // Step 1: Check if already verified
  const status = await twitter.getVerificationStatus(userId.toString());
  if (status.data.twitter_verified) {
    console.log('User already verified!');
    return status;
  }
  
  // Step 2: Initiate verification
  const verification = await twitter.initiateVerification({
    user_id: userId,
    twitter_username: twitterUsername
  });
  
  console.log(`Verification code: ${verification.data.verification_code}`);
  console.log('Please post this tweet:');
  console.log(`"${verification.data.tweet_template}"`);
  
  // Step 3: Wait for user to post tweet (implement your own UI)
  console.log('Waiting for tweet to be posted...');
  await waitForUserConfirmation(); // Your implementation
  
  // Step 4: Complete verification
  const verified = await twitter.verifyAccount({
    user_id: userId,
    verification_code: verification.data.verification_code
  });
  
  console.log(`Verification successful! Welcome reward: ${verified.data.reward.amount} ${verified.data.reward.currency}`);
  
  return verified;
}

Workflow 2: Reward Processing Flow​

// Process mention rewards with validation
async function processMentionRewardFlow(userId, tweetId, tweetText) {
  console.log('Processing mention reward...');
  
  // Step 1: Check if user is verified
  const status = await twitter.getVerificationStatus(userId.toString());
  if (!status.data.twitter_verified) {
    throw new Error('User must verify Twitter account first');
  }
  
  // Step 2: Check daily limits
  const limits = await twitter.checkDailyLimits(userId.toString());
  if (!limits.data.can_receive_reward) {
    console.log(`Daily limit reached: ${limits.data.daily_count}/${limits.data.daily_limit}`);
    return { error: 'daily_limit_reached', limits: limits.data };
  }
  
  // Step 3: Process mention reward
  const reward = await twitter.processMentionReward({
    user_id: userId,
    tweet_id: tweetId,
    tweet_text: tweetText,
    action_type: 'mention'
  });
  
  console.log(`Reward processed: ${reward.data.reward.amount} ${reward.data.reward.currency}`);
  console.log(`Remaining today: ${reward.data.daily_status.remaining}`);
  
  return reward;
}

Workflow 3: Admin Monitoring Flow​

// Admin monitoring and analytics workflow
async function adminMonitoringFlow() {
  console.log('Starting admin monitoring...');
  
  // Step 1: Check service health
  const health = await twitter.getHealthStatus();
  console.log(`Service status: ${health.data.status}`);
  
  // Step 2: Check webhook status
  const webhookStatus = await twitter.getWebhookStatus();
  console.log(`Webhook configured: ${webhookStatus.data.webhook_configured}`);
  console.log(`Events processed today: ${webhookStatus.data.events_processed_today}`);
  
  // Step 3: Search recent mentions
  const mentions = await twitter.searchMentions({
    bot_username: 'BRDZBot',
    max_results: 20
  });
  
  console.log(`Found ${mentions.data.total_found} recent mentions`);
  
  // Step 4: Get webhook logs
  const logs = await twitter.getWebhookLogs({
    limit: 100,
    status: 'success'
  });
  
  console.log('Event summary:');
  Object.entries(logs.data.event_summary).forEach(([type, count]) => {
    console.log(`  ${type}: ${count}`);
  });
  
  return {
    health: health.data,
    webhook: webhookStatus.data,
    mentions: mentions.data,
    logs: logs.data
  };
}

Workflow 4: Multi-Chain Reward Distribution​

// Distribute rewards across multiple chains
async function multiChainRewardDistribution(userId, baseAmount = 10) {
  console.log('Starting multi-chain reward distribution...');
  
  const supportedChains = ['sepolia', 'amoy', 'neon'];
  const userWalletAddresses = {
    sepolia: '0x742d35Cc6634C0532925a3b8D389E2B74e8E8329',
    amoy: '0x742d35Cc6634C0532925a3b8D389E2B74e8E8329',
    neon: '0x742d35Cc6634C0532925a3b8D389E2B74e8E8329'
  };
  
  const rewards = [];
  
  for (const chain of supportedChains) {
    try {
      console.log(`Minting ${baseAmount} USDC on ${chain}...`);
      
      const reward = await twitter.mintReward({
        chain: chain,
        address: userWalletAddresses[chain],
        amount: baseAmount,
        user_id: userId
      });
      
      rewards.push({
        chain,
        success: true,
        txHash: reward.data.transaction_hash,
        amount: reward.data.amount
      });
      
      console.log(`✅ ${chain}: ${reward.data.amount} USDC - TX: ${reward.data.transaction_hash}`);
      
    } catch (error) {
      console.log(`❌ ${chain}: Failed - ${error.message}`);
      rewards.push({
        chain,
        success: false,
        error: error.message
      });
    }
  }
  
  const successfulRewards = rewards.filter(r => r.success);
  const totalMinted = successfulRewards.reduce((sum, r) => sum + r.amount, 0);
  
  console.log(`Distribution complete: ${totalMinted} USDC across ${successfulRewards.length} chains`);
  
  return {
    total_minted: totalMinted,
    successful_chains: successfulRewards.length,
    failed_chains: rewards.filter(r => !r.success).length,
    details: rewards
  };
}

🎯 When to Use Which Method​

Verification Operations​

  • New user verification: initiateVerification → verifyAccount
  • Check verification status: getVerificationStatus
  • Welcome rewards: Automatic via verifyAccount

Reward Operations​

  • Manual reward distribution: mintReward
  • Automated mention rewards: processMentionReward
  • Track reward history: getRewardsHistory
  • Check eligibility: checkDailyLimits

Integration Operations​

  • Twitter user lookup: getTwitterUserInfo
  • Service monitoring: getHealthStatus
  • Admin mention search: searchMentions

Webhook Operations (Admin)​

  • Webhook monitoring: getWebhookStatus
  • Test webhook events: testWebhookEvent
  • Debug webhook issues: getWebhookLogs

Static Content​

  • OAuth integration: getOAuthCallback
  • Legal compliance: getTermsOfService, getPrivacyPolicy

💡 Pro Tips for Twitter Bot Integration​

Error Handling​

// Robust error handling for Twitter operations
async function safeTwitterOperation(operation) {
  try {
    return await operation();
  } catch (error) {
    if (error.message.includes('ALREADY_VERIFIED')) {
      console.log('User already verified - skip verification');
      return { error: 'already_verified', suggestion: 'check_status' };
    } else if (error.message.includes('DAILY_LIMIT_REACHED')) {
      console.log('Daily reward limit reached');
      return { error: 'daily_limit', suggestion: 'try_tomorrow' };
    } else if (error.message.includes('USER_NOT_VERIFIED')) {
      console.log('User must verify Twitter first');
      return { error: 'not_verified', suggestion: 'complete_verification' };
    } else if (error.message.includes('VERIFICATION_EXPIRED')) {
      console.log('Verification code expired');
      return { error: 'expired', suggestion: 'restart_verification' };
    } else if (error.message.includes('TWEET_ALREADY_REWARDED')) {
      console.log('Tweet already received reward');
      return { error: 'duplicate_reward', suggestion: 'try_different_tweet' };
    } else {
      console.error('Unexpected Twitter error:', error.message);
      throw error;
    }
  }
}

Verification State Management​

// Track verification progress
class TwitterVerificationManager {
  static async startVerification(userId, twitterUsername) {
    const verification = await twitter.initiateVerification({
      user_id: userId,
      twitter_username: twitterUsername
    });
    
    // Store verification state (use your preferred storage)
    localStorage.setItem(`verification_${userId}`, JSON.stringify({
      code: verification.data.verification_code,
      username: twitterUsername,
      expires_at: verification.data.expires_at,
      tweet_template: verification.data.tweet_template
    }));
    
    return verification;
  }
  
  static async completeVerification(userId) {
    const stored = localStorage.getItem(`verification_${userId}`);
    if (!stored) {
      throw new Error('No pending verification found');
    }
    
    const { code } = JSON.parse(stored);
    const result = await twitter.verifyAccount({
      user_id: userId,
      verification_code: code
    });
    
    // Clear stored verification
    localStorage.removeItem(`verification_${userId}`);
    
    return result;
  }
  
  static getPendingVerification(userId) {
    const stored = localStorage.getItem(`verification_${userId}`);
    return stored ? JSON.parse(stored) : null;
  }
}

Daily Limits Monitoring​

// Monitor and display daily limits
async function displayDailyProgress(userId) {
  const limits = await twitter.checkDailyLimits(userId.toString());
  
  const progress = {
    current: limits.data.daily_count,
    maximum: limits.data.daily_limit,
    remaining: limits.data.remaining_today,
    percentage: limits.data.progress_percentage,
    canReceive: limits.data.can_receive_reward
  };
  
  console.log(`Daily Progress: ${progress.current}/${progress.maximum} (${progress.percentage}%)`);
  console.log(`Remaining: ${progress.remaining} rewards`);
  
  if (!progress.canReceive) {
    console.log('⚠️ Daily limit reached - no more rewards today');
  }
  
  return progress;
}

Chain Selection Strategy​

// Smart chain selection for rewards
class ChainSelector {
  static async selectOptimalChain(userPreference = null) {
    const chainPriority = {
      amoy: { priority: 1, gasEstimate: 0.01, name: 'Polygon Amoy' },
      sepolia: { priority: 2, gasEstimate: 0.05, name: 'Sepolia Testnet' },
      neon: { priority: 3, gasEstimate: 0.02, name: 'Neon EVM' }
    };
    
    // Use user preference if valid
    if (userPreference && chainPriority[userPreference]) {
      return userPreference;
    }
    
    // Default to chain with highest priority (lowest cost)
    return Object.entries(chainPriority)
      .sort(([,a], [,b]) => a.priority - b.priority)[0][0];
  }
  
  static getChainInfo(chainId) {
    const chainInfo = {
      sepolia: {
        name: 'Sepolia Testnet',
        symbol: 'ETH',
        explorer: 'https://sepolia.etherscan.io',
        gasEstimate: '~$0.05'
      },
      amoy: {
        name: 'Polygon Amoy',
        symbol: 'MATIC',
        explorer: 'https://amoy.polygonscan.com',
        gasEstimate: '~$0.01'
      },
      neon: {
        name: 'Neon EVM',
        symbol: 'NEON',
        explorer: 'https://neon-devnet.blockscout.com',
        gasEstimate: '~$0.02'
      }
    };
    
    return chainInfo[chainId] || null;
  }
}

🔐 Authentication & Authorization​

All Twitter endpoints require authentication with different permission levels:

// Configure authentication
const config = await brdzSDK.config;
config.setToken('your-jwt-token');
config.setApiKey('your-api-key');

// User-level operations
await twitter.initiateVerification({ user_id: 123, twitter_username: 'user' });
await twitter.verifyAccount({ user_id: 123, verification_code: 'BRDZ-A1B2C' });
await twitter.getRewardsHistory('123');

// Admin-level operations (requires admin role)
await twitter.searchMentions({ bot_username: 'BRDZBot' });
await twitter.getWebhookStatus();
await twitter.testWebhookEvent(testData);

🌍 Supported Features & Limits​

Verification System​

  • Code expiry: 30 minutes from generation
  • Tweet requirements: Must contain exact verification code
  • Welcome reward: 5 USDC on successful verification
  • Account requirements: Public Twitter account required

Reward System​

  • Daily limits: 3 rewards per user per day
  • Reward amounts: 10 USDC per mention/retweet
  • Supported actions: Mentions, retweets, verification
  • Chain support: Sepolia, Polygon Amoy, Neon EVM

Rate Limits​

  • User endpoints: 100 requests/hour per user
  • Admin endpoints: 1000 requests/hour
  • Webhook endpoints: No rate limit (secured by signature)

Error Handling​

All methods return consistent error formats:

{
  success: false,
  error: {
    code: "ERROR_CODE",
    message: "Human readable error message"
  },
  timestamp: "2024-01-15T10:30:00Z"
}
Verification Best Practices

Always check verification status before starting new verification. Store verification codes securely and implement proper expiry handling. Use the tweet template exactly as provided for successful verification.

Daily Limits

Users can only receive 3 rewards per day. Always check daily limits before processing mention rewards to avoid unnecessary API calls and provide better user experience.

Multi-Chain Support

USDC rewards can be distributed on Sepolia, Polygon Amoy, or Neon EVM networks. Consider gas costs and user preferences when selecting chains. Polygon Amoy typically has the lowest fees.