

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

Nick Sypteras

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://napkin.wiki/docs/python#a58119047590473db569f9a0f1f077c8) 
 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

NFT Portfolio Tracker Bot on Discord with Napkin

Build a telegram bot with NodeJS in 4 minutes

Build a Discord Bot to Track the ISS with Napkin

ETH Gas Price Alerts on Discord with Napkin

Write and deploy cloud functions from your browser.