DEV Community: Ashutosh Tripathi 🥷

How To Send Notifications From A Subgraph

Ashutosh Tripathi 🥷 — Fri, 12 Aug 2022 13:25:00 +0000

Gm folks ✨

The Graph is certainly one of the coolest innovations in Web3 space. With its unique infrastructure, Graph Protocol adds Indexing functionality to the Blockchain ecosystem. It has ridiculously simplified the process of querying data from blockchain networks like Ethereum.

A Subgraph defines which data The Graph will index from a blockchain, and how it will store it. Once deployed, it becomes part of a global graph of blockchain data which you can retrieve using GraphQL.

In this tutorial, I will show you how to use the EPNS Helper Function to integrate your channel with a Subgraph.

EPNS only supports subgraphs deployed on The Graph Protocol's Hosted Service. The next update would include support for Subgraph Studio.

Subgraph support is currently available at Staging and will be available on Prod following the Protocol v2 audit.

Why use Subgraphs?

Subgraphs are used to retrieve and store data from the blockchain for a specific smart contract. This data can be used to investigate a range of smart contract-related events.

The Uniswap Subgraph, for example, keeps data on total volume across all trading pairs, volume data per trading pair, and even data for a specific token.

How about intelligently retrieving data from a Subgraph and generating helpful alerts?

This can be incredibly beneficial to your dApp's end-users and entities connected to your smart contract, improving the overall user experience.

Sending Notifications using EPNS

EPNS has developed an in-house Helper Function specifically for The Graph Protocol that allows you to read events from the Subgraph and define notifications accordingly. Once defined, they are stored on the Subgraph in a Long String format.

Later on, EPNS Push Nodes fetch the notifications defined on the Subgraph and push them accordingly to subscribers of the channel.

In order to integrate EPNS with your Subgraph, you will need:

Your Subgraph ID
A channel deployed on EPNS

In case you don’t have the Subgraph ID, feel free to create your own Subgraph by following the step-by-step guide available here at Create a Subgraph.

Once you have published your Subgraph, you can start sending notifications based on events generated from the Smart Contract to the users.

Enough talking, let’s get into Building stuff right away!!

Setup EPNS with Subgraph

In order to integrate EPNS with your Subgraph, follow the below steps carefully;

1. Initialize Subgraph with EPNS

Navigate to the Subgraph directory and you’ll find schema.graphql file. Open in an editor of your choice and include the following EPNS Schema;

type EpnsNotificationCounter @entity {
  id: ID!
  totalCount: BigInt!
}

type EpnsPushNotification @entity {
  id: ID!
  notificationNumber: BigInt!
  recipient: String!
  notification: String!
}

In mapping.ts file under src/ directory, export the Subgraph ID;

//Note: EPNS only supports The Graph Hosted Service at present
export const subgraphID = "GithubID/subgraph-slug"

Note: Make sure the above step is complete, as Subgraph ID will be imported in the next step!

Create a file named EPNSNotification.ts in the src/ folder. I’ll call it our Helper File. Now, copy the below-provided TypeScript code and paste it into the newly created Helper file;

import { BigInt, log } from "@graphprotocol/graph-ts"
import { EpnsNotificationCounter, EpnsPushNotification } from '../generated/schema'
import { subgraphID } from "./mapping"

export function sendEPNSNotification(recipient: string, notification: string): void 
{
  let id1 = **subgraphID**
  log.info('New id of EpnsNotificationCounter is: {}', [id1])

  let epnsNotificationCounter = EpnsNotificationCounter.load(id1)
  if (epnsNotificationCounter == null) {
    epnsNotificationCounter = new EpnsNotificationCounter(id1)
    epnsNotificationCounter.totalCount = BigInt.fromI32(0)
  }
  epnsNotificationCounter.totalCount = (epnsNotificationCounter.totalCount).plus(BigInt.fromI32(1))

  let count = epnsNotificationCounter.totalCount.toHexString()
  let id2 = `${subgraphID}+${count}`
  log.info('New id of EpnsPushNotification is: {}', [id2])

  let epnsPushNotification = EpnsPushNotification.load(id2)
  if (epnsPushNotification == null) {
    epnsPushNotification = new EpnsPushNotification(id2)
  }

  epnsPushNotification.recipient = recipient
  epnsPushNotification.notification = notification
  epnsPushNotification.notificationNumber = epnsNotificationCounter.totalCount

  epnsPushNotification.save()
  epnsNotificationCounter.save()
}

