Filecoin DX and Secure Request/Response Primitives for py-libp2p

# Open Grant Proposal: Filecoin Developer Tooling and Secure Communication Primitives for py-libp2p

**Project Name:** Filecoin Developer Tooling and Secure Communication Primitives for py-libp2p

**Proposal Category:** Developer and data tooling

**Individual or Entity Name:** Gautam Manchandani (Individual)

**Proposer:** GautamBytes

**Project Repo(s)**
- https://github.com/libp2p/py-libp2p

**(Optional) Filecoin ecosystem affiliations:** (Optional) Filecoin ecosystem affiliations: I am an active contributor to `py-libp2p` through the Protocol Labs/libp2p ecosystem, and the proposed work targets upstream contributions to that codebase. This application is submitted by Gautam Manchandani as an individual, not on behalf of Protocol Labs, libp2p, Filecoin Foundation, or any affiliated organization.

**Do you agree to open source all work you do on behalf of this RFP under the MIT/Apache-2 dual-license?:** Yes

# Project Summary

Filecoin teams need a lower-friction Python path for diagnostics, secure protocol development, control-plane workflows, and experimentation on top of libp2p. Today, many common networking tasks are still too easy to implement incorrectly: request/response flows require manual handling of stream lifecycle, timeouts, buffering, flushing, payload bounds, and error paths. That makes protocol development slower, harder to audit, and more likely to produce brittle or insecure application code.

This project will build a Filecoin-focused developer tooling layer in `py-libp2p` that makes these workflows safer and easier. The goal is to deliver secure request/response primitives with sane defaults, Filecoin-aligned DX helpers and runtime utilities, agentic/control-plane examples, and stronger documentation and tests around reliability and resource handling. Rather than funding generic libp2p maintenance in isolation, this proposal targets concrete developer pain points that affect Filecoin-facing tooling, experimentation, and application development in Python.

The proposal is also designed to turn early validated directions into a coherent production-oriented package. There is already upstream groundwork in adjacent areas, but the grant would fund the next step: consolidating that momentum into reliable, documented, Filecoin-relevant tooling that can actually be adopted by ecosystem developers.

## Impact

A recurring problem for Filecoin-related development is that networking surfaces remain too low-level for many application builders. Writing “send this message to peer X and safely wait for a response” still involves too much manual logic and too many footguns. That affects not only developer velocity but also correctness and security. In practice, different teams end up reinventing partial solutions with inconsistent limits, inconsistent close/reset behavior, and inconsistent protection against malformed input or hanging streams.

Getting this right would have a meaningful impact for the Filecoin ecosystem. A safe, reusable Python request/response layer and Filecoin-aligned developer tooling would reduce repeated low-level work across teams, improve the safety of new protocols and tools, and make Python more practical for diagnostics, testnet work, control-plane applications, and research workflows. It would also lower the entry barrier for new contributors who want to build Filecoin-relevant software but are blocked by networking complexity.

If this work is not done, Filecoin-facing Python tooling will remain more fragmented, less reliable, and harder to build on. Success looks like developers spending less time reimplementing stream safety, less time debugging protocol boilerplate, and more time building useful Filecoin-facing functionality. It also looks like stronger examples, more reusable abstractions, and a clearer developer path from prototype to production-quality tooling.

## Outcomes

If funded, this project will deliver the following outcomes:

### 1. Secure request/response primitives for Filecoin-facing protocol development

This work will add a safer request/response abstraction to `py-libp2p` so developers do not need to manually wire raw stream handling for common RPC-style workflows.

Expected functionality:
- one-shot request/response over fresh streams
- default timeouts and bounded payload sizes
- explicit handling of close/reset behavior
- pluggable encoding/decoding support
- safer defaults around malformed payloads and error handling

### 2. Filecoin-focused DX toolkit inside `py-libp2p`

This work will provide a developer-experience layer for Filecoin-related Python workflows.

Expected functionality:
- Filecoin-aligned protocol/topic/bootstrap constants
- runtime/bootstrap helpers
- reusable pubsub presets where appropriate
- small CLI tools for diagnostics and example flows
- architecture docs that clarify boundaries and intended usage

### 3. Agentic and control-plane examples

This work will provide high-quality examples showing how to model Filecoin-style control-plane interactions on top of libp2p.

