Notify API Options – Best Technique to Set Up Web3 Notifications

Take heed to a wise contract deal with and create desktop Web3 notifications for on-chain occasions:

Observe a Web3 pockets’s exercise:

To combine Web3 notifications, you could make the most of instruments such because the Notify API or its alternate options. Whereas the Notify API is a superb software, it could possibly’t match the velocity and energy of Moralis Streams. Moralis Streams is an enterprise-grade API that, for instance, helps the implementation of blockchain notifications and permits devs to hearken to any pockets or good contract deal with. The truth is, right here’s how easy it’s to create a brand new stream by way of the Moralis JS SDK to trace a selected pockets:

const newStream = await Moralis.Streams.add(choices) 

const {id}=newStream.toJSON();

const deal with=”wallet_address_you_want_to_track”

await Moralis.Streams.addAddress({deal with,id})

It doesn’t get extra simple than this when utilizing the most effective Notify API various, and whether or not you’re listening to pockets addresses or good contracts, the strategies are fairly comparable. In both case, we will use logged occasions and implement Web3 notifications in several kinds. Our blockchain notifications may be constructed into dapps or social media (by way of bots) platforms as cellular or desktop notifications, and so forth. For instance, the next strains of code use a USDT stream to create a desktop notification for each switch of USDT above any particular threshold:

app.put up(‘/webhook’, (req, res) => {

  const webhook = req.physique;
  for (const erc20Transfer of webhook.erc20Transfers){

     const addrs = `${erc20Transfer.from.slice(0, 4)}…${erc20Transfer.from.slice(38)}`;
      const quantity = Quantity(erc20Transfer.valueWithDecimals).toFixed(0);

      notifier.notify({
          title: ‘NEW USDT Switch’,
          message: `${addrs} simply despatched n$${quantity}`,
        });

  }

  return res.standing(200).json();

})

In case you want to discover ways to implement the above-presented code snippets accurately, create your free Moralis account and comply with our lead!

Overview

In at this time’s article, we’ll first present you the best way to implement the code snippets above and use them with the most effective Notify API various. The primary instance will display the best way to create blockchain notifications by listening to a wise contract deal with. For that, we are going to use the Moralis Streams API by way of the Moralis admin UI. The second instance will lean on utilizing Moralis Streams by way of the JS SDK to implement crypto pockets monitoring. 

Beneath the 2 tutorials, we may even discover varied Notify API alternate options, the place you’ll have an opportunity to be taught extra in regards to the Moralis Streams API and different instruments that this final Web3 API supplier has to supply.

Best Technique to Set Up Web3 Notifications with NodeJS

The simplest approach to arrange blockchain notifications with JavaScript (JS) is utilizing the Moralis Streams API. So, earlier than you dive into the next two examples, be sure to have your free Moralis account prepared. To do that, use the “create your free Moralis account” hyperlink above or go to “moralis.io” and hit one of many “Begin for Free” buttons:

After getting your free account prepared, you’ll be able to entry your admin space. That is the place you’ll be able to get hold of your Web3 API key and entry the UI for Moralis Streams:

Acquiring your Web3 API key:

Tutorial 1: Blockchain Notifications for Desktop

Create a brand new challenge folder (“DesktopNotifications”) and open it in Visible Studio Code (VSC). Then, chances are you’ll proceed by creating an Specific dapp utilizing NodeJS. This backend dapp will function a webhook, to which you’ll ship on-chain occasions detected along with your USDT stream.

To initialize a NodeJS challenge, use the next command:

npm init

Then merely hit enter a few occasions to decide on the default choices. After confirming “Is that this OK?” in your terminal, you’ll see a “bundle.json” file in your challenge folder: 

Subsequent, set up the required dependencies by working this command:

npm i categorical nodemon node-notifier

Now, you might have all the things able to create a brand new “index.js” file:

contact index.js

Open your “index.js” script and import Specific and “node-notifier“. It’s essential to additionally outline an area port you wish to use and be sure that your dapp makes use of JSON. These are the strains that can cowl these points:

const categorical = require(‘categorical’)
const notifier = require(‘node-notifier’);
const app = categorical()
const port = 3000

app.use(categorical.json())

Create Nodemon Script, Ngrok Tunnel, and Use the Publish Endpoint

Open the “bundle.json” file and add a “begin” script with “nodemon index.js”:

Use “ngrok” to create a tunnel to your native machine and get a URL you need to use as a webhook. For that goal, open a brand new terminal and enter the command under to put in “ngrok“:

sudo npm i ngrok

Subsequent, run the next command:

ngrok http 3000

As a response, you’ll get a URL that you need to use as a webhook URL:

Transferring ahead, you wish to create a “put up” endpoint that shall be your webhook URL. The latter will learn what your stream is sending after which hearth up the suitable logic. For starters, use the next strains of code: 

app.put up(‘/webhook’, (req, res) => {

  const webhook = req.physique;

  console.log(webhook)

  return res.standing(200).json();

})

Lastly, you wish to initialize your Specific dapp to hearken to the native port: 

app.pay attention(port, () => {

  console.log(`Listening to streams`)

})

With the above script in place, you’ll be able to run your dapp:

npm run begin

Along with your webhook URL prepared and your backend NodeJS dapp working, you’re prepared to make use of the final word Notify API various to start out listening to on-chain occasions. 

Utilizing the Moralis Admin UI to Create Triggers for Blockchain Notifications 

Because of the screenshot offered earlier, you already know the best way to entry the Streams tab. As soon as there, hit the “New Streams” button: 

On the following web page, you’ll get to arrange a brand new stream. Since we wish to hearken to USDT transfers, you could paste the USDT contract’s deal with. You may copy it from Etherscan:

Then, you could add an outline, webhook URL, and a tag:

So far as the webhook URL goes, be certain to make use of your “ngrok” URL obtained above and add “/webhook” on the finish. Subsequent, choose the “Ethereum Mainnet” community – that is the place the USDT good contract lives:

Transfers are particular occasions of contract interactions, so you could select the correct kind of exercise:

You additionally want the USDT contract’s ABI, which you can even copy from Etherscan (“Contract” tab):

As soon as on the “Contract” tab, scroll down till you see “Contract ABI” and duplicate it:

After pasting the above-copied ABI into the designated space in your setup, Moralis will routinely detect the obtainable on-chain occasions. As such, you merely choose the “Switch” choice:

Lastly, you could add a filter that can deal with transfers of greater than 50 thousand USDT:

These are the strains of code offered within the above screenshot:

[

{

“topic0”: “Transfer(address,address,unit256)”,

“filter”: {“gt: [“value”, “50000000000]}

}

]

Word: That you must use “50000000000” as a result of USDT makes use of six decimal locations. You may discover completely different filters on our GitHub web page within the “Filter Streams” part. 

In case you return to your terminal the place you’re working your “index.js” script, you need to see detected USDT transfers within the following format:

All that’s left to do is to current these outcomes by way of neat desktop notifications, which we’ll take a look at subsequent!

Displaying Web3 Notifications

To make sure that each new USDT switch triggers a corresponding desktop blockchain notification, you could tweak your “index.js” script. That is the place the snippet of code from the intro comes into play. So, your up to date “put up” endpoint ought to comprise the next:

app.put up(‘/webhook’, (req, res) => {

  const webhook = req.physique;

  for (const erc20Transfer of webhook.erc20Transfers){

      const addrs = `${erc20Transfer.from.slice(0, 4)}…${erc20Transfer.from.slice(38)}`;
      const quantity = Quantity(erc20Transfer.valueWithDecimals).toFixed(0);

      notifier.notify({
          title: ‘NEW USDT Switch’,
          message: `${addrs} simply despatched n$${quantity}`,
        });

  }

  return res.standing(200).json();

})

Word: You may entry the ultimate “index.js” script used above on GitHub.