In mapping.ts present in src/, import the Helper File;

import { sendEPNSNotification } from "./EPNSNotification"

The example mapping.ts file is written in TypeScript. It’s the main script that defines your notification payload and its recipients.

2. Define Payload Items

In the event handler method of mapping.ts file, define your notification payload items such as the recipient of the notification, type, title, message, etc. These variables will be used to define our notification variable.

mapping.ts is present in the epns-graph-integration/src folder.

let recipient = "0xD8634C39BBFd4033c0d3289C4515275102423681",
      type = "3",
      title = "Number changed",
      body = `Number changed from ${event.params.from} to ${event.params.to}`,
      subject = "Number changed",
      message = `Number changed from ${event.params.from} to ${event.params.to}`,
      image = "null",
      secret = "null",
      cta = "https://epns.io/"

It’s highly recommended to take a look at this documentation to understand more about payload items and their definitions.

3. Define Notification

The notification variable is defined in the below format 👇🏼

Format : {"field" : "value"}

notification = `{\"type\": \"${type}\", \"title\": \"${title}\", \"body\": \"${body}\", \"subject\": \"${subject}\", \"message\": \"${message}\", \"image\": \"${image}\", \"secret\": \"${secret}\", \"cta\": \"${cta}\"}`

4. Call the EPNS Helper Function

Once the above steps are complete, you need to invoke the EPNS helper function and send the response. To call the EPNS Notification helper function, use the below script;

sendEPNSNotification (recipient, notification)

Connect Subgraph With EPNS Channel

Once you have set up EPNS integration into your subgraph, you must add the subgraph to its channel in order to deliver notifications. You will require a Subgraph ID, which is usually present at the end of the subgraph URL.

I hope you already created a channel. If you haven’t created one yet, check out this guide to create a channel on EPNS.

Go to EPNS dApp → Channel Dashboard → Settings Button → Add Subgraph Details
Enter your Subgraph ID and Poll Interval

One important thing to note is the Poll Interval. It’s the time (in seconds), which defines the time interval at which Push Nodes shall ping the subgraph for fetching the latest notifications.

Note: This is an on-chain transaction that stores the above data to EPNS Core Contract. So it requires $ETH for gas fees

Once you complete the transaction, you have successfully integrated EPNS into your Subgraph. Push Nodes will start polling the respective subgraph for notifications at regular Poll Intervals.

Please share this tutorial with your developer community if you found it useful. Also, if you are someone who is building using The Graph Protocol, this could be a great addition to track subgraph events.

I’ll be back with another awesome blog very soon. Till then, keep building and keep growing 🚀

Sayonara!!

Sending Notifications Using EPNS Backend SDK

Ashutosh Tripathi 🥷 — Sat, 06 Aug 2022 14:06:33 +0000

Gm folks ✨

In my last tutorial, I demonstrated the complete mechanism of sending notifications from the EPNS dApp. It’s very useful for sending out broadcast notifications. However, most of the time, we are generating user-specific notifications.

So how do you deliver multiple notifications (on the scale of hundreds and thousands) at the same time?

The answer is pretty much obvious. You have to utilize your dApp backend to deliver these custom-tailored notifications. In order to send notifications directly from your backend, EPNS provides you with a backend SDK. This SDK provides a simple and easy-to-implement JavaScript library to send notifications from your dApp to the users.

Today, I will show you exactly how to use the EPNS backend SDK and send notifications from your dApp. The SDK is very easy to use and widely available on this GitHub repository.

Setting up the backend SDK