Expected functionality:
- capability discovery flows
- structured request/response task submission
- partial-success and failure semantics
- simulated delegated auth semantics
- explicit local-only examples that are safe to run and easy to study

### 4. Reliability and security hardening around the new surfaces

This work will improve trustworthiness and production-readiness.

Expected functionality:
- targeted review of request/response and resource-handling paths
- fixes for issues surfaced during implementation and validation
- stronger integration tests and failure-case coverage
- clear developer guidance for safe usage patterns

### Success Metrics

Success will be measured by:
- upstreamed code merged into `py-libp2p`
- passing CI, lint, typecheck, and docs for the delivered work
- at least 3 high-quality developer-facing examples or runnable tools
- at least 4 substantial docs/tutorial artifacts
- strong automated test coverage for the new abstractions and examples
- direct validation from `py-libp2p` / Filecoin-adjacent contributors reviewing or using the work

## Current Status

The project is not starting from zero. There is already upstream momentum in three adjacent directions:
- Filecoin-aligned developer experience exploration in `py-libp2p`
- secure request/response abstraction work
- agentic request/response example work

That existing progress is important because it reduces execution risk and helps identify what should be productionized next. The grant would fund the next phase: consolidating and extending these directions into a coherent Filecoin-focused developer tooling package with stronger reliability, documentation, and adoption readiness.

## Data Onboarding

Not applicable. This proposal focuses on developer tooling, secure communication primitives, examples, and protocol ergonomics rather than onboarding data to the Filecoin network.

## Adoption, Reach, and Growth Strategies

The target audience is Filecoin ecosystem developers, py-libp2p contributors, researchers, and Python developers building tooling, diagnostics, or protocol-layer applications related to Filecoin. This is a focused technical audience, but a leveraged one: improving tooling for this group makes downstream software easier to build, safer to maintain, and faster to iterate on.

Initial adoption will come through upstream usage and review in `py-libp2p`, as well as developers already trying to build Filecoin-relevant Python tooling. The first 10 users will likely come from contributors and adjacent teams who immediately need safer request/response and better examples. The first 100 users would come from strong docs, runnable examples, clearer packaging, and community visibility around the project as a practical Python path for Filecoin-facing experimentation and development.

Growth will be driven by usefulness rather than marketing. The project will prioritize high-signal examples, strong tests, and concrete developer pain points. That makes it easier for builders to adopt the tooling because they can see the intended patterns, trust the defaults, and start from working examples instead of from protocol boilerplate.

## Development Roadmap

### Milestone 1: Secure request/response foundation

Start Date: May 15, 2026
End Date: June 30, 2026
People: 3
- Gautam Manchandani: implementation lead, upstream coordination, tests, docs
- Luca Pisani: code contributions, PR support, code review
- Paul Robinson: productionization support, technical review

Funding Required: $12,000

Deliverables:
- secure one-shot request/response abstraction in `py-libp2p`
- default timeouts, payload limits, and error-handling behavior
- encoder/decoder support
- integration tests for host-to-host communication
- initial usage documentation

Expected result after completion:
Developers can implement RPC-style communication in Python without manually handling raw stream lifecycle details in unsafe or inconsistent ways.

### Milestone 2: Filecoin DX toolkit and runtime helpers

Start Date: July 1, 2026
End Date: August 15, 2026
People: 3
- Gautam Manchandani: implementation lead, CLI/docs ownership
- Luca Pisani: code contributions, review, PR support
- Paul Robinson: production-readiness review and usability feedback

Funding Required: $13,000

Deliverables:
- Filecoin-aligned protocol/topic/bootstrap constants
- helper functions for runtime/bootstrap flows
- CLI tools for diagnostics and example use cases
- architecture-positioning docs and usage guidance

Expected result after completion:
Python builders have a clearer and more reusable toolkit for Filecoin-relevant networking and diagnostics work instead of scattered ad hoc helpers.

### Milestone 3: Agentic and control-plane examples

Start Date: August 16, 2026
End Date: September 30, 2026
People: 3
- Gautam Manchandani: example design, implementation, tests, docs
- Luca Pisani: code contributions, PRs, code review
- Paul Robinson: productionization and review support

Funding Required: $12,500

Deliverables:
- Filecoin-aligned agentic/control-plane example flows
- capability discovery and structured task submission examples
- partial-success and delegated-auth simulation behavior
- runnable entrypoints and focused docs

Expected result after completion:
Developers can study and reuse higher-level Filecoin-style protocol patterns rather than only low-level networking examples.

