Notify API Options – Best Solution to Set Up Web3 Notifications

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

Monitor a Web3 pockets’s exercise:

To combine Web3 notifications, you could make the most of instruments such because the Notify API or its options. Whereas the Notify API is a good instrument, it will probably’t match the pace and energy of Moralis Streams. Moralis Streams is an enterprise-grade API that, for instance, helps the implementation of blockchain notifications and allows devs to take heed to any pockets or good contract deal with. In truth, right here’s how easy it’s to create a brand new stream by way of the Moralis JS SDK to trace a particular 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 very best Notify API various, and whether or not you’re listening to pockets addresses or good contracts, the strategies are fairly related. In both case, we will use logged occasions and implement Web3 notifications in several types. Our blockchain notifications will be constructed into dapps or social media (by way of bots) platforms as cellular or desktop notifications, and so on. 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();

})

If you happen to want to learn to implement the above-presented code snippets appropriately, create your free Moralis account and comply with our lead!

Overview

In in the present day’s article, we’ll first present you how one can implement the code snippets above and use them with the very best Notify API various. The primary instance will reveal how one can create blockchain notifications by listening to a sensible 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. 

Under the 2 tutorials, we may also discover numerous Notify API 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 Solution to Set Up Web3 Notifications with NodeJS

The simplest solution to arrange blockchain notifications with JavaScript (JS) is utilizing the Moralis Streams API. So, earlier than you dive into the next two examples, ensure you 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 may entry your admin space. That is the place you may 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 mission folder (“DesktopNotifications”) and open it in Visible Studio Code (VSC). Then, you could 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 mission, use the next command:

npm init

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

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

npm i categorical nodemon node-notifier

Now, you might have every part 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 make sure that your dapp makes use of JSON. These are the strains that can cowl these facets:

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 Submit Endpoint

Open the “package deal.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 objective, 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 will likely be your webhook URL. The latter will learn what your stream is sending after which fireplace 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 take heed to the native port: 

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

  console.log(`Listening to streams`)

})

With the above script in place, you may run your dapp:

npm run begin

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

Utilizing the Moralis Admin UI to Create Triggers for Blockchain Notifications 

Due to the screenshot introduced earlier, you already know how one can entry the Streams tab. As soon as there, hit the “New Streams” button: 

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

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

So far as the webhook URL goes, be sure 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 must select the fitting sort of exercise:

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

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

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

Lastly, you must add a filter that can concentrate on transfers of greater than 50 thousand USDT:

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

[

{

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

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

}

]

Be aware: It’s worthwhile to use “50000000000” as a result of USDT makes use of six decimal locations. You’ll be able to discover completely different filters on our GitHub web page within the “Filter Streams” part. 

If you happen to 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 have a look at subsequent!

Displaying Web3 Notifications

To make sure that each new USDT switch triggers a corresponding desktop blockchain notification, you must 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 include 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();

})

Be aware: You’ll be able to entry the ultimate “index.js” script used above on GitHub.

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

Tutorial 2: Utilizing the Notify API Different to Monitor Web3 Wallets

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

On this instance, we are going to present you how one can use the Moralis JS SDK to create a brand new stream that tracks a Web3 pockets deal with. It’s worthwhile to 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 must outline the stream’s choices (embrace the identical particulars as contained in the Streams UI):

async perform streams(){

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

Trying on the strains of code above, you may see that the choices cowl a sequence to concentrate on, an outline, a tag, and a webhook URL. You too can see that the script focuses on completely different on-chain occasions by setting “includeContractLogs” to “false” and “includeNativeTxs” to “true“. This manner, you may concentrate on native forex transfers. For the Mumbai testnet, that’s testnet MATIC. To make use of the above strains of code, be sure to switch “your webhook url” along with your “ngrok” URL. Don’t neglect 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 in the present day’s introduction. So, add these strains of code contained in the “async” perform 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 sure 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 advocate you utilize certainly one of your pockets addresses. In that case, you’ll have the ability to execute instance testnet MATIC transfers to see the leads to your terminal:

Be aware: 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. Thankfully, yow will discover an Ethereum faucet (Goerli faucet), Chainlink testnet faucet, Solana testnet faucet, and others on the Pure Taps web page.

Exploring Notify API Options

If you happen to accomplished the above two tutorials, you have already got an honest sense of what the very best Notify API various is all about. Nonetheless, you may discover the Moralis Streams API in additional element within the upcoming sections. Nonetheless, let’s first ensure you 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 permits builders to ship real-time push notifications to customers for essential on-chain occasions. Given the title “Notify”, it has raised consciousness relating to Web3 and blockchain notifications. Nonetheless, different merchandise serve the identical objective extra effectively, and the Moralis Streams API is the last word Notify API various. It’s quicker, covers all main blockchains, and provides much more than simply notifications.

The Finest Notify API Different

The Streams API is the very best various to Alchemy’s Notify API. Certainly one of its benefits is cross-chain interoperability. If you happen to accomplished the primary tutorial herein, you have been capable of see a number of chains within the “Choose Networks” step of the Streams UI. But it surely’s price mentioning that Moralis Streams help all main EVM-compatible chains. As such, you may monitor any main chain or a number of networks concurrently. Apart from 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 solution to rapidly set the backend in place required to take heed to on-chain occasions. Plus, the Moralis SDK helps all main legacy programming languages and frameworks. Therefore, you need to use your Web3 programming abilities to take heed 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
• ✅ Consumer-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 complicated information pipelines

Moralis – Past Web3 Notifications

Registering blockchain occasions and fetching parsed on-chain information is what all decentralized functions (dapps) want. Whereas a number of devs nonetheless make the error of constructing an infrastructure to assist them do 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 should waste assets on constructing a singular backend. As a substitute, you need to use brief snippets of code to cowl all of your blockchain-related backend wants after which dedicate most consideration to creating the absolute best frontend.  

With that in thoughts, be sure to discover the total energy of Moralis. Apart from the Streams API, Moralis provides you the last word Web3 Information API and Web3 Auth API. The previous helps your have to fetch any sort of on-chain information with a single line of code. It lets you use the Web3 get block timestamp perform, token worth API, the last word NFT API, and rather more:

So far as Moralis authentication goes, it permits 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 whilst you unify Web3 wallets and Web2 accounts. To expertise this instrument firsthand, tackle our Supabase authentication tutorial. 

Nonetheless, except for 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 Solution to Set Up Web3 Notifications – Abstract

In in the present day’s article, you had an opportunity to roll up your sleeves and tackle two tutorials that taught you how one can use the last word Notify API various to take heed to on-chain occasions with out breaking a sweat. The primary tutorial provided you a chance to concentrate on listening to a sensible contract deal with and utilizing the Streams API by way of the Moralis admin UI. Within the second tutorial, we confirmed you how one can concentrate on Web3 pockets addresses whereas utilizing the ability of Moralis Streams by way of the JS SDK. After finishing the tutorials, you have 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 very best 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. For example, you may create a Twitter bot, NodeJS Telegram bot, or a blockchain Discord bot. 

Alternatively, you is perhaps all in favour of exploring different blockchain growth matters or getting the crypto fundamentals beneath your belt, akin to answering questions like “what’s Web3 expertise?“. In that case, you need to discover our crypto weblog additional. That mentioned, if you’re prepared to begin BUIDLing and would love some steerage, be sure to take a look at the Moralis YouTube channel and documentation. If you happen to plan on coping with token costs in ETH, you’ll wish to use a dependable gwei to ETH calculator.