एक OpenFiat नोड चलाना

1. 01

   मशीन तैयार करें

   एक अद्यतन Debian या Ubuntu सर्वर, एक फ़ायरवॉल और एक सटीक घड़ी। घड़ी जितनी लगती है उससे अधिक मायने रखती है: रिकॉर्ड टाइमस्टैम्प और समय-सीमा वहन करते हैं, और एक विचलित घड़ी एक नोड को वैध डेटा अस्वीकार करने पर मजबूर करती है।

   shellकॉपी करें

   # Debian 12 / Ubuntu 24.04, as root
   apt update && apt install -y ca-certificates curl gnupg ufw chrony
   
   # Clock drift breaks signature and expiry checks — keep NTP running.
   systemctl enable --now chrony

2. 02

   नोड स्थापित करें

   स्रोत से बनाएँ और परिणाम को systemd के तहत चलाएँ — अभी तक कोई संस्करण टैग नहीं किया गया है, इसलिए आज बाइनरी पाने का यही एकमात्र तरीका है, और इस मैनुअल का बाकी हिस्सा यही मानता है। Docker का सहारा केवल स्थानीय परीक्षण या एक डिस्पोज़ेबल क्लस्टर खड़ा करते समय लें।
3. 03

   नोड वॉलेट उत्पन्न करें

   कोई अलग «नोड पहचान» प्रारूप नहीं है — एक नोड की पहचान एक असली Solana CLI wallet.json है, वही फ़ाइल जिसे solana-keygen उत्पन्न करता है। इसका seed नोड की gossip/पीयर पहचान और Solana हस्ताक्षर कुंजी दोनों के लिए पुनः उपयोग होता है। फ़ाइल सुरक्षित रखें — यदि आप इसे खो देते हैं, तो नोड एक अजनबी के रूप में फिर जुड़ता है और शून्य से प्रतिष्ठा बनाना शुरू करता है।

   shellकॉपी करें

   # The node's identity IS a Solana CLI-format wallet.json — the same
   # file "solana-keygen new" produces (its own seed is reused for the
   # node's gossip/P2P keypair too, see crates/cli's load_or_generate_wallet).
   # There is no separate "node identity" format or command.
   solana-keygen new --outfile /etc/openfiat/wallet.json
   chmod 600 /etc/openfiat/wallet.json
   solana-keygen pubkey /etc/openfiat/wallet.json

4. 04

   पर्यावरण सेट करें

   openfiat-node की अपनी कोई कॉन्फ़िगरेशन फ़ाइल नहीं है — हर सेटिंग एक पर्यावरण चर है, स्टार्टअप पर एक बार पढ़ी जाती है: डेटा कहाँ रहता है, किस पते पर सुनना है, स्टार्ट पर किन पीयरों से जुड़ना है और (वैकल्पिक रूप से) कौन-सा Solana RPC एंडपॉइंट उपयोग करना है। बूटस्ट्रैप पीयर एक स्थिर multiaddr/IP होने चाहिए, कोई होस्टनाम नहीं — DNS बूटस्ट्रैप हल नहीं होता।

   shellकॉपी करें

   # There is no config file and no environment variables. Every
   # setting is a flag on the systemd unit's ExecStart below, so
   # "systemctl cat openfiat-node" shows exactly what a running node was
   # given, and "openfiat-node --help" is the whole surface.
   #
   # Try it in the foreground first — the node prints the addresses it is
   # reachable at and whether it reached Solana:
   
   openfiat-node \
     --ledger /var/lib/openfiat \
     --identity /etc/openfiat/wallet.json \
     --rpc-bind-address 0.0.0.0:7080 \
     --gossip-bind-address /ip4/0.0.0.0/udp/4001/quic-v1 \
     --entrypoint /ip4/84.32.223.111/udp/4001/quic-v1/p2p/12D3KooWK9hQ7TwbfvFiaAxUbRFCkdhS7iEpAJDnewNL1anyREQ1 \
     --solana-rpc-url https://api.devnet.solana.com
   
   # Omit --solana-rpc-url to stay GossipOnly, the safe default: the node
   # still serves the marketplace, but its on-chain answers come
   # second-hand from peers. Never put a real endpoint or API key anywhere
   # version controlled — it belongs in the unit file on the server.
   #
   # Add --ipfs-api-url http://127.0.0.1:5001 to pin protocol content and
   # earn the full reward share, and --retention archival to keep the whole
   # history instead of a rolling 30 days.