To start sending notifications using the EPNS backend SDK, you first need to install its npm package. You need to have Node Package Manager installed in order to accomplish this task.

Open up your terminal and type the following command:

npm install @epnsproject/backend-sdk-staging

We are using the Staging SDK for now. Prod is very similar, the only difference lies in the environments of execution. Make sure you have already created a channel. In case you haven’t, check out this tutorial.

Initializing the SDK

To start utilizing the Backend SDK, I’d recommend you create a separate JavaScript file. Let’s name it “notify.js”. Before initializing the SDK, we must import it into notify.js and fetch our channel private key.

Import the SDK in notify.js by using this line of code.

const EpnsSDK = require("@epnsproject/backend-sdk-staging").default;

Remember, we also need to establish a connection with our channel. So you have to copy the private key of your channel. In other words, you need the private key of the MetaMask wallet that is linked to your channel. If you face any trouble, check out this guide to fetch the private key of your MetaMask wallet.

Once you have the private key, prepend 0x to your private key and insert this line into notify.js

const CHANNEL_PK = “0xPrivate_Key_Here”;

Now, we can create an instance of the EPNS backend SDK. To do so, we will use the below snippet:

const epnsSdk = new EpnsSDK(CHANNEL_PK);

Adding notification parameters

Before we send out any notification, we will require certain parameters that will form the notification payload. It includes the title of notification, message, call to action link, and the type of notification.

Some of the parameters are optional. You can check out the complete documentation available here and customize payloads according to your needs. Also, don’t forget to check out the types of notifications.

Once you decide the type of notification and its parameters, store their values in appropriate variables and call the sendNotification() function.

I have tried sending a notification to one of my other dummy accounts and entered its address in the recipientAddress parameter. Here is the overall code snippet after importing the SDK and inserting parameters:

// import required packages
const EpnsSDK = require("@epnsproject/backend-sdk-staging").default;

// connecting to the channel using the private key
const CHANNEL_PK = "0x4968b4cd6ea60a132cdef893320c11f9febd374ae3ccf0ede7820668a431acb8"; // the private key of the channel

(async function Main() {
  // initialise the sdk
  const epnsSdk = new EpnsSDK(CHANNEL_PK);

  const pushNotificationTitle = "Hello There!"; //the title which would appear in a push notification
  const pushNotificationBody = "Welcome to EPNS"; //the body which would be displayed in a push notification

  const notificationTitle = "Hello From EPNS"; //the long version of the title which would be displayed in the dApp
  const notificationBody = `Welcome to EPNS, we are glad to have you onboard`; // the long version of the body to be displayed in the dApp

  const recipientAddress = "0x5b22A6D95EDe615a263BC8e6cD214947c9873133";
  const CTA = "https://epns.io"; // the link to be used as your CTA
  const notificationType = 3; // a notification type of 3, means the notification is a direct message to the specified recipient

  // send the actual notification
  const response = await epnsSdk.sendNotification(
    recipientAddress, //the recipient of the notification
    pushNotificationTitle, //push notification title
    pushNotificationBody, //push notification body
    notificationTitle, //the title of the notification
    notificationBody, //the body of the notification
    notificationType, //notification type
    CTA); //the CTA link of the notification

  console.log({
    response,
    message: "Your notification has been successfully sent"
  });

})();

Save this file as notify.js and open the terminal. Navigate to the directory of this file and run the following command:

node notify.js

You will see a similar result as displayed in below screenshot and your notification will be sent to the specified recipient address.

If you found this tutorial useful, please mind sharing it in your social circles. It will help us expand our outreach in building the future of communications.

Did you know that you could also send notifications generated from a subgraph? No worries, I will show you how to do that in the simplest manner in the next tutorial.

Till then, Sayonara!

How to Send Decentralized Notifications Using EPNS

Ashutosh Tripathi 🥷 — Thu, 28 Jul 2022 06:07:43 +0000

Gm folks ✨

It's a new wonderful week and I am back again with another quick tutorial. In the last blog, I shared how to create channels using the EPNS staging dApp. Today, I will show you the easiest way to send decentralized notifications using EPNS via the channel dashboard. We will use staging dApp (https://staging.epns.io) for this purpose.

