एक सरल क्रिप्टोक्यूरेंसी ट्रेडिंग बॉट

सभी को नमस्कार! आज हम स्टॉक एक्सचेंज पर खेलने के लिए अपना पहला मुकाबला ट्रेडिंग रोबोट लिखेंगे। Kriptobirzhe। क्रिप्टोक्यूरेंसी एक्सचेंज क्यों?

क) प्रचार विषय;
b) वे किसी भी तरह सरल हैं।

सबसे पहले, मैं तुरंत तीन एक्सिस कैसीनो के प्रशंसकों को चेतावनी देना चाहता हूं: आपने कल एक कार नहीं कमाई। लेख आपके रोबोट को लिखना शुरू करने के तरीके के बारे में अधिक है, इसलिए एल्गोरिथ्म आदिम होगा, लेकिन काम करना।

दूसरे, आप कमाएंगे। बस थोड़ा सा।

सबसे अधीर के लिए, एक्सो-एक्सचेंज-ट्रेड-बॉट गिथब पर सभी कोड।

चरण 1: विनिमय।

हम EXMO एक्सचेंज पर ट्रेड करेंगे। इसके कई कारण हैं। एक्सचेंज सीआईएस में लोकप्रिय है, यह रूसी भाषी है और रूबल के इनपुट का समर्थन करता है, इसमें रूबल के लिए जोड़े बनाने की क्षमता है।

मंत्रियों के बीच रूबल जमा करने की असुविधाजनक प्रक्रिया है, एक सभ्य कमीशन, कुछ व्यापारिक जोड़े।

हमारे लिए, मुख्य बात यह है कि इसके पास अपने एपीआई के साथ काम करने के लिए तैयार समाधान हैं। इससे निश्चित रूप से हमारे काम में आसानी होगी।

तो चलिए शुरू करते हैं।

बेशक, आपको स्टॉक एक्सचेंज में पंजीकरण करने और कुछ पैसे जमा करने की आवश्यकता है। उदाहरण के लिए, मैंने $ 5 का योगदान दिया।

आपके खाते में आगे आपको एपीआई तक पहुंचने के लिए चाबियां मिलेंगी।

मैं NodeJS के लिए क्लाइंट का उपयोग करूंगा (इसलिए आपको नोडज और एनपीएम स्थापित करने की आवश्यकता होगी)।

अपने कंप्यूटर पर, एक नया फ़ोल्डर और एक फ़ाइल बनाएं जिसमें हमारा ट्रेडिंग रोबोट होगा (जैसे exmo / index.js), कंसोल खोलें और अंतिम मानक तैयारी करें।

हम अपने प्रोजेक्ट के साथ फ़ोल्डर में जाते हैं और लिखते हैं - npm init, फिर सभी सवालों के लिए एंटर दबाएं।

आगे हम लिखते हैं

npm install exmo-api 

जबकि पैकेज इंस्टॉल किए जा रहे हैं, एक अन्य फ़ाइल बनाएं, इसे exmo.js कहें और इसे इस सामग्री से भरें।

 var CryptoJS = require("crypto-js") http = require('http'), querystring = require('querystring'), request = require('request'), config = { url: 'https://api.exmo.me/v1/' }; function sign(message){ return CryptoJS.HmacSHA512(message, config.secret).toString(CryptoJS.enc.hex); } exports.init_exmo = function (cfg) { config.key = cfg.key; config.secret = cfg.secret; config.nonce = Math.floor(new Date().getTime()*1000); }; exports.api_query = function(method_name, data, callback){ data.nonce = config.nonce++; var post_data = querystring.stringify(data); var options = { url: config.url + method_name, method: 'POST', headers: { 'Key': config.key, 'Sign': sign(post_data) }, form:data }; request(options, function (error, response, body) { if (!error && response.statusCode == 200) { callback(body); }else{ callback(error); } }); }; exports.api_query2 = function(method_name, data, callback){ data.nonce = config.nonce++; var post_data = querystring.stringify(data); var post_options = { host: 'api.exmo.me', port: '80', path: '/v1/' + method_name, method: 'POST', headers: { 'Key': config.key, 'Sign': sign(post_data), 'Content-Type': 'application/x-www-form-urlencoded', 'Content-Length': Buffer.byteLength(post_data) } }; var post_req = http.request(post_options, function(res) { res.setEncoding('utf8'); res.on('data', function (chunk) { callback(chunk); }); }); post_req.write(post_data); post_req.end(); }; exports.test = function(){ return config.key; }; 

