Protocol Developer Support

A developer server for a protocol: help split by layer, testnet status, SDK releases and an answer archive.

  • 7 categories
  • 25 channels
  • 10 roles
  • Medium
Download Discord JSON

Choose a server, review what will be created or reused, then confirm. Merge keeps what you have; replace rebuilds the server. Vetox takes a safety backup first either way.

No uses yetNo views yet

Server structure

Channels

START HERE

  • read-first

    Never share a private key or seed phrase. Staff will never ask.

  • general

    Everything that is not a question.

  • what-are-you-building

    Self-Roles panel and introductions.

  • announcements

    Releases, incidents, anything a builder must read.

INTEGRATION HELP

  • contracts

    On-chain code and interactions.

  • sdk-and-libraries

    Client libraries and typings.

  • rpc-and-nodes

    Endpoints, rate limits, sync.

  • indexing-and-data

    Queries, subgraphs, backfills.

  • wallets-and-signing

    Where most real integration pain is.

  • private-issue

    Security or account issues. Opens a ticket.

QUESTIONS

  • ask-a-question

    One thread per question. Tag the layer; it gets marked Answered.

  • answered-and-worth-reading

    Threads that turned into real explanations.

STATUS

  • testnet-status

    Automated.

  • mainnet-status

    Automated.

  • incidents

    What is broken and what we are doing.

RELEASES

  • sdk-releases

    Every version and what changed.

  • breaking-changes

    Notice period stated in this topic, and never shortened.

  • deprecations

    What is going away, and the migration path.

DOCS

  • docs-feedback

    What is wrong, missing or misleading.

  • docs-gaps

    What we know is undocumented. Honest beats complete-looking.

  • Office Hours
  • Debug Room

TEAM

  • triage

    What is actually happening with each report.

  • escalations

    Anything needing a core engineer.

  • vetox-logs

    Vetox Logs output.

Roles

  • Core TeamAdministrator
  • Developer RelationsAdministrator
  • ModeratorModerator
  • Community HelperModerator
  • Builder
  • Contracts
  • Frontend
  • Infrastructure
  • Muted

Overview

This is a support server for the people building on a protocol, and it is organised by where they are stuck rather than by who they are. Integration Help splits by layer: #contracts for on-chain work, #sdk-and-libraries, #rpc-and-nodes for infrastructure problems, #indexing-and-data, and #wallets-and-signing, which is where a disproportionate share of real integration pain lives. #ask-a-question is a forum, one thread per question, tagged by layer and marked Answered, so a question asked in March is the documentation for the person who hits it in September — which is the single highest-leverage thing a protocol developer server can do. #answered-and-worth-reading collects the threads that turned into real explanations. Status is read-only and fed automatically: #testnet-status, #mainnet-status and #incidents, because a developer whose transactions are failing needs to know within seconds whether it is them or the network. Releases carries #sdk-releases, #breaking-changes with a stated notice period, and #deprecations. Docs is the feedback loop most protocols lack: #docs-feedback for what is wrong or missing, and #docs-gaps where the team publishes what it knows is undocumented, which is more honest and more useful than pretending coverage is complete. A hidden team area holds triage and escalation.

When to use it

Protocol support servers turn into one channel where the same five questions are answered forever, nobody can tell whether an outage is theirs or the network's, and breaking changes arrive in a message that scrolls past. This layout splits help by layer, keeps a searchable answered-question forum that doubles as documentation, publishes network status automatically, and gives breaking changes a channel with a stated notice period.

What makes it different

  • Help is split by layer, so an RPC problem is not answered by a contracts specialist.
  • The question forum is tagged and marked Answered, which makes it de facto documentation.
  • Network status is automated, so a developer knows in seconds whether the fault is theirs.
  • A channel where the team publishes what it knows is undocumented, rather than pretending.

Recommended Vetox setup

  • Notifications

    Point Notifications at your status and release feeds so #testnet-status and #sdk-releases fill without a human relaying them.

  • Self-Roles

    Post a Self-Roles panel in #what-are-you-building so a breaking change can ping only the developers it affects.

  • Tickets

    Point Tickets at #private-issue so a developer can report a vulnerability or share keys-adjacent detail without posting it.

  • Auto-Mod

    Run Auto-Mod hard across every public channel, since developer servers are a standing target for wallet-drainer links.

Questions

Why a forum rather than a help channel?

Because a forum thread is findable and a chat message is not. A protocol answers the same integration question dozens of times, and each answer in a chat channel is written, read once and lost. A tagged thread marked Answered is searchable by the next person, can be linked from the documentation, and turns support effort into an asset rather than a treadmill.

Should the team really publish known documentation gaps?

Yes. Developers discover the gaps anyway, and they discover them at the worst possible moment, halfway through an integration. Publishing them lets someone choose a different approach before they have spent two days, and it converts the most frustrating experience in developer relations into a manageable one. It also produces a genuinely prioritised documentation backlog for free.

How much notice should a breaking change get?

Whatever you state, and then honour it. The number matters less than its being written in the channel topic and never shortened. Teams that publish a fixed window, keep a deprecation channel and give one concrete migration example find integrations survive changes; teams that announce and ship in the same week train developers to pin an old version and never upgrade.

Common mistakes

  • One help channel, where an indexing question waits behind twenty wallet questions.
  • Announcing breaking changes with no notice period, which is how integrations break silently in production.
  • Answering questions only in chat, so the same explanation is retyped every few weeks forever.

Consider instead

Do you have any doubts?

Our team is there for you

0.0k

Servers

0+

Commands

0

Users

0

Languages