Integrating Web3 with IoT: Project Snowman’s New Blockchain-Powered CO Capture System

Jay Lee — Mon, 11 Aug 2025 21:21:43 +0000

Project Snowman is an IoT platform that measures and verifies CO₂ capture in real time.
Our devices log environmental impact directly from the source — but until now, the data stayed in private databases.

The problem? Trust.
How can anyone verify that the numbers are accurate without relying solely on us?

Why We’re Bringing Web3 Into the Loop
Web3 solves this with public, immutable records.
By recording capture events on-chain, we make every kilogram of CO₂ captured:

Verifiable – Anyone can confirm the data against on-chain proofs.

Immutable – No edits, no deletions, no tampering.

Auditable – Third parties can run their own checks.

This means Snowman’s environmental impact data now becomes part of a global, transparent ledger.

The New Snowman Flow
IoT Sensors measure CO₂ levels and capture rates.

Data Processing happens in the Snowman app — validating, aggregating, and preparing proofs.

Blockchain Proofs store hashes (Merkle roots) of the data for immutability.

Snow Credits (ERC-20) are minted as loyalty-style rewards for verified impact.

Achievement Badges (ERC-1155 NFTs) mark milestones and unlock perks.

In-App Swap lets users exchange Snow Credits for other assets without leaving the app.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";

contract SnowCredits is ERC20, AccessControl {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");

    constructor(address admin) ERC20("Snow Credits", "SNOW") {
        _grantRole(DEFAULT_ADMIN_ROLE, admin);
        _grantRole(MINTER_ROLE, admin);
    }

    function mint(address to, uint256 amount) external onlyRole(MINTER_ROLE) {
        _mint(to, amount);
    }
}

`// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";

contract SnowBadges is ERC1155, AccessControl, IERC2981 {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
address public royaltyReceiver;
uint96 public royaltyBps = 500; // 5%

constructor(address admin, string memory baseURI) ERC1155(baseURI) {
    _grantRole(DEFAULT_ADMIN_ROLE, admin);
    _grantRole(MINTER_ROLE, admin);
    royaltyReceiver = admin;
}

function mint(address to, uint256 id, uint256 qty)
    external
    onlyRole(MINTER_ROLE)
{
    _mint(to, id, qty, "");
}

// ---- Optional soulbound guard ----
// uncomment to disable transfers between users
// function _beforeTokenTransfer(
//   address op, address from, address to, uint256[] memory ids,
//   uint256[] memory amts, bytes memory data
// ) internal override {
//   if (from != address(0) && to != address(0)) revert("Soulbound");
//   super._beforeTokenTransfer(op, from, to, ids, amts, data);
// }

// ---- EIP-2981 royalties ----
function royaltyInfo(uint256, uint256 salePrice)
    external
    view
    returns (address, uint256)
{
    return (royaltyReceiver, (salePrice * royaltyBps) / 10_000);
}

}

`
Technical Notes
Tokens:

Snow Credits → ERC-20 with MINTER_ROLE controlled by an admin wallet.

Snow Badges → ERC-1155, optionally soulbound for certain tiers.

Data Integrity:

Raw telemetry stored off-chain (database/IPFS).

Merkle root written to the blockchain for verification.

Wallet Integration:

Uses wagmi + RainbowKit for a quick connect flow.

Smart wallets (ERC-4337) under consideration for gasless claims.

Swap Function:

Uniswap v3 or 0x aggregator integrated via in-app UI.

Snow Credits paired against USDC or WETH on Polygon/Base for low fees.

`
// wagmi v2 + viem
import { useWriteContract } from 'wagmi'
import snowCreditsAbi from './abi/SnowCredits.json'
import snowBadgesAbi from './abi/SnowBadges.json'

const SNOW_CREDITS = '0xYourSnowCredits';
const SNOW_BADGES = '0xYourSnowBadges';

export function AdminActions({ user, credits, badgeId }:{
user: 0x${string}, credits: string, badgeId: number
}) {
const { writeContractAsync } = useWriteContract();

const awardCredits = async () => {
await writeContractAsync({
address: SNOW_CREDITS,
abi: snowCreditsAbi,
functionName: 'mint',
args: [user, BigInt(credits)] // credits are 18 decimals in the ABI
});
};

const mintBadge = async () => {
await writeContractAsync({
address: SNOW_BADGES,
abi: snowBadgesAbi,
functionName: 'mint',
args: [user, BigInt(badgeId), 1n]
});
};

return (
<>
Award Credits
Mint Badge #{badgeId}
</>
);
}

`
// Pseudocode (Node.js) – illustrate approach without revealing data model
import { createHash } from 'crypto';
// const cid = await ipfsAdd(JSON.stringify(redactedSummary))

