पढ़ने में 31 मिनट लगेंगे

अवलोकन

भविष्यवाणी बाज़ार उपयोगकर्ताओं को खेल, चुनाव परिणाम, आर्थिक संकेतक, सांस्कृतिक आयोजन आदि जैसी वास्तविक दुनिया की घटनाओं के परिणाम पर दांव लगाने की सुविधा देते हैं। दांव 'हां' या 'ना' अनुबंधों के रूप में संरचित होते हैं, जिनका भुगतान चुने गए परिणाम के घटित होने पर किया जाता है। कल्शी संयुक्त राज्य अमेरिका में CFTC द्वारा विनियमित पहला भविष्यवाणी बाज़ार एक्सचेंज है, जिसका अर्थ है कि कल्शी पर किए गए व्यापार कानूनी, एक्सचेंज-विनियमित घटना अनुबंध हैं, न कि अपतटीय या अविभाजित बाज़ार सट्टेबाजी।

कल्शी ऑफचेन पर काम करता है, लेकिन डीफ्लो के साथ इसके एकीकरण के माध्यम से, अब उन बाजारों तक सीधे पहुँचा जा सकता है। Solana आवेदन। Solana डेवलपर्स DFlow के API को अपने dApps में एकीकृत कर सकते हैं ताकि वे मूल रूप से भविष्यवाणी बाजार की कार्यक्षमता प्रदान कर सकें, जिसमें पोजीशन को वास्तविक SPL टोकन के रूप में दर्शाया जाता है जो बाकी DeFi के साथ संयोजनीय होते हैं।

डीफ्लो एक है Solana - एक नेटिव ट्रेडिंग इंफ्रास्ट्रक्चर लेयर जो विकेंद्रीकृत अनुप्रयोगों के लिए लिक्विडिटी रूटिंग, ऑर्डर निष्पादन और टोकनाइजेशन सेवाएं प्रदान करती है। DFlow का * मेटाडेटा API, Kalshi के विनियमित इवेंट अनुबंधों को जोड़ता है। Solana हां/ना स्थितियों को एसपीएल टोकन के रूप में टोकनाइज़ करके इकोसिस्टम को सक्षम बनाना, किसी भी Solana यह ऐप एक्सचेंज इंफ्रास्ट्रक्चर को शुरू से बनाए बिना ही प्रेडिक्शन मार्केट ट्रेडिंग की सुविधा प्रदान करता है। ट्रेड एपीआई तैयार ट्रेडिंग एप्लिकेशन बनाता है और उसे साइन करने के लिए तैयार करके लौटाता है। Solana परिणाम टोकन खरीदने या जीत की राशि निकालने के लिए किए जाने वाले लेनदेन।

आप क्या करेंगे

इस गाइड में, आप एक टाइपस्क्रिप्ट CLI बनाएंगे जो किसी प्रेडिक्शन मार्केट ट्रेड के पूरे लाइफसाइकिल को समझाएगा। Solana :

• DFlow का उपयोग करके लाइव इंग्लिश प्रीमियर लीग (EPL) फुटबॉल पूर्वानुमान बाजार खोजें। मेटाडेटा एपीआई
• मूल्य निर्धारण प्राप्त करें (हाँ/नहीं)
• DFlow का उपयोग करके हां या ना परिणाम वाले टोकन खरीदें व्यापार एपीआई
• वॉलेट टोकन बैलेंस को प्रेडिक्शन मार्केट से मैप करके ओपन पोजीशन को ट्रैक करें।
• बाजार बंद होने के बाद विजेता टोकन को USDC में भुनाएं

आपको क्या चाहिए होगा

• ए Quicknode Solana endpoint हस्ताक्षरित लेनदेन भेजने के लिए — शुरू करने के लिए साइन अप करें
• लेनदेन शुल्क के लिए थोड़ी मात्रा में SOL और आउटकम टोकन खरीदने के लिए USDC वाला एक वॉलेट
• Node.js 20 या उसके बाद का संस्करण
• उत्पादन के लिए एक DFlow API कुंजी

इस गाइड में निम्नलिखित पैकेज और टूल का उपयोग किया गया है:

निर्भरता	संस्करण
नोड	24.8.0
टाइपप्रति	5.7.3
टीएसएक्स	4.20.3
@ solana /किट	6.1.0

कालशी भविष्यवाणी बाजार कैसे काम करते हैं

कल्शी व्यापार योग्य अनुबंधों को चार-स्तरीय पदानुक्रम में व्यवस्थित करता है: श्रेणियाँ → श्रृंखला → घटनाएँ → बाज़ार ।

