my-project-public

repository

loading code, commits, and activity

repositories

loading repo index

#1	# Blockchain Prompt Templates
#2
#3	Production-ready prompt templates for common blockchain development patterns. Copy-paste and customize for your project.
#4
#5	---
#6
#7	## Template: Token Sniper / Trading Bot
#8
#9	```
#10	I want a production Solana token sniper that:
#11	- Monitors [Raydium/Pump.fun/Moonshot] for new pools via websocket
#12	- Evaluates tokens against [criteria: liquidity, holder distribution, etc.]
#13	- Executes buys within [X]ms of detection using Jito bundles
#14	- Implements [trailing stop / take profit / time-based exit] strategy
#15	- Exposes a terminal UI with real-time PnL
#16
#17	Interview me about:
#18	- My RPC setup (Helius tier, dedicated nodes?)
#19	- Risk parameters (max position size, daily loss limit)
#20	- The specific signals I want to filter on
#21	- My existing infra this needs to integrate with
#22
#23	ultrathink about:
#24	- The latency budget from detection → execution
#25	- Race conditions between the monitor and executor
#26	- State management for open positions
#27	- Failure modes when RPC lags or Jito rejects bundles
#28	- How to avoid getting rekt by rugs and honeypots
#29
#30	plan mode: on — I need to see the architecture before code.
#31
#32	Constraints:
#33	- TypeScript with strict mode
#34	- Use Helius websockets for pool detection
#35	- Jito bundle submission for execution
#36	- All secrets from environment variables
#37	- Graceful shutdown that doesn't leave orphan positions
#38	```
#39
#40	---
#41
#42	## Template: DeFi Protocol Integration
#43
#44	```
#45	I want to integrate with [Protocol] to [action: swap/stake/lend/etc.].
#46
#47	Context:
#48	- Protocol address: [address]
#49	- IDL available: [yes/no, location]
#50	- Documentation: [link if exists]
#51
#52	Interview me about:
#53	- The specific user flow I'm building
#54	- Whether I need to handle [token accounts, ATAs, wrapping SOL]
#55	- Expected transaction frequency
#56	- Error handling requirements
#57
#58	ultrathink about:
#59	- The exact instruction sequence this protocol expects
#60	- Account validation — what PDAs need derivation?
#61	- Edge cases: what if user has no ATA? What if balance insufficient?
#62	- How to simulate this transaction before sending
#63
#64	Before writing code, show me:
#65	1. The account schema for each instruction
#66	2. The instruction data layout
#67	3. Example transaction structure
#68
#69	Then implement with full error handling.
#70	```
#71
#72	---
#73
#74	## Template: Indexer / Analytics Pipeline
#75
#76	```
#77	I want to index [event type] from [program/token/protocol] and:
#78	- Store in [Postgres/SQLite/Redis]
#79	- Expose via [REST API / GraphQL / websocket]
#80	- Update in [real-time / batched]
#81
#82	Interview me about:
#83	- Historical depth needed (how far back?)
#84	- Query patterns (what questions am I answering?)
#85	- Update latency requirements
#86	- Scale expectations (events per second)
#87
#88	ultrathink about:
#89	- The gRPC vs websocket vs polling tradeoff for ingestion
#90	- Schema design for the query patterns I described
#91	- Handling chain reorgs and missed slots
#92	- Backfill strategy for historical data
#93	- Rate limit management with the RPC provider
#94
#95	plan mode: on
#96
#97	Constraints:
#98	- Use Helius webhooks or geyser if applicable
#99	- Idempotent processing (re-running is safe)
#100	- Include health checks and lag monitoring
#101	- Document the schema with example queries
#102	```
#103
#104	---
#105
#106	## Template: Anchor Program (Rust)
#107
#108	```
#109	I want an Anchor program that [functionality].
#110
#111	Interview me about:
#112	- The accounts this program will manage
#113	- Who can call which instructions (authority model)
#114	- Fee structure if any
#115	- Upgrade authority plan
#116
#117	ultrathink about:
#118	- Account sizing and rent implications
#119	- PDA derivation strategy (seeds, bump handling)
#120	- Access control vulnerabilities
#121	- Integer overflow/underflow risks
#122	- Reentrancy potential
#123	- What happens if accounts are passed in wrong order
#124
#125	plan mode: on — show me:
#126	1. Account struct definitions
#127	2. Instruction signatures
#128	3. Error enum
#129	4. Events emitted
#130	5. Key security invariants
#131
#132	Constraints:
#133	- Anchor 0.29+ patterns
#134	- All math uses checked operations or safe-math
#135	- Events for every state change
#136	- Comprehensive error types (no generic errors)
#137	- Include test scaffolding in TypeScript
#138	```
#139
#140	---
#141
#142	## Template: Multi-Agent Trading System
#143
#144	```
#145	I want a multi-agent system where:
#146	- Agent A monitors [data source] for signals
#147	- Agent B evaluates signals against [strategy]
#148	- Agent C executes approved trades via [execution venue]
#149	- Agent D manages risk and position limits
#150	- All agents coordinate via [message bus / shared state]
#151
#152	Interview me about:
#153	- The specific signal sources and their data format
#154	- Strategy parameters (what makes a "good" signal?)
#155	- Execution requirements (speed, MEV protection)
#156	- Risk limits (position size, correlation, drawdown)
#157	- How I want to monitor and intervene
#158
#159	ultrathink about:
#160	- Agent coordination — avoiding race conditions and conflicts
#161	- State consistency across agents
#162	- Failure isolation — one agent crashing shouldn't kill the system
#163	- Human override mechanisms
#164	- Backtest vs live mode switching
#165
#166	plan mode: on
#167
#168	Show me the message schemas, state machine for each agent,
#169	and the coordination protocol before writing implementation.
#170	```
#171
#172	---
#173
#174	## Template: One-Shot Production Prompt
#175
#176	The universal template that combines all patterns:
#177
#178	```
#179	Context: Solana mainnet-beta production environment.
#180	Stack: TypeScript, Helius RPC + websockets, Birdeye data, Jito execution.
#181
#182	I want [detailed goal with success metrics].
#183
#184	Before writing code, interview me about requirements, constraints,
#185	existing infrastructure, and edge cases. Ask 3-5 questions at a time.
#186
#187	After the interview:
#188	1. Reflect requirements back for confirmation
#189	2. ultrathink about:
#190	- Transaction structure and instruction ordering
#191	- Account validation and PDA derivation
#192	- MEV exposure and protection strategy
#193	- Failure modes and retry logic
#194	- State race conditions
#195	3. Present plan (accounts, instructions, error taxonomy, tests)
#196	4. Wait for my approval
#197
#198	Constraints:
#199	- All RPC calls through retry wrapper with backoff
#200	- All transactions simulated before sending
#201	- Dynamic priority fees via Helius
#202	- Value transactions through Jito bundles
#203	- Explicit timeout on all network operations
#204	- Graceful degradation when dependencies fail
#205	- Comprehensive error types (no generic throws)
#206	- Structured logging with correlation IDs
#207
#208	Code style:
#209	- TypeScript strict mode, no `any`
#210	- Pure functions where possible
#211	- Explicit state machines for async flows
#212	- Full files, no placeholders
#213
#214	Write production code. I'm shipping this.
#215	```
#216

z6Mkq5mY3JWtxoxUobWcfNHm7AkRubgSWEZTkBVqZXJviFZ5/my-project-public