Build a Twitter bot with arc.codes ⚡️

Introduction

In this tutorial, we're going to create a Twitter bot using arc.codes @scheduled functions feature that will tweet the daily price of Blockstacks($STX).

Stacks is a new cryptocurrency integrated with Bitcoin's security, capital, and network, enabling you to build apps, smart contracts, and digital assets.

Prerequisites

• You must have an approved Twitter developer account.
• AWS account.

You can clone the code for this project here: https://github.com/ShawnHosea/stacksbot

Step 1: Create a Twitter app

First, let's set up our Twitter developer account to create an app and gain access to our API keys.

Follow these instructions to create an app:

• Navigate to https://developer.twitter.com/en and click Developer Portal
• Create and name your app.
• Scroll to App permissions and change to Read and Write.
• Navigate to the Keys and tokens tab and regenerate all of your API keys. Make sure to save them somewhere safe.

Step 2: Create an Architect app & add environment variables

Now it's time to create our Architect project. We're going to follow the Quickstart found on arc.codes.

mkdir twitterApp
cd twitterApp
arc init

Next, create a preferences.arc file holding the following keys:

• TWITTER_API_KEY
• TWITTER_API_SECRET
• TWITTER_ACCESS_TOKEN
• TWITTER_ACCESS_TOKEN_SECRET

You can sync these API keys by using the arc env CLI command

Here is an example of how your preferences.arc file should look:

# The @env pragma is synced (and overwritten) by running arc env
@env
testing
  TWITTER_ACCESS_TOKEN something-for-testing
  TWITTER_ACCESS_TOKEN_SECRET something-for-testing
  TWITTER_API_KEY something-for-testing
  TWITTER_API_SECRET something-for-testing

staging
  TWITTER_ACCESS_TOKEN something-for-staging
  TWITTER_ACCESS_TOKEN_SECRET something-for-staging
  TWITTER_API_KEY something-for-staging
  TWITTER_API_SECRET something-for-staging

production
  TWITTER_ACCESS_TOKEN something-for-production
  TWITTER_ACCESS_TOKEN_SECRET something-for-production
  TWITTER_API_KEY something-for-production
  TWITTER_API_SECRET something-for-production

Step 3: Create a Scheduled function

Start by adding a Scheduled function to your app.arc files @scheduled pragma.

@app
init

@static
folder public

@events

@http
get /

# Scheduled function for once a day.
@scheduled
daily rate(1 day)

# @aws
# profile default
# region us-west-1

• We're going to be using the twitter-api-client to interact with the Twitter API more seamlessly.
• We'll use tiny-json-http to fetch the data from Coincap.com to use for our daily scheduled tweet.
• cd into src/scheduled/daily to install these two dependencies above so that we may use them inside of the function.
• Place this code into src/scheduled/daily

const tiny = require('tiny-json-http')
const { TwitterClient } = require('twitter-api-client')


exports.handler = async function scheduled (event) {

  const twitterClient = new TwitterClient({
    apiKey: process.env.TWITTER_API_KEY,
    apiSecret: process.env.TWITTER_API_SECRET,
    accessToken: process.env.TWITTER_ACCESS_TOKEN,
    accessTokenSecret: process.env.TWITTER_ACCESS_TOKEN_SECRET
  })

  let url = `https://api.coincap.io/v2/assets/blockstack`


  const status = await tiny.get({url})
  .then(response => {
    let stx = response.body.data
    let tweet
    if (stx) {
      //tweet the $STX price
      tweet = 'Daily $STX price: ' + "\n" + "\n" + '$' + stx.priceUsd
    } 
    return tweet
  }).catch(err => {
    console.error(err)
  })

  console.log('Log2:', status)

  await twitterClient.tweets.statusesUpdate({
    status: status
  }).then(response => {
    console.log("Tweeted!", response)
  }).catch(err => {
    console.error(err)
  })

  console.log(JSON.stringify(event, null, 2))

  return 
}

• First, we authenticate our Twitter account using our API keys loaded through the twitter-api-client.
• Then, we use tiny-json-http to pull in the $STX data from Coincap.io
• After our account is authenticated and data loaded, we create a tweet using the twitter-api-client to tweet out a status update.

You can test this code to ensure that your function is working by placing this exact code in the get / of your app. When you navigate to this endpoint, it will trigger a status update to your Twitter feed.

Conclusion

Architect and Begin are great tools for interfacing with the Twitter API. I encourage you to explore both arc.codes and the Twitter API to see what kinds of bots you can come up with!