I'm seeking an experienced blockchain developer to build a custom indexer for BSTY (GlobalBoost) inscriptions, which are Ordinals-like NFTs and data embeddings on the BSTY blockchain (a Bitcoin fork with Taproot support). The indexer should synchronize with a BSTY node, parse transactions to track inscribed satoshis (or BSTY equivalents), handle inscription metadata (e.g., NFTs, private data), and store data in a queryable database. This will enable searching, exploring, and integrating with wallets/apps in the 2025-2026 GlobalBoost Media ecosystem (e.g., for media tipping on FSNN.net or boostR.live). Similar to Bitcoin's ord indexer or adaptations for Doginals/Litecoin Ordinals, this tool must handle chain reorgs, large datasets, and Ordinals protocol rules. Use the provided code snippet (Snippet 3) as a starting point for inscription handling. Propose your stack (e.g., Rust like ord, with PostgreSQL for DB, RPC for node comms). The MVP should include basic indexing, a simple API for queries, and optional explorer UI.Core Goal: Create a reliable, efficient indexer for BSTY inscriptions. Focus on essentials; expand to token standards (e.g., BRC-20-like) if time allows. Key Requirements: Technical Skills Needed:Expertise in Bitcoin forks (BSTY/Litecoin/Dogecoin experience a plus; research BSTY via its explorer if needed). Proficiency in Rust (preferred, as in ord) or Python/Go for indexer logic. Knowledge of Ordinals protocol: Satoshi tracking, inscription parsing (Taproot witnesses, envelopes), reorg handling. Database skills: PostgreSQL or similar for storing inscription data, balances, histories. Blockchain node integration: RPC with BSTY Core (similar to Bitcoin Core). Security: Efficient data processing, error resilience. Optional: API development (e.g., REST/GraphQL), basic frontend (e.g., for a block explorer). Functional Requirements: Sync with BSTY mainnet/testnet node to index from genesis or a specified height. Parse transactions for inscriptions (e.g., detect envelopes like in Snippet 3). Track satoshi paths, inscription ownership, metadata (e.g., JSON for NFTs). Handle reorgs: Rollback invalid blocks efficiently. Query API: Endpoints for searching inscriptions by ID, address, content type. Edge Cases: Large inscriptions, chain forks, high throughput. Exclusions: Skip advanced features like full token minting UI unless proposed as add-ons. Non-Functional Requirements: Performance: Handle full chain sync in reasonable time; optimize for large data. Scalability: Design for growing inscription volume. Platform: Run on Linux/server; Dockerize for easy deployment. Docs: Code comments, setup guide, API specs. Testing: Unit tests for parsing, integration with testnet. Scope and Deliverables: Phase 1: Setup BSTY node integration, basic inscription parsing/indexing prototype (using Snippet 3). Phase 2: Full syncing, reorg handling, database storage, simple API. Phase 3: Testing, optimizations, optional explorer/demo. Deliverables: Source code (private Git repo, e.g., in Rust). Deployment scripts (Docker Compose). Documentation: Installation, config, API usage. Test reports and demo (e.g., indexing sample inscriptions). Budget and TimeLine: Budget: $1,500 (based on experience; bid with breakdowns). Timeline: 4–6 weeks (focused MVP). Payment: 30% upfront, 40% after Phase 2, 30% on delivery via escrow. Additional Notes: Proposal: Share experience (e.g., Bitcoin/Ordinals projects, GitHub links), proposed stack, timeline/cost, BSTY questions. Preference: Individuals with indexer/portfolio in crypto. I'll provide testnet access, API details. Keywords: "Blockchain Indexer", "Ordinals Developer", "Rust Blockchain", "Bitcoin Fork". Provided Code Snippet (Starting Point): Create Ordinals-Like Inscriptions for NFTs on BSTY Using Taproot (Private Data Embedding) Why: Embeds data privately for immutable, hidden NFTs or messages. How: Encode and inscribe in Taproot witness. python import requests import json # Hack: Inscribe data on BSTY (simplified Ordinals-like) def inscribe_bsty_nft(inscription_data, priv_key_hex): # Build raw tx with Taproot witness (placeholder; use full lib like bitcoinlib for prod) envelope = b'\x63\x3f' + inscription_data.encode() # OP_IF OP_PUSH "ord" ... raw_tx = "01000000...witness with envelope..." # Dummy raw tx hex # Sign (simplified) # ... (use ecdsa for Schnorr sign) # Broadcast url = "https://bstyexplorer.globalboost.info/api/tx/send" payload = {"rawtx": raw_tx} response = requests.post(url, json=payload) return response.json().get('txid') if response.status_code == 200 else None txid = inscribe_bsty_nft("{\"p\":\"bsty-nft\",\"op\":\"mint\",\"name\":\"VetBadge\"}", "your_priv_hex") print(f"Inscribed NFT txid: {txid}")