Deploy a Serverless Maker Bot on AirSwap (Part I) – Fluidity

Deploy a Serverless Maker Bot on AirSwap (Part I) – Fluidity

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.

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.

We recently released the AirSwap Maker Kit. This JavaScript library provides helpful utilities and example code to aid developers in building on top of the Swap Protocol. We will be importing the handlers.js file to our project. This is where all of the pricing logic lives, and it will act as a useful reference when you want to create your own custom pricing logic in the future. The Maker Kit also includes some helpful scripts for administrative tasks. We’ll use these scripts to approve tokens for trade, set indexer intents, and test our maker locally.

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.

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` && yarn

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 fetch && git checkout zeit-tutorial-starting-point

Then, navigate to the zeit/ directory and install dependencies

cd zeit && yarn

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 Maker Kit provides helpful many helpful utilities, including Ethereum account generation. Follow the steps below to get your private key.

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

git clone git@github.com:airswap/airswap-maker-kit.git && cd airswap-maker-kit

Next, install dependencies

yarn

Now, generate a private key.

yarn utils:account

Your result should look like this:

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

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.

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 helperimport winston from 'winston' // loggerimport connect from 'connect' // expressJS-like middleware helperimport cors from 'cors' // CORS middlewareimport bodyParser from 'body-parser' // body parsing middlewareimport initHandlers from '@airswap/maker-kit' // 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 readyif (!process.env.ETHEREUM_ACCOUNT) 

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 loggerconst logger = winston.createLogger() => : $`    }),})

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 keyconst 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 requestsconst server = new jayson.Server(handlers,  request`)      return this._methods[method]    } catch (e) )    }  },})

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 helperconst app = connect()// Parse JSON request bodyapp.use(bodyParser.json())// Do preflight OPTIONS check before the jayson middlewareapp.use(cors())// Apply our order handlersapp.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/zeit/ 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. We’ll cover these steps in the next installment of this tutorial coming next week.

Published at Wed, 27 Nov 2019 19:53:25 +0000

{flickr|100|campaign}