इस फ़ाइल में एपीआई का पता, अतिरिक्त पुस्तकालयों का कनेक्शन है जिसे हमें एपीआई के साथ काम करने की आवश्यकता है, और एपीआई के अनुरोध के लिए मुख्य कार्य।

बस इतना ही, हमने सब कुछ तैयार कर लिया है और अब हम सीधे "पैसा बनाने वाली मशीन" बनाना शुरू कर सकते हैं;)

स्टेज 2: कोड

हमारी index.js खोलें और exmo.js फ़ाइल कनेक्ट करें:

 const exmo = require("./exmo"); 

इसके बाद, अपने व्यक्तिगत खाते में उस स्थान पर एक्सचेंज पर जाएं जहां हमने एपीआई तक पहुंच के लिए अपनी चाबियां बनाई थीं। हम उन्हें कॉपी करते हैं और उन्हें चर में सहेजते हैं:

 const apiKey = ' '; const apiSecret = ' '; 

अब दो चर बनाएं:
Currency1 हम क्या खरीदते हैं;
Currency2 - वह मुद्रा जिसके लिए हम खरीद रहे हैं।

मैं डॉलर के लिए बिटकॉइन खरीदना चाहता हूं:

 const currency1 = 'BTC'; const currency2 = 'USD'; 

अगला, एक महत्वपूर्ण बिंदु - हम एक न्यूनतम शर्त राशि के साथ एक चर बनाते हैं। एक्सचेंज इस राशि से कम खरीदने की अनुमति नहीं देता है।

हम पते पर जाएँ https://api.exmo.com/v1/pair_settings/ अपनी जोड़ी की तलाश करें (मेरे लिए यह BTC_USD है) और पहले पैरामीटर को देखें - min_quantity - 0.001

 const currency1MinQuantity = 0.001; 

और कुछ और चर:

मिनट की संख्या जिसके बाद एक अधूरा खरीद आदेश मुद्रा 1 को रद्द कर दिया जाएगा

 const orderLifeTime = 3; 

विनिमय आयोग (0.002 = 0.2%)

 const stockFee = 0.002; 

औसत मूल्य की गणना के लिए समय की अवधि (मिनट में) (यह हमारे एल्गोरिथ्म के लिए आवश्यक होगा)

 const avgPricePeriod = 1; 

Currency2 को एक बार के लेनदेन में Currency1 खरीदने के लिए 2 की राशि (मैंने $ 5 फेंक दिया - मैं उनके साथ काम करूंगा)

 const canSpend = 5; 

प्रत्येक लेनदेन से लाभ की वांछित राशि (0.001 = 0.1%)

 const profit = 0.001; 

यदि विनिमय समय वर्तमान से अलग हो जाता है

 const stockTimeOffset = 0; 

सुविधा के लिए, हम अपनी जोड़ी को _ के माध्यम से जोड़ते हैं

 let currentPair = currency1+'_'+currency2; 

कनेक्शन को प्रारंभ करें।

 exmo.init_exmo({key:apiKey, secret:apiSecret}); 

परीक्षण के लिए, आप अपने बारे में जानकारी का अनुरोध कर सकते हैं:

 exmo.api_query("user_info", { }, result => console.log(result);); 

कंसोल पर जाएं और चलाएं

 node index.js 

यदि सब कुछ सही ढंग से किया जाता है, तो आप अपने बारे में जानकारी देखेंगे!

सब कुछ काम करता है और आप सबसे दिलचस्प भाग पर आगे बढ़ सकते हैं - वह फ़ंक्शन जो दादी हमारे लिए उत्पन्न करेगा।

इसलिए, मैंने पहले ही ऊपर कहा था कि हमारा एल्गोरिथ्म बेवकूफ होगा, अब आप समझेंगे कि कितना)

चाल किसी भी अवधि के लिए पूर्ण लेनदेन का इतिहास लेने के लिए है - हमारे पास इसके लिए जिम्मेदार avgPricePeriod का चर है - और औसत मूल्य की गणना करें जिसके लिए Currency1 बेचा गया था। इस औसत मूल्य के लिए, हम अपना ऑर्डर देंगे।