5. 05

   सही पोर्ट खोलें

   पीयर नोड तक UDP से पहुँचते हैं क्योंकि QUIC मुख्य परिवहन है — यही वह पोर्ट है जिसे लोग सबसे अधिक भूलते हैं। एक TCP पोर्ट JSON-RPC, WebSocket, REST, स्वास्थ्य और मेट्रिक्स साथ में परोसता है; यदि आप सार्वजनिक रूप से क्लाइंट नहीं परोसना चाहते तो इसे निजी रखें।

   shellकॉपी करें

   ufw default deny incoming
   ufw allow 22/tcp                 # keep your own access
   ufw allow 4001/udp               # libp2p, QUIC — the port people most often forget
   ufw allow 443/tcp                # once nginx terminates TLS in front (see below)
   ufw allow 7080/tcp               # only if the node is exposed directly, without a proxy
   ufw enable && ufw status verbose

6. 06

   नेटवर्क की सेवा करें: अपने नोड को पहुँच योग्य बनाएँ

   यही वह चरण है जो एक नोड को नेटवर्क देखने वाली किसी चीज़ से नेटवर्क वहन करने वाली चीज़ में बदल देता है। सामने nginx रखें और एक प्रमाणपत्र प्राप्त करें, फिर --public-rpc-url से नोड को उसका सार्वजनिक URL बताएँ और वह स्वयं की घोषणा करता है ताकि वॉलेट, एक्सप्लोरर और स्वयं OpenFiat वेब ऐप उसका उपयोग कर सकें। क्रम मायने रखता है: पहले सादे HTTP पर nginx, फिर certbot TLS जोड़ता है — एक कॉन्फ़िगरेशन जो पहले से किसी प्रमाणपत्र का नाम लेती है, वह शुरू नहीं हो सकती, इसलिए certbot उसे जारी कर पाने से पहले ही विफल हो जाता है जो समस्या हल कर देता। एक प्रमाणपत्र कोई वैकल्पिक सजावट नहीं है: HTTPS पर परोसा गया पेज एक सादा HTTP कनेक्शन नहीं खोल सकता, इसलिए इसके बिना एक नोड हर ब्राउज़र के लिए अदृश्य है, चाहे वह कितना भी स्वस्थ हो।

   /etc/nginx/sites-available/openfiat-nodeकॉपी करें

   # /etc/nginx/sites-available/openfiat-node
   #
   # HTTP only at this stage, with NO TLS directives. certbot --nginx works
   # by running "nginx -t" and editing this file, so a config that already
   # points at a certificate cannot load, nginx will not start, and certbot
   # fails before it can issue the certificate that would have fixed it.
   server {
       listen 80;
       listen [::]:80;
       server_name openfiat.example.com;
   
       location / {
           proxy_pass http://127.0.0.1:7080;
           proxy_http_version 1.1;
   
           # The node serves its WebSocket event stream on the same port;
           # without these the stream downgrades to a plain request and
           # subscriptions silently never deliver.
           proxy_set_header Upgrade    $http_upgrade;
           proxy_set_header Connection "upgrade";
   
           proxy_set_header Host              $host;
           proxy_set_header X-Real-IP         $remote_addr;
           proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
           proxy_set_header X-Forwarded-Proto $scheme;
   
           # Do NOT add CORS headers here — the node already sets them, and
           # two Access-Control-Allow-Origin headers on one response make
           # browsers reject it while curl sees a clean 200.
           proxy_read_timeout 300s;
       }
   }

   shellकॉपी करें

   # The A record must already resolve for the world — certbot proves
   # control of the name over port 80. Check a public resolver, not your
   # own machine, whose cache can be stale:
   dig +short @8.8.8.8 openfiat.example.com
   
   ln -s /etc/nginx/sites-available/openfiat-node /etc/nginx/sites-enabled/
   nginx -t && systemctl reload nginx
   curl -s http://openfiat.example.com/health    # ok, before any certificate
   
   apt install -y certbot python3-certbot-nginx
   certbot --nginx -d openfiat.example.com
   
   # certbot edits the server block in place: it adds listen 443 ssl, the
   # certificate paths, and a redirect from :80. The location block and its
   # proxy headers carry over. Renewal installs itself as a systemd timer.
   # Do not hand-write a 443 block afterwards — certbot manages that one.
   
   # Then tell the network this node can be reached directly:
   #   openfiat-node --public-rpc-url https://openfiat.example.com