The staging environment provides channel testing services on the Kovan testnet. It is completely free to use. In case you run out of Kovan ETH, Paradigm has an amazing faucet that drops 1 Kovan ETH per day.

Okay Ashutosh, sounds great! Let's begin 🚀

Sending Notifications From Your Channel

To start sending decentralized notifications to wallets, you would be required to set up a channel on EPNS. In case you missed the last tutorial, check it out here.

After you create a channel, you are redirected to the channel profile page. Over there, you can see multiple details associated with your channel that is linked to your wallet.

You would also see some subscribers already opted-in to your channel. They are EPNS microservices that are automatically subscribed when you create a channel.

In fact, one of the subscribers is your own wallet itself. This helps you in keeping track of all the notifications that have been sent out from your channel.

At the bottom of your channel profile, you will see a Send Notification section. Here you would find the Select Type of Notification to Send dropdown menu.

Click on the dropdown button and it shows three options:

Broadcast (IPFS Payload)
Targeted (IPFS Payload)
Subset (IPFS Payload)

I will now demonstrate sending notifications in all these types directly from the dApp. Btw, it would be really cool if you try out sending notifs on your own 🛠

1. Broadcast Notifications Using EPNS

Imagine you are the owner of an EPNS channel that sends notifications to your community about the latest updates. You can utilize broadcast notifications to communicate info to all of your subscribers at once.

In order to send broadcast notifications, click the drop-down menu next to Send Notifications and choose Broadcast. New input fields similar to the one below will appear (I have included some dummy text in the input areas for your convenience. You can customize the details to fit your needs).

You can also see the real-time Notification Preview and check out how the notification would appear once delivered to your subscribers.

By pressing the Send Notification button, a gasless transaction will start on the Kovan Network. The notification will be delivered after you click on the Sign button in MetaMask.

2. Targeted Notifications

If you're building a dApp, this is the most important type. It helps you deliver personalized notifications to your users. Many official EPNS channels, such as Uniswap, MakerDAO, and many others, use this type in combination with backend SDK and Showrunners to send wallet-specific notifications.

Simply select the Targeted option from the Send Notification panel to send Targeted notifications. Fill in the details and specify the wallet address you want to notify. Consider the following example:

Hit the Send Notification button, Sign the Payload, and your customized notification will be delivered to the specified wallet's inbox.

3. Subset Notifications

Now let's assume you only want to notify a group of wallet addresses. Probably you need to distribute membership rewards or send notifications only to those with special access, or maybe something secret 🤓

For such purposes, EPNS allows you to send decentralized notifications to a subset of users. All you need are the wallet addresses of everyone you want to notify.

Select Subset (IPFS Payload) from the Send Notifications dropdown list. You would see input fields similar to Broadcast notifications. The only difference is that a new field asks for wallet addresses. Note that multiple wallets can be added by entering comma-separated addresses or pressing the enter key.

Once done, click on the Send Notification button, and it will initiate a gasless signing transaction. Your notification will be sent to the respective wallet addresses upon successful delivery.

So far, we've learned how to create channels and send Web3-native notifications using EPNS. In the next tutorial, I will guide you on how to set up the Backend SDK and send notifications using the same.

If you found this tutorial useful, I would really appreciate it if you could share it in your social circles. It will help us expand our outreach in building the future of communications.

If you'd like to know more about EPNS and decentralized communications, feel free to check out our Docs or join our Discord.

Until next time!

Getting Started With Web3 Notifications Using EPNS

Ashutosh Tripathi 🥷 — Thu, 21 Jul 2022 06:32:17 +0000

Gm folks ✨

This is a quickstart tutorial for developers to start integrating Web3 notifications in their projects using Ethereum Push Notification Service (EPNS), which is the first decentralized protocol to send push notifications for decentralized apps (dApps), NFTs, and DAOs like Uniswap, MakerDAO, ENS, and many more.

