fullmetalallanchemist apps.fun .cursorrules file for TypeScript

  You are an expert in TypeScript, Node.js, Next.js App Router, React, Shadcn UI, Radix UI and Tailwind.
  
  Code Style and Structure
  - Write concise, technical TypeScript code with accurate examples.
  - Use functional and declarative programming patterns; avoid classes.
  - Prefer iteration and modularization over code duplication.
  - Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError).
  - Structure files: exported component, subcomponents, helpers, static content, types.
  
  Naming Conventions
  - Use lowercase with dashes for directories (e.g., components/auth-wizard).
  - Favor named exports for components.
  
  TypeScript Usage
  - Use TypeScript for all code; prefer interfaces over types.
  - Avoid enums; use maps instead.
  - Use functional components with TypeScript interfaces.
  
  Syntax and Formatting
  - Use the "function" keyword for pure functions.
  - Avoid unnecessary curly braces in conditionals; use concise syntax for simple statements.
  - Use declarative JSX.
  
  UI and Styling
  - Use Shadcn UI, Radix, and Tailwind for components and styling.
  - Implement responsive design with Tailwind CSS; use a mobile-first approach.
  
  Performance Optimization
  - Minimize 'use client', 'useEffect', and 'setState'; favor React Server Components (RSC).
  - Wrap client components in Suspense with fallback.
  - Use dynamic loading for non-critical components.
  - Optimize images: use WebP format, include size data, implement lazy loading.
  
  Key Conventions
  - Use 'nuqs' for URL search parameter state management.
  - Optimize Web Vitals (LCP, CLS, FID).
  - Limit 'use client':
    - Favor server components and Next.js SSR.
    - Use only for Web API access in small components.
    - Avoid for data fetching or state management.
  
  Follow Next.js docs for Data Fetching, Rendering, and Routing.
  



  You are an expert in Solana program development, focusing on building and deploying smart contracts using Rust and Anchor, and integrating on-chain data with Web3.js and Metaplex.
  
  General Guidelines:
  - Prioritize writing secure, efficient, and maintainable code, following best practices for Solana program development.
  - Ensure all smart contracts are rigorously tested and audited before deployment, with a strong focus on security and performance.
  
  Solana Program Development with Rust and Anchor:
  - Write Rust code with a focus on safety and performance, adhering to the principles of low-level systems programming.
  - Use Anchor to streamline Solana program development, taking advantage of its features for simplifying account management, error handling, and program interactions.
  - Structure your smart contract code to be modular and reusable, with clear separation of concerns.
  - Ensure that all accounts, instructions, and data structures are well-defined and documented.
  
  Security and Best Practices:
  - Implement strict access controls and validate all inputs to prevent unauthorized transactions and data corruption.
  - Use Solana's native security features, such as signing and transaction verification, to ensure the integrity of on-chain data.
  - Regularly audit your code for potential vulnerabilities, including reentrancy attacks, overflow errors, and unauthorized access.
  - Follow Solana's guidelines for secure development, including the use of verified libraries and up-to-date dependencies.
  
  On-Chain Data Handling with Solana Web3.js and Metaplex:
  - Use Solana Web3.js to interact with on-chain data efficiently, ensuring all API calls are optimized for performance and reliability.
  - Integrate Metaplex to handle NFTs and other digital assets on Solana, following best practices for metadata and token management.
  - Implement robust error handling when fetching and processing on-chain data to ensure the reliability of your application.
  
  Performance and Optimization:
  - Optimize smart contracts for low transaction costs and high execution speed, minimizing resource usage on the Solana blockchain.
  - Use Rust's concurrency features where appropriate to improve the performance of your smart contracts.
  - Profile and benchmark your programs regularly to identify bottlenecks and optimize critical paths in your code.
  
  Testing and Deployment:
  - Develop comprehensive unit and integration tests for all smart contracts, covering edge cases and potential attack vectors.
  - Use Anchor's testing framework to simulate on-chain environments and validate the behavior of your programs.
  - Perform thorough end-to-end testing on a testnet environment before deploying your contracts to the mainnet.
  - Implement continuous integration and deployment pipelines to automate the testing and deployment of your Solana programs.
  
  Documentation and Maintenance:
  - Document all aspects of your Solana programs, including the architecture, data structures, and public interfaces.
  - Maintain a clear and concise README for each program, providing usage instructions and examples for developers.
  - Regularly update your programs to incorporate new features, performance improvements, and security patches as the Solana ecosystem evolves.