The Swap protocol facilitates a wide variety of trading methods trustlessly. The most popular method to date is the RFQ style system that powers AirSwap Instant. When you request a price on Instant, responses come from automated bots built by developers. This guide will show you how quickly you can get started with a bot of your own!

We’re going to leverage two awesome tools in this tutorial, so I’ll touch on them both briefly before we dive in.

Serverless with ZEIT Now

Until recently, AirSwap Instant peers only communicated using JSON-RPC over websockets. This was okay, but frankly not great. Websockets can be fragile and hard to work with, plus most developers don’t have a lot of experience building on top of them. With AirSwap 2.0, peers can now communicate with JSON-RPC over HTTP. This means AirSwap developers can use all of the latest and greatest in web tooling — like ZEIT Now!

Of course, we could always whip up vanilla web server, but then we’d have to containerize it, host it in the cloud, and setup some health checks or process monitoring tools in case something ever goes wrong. That’s a lot of work, and that’s why Serverless really shines here. All you have to do is write your code, and ZEIT will take care of the rest.

Quick Start with the AirSwap CLI

We recently released the AirSwap CLI. This command line tool provides helpful utilities to aid developers in building on top of the Swap Protocol. The CLI also includes some helpful scripts for administrative tasks. We’ll use these scripts to approve tokens, interact with indexers, and test our maker locally.

Setup

Before we get started, you’ll need to make sure you have Node.js >= v10.13.0 and Yarn installed. You’ll also need the latest version of Google Chrome with the MetaMask extension installed. If you ever get stuck or lost, you can find the complete source code for this tutorial here.

Clone down the airswap-zeit-example repo and checkout the tutorial starting point branch.

https://github.com/airswap/airswap-zeit-example/tree/zeit-tutorial-starting-point



$ git checkout zeit-tutorial-starting-point $ git clone git@github.com :airswap/airswap-zeit-example.git$ git checkout zeit-tutorial-starting-point

Then, install dependencies.

$ yarn install

Building the Maker

We’re going to start by setting up an environment variable. ZEIT has great built-in support for environment variables with their Secrets system.

The only environment variable that we need for this tutorial is ETHEREUM_ACCOUNT , which should be a 64 character Ethereum account private key. If you want to generate a new private key for the purpose of this tutorial you can follow the steps below. If you already know how to create a private key or have a spare one handy, skip ahead to the section titled “Configure ZEIT Now Secret and .env file.”

Generating a new Private Key

The AirSwap CLI provides helpful many helpful utilities, including Ethereum account generation. Follow the steps below to get your private key.

First, install the AirSwap CLI.

$ yarn global add airswap

Now, generate a private key.

$ airswap account:generate

Your result should look like this:

Copy this private key to your clipboard and use it in the next section below.

WARNING: You should never reuse this private key outside of this tutorial. Anyone with access to your private key can access all funds associated with the account.

Configure ZEIT Now Secret and .env file

We’re going to use the ZEIT Now CLI to set up our Secret. Enter the following command, making sure to replace the template with your actual private key:

$ now secrets add ethereum-account 64_CHAR_PRIVATE_KEY_HERE

We also need to add a .env file for local development. You can look at the .env.example file for reference. Your .env file should just have one line that looks like this:

ETHEREUM_ACCOUNT=64_CHAR_PRIVATE_KEY_HERE

That’s all we need to do. Now the secret will be available to our maker as an environment variable called ETHEREUM_ACCOUNT . This is configured by the now.json file provided in the tutorial template. You can learn more by reading ZEIT’s documentation.

Acquiring testnet tokens

Our example maker is going to serve orders for DAI on the Rinkeby test network, so we’ll need to acquire some test DAI before we begin. Follow the steps below:

First, import the private key that you made for this tutorial into MetaMask

Click this button in the MetaMask extension to import your private key

Then, visit the Rinkeby ETH Faucet and follow instructions to get some ETH

Finally, visit the Compound Rinkeby DAI Faucet to get some DAI. You’ll need to click on the “FAUCET” button like in the photo below.

Click the “FAUCET” button and follow the prompts

Code

Now we’re ready to write some code. We’re going to navigate to the api/ directory, which is where the ZEIT build system looks for files. Open the api/index.ts file in your text editor, and let’s get started.

We’ll start by importing some dependencies.

import jayson from 'jayson' // JSON-RPC helper

import winston from 'winston' // logger

import connect from 'connect' // expressJS-like middleware helper

import cors from 'cors' // CORS middleware

import bodyParser from 'body-parser' // body parsing middleware

import initHandlers from './handlers' // airswap maker logic

Let’s also add a check for the environment variable, since our maker can’t run without it.

// Make sure environment variables are ready

if (!process.env.ETHEREUM_ACCOUNT) {

throw new Error('ETHEREUM_ACCOUNT must be set')

}

We’ll also configure our logger. This will be helpful later on if we want to debug our maker in real time using ZEIT’s built in log monitoring features.

// Setup logger

const logger = winston.createLogger({

level: 'info',

transports: [new winston.transports.Console()],

format: winston.format.printf(({ level, message }) => {

return `${level}: ${message}`

}),

})

Next, we’re going to instantiate the example order and pricing handlers from AirSwap Maker Kit. By default, the Maker Kit provides some hard-coded handlers to get you up and running quickly. Once you reach the end of the tutorial, you should come back here and try customizing the handlers with your own pricing strategies.

// Initialize pricing handlers with our private key

const handlers = initHandlers(process.env.ETHEREUM_ACCOUNT)

These handlers are now used to power a JSON-RPC server with the help of the jayson package. This means that when a prospective counter-party calls a method on our maker like getMaxQuote or getSenderSideOrder , it will be processed and responded to automatically.

// Listen and respond to incoming JSON-RPC over HTTP requests

const server = new jayson.Server(handlers, {

router: function(method) {

try {

logger.info(`Received ${method} request`)

return this._methods[method]

} catch (e) {

return new jayson.Method((params, callback) => {

callback(true, null)

})

}

},

})

Lastly, we just need to add some middleware and export our code. We don’t have to worry about configuring ports or transpiling the TypeScript. ZEIT’s build system will take care of everything else from here.

// Instantiate our express-style middleware helper

const app = connect() // Parse JSON request body

app.use(bodyParser.json()) // Do preflight OPTIONS check before the jayson middleware

app.use(cors()) // Apply our order handlers

app.use(server.middleware()) export default app

Now that we have our index.ts file finished, let’s take it for a spin. We’re going to need two terminal shells for this part.

In the first window, navigate to the airswap-zeit-example/ directory if you’re not there already. Then start your maker locally by running:

$ now dev

In the second window, run airswap quote:get . This script allows us to query any maker. Make sure to query your own maker by typing http://localhost:3000 in the locator prompt. Ask for a price quote to buy 100 DAI in exchange for WETH.

You should see your maker log the request in the first window, and the quote will come back in the second window. Everything is working!

Now that we have our maker working locally, the last phase is to deploy it and make it discoverable by other traders on AirSwap Instant. There are just a few final steps required to make that happen: approving our DAI balance to be transferred by the Swap contract, setting an intent to trade on the indexer contract, and deploying our maker to ZEIT. These steps are covered in Part 2 of the Deploy a Serverless Maker Bot on AirSwap tutorial series.