Links
- Demo: https://youtu.be/Ob84OdtCP0E
- Dapp: https://grand-sawine-1d648f.netlify.app/
- Deck: https://www.canva.com/design/DAGB5hj2qyo/jc6mAihQsAaEGgh_aw0OYg/view?utm_content=DAGB5hj2qyo&utm_campaign=designshare&utm_medium=link&utm_source=editor
- Smart contract code: https://github.com/daksha-aeer/stratum-contracts
- UI code: https://github.com/daksha-aeer/str-frontend
Inspiration
We wanted to bring the concept of proof-of-work to the NEAR ecosystem in a way that’s simple and engaging, allowing anyone to participate in token minting without needing extensive technical knowledge or equipment. Proof of work is typically associated with complex calculations and high entry barriers. By simplifying this process, we’re making it accessible to anyone interested in Web3.
What it does
Stratum is a proof-of-work token distribution system built on the NEAR blockchain. Miners compete to find a hash-based proof for a counter stored in our smart contract. When a user submits a correct proof, the contract verifies it, rewards the user with a token, and increments the counter, prompting the next round. Mining is as simple as connecting your wallet and clicking "Start Mining"—the rest runs automatically.
How we built it
We split development into two parts. For the backend, we used Rust and the NEAR SDK to build a smart contract that keeps track of a counter and checks proofs, using Keccak256 and little-endian encoding to keep hashes consistent. The contract handles tasks like getting the counter, verifying proofs, and minting tokens. On the front-end, we used TypeScript and React within a Vite.js setup to let users connect their NEAR wallets and interact with the contract easily. NEAR Wallet Selector simplifies wallet connections, while the NEAR API helps manage transactions. We also set up a mining script that automatically submits proofs, so users can keep things running smoothly without extra steps.
Challenges we ran into
We encountered a few bumps along the way during development. We started by writing the smart contract to take proof as input and verify its hash. However, when we moved on to the minting part and began debugging the code, we ran into errors. Even after reverting to the previous version—the one that handled hash verification—nothing worked. While we could still deploy the smart contract, we started receiving deserialization errors whenever we called any of its functions.
Initially, we thought it might be an issue with the directory, so we tried writing code in a new one, but that didn’t resolve the problem either. We began to suspect that the account we were using for deployment might have become corrupted, which led to these deserialization issues. This forced us to take a step back and thoroughly investigate our work environment, which unfortunately consumed quite a bit of time and stalled our progress.
When we integrated the NEAR Wallet using the SDK, we also faced dependency clashes. Different libraries required conflicting versions of Node.js, and this wasn’t clearly indicated in the documentation, which hadn’t been updated. As a result, we had to sift through various websites to find a compatible version.
Accomplishments that we're proud of
We’re proud of the work we put into building an easy proof-of-work system on the NEAR blockchain. Getting the smart contract right took time and research, especially around token creation and distribution. We had to pull together a few resources to piece the code together. One of our big goals was to make mining accessible, so anyone could jump in without needing special hardware or technical skills. We’re happy that users can simply connect their wallet, click "Start Mining," and let the system take care of the rest. We also think this approach could make it easier for people new to Web3 to get started, giving them a straightforward way to participate without feeling overwhelmed.
What we learned
We learned that even simple-sounding features, like proof verification and wallet integration, come with a surprising amount of technical depth and can take a lot of time to get just right. Reading the documentation thoroughly turned out to be essential—it helped us code more effectively and troubleshoot faster when things went wrong.
Writing the smart contract itself was a major learning curve. We had to balance coding and debugging constantly. We also learned the importance of structuring our code carefully from the start, as even small changes can have ripple effects that aren’t always obvious until much later.
In the end, we came away with a better understanding of both the technical and creative sides of building a project. We saw firsthand how critical good planning and solid documentation are to a project’s success, and we’re excited to bring these skills into future projects.
Proof Of Work Landscape
Bitcoin Bitcoin uses a SHA-256 hashing algorithm where miners compete to find a hash below a certain difficulty level, adjusted every two weeks. Miners earn new Bitcoins and transaction fees as rewards. However, the process is highly energy-intensive, which has sparked environmental concerns, and the mining space is increasingly dominated by large, centralized operators.
Monero Monero, on the other hand, employs RandomX—a CPU-friendly, ASIC-resistant algorithm that promotes decentralization by allowing mining on general-purpose CPUs. This makes Monero mining more accessible and reinforces its privacy-focused ethos. Yet, Monero’s commitment to privacy can lead to slower transactions, and even RandomX may still attract centralization through high-performance setups.
Ore Ore on Solana introduces a more accessible proof-of-work model, lowering technical entry barriers and allowing newcomers to participate in mining with minimal setup. Ore pioneered proof of work on smart contracts using drillx, a GPU resistant PoW algorithm based on Monero's RandomX.
What's next for Stratum
Looking ahead, we have a lot of ideas for Stratum. First, we’re planning to enhance both the security and complexity of our proof-of-work system. Right now, the system runs on a straightforward counter, but we’d like to implement more advanced hashing functions, such as Equihash or RandomX, to make the mining process more secure and challenging.
We also want to expand wallet compatibility, allowing users to connect with a wider range of wallets for greater convenience and flexibility. Beyond mining, we’re excited to introduce staking options, enabling users to earn higher rewards by committing tokens to the network. This could add a new dimension to user engagement, blending mining and staking for a more dynamic experience.
Ultimately, we see a lot of potential for Stratum to grow, and we're excited to explore features that could make it even more user-friendly and rewarding.
Built With
- nearapi
- nearsdk
- react
- rust
- typescript


Log in or sign up for Devpost to join the conversation.