7. 07

   इसे एक सेवा के रूप में चलाएँ

   systemd के तहत नोड किसी क्रैश या रीबूट के बाद पुनः शुरू होता है, और उसे इतना लंबा समापन अवधि मिलती है कि डेटाबेस किसी लेखन के बीच मारे जाने के बजाय साफ़-सुथरे ढंग से खाली हो जाए।

   openfiat-node.serviceकॉपी करें

   # /etc/systemd/system/openfiat-node.service
   [Unit]
   Description=OpenFiat node
   Documentation=https://docs.openfiat.network
   After=network-online.target
   Wants=network-online.target
   
   [Service]
   Type=simple
   User=openfiat
   Group=openfiat
   ExecStart=/usr/local/bin/openfiat-node \
       --ledger /var/lib/openfiat \
       --identity /etc/openfiat/wallet.json \
       --rpc-bind-address 0.0.0.0:7080 \
       --gossip-bind-address /ip4/0.0.0.0/udp/4001/quic-v1 \
       --entrypoint /ip4/84.32.223.111/udp/4001/quic-v1/p2p/12D3KooWK9hQ7TwbfvFiaAxUbRFCkdhS7iEpAJDnewNL1anyREQ1 \
       --solana-rpc-url https://api.devnet.solana.com
   WorkingDirectory=/var/lib/openfiat
   Restart=on-failure
   RestartSec=5s
   
   # openfiat-node handles SIGTERM itself (graceful shutdown) rather than
   # needing systemd to force-kill it; this gives that shutdown path a
   # reasonable window before systemd escalates to SIGKILL.
   TimeoutStopSec=30s
   
   NoNewPrivileges=true
   ProtectSystem=strict
   ProtectHome=true
   ReadWritePaths=/var/lib/openfiat
   PrivateTmp=true
   
   # AF_NETLINK is required, not optional: binding a wildcard address makes
   # libp2p enumerate this host's interfaces, and that goes over a netlink
   # socket. Without it the QUIC listener fails and the gossip actor panics
   # while the HTTP thread survives — so systemd reports the unit active
   # and the node looks healthy while serving nothing.
   RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX AF_NETLINK
   
   [Install]
   WantedBy=multi-user.target

   shellकॉपी करें

   useradd --system --create-home --home-dir /var/lib/openfiat --shell /usr/sbin/nologin openfiat
   install -m 755 openfiat-node /usr/local/bin/openfiat-node
   mkdir -p /etc/openfiat
   chown -R openfiat:openfiat /var/lib/openfiat
   
   systemctl daemon-reload
   systemctl enable --now openfiat-node
   journalctl -u openfiat-node -f

8. 08

   इसे पकड़ने दें

   पूरे इतिहास को दोहराने के बजाय, एक नया नोड बाज़ार की वर्तमान स्थिति का एक पीयर-घोषित स्नैपशॉट खोज और आयात कर सकता है (OFS-1300) — असली JSON-RPC विधियाँ, कोई अलग उपकरण नहीं: getLatestSnapshot, getCheckpointHeight। हस्ताक्षर, प्रोटोकॉल संस्करण और स्थिति रूट, सभी को भरोसा किए जाने से पहले मेल खाना चाहिए।

   shellकॉपी करें

   # Snapshot sync (OFS-1300) is real JSON-RPC, not a separate CLI —
   # a new node discovers and imports a peer-announced snapshot instead of
   # replaying all history:
   curl -s -X POST http://localhost:7080/rpc -H 'content-type: application/json' \
     -d '{"jsonrpc":"2.0","id":1,"method":"getLatestSnapshot","params":{}}'
   curl -s -X POST http://localhost:7080/rpc -H 'content-type: application/json' \
     -d '{"jsonrpc":"2.0","id":1,"method":"getCheckpointHeight","params":{}}'