That is what these USDT switch notifications appear like on a desktop:

Tutorial 2: Utilizing the Notify API Various to Observe Web3 Wallets

Word: To arrange your Specific dapp utilizing NodeJS and create a “ngrok” tunnel, use the steps coated within the above tutorial. 

On this instance, we are going to present you the best way to use the Moralis JS SDK to create a brand new stream that tracks a Web3 pockets deal with. That you must initialize one other NodeJS app and create a brand new “index.js” file. Inside that script, require Moralis and “dotenv“:

const Moralis = require(“moralis”).default;
const { EvmChain } = require(“@moralisweb3/common-evm-utils”);
require(“dotenv”).config();

Additionally, create a “.env” file the place you wish to paste your Moralis Web3 API key within the “MORALIS_KEY” variable. Subsequent, initialize Moralis:

Moralis.begin({
    apiKey: course of.env.MORALIS_KEY,
  });

Then, you could outline the stream’s choices (embody the identical particulars as contained in the Streams UI):

async operate streams(){

  const choices = {
    chains: [EvmChain.MUMBAI],
description: “Take heed to Transfers”,
    tag: “transfers”,
    includeContractLogs: false,
    includeNativeTxs: true,
    webhookUrl: “your webhook url”
  }

Wanting on the strains of code above, you’ll be able to see that the choices cowl a series to deal with, an outline, a tag, and a webhook URL. You may also see that the script focuses on completely different on-chain occasions by setting “includeContractLogs” to “false” and “includeNativeTxs” to “true“. This manner, you’ll be able to deal with native foreign money transfers. For the Mumbai testnet, that’s testnet MATIC. To make use of the above strains of code, be certain to switch “your webhook url” along with your “ngrok” URL. Don’t overlook so as to add “/webhook” on the finish of that URL. 

Create a New Pockets-Monitoring Stream

With the strains of code above set in place, it’s time to make use of the snippet from at this time’s introduction. So, add these strains of code contained in the “async” operate of your “index.js” file:

const newStream = await Moralis.Streams.add(choices)

  const {id} = newStream.toJSON();

  const deal with = “wallet_address_you_want_to_track”;

  await Moralis.Streams.addAddress({deal with, id})

  console.log(“Fin”)

}

streams()

To make use of this script, be certain to switch “wallet_address_you_want_to_track” with an precise pockets deal with. If you wish to take a look at this stream firsthand, we suggest you employ one among your pockets addresses. In that case, you’ll be capable of execute instance testnet MATIC transfers to see the ends in your terminal:

Word: To acquire testnet MATIC, you could use a dependable Polygon Mumbai faucet. If you wish to goal completely different testnets, you’ll want different crypto taps. Happily, you’ll find an Ethereum faucet (Goerli faucet), Chainlink testnet faucet, Solana testnet faucet, and others on the Pure Taps web page.

Exploring Notify API Options

In case you accomplished the above two tutorials, you have already got a good sense of what the most effective Notify API various is all about. Nonetheless, you’ll be able to discover the Moralis Streams API in additional element within the upcoming sections. Nonetheless, let’s first be sure to know what the Notify API is. 

What’s the Notify API?

Within the realm of Web3, the Notify API refers to Alchemy’s product that enables builders to ship real-time push notifications to customers for important on-chain occasions. Given the title “Notify”, it has raised consciousness relating to Web3 and blockchain notifications. Nonetheless, different merchandise serve the identical goal extra effectively, and the Moralis Streams API is the final word Notify API various. It’s sooner, covers all main blockchains, and provides much more than simply notifications.

The Finest Notify API Various

The Streams API is the most effective various to Alchemy’s Notify API. Considered one of its benefits is cross-chain interoperability. In case you accomplished the primary tutorial herein, you had been capable of see a number of chains within the “Choose Networks” step of the Streams UI. Nevertheless it’s price stating that Moralis Streams help all main EVM-compatible chains. As such, you’ll be able to monitor any main chain or a number of networks concurrently. Except for concentrating on a number of chains, this additionally future-proofs your work because it ensures you’re by no means caught on any specific chain.

