Deploy a Serverless Maker Bot on AirSwap (Part 1)

In this two-part tutorial, learn how to quickly set up a maker for AirSwap Instant using the new AirSwap Maker Kit and zero-config deployment with ZEIT Now.

Graham Perich
Nov 27, 2019 · 8 min read

AirSwap is a peer-to-peer trading network for Ethereum tokens. Traders connect to each other based on common interest, agree on price through mutual cryptographic signatures, and settle trades without intermediaries. It’s a good system for makers, with no deposits or costly price updates to on-chain order books.

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

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 Maker Kit

Setup

First, clone down the airswap-maker-kit repo and install dependencies. We will come back to it in a bit.

https://github.com/airswap/airswap-maker-kit

$ git clone git@github.com:airswap/airswap-maker-kit.git
$ cd airswap-maker-kit
$ yarn install

Second, clone down the airswap-maker-kit-examples repo and checkout the tutorial starting point branch.

https://github.com/airswap/airswap-maker-kit-examples/tree/zeit-tutorial-starting-point

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

Then, install dependencies.

$ yarn install

Building the Maker

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

First, clone down the repo. You don’t need to do this in the same directory you were working in above. Then, install dependencies.

$ git clone git@github.com:airswap/airswap-maker-kit.git
$ cd airswap-maker-kit
$ yarn install

Now, generate a private key.

$ yarn utils:account

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

$ 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

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

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-maker-kit-examples/ directory if you’re not there already. Then start your maker locally by running:

$ now dev

In the second window, navigate to airswap-maker-kit/ which we cloned down earlier and run yarn peers: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. For all of the other prompts, you can just press enter/return on your keyboard to accept the default. By default, it will ask for a price quote to buy “100 DAI/WETH”. In English, this translates to “I want to buy 100 DAI in exchange for my 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.


Note: The information contained in this blog post is solely for information purposes and does not constitute financial or legal advice. Users agree that their activity and conduct in connection with their use of AirSwap or any tools described in this post, including any resultant transactions, will be in compliance with all applicable laws, rules, regulations, requirements, guidelines, policies, economic or financial sanctions.


More about AirSwap

Fluidity

Rebuilding Finance for a Frictionless World

Graham Perich

Written by

👨‍💻 Software Engineer - building the future of trade @AirSwap

Fluidity

Fluidity

Rebuilding Finance for a Frictionless World

Welcome to a place where words matter. On Medium, smart voices and original ideas take center stage - with no ads in sight. Watch
Follow all the topics you care about, and we’ll deliver the best stories for you to your homepage and inbox. Explore
Get unlimited access to the best stories on Medium — and support writers while you’re at it. Just $5/month. Upgrade