तो चलिए शुरू करते हैं। हम अपना व्यापार () फ़ंक्शन लिखते हैं

 function trade(){} 

पहले हमें अपने खुले आर्डर की सूची मिलती है:

1) हम जाँचते हैं कि क्या हमारे पास user_open_orders api पद्धति का उपयोग करके हमारी जोड़ी के लिए खुले ऑर्डर हैं। यदि बिक्री के लिए भी हैं,

तब हम बस उनके पूरा होने की प्रतीक्षा करते हैं (कभी-कभी समय के अंत तक)। यदि खरीद के आदेश हैं, तो उन्हें याद रखें।

 exmo.api_query("user_open_orders", { }, result => { let res = JSON.parse(result); if(res[currentPair] == undefined) console.log('  '); let buyOrders = []; for(let i in res[currentPair]){ console.log(res[currentPair][i]); if(res[currentPair][i].type == 'sell'){ console.log(',    /    '); }else{ buyOrders.push(res[currentPair][i]); } } 

2) हम जाँच करते हैं कि क्या हमारे पास खुली खरीद के आदेश हैं।

हम सभी आदेशों के माध्यम से क्रमबद्ध करते हैं और उनमें से एक इतिहास प्राप्त करते हैं ताकि आदेश आईडी का उपयोग करके आदेश आईडी को पारित किया जा सके।

3 विकल्प हो सकते हैं:

 if(buyOrders.length > 0){ for(let key in buyOrders){ console.log(',     ', buyOrders[key]['order_id']); exmo.api_query('order_trades', {"order_id": buyOrders[key]['order_id']}, result => { let res = JSON.parse(result); 

1) हम आवश्यक मुद्रा पूरी तरह से नहीं, बल्कि विक्रेताओं के आदेशों से खरीद सकते हैं।
इसलिए, यदि हमने पहले से ही वांछित मूल्य पर खरीदा है, तो हम पूरी राशि की खरीद की प्रतीक्षा कर रहे हैं।

 if(res.result !== false){ console.log(',       ,     '); } 

2) दूसरे विकल्प के साथ, हमें यह जांचना होगा कि क्या हमारा ऑर्डर बहुत लंबा है। कीमतें जल्दी से बदलती हैं और शायद औसत कीमत अब प्रासंगिक नहीं है। ऐसा करने के लिए, हमने वैरिएबल ऑर्डरलाइफटाइम बनाया, जहां हम इंगित करते हैं कि मिनटों में हमारा ऑर्डर कितना लटका होना चाहिए।

यदि समय समाप्त हो जाता है, तो ऑर्डर आईडी का उपयोग करके ऑर्डर_कैंसेल पद्धति का उपयोग करके ऑर्डर को रद्द कर दें।

 let timePassed = (new Date().getTime() / 1000) + stockTimeOffset * 60 * 60 - (buyOrders[key]['created']); if(timePassed > orderLifeTime * 60){ exmo.api_query('order_cancel',{"order_id":buyOrders[key]['order_id']}, res => { let result = JSON.parse(res); if(result.error) console.log(result.error); console.log(`   ${orderLifeTime}     ${currency1}`); }); }else{ 

3) यदि समय अभी तक नहीं आया है, तो हमें उम्मीद है कि हम अपनी कीमत पर खरीद सकते हैं।

 console.log(`,        ,      ${timePassed} `); } } }); } }else{ 

सब कुछ, हम खुले आदेशों का पता लगाते हैं, अब हमारा रोबोट जानता है कि जब वह उन्हें बनाता है तो आदेशों का क्या करना है। आधा काम हो गया।

तो, एक ब्लॉक अगर हमारे पास ऑर्डर नहीं है।

हमें user_info पद्धति का उपयोग करके अपने खाते के बारे में जानकारी मिलती है:

 exmo.api_query('user_info',{},(result)=>{ let res = JSON.parse(result); 

सुविधा के लिए, हम अपनी जोड़ी के लिए शेष राशि लिखते हैं:

 let balance = res.balances[currency1]; let balance2 = res.balances[currency2]; 

जाँच करें कि क्या Currency1 है जिसे बेचा जा सकता है?

 if(balance >= currency1MinQuantity){} 

यदि हां, तो हमें विक्रय दर की गणना करने की आवश्यकता है।

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

एक महत्वपूर्ण बिंदु! हमारे पास खरीदी गई मुद्राओं की तुलना में कम मुद्राएं हैं - विनिमय ने कमीशन लिया।

 let wannaGet = canSpend + canSpend * (stockFee+profit); console.log('sell', balance, wannaGet, (wannaGet/balance)); 

ऑर्डर बनाते समय, ऑर्डर_क्रिएट विधि को मापदंडों को पारित करने की आवश्यकता होती है:

• व्यापार के लिए जोड़ी हमारी वर्तमान जोड़ी है;
• मात्रा - मात्रा;
• मूल्य - मूल्य;
• प्रकार - निर्मित आदेश का प्रकार (खरीद / बिक्री);

हम बेचना चाहते हैं - उस प्रकार में जैसे हम बेचते हैं ।

 let options = { "pair": currentPair, "quantity": balance, "price": wannaGet / balance, "type": 'sell' }; 

और एक अनुरोध भेजें, अगर सब कुछ सही है, तो आप प्रविष्टि देखेंगे "एक बिक्री आदेश बनाया गया है"

 exmo.api_query("order_create", options,(result)=>{ if(result.error) console.log(result.error); console.log("   ", currency1, result.order_id); }); 

वह सब है। यदि हमारे पास एक मुद्रा थी, तो हमने इसे बेचने का आदेश दिया।

अब हम सबसे दिलचस्प ब्लॉक की ओर रुख करते हैं: यदि हमारे पास करेंसी 1 (btc) नहीं है और हम इसे अपनी करेंसी 2 (usd) के लिए खरीदना चाहते हैं।

पहले, यह जांचें कि क्या करेंसी 2 में बैलेंस शीट पर पर्याप्त पैसा है।

 if(balance2 >= canSpend){} 

अगर वहाँ है, तो हमें औसत मूल्य प्राप्त करने की आवश्यकता है जिसके लिए Currency1 (btc) उस समय की अवधि के लिए बेचा जाता है जिसे हमने avgPricePeriod में निर्दिष्ट किया था ।

गाने के बोल:
Exmo में मुद्रा जोड़े के लिए आंकड़ों और ट्रेडिंग वॉल्यूम के साथ एक टिकर विधि है। आंकड़े पिछले 24 घंटों के लिए औसत मूल्य दर्शाते हैं। हालांकि, औसत कीमत और जिस पर वर्तमान में नीलामी हो रही है, के बीच अंतर बहुत अलग हो सकता है।

इस वजह से, हम एक बेचने के आदेश के निष्पादन के लिए लंबे समय तक इंतजार कर सकते हैं।

हम अपनी बाइक बनाएंगे।

Exmo में एक ट्रेड विधि है, यह एक मुद्रा जोड़ी के लिए सौदों की एक सूची देता है।

हम जिस avgPricePeriod में रुचि रखते हैं और उनसे औसत कीमत की गणना करेंगे, उसके लिए हम सही सौदा करेंगे।

यह एक आदर्श विकल्प नहीं है, लेकिन यह वास्तविक कीमतों को दिखाएगा जिस पर वे बेचते हैं और खरीदते हैं।

उदाहरण के लिए, लेखन के समय, BTC_USD की औसत कीमत 8314 है, जबकि एक्सचेंज पर खरीद 7970 की कीमत पर की जाती है।

यदि हम औसत मूल्य पर ऑर्डर देते हैं, तो इसे तुरंत बेचने के आदेशों में इंगित न्यूनतम मूल्य पर निष्पादित किया जाएगा।

लेकिन लाभ और विनिमय आयोग को जोड़ने पर, हमें बिक्री के लिए बहुत लंबा इंतजार करने की संभावना है।

तो, चलिए ट्रेडों की विधि की ओर मुड़ते हैं और उनसे हमारी करंट जोड़ी पर आंकड़े मांगते हैं:

 exmo.api_query("trades",{"pair":currentPair}, result => { let res = JSON.parse(result); let prices = []; let summ = 0; 

हम सभी परिणामों पर जाएंगे और केवल उन लोगों को छोड़ देंगे जो हमारे समय की अवधि के लिए उपयुक्त हैं।

 for(deal in res[currentPair]){ let timePassed = (new Date().getTime() / 1000) + stockTimeOffset * 60 * 60 - res[currentPair][deal].date; if(timePassed < avgPricePeriod * 60){ summ += parseInt(res[currentPair][deal].price); prices.push(parseInt(res[currentPair][deal].price)); } } 

और औसत मूल्य की गणना करें।

 let avgPrice = summ2 / prices.length; 

हमारे पास औसत मूल्य है, लेकिन हमें इसे थोड़ा ठीक करने की आवश्यकता है - स्टॉकफी एक्सचेंज कमीशन को घटाएं और वांछित लाभ जोड़ें। इस प्रकार, औसत बाजार मूल्य से नीचे एक मूल्य प्राप्त करने के बाद, हम थोड़ी अधिक मुद्रा खरीद लेंगे, क्योंकि बाद में एक्सचेंज इसका हिस्सा लेता है;

 let needPrice = avgPrice - avgPrice * (stockFee + profit); 

हमें अंतिम राशि मिलती है जिसे हमें खरीदने की आवश्यकता होती है।

 let ammount = canSpend / needPrice; console.log('Buy', ammount, needPrice); 

हम जांचते हैं कि क्या इस तरह की मुद्रा खरीदना संभव है (क्या न्यूनतम खरीद राशि का उल्लंघन नहीं किया गया)।

 if(ammount >= currency1MinQuantity){} 

यदि हमारी मात्रा अधिक है, तो हम ऑर्डर_क्रिएट विधि के लिए पैरामीटर बनाते हैं , केवल इस बार खरीद प्रकार के साथ।

  let options = { "pair": currentPair, "quantity": ammount, "price": needPrice, **"type": 'buy'** }; exmo.api_query('order_create', options, res => { let result = JSON.parse(res); if(result.error) console.log(result.error); console.log('   ', result.order_id); }); }else{ console.log(',      '); } }); }else{ console.log(',   '); } 

अब हमें अपने कार्य को टाइमर पर रखना होगा (उदाहरण के लिए सीमा हर 5 सेकंड में एक बार होती है) और हम इसे चला सकते हैं।

 var timerId = setTimeout(function tick() { trade(); timerId = setTimeout(tick, 5000); }, 5000); 

 node index.js 

बधाई हो, आपने अपना पहला ट्रेडिंग रोबोट लिखा: आप एल्गोरिथ्म को पूरा कर सकते हैं और बहुत सारा पैसा कमा सकते हैं) बस मजाक कर रहे हैं ।

