Verifiable Compute Primitives for Filecoin Data

Filecoin Open Grant Proposal

Verifiable Compute Primitives for Filecoin Data

Applicant: Ismail Abdo
Project: Compute Chain
Target: $30,000
Duration: 6 months
License: MIT OR Apache-2.0

 

1. Project Summary

Compute Chain is a working open-source prototype for verifiable distributed compute. This grant funds the development of primitives that connect Filecoin-stored data with verifiable computation pipelines, enabling independent verification that a specific computation was performed on specific Filecoin-referenced data.

2. Problem

When data is stored on Filecoin, retrieving and computing on that data typically leaves no standardized, independently verifiable record that the computation was performed correctly on the intended data. A gap exists between Filecoin's storage proofs and a general mechanism for binding computation results to Filecoin data identifiers.

3. Why Verifiable Compute

Verifiable compute produces cryptographic receipts proving that specific data produced a specific output. Key primitives include:

Content-addressed data binding: referencing data by CID
Merkle commitments: binding verified result data to a tree root
STARK commitment proofs: cryptographic receipts of data integrity
Independent verification: any party can recompute and verify

These primitives complement Filecoin's storage proofs by extending verifiability to computation on stored data.

4. Why Filecoin

Filecoin provides decentralized storage with built-in proof mechanisms. Adding verifiable compute primitives creates a more complete data lifecycle: store data on Filecoin, retrieve it by CID, compute, and produce a verifiable record that binds the computation to the original data. This aligns with Filecoin's roadmap toward programmable storage and computation.

5. Why Compute Chain

Compute Chain already has a working end-to-end prototype pipeline:

Browser workers execute real workloads
Results are independently verified
Merkle commitments bind verified data
The current STARK layer demonstrates a cryptographic commitment proof with independent verification
Execution and verification state are visible live on a WebSocket dashboard

The prototype has 279 passing tests, zero failures, and has been validated with 6 consecutive real-device jobs producing 60 recorded rewards.

GitHub: https://github.com/grgrthr/compute-chain

6. Current Technical State

The current prototype provides a working verification pipeline and public evidence for its existing capabilities.

Evidence: 279 tests (278 unit + 1 integration), 0 failures, two-device validation, demo video.

7. Existing Evidence

Repository: https://github.com/grgrthr/compute-chain
Validation report: docs/VALIDATION_EVIDENCE.md
Evidence index: docs/EVIDENCE_INDEX.md
Demo video: https://youtube.com/shorts/_CMj4qW8IQM
Build: cargo check/build/test — all pass

8. Proposed Filecoin Integration

This grant funds the creation of verifiable compute primitives that connect Filecoin data identifiers with Compute Chain's verification pipeline:

CID-aware job schema: Jobs can reference input data by Filecoin CID
Data retrieval binding: Workers fetch data from IPFS/Filecoin gateways
Compute-on-data verification: Results are verified and bound to the CID
Proof commitment: STARK proof binds CID, computation, and result
Reference implementation: Fully documented, reproducible demo

All deliverables are open-source under MIT OR Apache-2.0.

9. Technical Approach

Phase 1 — Schema & Binding: Extend job schema to accept CID references. Implement deterministic CID-to-data resolution for worker dispatch.

Phase 2 — Verification Pipeline: Integrate CID into Merkle commitment and STARK proof. Verify that retrieved data matches the referenced CID before computation. Produce proof that binds CID, input hash, output hash.

Phase 3 — Reference Implementation: Build end-to-end demo: store data on Filecoin/IPFS, submit CID as job input, worker retrieves and computes, proof verifies both data origin and computation result. Document fully.

10. Milestone 1 — CID-Aware Job Schema & Data Binding

Objective: Enable Compute Chain jobs to reference input data by Filecoin CID.

Duration: 2 months
Budget: $10,000

Outputs

CID-aware job schema specification
IPFS/Filecoin data fetching module for worker dispatch
CID verification: retrieved data must match referenced CID
Unit tests for CID resolution and data binding

Acceptance Criteria

A job can be submitted with a Filecoin CID as input reference
Worker retrieves data from an IPFS gateway
System verifies retrieved data matches the CID
Tests pass with documented coverage

11. Milestone 2 — Compute-on-Data Verification Pipeline

Objective: Integrate CID into the Merkle commitment and STARK proof pipeline.

Duration: 2 months
Budget: $12,000

Outputs

Extended Merkle commitment including CID
STARK proof binding CID + input hash + output hash
Independent quick_verify supporting CID-bound proofs
Integration tests for end-to-end CID verification

Acceptance Criteria

Proof verifiably binds computation result to Filecoin CID
Independent verification succeeds using only CID and result
Tampered CID or result causes verification failure
Tests pass with documented coverage

12. Milestone 3 — Reference Implementation & Documentation

Objective: Produce a complete, reproducible demonstration and documentation.

Duration: 2 months
Budget: $8,000