### Milestone 4: Reliability hardening, polish, and adoption readiness

Start Date: October 1, 2026
End Date: November 15, 2026
People: 3
- Gautam Manchandani: audit-driven fixes, final docs, release packaging
- Luca Pisani: implementation support, PRs, code review
- Paul Robinson: production-readiness, stabilization, technical review

Funding Required: $12,500

Deliverables:
- targeted hardening of request/response and related surfaces
- fixes for issues found during implementation and validation
- stronger failure-case and integration coverage
- final docs/tutorial polish
- adoption-oriented technical write-up

Expected result after completion:
The delivered tooling is not just merged upstream, but stable, documented, and easier for Filecoin ecosystem developers to trust and build on.

## Total Budget Requested

## Maintenance and Upgrade Plans

The project will be maintained upstream-first inside `py-libp2p`, which is important for long-term sustainability. This means the work will live where contributors already review, test, and evolve the code rather than being stranded in a disconnected side repository. The plan after the grant period is to continue maintaining the delivered modules and examples, respond to upstream feedback, fix follow-up bugs, and keep examples and docs aligned with the main codebase.

Longer term, this project is intended to establish a stronger Python foundation for Filecoin-facing tooling. If the initial grant work succeeds, the same foundation can support deeper improvements in reliability, safer protocol development, better control-plane tooling, and eventually richer Filecoin-facing Python applications. The maintenance goal is not just to preserve the work, but to keep improving it as real users adopt it.

# Team

## Team Members

- Gautam Manchandani - Project lead, primary implementer, upstream coordination, tests, docs, examples, and delivery owner
- Luca Pisani - Core collaborator focused on productionization; will also submit PRs and participate in code reviews
- Paul Robinson - Core collaborator supporting production-readiness, review, and helping take the project toward production-quality outcomes

## Mentors and Advisers

- Manusheel Gupta
- Johanna Moran

## Team Member LinkedIn Profiles

- Gautam Manchandani: https://www.linkedin.com/in/gautam-manchandani/
- Luca Pisani:
https://www.linkedin.com/in/luca-pisani-bb84b6b9/
- Paul Robinson: https://www.linkedin.com/in/pacrob/

## Team Website

- https://libp2p.io/

## Relevant Experience

This team is well positioned to execute the project because it combines upstream implementation momentum with production-oriented support. Gautam Manchandani has already been contributing directly to `py-libp2p` in areas adjacent to this proposal, which lowers execution risk and gives the project a concrete technical starting point. That prior work is useful here not as the end goal, but as proof that the proposed roadmap is grounded in real ecosystem needs and can be shipped upstream.

Luca Pisani and Paul Robinson strengthen the execution model by helping move the work from strong upstream development into more production-oriented outcomes. Luca will directly contribute code, submit PRs, and participate in code reviews. Paul will support review quality, usability, and production-readiness. Manusheel Gupta and Johanna Moran will support the project as mentors and advisers to help keep the work aligned with real ecosystem needs and the broader Filecoin/libp2p direction.

Together, the team combines implementation capacity, upstream familiarity, productionization support, and ecosystem-informed guidance. That makes it more likely that the funded work will result in durable tooling, not just isolated code contributions.

## Team code repositories

- Gautam Manchandani: https://github.com/GautamBytes
- Luca Pisani: https://github.com/acul71
- Paul Robinson: https://github.com/pacrob
- Primary project repo: https://github.com/libp2p/py-libp2p

# Additional Information

How did you learn about the Open Grants Program?
- Through the Protocol Labs / Filecoin ecosystem and direct discussion of Filecoin developer needs

Best email address for discussing the grant agreement and general next steps:
- manchandanigautam@gmail.com

Additional context:
- This proposal is intentionally framed around Filecoin developer needs, not generic libp2p maintenance in isolation.
- The work is designed to be upstream-first and open source.
- The project already has a validated technical direction, but the grant would fund the production-oriented roadmap needed to make that direction more useful to the Filecoin ecosystem.

Related upstream `py-libp2p` work already underway:
- Filecoin DX toolkit, examples, and architecture/docs: https://github.com/libp2p/py-libp2p/pull/1260
- secure request/response helper: https://github.com/libp2p/py-libp2p/pull/1286
- agentic request/response example: https://github.com/libp2p/py-libp2p/pull/1295