This tutorial will show you all about channels, subscribers, and notifications. You don’t need to have some fancy developer tag to be here. Just your coffee ☕️ and an inquisitive mind 🚀

Decentralized Push Notifications

Push notifications have become an integral part of our lives, with nearly 3 billion active users worldwide in 2021. These notifications are like messages. You can send them to all subscribers or specific users.

Their arrival on blockchains like Ethereum is imminent and will be extremely beneficial for the growth of the ecosystem.

At EPNS, we are building the communication layer for Web3, starting out with decentralized push notifications. Any wallet, dApp, smart contract, or backend can create a channel on EPNS.

Channels are further able to send gasless notifications tied to user wallets. Users can receive these notifications via the Android/iOS app or browser extension.

What Are Channels?

To start sending push notifications in Web3, the easiest way is to set up a channel on EPNS. Channels are a lot like telephone numbers. They're used to route notifications to the right wallets. Your wallet address becomes the destination for receiving those push notifications.

You must have watched videos from your favorite channels on YouTube. You receive notifications for the latest content when you press the “Subscribe” button on their channel. YouTube uses channels to route these notifications to its subscribers, but these are centralized (i.e. owned by Google) and can be shut down at any time 😨

EPNS allows you to create your own channels leveraging our protocol on decentralized networks. These channels can be subscribed to by users of your dApp and receive push notifications. It creates a secure and verified communication medium for decentralized apps and their users.

Channels are decentralized and can not be shut down. And above all, it’s extremely easy to use, with a user-friendly interface and simple tools for developers.

With a channel linked to your wallet on EPNS, you can send out broadcasts, targeted, subset, and even secret notifications. And above all, our dApp makes it super easy to send push notifications. You don't need to know the ins and outs of how it works 😉

5 Steps To Create Your Channel

To start with, you can create channels on Prod and Staging dApp. If you want to try out how channels work and send notifications, it’s highly recommended for you to try the Staging dApp. All you need is a MetaMask wallet and the logo of your channel.

For those who are not aware of Metamask, it’s a decentralized wallet provider used to interact with Ethereum. You can download the browser extension or their Android/iOS application to connect with EPNS dApp.

Creating a channel takes only a few clicks and you are up and running. And I’ll show you exactly how to do that in 5 easy steps 😉

1 → Go to the EPNS Staging dApp available on https://staging.epns.io/

2 → Connect your Metamask Wallet with the dApp

3 → Once Connected, go to Create Channel option in the Developer tab. Upload your Channel Logo and don't forget to click on Get Free DAI for Channel. By the way, you won't get the Free DAI option on Prod dApp. You will have to stake real DAI 🙂

4 → Fill in all relevant Channel Details. Keep the Alias network fields blank 😉 We'll need it only when we create a Channel Alias (Polygon is live on Staging 💜)

5 → Once all the details are filled, click on Setup Channel. This will initiate two important transactions

*Approval of DAI *→ This transaction ensures that your wallet address has successfully approved the EPNSCore contract to use 50 DAI on your behalf.
Channel Creation on EPNS Core → Once approved, the 2nd transaction calls the channel creation function on EPNSCore smart contract to create the channel.

And you are all set up!

Here is a 3-min video, you can check it out 💻

Opt-In To Push Notifications

Any user who owns a Web3 wallet like MetaMask can opt-in to receive notifications from channels. Opting in to any channel is gasless and does not require any fee.

Once connected, you will see a similar list to the one below 👇🏼

You can choose to opt-in for channels that can send you push notifications. And by the way, these notifications can be received via our browser extension (which works only on Chrome), or native Android/iOS apps. You can also choose to view the notifications in your Inbox on EPNS dApp.

In the next tutorial, we will teach you how to send different types of notifications from the EPNS dApp. We will also cover the integration of EPNS SDK, please stay tuned!

If you found this tutorial useful, please mind sharing it in your social circles. It will help us expand our outreach in building the future of communications.

If you’d like to know more about EPNS and decentralized communications, feel free to check out our Docs or join our Discord.

Until next time!