One other excellent profit the Streams API provides is user-friendliness. By providing an admin UI and an SDK to work with Moralis Streams, anybody can discover a approach to rapidly set the backend in place required to hearken to on-chain occasions. Plus, the Moralis SDK helps all main legacy programming languages and frameworks. Therefore, you need to use your Web3 programming expertise to hearken to any good contract and pockets deal with. What’s extra, you are able to do so with a free Moralis account! All these benefits even make Web3 libraries out of date in a number of methods.

TRUSTED BY INDUSTRY LEADERS

✅ Cross-chain interoperability ✅ Person-friendliness (cross-platform interoperability) ✅ Listening to crypto wallets and good contracts ✅ Pace and effectivity ✅ Superior filtering choices ✅ Accessible with a free account ❌ Connecting and sustaining buggy RPC nodes ❌ Constructing pointless abstractions ❌ Losing time constructing advanced information pipelines

Moralis – Past Web3 Notifications

Registering blockchain occasions and fetching parsed on-chain information is what all decentralized purposes (dapps) want. Whereas a number of devs nonetheless make the error of constructing an infrastructure to assist them try this from scratch, you don’t wish to waste time reinventing the wheel. That is the place the Web3 APIs from Moralis change the sport. With this toolbox in your nook, you don’t need to waste sources on constructing a singular backend. As an alternative, you need to use quick snippets of code to cowl all of your blockchain-related backend wants after which commit most consideration to creating the absolute best frontend.  

With that in thoughts, be certain to discover the total energy of Moralis. Except for the Streams API, Moralis provides you the final word Web3 Information API and Web3 Auth API. The previous helps your must fetch any kind of on-chain information with a single line of code. It lets you use the Web3 get block timestamp operate, token value API, the final word NFT API, and far more:

So far as Moralis authentication goes, it enables you to add all of the main Web3 login strategies to your dapps. Consequently, your dapp’s customers can expertise a frictionless Web3 onboarding expertise when you unify Web3 wallets and Web2 accounts. To expertise this software firsthand, tackle our Supabase authentication tutorial. 

Nonetheless, apart from options for constructing dapps on Ethereum and main EVM-compatible chains, Moralis additionally allows you to goal Solana. The 2 hottest choices for that community are the Solana Python API and the Solana JS API. 

Notify API Options – Best Technique to Set Up Web3 Notifications – Abstract

In at this time’s article, you had an opportunity to roll up your sleeves and tackle two tutorials that taught you the best way to use the final word Notify API various to hearken to on-chain occasions with out breaking a sweat. The primary tutorial provided you a chance to deal with listening to a wise contract deal with and utilizing the Streams API by way of the Moralis admin UI. Within the second tutorial, we confirmed you the best way to deal with Web3 pockets addresses whereas utilizing the ability of Moralis Streams by way of the JS SDK. After finishing the tutorials, you had been capable of be taught what Alchemy’s Notify API is and get a greater sense of the Moralis Streams API and the remainder of Moralis’ suite of instruments.    

Now that you understand how to cowl the backend facet of utilizing the most effective Notify API various, it’s time you begin constructing some distinctive frontends incorporating blockchain notifications. Moreover, you might also use on-chain occasions to automate social media posts. As an illustration, you’ll be able to create a Twitter bot, NodeJS Telegram bot, or a blockchain Discord bot. 

Alternatively, you is likely to be fascinated by exploring different blockchain improvement matters or getting the crypto fundamentals underneath your belt, similar to answering questions like “what’s Web3 know-how?“. In that case, you need to discover our crypto weblog additional. That stated, in case you are prepared to start out BUIDLing and would really like some steerage, be certain to take a look at the Moralis YouTube channel and documentation. In case you plan on coping with token costs in ETH, you’ll wish to use a dependable gwei to ETH calculator.