원클릭으로 Manus에서 모든 스킬 실행

flow-ecosystem

스타5

포크1

업데이트2026년 6월 23일 18:25

Use when a developer is building, analyzing, or shipping on Flow (Cadence or Flow EVM) and needs an ecosystem tool: on-chain analytics, metrics, a query, or a dashboard (Dune); a Flow EVM RPC endpoint, node access, or reading chain state from an app (Alchemy); or swapping tokens, adding liquidity, getting a price quote, or integrating a DEX (PunchSwap / KittyPunch). Routes the builder to the right Flow ecosystem integration and supplies how to call it (MCP server, docs, or on-chain contract). Triggers on requests like "building on Flow and need a tool for X", "how do I get Flow on-chain data or a dashboard", "what should I use to query Flow", "Flow EVM RPC or node provider", "how do I swap or add liquidity on Flow", "integrate a DEX on Flow", or "is there a Flow tool for X". Not for non-Flow chains, and not for Cadence language correctness.

설치

Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.

Manus에서 실행

출처

onflow

onflow/flow-ai-tools

GitHub 저장소 열기 Creator 저장소 보기

다운로드

Manus에서 실행

Flow Ecosystem — Integration Router

This skill maps a Flow builder's need to the right ecosystem integration, then to how to call it. The integration makes its tool reachable; this skill makes Claude reach for it correctly, at the right moment. It is the knowledge layer on top of integrations' MCP servers, docs, and contracts.

Routing protocol (follow in order)

Match the need to an integration. Read references/routing-table.md, the index of need to integration. Pick the one whose "when to call" matches the builder's actual need. If two fit, prefer the closer primary use case. If genuinely ambiguous, ask one question.
Load that integration's file. Read references/ecosystem/<name>.md. It is authoritative for that integration: what it is, when to use it, how to call it (its type), use cases versus anti-uses, and verification rules. Do not act on an integration from memory; load its file.
Read the protocol for its type. references/integration-protocol.md covers how to invoke each type (mcp, docs, contract). Follow the steps for the declared type.
Verify before asserting. Before stating that an integration supports something, or giving an address or endpoint, clear it through references/verification-gate.md. Capabilities, endpoints, and addresses change. Never state them from memory; confirm against the integration file's verified: date or fetch its canonical source.
Do the task, citing which integration was used.
Verify what you produce. This skill picks and wires up integrations; it does not replace independent verification. Re-check any Cadence you produce against canonical Cadence sources, and confirm any competitor, market, or superlative claim in content built from integration data before stating it.

Integration types

Each integration exposes its capability one primary way, declared in its file:

mcp: runs an MCP server; Claude calls its tools once the user connects it. Example: Dune.
docs: reached via an API or SDK at canonical URLs; Claude fetches the docs, then writes the integration. Example: Alchemy.
contract: on-chain; Claude works against verified addresses and ABIs. Example: PunchSwap.

An integration may list a secondary type; its file names the primary one first.

Registered integrations

Authoritative index: references/routing-table.md. The entries marked [example] are built from each tool's public documentation to illustrate the three integration types; they are not consented partnerships and become full entries when the tool opts in through the intake form.

Integration	Capability	Type
Dune `[example]`	On-chain analytics, SQL queries, dashboards	`mcp`
Alchemy `[example]`	Flow EVM RPC and node access, EVM data APIs	`docs`
PunchSwap / KittyPunch `[example]`	DEX: swaps, liquidity, on-chain DeFi	`contract`

Adding a new integration

Registering an integration is a maintenance task, not a build task. The mechanics are: create the integration file from references/ecosystem/_TEMPLATE.md, add its row to references/routing-table.md, append its triggers to this file's description, then test that representative requests route to it. The intake process and onboarding steps are maintained by the Flow team and are not part of this public skill. Tools interested in joining are pointed to CONTRIBUTING.md.

References