Outputs

End-to-end demo: Filecoin/IPFS → CID job → compute → verify → proof
Demo video showing complete workflow
Reproduction guide (step-by-step)
Final technical report with test evidence
API documentation for CID-aware job submission

Acceptance Criteria

Complete workflow demonstrated and recorded
Reproduction guide enables independent verification
All tests pass
Documentation published in public repository

13. Deliverables Summary

The grant will produce the following open-source deliverables:

CID-aware job schema capable of representing Filecoin CID input references.
Data retrieval and binding layer for resolving referenced data and verifying that the retrieved content matches the CID.
CID-bound verification pipeline connecting the input CID, input commitment, computation result, and proof.
Independent verification tooling for validating CID-bound computation proofs.
Automated tests covering CID resolution, data binding, proof generation, tampering detection, and end-to-end verification.
Reference implementation demonstrating the complete Filecoin/IPFS → CID job → compute → verify → proof workflow.
Reproduction guide and API documentation for developers.
Final technical report and demonstration video documenting the implementation and validation evidence.

All grant-funded deliverables will be publicly available under MIT OR Apache-2.0 licensing.

14. Timeline

 
 
 
 

The milestones are sequential: M1 establishes reliable CID input and data binding; M2 builds the verifiable computation layer on top of that binding; M3 packages the resulting system as a reproducible reference implementation.

15. Budget

 
 
 
 
 

The requested grant amount is $30,000 total. The budget is allocated directly across the three technical milestones and does not include production deployment, security auditing, performance optimization, or unrelated infrastructure work.

16. Success Criteria

The project will be considered successful when all of the following are demonstrated:

A Filecoin CID can be submitted as a job input reference.
The worker retrieves the referenced data and verifies that the retrieved content matches the CID.
The computation and its result are cryptographically bound to the referenced CID through the proposed commitment/proof pipeline.
An independent verifier can validate the resulting proof and reject tampered CID, input, or result data.
The complete workflow is demonstrated, documented, tested, and reproducible by an independent developer.

17. Risks and Mitigations

Risk 1 — Data retrieval differences across gateways

Different IPFS/Filecoin gateway configurations may expose the same content through different retrieval paths or may temporarily fail.

Mitigation: Keep the job input content-addressed by CID, verify retrieved content against the CID before computation, and document the supported retrieval path and failure behavior. The verification layer will not trust a gateway response solely because it was returned successfully.

Risk 2 — Proof/commitment design complexity

Binding the CID and the computation result into the existing Merkle/STARK pipeline may require changes to the commitment structure and verification inputs.

Mitigation: Implement the binding incrementally, with explicit input/CID commitments and tampering tests before completing the end-to-end reference implementation. Each milestone has acceptance criteria that isolate the relevant failure modes.

Risk 3 — Scope expansion during integration

Filecoin integration could expand into production networking, consensus, performance optimization, or FEVM integration, increasing complexity beyond the grant's objective.

Mitigation: Keep the grant focused on the three defined primitives: CID-aware job input, data binding, and verifiable compute. Production deployment, P2P hardening, performance optimization, security audits, and FEVM integration remain outside the funded scope.

18. Limitations

This grant does NOT fund:

Production deployment on Filecoin mainnet
Decentralized consensus or multi-node P2P
Performance benchmarks or optimization
Security audit
Integration with Filecoin smart contracts (FEVM)

These are separate future work items outside the proposed scope.

19. Open Source & Licensing

All code produced under this grant will be licensed under MIT OR Apache-2.0, matching Compute Chain's existing dual licensing. All documentation, tests, and reference materials will be publicly available in the Compute Chain repository.

20. Existing Evidence & Links

GitHub: https://github.com/grgrthr/compute-chain
Validation Evidence: docs/VALIDATION_EVIDENCE.md
Evidence Index: docs/EVIDENCE_INDEX.md
Demo Video: https://youtube.com/shorts/_CMj4qW8IQM
Tests: 279 passed, 0 failed (278 unit + 1 integration)
License: MIT OR Apache-2.0

21. Final Summary

Compute Chain is a working verifiable compute prototype. This grant funds the creation of primitives that bridge Filecoin's content-addressed storage with verifiable computation pipelines.

The result will be a documented, reproducible, open-source reference implementation enabling any developer to submit a Filecoin CID as job input, have a worker retrieve and compute on that data, and receive a STARK commitment proof that independently verifies the computation was performed on the CID-referenced data.

All deliverables will be publicly available under MIT OR Apache-2.0 licensing.

Start by reading docs/VALIDATION_EVIDENCE.md and docs/EVIDENCE_INDEX.md in the linked Compute Chain repository, then run the stated cargo check/build/test commands to understand the existing pipeline. The proposed work spans CID-aware jobs, retrieval, Merkle/STARK verification, tests, and documentation; done means the three milestones and their acceptance criteria are demonstrated and reproducible.

Written by the indexing model from the issue text.