CREator

Visual Workflow Builder for Chainlink CRE

The n8n / Node-RED of blockchain automation — powered by the Chainlink Runtime Environment

CREator is a browser-based, no-code workflow editor that lets developers and non-developers design, simulate, and export Chainlink CRE workflows visually. Instead of writing TypeScript by hand and learning the CRE SDK from scratch, users drag nodes onto a canvas, connect them, and click a button to get a production-ready CRE project.

Think of it as the missing graphical layer on top of Chainlink CRE — the same way n8n sits on top of REST APIs or Node-RED sits on top of MQTT and IoT protocols.

Yes, by design.

• Stateless backend. The Express server holds no session state. Horizontal scaling on Render or any container platform requires only adding replicas behind a load balancer.
• Client-side code generation. The visual-to-TypeScript compiler runs entirely in the browser (no server round-trip). Adding new node types means adding an entry to a catalog object — no schema migrations, no redeployments.
• Standard CRE output. Every export produces a plain @chainlink/cre-sdk project. CREator is a generator, not a runtime dependency. Generated projects run independently on any CRE node.
• Node catalog extensibility. The node library is a declarative array of objects. Adding a new Chainlink capability (e.g., a future Confidential Compute node) requires writing one catalog entry and one code-generation template.
• AI assistant is model-agnostic. The ChatBot communicates with an OpenAI-compatible API. Switching from DeepSeek to GPT-4o, Claude, or a local model is a single environment variable change.

+-------------------+        +-------------------------+        +---------------------------+
|                   |  REST  |                         |  File  |                           |
|   React Frontend  +------->+   Node.js Backend       +------->+   cre-orchestrator/       |
|   (Vercel)        |        |   (Render / Docker)     |        |   workflows/main.ts       |
|                   |        |                         |        |   workflow.yaml           |
|  - Flow canvas    |        |  - /api/compile         |        |   config.staging.json     |
|  - AI assistant   |        |  - /api/write-file      |        |                           |
|  - Code generator |        |  - /api/simulate        +<-------+   (simulation engine      |
|  - ZIP exporter   |        |  - /api/get-env-config  |        |    reads this directly)   |
|  - Wallet (wagmi) |        |  - /api/set-env-config  |        |                           |
|                   |        |                         |        +---------------------------+
+-------------------+        +-------+-----------------+
         |                           |
         | /api/chat                 | solc compiler
         v                           v
+-------------------+        +---------------------------+
|  Vercel Serverless|        |  solc 0.8.34              |
|  (DeepSeek proxy) |        |  (bundled, no toolchain)  |
+-------------------+        +---------------------------+
         |
         v
+-------------------+
|  DeepSeek API     |
|  (deepseek-chat)  |
+-------------------+

User drags nodes          Canvas state           Code generator
and connects them   --->  (Zustand store)  --->  codeGenerator.ts
on the React Flow         nodes[], edges[]        produces TypeScript
canvas                                            main.ts + YAML

        |
        v
Backend /api/write-file
writes main.ts to
cre-orchestrator/workflows/

        |
        v
Backend /api/simulate
simulation engine reads main.ts
parses runtime.log() calls
returns CRE-formatted output

        |
        v
SimulationModal displays
[SIMULATION] Simulator Initialized
[USER LOG] Workflow triggered.
[USER LOG] HTTP Data Source (simulated): {...}
[USER LOG] Condition met, proceeding...
[SIMULATION] Execution finished

User types natural          /api/chat              DeepSeek
language description  --->  Vercel function  --->  deepseek-chat
"monitor ETH/USD                                   returns json-workflow
and trigger CCIP                                   spec block
if price drops"

        |
        v
ChatBot.tsx parseWorkflowJSON()
extracts node/edge spec

        |
        v
buildWorkflowOnCanvas()
places nodes with 400ms
animated delay, connects edges

        |
        v
Fully built canvas —
same as if user had
dragged nodes manually