9. 09

   जाँचें कि यह स्वस्थ है

   GET /health पुष्टि करता है कि प्रक्रिया चालू है; JSON-RPC से getChainStatus बताता है कि यह GossipOnly है या RpcConnected, और यदि यह नवीनतम है तो इसका वर्तमान blockhash।

   shellकॉपी करें

   # Is it up, and which mode is it in?
   curl -s http://localhost:7080/health
   # ok
   
   curl -s -X POST http://localhost:7080/rpc -H 'content-type: application/json' \
     -d '{"jsonrpc":"2.0","id":1,"method":"getChainStatus","params":{}}'
   # {"jsonrpc":"2.0","id":1,"result":{"mode":"GossipOnly","blockhash":null,"slot":null,"age_ms":null}}
   # ("RpcConnected" with a real blockhash once --solana-rpc-url is set)
   
   # The addresses your node is reachable at are in its own log — give one
   # of these to another operator as their --entrypoint:
   journalctl -u openfiat-node | grep "reachable at a new address"

10. 10

    यह पहले से ही नेटवर्क का हिस्सा है

    कोई अलग «घोषणा» चरण नहीं है — जैसे ही एक नोड के पास बूटस्ट्रैप पीयर होते हैं, वह gossip करता है और स्वतः प्रसारित होता है; कोई इसे स्वीकृत नहीं करता। स्टेक करना, सेवा रजिस्ट्री में मेटाडेटा प्रकाशित करना, विवादों में शामिल होना और शासन मत डालना — ये अलग, वॉलेट-संचालित क्रियाएँ हैं जिन्हें एक क्लाइंट चालू नोड के विरुद्ध करता है — हर एक के लिए संबंधित भागीदारी गाइड देखें।

    एक नोड सक्रिय भागीदार बनने के लिए OPEN स्टेक करता है। पर स्टेक प्रतिष्ठा नहीं खरीदता: खराब प्रदर्शन वाला संचालक अधिक स्टेक करके इसकी भरपाई नहीं कर सकता। प्रभावी प्राथमिकता प्रतिष्ठा, स्टेक और मापे गए नेटवर्क प्रदर्शन को जोड़ती है।
11. 11

    इस पर नज़र रखें

    जो संकेत वास्तव में समस्या की भविष्यवाणी करते हैं वे हैं जुड़े हुए पीयर, चेन मोड (GossipOnly बनाम RpcConnected) और blockhash की आयु। इन पर अलर्ट सेट करें और आप अपने उपयोगकर्ताओं से पहले जान लेंगे।

    prometheus.ymlकॉपी करें

    # /etc/prometheus/prometheus.yml — same port as everything else,
    # no separate metrics listener to configure on the node's own side.
    scrape_configs:
      - job_name: openfiat-node
        static_configs:
          - targets: ["127.0.0.1:7080"]

12. 12

    इसे अद्यतन रखें

    रोकें, बाइनरी बदलें, शुरू करें। नोड एक बार में एक अपडेट होते हैं, इसलिए नेटवर्क को कभी समन्वित ठहराव की ज़रूरत नहीं, और छूटी हुई gossip घटनाएँ स्टार्टअप पर दोहराई जाती हैं।

    shellकॉपी करें

    systemctl stop openfiat-node        # SIGTERM, lets RocksDB flush
    # docker: docker compose pull node && docker compose up -d node
    install -m 0755 ./openfiat-node /usr/local/bin/
    systemctl start openfiat-node
    
    # Missed gossip events replay automatically on start.
    journalctl -u openfiat-node -f

13. 13

    जो पुनः उत्पन्न नहीं हो सकता उसका बैकअप लें

    बाज़ार स्थिति हमेशा एक स्नैपशॉट से फिर समन्वयित की जा सकती है। वॉलेट पुनः उत्पन्न नहीं किया जा सकता। शेष और कस्टडी Solana पर रहते हैं, आपकी डिस्क पर नहीं।

    shellकॉपी करें

    # Back up what cannot be re-derived. Marketplace state can always be
    # re-synced from a snapshot; the wallet cannot be regenerated.
    tar czf openfiat-wallet-$(date +%F).tar.gz /etc/openfiat/wallet.json
    
    # Authoritative financial state lives on Solana, not on the node's own
    # RocksDB volume.

हर अनुरूप नोड वही API सतह उजागर करता है, इसलिए एक नोड के विरुद्ध लिखा गया इंटरफ़ेस सभी के विरुद्ध काम करता है।