references/routing-table.md: the need-to-integration index. Grows as integrations are added.
references/integration-protocol.md: how to invoke each type (mcp, docs, contract).
references/verification-gate.md: verify-before-claim for capabilities, endpoints, and addresses.
references/ecosystem/_TEMPLATE.md: the schema every integration file fills.
references/ecosystem/<name>.md: per-integration kits (ships with dune, alchemy, punchswap).
CONTRIBUTING.md: how a tool can join the ecosystem.

이 저장소의 다른 Skills

같은 저장소

cadence-lang

onflow/flow-ai-tools

Comprehensive guide for writing correct, secure, and idiomatic Cadence smart contract code on the Flow blockchain. Covers language fundamentals (resources, contracts, transactions, interfaces, accounts, references, imports), access control and entitlements, capabilities, pre/post conditions, security best practices, anti-patterns to avoid, and proven design patterns. TRIGGER when: writing or debugging Cadence code, asking about Cadence syntax, access(self), access(all), entitlements, resources, move operator (<-), capabilities, references, pre/post conditions, storage paths, "how do I write cadence", "cadence error", "compile error in .cdc", "what does access(self) mean", "how do resources work", "capability-based security". DO NOT TRIGGER when: building NFT/FT token contracts (use cadence-tokens), setting up flow.json or FCL (use flow-project-setup), reviewing existing code for vulnerabilities (use cadence-audit), generating new contracts from scratch (use cadence-scaffold).

2026-05-065

cadence-scaffold

onflow/flow-ai-tools

Generate production-ready Cadence smart contracts, transactions, and DeFi transactions from scratch following security-first standards. Scaffolds secure code with proper access control, entitlements, events, storage paths, and phase discipline. TRIGGER when: creating new Cadence contracts, generating transactions, scaffolding DeFi transactions, building smart contracts from scratch, "generate contract", "create transaction", "scaffold", "new contract", "new transaction", "build a contract for", "write me a contract", "help me create a", "template for", "boilerplate", "starter contract", "create an NFT contract", "generate a transfer transaction". DO NOT TRIGGER when: reviewing or auditing existing code (use cadence-audit), asking about Cadence syntax or language rules (use cadence-lang), configuring flow.json (use flow-project-setup).

2026-05-065

cadence-testing

onflow/flow-ai-tools

Guide for writing, running, and debugging unit tests for Cadence smart contracts using the built-in Cadence Testing Framework and `flow test`. Covers test file structure (_test.cdc, setup/beforeEach/tearDown), assertions and matchers, blockchain emulation (accounts, deployments, events, time manipulation), coverage reports, CI integration, and testing patterns. TRIGGER when: writing Cadence unit tests, debugging failing tests, using Test.assert / Test.expect / Test.assertEqual / Test.expectFailure, matchers (Test.equal, Test.beGreaterThan, etc.), Test.createAccount / Test.deployContract / Test.executeTransaction / Test.executeScript in tests, Test.moveTime, Test.eventsOfType in tests, Test.reset, `flow test`, `flow test --cover`, coverage reports, `_test.cdc`, "how do I test this contract", "test is flaky", "mock a capability in a test". DO NOT TRIGGER when: writing contract or transaction code itself (use cadence-lang), generating new contracts/transactions from scratch (use cadence-scaffold), auditing non-t

2026-04-235

cadence-audit

onflow/flow-ai-tools

Comprehensive audit and review skill for Cadence smart contracts on the Flow blockchain. Identifies security vulnerabilities, bugs, code quality issues, and optimization opportunities. Produces severity-rated findings (Critical/High/Medium/Low) with actionable fixes. TRIGGER when: auditing, reviewing, or improving Cadence code, checking for security issues, performing code review on .cdc files, looking for anti-patterns or vulnerabilities, optimizing smart contract code, "review cadence", "audit cadence", "check cadence security", "validate cadence contract", "review my .cdc file", "security review", "code review", "find vulnerabilities", "check this contract", "is this code secure", "audit my project". DO NOT TRIGGER when: writing new contracts from scratch (use cadence-scaffold), asking about Cadence syntax or patterns (use cadence-lang), building token contracts (use cadence-tokens).

2026-04-205

cadence-tokens

onflow/flow-ai-tools