श्रेणियाँ सबसे व्यापक समूह हैं (खेल, अर्थशास्त्र, राजनीतिप्रत्येक श्रेणी में एक या एक से अधिक टैग होते हैं जो इसकी सामग्री को आगे वर्गीकृत करते हैं (फुटबॉल, बास्केटबालटैग्स की मदद से आप एपीआई में खोज करते समय किसी विशिष्ट डोमेन तक सीमित हो सकते हैं।

ए शृंखला यह एक श्रेणी के भीतर एक नामित, आवर्ती अनुबंध टेम्पलेट है। यह उन नियमों, समाधान स्रोतों और शुल्क संरचना को परिभाषित करता है जो इसके द्वारा उत्पादित प्रत्येक बाजार पर लागू होते हैं। उदाहरण के लिए, श्रृंखला KXEPLGAME इसमें पूरे सीज़न के लिए इंग्लिश प्रीमियर लीग (ईपीएल) के सभी गेम-परिणामों के बाज़ार शामिल हैं।

एक घटना किसी श्रृंखला में घटित होने वाली एक वास्तविक घटना को दर्शाती है। एक घटना उस घटना से संबंधित सभी बाइनरी बाजारों को एक साथ समूहित करती है।

ए बाज़ार यह किसी आयोजन के भीतर एक व्यक्तिगत हां/ना अनुबंध है। प्रत्येक बाजार में एक यसमिंट और नोमिंट एसपीएल टोकन का जो पदों का प्रतिनिधित्व करता है Solana बाजार का नतीजा आधिकारिक रूप से घोषित होने पर ही तय होता है। जीतने वाली टीम को प्रति अनुबंध 1.00 डॉलर का भुगतान मिलता है, जबकि हारने वाली टीम का अनुबंध बेकार हो जाता है।

डीफ्लो कलशी को कैसे जोड़ता है Solana

डीफ्लो का प्रमुख नवाचार कॉन्करेंट लिक्विडिटी प्रोग्राम (सीएलपी) है, जो एक Solana - एक नेटिव फ्रेमवर्क जो ऑफ-चेन कालशी लिक्विडिटी को ऑन-चेन लिक्विडिटी से जोड़ता है Solana उपयोगकर्ता:

1. एक व्यापारी ऑन-चेन पर व्यापार करने का इरादा व्यक्त करता है (जो लिमिट ऑर्डर के समान है)।
2. तरलता प्रदाता प्रतिस्पर्धी कीमतों पर मांग का अवलोकन करते हैं और उसे पूरा करते हैं।
3. यह प्रोटोकॉल खरीदी गई पूर्वानुमान स्थिति का प्रतिनिधित्व करने वाले एसपीएल टोकन उत्पन्न करता है।
4. जब बाजार का संतुलन स्थापित हो जाता है, तो जीतने वाले टोकन को उसी सीएलपी के माध्यम से उनके स्टेबलकॉइन भुगतान के लिए वापस भुना लिया जाता है।

क्योंकि पद वास्तविक होते हैं Solana एसपीएल टोकन कृत्रिम प्रतिनिधित्व नहीं हैं, इन्हें उधार लिया जा सकता है, उधार दिया जा सकता है, गिरवी के रूप में इस्तेमाल किया जा सकता है या डीईएक्स पर ट्रेड किया जा सकता है।

DFlow इन टोकनों के साथ काम करने के लिए दो API उपलब्ध कराता है:

एपीआई	Base यूआरएल (डेव)	उद्देश्य
मेटाडेटा एपीआई	https://dev-prediction-markets-api.dflow.net	बाज़ार खोजें, मूल्य निर्धारण प्राप्त करें, निपटान की जाँच करें
व्यापार एपीआई	https://dev-quote-api.dflow.net	परिणाम टोकन खरीदने या जीत की राशि निकालने के लिए लेनदेन करें

देव एंडपॉइंट्स

विकास के दौरान दोनों डेवलपर एंडपॉइंट खुले हैं और API कुंजी की आवश्यकता नहीं है। दर सीमाएं लागू होती हैं। उत्पादन के लिए, समर्पित API कुंजी के लिए DFlow से संपर्क करें। "Dev" अनधिकृत API एक्सेस स्तर को संदर्भित करता है, न कि Solana devnet. सभी अनुरोध निष्पादित होते हैं Solana mainnet -बीटा.

भविष्यवाणी बाज़ारों की खोज करें

ट्रेड करने से पहले, आपको उन बाजारों के लिए सीरीज़ टिकर की पहचान करनी होगी जिनमें आप ट्रेड करना चाहते हैं, फिर विशिष्ट इवेंट और परिणाम मिंट्स का पता लगाना होगा। DFlow का मेटाडेटा API, डिस्कवरी एंडपॉइंट्स के एक सेट के माध्यम से संपूर्ण Kalshi पदानुक्रम को उजागर करता है।

इस गाइड के लिए, हम इंग्लिश प्रीमियर लीग (ईपीएल) के गेम मार्केट पर काम करेंगे। खोज के यही चरण किसी भी अन्य श्रेणी - राजनीति, अर्थशास्त्र, मनोरंजन आदि - पर भी लागू होते हैं।

सही सीरीज़ को प्रोग्रामेटिकली खोजने के लिए कोड लिखने के बजाय, हम इस खोज प्रक्रिया को मैन्युअल रूप से करेंगे। इसके लिए केवल तीन API कॉल की आवश्यकता होती है, और एक बार जब आपके पास सीरीज़ का टिकर आ जाता है, तो यह पूरे सीज़न के लिए स्थिर रहता है।

चरण 1: उपलब्ध टैग प्राप्त करें

curl https://dev-prediction-markets-api.dflow.net/api/v1/tags_by_categories

अपेक्षित उत्तर (संक्षिप्तता के लिए अन्य श्रेणियां छोड़ दी गई हैं):

{
  "tagsByCategories": {
    "Climate and Weather": ["..."],
    "Companies": ["..."],
    "Crypto": ["..."],
    "Economics": ["..."],
    "Elections": null,
    "Entertainment": ["..."],
    "Financials": ["..."],
    "Mentions": ["..."],
    "Politics": ["..."],
    "Science and Technology": ["..."],
    "Social": null,
    "Sports": [
      "Soccer",
      "Basketball",
      "Baseball",
      "Football",
      "Hockey",
      "Olympics",
      "Golf",
      "Tennis",
      "Esports",
      "MMA",
      "Motorsport",
      "Rugby",
      "Cricket",
      "Lacrosse",
      "Boxing",
      "Darts",
      "Chess"
    ]
  }
}

The खेल श्रेणी में एक शामिल है फुटबॉल टैग। उन दोनों मानों को इस प्रकार पास करें वर्ग और टैग अगले चरण में।

चरण 2: सभी फुटबॉल श्रृंखलाओं की सूची बनाएं

curl "https://dev-prediction-markets-api.dflow.net/api/v1/series?category=Sports&tags=Soccer"

प्रतिक्रिया में कई श्रृंखलाएँ शामिल हैं। स्कैन करें शीर्षक जब तक आपको न मिल जाए तब तक खेत "इंग्लिश प्रीमियर लीग मैच" और इसे नोट करें लंगर:

{
  "series": [
    {...},
    {
      "ticker": "KXEPLGAME",
      "frequency": "custom",
      "title": "English Premier League Game",
      "category": "Sports",
      "tags": ["Soccer"],
      "settlementSources": [
        { "name": "ESPN", "url": "https://www.espn.com/" },
        { "name": "Fox Sports", "url": "https://www.foxsports.com/" }
      ],
      "contractUrl": "...",
      "contractTermsUrl": "...",
      "productMetadata": {},
      "feeType": "quadratic_with_maker_fees",
      "feeMultiplier": 1.0,
      "additionalProhibitions": ["..."]
    }
  ]
}

टिकर यह है KXEPLGAMEइस गाइड के लिए यही सीरीज़ इस्तेमाल करें। अन्य सीरीज़ (अन्य फ़ुटबॉल लीग) पूरी जानकारी में दिखाई देंगी।

चरण 3: सक्रिय ईपीएल इवेंट्स प्राप्त करें

सीरीज़ टिकर के साथ, यह वह एकमात्र कॉल है जो आपका ऐप रनटाइम पर अपनी सभी आवश्यक जानकारी प्राप्त करने के लिए करता है:

curl https://dev-prediction-markets-api.dflow.net/api/v1/events?seriesTickers=KXEPLGAME&status=active&withNestedMarkets=true

वांछित परिणाम प्राप्त करने के लिए हमें दो पैरामीटर पास करने होंगे:

• स्थिति = सक्रिय: यह विकल्प परिणामों को केवल उन इवेंट्स तक सीमित रखता है जिनमें वर्तमान में ट्रेडिंग चल रही है। इसके बिना, प्रतिक्रिया में निर्धारित, अंतिम रूप दिए गए और निलंबित इवेंट्स शामिल होंगे जिनमें आप खरीदारी नहीं कर सकते।
• withNestedMarkets=true: प्रत्येक इवेंट के बाज़ारों को शामिल करता है (सहित) यसमिंट, नोमिंटलाइव मूल्य निर्धारण और खाता डेटा जैसी जानकारी सीधे प्रतिक्रिया में प्राप्त होती है। एक ही कॉल में डिस्प्ले और ट्रेडिंग के लिए आवश्यक सभी जानकारी मिल जाती है, और प्रत्येक बाजार के लिए कोई अतिरिक्त अनुरोध करने की आवश्यकता नहीं होती है।

अपेक्षित प्रतिक्रिया (वास्तविक प्रतिक्रिया में सभी सक्रिय ईपीएल मैच शामिल हैं):

{
"events": [
    {...},
    {
      "ticker": "KXEPLGAME-26FEB18WOLARS",
      "seriesTicker": "KXEPLGAME",
      "title": "Wolverhampton vs Arsenal",
      "subtitle": "WOL vs ARS (Feb 18)",
      "status": "active",
      "markets": [
        {
          "ticker": "KXEPLGAME-26FEB18WOLARS-ARS",
          "eventTicker": "KXEPLGAME-26FEB18WOLARS",
          "title": "Wolverhampton vs Arsenal Winner?",
          "yesSubTitle": "Arsenal",
          "noSubTitle": "Arsenal",
          "status": "active",
          "result": "",
          "openTime": 1770382800,
          "closeTime": 1772654400,
          "yesBid": "0.7600",
          "yesAsk": "0.7700",
          "noBid": "0.2300",
          "noAsk": "0.2400",
          "accounts": {
            "CASHx9KJUStyftLFWGvEVf59SGeG9sh5FfcnZMVPCASH": {
              "marketLedger": "C5sDtQq8iAZHqMGdH382uCT2yZTDAphEhVsMnGKAWDBT",
              "yesMint": "GPGgr29ektC4ZB2TsPpbWmmNiCtNjq3vospE8cLweH5U",
              "noMint": "7fLxMYQdQRdTCVTDXzxaimt6rjXSpgogWYiBXVE78roi",
              "isInitialized": true,
              "redemptionStatus": "pending"
            },
            "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v": {
              "marketLedger": "ERm2CMDxUJduckmBkZU28SBzzGycZzcdUbiRmzqRaoA",
              "yesMint": "EahtAm7FJfTrGdEFvsQbztsadM6ohMqyPcLk1Q6YCRDx",
              "noMint": "4kXWe1ofHoihJfSzTAT7Yecm5vsEuBFEKmrtLzuASLU8",
              "isInitialized": true,
              "redemptionStatus": "pending"
            }
          }
        },
        {
          "ticker": "KXEPLGAME-26FEB18WOLARS-WOL",
          "eventTicker": "KXEPLGAME-26FEB18WOLARS",
          "title": "Wolverhampton vs Arsenal Winner?",
          "yesSubTitle": "Wolverhampton",
          "noSubTitle": "Wolverhampton",
          "status": "active",
          "result": "",
          "openTime": 1770382800,
          "closeTime": 1772654400,
          "yesBid": "0.0700",
          "yesAsk": "0.0800",
          "noBid": "0.9200",
          "noAsk": "0.9300",
          "accounts": {
            "CASHx9KJUStyftLFWGvEVf59SGeG9sh5FfcnZMVPCASH": {
              "marketLedger": "ADBWy7L2VzSAfVima4ybNqse7zDGBqac1B6fGkYSEpVc",
              "yesMint": "Hy8XLnGcyvmbxf3SBBQbkws5SDa46eF2AWhJLQXiuSci",
              "noMint": "2Tw3tAE3is7TiCqrcS7DxXJ2UAeEsq7dbMDc8Nya57eg",
              "isInitialized": true,
              "redemptionStatus": "pending"
            },
            "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v": {
              "marketLedger": "5UHoukpeVPQbmSUaAPWnkXEKZMrjSmwTqqaD8eXmvKNn",
              "yesMint": "CA7FMbzNTfeR7jkLzF113bBJupKwq98cixaQtc3b3frb",
              "noMint": "D7ibW7tu2kvzfbDS78gF5i9UZTye7pqTP63yxYd43No3",
              "isInitialized": true,
              "redemptionStatus": "pending"
            }
          }
        },
        {
          "ticker": "KXEPLGAME-26FEB18WOLARS-TIE",
          "eventTicker": "KXEPLGAME-26FEB18WOLARS",
          "title": "Wolverhampton vs Arsenal Winner?",
          "yesSubTitle": "Tie",
          "noSubTitle": "Tie",
          "status": "active",
          "result": "",
          "openTime": 1770382800,
          "closeTime": 1772654400,
          "yesBid": "0.1500",
          "yesAsk": "0.1600",
          "noBid": "0.8400",
          "noAsk": "0.8500",
          "accounts": {
            "CASHx9KJUStyftLFWGvEVf59SGeG9sh5FfcnZMVPCASH": {
              "marketLedger": "BfdCBQiiNbxxWNgs1dYpNgsfXC5SDH19RmratW2hTxPG",
              "yesMint": "6Ka59wvyvppd2v7D1LGfjKMb2LJ36KcnCpHZU2uP2EPB",
              "noMint": "48CyDoWdsEL62gD81My4wHYybrsyH8dnHRHWJcaUHvtA",
              "isInitialized": true,
              "redemptionStatus": "pending"
            },
            "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v": {
              "marketLedger": "GGViDLxL6RRQ4zTydGoiL6NnLugxyDGraydUBAQfo9iX",
              "yesMint": "4qeSi2JVCbE9VQt1uzTJTpJSKdMFRsqWuvf3UL9fGa2P",
              "noMint": "7GA2eFoEupkSqJaeKrHgS516dipVDfmQ4ZQ2BFdZpdb3",
              "isInitialized": false,
              "redemptionStatus": null
            }
          }
        }
      ]
    },
    "..."
  ],
  "cursor": null
}

प्रत्येक इवेंट में तीन बाज़ार समूह होते हैं, प्रत्येक परिणाम के लिए एक।-एआरएस, -डब्ल्यूओएल, -बाँधनाप्रत्येक बाजार में दो हैं। हिसाब किताब निपटान टकसाल द्वारा दर्ज की गई प्रविष्टियाँ: नकद नकद...नकद (फैंटम द्वारा जारी किया गया एक USD-समर्थित स्टेबलकॉइन) और USDC ईपीजेएफ...डीटी1वीद यसमिंट और नोमिंट प्रत्येक सेटलमेंट खाते के अंतर्गत दिए गए पते एसपीएल टोकन की वह संख्या है जो आपके वॉलेट में ट्रेड के बाद मौजूद रहेगी।

यह गाइड खरीद और रिडीम ऑर्डर तैयार करते समय सेटलमेंट मिंट के रूप में USDC का उपयोग करती है।

सैंपल ऐप बनाएं

अब जब आप समझ गए हैं कि कालशी बाजार कैसे संरचित होते हैं और डीफ्लो उन्हें कैसे प्रदर्शित करता है Solana अब कोड लिखने का समय आ गया है। इस सेक्शन में आप एक छोटा सा टाइपस्क्रिप्ट CLI बनाएंगे जिसमें सीरीज में सक्रिय इवेंट्स प्राप्त करने, आउटकम टोकन खरीदने, अपनी खुली पोजीशन देखने और सेटलमेंट के बाद अपनी जीत को रिडीम करने के लिए स्क्रिप्ट होंगी।

वॉलेट सेट अप करें

ट्रेडिंग से पहले केवाईसी का प्रमाण आवश्यक है

संघीय नियमों के अनुसार, कलशी के प्रेडिक्शन मार्केट में भाग लेने वाले सभी प्रतिभागियों की पहचान सत्यापित होनी अनिवार्य है। DFlow के माध्यम से प्रेडिक्शन मार्केट में ट्रेडिंग के लिए उपयोग किए जाने वाले किसी भी वॉलेट को DFlow के पहचान सत्यापन प्रदाता, Proof के साथ सत्यापित किया जाना चाहिए। बिना सत्यापित वॉलेट को आउटकम टोकन खरीदने से रोक दिया जाता है।

इस गाइड के लिए अपने मुख्य वॉलेट के बजाय एक अलग वॉलेट का उपयोग करें। आप इस वॉलेट की निजी कुंजी को एक स्थानीय फ़ाइल में निर्यात करेंगे ताकि स्क्रिप्ट लेनदेन पर हस्ताक्षर कर सकें।

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

इसके बजाय, इनमें से किसी एक विकल्प का उपयोग करें:

• एक नया ब्राउज़र प्रोफ़ाइल (क्रोम, ब्रेव, फ़ायरफ़ॉक्स) खोलें और उसमें फैंटम या बैकपैक को नए सिरे से इंस्टॉल करें। नया इंस्टॉलेशन अपना खुद का सीड फ्रेज़ जनरेट करता है, जो आपके मुख्य वॉलेट से पूरी तरह अलग होता है।
• यदि आप सामान्यतः फैंटम का उपयोग करते हैं, तो इस गाइड के लिए केवल बैकपैक ही इंस्टॉल करें। एक अलग वॉलेट एक्सटेंशन इंस्टॉल करें।

इस गाइड वॉलेट में केवल उतनी ही राशि डालें जितनी आप परीक्षण के दौरान खर्च करने के लिए तैयार हैं:

• लेनदेन शुल्क को कवर करने के लिए लगभग 0.01 SOL।
• आउटकम टोकन खरीदने के लिए थोड़ी मात्रा में USDC।

आवश्यक वास्तविक धनराशि

सभी लेनदेन, जिनमें "dev" (अमान्यता प्राप्त) API एंडपॉइंट्स पर किए गए लेनदेन भी शामिल हैं, Solana mainnet -beta पर वास्तविक USDC के साथ निष्पादित होते हैं। परीक्षण के दौरान एक समर्पित वॉलेट का उपयोग करें और उसमें केवल उतनी ही राशि डालें जितनी आप खर्च करने के लिए तैयार हैं।

प्रमाण सहित सत्यापित करें

खरीदारी करने से पहले, DFlow Proof का उपयोग करके अपने वॉलेट के पते की पुष्टि करें। Proof आपकी KYC सत्यापित पहचान को उस विशिष्ट वॉलेट पते से जोड़ता है। इस गाइड में दिए गए निर्देशों के अनुसार, इसी पते का उपयोग करें।

निजी कुंजी को निर्यात करें और सहेजें

एक बार सत्यापित हो जाने पर, अपने वॉलेट से निजी कुंजी को बेस58 स्ट्रिंग के रूप में निर्यात करें:

• Phantom: Settings → Security & Privacy → Export Private Key
• Solflare: वॉलेट सूची (ऊपर बाएँ) → वॉलेट के बगल में ⋮ → निजी कुंजी निर्यात करें
• बैकपैक: सेटिंग्स → आपका खाता → निजी कुंजी निर्यात करें

स्क्रिप्ट JSON बाइट ऐरे फ़ाइल से कीपेयर लोड करती है (उदाहरण के लिए [34, 189, 12, ...]), जो कि वॉलेट्स द्वारा निर्यात की जाने वाली बेस58 स्ट्रिंग से अलग फॉर्मेट है। इसे इस तरह कन्वर्ट करें:

import { getBase58Encoder } from '@solana/kit';
const privateKeyBase58 = process.argv[2];
const privateKeyBytes = getBase58Encoder().encode(privateKeyBase58);
console.log(Array.from(privateKeyBytes));

इस फ़ंक्शन को कॉल करके आप प्राइवेट की को एक ऐरे के रूप में प्राप्त कर सकते हैं:

tsx to-base58.js आपकी निजी कुंजी

अपेक्षित आउटपुट:

[12,34,...,78,90]

प्रतिस्थापित करें आपकी निजी कुंजी अपने वॉलेट से कॉपी की गई स्ट्रिंग के साथ। फ़ाइल को प्रोजेक्ट डायरेक्टरी से बाहर रखें ताकि यह गलती से कमिट न हो जाए। आउटपुट ऐरे को अपने लोकल फ़ाइल सिस्टम में सेव करें। dflow-wallet.jsonआप इस फ़ाइल का पथ इसमें जोड़ेंगे। .पर्यावरण गाइड में आगे।

प्रोजेक्ट को प्रारंभ करें

एक नई प्रोजेक्ट डायरेक्टरी बनाएं और उसे npm के साथ इनिशियलाइज़ करें:

mkdir dflow-prediction-markets && cd dflow-prediction-markets
npm init -y
mkdir src

आवश्यक शर्तें स्थापित करें:

npm install @solana/kit
npm install --save-dev typescript tsx @types/node

पर्यावरण को कॉन्फ़िगर करें

कोई भी कोड लिखने से पहले, अपने पर्यावरण चर सेट करें। एक बनाएं .पर्यावरण प्रोजेक्ट रूट में फ़ाइल:

.पर्यावरण

METADATA_API_URL=https://dev-prediction-markets-api.dflow.net
TRADE_API_URL=https://dev-quote-api.dflow.net
DFLOW_API_KEY= # required for production endpoints, leave blank for dev
QUICKNODE_RPC_URL=https://docs-demo.solana-mainnet.quiknode.pro/abcd1234
KEYPAIR_PATH=/path/to/your/wallet/dflow-wallet.json
SERIES_TICKER=KXEPLGAME
USDC_MINT=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v

चर	विवरण
METADATA_API_URL	बाजार की खोज और मूल्य निर्धारण के लिए DFlow मेटाडेटा API का आधार URL।
TRADE_API_URL	आउटकम टोकन खरीदने और भुनाने के लिए DFlow ट्रेड एपीआई का बेस यूआरएल।
डीएफलो_एपीआई_कुंजी	डेवलपर एंडपॉइंट्स के लिए इसे खाली छोड़ दें। यह आवश्यक है क्योंकि x-api-key हेडर उत्पादन में है।
QUICKNODE _RPC_URL	आपका Quicknode mainnet -बीटा endpoint इसे पाने के लिए यहां साइन अप करें ।
कुंजी जोड़ी पथ	आपके रास्ते पर Solana keypair JSON. यह वॉलेट ट्रेड पर हस्ताक्षर करता है और शुल्क के लिए SOL और आउटकम टोकन खरीदने के लिए USDC रखना आवश्यक है।
सीरीज़_टिकर	कालशी सीरीज मॉनिटर के लिए। इसे सेट करें KXEPLGAME ईपीएल गेम मार्केट के लिए।
यूएसडीसी_मिंट	यूएसडीसी मिंट का उपयोग बाजार खातों से सही मिंट पते चुनने के लिए किया जाता था।

टाइप्स फ़ाइल बनाएँ

कोई भी स्क्रिप्ट लिखने से पहले, बनाएं src/types.tsइस गाइड में दी गई प्रत्येक स्क्रिप्ट इसी फ़ाइल से आयात करती है, इसलिए एक बार प्रकारों को परिभाषित करने से कोड सुसंगत रहता है और खोज, खरीद, स्थिति और मोचन के दौरान पूरी तरह से टाइप-सुरक्षित रहता है।

src/types.ts

export interface MarketAccountInfo {
  yesMint: string;
  noMint: string;
  isInitialized?: boolean;
  redemptionStatus: string;
  scalarOutcomePercent: number | null;
}

export interface Market {
  ticker: string;
  title: string;
  yesSubTitle?: string;
  closeTime?: number | null;
  status?: string;
  result?: string | null;
  yesBid: string | null;
  yesAsk: string | null;
  noBid: string | null;
  noAsk: string | null;
  accounts: Record<string, MarketAccountInfo>;
}

export interface Event {
  ticker: string;
  title: string;
  subtitle: string | null;
  markets: Market[];
}

export interface EventsResponse {
  events: Event[];
  cursor: number | null;
}

export interface OrderResponse {
  outAmount: string;
  executionMode: 'sync' | 'async';
  transaction: string;
  lastValidBlockHeight: number;
  revertMint?: string;
}

export interface OrderStatusResponse {
  status: 'pending' | 'expired' | 'failed' | 'open' | 'pendingClose' | 'closed';
  outAmount: number;
  reverts?: { signature: string }[];
}

यूटिलिटीज़ फ़ाइल बनाएँ

कई कार्य चारों स्क्रिप्ट में समान रूप से उपयोग किए जाते हैं: वॉलेट लोड करना, अनुरोध हेडर बनाना, टाइप किए गए API कॉल करना, लेनदेन पर हस्ताक्षर करना और भेजना, ऑर्डर की स्थिति की जाँच करना और टोकन खाता डेटा को डिकोड करना। इन सभी कार्यों को एक साझा मॉड्यूल में केंद्रीकृत करने का अर्थ है कि प्रत्येक स्क्रिप्ट अपने स्वयं के तर्क पर केंद्रित रहती है।

बनाएं src/utils.ts:

src/utils.ts

import {
  createKeyPairFromBytes,
  getAddressFromPublicKey,
  getAddressDecoder,
  address,
  sendTransactionWithoutConfirmingFactory,
  assertIsTransactionWithinSizeLimit,
  getTransactionDecoder,
  signTransaction,
  getSignatureFromTransaction,
} from '@solana/kit';
import type { createSolanaRpc } from '@solana/kit';
import fs from 'fs';
import path from 'path';
import os from 'os';
import type { OrderResponse, OrderStatusResponse } from './types';

type SolanaRpc = ReturnType<typeof createSolanaRpc>;

export function getHeaders(): Record<string, string> {
  const h: Record<string, string> = { 'Content-Type': 'application/json' };
  const apiKey = process.env.DFLOW_API_KEY;
  if (apiKey) h['x-api-key'] = apiKey;
  return h;
}

export async function loadWallet() {
  const keypairPath = process.env.KEYPAIR_PATH || path.join(os.homedir(), '.config', 'solana', 'id.json');
  const secretKey = Uint8Array.from(JSON.parse(fs.readFileSync(keypairPath, 'utf-8')));
  const keyPair = await createKeyPairFromBytes(secretKey);
  const address = await getAddressFromPublicKey(keyPair.publicKey);
  return { keyPair, address };
}

export async function fetchJson<T>(url: string, options?: RequestInit): Promise<T> {
  const res = await fetch(url, { headers: getHeaders(), ...options });
  if (!res.ok) throw new Error(`API error ${res.status}: ${await res.text()}`);
  return res.json() as Promise<T>;
}

export async function signAndSend(
  order: OrderResponse,
  keyPair: Awaited<ReturnType<typeof createKeyPairFromBytes>>,
  rpc: SolanaRpc,
): Promise<string> {
  const txBytes = Buffer.from(order.transaction, 'base64');
  const transaction = getTransactionDecoder().decode(txBytes);
  const signedTx = await signTransaction([keyPair], transaction);
  const signature = getSignatureFromTransaction(signedTx);
  assertIsTransactionWithinSizeLimit(signedTx);
  const sendTx = sendTransactionWithoutConfirmingFactory({ rpc });
  await sendTx(signedTx, { commitment: 'confirmed', skipPreflight: false });
  return signature as string;
}

export async function waitForOrder(
  sig: string,
  lastValidBlockHeight: number,
  tradeApiUrl: string,
): Promise<OrderStatusResponse> {
  while (true) {
    const status = await fetchJson<OrderStatusResponse>(
      `${tradeApiUrl}/order-status?signature=${sig}&lastValidBlockHeight=${lastValidBlockHeight}`
    );
    console.log(`  Status: ${status.status}`);
    if (['closed', 'expired', 'failed'].includes(status.status)) return status;
    await new Promise((r) => setTimeout(r, 2_000)); // Wait before next poll to avoid rate-limiting
  }
}

export function parseMintAndBalance(accountData: [string, string]): { mint: string; amount: bigint } {
  const [base64Data] = accountData;
  const data = Buffer.from(base64Data, 'base64');
  const mint = getAddressDecoder().decode(data.subarray(0, 32));
  const amount = data.readBigUInt64LE(64);
  return { mint, amount };
}

// SPL Token programs
export const TOKEN_PROGRAM      = address('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
export const TOKEN_2022_PROGRAM = address('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb');

export async function getWalletTokenAccounts(rpc: SolanaRpc, walletAddress: string) {
  const [{ value: legacyAccounts }, { value: token2022Accounts }] = await Promise.all([
    rpc.getTokenAccountsByOwner(address(walletAddress), { programId: TOKEN_PROGRAM },      { encoding: 'base64' }).send(),
    rpc.getTokenAccountsByOwner(address(walletAddress), { programId: TOKEN_2022_PROGRAM }, { encoding: 'base64' }).send(),
  ]);
  return [...legacyAccounts, ...token2022Accounts];
}

ईपीएल इवेंट्स में सक्रिय रूप से भाग लें

बनाएं src/events.ts बुलाने के लिए /घटनाएँ endpoint और आगामी ईपीएल इवेंट्स और उनके यूएसडीसी यस/नो मार्केट की एक तालिका प्रिंट करें:

src/events.ts

import { fetchJson } from './utils';
import type { EventsResponse } from './types';

const METADATA_API  = process.env.METADATA_API_URL;
const SERIES_TICKER = process.env.SERIES_TICKER;
const USDC_MINT     = process.env.USDC_MINT;

// Helpers
function toUsd(price: string | null): string {
  if (!price) return '  N/A  ';
  return `$${Number(price).toFixed(2)}`;
}

function closeDate(ts: number): string {
  return new Date(ts * 1000).toLocaleString(undefined, {
    month: 'short', day: 'numeric', year: 'numeric',
    hour: '2-digit', minute: '2-digit',
  });
}

// Main
async function listEvents() {
  const url = `${METADATA_API}/api/v1/events?seriesTickers=${SERIES_TICKER}&status=active&withNestedMarkets=true`;
  const { events } = await fetchJson<EventsResponse>(url);

  if (events.length === 0) {
    console.log(`No active events found for series "${SERIES_TICKER}".`);
    return;
  }

  console.log(`\n${SERIES_TICKER} — ${events.length} active event(s)\n`);

  for (const event of events) {
    // closeTime lives on the markets, not the event itself
    const closeTime = event.markets[0]?.closeTime;

    console.log(`┌─ ${event.title}`);
    console.log(`│  Ticker:  ${event.ticker}`);
    if (event.subtitle) console.log(`│  Subtitle: ${event.subtitle}`);
    if (closeTime) console.log(`│  Closes:  ${closeDate(closeTime)}`);
    console.log('│');

    for (const market of event.markets) {
      // Prefer USDC accounts; fall back to first account available
      const acct = market.accounts[USDC_MINT] ?? Object.values(market.accounts)[0];

      console.log(`│  ▸ YES label: ${market.yesSubTitle}`);
      console.log(`│    Ticker:   ${market.ticker}`);
      console.log(`│    YES mint: ${acct?.yesMint ?? 'not initialized'}`);
      console.log(`│    NO  mint: ${acct?.noMint  ?? 'not initialized'}`);
      console.log(`│    Price (ask):  YES ${toUsd(market.yesAsk)}   NO ${toUsd(market.noAsk)}`);
      console.log('│');
    }

    console.log('└─────────────────────────────────────────────────────\n');
  }
}

listEvents().catch(console.error);

सीरीज़ के सक्रिय इवेंट्स की सूची प्राप्त करने के लिए इवेंट्स स्क्रिप्ट चलाएँ:

tsx --env-file=.env src/events.ts

अपेक्षित आउटपुट (यह केवल लौटाए गए पहले इवेंट को दर्शाता है, लेकिन वास्तविक परिणामों में सभी सक्रिय इवेंट शामिल होंगे):

KXEPLGAME — 31 active event(s)

┌─ Wolverhampton vs Arsenal
│  Ticker:  KXEPLGAME-26FEB18WOLARS
│  Subtitle: WOL vs ARS (Feb 18)
│  Closes:  Mar 4, 2026, 02:00 PM
│
│  ▸ YES label: Arsenal
│    Ticker:   KXEPLGAME-26FEB18WOLARS-ARS
│    YES mint: EahtAm7FJfTrGdEFvsQbztsadM6ohMqyPcLk1Q6YCRDx
│    NO  mint: 4kXWe1ofHoihJfSzTAT7Yecm5vsEuBFEKmrtLzuASLU8
│    Price (ask):  YES $0.78   NO $0.23
│
│  ▸ YES label: Wolverhampton
│    Ticker:   KXEPLGAME-26FEB18WOLARS-WOL
│    YES mint: CA7FMbzNTfeR7jkLzF113bBJupKwq98cixaQtc3b3frb
│    NO  mint: D7ibW7tu2kvzfbDS78gF5i9UZTye7pqTP63yxYd43No3
│    Price (ask):  YES $0.08   NO $0.93
│
│  ▸ YES label: Tie
│    Ticker:   KXEPLGAME-26FEB18WOLARS-TIE
│    YES mint: 4qeSi2JVCbE9VQt1uzTJTpJSKdMFRsqWuvf3UL9fGa2P
│    NO  mint: 7GA2eFoEupkSqJaeKrHgS516dipVDfmQ4ZQ2BFdZpdb3
│    Price (ask):  YES $0.17   NO $0.85
└─────────────────────────────────────────────────────

┌─ [Other Events]
│ List of the other active EPL events
│ ...
└─────────────────────────────────────────────────────

रिकॉर्ड करें लंगर, यसमिंट, और नोमिंट अगले चरण में उपयोग करने के लिए, उस बाजार के मूल्य निर्धारित करें जिसमें आप व्यापार करना चाहते हैं।

हां/ना टोकन खरीदें

प्रत्येक ईपीएल इवेंट तीन स्वतंत्र बाइनरी बाजारों को उजागर करता है, प्रत्येक संभावित परिणाम के लिए एक: आर्सेनल जीतता है (-एआरएस), वॉल्वरहैम्प्टन जीतता है (-डब्ल्यूओएल), या मैच टाई पर समाप्त होता है (-बाँधना).

प्रत्येक बाज़ार एक अलग हां/ना का प्रश्न है। आर्सेनल पर हां का दांव लगाना वॉल्वरहैम्प्टन पर ना का दांव लगाने जैसा नहीं है। ड्रॉ होने पर हां-आर्सेनल पर दांव लगाने वाले को नुकसान होता है, जबकि ना-वॉल्वरहैम्प्टन पर दांव लगाने वाले को लाभ होता है। ड्रॉ होने पर हां-टाई पर दांव लगाने वालों को लाभ मिलता है, साथ ही ना-आर्सेनल और ना-वॉल्वरहैम्प्टन पर दांव लगाने वालों को भी। हमेशा उस बाज़ार को चुनें जो आपके द्वारा अनुमानित परिणाम से बिल्कुल मेल खाता हो।

बाज़ार	टोकन	आर्सेनल की जीत	वॉल्वरहैम्प्टन की जीत	खींचना
क्या आर्सेनल जीतेगा?	हाँ -एआरएस	✅ जीत	❌ हारता है	❌ हारता है
क्या आर्सेनल जीतेगा?	नहीं -एआरएस	❌ हारता है	✅ जीत	✅ जीत
क्या वॉल्वरहैम्प्टन जीतेगा?	हाँ -डब्ल्यूओएल	❌ हारता है	✅ जीत	❌ हारता है
क्या वॉल्वरहैम्प्टन जीतेगा?	नहीं -डब्ल्यूओएल	✅ जीत	❌ हारता है	✅ जीत
क्या मैच टाई पर समाप्त होगा?	हाँ -बाँधना	❌ हारता है	❌ हारता है	✅ जीत
क्या मैच टाई पर समाप्त होगा?	नहीं -बाँधना	✅ जीत	✅ जीत	❌ हारता है

आउटकम टोकन खरीदना तीन चरणों वाली प्रक्रिया है:

1. DFlow के ट्रेड API से ऑर्डर का अनुरोध करें
2. लौटाए गए लेनदेन पर हस्ताक्षर करें
3. हस्ताक्षरित लेनदेन को यहां भेजें Solana

बनाएँ src/buy.ts हां या ना परिणाम टोकन खरीदने के लिए स्क्रिप्ट:

src/buy.ts

// src/buy.ts
// Buys a Yes or No outcome token using USDC as the input
import {
  createSolanaRpc,
  Signature,
} from '@solana/kit';
import type { OrderResponse } from './types';
import { loadWallet, fetchJson, signAndSend, waitForOrder } from './utils';

const TRADE_API = process.env.TRADE_API_URL;
const RPC_URL   = process.env.QUICKNODE_RPC_URL;
const USDC_MINT = process.env.USDC_MINT;

const rpc = createSolanaRpc(RPC_URL);

// Main
async function buyOutcomeToken(
  outcomeMint: string, // yesMint or noMint from market metadata
  usdcAmount: number   // USDC to spend (e.g. 1 = $1.00)
) {
  const wallet = await loadWallet();

  // USDC has 6 decimal places: $1.00 = 1_000_000 base units.
  // The DFlow /order `amount` param is the INPUT quantity (USDC to spend).
  const amountBaseUnits = usdcAmount * 1_000_000;

  console.log(`\nSpending ${usdcAmount} USDC on outcome tokens`);
  console.log(`  Input (USDC):  ${USDC_MINT}`);
  console.log(`  Output (mint): ${outcomeMint}`);
  console.log(`  Wallet:        ${wallet.address}\n`);

  // Step 1: Request an order from DFlow Trade API
  const params = new URLSearchParams({
    inputMint: USDC_MINT,
    outputMint: outcomeMint,
    amount: String(amountBaseUnits),
    userPublicKey: wallet.address,
    slippageBps: 'auto',
    dynamicComputeUnitLimit: 'true',
    prioritizationFeeLamports: '5000',
  });

  const order = await fetchJson<OrderResponse>(`${TRADE_API}/order?${params}`);
  console.log(`Order received — mode: ${order.executionMode}, expected out: ${order.outAmount} base units`);

  // Step 2: Sign and send the transaction
  const signature = await signAndSend(order, wallet.keyPair, rpc);

  console.log(`\nTransaction submitted: ${signature}`);
  console.log(`  Explorer: https://explorer.solana.com/tx/${signature}`);

  // Step 3: For async orders, poll for fill confirmation
  if (order.executionMode === 'async') {
    const result = await waitForOrder(signature, order.lastValidBlockHeight, TRADE_API);
    if (result.status === 'closed') {
      console.log(`\n✅ Order filled! Received ${result.outAmount / 1_000_000} outcome tokens`);
    } else if (result.status === 'expired') {
      console.log(`\n⚠️ Order expired before being filled. No tokens received.`);
    } else {
      console.log(`\n⚠️ Order ended with status: ${result.status}`);
    }
  } else {
    // Sync: poll signature statuses until confirmed
    for (let i = 0; i < 30; i++) {
      await new Promise((r) => setTimeout(r, 1_000));
      const { value: statuses } = await rpc.getSignatureStatuses([signature as Signature]).send();
      const s = statuses[0];
      if (s?.confirmationStatus === 'confirmed' || s?.confirmationStatus === 'finalized') {
        if (s.err) {
          console.error(`\n❌ Transaction failed on-chain:`, s.err);
        } else {
          console.log(`\n✅ Sync order confirmed!`);
        }
        break;
      }
    }
  }
}

const [outcomeMint, amountStr] = process.argv.slice(2);
if (!outcomeMint || !amountStr) {
  console.error('Usage: npm run buy -- <outcome-mint-address> <usdc-amount>');
  process.exit(1);
}

buyOutcomeToken(outcomeMint, Number(amountStr)).catch(console.error);

स्क्रिप्ट को इसके साथ चलाएँ यसमिंट (या नोमिंटआपने पहले जो राशि दर्ज की थी और आप जितने USDC खर्च करना चाहते हैं, वह इस प्रकार है:

tsx --env-file=.env src/buy.ts 4qeSi2JVCbE9VQt1uzTJTpJSKdMFRsqWuvf3UL9fGa2P 1

अपेक्षित आउटपुट:

Spending 1 USDC on outcome tokens
  Input (USDC):  EPjFW...Dt1v
  Output (mint): 4qeS...Ga2P
  Wallet:        F6Yt...8kM9

Order received — mode: async, expected out: 11000000 base units

Transaction submitted: 3WmN...nD8s
  Explorer: https://explorer.solana.com/tx/3WmND...nD8s
  Status: pending
  Status: closed

✅ Order filled! Received 11 outcome tokens

रिक्त पदों पर नज़र रखें

किसी उपयोगकर्ता की अनुमानित बाज़ार स्थितियाँ उनके वॉलेट में SPL टोकन बैलेंस के रूप में मौजूद होती हैं। इन्हें प्रदर्शित करने के लिए, सभी टोकन खातों को प्राप्त करें, पहचानें कि कौन से टोकन परिणाम स्वरूप जारी किए गए हैं, और प्रत्येक को उसके बाज़ार डेटा से मैप करें।

बनाएं src/positions.ts:

src/positions.ts

// src/positions.ts
// Lists all open prediction market positions for a wallet
import { createSolanaRpc } from '@solana/kit';
import type { Market } from './types';
import { loadWallet, fetchJson, parseMintAndBalance, getWalletTokenAccounts } from './utils';

const METADATA_API = process.env.METADATA_API_URL;
const RPC_URL      = process.env.QUICKNODE_RPC_URL;

const rpc = createSolanaRpc(RPC_URL);

// Main
async function getPositions(walletAddress: string) {
  const tokenAccounts = await getWalletTokenAccounts(rpc, walletAddress);
  const heldMints: string[] = [];
  const mintToBalance: Record<string, bigint> = {};

  for (const { account } of tokenAccounts) {
    const { mint, amount } = parseMintAndBalance(account.data as [string, string]);
    if (amount > 0n) {
      heldMints.push(mint);
      mintToBalance[mint] = amount;
    }
  }

  if (heldMints.length === 0) {
    console.log('No SPL tokens found in wallet.');
    return;
  }

  console.log(`\nChecking ${heldMints.length} token(s) for prediction market positions...\n`);

  const positions: { mint: string; side: 'YES' | 'NO'; market: Market; balance: bigint }[] = [];

  // For each held mint, check if it is an outcome token via DFlow Metadata API
  for (const mint of heldMints) {
    let market: Market;
    try {
      market = await fetchJson<Market>(`${METADATA_API}/api/v1/market/by-mint/${mint}`);
    } catch { continue; }
    const allAccts = Object.values(market.accounts);
    const side = allAccts.some(a => a.yesMint === String(mint)) ? 'YES' : 'NO';
    positions.push({ mint, side, market, balance: mintToBalance[mint]! });
  }

  if (positions.length === 0) {
    console.log('No prediction market positions found.');
    return;
  }

  console.log(`Found ${positions.length} open position(s):\n`);

  for (const pos of positions) {
    const acct = Object.values(pos.market.accounts)[0];
    console.log(`Market:     ${pos.market.ticker}`);
    console.log(`Title:      ${pos.market.title}`);
    console.log(`Side:       ${pos.side}`);
    console.log(`Mint:       ${pos.mint}`);
    console.log(`Balance:    ${(Number(pos.balance) / 1_000_000).toFixed(6)} tokens`);
    console.log(`Status:     ${pos.market.status}${pos.market.result ? ` (result: ${pos.market.result})` : ''}`);
    const isOpen = acct?.redemptionStatus === 'open';
    const sideWon =
      (pos.side === 'YES' && pos.market.result === 'yes') ||
      (pos.side === 'NO'  && pos.market.result === 'no');
    const isScalar = !pos.market.result && acct?.scalarOutcomePercent != null;
    const redeemable = isOpen && (sideWon || isScalar);
    const redeemLabel = redeemable
      ? '✅ Yes'
      : !pos.market.result
        ? '⏳ Pending (not yet determined)'
        : sideWon
          ? '⏳ Won — redemption not open yet'
          : '❌ Lost';
    console.log(`Redeemable: ${redeemLabel}`);
    console.log();
  }
}

loadWallet()
  .then(({ address: walletAddress }) => getPositions(walletAddress))
  .catch(console.error);

बाजार में अपनी स्थिति जानने के लिए स्क्रिप्ट चलाएँ:

tsx --env-file=.env src/positions.ts

अपेक्षित आउटपुट:

Checking 4 token(s) for prediction market positions...

Found 1 open position(s):

Market:     KXEPLGAME-26FEB18WOLARS-TIE
Title:      Wolverhampton vs Arsenal Winner?
Side:       YES
Mint:       4qeSi2JVCbE9VQt1uzTJTpJSKdMFRsqWuvf3UL9fGa2P
Balance:    5.000000 tokens
Status:     active
Redeemable: ⏳ Pending (not yet determined)

मैच समाप्त होने और बाज़ार के अंतिम रूप देने के बाद, स्क्रिप्ट को दोबारा चलाने पर तय किया गया परिणाम दिखेगा। यदि आपने सही परिणाम पर दांव लगाया था, तो आपकी स्थिति भुनाने योग्य दिखाई देगी।

Checking 4 token(s) for prediction market positions...

Found 1 open position(s):

Market:     KXEPLGAME-26FEB18WOLARS-TIE
Title:      Wolverhampton vs Arsenal Winner?
Side:       YES
Mint:       4qeSi2JVCbE9VQt1uzTJTpJSKdMFRsqWuvf3UL9fGa2P
Balance:    5.000000 tokens
Status:     finalized (result: yes)
Redeemable: ✅ Yes

जीते हुए टोकन रिडीम करें

बाजार का निर्धारण हो जाने के बाद, विजेता टोकन को उनके स्टेबलकॉइन भुगतान के लिए भुनाया जा सकता है। /आदेश endpoint इसका उपयोग हैंडल रिडेम्पशन खरीदने के लिए किया जाता है। DFlow यह पता लगाता है कि इनपुट एक आउटकम टोकन है और स्वचालित रूप से एक रिडेम्पशन लेनदेन बनाता है।

मोचन का प्रयास करने से पहले, तीन शर्तें पूरी होनी चाहिए:

1. बाजार की स्थिति यह है दृढ़ निश्चय वाला या अंतिम रूप दिया
2. सेटलमेंट मिंट का मोचन स्थिति है खुला (चेक इन बाजार.खाते)
3. परिणाम टोकन विजेता पक्ष से मेल खाता है (परिणाम === "हाँ" → उपयोग करें यसमिंट; परिणाम === "नहीं" → उपयोग करें नोमिंट)

बनाएं src/redeem.ts:

src/redeem.ts

import { createSolanaRpc } from '@solana/kit';
import type { Market, OrderResponse } from './types';
import { loadWallet, fetchJson, signAndSend, waitForOrder, parseMintAndBalance, getWalletTokenAccounts } from './utils';

const METADATA_API = process.env.METADATA_API_URL;
const TRADE_API    = process.env.TRADE_API_URL;
const RPC_URL      = process.env.QUICKNODE_RPC_URL;
const USDC_MINT    = process.env.USDC_MINT;

const rpc = createSolanaRpc(RPC_URL);

// Main
async function redeemOutcomeTokens(outcomeMint: string) {
  const wallet = await loadWallet();

  const tokenAccounts = await getWalletTokenAccounts(rpc, wallet.address);
  let rawBalance = 0n;
  for (const { account } of tokenAccounts) {
    const { mint, amount } = parseMintAndBalance(account.data as [string, string]);
    if (mint === outcomeMint) { rawBalance = amount; break; }
  }
  if (rawBalance === 0n) {
    console.error('No balance found for this mint in your wallet.');
    process.exit(1);
  }
  const tokenAmount = Number(rawBalance);

  // Step 1: Verify the token is redeemable
  const market = await fetchJson<Market>(`${METADATA_API}/api/v1/market/by-mint/${outcomeMint}`);
  const allAccts = Object.values(market.accounts);
  const acct = allAccts.find(a => a.yesMint === outcomeMint || a.noMint === outcomeMint)
            ?? allAccts[0];
  if (!acct) throw new Error('No account info found for this market.');

  const isWinningMint =
    (market.result === 'yes' && allAccts.some(a => a.yesMint === outcomeMint)) ||
    (market.result === 'no'  && allAccts.some(a => a.noMint  === outcomeMint));
  const isScalar = !market.result && acct.scalarOutcomePercent !== null;

  if (!isWinningMint && !isScalar) {
    console.log(`\n⚠️ This outcome token cannot be redeemed.`);
    console.log(`  Market result: ${market.result ?? 'not yet determined'}`);
    console.log(`  Market status: ${market.status}`);
    return;
  }

  if (acct.redemptionStatus !== 'open') {
    console.log(`\n⚠️ Redemption window is not open yet.`);
    console.log(`  redemptionStatus: ${acct.redemptionStatus}`);
    return;
  }

  console.log(`\nRedeeming ${tokenAmount} tokens from market: ${market.ticker}`);

  if (isScalar && acct.scalarOutcomePercent !== null) {
    const yesPct = (acct.scalarOutcomePercent / 100).toFixed(2);
    const noPct = ((10_000 - acct.scalarOutcomePercent) / 100).toFixed(2);
    console.log(`  Scalar market — YES payout: ${yesPct}%  NO payout: ${noPct}%`);
  }

  // Step 2: Request a redemption order (same /order endpoint as buying)
  const params = new URLSearchParams({
    inputMint: outcomeMint,
    outputMint: USDC_MINT,
    amount: String(tokenAmount),
    userPublicKey: wallet.address,
  });

  const order = await fetchJson<OrderResponse>(`${TRADE_API}/order?${params}`);

  // Step 3: Sign and send
  const signature = await signAndSend(order, wallet.keyPair, rpc);

  console.log(`\nTransaction submitted: ${signature}`);
  console.log(`  Explorer: https://explorer.solana.com/tx/${signature}`);

  // Step 4: Monitor until closed
  const result = await waitForOrder(signature, order.lastValidBlockHeight, TRADE_API);
  if (result.status === 'closed') {
    console.log(`\n✅ Redemption complete! Received ${result.outAmount / 1_000_000} USDC`);
  } else {
    console.log(`\n⚠️ Redemption ended with status: ${result.status}`);
  }
}

const [mint] = process.argv.slice(2);
if (!mint) {
  console.error('Usage: npm run redeem -- <outcome-mint-address>');
  process.exit(1);
}

redeemOutcomeTokens(mint).catch(console.error);

बाजार का निर्धारण हो जाने और रिडेम्पशन विंडो खुल जाने के बाद इसे चलाएं:

tsx --env-file=.env src/redeem.ts 4qeSi2JVCbE9VQt1uzTJTpJSKdMFRsqWuvf3UL9fGa2P

अपेक्षित आउटपुट:

Redeeming 5000000 tokens from market: KXEPLGAME-26FEB18WOLARS-TIE

Transaction submitted: 2sF5df4KwTsKx4V8Qg3GLAQFRDRtctnVUaQbB9n3cjyvyHxKKr6RPHWu38HRvMozd7HGi5JvbLw4amXMQeYvLuL5
  Explorer: https://explorer.solana.com/tx/2sF5df4KwTsKx4V8Qg3GLAQFRDRtctnVUaQbB9n3cjyvyHxKKr6RPHWu38HRvMozd7HGi5JvbLw4amXMQeYvLuL5
  Status: pending
  Status: closed

✅ Redemption complete! Received 5 USDC

यही संपूर्ण है flow !

आपने DFlow मेटाडेटा API के माध्यम से लाइव मार्केट की खोज करने से लेकर अपनी जीत को USDC में भुनाने तक की पूरी प्रक्रिया को सफलतापूर्वक पूरा किया, जिसमें आउटकम टोकन खरीदना और पोजीशन को ट्रैक करना पूरी तरह से आपके नियंत्रण में था। Solana प्रत्येक चरण केवल एक एपीआई कॉल या हस्ताक्षरित लेनदेन है। किसी ऑफ-चेन ट्रेडिंग इंफ्रास्ट्रक्चर की आवश्यकता नहीं है।

उत्पादन चेकलिस्ट

किसी पूर्वानुमान बाजार एप्लिकेशन को तैनात करने से पहले mainnet उपयोगकर्ता, कृपया इस चेकलिस्ट का पालन करें:

एपीआई कुंजी और एंडपॉइंट

• देव एंडपॉइंट्स को बदलें (dev-quote-api.dflow.net, dev-prediction-markets-api.dflow.net) DFlow द्वारा प्रदान किए गए प्रोडक्शन URL और API कुंजी के साथ
• एपीआई कुंजी को इसके माध्यम से पास करें x-api-key प्रत्येक अनुरोध पर हेडर
• एक्सपोनेंशियल बैकऑफ़ के साथ रेट-लिमिट-अवेयर रिट्राई लॉजिक लागू करें

बाजार जीवनचक्र एज केस

• बाज़ार अस्थायी रूप से बंद हो सकते हैं; जाँच करें स्थिति "ट्रेड" CTA दिखाने से पहले
• बंद होने का समय ट्रेडिंग बंद होने का समय चिह्नित करें। इसे प्रमुखता से प्रदर्शित करें ताकि उपयोगकर्ता बाजार बंद होने के बाद खरीदारी करने का प्रयास न करें।
• परिणाम बाजार बंद होने के बाद डेटा भरने में समय लग सकता है; तब तक मतदान करें स्थिति पहुँचता है दृढ़ निश्चय वाला

अक्सर पूछे जाने वाले प्रश्नों

DFlow के एसिंक्रोनस प्रेडिक्शन मार्केट ट्रेड्स एक रेगुलर ट्रेड से किस प्रकार भिन्न रूप से काम करते हैं? Solana बदलना?

Unlike standard atomic swaps (one transaction, immediate confirmation), prediction market orders on DFlow use an async Concurrent Liquidity Program (CLP) model. You submit one transaction expressing a "trade intent," and one or more liquidity providers fill it in separate transactions. Poll GET /order-status?signature=<txSig> until the status reaches closed to confirm your outcome tokens have been minted.

क्या मैं हां/ना परिणाम टोकन खरीदने के लिए किसी भी टोकन का उपयोग कर सकता हूं, या इसके लिए केवल USDC ही आवश्यक है?

आप किसी से भी शुरुआत कर सकते हैं Solana स्पॉट टोकन। डीफ्लो /ऑर्डर endpoint यह प्रक्रिया आपके इनपुट को स्वचालित रूप से एक मध्यवर्ती स्वैप के माध्यम से बाजार के निपटान केंद्र (USDC या CASH) तक पहुंचाती है, जिसके बाद ही आपको अंतिम टोकन प्राप्त होता है। हालांकि, USDC या CASH को सीधे इनपुट के रूप में उपयोग करना सबसे तेज़ तरीका है। इससे अतिरिक्त स्वैप चरण समाप्त हो जाता है और लगभग 50 मिलीसेकंड की विलंबता बचती है।

अगर मैंने हारने वाली टीम का समर्थन किया तो मेरे आउटकम टोकन का क्या होगा?

हारने वाले टोकन निपटान के बाद बेकार हो जाते हैं। केवल जीतने वाले टोकन ही पूर्ण निपटान मूल्य (DFlow के आंतरिक पैमाने पर $1.00 प्रति टोकन = 10,000) के लिए रिडीम किए जा सकते हैं। स्केलर बाजारों में, YES और NO दोनों टोकन स्केलरआउटकमपरसेंट फ़ील्ड के आधार पर आनुपातिक भुगतान पर रिडीम किए जा सकते हैं। रिडेम्पशन लेनदेन करने से पहले हमेशा रिडेम्पशनस्टेटस की उपलब्धता की पुष्टि करें।

किसी बाजार की स्थिति निर्धारित होने और अंतिम रूप दिए जाने में क्या अंतर है?

निर्धारित का अर्थ है कि कालशी ने विजेता परिणाम की पहचान कर ली है, लेकिन निपटान अभी पूरी तरह से प्रसारित नहीं हुआ है। अंतिम रूप दिया गया का अर्थ है कि बाजार पूरी तरह से व्यवस्थित हो गया है और सभी पदों का भुगतान कर दिया गया है। DFlow परिणाम टोकन को तब रिडीम करने योग्य के रूप में चिह्नित करता है जब बाजार निर्धारित स्थिति में पहुंच जाता है और निपटान मिंट का रिडेम्पशन स्टेटस खुला होता है। आपको केवल बाजार की स्थिति पर निर्भर रहने के बजाय रिडेम्पशन स्टेटस के "खुला" होने की प्रतीक्षा करनी चाहिए।

क्या मुझे DFlow का उपयोग शुरू करने के लिए API कुंजी की आवश्यकता है?

यह विकास के लिए नहीं है। डेवलपर ट्रेड एपीआई (https://dev-quote-api.dflow.net) और डेवलपर मेटाडेटा एपीआई (https://dev-prediction-markets-api.dflow.net) दोनों बिना प्रमाणीकरण के काम करते हैं। डेवलपर एंडपॉइंट्स पर दर सीमाएं लागू होती हैं। प्रोडक्शन ट्रैफ़िक के लिए, आपको एक एपीआई कुंजी की आवश्यकता होगी (इसे x-api-key हेडर के रूप में पास करें)।

यदि मैं उपयोगकर्ताओं को एक पूर्वानुमान बाजार ऐप भेजता हूं तो कौन-कौन सी अनुपालन आवश्यकताएं लागू होती हैं?

क्योंकि पोजीशन Kalshi द्वारा समर्थित हैं — जो CFTC द्वारा विनियमित एक्सचेंज है — इसलिए Kalshi के अनुपालन संबंधी आवश्यकताओं को पूरा करने के लिए किसी भी एप्लिकेशन को Proof (एक KYC/पहचान प्रदाता) को एकीकृत करना आवश्यक है। DFlow के दस्तावेज़ में इसे लाइव होने से पहले एक अनिवार्य आवश्यकता के रूप में निर्दिष्ट किया गया है। लॉन्च से पहले KYC अनुपालन को एकीकृत करने में विफल रहने पर Kalshi की सेवा शर्तों का उल्लंघन हो सकता है।

ऊपर लपेटकर

आपने एक संपूर्ण एंड-टू-एंड पूर्वानुमान बाजार का निर्माण किया है। flow पर Solana DFlow मेटाडेटा API से शुरू करके, आपने लाइव EPL कॉन्ट्रैक्ट्स खोजने के लिए Series → Events → Markets पदानुक्रम का अनुसरण किया, इवेंट्स और Yes/No कीमतों को प्राप्त किया, एक हस्ताक्षरित लेनदेन के साथ परिणाम टोकन खरीदे, वॉलेट बैलेंस को वापस बाजार की स्थिति में मैप किया, और निपटान के बाद जीतने वाले टोकन को स्टेबलकॉइन के लिए भुनाया।

यहां दिए गए समान पैटर्न कल्शी समर्थित किसी भी बाजार पर लागू होते हैं जिसे डीफ्लो उजागर करता है: खेल, अर्थशास्त्र या राजनीति। अब आपके पास एक पूर्ण भविष्यवाणी बाजार एप्लिकेशन बनाने के लिए एक ठोस आधार है। Solana मूल रूप में।

संसाधन

• डीफ्लो प्रलेखन
• डीफ्लो भविष्यवाणी बाजार डेटा मॉडल
• डीफ्लो प्रूफ केवाईसी एकीकरण
• कालशी एपीआई दस्तावेज़
• डीफ्लो प्रेडिक्शन मार्केट्स एपीआई: कालशी के साथ भविष्य का टोकनाइजेशन ( Solana .com)