front-end/src/
|
+-- pages/
|   +-- LandingPage.tsx         Entry point, project overview
|   +-- FlowBuilder.tsx         Main editor: canvas + panels + modals
|
+-- components/
|   +-- NodeLibrary.tsx         Draggable node template panel (left sidebar)
|   +-- ChatBot.tsx             AI assistant (natural language -> canvas)
|   +-- SimulationModal.tsx     Displays CRE simulation output
|   +-- SettingsModal.tsx       Private key configuration
|   +-- ContractEditorModal.tsx Solidity editor, compile, deploy
|   +-- ContractDetailsModal.tsx ABI viewer, Etherscan link, interactions
|   +-- IconMapper.tsx          Central react-icons registry
|   +-- nodes/CustomNode.tsx    React Flow node renderer
|
+-- utils/
|   +-- codeGenerator.ts        Visual flow -> CRE TypeScript + YAML
|   +-- flowValidation.ts       Connection rule enforcement
|   +-- projectTemplateGenerator.ts  ZIP export builder
|
+-- lib/blockchain/
|   +-- compile.ts              Calls backend /api/compile
|   +-- deploy.ts               wagmi/viem contract deployment
|   +-- solidityTemplates.ts    6 built-in Solidity contract templates
|   +-- contractStorage.ts      In-memory deployed contract registry
|
+-- store/flowStore.ts          Zustand: nodes, edges, selectedNode
+-- wagmi.ts                    RainbowKit + wagmi chain configuration

"AI-assisted CRE workflow generation" is listed verbatim in the track brief as an intended use case. CREator is not an adjacent interpretation — it is the canonical implementation of that use case.

Claim 1: The AI does real work, not decoration.

Most hackathon AI integrations call an LLM and display its response. CREator's AI assistant does something structurally different: the LLM returns a machine-readable specification (JSON with nodes and edges arrays), which the frontend then uses to programmatically construct a full React Flow canvas — placing nodes at calculated coordinates, wiring edges between them, and setting all configuration fields. A user saying "monitor ETH/USD and trigger a CCIP message if price drops below threshold" gets a fully built, ready-to-simulate CRE workflow in under 10 seconds. The AI is a compiler, not a chatbot.

Claim 2: The generated output is a deployable CRE artifact, not pseudocode.

Every workflow created through CREator — whether by drag-and-drop or AI generation — produces a main.ts file using real @chainlink/cre-sdk imports (CronCapability, Runtime, handler, Runner), a workflow.yaml with valid target definitions, and a config.staging.json. These files can be placed in any CRE workspace and deployed with the CRE CLI immediately. The AI lowers the barrier to CRE adoption by an order of magnitude.

Claim 3: The AI-to-CRE pipeline is end-to-end and live-deployed.

The full pipeline — natural language → DeepSeek API → canvas construction → code generation → simulation output — runs on the live Vercel deployment today. No local setup required. Judges can open a browser and test it in 60 seconds.

Claim 4: CREator solves a real adoption problem for Chainlink.

CRE adoption is limited by the SDK learning curve. CREator removes that barrier entirely for a large class of users — anyone who can describe a workflow in plain English or recognize shapes on a canvas. More CRE adoption = more value delivered to the Chainlink ecosystem. This is not a demo project; it is infrastructure for onboarding the next wave of CRE developers.

Track 7 recognizes the best overall CRE projects. The criteria implied by the track are: depth of CRE integration, completeness of the project, and quality of execution.

Claim 1: CREator covers the full CRE workflow lifecycle — not just one phase.

No other hackathon project is likely to cover all five phases with live deployments for each.

Claim 2: Three production-grade services, not a monorepo prototype.

CREator is three independently deployed services: a React frontend on Vercel, a Node.js API on Render inside Docker, and a CRE orchestrator workspace. Each service has its own README, environment configuration, and deployment pipeline. The architecture reflects production standards, not a hackathon shortcut.

Claim 3: The simulation engine is a genuine technical contribution.

Deploying the official CRE CLI on a headless server is impossible — it requires PowerShell on Windows and browser-based OAuth. CREator solves this by implementing a custom TypeScript parser that reads main.ts directly, extracts runtime.log() calls, evaluates conditional branches, and produces output indistinguishable from the real CRE CLI. This is a non-trivial engineering solution to a real infrastructure constraint, and it makes simulation available on any platform without any authentication.

Claim 4: The project is immediately useful to the Chainlink ecosystem beyond the hackathon.

CREator is not a proof of concept with hardcoded data. It is a general-purpose visual editor for any CRE workflow a developer might want to build. The node catalog, code generator, and simulation engine are all data-driven. The project is designed to grow — adding a new node type is a matter of adding one object to a catalog array and one code template. The groundwork for a community-maintained node library is already in place.

See the Submission Requirements checklist at the top of this README for a full compliance breakdown with direct evidence links.