Guide for developing NFT and Fungible Token contracts on the Flow blockchain using Cadence. Covers NonFungibleToken and FungibleToken interface conformance, MetadataViews integration for marketplace compatibility, collection patterns, minting, standard paths, event emission, and modular NFT architectures for complex traits and evolution. TRIGGER when: building NFT contracts, FT token contracts, implementing NonFungibleToken or FungibleToken interfaces, working with MetadataViews, creating collections, minting tokens, "create an NFT", "build a token contract", "mint NFT", "NFT collection", "fungible token vault", "royalties", "MetadataViews.Display", "NonFungibleToken.Collection", "token standards", "FungibleToken.Vault". DO NOT TRIGGER when: asking about general Cadence syntax or patterns (use cadence-lang), setting up flow.json or deploying (use flow-project-setup), auditing code (use cadence-audit).

2026-04-205

flow-cli

onflow/flow-ai-tools

Complete reference for the Flow CLI — the command-line tool for developing, testing, and deploying on the Flow blockchain. Covers project initialization, account management, contract deployment, transaction sending, script execution, dependency management, key generation, scheduled transactions, and emulator usage. TRIGGER when: using the Flow CLI, running flow commands, "flow accounts get", "flow accounts create", "flow init", "flow project deploy", "flow scripts execute", "flow transactions send", "flow test", "flow emulator", "flow keys generate", "flow dependencies install", "flow accounts fund", "deploy contract to testnet", "how to create a Flow account", "check account balance on Flow", "run cadence script", "send a transaction", "flow accounts add-contract", "flow accounts staking-info". DO NOT TRIGGER when: writing Cadence contract code (use cadence-lang), building React frontends (use flow-react-sdk), auditing code (use cadence-audit).

2026-04-205

name

flow-ecosystem

description

Flow Ecosystem — Integration Router

Routing protocol (follow in order)

Match the need to an integration. Read references/routing-table.md, the index of need to integration. Pick the one whose "when to call" matches the builder's actual need. If two fit, prefer the closer primary use case. If genuinely ambiguous, ask one question.
Load that integration's file. Read references/ecosystem/<name>.md. It is authoritative for that integration: what it is, when to use it, how to call it (its type), use cases versus anti-uses, and verification rules. Do not act on an integration from memory; load its file.
Read the protocol for its type. references/integration-protocol.md covers how to invoke each type (mcp, docs, contract). Follow the steps for the declared type.
Verify before asserting. Before stating that an integration supports something, or giving an address or endpoint, clear it through references/verification-gate.md. Capabilities, endpoints, and addresses change. Never state them from memory; confirm against the integration file's verified: date or fetch its canonical source.
Do the task, citing which integration was used.
Verify what you produce. This skill picks and wires up integrations; it does not replace independent verification. Re-check any Cadence you produce against canonical Cadence sources, and confirm any competitor, market, or superlative claim in content built from integration data before stating it.

Integration types

Each integration exposes its capability one primary way, declared in its file:

mcp: runs an MCP server; Claude calls its tools once the user connects it. Example: Dune.
docs: reached via an API or SDK at canonical URLs; Claude fetches the docs, then writes the integration. Example: Alchemy.
contract: on-chain; Claude works against verified addresses and ABIs. Example: PunchSwap.

An integration may list a secondary type; its file names the primary one first.

Registered integrations

Integration	Capability	Type
Dune `[example]`	On-chain analytics, SQL queries, dashboards	`mcp`
Alchemy `[example]`	Flow EVM RPC and node access, EVM data APIs	`docs`
PunchSwap / KittyPunch `[example]`	DEX: swaps, liquidity, on-chain DeFi	`contract`

Adding a new integration

References

references/routing-table.md: the need-to-integration index. Grows as integrations are added.
references/integration-protocol.md: how to invoke each type (mcp, docs, contract).
references/verification-gate.md: verify-before-claim for capabilities, endpoints, and addresses.
references/ecosystem/_TEMPLATE.md: the schema every integration file fills.
references/ecosystem/<name>.md: per-integration kits (ships with dune, alchemy, punchswap).
CONTRIBUTING.md: how a tool can join the ecosystem.