lcp-protocol-spec
Edit LCP protocol docs under docs/protocol/ in BOLT-style (TLVs, message formats, state flow).
When & Why to Use This Skill
This Claude skill specializes in maintaining and editing the Lightning Compute Protocol (LCP) specifications with high technical rigor. It ensures all protocol documentation adheres to BOLT-style standards, focusing on TLV (Type-Length-Value) streams, message formats, and state machine flows to provide clear, parseable, and professional-grade technical specs.
Use Cases
- Defining new wire protocol messages and TLV fields using standardized BOLT-style formatting for extensibility.
- Maintaining consistency between the English protocol specification and its Japanese summary/translation.
- Updating protocol state machine descriptions and flow diagrams to reflect changes in peer-to-peer communication logic.
- Ensuring technical documentation remains synchronized with the underlying Go implementation (go-lcpd) terminology and validation rules.
- Refining protocol documentation to leverage existing Lightning Network primitives like onion messages and blinded paths for enhanced privacy.
| name | lcp-protocol-spec |
|---|---|
| description | Edit LCP protocol docs under docs/protocol/ in BOLT-style (TLVs, message formats, state flow). |
| short-description | Work on the LCP wire protocol spec |
You are editing the Lightning Compute Protocol (LCP) specification and related protocol docs.
Scope
- Primary spec:
docs/protocol/protocol.md(anddocs/protocol/protocol-ja.mdwhen applicable) - Related implementation:
go-lcpd/
Non-negotiables
- No modification to BOLTs: do not propose or require changes to upstream Lightning BOLT behavior. LCP is an application-layer protocol.
- Leverage, do not reinvent: reuse Lightning primitives for authentication, encryption, routing, and payment binding when possible.
- BOLT-quality documentation: aim for BOLT-level rigor, formatting, and readability.
- TLV streams only: define new message fields as TLVs for extensibility; avoid fixed-position fields unless the existing spec already does so.
Leveraging BOLT features
Transport
- Onion messages: for non-payment data transport, prefer onion messages over a custom TCP transport.
- Custom messages: for direct peer-to-peer communication, use high-range custom message types (>= 32768) and follow BOLT #1 parity rules.
Data structure
- Extension areas: if attaching to existing messages (
init, HTLC-related messages, etc.), use spec-defined extension TLVs.
Privacy
- Blinded paths: if the protocol carries identifiers or route information, use route blinding / blinded paths to protect endpoint privacy.
Specification strictness
Keep message and TLV definitions parseable and consistent. Use a BOLT-style definition shape like:
1. type: <TypeNumber> (`<message_name>`)
2. data:
* [`<type>`:`<field_name>`]
* [`<length>`*`<type>`:`<array_name>`]
Workflow
- Identify the exact section you are changing (message definition, TLV table, state machine, examples).
- Update the English spec first (
docs/protocol/protocol.md). If the Japanese page is meant to mirror it, updatedocs/protocol/protocol-ja.mdaccordingly (it may be a summary). - Keep terminology consistent with identifiers used in
go-lcpd/(when they exist). - If you introduce new fields:
- Define them as TLVs with explicit type numbers and clear semantics.
- Specify validation rules (required/optional, size limits, encoding, error handling).
- Add/adjust examples to match the new behavior.
Validation
- For prose/spec changes: re-read for consistency and BOLT-style formatting.
- If the change implies implementation changes, ensure
go-lcpd/is updated in the same PR and validated with:cd go-lcpd && make testcd go-lcpd && make lint