Dev Blog: A Tale of Typescript Conversion


Today I'm excited to announce that Napkin has been acquired by Klaviyo 🎉

[Klaviyo](https://klaviyo.com), a customer data platform, is unique in its continued focus on building a [best-in-class developer
platform](https://developers.klaviyo.com/en) - that includes more APIs, better documentation, and -- most relevantly -- a way for users to quickly code and deploy their own integrations. Enter Napkin!

In order to continue to provide the best possible experience to their customers, Klaviyo has actually been using Napkin – and promoting
it to those customers – since last spring. By acquiring Napkin, Klaviyo will provide value in 2 ways:

- Enable Klaviyo customers to easily integrate with Klaviyo APIs via Napkin’s cloud function interface. In the coming months, we’ll be creating new ways
  to empower customers by seamlessly integrating Klaviyo’s creator tools with Napkin’s developer tools 🤝
- Provide resources to further drive Napkin’s growth and functionality!

**To reiterate, Napkin is not shutting down**. I will be joining Klaviyo and together we will be working to make Napkin even better!

I’m extremely excited for what’s to come and I want to thank all of Napkin’s supporters for helping it reach this stage.
We’ll be sharing more details in the coming months, but in the meantime, I encourage Napkin users to
follow [@Klaviyo on Twitter](https://twitter.com/klaviyo) for the latest Napkin updates. Thanks again, and keep on coding 💪


Nick Sypteras

Big News: Napkin is Joining Klaviyo!


If you need to create a form or quiz, the first thing you probably think of is Google Forms. Unfortunately, there’s no easy way to get notifications when someone actually submits your form. The only default notification method Google Forms provides is email; however, most people nowadays look to chat apps like Slack or Discord for up-to-date notifications.

Thankfully with Napkin, it’s easy to build a function that pings Slack or Discord whenever there’s a new form submission. In this post, we’ll show how to set up that function ourselves (you can also [fork the JS version](https://www.napkin.io/n/be6ce78b626f4324) or the [Python version](https://www.napkin.io/n/3c877a063353495d)). Read on for a step-by-step guide as well as how to set up the appropriate Google and Slack APIs.

### Create A Google Form

First thing’s first, let’s make a [Google Form](https://docs.google.com/forms/u/0/). For this example, we made a simple form that asks the user for their ice cream preferences. You can see it here [https://forms.gle/JxYCJN2NjpwhF8387](https://forms.gle/JxYCJN2NjpwhF8387). Feel free to copy this one as you do this tutorial.

### Enable Google Sheets Sync For Your Form

We’ll have Google save the submission data in Google Sheets so we can access it from our Napkin function. To enable Google Sheets syncing for your form, go to the “Responses” tab of your Google Form. Click the green Google Sheets icon and then “Create”. Google will now save all form submission data to the spreadsheet that was just created.

![sync-google-sheets](/images/blog/20220615/sync_google_sheets_button.png)

## Create A Google Cloud Project with Access to Google Forms

In order to get programmatic access to Google Forms and Sheets, we need to create a new Project in Google Cloud Console. Head to [https://console.cloud.google.com/projectcreate](https://console.cloud.google.com/projectcreate) and create a new Project.

![create-gcp-app](/images/blog/20220615/create_gcp_app.png)

Next we need to give our project access to **Google Forms** and **Google Sheets**.

### Google Sheets Access

Visit [here](https://console.cloud.google.com/marketplace/product/google/sheets.googleapis.com) in the GCP dashboard and click Enable.

![grant-google-sheets-api-access](/images/blog/20220615/enable_google_sheets_api.png)

### Google Forms Access

Same thing for Google Forms: enable that [here](https://console.cloud.google.com/marketplace/product/google/forms.googleapis.com).

![grant-google-forms-api-access](/images/blog/20220615/enable_google_forms_api.png)

The last thing we need to do here is create a set of credentials for our **Napkin Function** to access these resources on behalf of our Google Project. In Google Cloud, this is done by creating a _Service Account_, which is essentially a “bot” Google account that has access to our GCP Project and our Google Sheet. Once that’s created, we create API credentials for our Service Account and then use those credentials in our Napkin function.

### Setting Up a Google Project Service Account

Go to [https://console.cloud.google.com/iam-admin/serviceaccounts/create](https://console.cloud.google.com/iam-admin/serviceaccounts/create), give your Service Account a name, and then assign it the “Owner” role, then click “Done”.

![create-service-account](/images/blog/20220615/create_service_account.png)

![grant-owner-role](/images/blog/20220615/grant_service_account_role.png)

### Generate the Service Account’s API Key

From the Google Cloud dashboard, click the hamburger icon next to your new service account and then click “Manage Keys”.

![service_account_manage_keys.png](/images/blog/20220615/manage_keys_button.png)

Now click the “Add Key” dropdown, “Create new key”, and “Create” (make sure “JSON” is selected as the Key Type). A JSON file with your credentials will be automatically downloaded. We will be using this shortly.

Last thing we need to do is give our new service account access to our Google Sheet. Just copy the service account email from the GCP dashboard and then share your Google Sheet with that email (just as if it were a human account).

### Create New Napkin Function

Head to [https://napkin.io](https://napkin.io) and create a new Napkin function. There are example functions you can fork for both [Python](https://www.napkin.io/n/3c877a063353495d) and [Javascript](https://www.napkin.io/n/be6ce78b626f4324), but for this tutorial we’ll use Javascript.

![new_function.png](/images/blog/20220615/new_function.png)

First, add the [google-spreadsheet](https://www.npmjs.com/package/google-spreadsheet) and [node-fetch](https://www.npmjs.com/package/node-fetch) modules to your function. This will make accessing the Google Sheets data easier.

![modules.png](/images/blog/20220615/modules.png)

Remember the JSON file that was saved when we created our service account key? Let’s upload it to Napkin so our function can use it to authenticate with Google. Go to the “Other” tab in the Napkin editor and drag the file into the Files section.

![files.png](/images/blog/20220615/files.png)

Finally, we'll add the ID of our Google Sheet as an env variable. Go to the Google Sheet, copy the ID from the URL and paste it into the Environment Variables section of Napkin's "Other" tab.

![env-vars-1](/images/blog/20220615/env_vars_1.png)

### The Code

At a high level, our code will do the following:

1. Read the data from the Google Sheet.
2. Check if the latest submission has been reported yet by comparing the timestamp to the latest timestamp we have stored in the [Napkin Key-Value store](https://docs.napkin.io/javascript/key-value-store).
3. Notify Slack with the latest form data. Then, cache our latest submission timestamp in the Napkin Key-Value store for the next time the function runs.

You can copy the code below, or just fork the function [here](https://www.napkin.io/n/be6ce78b626f4324). See [here](https://www.napkin.io/n/3c877a063353495d) for Python code

```jsx
import { store } from "napkin"
import { GoogleSpreadsheet } from "google-spreadsheet"
import fetch from "node-fetch"
import fs from "fs"

const credsFilePath = "/opt/files/service_account.json"
const SlackWebhookURL = process.env.SLACK_WEBHOOK_URL
const isLaterThan = (t1, t2) => new Date(t1) > new Date(t2)

const objToBlocks = (obj) => {
  const blocks = {
    blocks: [
      {
        type: "header",
        text: {
          type: "plain_text",
          text: "New Form Submission :icecream:",
          emoji: true
        }
      }
    ]
  }

  Object.keys(obj).forEach((text) => {
    blocks.blocks.push({
      type: "section",
      text: {
        type: "mrkdwn",
        text: `*${text}*\n${obj[text]}`
      }
    })
  })

  // add a divider to improve readability
  blocks.blocks.push({
    type: "divider"
  })

  return blocks
}

const sendSlackMessage = async (blocks) => {
  await fetch(SlackWebhookURL, {
    headers: {
      Accept: "application/json",
      "Content-Type": "application/json"
    },
    method: "POST",
    body: JSON.stringify(blocks)
  })
}

export default async (req, res) => {
  const creds = await fs.promises
    .readFile(credsFilePath, "utf8")
    .then((data) => JSON.parse(data))
    .catch((err) => {
      console.info("There was an error")
      console.error(err)
    })

  const doc = new GoogleSpreadsheet(process.env.SHEET_ID)
  await doc.useServiceAccountAuth(creds)
  await doc.loadInfo()

  const sheet = doc.sheetsByIndex[0]
  const rows = await sheet.getRows()

  if (rows.length == 0) {
    console.info("No submissions yet. Exiting...")
    return
  }

  const latestTs = rows[rows.length - 1].Timestamp

  const allSubmissions = rows.map((r, i) => {
    return Object.fromEntries(
      sheet.headerValues.map((name, j) => {
        return [name, r[name]]
      })
    )
  })

  const storeKey = `lastCached-${process.env.SHEET_ID}`

  const { data } = await store.get(storeKey)

  if (!data || isLaterThan(latestTs, data)) {
    const newSubmissions = data
      ? allSubmissions.filter((x) => isLaterThan(x.Timestamp, data))
      : allSubmissions
    const messageBlocks = newSubmissions.map(objToBlocks)

    for (let blocks of messageBlocks) {
      await sendSlackMessage(blocks)
    }

    const maxTs = Math.max(...newSubmissions.map((x) => new Date(x.Timestamp)))
    await store.put(storeKey, maxTs)
    console.info("Cached new latest timestamp:", maxTs)
  }
}
```

Notice we’re loading the Slack webhook URL from our function’s environment variables. Let’s set up that webhook now.

### Setting Up a Slack Webhook

Check out our guided example of how to build a Slack Webhook function [here](https://www.napkin.io/n/3d7541122cc34227). Once you’ve generated your webhook URL, paste it into your function’s env vars (where we put the Google Sheet ID).

![env_vars.png](/images/blog/20220615/env_vars_2.png)

### Schedule The Function To Run Every Minute

Click the “Schedule” button in the Napkin editor. Enable scheduling, select “Every Minute”, and then “Done”. The function will now run automatically every minute.

### Test It!

Let’s test everything end-to-end. Submit a response to your form. Within a minute, you should get a Slack notification like this.

![slack-message-example](/images/blog/20220615/slack_message.png)

And that’s it! Now all that needs to be done is to go get some people to fill out your form 🙂

If you’re interested in getting Discord notifications, you can check out [this example](https://www.napkin.io/n/676202a945d541be) (Python version [here](https://www.napkin.io/n/c9e82495459d4f4a)) and integrate the code into the function we just created. If you have any questions, feel free to reach out for help on our [Discord](https://discord.gg/VZ2wpsnAHu)!


Learn how to get Slack notifications when someone submits your Google Form

Napkin

How to Get Google Form Responses on Slack


With [more than 10 million daily active users](https://techjury.net/blog/slack-statistics/#gref), Slack changed the way people work: 600,000 organizations use Slack as part of their daily workflow, and chances are you do as well.

At [Napkin](napkin.io), we use Slack every day to work and bond remotely. As a young startup, we were naturally led to use Slack’s extensive app catalog of +4000 slackbots. As developers, we eventually figured out how to create a slack bot of our own. In this slack bot tutorial, we teach you how to do it yourself in just a few minutes―but not alone!

## Why You Should Make A Slack Bot

A Slack bot allows you to do more by leveraging Slack’s application programming interface instead of the regular graphical user interface. [Slack offers +100 API methods](https://api.slack.com/methods) to do anything from analytics to sending or reading a message―the sky's the limit.

During work hours, Slack is an app the majority of users run in the background―replacing meetings and emails to a great extent. Building a slackbot takes you a step further by automating tasks in your Slack workspace. You could build a report app to access all your messages on a given day and compute some usage statistics to measure the level of activity in your organization, for example.

Last but not least, developing a Slack bot opens the possibility to integrate third-party tools & processes into your Slack workspace that don’t already have a Slack app―making it the perfect place to centralize all your tools in a single cohesive whole. Unlike [bots on regular messaging apps like Telegram](https://www.napkin.io/blog/build-telegram-bot-in-4-minutes), slackbots can span all your channels across your entire organization in one shot.

## How To Make A Slack Bot Reminder In 9 Steps

For the sake of simplicity, we're going to build a bot in Python that reminds you to drink water every hour―a Slackbot reminder! It’s a simple yet powerful example because it will walk you through the whole process of coding a slackbot in only 9 steps (~15 minutes tops).

### 1. Create a Slack app

First, you need to register a new Slackbot app.

Head to your Slack workspace and navigate to **Settings > Settings & administration > Manage apps**. Then, click on **Build** in the navigation bar. You can also go directly to [https://api.slack.com/apps/](https://api.slack.com/apps/).

Press the “**Create an App**” button.

![Create a Slack app](/images/blog/20220228/1-create-app.jpg "Create a Slack app")

### 2. Configure your Slackbot

We start the app from scratch with the name “_Hourly Reminder_” and a workspace created for the occasion:

![Slack app configuration](/images/blog/20220228/2-app-config.jpg "Slack app configuration")

In the left sidebar, configure your app’s permissions by clicking on **OAuth & Permissions**.

Then go to **Scopes** and check the scope _chat:write_. Scopes limit what your bot can do and which API features your bot can use. It’s a security mechanism. The Slack API proposes dozens of scopes, but for this example we only need to send messages to a public chat―hence the scope _chat:write_.

You need to generate an authentication token to interact with the Slack API. Create a new bot oauth token and copy it for later.

Next, click on “**Install to workspace**”. The slackbot _Hourly Reminder_ is now available in your workspace:

![Installed Slack bot](/images/blog/20220228/3-installed-bot.jpg "Installed Slack bot")

You need to add the bot to a channel to use it. Let’s use the “_general_” channel for example. In your Slack workspace, click on the channel and go to **Channel Settings > Integrations > Apps > Add apps**. Select your Slack bot and you’re good to go:

![Add app to Slack channel](/images/blog/20220228/4-add-app.jpg "Add app to Slack channel")

### 3. Test Your Slack API Endpoint

All it takes to interact with the Slack API is an HTTP request to the public API endpoint. Let’s try to post a message in the general channel with a simple curl command from your computer terminal:

```
curl \
-X POST \
-H "Content-Type: application/json" \
-H "Authorization: Bearer <Your Slack Token>" \
-d '{"channel":"general", "text":"test"}' \
https://slack.com/api/chat.postMessage
```

The curl command sends a HTTP POST request containing JSON data to the endpoint _chat.postMessage_, as specified in [the official documentation](https://api.slack.com/methods/chat.postMessage). The authentication token is defined in an Authorization header. You can log into your workspace and check the message you've sent:

![Slack message sent using curl command](/images/blog/20220228/5-curl-test.jpg "Slack message sent using curl command")

Now of course, you want to automate the sending part with a web server and a program written in Python.

### 4. Set up your Python web server

Creating a custom bot implies hosting the programming logic in a web server. Slack only offers an API and cannot host code for you, but you still need to tell your bot what needs to be done.

[To make things much simpler, we are going to use Napkin](https://www.napkin.io/philosophy)’s serverless platform to build and deploy our code without having to configure a web server ourselves, in less than a minute and for free.

[Create an account](https://www.napkin.io/signup), add a new project by clicking “**New Function**”, pick Python as your runtime language, choose a name, and you’re ready to code:

![Creating a new Napkin function](/images/blog/20220228/6-new-function.jpg "Creating a new Napkin function")

For this demo, we will only need a single Python module to perform HTTP requests. We choose _requests_ as our HTTP library.

[To add a module to your dev environment](https://docs.napkin.io/python/install-module) you simply click on the **Modules tab**, search the module “_requests_”, and click the Download icon:

![Installing a Python module to Napkin](/images/blog/20220228/7-install-module.jpg "Installing a Python module to Napkin")

### 5. Send custom responses to Slack

Let’s write some code now. First, you want to be able to send a message to the Slack API in the form of a HTTP request, using the _requests_ library we just installed.

As you saw in step 3, we need 3 variables―a bot token, the API endpoint, and a message to send:

```python
slackbot_token = "<Your Slackbot Token>"
url = 'https://slack.com/api/chat.postMessage'
message = "sent from Napkin"
```

And then you combine all these elements in a HTTP POST request:

```python
import requests

slackbot_token = "<Your Slackbot Token>"
url = 'https://slack.com/api/chat.postMessage'
message = "sent from Napkin"

requests.post(
    url,
    headers={
        "Content-Type":"application/json",
        "Authorization": "Bearer " + slackbot_token
    },
    json={
        "channel": "general",
        "text": message
    }
)
```

The authentication token needs to be sent in an Authorization header, and we add a “Content-type” header to tell Slack the HTTP request contains JSON data. According to the Slack API documentation, you need two JSON fields: a channel defined by a name or an identification number, and a text.

With your current app scopes, the slackbot needs to be added to the channel to be able to send a message. Fortunately, you already added _Hourly Reminder_ to the _general_ channel in step 2.

You can test the function in Napkin by clicking the **Run** button in the top right corner of the screen. You obtain the same result:

![Slack message sent from Napkin](/images/blog/20220228/8-sent-napkin.jpg "Slack message sent from Napkin")

### 6. Write the business logic

A reminder message should be sent every hour, so let’s make sure our bot works as expected by displaying the time of the day along with the message “_Remember to drink water_”.

First, import Python's “_datetime_” library to get the current date and time:

```python
from datetime import datetime

now = datetime.now().strftime("%d/%m/%Y %H:%M:%S")

message = "It's " + now + ", remember to drink water."
```

The _now_ variable is simply the current datetime in a string data type following the format _Day/Month/Year Hour:Minute:Second_. The final message is a concatenated text containing the _now_ variable.

And we obtain:

![Adding a datetime to the Slack message](/images/blog/20220228/10-drink-water.jpg "Adding a datetime to the Slack message")

Except for a timezone difference between Slack and our server, all is well. You can fix that by using [Slack’s users.info API endpoint](https://api.slack.com/methods/users.info), which contains info regarding the user’s timezone, but this is out of the scope of this article.

### 7. Set environment variables

To make the code cleaner, you can define your Slack bot token as [a secure environment variable](https://docs.napkin.io/python/environment-variables). Hard-coding your bot’s authentication token is bad practice as anyone reading it can send messages in your stead, so you should hide this sensitive information in a secret stored in an environment variable.

Switch to the **Others** tab, find the **Environment Variables** section, and add one:

![Adding an environment variable to Napkin](/images/blog/20220228/11-env.jpg "Adding an environment variable to Napkin")

This is the final code with the token referred as an environment variable:

```python
import os

slackbot_token = os.getenv("SLACKBOT_TOKEN")

message = "It's " + now + ", remember to drink water SECURELY."
```

An environment variable is accessed using the _getenv_ method from the “_os_” library.

The corresponding result message:

![Slack message using an environment variable](/images/blog/20220228/12-secure-message.jpg "Slack message using an environment variable")

### 8. Send a reminder every hour

For the initial objective to be considered completed, you still need to have the Cloud function triggered once every hour.

With a traditional web server configuration, you’d need to set up a cron job to run your code every hour, but Napkin's Schedule feature makes it much simpler―just go to the online code editor and click the **Schedule** button:

![Scheduling a Cloud function with Napkin](/images/blog/20220228/13-schedule.jpg "Scheduling a Cloud function with Napkin")

What do we get?

![Scheduled Slack message](/images/blog/20220228/14-scheduled-message.jpg "Scheduled Slack message")

As expected, the function runs at each new hour.

### 9. Protecting your endpoint

Last but not least, you want to protect your server endpoint to avoid malicious people from running your Cloud functions behind your back. Anyone with the URL of your Cloud function can use it, but you can [use Napkin's simple API authentication system](https://docs.napkin.io/api-auth) to prevent that.

Just go to the **Other** tab and toggle the **API Authentication** feature:

![API authentication with Napkin](/images/blog/20220228/15-auth.jpg "API authentication with Napkin")

Now, visiting the URL of your Cloud function results in an error if you do not add your API key to the header of each HTTP request, so no untrusted request will be able to run your Cloud function without your knowledge:

```python
curl <your cloud function URL endpoint>
$ {"message": "Unauthorized"}
```

## Use Napkin To Create A Slack Bot

That’s it, you know how to build a slack bot! This slack bot tutorial may look simple, but it’s all you need to get started. You can use Napkin to add more features to your bot, and the best part―[it’s free even with unlimited functions](https://www.napkin.io/pricing)!

If you prefer using Discord over Slack, check out our code our code example on [how to build a Discord bot](https://www.napkin.io/n/ed3ee69ae2fc496f).


A Slack bot allows you to do more by leveraging Slack’s application programming interface instead of the regular graphical user interface.

(2022) How To Create A Bot For Slack In Python


I was browsing Web3 Twitter last week and came across a cool project just
launched by [@Traf](https://twitter.com/traf/status/1478154666596872192): [value.app](https://value.app). It's
a site that estimates the current total value of all NFTs belonging to any Ethereum wallet.

I loved the idea so much that I decided to build my own “bot version” on
Napkin. This "NFT Portfolio Tracker Bot" sends me updates on my/others’ NFT portfolio
performance each day on Discord. Here's how it looks.

![nft tracker bot message](/images/blog/20220110/gm.png)

And no, that’s not the value of my NFT collection, sadly. It’s Serena Williams’, who I
recently found out is a fellow JPEG collector.

![degen serena](/images/blog/20220110/degen_serena.png)

But back to the tracker bot. In this tutorial, we’ll go through how to make one yourself for free using
Napkin! You can follow the tutorial below or simply fork the function [here](https://www.napkin.io/n/48bc02205e1c4743).

## Set Up The Discord Bot

First, lets set up a bot on Discord to send us messages from our Napkin function.
Go to your Discord server settings, then `Integrations -> Webhooks` , then click `New Webhook`.

![new webhook button](/images/blog/20220110/discord_settings.png)

Give your Webhook Integration a name and select what channel it will post in. Don’t
forget to give your bot a beautiful face!

![new webhook button](/images/blog/20220110/webhook_settings.png)

Save your changes, copy the Webhook URL and then head over to [napkin.io/dashboard/new](https://napkin.io/dashboard/new) to
create a new Python function.

![new function](/images/blog/20220110/new_function.png)

## Setting Up Your Napkin Environment

First off, let’s add our webhook URL as an environment variable for our function.
Go to the Other tab and add a new Environment Variable called `WEBHOOK_URL`. Let’s also
add an environment variable for the wallet address we want to
track (Serena Williams is 0x0864224f3cc570ab909ebf619f7583ef4a50b826 🎾).

![environment variables](/images/blog/20220110/env_vars.png)

As for modules, we’ll only need one: [requests](https://pypi.org/project/requests/), to make HTTP requests
to the [OpenSea API](https://docs.opensea.io/)\*. You can easily add it (and any other modules you want) in
the Modules tab of the Napkin editor.

![modules](/images/blog/20220110/modules.png)

\*_Quick note on the OpenSea API: You can use it without an API key, but for production use cases
you should [request a free one](https://docs.opensea.io/reference/request-an-api-key)._

## What’s A NFT Actually Worth?

Assessing the value of a NFT is a highly... ahem... debated topic. There’s no purely
objective way to do it, so feel free to use your own logic. The simple logic my function uses
is to **assign each NFT the value of either the NFT collection’s Floor Price or the last
amount paid for the NFT if the collection floor isn’t known.** In pseudo code, we can define this as:

```python
nft_value = collection_floor_price(nft)

if nft_value == null:
	nft_value = last_purchase_price(nft)
```

## The OpenSea API

Given our value definition above, we’ll need 2 pieces of data from the OpenSea API: the floor of
a given NFT collection, and the price that the owner paid for a NFT. We can get these using the
following endpoints:

- **[Floor](https://docs.opensea.io/reference/getting-assets)** (`https://api.opensea.io/api/v1/collection/{collection_slug}/stats`)
- **[Last Price Paid](https://docs.opensea.io/reference/retrieving-collection-stats)** (`https://api.opensea.io/api/v1/assets`)

Our API requests will then look like this

```python
def opensea_api(path, **kwargs) -> dict:
   res = requests.get(f"https://api.opensea.io/api/v1/{path}", **kwargs)

   return res.json()

def get_nfts(address) -> dict:
		# if you're address has > 50 NFTs, you'll also need pagination logic here
   data = opensea_api(f"assets?order_direction=desc&limit=50&owner={address}")

   nft_holdings = {}

   for asset in data['assets']:
       slug = asset['collection']['slug']
       last_sale = asset.get('last_sale') or {}
       str_price = last_sale.get('total_price', '0')
       int_price = int(str_price) / 1000000000000000000

       if slug in nft_holdings:
           nft_holdings[slug].append(int_price)
       else:
           nft_holdings[slug] = [int_price]

				return nft_holdings

def update_with_floor_prices(nft_holdings) -> None:

   slugs = [s for s in nft_holdings.keys()]
   for slug in slugs:
       floor_price = get_floor(slug)

       if floor_price > 0.0:
           nft_holdings[slug] = [floor_price for h in nft_holdings[slug]]

def get_floor(slug) -> float:
   data = opensea_api(f"collection/{slug}/stats")

   # if opensea can't find it, then we can't guess the value
   if not data.get('success', True):
       return 0

   floor_price = data['stats']['floor_price'] or 0

   return floor_price
```

## Tracking Value Over Time

We’ll be wanting to compare the portfolio’s current value to it’s historical value. We can cache and retrieve
the historical value by saving data to the Napkin key-value store.

```python
from datetime import datetime
from napkin import store

TIMESTAMP_FMT = "%Y-%m-%d-%H:%M"
store_key = f"{ADDRESS}_value"

def save(current, **kwargs):
    time_now = datetime.now().strftime(TIMESTAMP_FMT)
    store.put(store_key, {
        'previous': current,
        'last_checked': time_now,
        'initial_checked': kwargs.get('initial_checked', time_now),
        'initial': kwargs.get('initial', current)
    })

def previous_value_eth(address):
    data = store.get(store_key)['data'] or {}

    return {
        'last_checked': data['last_checked'],
        'initial_checked': data['initial_checked'],
        'previous': data['previous'],
        'initial':data['initial']
    }
```

Every time our function runs, we’ll see what the previous value was, compare it to the current
value, and then save the current value in the database to be compared with next time.

## Sending a Message on Discord

Here, we compare the previous value to the current value, and then POST
the results to our Discord webhook URL. To make things look nice, I also included
some extra formatting in the request
payload. [Here’s a nice cheatsheet I found](https://gist.github.com/Birdie0/78ee79402a4301b1faf412ab5f1cdcf9)
if you want to change how the message looks.

```python
import os
webhook_url = os.getenv('WEBHOOK_URL')

def send_message(current_value, previous=None, initial=None, initial_checked=None, last_checked=None):

   gain_from_prev = current_value - previous
   gain_from_init = current_value - initial

   trend_from_prev = 'upwards' if gain_from_prev >= 0 else 'downwards'
   trend_from_init = 'upwards' if gain_from_init >= 0 else 'downwards'

   pct_from_prev = round(gain_from_prev / previous, 2)
   pct_from_init = round(gain_from_init / initial, 2)

   if trend_from_init == trend_from_prev == 'upwards':
       color = 2206495
   elif trend_from_init == trend_from_prev == 'downwards':
       color = 15547966
   else:
       color = 7237230

   def fmt(timestamp):
       now = datetime.now()
       dt = datetime.strptime(timestamp, TIMESTAMP_FMT)

       delta = now - dt

       if delta.days > 0:
           return dt.strftime("%b %d, %Y")

       if delta.seconds > 3600:
           return f"{delta.seconds // 3600} hours ago"

       if delta.seconds > 60:
           return f"{delta.seconds // 60} minutes ago"

       return "Just now"


   requests.post(webhook_url, json={
       'content': "gm",
       'embeds': [
           {
               'title': f"Total Value: {round(current_value, 2)} Ξ :sparkles:",
               'description': f"Last checked {fmt(last_checked)}. Started tracking {fmt(initial_checked)}.",
               'color': color,
               'fields': [
                   {
                       'name': f'Since Last Checked',
                       'value': f"{pct_from_prev*100}% :chart_with_{trend_from_prev}_trend:",
                       'inline': False
                   },
                   {
                       'name': f'All Time',
                       'value': f"{pct_from_init*100}% :chart_with_{trend_from_init}_trend:",
                       'inline': False
                   }
               ],
               'footer': {
                   'text': f"https://opensea.io/assets/{ADDRESS}"
               }
           },
       ],

   })
```

And that’s the gist of it! Here’s what all the code looks like
together (**[you can also fork it here](https://www.napkin.io/n/48bc02205e1c4743)**).

```python
import os
import requests
from napkin import store, response
from datetime import datetime

# serena williams wallet
# 0x0864224f3cc570ab909ebf619f7583ef4a50b826


ADDRESS = os.getenv('WALLET_ADDRESS')
WEBHOOK_URL = os.getenv('WEBHOOK_URL')
TIMESTAMP_FMT = "%Y-%m-%d-%H:%M"

store_key = f"{ADDRESS}_value"

def opensea_api(path, **kwargs) -> dict:
   res = requests.get(f"https://api.opensea.io/api/v1/{path}", **kwargs)

   return res.json()

def get_nfts(address):
   data = opensea_api(f"assets?order_direction=desc&limit=50&owner={address}")

   nft_holdings = {}

   for asset in data['assets']:
       slug = asset['collection']['slug']
       last_sale = asset.get('last_sale') or {}
       str_price = last_sale.get('total_price', '0')
       int_price = int(str_price) / 1000000000000000000

       if slug in nft_holdings:
           nft_holdings[slug].append(int_price)
       else:
           nft_holdings[slug] = [int_price]

   return nft_holdings

def update_with_floor_prices(nft_holdings):

   slugs = [s for s in nft_holdings.keys()]
   for slug in slugs:
       floor_price = get_floor(slug)

       if floor_price > 0.0:
           nft_holdings[slug] = [floor_price for h in nft_holdings[slug]]

def get_floor(slug) -> float:
   data = opensea_api(f"collection/{slug}/stats")

   # if opensea can't find it, then we can't guess the value
   if not data.get('success', True):
       return 0

   floor_price = data['stats']['floor_price'] or 0

   return floor_price


def portfolio_value_eth(address):
   nft_holdings = get_nfts(address)
   total_value_eth = 0

   # for each nft, get the floor price if available
   update_with_floor_prices(nft_holdings)

   for slug, holdings in nft_holdings.items():
       total_value_eth += sum(holdings)

   return total_value_eth


def previous_value_eth(address):
   data = store.get(store_key)['data']

   if data is None:
       return {}

   return {
       'last_checked': data['last_checked'],
       'initial_checked': data['initial_checked'],
       'previous': data['previous'],
       'initial':data['initial']
   }

def save(current, **kwargs):
   time_now = datetime.now().strftime(TIMESTAMP_FMT)
   store.put(store_key, {
       'previous': current,
       'last_checked': time_now,
       'initial_checked': kwargs.get('initial_checked', time_now),
       'initial': kwargs.get('initial', current)
   })

def send_message(current_value, previous=None, initial=None, initial_checked=None, last_checked=None):

   gain_from_prev = current_value - previous
   gain_from_init = current_value - initial

   trend_from_prev = 'upwards' if gain_from_prev >= 0 else 'downwards'
   trend_from_init = 'upwards' if gain_from_init >= 0 else 'downwards'

   pct_from_prev = round(gain_from_prev / previous, 2)
   pct_from_init = round(gain_from_init / initial, 2)

   if trend_from_init == trend_from_prev == 'upwards':
       color = 2206495
   elif trend_from_init == trend_from_prev == 'downwards':
       color = 15547966
   else:
       color = 7237230

   def fmt(timestamp):
       now = datetime.now()
       dt = datetime.strptime(timestamp, TIMESTAMP_FMT)

       delta = now - dt

       if delta.days > 0:
           return dt.strftime("%b %d, %Y")

       if delta.seconds > 3600:
           return f"{delta.seconds // 3600} hours ago"

       if delta.seconds > 60:
           return f"{delta.seconds // 60} minutes ago"

       return "Just now"


   payload = {
       'content': "gm",
       'embeds': [
           {
               'title': f"Total Value: {round(current_value, 2)} Ξ :sparkles:",
               'description': f"Last checked {fmt(last_checked)}. Started tracking {fmt(initial_checked)}.",
               'color': color,
               'fields': [
                   {
                       'name': 'Since Last Checked',
                       'value': f"{pct_from_prev*100}% :chart_with_{trend_from_prev}_trend:",
                       'inline': False
                   },
                   {
                       'name': 'All Time',
                       'value': f"{pct_from_init*100}% :chart_with_{trend_from_init}_trend:",
                       'inline': False
                   }
               ],
               'footer': {
                   'text': f"https://opensea.io/assets/{ADDRESS}"
               }
           },
       ],

   }
   print(payload)
   res = requests.post(WEBHOOK_URL, json=payload)

   print(res.content)


# main
current_value = portfolio_value_eth(ADDRESS)
prev_data = previous_value_eth(ADDRESS)
if len(prev_data) > 0:
   send_message(current_value, **prev_data)
save(current_value, **prev_data)

```

Make sure to run the function once manually to populate the key-value store with initial values - that way
when the schedule runs there will be something to compare to.

## Running On A Schedule

Finally let’s schedule our function so it automatically gives us updates. Napkin lets you
schedule functions to run every hour, every minute - but for our sanity, let’s stick to once a day 🙂

![schedule](/images/blog/20220110/schedule_modal.png)

And that’s it! You now have a personal assistant tracking your NFT portfolio. There’s a lot of
directions you could go from here. If you want your bot to respond to slash commands,
check out my previous
post, [Build a Discord Bot to Track the ISS](https://www.napkin.io/blog/where-is-iss-discord-bot), for
a guide on how to set that up.

That’s it! Have fun, be safe. gn 🌜


Build a bot to track the value of your NFT portfolio

NFT Portfolio Tracker Bot on Discord with Napkin


Building bots is a whole lot of fun, although setting them up can be a bit tedious.
Today I'm going to show you how to build and deploy a telegram bot in under four minutes.

## Minute 1 - Create a bot profile

To build a bot on telegram, first, you need a bot profile. To do that,
open Telegram and search for `@botfather`

![Search for @botfather bot on telegram](/images/blog/20220107/telegram-search.png)

Go to BotFather and click `Start`. It'll guide you through the process of
creating a bot profile.

![Click start on @botfather to begin a conversation. Botfather lists all commands](/images/blog/20220107/telegram-botfather.png)

Click “/newbot” and it'll ask you a series of questions. Choose a name
and a unique username for you bot. Once that's done, hurray you've
created a new telegram bot! But right now, it does nothing so let's
not pat ourselves on the back just yet.

![click or type command /newbot, choose a name for the bot](/images/blog/20220107/telegram-bot-convo1.png)

Once, the bot is created, it should send you a message with your API key. It'll
look something like the image below. Save the API key somewhere, we'll need it later.

![@botfather sends you a message with the API keys](/images/blog/20220107/telegram-bot-api-key.png)

## Minute 2 - Connecting the bot

Now for the bot to work, we need to run it somewhere. For that, we'll use a
cloud function. If you don't know what a cloud function is, it's basically
a bit of code that runs on a server somewhere and you don't have to manage
anything. Cloud functions are really great for building automation and bots because
they're easy and lightweight. We can use Napkin to quickly code one up.
So head over to [napkin.io](http://napkin.io) and let's build that bot!

![Create napkin function dialog](/images/blog/20220107/napkin-create.png)

Once you've signed on to Napkin, it should take you to the dashboard. Once
there, click on “Create a function”. For this tutorial, we'll choose NodeJS
as the runtime and then name our bot and then click on create.

Napkin will set up all the infrastructure in the cloud to run your code,
then it should take us to the editor where we can code and deploy our bot.

![napkin editor with example code](/images/blog/20220107/napkin-editor.png)

## Minute 3 - Coding the bot

Ok, I know I said code the bot in the title but before that, we'll need
to do a couple of tiny setups. Remember the API key you saved earlier?
Grab that! We have to set-up some env variables.

For the telegram bot to work, we'll need 2 things

- Telegram API key
- Telegram Chat Id

You have the API key, now to get the telegram chat id,
open Telegram → go to search → type `@my_id_bot` on Telegram → click start.
It should give you your chat id. We'll use this to send messages to you.

![/start command for @my_id_bot. Bot replies with telegram user id](/images/blog/20220107/telegram-id.png)

Once you grab that, head over to the `Others` tab > Environment variables and
click on “Add” to add the keys.

![Environment variables tab on napkin. Click on add](/images/blog/20220107/telegram-env.png)

Once you've added them, it should look something like this. Adding env vars
here will make them available in the editor while you code.

![Environment variables added](/images/blog/20220107/napkin-env-add.png)

Now, one last thing before we start coding. We'll be using the `telegraf` library
to interact with the telegram bot API. Napkin comes pre-installed with 300k+ packages
so just head over to the `Modules` Tab and click on the download symbol.

![Install modules on napkin by switching to the modules tab](/images/blog/20220107/napkin-modules.png)

**_Note: To receive messages from your bot, you'll need to go to the bot's profile and click on “/start” to start a conversation. Otherwise you'll see a 404 error._**

Alright, you're good to go now. Now let's begin coding.

## Minute 4 - Actually coding the bot

Go to the `Code` tab of the editor and copy this code. The code initialises
the bot with our API key from earlier and lets us send messages to anyone
if you have their `chat_id`. We grabbed ours from earlier, we can use that.

```jsx
const { Telegraf } = require("telegraf")

const bot = new Telegraf(process.env.telegram_key, {
  telegram: { webhookReply: true }
})

const CHATID = process.env.chat_id

export default async (req, res) => {
  await bot.telegram.sendMessage(CHATID, "hello there!!")
}
```

Once done, click on `Run` and our little bot should send you a message on telegram.

![Telegram bot demo. Bot sends a message when run button is clicked](/images/blog/20220107/napkin-bot-hello.png)

Let's take it one step further, let's make the bot say `hello there` every minute.
To do that on Napkin, it's pretty simple. Just click on the “Schedule” button
on the top right and select “Every Minute” from the options tab and hit save.

![Napkin schedule modal. Choose every minute option](/images/blog/20220107/napkin-schedule.png)

That'll make your function trigger every minute and send you a message each time it runs.

![Napkin scheduling demo. Bot sends message every minute](/images/blog/20220107/napkin-telegram-schedule.png)

## The end

So is this it? Yes, for now, my friend. The end is just the beginning
and that's how you build a bot in 4 minutes. Feel free to customize it more,
I'll write another tutorial soon on how to build a more advanced bot for
telegram. In the meantime, if you want to learn how to build a discord bot,
you can read this post by my friend Nick - **[Build a Discord Bot to Track the ISS with Napkin](https://www.napkin.io/blog/where-is-iss-discord-bot).**

If you've got questions regarding anything, feel free to
stop by on our [Discord](https://discord.com/invite/VZ2wpsnAHu).

Happy building!!


Learn how to build a custom telegram bot in 4 minutes with Napkin

Joel Benjamin

Build a telegram bot with NodeJS in 4 minutes


Discord is moving its API more and more towards event-based interactions (webhooks)
rather than relying on always-on connections (websockets). This is good news as
the internet becomes increasingly serverless, but presents a new challenge for us serverless
developers since guides on how to navigate the new APIs are still slim.

Fear not! **In this article, we'll use Napkin to demystify how to set up a
webhook-based slash command on Discord**. To make things more interesting, our
bot will actually do something cool: show us the current location of
the International Space Station!

Here's how the bot interaction will look on Discord when we're done.

![ISS Bot Demo](/images/blog/20211114/iss_bot_interaction.gif)

Want to skip ahead to the final code? You can check it out and fork it by
following the links below. Or, continue on as we set everything up step-by-step.

[Register Slash Command](https://www.napkin.io/n/4816e451cd1d4166)

**Discord Bot Code**

- [Python Version](https://www.napkin.io/n/ed3ee69ae2fc496f)
- [Javascript Version](https://www.napkin.io/n/5873c6a0dddb4dcb)

[(Bonus) ISS Map Function](https://www.napkin.io/n/61bb5e0bab3848a3)

Still here? Awesome! 😄 Let's get started.

## Initial Setup

First, we'll create a new Application in the Discord Developer Portal. Head over
to [https://discord.com/developers/applications](https://discord.com/developers/applications)
and click "New Application" in the top right.

Next we'll add a Bot to our application. Go to `Settings > Bot`,
create a new one, and enable the Message Content Intent (seen at the bottom).

![Bot Configuration](/images/blog/20211114/discord_application_portal.png)

Lastly, copy the bot's Token by clicking the `Copy` button. We'll need it
for the next step.

![Bot Token Copy Button](/images/blog/20211114/build-a-bot.png)

Now we have to register a slash command for our new application. To do that, we
have to send a HTTP request to the Discord API. You can fork [this Napkin function](https://www.napkin.io/n/4816e451cd1d4166)
to do that - just copy in your Application ID and Bot Token and run it. For
more details on registering commands, check out [Discord's official docs](https://discord.com/developers/docs/intro).

OK. Let's see what we have so far

**Done**

- Application created
- Bot created and configured
- Slash command registered

**Still To Do**

- Write the code
- Point our Application's webhook URL to our Napkin function

## Writing the Code

Head over to [napkin.io/dashboard/new](https://napkin.io/dashboard/new) and
create a new Python function **(for Javascript, see
the [example code here](https://www.napkin.io/n/5873c6a0dddb4dcb))**.

To start, we'll write the logic to verify Discord's security signatures. Discord
uses these signatures to ensure that your bot is capable of identifying legit
requests from Discord and denying unauthorized requests from evildoers on the internet.

Discord doesn't mess around here. It will actually try to trick your bot by sending
bad signatures from time to time. If your bot fails to deny those requests, Discord
takes it offline.

In order to verify those security signatures, Discord recommends using a
popular crypto library like [PyNacl](https://pypi.org/project/PyNaCl/), so we'll do just that. Let's also throw in the rest of the imports we'll need while we're at it.

```python
from napkin import request, response
import os
import uuid
from nacl.signing import VerifyKey
from nacl.exceptions import BadSignatureError
```

OK, now the verification part which trips a lot of people (maybe just me) up. We'll
use the `nacl` module to verify the contents of the the request header sent from
Discord. If it's invalid, we respond with a `401` status. If it's valid,
we do our bot thing 🤖

```python
# you can find your application public key at
# https://discord.com/developers/applications/<my_app_id>/information
PUBLIC_KEY = os.environ['DISCORD_PUBLIC_KEY']

# The code below handles Discord's verification check for webhook-based interactions.
# To read more about the Discord API's security requirements, see:
# https://discord.com/developers/docs/interactions/receiving-and-responding#security-and-authorization
verify_key = VerifyKey(bytes.fromhex(PUBLIC_KEY))
signature = request.headers["X-Signature-Ed25519"]
timestamp = request.headers["X-Signature-Timestamp"]
body = request.body

message = message = timestamp.encode() + request.data.encode()
try:
    verify_key.verify(message, bytes.fromhex(signature))
    # If we get here without a BadSignatureError, we're good!
    response.status_code = 200

		# response logic to go here...
except BadSignatureError:
    # In this case, we failed verification due to one of the following:
    # -----------------------------------------------------------------
    # - Discord is testing our bot to make sure we fail invalid signatures
    # - An unauthorized request is being made to our bot from somewhere on the internet
    response.status_code = 401
    response.body = "Bad Signature"
```

Remember how I mentioned Discord sends requests to your bot just to ensure
it does verification properly? It does that via a certain type of HTTP request
that the API Reference calls a PING request. Request types from Discord are
marked in the request JSON body's `type` field. According to the docs, if we
receive a request where `type` equals 1, it's a PING request, and we should
respond with a simple JSON object containing `{"type": 1}` to acknowledge it.

```python
# https://discord.com/developers/docs/interactions/receiving-and-responding
if body["type"] == 1: # type 1 is a Discord verification check (PING)
	response.body = {'type': 1}
```

With that code added, we can now set our webhook URL in the developer portal!

## Set the Webhook URL

Make sure your code is deployed, then copy the function URL. Go back to the
Discord Developer Portal and paste the URL under
`General Information > Interactions Endpoint URL`. Save changes and Discord
will test our bot to make sure it verifies signatures correctly. You should see
a confirmation message.

![Bot Verified Confirmation](/images/blog/20211114/verification_confirmation.png)

We can actually go to our Napkin function logs and see that Discord has performed
the test. Go to your function's Event Logs and you should see 1 or more PING
requests from Discord. If they really wanted to test you, you might even see
them sending a bad signature in one of the requests and your function responding
with a `401`.

![Successful PING Request](/images/blog/20211114/response_success.png)_Succesful PING request_

![Failed PING Request](/images/blog/20211114/response_fail.png)_Failed verification. Nice try, Discord._

OK. Time for the final piece. The actual slash command response.
It's actually super simple.

```python
if body["type"] == 1: # type 1 is a Discord verification check
    response.body = {'type': 1}

elif body["type"] == 2: # type 2 is a slash command interaction
    response.body = {
        "type": 4, # type 4 = CHANNEL_MESSAGE_WITH_SOURCE
        "data": {
            "embeds": [{
                "title": ":red_circle: Current ISS Location",
                "image": {
                    # add a random uuid argument to prevent Discord from caching image
                    # You can see and fork the iss-map code at
                    # https://www.napkin.io/n/61bb5e0bab3848a3
                    "url": f"https://napkin-examples.npkn.net/iss-map?id={uuid.uuid4()}"
                }
            }]
        }
    }
```

In the interest of [separation of concerns](https://en.wikipedia.org/wiki/Separation_of_concerns),
I've split the code that plots the
position of the ISS into a separate function called `iss-map`. If you're interested
in how that code works, feel free to check it out and fork it [here](https://www.napkin.io/n/61bb5e0bab3848a3)! As for the bot
code, we simply include the iss-map function URL as part of the embed in our
response message.

The final code for the bot should now look like this.

```python
from napkin import request, response
import os
import uuid
from nacl.signing import VerifyKey
from nacl.exceptions import BadSignatureError

# you can find your application public key at
# https://discord.com/developers/applications/<my_app_id>/information
PUBLIC_KEY = os.environ['DISCORD_PUBLIC_KEY']

# The code below handles Discord's verification check for webhook-based interactions.
# To read more about the Discord API's security requirements, see:
# https://discord.com/developers/docs/interactions/receiving-and-responding#security-and-authorization
verify_key = VerifyKey(bytes.fromhex(PUBLIC_KEY))
signature = request.headers["X-Signature-Ed25519"]
timestamp = request.headers["X-Signature-Timestamp"]
body = request.body

message = message = timestamp.encode() + request.data.encode()
try:
    verify_key.verify(message, bytes.fromhex(signature))
    # If we get here without a BadSignatureError, we're good!
    response.status_code = 200

    # what we do now depends on the Interaction Type that Discord sends
    # https://discord.com/developers/docs/interactions/receiving-and-responding
    if body["type"] == 1: # type 1 is a Discord verification check
        response.body = {'type': 1}

    elif body["type"] == 2: # type 2 is a slash command interaction
        response.body = {
            "type": 4, # type 4 = CHANNEL_MESSAGE_WITH_SOURCE
            "data": {
                "embeds": [{
                    "title": ":red_circle: Current ISS Location",
                    "image": {
                        # add a random uuid argument to prevent Discord from caching image
                        # You can see and fork the iss-map code at
                        # https://www.napkin.io/n/61bb5e0bab3848a3
                        "url": f"https://napkin-examples.npkn.net/iss-map?id={uuid.uuid4()}"
                    }
                }]
            }
        }
except BadSignatureError:
    # In this case, we failed verification due to one of the following:
    # -----------------------------------------------------------------
    # - Discord is testing our bot to make sure we fail invalid signatures
    # - An unauthorized request is being made to our bot from somewhere on the internet
    response.status_code = 401
    response.body = "Bad Signature"
```

Now hit "Deploy", head over to Discord, and try it out!

![ISS Bot Demo](/images/blog/20211114/iss_bot_interaction.gif)

Have more questions? Other examples you want to see?
[Let us know on (where else?) our Discord!](http://discord.gg/VZ2wpsnAHu)

Happy building 🛰️


Use Discord's webhook-based API to build a custom slash command

Build a Discord Bot to Track the ISS with Napkin


If you've used Ethereum, you've paid [Gas](https://ethereum.org/en/developers/docs/gas/) to
execute your transaction on the blockchain. And if you've paid Gas, you probably know that
it can be very expensive. In fact, the average ethereum transaction fee
[has been bouncing around $30 USD over the past couple months](https://bitinfocharts.com/comparison/ethereum-transactionfees.html#3m).

Ideally, we want to execute transactions when the Gas price is reasonably low.
But how can we know when that is?

In this tutorial, we'll be using Napkin to build a Gas Price Monitor to constantly
check the price of Gas on the blockchain, and alert us when it's a good time to buy those
[precious JPEGs](https://preview.redd.it/xu8hy2j9lb071.gif?format=mp4&s=33b7ff071391e5823b64e138bfad616f41fe52e7).
Specifically we'll be utilizing the free [Etherscan API](https://docs.etherscan.io/api-endpoints/gas-tracker#get-gas-oracle)
to check Gas prices and the [Discord API](https://discord.com/developers/docs/intro) to send
us an alert on Discord.

Shoutout to Kevin Yang of [Anzo Creative](https://www.anzocreative.com/), who's been
using this method himself to monitor Gas prices and was kind enough to share his idea
for this tutorial.

## Creating a Discord Webhook

To create a webhook URL, open your desired Discord server
and navigate to Server Settings > Integrations > Webhooks > New Webhook.

![discord settings integrations](/images/blog/20211028/discord-integrations.png)

![discord settings integrations](/images/blog/20211028/discord-integrations-webhooks.png)

## Etherscan API Key

To obtain an Etherscan API key, simply create a free profile at
[etherscan.io](etherscan.io) and create a key at https://etherscan.io/myapikey.

## Coding the Monitor Function

To start off, head on over to [napkin.io/dashboard/new](napkin.io/dashboard/new) and create a new Python function.

![napkin new function](/images/blog/20211028/napkin-dashboard-new.png)

We'll need a few modules: `requests`, `os`, and `napkin.store`. Napkin has hundreds of
modules preinstalled in every Napkin runtime, including these three, so nothing
more we need to do here other than import them.

```python
from napkin import store
import requests
import os
```

Napkin lets you create and modify Environment Variables for each of your functions.
We can store our Discord webhook URL and Etherscan API Key there via
Other > Environment Variables.

![napkin environment variables](/images/blog/20211028/napkin-ui-other.png)

Coding time. Let's split up the main tasks for our monitor into helper functions.
We'll need to look up current Gas price, decide if it's a good price, and optionally
send a message on Discord. We'll also need a way to cache and retrieve the last
price we saw.

Napkin provides a [built-in key value store](https://docs.napkin.io/python/key-value-store)
to persist data across function runs, so we can use that to save and look up the previous price.

We'll simply assume that the current Gas price is "good" if it's less than 140 [GWEI](https://www.investopedia.com/terms/g/gwei-ethereum.asp),
but feel free to use your own logic.

```python
webhook_url = os.getenv('DISCORD_WEBHOOK_URL')
gas_url = "https://api.etherscan.io/api?" \
  + "module=gastracker" \
  + "&action=gasoracle" \
  + f"&apikey={os.getenv('ETHERSCAN_API_KEY')}"
THRESHOLD_GWEI = 140

def send_alert(message):
    requests.post(webhook_url, json={'content': message})

def get_gas_price():
    data = requests.get(gas_url).json()
    return int(data['result'].get('SafeGasPrice'))

def should_alert(current_price, past_price):
    return current_gas_price < THRESHOLD_GWEI < past_price

def save_last_price(price):
	store.put('last_gas_price', price)
```

With our helper functions written, the final logic is pretty short.

```python
current_gas_price = get_gas_price()
last_gas_price = store.get('last_gas_price')['data'] or THRESHOLD_GWEI+1

if should_alert(current_gas_price, last_gas_price):
    send_alert(f"Gas Price Alert: Current price is {current_gas_price} Gwei.")

save_last_price(current_gas_price)
```

Check out our example function [here](https://www.napkin.io/n/3df3e8045cd14e8a)
to see the final code.

Lastly, we'll schedule our function to run automatically. Napkin
[lets you schedule your functions](https://www.napkin.io/scheduling)
to run every minute, every hour, or once a day. In this case, we'll
do every minute so that we don't miss any good Gas deals. Simply
navigate to the "Schedule" tab and select "Every Minute".

![napkin schedule ui](/images/blog/20211028/napkin-ui-schedule.png)

Now, just hit the big, blue "Deploy", and we're done! From there we can can watch
the function running every minute in the "Event Logs" tab.

![napkin event logs](/images/blog/20211028/napkin-event-logs.png)

Once the monitor spots good Gas fees, it will give us a shout on Discord.

![discord alert example](/images/blog/20211028/discord-alert.png)

Happy coding! 🚀🌚


Build a custom price monitor and get notified when Gas is cheap

Napkin Blog