10 Prompts for Blockchain and Smart Contracts: Solidity, Rust, Vyper

Generate a Solidity smart contract for an NFT collection using OpenZeppelin v5.0. Include:
- ERC-721 with ERC2981 royalties (5% default)
- Ownable for admin functions
- A mint function with a price in wei
- A maximum supply of 10,000 tokens
- Use the Checks-Effects-Interactions pattern
- Add NatSpec comments

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";

contract MyNFT is ERC721, Ownable, ERC2981 {
    uint256 public constant MAX_SUPPLY = 10000;
    uint256 public mintPrice = 0.01 ether;
    uint256 private _nextTokenId;

    constructor() ERC721("MyNFT", "MNFT") {
        _setDefaultRoyalty(msg.sender, 500); // 5%
    }

    function mint(address to) external payable {
        require(_nextTokenId < MAX_SUPPLY, "Max supply reached");
        require(msg.value >= mintPrice, "Insufficient payment");
        _safeMint(to, _nextTokenId);
        _nextTokenId++;
    }
}

Write a Solana smart contract in Rust using the Anchor framework v0.30. The program should:
- Initialize a new token mint with a specified decimal count
- Mint tokens to a user's associated token account
- Use an authority PDA to control minting
- Include unit tests using solana-program-test

use anchor_lang::prelude::*;
use anchor_spl::token::{self, Mint, Token, TokenAccount};

declare_id!("Fg6...");

#[program]
pub mod mint_token {
    use super::*;

    pub fn initialize_mint(ctx: Context<InitializeMint>, decimals: u8) -> Result<()> {
        let cpi_accounts = token::InitializeMint {
            mint: ctx.accounts.mint.to_account_info(),
            rent: ctx.accounts.rent.to_account_info(),
        };
        let cpi_program = ctx.accounts.token_program.to_account_info();
        token::initialize_mint(cpi_ctx, decimals, &ctx.accounts.authority.key(), None)?;
        Ok(())
    }
}

Analyze this Vyper smart contract for reentrancy bugs. The contract is a simple vault where users deposit and withdraw ETH. Point out any unsafe patterns, suggest fixes, and explain the CEI principle. Provide the corrected code.

Optimize this Solidity swap function for gas. It currently uses a loop to update user balances. Suggest:
- Use of unchecked blocks for overflow
- Replace storage reads with memory
- Batch operations where possible
- Use of custom errors instead of require strings
Provide the refactored code and estimate gas savings.

Write a Vyper 0.4.0 contract for an ERC-20 token that:
- Implements ERC-20 standard (balanceOf, transfer, approve)
- Includes a flashLoan function that mints and burns tokens temporarily
- Uses the Vyper built-in `raw_call` for flash loan callbacks
- Has a fee of 0.3% on flash loans

Create a Substrate pallet in Rust that:
- Locks tokens on the parachain
- Emits an event for a relayer to mint on Ethereum
- Validates Merkle proofs of Ethereum transactions
- Uses XCM (Cross-Consensus Messaging) for communication

Write a Solidity staking contract where:
- Users stake ERC-20 tokens
- Rewards are distributed based on time staked (using a rewardPerToken accumulator)
- APY decreases as total staked increases (e.g., 20% at 100k, 10% at 1M)
- Use the Synthetix staking rewards pattern for efficiency

Generate a UUPS upgradeable contract in Solidity using OpenZeppelin v5.0. Include:
- An initializable storage layout
- The `_authorizeUpgrade` function restricted to owner
- Example of adding a new state variable in v2 without storage collision

Given this Ethereum transaction hash [0xabc...], parse the trace to identify why it reverted. The contract is a Uniswap V3 pool. Explain the cause and suggest a fix. Use the Etherscan API and show the decoded revert data.

Write a Vyper governance contract where:
- Token holders can delegate votes
- Proposals require 1% of total supply to propose
- Voting lasts 7 days
- Executable calls are batched via delegatecall
- Use a timelock for execution