From 63217f0ecfd7ad517828aa6271dc2ac401a352a6 Mon Sep 17 00:00:00 2001 From: pael666 <86571253+pael666@users.noreply.github.com> Date: Fri, 5 Dec 2025 07:49:44 +0700 Subject: [PATCH 1/8] Create pael666.md --- submissions/infrastructure/pael666.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 submissions/infrastructure/pael666.md diff --git a/submissions/infrastructure/pael666.md b/submissions/infrastructure/pael666.md new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/submissions/infrastructure/pael666.md @@ -0,0 +1 @@ + From e15b22e493b13ae1dd3c4dc8c191a66f0c3e2966 Mon Sep 17 00:00:00 2001 From: pael666 <86571253+pael666@users.noreply.github.com> Date: Fri, 5 Dec 2025 07:51:14 +0700 Subject: [PATCH 2/8] Update pael666.md --- submissions/infrastructure/pael666.md | 105 ++++++++++++++++++++++++++ 1 file changed, 105 insertions(+) diff --git a/submissions/infrastructure/pael666.md b/submissions/infrastructure/pael666.md index 8b137891..490e71a9 100644 --- a/submissions/infrastructure/pael666.md +++ b/submissions/infrastructure/pael666.md @@ -1 +1,106 @@ +# vApp Submission: ProofLens +## Verification +```yaml +github_username: "pael666" +discord_id: "pa3l" +timestamp: "2025-12-05" +Developer +Name: Raphael Pardamean + +GitHub: @pael666 + +Discord: pa3l + +Experience: +I’ve been learning and experimenting with Web3 development, mostly by building small prototypes and testing new ideas. Recently I’ve been interested in tools that focus on verification and authenticity, especially as AI-generated content becomes harder to trust. ProofLens is a project where I want to explore how verifiable authorship can be made simple enough for anyone to use. + +Project +Name & Category +Project: ProofLens + +Category: infrastructure + +Description +The idea behind ProofLens comes from a simple problem: it’s getting harder to know whether someone actually created the content they post. With AI tools everywhere, almost anyone can generate convincing text or images, and there’s no easy way to prove who made what. + +ProofLens gives users a way to generate proof of authorship for their content. The app takes a piece of text or an image, turns it into a hash locally, and then asks the Soundness Layer to create an attestation linking the user to that hash. Other apps can later verify this proof without needing access to the original content. + +It’s meant to be a small but useful building block that creators and developers can rely on when they need a trustworthy way to show that something actually came from them. + +SL Integration +ProofLens uses the Soundness Layer to generate authorship attestations that are verifiable and tamper-proof. +The SL makes it possible to: + +Create authorship proofs tied to a user without relying on a centralized database + +Let third-party apps verify the proof independently + +Validate ownership using a hash instead of the original content, keeping the user’s data private + +The Soundness Layer essentially acts as the trust anchor that makes these claims meaningful and easy to verify anywhere. + +Technical +Architecture +The system is built around three simple pieces: + +Frontend: Users upload content, and the hashing happens locally so nothing sensitive leaves the device. + +Backend: Receives the content hash and requests the attestation from the Soundness Layer. + +Verification API: Lets other applications check whether a given hash matches a valid attestation. + +Optional storage (like IPFS or WALRUS) may be used only if users want to persist their files, but it's not required for the core authorship proof. + +Stack +Frontend: React / Next.js + +Backend: Node.js + +Blockchain: Soundness Layer + +Storage: WALRUS / IPFS (optional) + +Features +Local content hashing for privacy + +Attestation creation through the Soundness Layer + +Dashboard for users to view their proofs + +Public verification endpoint for third-party integrations + +Timeline +PoC (2–4 weeks) + Basic hashing and attestation flow + + Initial SL integration + + Simple UI to upload content and display proofs + +MVP (4–8 weeks) + Full dashboard + + Public verification API + + Support for more content formats + + User testing and UX refinement + +Innovation +ProofLens focuses on a problem that’s becoming more relevant every day: proving authorship in a world full of AI-generated content. Instead of trying to fight AI, ProofLens provides creators with a way to say, “Yes, I made this — and here’s the proof.” +It’s lightweight, private by design, and flexible enough for other developers to embed into their own apps. + +Contact +Preferred contact: Discord (pa3l) +Updates will be shared on GitHub (@pael666) + +Checklist before submitting: + + All fields completed + + GitHub username matches PR author + + SL integration explained + + Timeline is realistic From 4a17614f376f1ba06bd56e74d827627d355c0d08 Mon Sep 17 00:00:00 2001 From: pael666 <86571253+pael666@users.noreply.github.com> Date: Fri, 5 Dec 2025 07:52:14 +0700 Subject: [PATCH 3/8] Update pael666.md --- submissions/infrastructure/pael666.md | 118 +++++++++++++++----------- 1 file changed, 68 insertions(+), 50 deletions(-) diff --git a/submissions/infrastructure/pael666.md b/submissions/infrastructure/pael666.md index 490e71a9..121aabac 100644 --- a/submissions/infrastructure/pael666.md +++ b/submissions/infrastructure/pael666.md @@ -1,11 +1,14 @@ -# vApp Submission: ProofLens +Project: ProofLens +Category: Infrastructure +Developer: Raphael Pardamean (pael666) -## Verification -```yaml +Verification github_username: "pael666" discord_id: "pa3l" timestamp: "2025-12-05" + Developer + Name: Raphael Pardamean GitHub: @pael666 @@ -13,94 +16,109 @@ GitHub: @pael666 Discord: pa3l Experience: -I’ve been learning and experimenting with Web3 development, mostly by building small prototypes and testing new ideas. Recently I’ve been interested in tools that focus on verification and authenticity, especially as AI-generated content becomes harder to trust. ProofLens is a project where I want to explore how verifiable authorship can be made simple enough for anyone to use. +I’ve been exploring Web3 development and the idea of building tools that help people trust what they see online. I enjoy working on small prototypes, testing ideas quickly, and learning new frameworks along the way. Lately, I’ve been interested in systems that deal with verification and identity, especially as AI content becomes harder to distinguish. ProofLens is my attempt to create something useful and simple for creators and developers. Project Name & Category + Project: ProofLens -Category: infrastructure +Category: Infrastructure Description -The idea behind ProofLens comes from a simple problem: it’s getting harder to know whether someone actually created the content they post. With AI tools everywhere, almost anyone can generate convincing text or images, and there’s no easy way to prove who made what. -ProofLens gives users a way to generate proof of authorship for their content. The app takes a piece of text or an image, turns it into a hash locally, and then asks the Soundness Layer to create an attestation linking the user to that hash. Other apps can later verify this proof without needing access to the original content. +It’s becoming harder every year to tell whether a piece of content truly comes from the person who claims to have created it. With the rise of AI-generated text and images, the internet is starting to feel full of things that look real but aren’t tied to any real creator. -It’s meant to be a small but useful building block that creators and developers can rely on when they need a trustworthy way to show that something actually came from them. +ProofLens aims to provide a small, practical solution to that problem. +The idea is simple: let users prove that they created or own a specific piece of content — without needing to reveal the content itself. -SL Integration -ProofLens uses the Soundness Layer to generate authorship attestations that are verifiable and tamper-proof. -The SL makes it possible to: +A user uploads a text snippet or an image, the app turns it into a hash locally, and then Soundness Layer creates an attestation linking the user to that hash. The attestation can be verified by any other application later on. -Create authorship proofs tied to a user without relying on a centralized database +It’s not meant to replace social platforms or marketplaces. Instead, ProofLens acts more like a building block — a small piece of infrastructure that developers can plug into their own apps when they want a reliable way to check if content really belongs to someone. -Let third-party apps verify the proof independently +Soundness Layer Integration -Validate ownership using a hash instead of the original content, keeping the user’s data private +Soundness Layer plays a central role in how ProofLens works: -The Soundness Layer essentially acts as the trust anchor that makes these claims meaningful and easy to verify anywhere. +Creating a trustworthy authorship proof +Instead of storing data in a centralized database, the attestation comes from SL. +This makes the authorship claim tamper-proof and independently verifiable. -Technical -Architecture -The system is built around three simple pieces: +Allowing verification without exposing the content +Only the hash is used. +Applications can confirm the attestation without ever accessing the original content. -Frontend: Users upload content, and the hashing happens locally so nothing sensitive leaves the device. +Providing a neutral verification layer +No need to trust ProofLens itself. +The proof lives on SL, so any app can check it from there. -Backend: Receives the content hash and requests the attestation from the Soundness Layer. +The SL essentially becomes the “trust backbone” of the system — the part that makes the attestation meaningful. -Verification API: Lets other applications check whether a given hash matches a valid attestation. +Technical +Architecture Overview -Optional storage (like IPFS or WALRUS) may be used only if users want to persist their files, but it's not required for the core authorship proof. +Frontend (React / Next.js) +A lightweight interface where users upload content. +The hashing happens locally, so the original file never leaves the browser. -Stack -Frontend: React / Next.js +Backend (Node.js or Rust) +Receives the hash and interacts with the Soundness Layer to create the attestation. +Only minimal data is stored — mostly for the user’s dashboard. -Backend: Node.js +Soundness Layer +Generates and verifies all attestations. -Blockchain: Soundness Layer +Verification API +A simple endpoint that apps can call to check whether a specific content hash has a valid attestation. -Storage: WALRUS / IPFS (optional) +Optional Storage (IPFS / WALRUS) +Only used if users want to permanently store their content, but not required for the core workflow. Features -Local content hashing for privacy -Attestation creation through the Soundness Layer +Local hashing for privacy + +Attestation creation through SL -Dashboard for users to view their proofs +Dashboard to track all proofs created by the user -Public verification endpoint for third-party integrations +Public verification endpoint for third-party apps Timeline -PoC (2–4 weeks) - Basic hashing and attestation flow +PoC: 2–4 weeks - Initial SL integration +Local hashing of content - Simple UI to upload content and display proofs +First working attestation request to SL -MVP (4–8 weeks) - Full dashboard +Minimal UI to upload content and display proof - Public verification API +Simple verification endpoint - Support for more content formats +MVP: 4–8 weeks - User testing and UX refinement +Full dashboard for users + +Public verification API + +Support for multiple content formats + +Basic UX polish and testing Innovation -ProofLens focuses on a problem that’s becoming more relevant every day: proving authorship in a world full of AI-generated content. Instead of trying to fight AI, ProofLens provides creators with a way to say, “Yes, I made this — and here’s the proof.” -It’s lightweight, private by design, and flexible enough for other developers to embed into their own apps. -Contact -Preferred contact: Discord (pa3l) -Updates will be shared on GitHub (@pael666) +What makes ProofLens interesting isn’t that it’s a full platform — it’s that it tries to solve one problem cleanly: -Checklist before submitting: +“How do you prove you actually made something, without giving it away?” - All fields completed +Instead of fighting AI or building complex anti-bot systems, ProofLens leans on the idea of authorship as a cryptographic claim. Anyone can generate content, even AI — but being able to prove you were the one who submitted it first gives creators an advantage. - GitHub username matches PR author +And because the entire proof system sits on the Soundness Layer, other apps don’t need to trust ProofLens. They can verify everything independently. + +It’s a small piece of infrastructure, but one that can fit into social apps, marketplaces, creative platforms, identity systems, and even private communities where authenticity matters. + +Contact - SL integration explained +Preferred: Discord (pa3l) - Timeline is realistic +Updates: GitHub (@pael666) From 40ae89337ee397d8f2610a3590d5ef5f0e9c6f71 Mon Sep 17 00:00:00 2001 From: pael666 <86571253+pael666@users.noreply.github.com> Date: Fri, 5 Dec 2025 07:54:04 +0700 Subject: [PATCH 4/8] Update pael666.md --- submissions/infrastructure/pael666.md | 103 +++++++++----------------- 1 file changed, 33 insertions(+), 70 deletions(-) diff --git a/submissions/infrastructure/pael666.md b/submissions/infrastructure/pael666.md index 121aabac..6c184e0b 100644 --- a/submissions/infrastructure/pael666.md +++ b/submissions/infrastructure/pael666.md @@ -1,12 +1,10 @@ -Project: ProofLens -Category: Infrastructure -Developer: Raphael Pardamean (pael666) +# vApp Submission: ProofLens -Verification +## Verification +```yaml github_username: "pael666" discord_id: "pa3l" timestamp: "2025-12-05" - Developer Name: Raphael Pardamean @@ -16,109 +14,74 @@ GitHub: @pael666 Discord: pa3l Experience: -I’ve been exploring Web3 development and the idea of building tools that help people trust what they see online. I enjoy working on small prototypes, testing ideas quickly, and learning new frameworks along the way. Lately, I’ve been interested in systems that deal with verification and identity, especially as AI content becomes harder to distinguish. ProofLens is my attempt to create something useful and simple for creators and developers. +I’ve been experimenting with Web3 development by building small prototypes and exploring tools related to verification, identity, and content authenticity. Lately I’ve been interested in how creators can prove authorship in a simple and privacy-friendly way, which led me to build ProofLens. Project Name & Category Project: ProofLens -Category: Infrastructure +Category: infrastructure Description -It’s becoming harder every year to tell whether a piece of content truly comes from the person who claims to have created it. With the rise of AI-generated text and images, the internet is starting to feel full of things that look real but aren’t tied to any real creator. - -ProofLens aims to provide a small, practical solution to that problem. -The idea is simple: let users prove that they created or own a specific piece of content — without needing to reveal the content itself. - -A user uploads a text snippet or an image, the app turns it into a hash locally, and then Soundness Layer creates an attestation linking the user to that hash. The attestation can be verified by any other application later on. +It’s becoming harder to know whether someone genuinely created a piece of content, especially with AI tools everywhere. ProofLens gives users a simple way to prove authorship of text or images without exposing the content itself. The app generates a local hash, then uses the Soundness Layer to create an attestation that links the user to that hash. Other apps can verify this proof independently. -It’s not meant to replace social platforms or marketplaces. Instead, ProofLens acts more like a building block — a small piece of infrastructure that developers can plug into their own apps when they want a reliable way to check if content really belongs to someone. +SL Integration -Soundness Layer Integration +ProofLens relies on the Soundness Layer to produce verifiable authorship attestations. The SL allows users to create proofs that are tamper-proof and can be validated without needing the original content. Third-party apps can check these attestations directly through SL, making the authorship claim portable and trustworthy. -Soundness Layer plays a central role in how ProofLens works: - -Creating a trustworthy authorship proof -Instead of storing data in a centralized database, the attestation comes from SL. -This makes the authorship claim tamper-proof and independently verifiable. +Technical +Architecture -Allowing verification without exposing the content -Only the hash is used. -Applications can confirm the attestation without ever accessing the original content. +The flow is straightforward: -Providing a neutral verification layer -No need to trust ProofLens itself. -The proof lives on SL, so any app can check it from there. +The frontend handles content upload and hashing locally. -The SL essentially becomes the “trust backbone” of the system — the part that makes the attestation meaningful. +The backend receives the hash and interacts with the Soundness Layer to generate the attestation. -Technical -Architecture Overview +A verification endpoint lets other apps confirm whether a hash has a valid proof attached. +Optional storage (like WALRUS/IPFS) can be used if users want to store their content, but it isn’t required. -Frontend (React / Next.js) -A lightweight interface where users upload content. -The hashing happens locally, so the original file never leaves the browser. +Stack -Backend (Node.js or Rust) -Receives the hash and interacts with the Soundness Layer to create the attestation. -Only minimal data is stored — mostly for the user’s dashboard. +Frontend: React / Next.js -Soundness Layer -Generates and verifies all attestations. +Backend: Node.js -Verification API -A simple endpoint that apps can call to check whether a specific content hash has a valid attestation. +Blockchain: SL -Optional Storage (IPFS / WALRUS) -Only used if users want to permanently store their content, but not required for the core workflow. +Storage: WALRUS / IPFS (optional) Features -Local hashing for privacy - -Attestation creation through SL +Local content hashing for privacy -Dashboard to track all proofs created by the user +Authorship attestation through SL -Public verification endpoint for third-party apps +User dashboard to view proofs Timeline -PoC: 2–4 weeks +PoC (2-4 weeks) -Local hashing of content + Basic functionality -First working attestation request to SL + SL integration -Minimal UI to upload content and display proof + Simple UI -Simple verification endpoint +MVP (4-8 weeks) -MVP: 4–8 weeks + Full features -Full dashboard for users + Production ready -Public verification API - -Support for multiple content formats - -Basic UX polish and testing + User testing Innovation -What makes ProofLens interesting isn’t that it’s a full platform — it’s that it tries to solve one problem cleanly: - -“How do you prove you actually made something, without giving it away?” - -Instead of fighting AI or building complex anti-bot systems, ProofLens leans on the idea of authorship as a cryptographic claim. Anyone can generate content, even AI — but being able to prove you were the one who submitted it first gives creators an advantage. - -And because the entire proof system sits on the Soundness Layer, other apps don’t need to trust ProofLens. They can verify everything independently. - -It’s a small piece of infrastructure, but one that can fit into social apps, marketplaces, creative platforms, identity systems, and even private communities where authenticity matters. +ProofLens focuses on a practical problem: proving content ownership in a world filled with AI-generated material. Instead of trying to detect AI or block automation, it gives creators a way to show, “I made this, and here’s verifiable proof.” It’s small, simple, and something many applications can build on. Contact -Preferred: Discord (pa3l) - -Updates: GitHub (@pael666) +Preferred contact: Discord (pa3l). Updates will be shared through GitHub (@pael666). From f6d97488c73e7546dedeae594b41d246efdcfe4d Mon Sep 17 00:00:00 2001 From: pael666 <86571253+pael666@users.noreply.github.com> Date: Fri, 5 Dec 2025 07:55:28 +0700 Subject: [PATCH 5/8] Update pael666.md --- submissions/infrastructure/pael666.md | 32 ++++++++++++++++++--------- 1 file changed, 21 insertions(+), 11 deletions(-) diff --git a/submissions/infrastructure/pael666.md b/submissions/infrastructure/pael666.md index 6c184e0b..852301d2 100644 --- a/submissions/infrastructure/pael666.md +++ b/submissions/infrastructure/pael666.md @@ -1,10 +1,9 @@ -# vApp Submission: ProofLens - -## Verification -```yaml +vApp Submission: ProofLens +Verification github_username: "pael666" discord_id: "pa3l" timestamp: "2025-12-05" + Developer Name: Raphael Pardamean @@ -14,7 +13,7 @@ GitHub: @pael666 Discord: pa3l Experience: -I’ve been experimenting with Web3 development by building small prototypes and exploring tools related to verification, identity, and content authenticity. Lately I’ve been interested in how creators can prove authorship in a simple and privacy-friendly way, which led me to build ProofLens. +I’ve been experimenting with Web3 development by building small prototypes and exploring tools related to verification, identity, and content authenticity. Recently I’ve been interested in how creators can prove authorship in a simple and privacy-friendly way, which led me to build ProofLens. Project Name & Category @@ -25,7 +24,7 @@ Category: infrastructure Description -It’s becoming harder to know whether someone genuinely created a piece of content, especially with AI tools everywhere. ProofLens gives users a simple way to prove authorship of text or images without exposing the content itself. The app generates a local hash, then uses the Soundness Layer to create an attestation that links the user to that hash. Other apps can verify this proof independently. +It’s becoming harder to know whether someone genuinely created a piece of content, especially with AI tools everywhere. ProofLens gives users a simple way to prove authorship of text or images without exposing the content itself. The app generates a local hash, then uses the Soundness Layer to create an attestation linking the user to that hash. Other apps can verify this proof independently. SL Integration @@ -40,8 +39,8 @@ The frontend handles content upload and hashing locally. The backend receives the hash and interacts with the Soundness Layer to generate the attestation. -A verification endpoint lets other apps confirm whether a hash has a valid proof attached. -Optional storage (like WALRUS/IPFS) can be used if users want to store their content, but it isn’t required. +A verification endpoint lets other apps confirm whether a hash has a valid proof. +Optional storage (like WALRUS/IPFS) may be used if users want to store content, but it’s not required. Stack @@ -59,7 +58,7 @@ Local content hashing for privacy Authorship attestation through SL -User dashboard to view proofs +Dashboard for users to view their proofs Timeline PoC (2-4 weeks) @@ -80,8 +79,19 @@ MVP (4-8 weeks) Innovation -ProofLens focuses on a practical problem: proving content ownership in a world filled with AI-generated material. Instead of trying to detect AI or block automation, it gives creators a way to show, “I made this, and here’s verifiable proof.” It’s small, simple, and something many applications can build on. +ProofLens focuses on a practical problem: proving content ownership in a world filled with AI-generated material. Instead of detecting AI, it gives creators a simple way to say, “I made this, and here’s proof.” Because it uses the Soundness Layer, the attestation can be verified anywhere without trusting ProofLens itself. Contact -Preferred contact: Discord (pa3l). Updates will be shared through GitHub (@pael666). +Preferred contact: Discord (pa3l). +Updates will be shared via GitHub (@pael666). + +Checklist before submitting: + + All fields completed + + GitHub username matches PR author + + SL integration explained + + Timeline is realistic From 385f11a6770f87b96d26385f07777beead4e3ceb Mon Sep 17 00:00:00 2001 From: pael666 <86571253+pael666@users.noreply.github.com> Date: Fri, 5 Dec 2025 07:57:17 +0700 Subject: [PATCH 6/8] Update pael666.md --- submissions/infrastructure/pael666.md | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/submissions/infrastructure/pael666.md b/submissions/infrastructure/pael666.md index 852301d2..96ff7ba2 100644 --- a/submissions/infrastructure/pael666.md +++ b/submissions/infrastructure/pael666.md @@ -1,9 +1,11 @@ -vApp Submission: ProofLens -Verification +# vApp Submission: ProofLens +##Verification + +```yaml github_username: "pael666" discord_id: "pa3l" timestamp: "2025-12-05" - +``` Developer Name: Raphael Pardamean From 5239d65ab3a364656c724ef08ef33d13c98219a1 Mon Sep 17 00:00:00 2001 From: pael666 <86571253+pael666@users.noreply.github.com> Date: Fri, 5 Dec 2025 07:57:27 +0700 Subject: [PATCH 7/8] Update pael666.md --- submissions/infrastructure/pael666.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/submissions/infrastructure/pael666.md b/submissions/infrastructure/pael666.md index 96ff7ba2..69e81912 100644 --- a/submissions/infrastructure/pael666.md +++ b/submissions/infrastructure/pael666.md @@ -1,5 +1,5 @@ # vApp Submission: ProofLens -##Verification +## Verification ```yaml github_username: "pael666" From 4f250f23f8a3a825c064f33692e8dc608870b582 Mon Sep 17 00:00:00 2001 From: pael666 <86571253+pael666@users.noreply.github.com> Date: Fri, 5 Dec 2025 08:02:18 +0700 Subject: [PATCH 8/8] Update pael666.md --- submissions/infrastructure/pael666.md | 126 ++++++++++---------------- 1 file changed, 49 insertions(+), 77 deletions(-) diff --git a/submissions/infrastructure/pael666.md b/submissions/infrastructure/pael666.md index 69e81912..e70f89ff 100644 --- a/submissions/infrastructure/pael666.md +++ b/submissions/infrastructure/pael666.md @@ -1,99 +1,71 @@ -# vApp Submission: ProofLens -## Verification +# vApp Submission: [Your Project Name] +## Verification ```yaml github_username: "pael666" discord_id: "pa3l" timestamp: "2025-12-05" ``` -Developer - -Name: Raphael Pardamean - -GitHub: @pael666 - -Discord: pa3l - -Experience: -I’ve been experimenting with Web3 development by building small prototypes and exploring tools related to verification, identity, and content authenticity. Recently I’ve been interested in how creators can prove authorship in a simple and privacy-friendly way, which led me to build ProofLens. - -Project -Name & Category - -Project: ProofLens - -Category: infrastructure - -Description - -It’s becoming harder to know whether someone genuinely created a piece of content, especially with AI tools everywhere. ProofLens gives users a simple way to prove authorship of text or images without exposing the content itself. The app generates a local hash, then uses the Soundness Layer to create an attestation linking the user to that hash. Other apps can verify this proof independently. - -SL Integration - -ProofLens relies on the Soundness Layer to produce verifiable authorship attestations. The SL allows users to create proofs that are tamper-proof and can be validated without needing the original content. Third-party apps can check these attestations directly through SL, making the authorship claim portable and trustworthy. - -Technical -Architecture - -The flow is straightforward: - -The frontend handles content upload and hashing locally. - -The backend receives the hash and interacts with the Soundness Layer to generate the attestation. - -A verification endpoint lets other apps confirm whether a hash has a valid proof. -Optional storage (like WALRUS/IPFS) may be used if users want to store content, but it’s not required. - -Stack - -Frontend: React / Next.js - -Backend: Node.js - -Blockchain: SL - -Storage: WALRUS / IPFS (optional) - -Features - -Local content hashing for privacy - -Authorship attestation through SL - -Dashboard for users to view their proofs - -Timeline -PoC (2-4 weeks) - Basic functionality +## Developer +- **Name**: Raphael Pardamean +- **GitHub**: @pael666 +- **Discord**: pa3l +- **Experience**: I’ve been exploring Web3 development by experimenting with small prototypes, especially around verification and content authenticity. Recently I’ve been interested in how creators can prove ownership of their work without revealing the content itself, which inspired the idea for ProofLens. - SL integration +## Project - Simple UI +### Name & Category +- **Project**: ProofLens +- **Category**: infrastructure -MVP (4-8 weeks) +### Description +With AI-generated content becoming more common, it’s getting harder to tell whether someone truly created the text or images they post. ProofLens gives users a simple way to prove authorship by hashing content locally and generating an attestation through the Soundness Layer. +This lets anyone verify the claim without needing the original file. - Full features +### SL Integration +ProofLens uses the Soundness Layer to generate verifiable, tamper-proof authorship attestations. SL allows users to create proofs using only a hash, keeping the content private. Other apps can independently verify these attestations through SL, making authorship claims portable and trustworthy. - Production ready +## Technical - User testing +### Architecture +The frontend handles uploading and hashing content locally. +The backend receives the hash and communicates with the Soundness Layer to generate an attestation. +A verification endpoint allows third-party applications to confirm whether a content hash has a valid proof. +Optional decentralized storage (WALRUS/IPFS) can be used if users want to save their content publicly. -Innovation +### Stack +- **Frontend**: React / Next.js +- **Backend**: Node.js +- **Blockchain**: SL +- **Storage**: WALRUS / IPFS -ProofLens focuses on a practical problem: proving content ownership in a world filled with AI-generated material. Instead of detecting AI, it gives creators a simple way to say, “I made this, and here’s proof.” Because it uses the Soundness Layer, the attestation can be verified anywhere without trusting ProofLens itself. +### Features +1. Local content hashing +2. Authorship attestation +3. Simple dashboard for proof history -Contact +## Timeline -Preferred contact: Discord (pa3l). -Updates will be shared via GitHub (@pael666). +### PoC (2-4 weeks) +- [ ] Basic functionality +- [ ] SL integration +- [ ] Simple UI -Checklist before submitting: +### MVP (4-8 weeks) +- [ ] Full features +- [ ] Production ready +- [ ] User testing - All fields completed +## Innovation +ProofLens focuses on a straightforward but important issue: proving who created something in a world filled with AI-generated content. Instead of detecting AI, it gives creators a cryptographic way to say, “I made this,” backed by an independent attestation from the Soundness Layer. - GitHub username matches PR author +## Contact +Preferred contact: Discord (pa3l). Updates will be shared through GitHub (@pael666). - SL integration explained - Timeline is realistic +**Checklist before submitting:** +- [ ] All fields completed +- [ ] GitHub username matches PR author +- [ ] SL integration explained +- [ ] Timeline is realistic