मुझे लगता है कि आपके पास एक उचित सवाल है, "आप इस तरह से कितना पैसा कमा सकते हैं?"

$ 5 के साथ एक ऑपरेशन के लिए, मैं लगभग 2-3 सेंट कमाता हूं। यह एल्गोरिथ्म की प्रधानता के कारण है, जो काम करता है यदि कीमत एक निश्चित सीमा में उतार-चढ़ाव करती है (और यह लगभग हमेशा क्रिप्टोक्यूरेंसी एक्सचेंजों पर मामला नहीं है)। लगभग 10-20 ऑपरेशन प्रति दिन (अच्छे हाथों से) होते हैं। आप खुद को गिन सकते हैं;)

लेकिन हम पैसे की खातिर कोड में महारत हासिल नहीं कर रहे हैं)

एक बार फिर, बॉट और टिप्पणियों के पूर्ण संस्करण के साथ जीथब का लिंक।
https://github.com/v-florinskiy/exmo-exchange-trade-bot

यह मेरा पहला लेख है - कड़ाई से न्याय न करें)

सभी लाभ।

पुनश्च: उन लोगों के लिए जो नोड के साथ काम नहीं करते थे, आपकी स्क्रिप्ट स्वाभाविक रूप से काम करेगी जबकि कंसोल खुला है।

आपके रोबोट को 24/7 काम करने के लिए, आपको कुछ प्रकार के वीपीएस की आवश्यकता है: वहां आपने नोडज, एनपीएम और, उदाहरण के लिए, पीएम 2 लगाया। इस उपयोगिता का उपयोग करते हुए, स्क्रिप्ट काम करना जारी रखेगी, भले ही कंसोल बंद हो।