Smart contract portal

The smart contract portal middleware

The smart contract portal is a middleware which creates an easy to use api on top of your smart contracts. It can be used with all EVM-compatible chains like Ethereum, Hyperledger Besu, Polygon, Avalanche, etc. You can run it on your own blockchain nodes (both public and permissioned) or on a Load Balancer.

Benefits of using the smart contract portal:

1. Simplified Integration: APIs allow developers to interact with complex smart contract functions through familiar interfaces, reducing the need to understand blockchain-specific languages and protocols.
2. Data Aggregation: APIs can consolidate data from multiple smart contracts, providing a unified view.
3. Improved Performance: GraphQL optimizes data fetching, ensuring that clients retrieve only the necessary data in a single request, reducing network load and improving performance.
4. Stack agnostic: Teams are free to choose their own technology stack.
5. Transaction Monitoring & Alerting: Monitor blockchain transactions in real-time, filter by parameters like sender, receiver, block number, function name, and contract address. Set up custom alerts to trigger actions such as email notifications, webhooks, or automated processes when specific conditions are met.

Using the smart contract portal middleware

The Portal middleware provides instant API access to your smart contracts. Key features include:

• Auto-generated REST & GraphQL APIs
• Built-in webhooks for event notifications
• Type-safe contract interactions
• Automatic ABI parsing

Using the portal sdk

import { createPortalClient } from "@settlemint/sdk-portal";

const { client: portalClient, graphql: portalGraphql } = createPortalClient({
  instance: process.env.SETTLEMINT_PORTAL_GRAPHQL_ENDPOINT,
  accessToken: process.env.SETTLEMINT_ACCESS_TOKEN,
});

Upload an abi

A smart contract ABI (Application Binary Interface) is a standardized way for interacting with smart contracts in the Ethereum blockchain and other compatible systems. It serves as the bridge between human-readable contract code (written in languages like Solidity) and the Ethereum Virtual Machine (EVM), which executes the contract. The ABI specifies the functions that can be called on the contract, including their names, input parameters, and output types.

When deploying a smart contract the ABI file can be found as part of the artificats. See Deploying the Smart Contract. Download the ABI json files and save them on your local filesystem.

When creating a new middleware you'll need to upload at least one ABI.

To update the ABIs of an existing smart contract portal middleware navigate to the middleware, go the details and click on the 'Manage Middleware' button on the top right. Click on the 'Update ABIs' item and a dialog will open. In this dialog upload the ABI file(s) you saved on your local filesystem in the previous step.

Rest

A fully typed REST api with documentation is created out of the Smart Contract ABI, you can discover all its endpoints on the REST tab. To see examples in your technology of choice use the dropdown in the example section on the right.

Graphql

The GraphQL api exposes the same functionality as the REST api, you can discover it on the GraphQL tab.

Webhooks

On the Webhooks tab you can register your own webhook. The portal will send events to this webhook when a transaction is processed.

When sending a message the event will have a signature which allows the receiver to validate if the event has not been tampered with.

The secret to validate the signature can be copied from the details page of your webhook.

Standard Webhooks has built SDKs and useful tools using different programming languages that make it easy to start using webhooks.

An example using Typescript, Elysia and standard webhooks.

import { Elysia, t } from "elysia";
import { Webhook } from "standardwebhooks";

async function webhookConsumerBootstrap(secret: string) {
  const webhookConsumer = new Elysia().post(
    "/scp-listener",
    ({ headers, body }) => {
      try {
        const wh = new Webhook(btoa(secret));
        const verifiedPayload = wh.verify(JSON.stringify(body.payload), {
          "webhook-id": headers["btp-portal-event-id"]!,
          "webhook-signature": headers["btp-portal-event-signature"]!,
          "webhook-timestamp": headers["btp-portal-event-timestamp"]!,
        });
        console.log(
          `Received a webhook event: ${JSON.stringify(verifiedPayload)}`
        );
      } catch (err) {
        console.error("Webhook payload invalid", err);
        throw err;
      }
    },
    {
      body: t.Object({
        payload: t.Object({
          apiVersion: t.String(),
          eventId: t.String(),
          eventName: t.String(),
          timestamp: t.Number(),
          data: t.Any(),
        }),
      }),
    }
  );
  const app = new Elysia().use(webhookConsumer).onStart(({ server }) => {
    console.log(
      `Started the test webhook consumer on ${server?.url.toString()}`
    );
  });
}

Transaction Monitoring & Alerting

The smart contract portal provides powerful on-chain monitoring capabilities that enable you to track, filter, and respond to blockchain transactions in real-time.

On-chain monitoring is critical for:

• Security: Detect and respond to suspicious activities instantly
• Compliance: Track transactions for regulatory reporting
• Operations: Ensure critical transactions are processed correctly
• Business Intelligence: Gain insights from transaction patterns

Common monitoring scenarios include:

• High-value transfers exceeding threshold amounts
• Contract interactions from specific addresses
• Contract events signaling state changes
• Failed transactions that require attention

With the portal, you can set up customized alerting rules that trigger actions when specified conditions are met. These actions can include:

• Sending email notifications to stakeholders
• Triggering webhooks to external systems
• Logging events for audit purposes
• Executing automated workflows in response

The combination of real-time monitoring and flexible alerting provides a powerful foundation for building robust dApps that can respond dynamically to on-chain activities.

Further reading

• The Graph Middleware
• The Smart contract portal Middleware
• Attestation Indexer
• Firefly FabConnect
• Configure transaction monitoring & alerting