Plopl.

PLOPL is a dev-tooling designed to bring off-chain (Web2) data onto the blockchain. It simplifies verification, keeping user data secure while empowering dApps to leverage real-world facts on-chain. Rather than dealing with cryptographic complexity, developers can rely on PLOPL’s “Recipes” and an easy-to-use browser extension to validate data from Web2 sources.

Key Features Privacy Preservation Only the relevant facts needed for verification are shared. This ensures user data stays private, with no unnecessary exposure.

Developer-Friendly No advanced cryptography or specialized infrastructure required. Recipes are written in JSON, and proofs can be requested with minimal code.

Reusability Once a user proves a fact, the proof can be used across multiple dApps. This leads to faster user onboarding and less friction.

Web2 to Web3 Verification The PLOPL Extension intercepts data from standard Web2 APIs, checks it against a set of rules, and generates on-chain proofs.

NODIT Infrastructure PLOPL is powered by NODIT for RPC calls and an indexer that tracks proofs (Plops) across various registries.

Why PLOPL Verifying real-world data on-chain typically involves complex cryptographic setups or reliance on centralized oracles. PLOPL reduces that complexity by:

Providing a convenient browser extension to intercept and validate Web2 API calls.

Allowing anyone to create or reuse recipes that define how to parse and check incoming data.

Storing proofs in a decentralized manner via smart contracts that developers can query with confidence.

How It Works Plop Request A dApp includes a Recipe ID (stored in a PloplRegistry contract) and a target chain in its request to the user.

PLOPL Extension Intercepts The user’s browser extension prompts them to visit or log into the relevant Web2 page (for example, a conference site to prove attendance).

Data Capture When the user visits that page, the browser extension listens for the specified API call and captures its response.

Recipe Validation The extension checks if the data in the API response meets the conditions defined in the Recipe.

Proof Generation Once validated, a multi-signed proof (also called a Plop) is generated and submitted to the PloplRegistry on-chain.

Creating a Recipe A Recipe is a JSON file that tells the extension where to fetch data, which fields to look at, and what conditions must be met. PLOPL Portal provides two ways to create Recipes:

Manual Mode Write or paste a JSON schema that outlines your data source, fields, conditions, and any other logic.

GUI Mode

Provide a cURL request (for instance, one that fetches user event history).

The system parses the response fields.

You select which fields to verify, and define the conditions (like “greater than 3”).

Add a name, description, and “Prepare URL” (the page the user must open).

Sign a transaction to finalize the new Recipe on the PloplRegistry.

Generating a Proof (Plop) Select a Recipe On the PLOPL Portal, find the Recipe you want to use and click “Generate.”

Visit the Required Page The extension guides you to open or log into the data source (for example, ethglobal.com).

Wait for Interception The PLOPL Extension captures the relevant API request and checks it against the recipe rules.

Submit Proof If the response is valid, the “Submit PLOP” button becomes available. Clicking it finalizes the proof submission on-chain.

Use It Anywhere After confirmation, the Plop is ready to be referenced in any smart contract or dApp that supports PLOPL.

Example Use Case: ETHGlobal Attendance Use Case A dApp wants to verify if a user has minted three or more packs through the ETHGlobal platform.

Recipe Creation

Provide a cURL command to fetch the user’s pack redemption data.

Define a condition such as “packRedemptions >= 3.”

Set the “Prepare URL” to ethglobal.com/home.

Sign the transaction to publish the Recipe.

User Flow

The dApp references the Recipe on the PloplRegistry.

The user is prompted to visit ethglobal.com/home.

The extension intercepts the API call and verifies the data against the Recipe.

A proof (Plop) is generated and recorded on-chain.

The user can reuse this proof wherever they need to demonstrate ETHGlobal attendance.

Multi-Chain Support PLOPL is deployed on the following testnets:

Base Sepolia

Polygon Amoy

Zircuit

NODIT infrastructure handles the behind-the-scenes operations such as RPC calls and indexing all proofs across these networks.

We started with a simple concept: bring off-chain Web2 data onto the blockchain in a way that’s private and easy to use. This required bridging several technologies and solving a few tricky problems along the way.

Browser Extension

Built with TypeScript to leverage strong typing and modern tooling.

Intercepts HTTP requests by listening at the network level via the browser’s APIs.

“Hacky” bit: we had to carefully filter requests to capture only the relevant ones for each Recipe, which required deep fiddling with the extension’s background and content scripts.

Uses cryptographic functions to sign the validated data client-side, ensuring no sensitive info is exposed until it’s time to submit the proof on-chain.

Smart Contracts

Solidity on Ethereum-compatible testnets (Base Sepolia, Polygon Amoy, Zircuit).

PloplRegistry holds references to Recipes (small JSON specifications) and proofs.

PloplManager coordinates proof submissions and provides an easy interface for dApps to check if a proof exists.

Each Recipe is stored minimally on-chain: we keep references and hashed data to preserve space and privacy.

PLOPL Portal

Built with a React/Next.js frontend, allowing for dynamic, component-based development.

Offers a GUI for generating or editing Recipes. By pasting in a cURL request, the portal parses the response fields so you can define conditions more intuitively.

The “manual mode” lets power users paste in their own JSON schema directly.

Displays user proofs by fetching data from the blockchain and an indexing layer.

NODIT Integration

Serves as our partner technology for RPC endpoints and indexing.

Bypasses the need to stand up our own node infrastructure on multiple testnets.

Makes the “Dashboard” experience smoother; when a user submits a proof, NODIT’s indexer picks it up quickly, so the Portal shows the update in near real-time.

Under the Hood

Data Flow: dApps reference a Recipe ID, the extension redirects the user to the correct webpage, the user logs in if needed, the extension intercepts the API call, checks it against the Recipe, and if everything matches, it signs and submits the proof on-chain.

Security: Only the fields required by the Recipe are used, and everything else remains private.

Modular Design: New Recipes can be created or reused by different projects, letting multiple dApps verify the same user fact without extra hassle.

Notable Hacks and Tweaks

Real-Time Interception: Designing an extension that passively listens for specific requests on certain domains took trial and error. The biggest challenge was ensuring we didn’t accidentally capture or store unrelated user data.

Lightweight On-Chain Storage: To avoid bloated contracts, we store minimal data on-chain, with logic that references off-chain fields by their hashed identifiers.

Privacy Controls: We had to ensure that only the proof or “Yes/No” condition would be revealed, rather than the entire user response from Web2.

Overall, by mixing a specialized browser extension, straightforward smart contracts, a user-friendly portal, and NODIT’s infrastructure, we achieved a system that lets developers validate Web2 data in Web3 without the usual friction.