export function proofHash(jsonSummary: string) {
return createHash('sha256').update(jsonSummary).digest('hex');
}

// Later on-chain you would store: { periodId, wallet, cid, hash }

` `
Why It Matters for Developers
This architecture is modular and chain-agnostic.
You can replicate the model for any IoT → Proof → Reward flow, whether you’re measuring emissions, renewable generation, or supply chain events.

The key takeaway: don’t put raw IoT data directly on-chain.
Instead, store proofs (hashes) to keep transactions lightweight, private, and cost-effective.

Next Steps for Project Snowman
Phase 1 – On-chain proofs + wallet integration (in progress)

Phase 2 – Snow Credits minting + badge reward system

Phase 3 – Full in-app swap and expanded partner ecosystem

If you’re building in IoT, blockchain, or climate tech — I’d love to connect and exchange ideas.

💬 What’s your take on using NFTs and tokens for environmental incentives? Would love to hear from other builders in the comments.

IoT #Web3 #Blockchain #NFTs #DeFi #ClimateTech #ProjectSnowman

How We Cut IoT Backend Calls by 85% with C++ and BLE Pairing on ESP32

Jay Lee — Mon, 04 Aug 2025 17:52:49 +0000

❄️ How We Cut IoT Backend Calls by 85% with C++ and BLE Pairing on ESP32

Project Snowman is an embedded IoT system built on an ESP32. Our goal?

Collect real-time environmental data, send it to the cloud, and display it on a live frontend —

all while minimizing backend strain and keeping config secure.

🔧 Hardware & Stack

ESP32
DS18B20 temperature sensors
C++ with PlatformIO
BLE + Wi-Fi
REST API (Render backend)
React + Vite frontend (Netlify)

🧱 Modular C++ Architecture (S.O.L.I.D. Principles)

We designed the firmware using modern object-oriented programming:

SensorManager handles DS18B20 readings
WiFiManager connects to Wi-Fi and checks status
BLEServerModule handles proximity-based setup
APIClient pushes data only when requested

if (bleTriggeredReconnect && millis() - bleReconnectTime > 10000) {
  WiFi.begin(bleSSID.c_str(), blePassword.c_str());
  bleServer->stopAdvertising();
}

Each class has a single responsibility — easy to debug, maintain, and scale.

🔐 BLE Pairing Mode with Proximity Logic

BLE is used for configuration. No insecure web portals.

BLE GATT server activates only during setup mode
Accepts Wi-Fi credentials from a phone
Reconnects automatically and turns off BLE afterward

⚙️ Request-Only Backend API Flow

Instead of pushing sensor data continuously, the ESP32 sends updates only when requested by the frontend.

Dropped backend calls from 100+ per hour ➝ ~15
Reduced bandwidth, power, and compute costs

💻 Frontend Integration (React + Vite)

The frontend fetches sensor data and renders it in real-time using stat cards.

useEffect(() => {
  fetch("/api/data/latest")
    .then(res => res.json())
    .then(setData);
}, []);

Fast. Clean. Minimal load.

🧠 What We Learned

Event-driven IoT logic beats constant loop polling
BLE provisioning improves security + UX
PlatformIO and C++ OOP scale beautifully for embedded builds

🔜 What’s Next

Audit logging for BLE pairing events
Push BLE config via mobile app
Real-world vehicle deployments
Publishing full Medium article + case study

Let me know what you're building — and if you're working on embedded systems or sustainable tech, let's connect!

Tags: #esp32 #c++ #iot #ble #embedded #platformio

DEV Community: Jay Lee