1. Quadrado
2. Cliente do centro de mercado

Cliente do centro de mercado

Autora:Fmzero, Data: 19 de janeiro de 2020 23:29:25
Tags:

---

---

// a client for market center, https://github.com/goex-top/market_center
// api list 
// * GetSupportList
// * SubscribeSpotTicker
// * SubscribeSpotDepth
// * ~~SubscribeSpotTrade~~
// * GetSpotTicker
// * GetSpotDepth
// * ~~GetSpotTrade~~
// * SubscribeFutureTicker
// * SubscribeFutureDepth
// * ~~SubscribeFutureTrade~~
// * GetFutureTicker
// * GetFutureDepth
// * ~~GetFutureTrade~~

// params wit web
// var udspath = /tmp/goex.market.center //ref to https://github.com/goex-top/market_center/blob/1e1bb15c69a1da6fddbba3d506920e91f9ec7842/const.go#L35

// local variable
// var client = null

var ReqType = {
    ReqType_GetSupportList: 1,
    ReqType_SubscribeSpotDepth: 2,
    ReqType_SubscribeSpotTicker: 3,
    ReqType_SubscribeFutureDepth: 4,
    ReqType_SubscribeFutureTicker: 5,
    ReqType_GetSpotDepth: 6,
    ReqType_GetSpotTicker: 7,
    ReqType_GetFutureDepth: 8,
    ReqType_GetFutureTicker: 9,
}

//---------------------------------------
function newUDSClient() {
    var client = Dial('unix://'+udspath)
    if (null === client) {
        throw 'new usd client fail'
    }
    return client
}

function udsRequest(client, req) {
    try {
        client.write(JSON.stringify(req))
        var rsp = client.read(20)
        if (rsp === null) {
            return null
        }
    
        var obj = JSON.parse(rsp)
        if(obj.status !== 0) {
            return null
        }
        return obj.data
    }
    catch(e) {
        return null
    }
    
}

function GetSupportList(client) {
    var req = {type:ReqType.ReqType_GetSupportList}
    var rsp = udsRequest(client, req)
    if (rsp === null) {
        return null
    }
    return rsp
}

function GetSpotDepth(client, exchangeName, pair) {
    var req = {type:ReqType.ReqType_GetSpotDepth, exchange_name: exchangeName, currency_pair: pair}
    var rsp = udsRequest(client, req)
    if(rsp === null) {
        return null
    }
    return {Asks:rsp.AskList, Bids:rsp.BidList, Time:rsp.UTime, Info:rsp.rsp}
}

function GetSpotTicker(client, exchangeName, pair) {
    var req = {type:ReqType.ReqType_GetSpotTicker, exchange_name: exchangeName, currency_pair: pair}
    var rsp = udsRequest(client, req)
    if(rsp === null) {
        return null
    }
    return {
        Last:parseFloat(rsp.last), 
        Buy:parseFloat(rsp.buy), 
        Sell:parseFloat(rsp.sell), 
        Volume:parseFloat(rsp.vol), 
        Time:parseFloat(rsp.date), 
        High:parseFloat(rsp.high), 
        Low:parseFloat(rsp.low), 
        Info:rsp
    }
}

function SubscribeSpotDepth(client, exchangeName, pair, period) {
    var req = {type:ReqType.ReqType_SubscribeSpotDepth, exchange_name: exchangeName, currency_pair: pair, period: period}
    var rsp = udsRequest(client, req)
    return rsp
}

function SubscribeSpotTicker(client, exchangeName, pair, period) {
    var req = {type:ReqType.ReqType_SubscribeSpotTicker, exchange_name: exchangeName, currency_pair: pair, period: period}
    var rsp = udsRequest(client, req)
    return rsp
}

function GetFutureDepth(client, exchangeName, contractType, pair) {
    var req = {type:ReqType.ReqType_GetFutureDepth, exchange_name: exchangeName, contract_type: contractType, currency_pair: pair}
    var rsp = udsRequest(client, req)
    if(rsp === null) {
        return null
    }
    return {Asks:rsp.AskList, Bids:rsp.BidList, Time:rsp.UTime, Info:rsp.rsp}
}

function GetFutureTicker(client, exchangeName, contractType, pair) {
    var req = {type:ReqType.ReqType_GetFutureTicker, exchange_name: exchangeName, contract_type: contractType, currency_pair: pair}
    var rsp = udsRequest(client, req)
    if(rsp === null) {
        return null
    }
    return {
        Last:parseFloat(rsp.last), 
        Buy:parseFloat(rsp.buy), 
        Sell:parseFloat(rsp.sell), 
        Volume:parseFloat(rsp.vol), 
        Time:parseFloat(rsp.date), 
        High:parseFloat(rsp.high), 
        Low:parseFloat(rsp.low), 
        Info:rsp
    }
}

function SubscribeFutureDepth(client, exchangeName, contractType, pair, period) {
    var req = {type:ReqType.ReqType_SubscribeFutureDepth, exchange_name: exchangeName, contract_type: contractType, currency_pair: pair, period: period}
    var rsp = udsRequest(client, req)
    return rsp
}

function SubscribeFutureTicker(client, exchangeName, contractType, pair, period) {
    var req = {type:ReqType.ReqType_SubscribeFutureTicker, exchange_name: exchangeName, contract_type: contractType, currency_pair: pair, period: period}
    var rsp = udsRequest(client, req)
    return rsp
}

var MarketCenterClient = (function() {
    function MarketCenterClient() {
        if (typeof udspath === 'undefined' || udspath === '') {
            throw 'udspath not defined'
        }
        this.client = newUDSClient()
        this.list = GetSupportList(this.client)
        Log("this.list:" + this.list)
    }

    MarketCenterClient.prototype.GetSpotTicker = function(exchangeName, pair) {
        if (typeof exchangeName === 'undefined' || exchangeName === '') {
            throw 'GetSpotTicker exchangeName not defined'
        }
        if (typeof pair === 'undefined' || pair === '') {
            throw 'GetSpotTicker pair not defined'
        }
        return GetSpotTicker(this.client, exchangeName, pair)
    }

    MarketCenterClient.prototype.GetSpotDepth = function(exchangeName, pair) {
        if (typeof exchangeName === 'undefined' || exchangeName === '') {
            throw 'GetSpotDepth exchangeName not defined'
        }
        if (typeof pair === 'undefined' || pair === '') {
            throw 'GetSpotDepth pair not defined'
        }
    return GetSpotDepth(this.client, exchangeName, pair)
    }

    MarketCenterClient.prototype.SubscribeSpotDepth = function(exchangeName, pair, period) {
        if(typeof(period) === 'undefined') {
            period = 200
        }
        if (typeof exchangeName === 'undefined' || exchangeName === '') {
            throw 'SubscribeSpotDepth exchangeName not defined'
        }
        if (typeof pair === 'undefined' || pair === '') {
            throw 'SubscribeSpotDepth pair not defined'
        }
        var found = false
        _.each(this.list, function(item) {
            if (item === exchangeName) {
                found = true
                return false
            }
        })

        if(!found) {
            throw 'exchange ('+ exchangeName +') not support, please check it again, https://github.com/goex-top/market_center#support-exchanges'
        }
        return SubscribeSpotDepth(this.client, exchangeName, pair, period)
    }

    MarketCenterClient.prototype.SubscribeSpotTicker = function(exchangeName, pair, period) {
        if(typeof(period) === 'undefined') {
            period = 200
        }
        if (typeof exchangeName === 'undefined' || exchangeName === '') {
            throw 'SubscribeSpotTicker exchangeName not defined'
        }
        if (typeof pair === 'undefined' || pair === '') {
            throw 'SubscribeSpotTicker pair not defined'
        }
      var found = false
        _.each(this.list, function(item) {
            if (item === exchangeName) {
                found = true
                return false
            }
        })

        if(!found) {
            throw 'exchange ('+ exchangeName +') not support, please check it again, https://github.com/goex-top/market_center#support-exchanges'
        }
        return SubscribeSpotTicker(this.client, exchangeName, pair, period)
    }


    MarketCenterClient.prototype.GetFutureTicker = function(exchangeName, contractType, pair) {
        if (typeof exchangeName === 'undefined' || exchangeName === '') {
            throw 'GetFutureTicker exchangeName not defined'
        }
        if (typeof pair === 'undefined' || pair === '') {
            throw 'GetFutureTicker pair not defined'
        }
     return GetFutureTicker(this.client, exchangeName, contractType, pair)
    }

    MarketCenterClient.prototype.GetFutureDepth = function(exchangeName, contractType, pair) {
        if (typeof exchangeName === 'undefined' || exchangeName === '') {
            throw 'GetFutureDepth exchangeName not defined'
        }
        if (typeof pair === 'undefined' || pair === '') {
            throw 'GetFutureDepth pair not defined'
        }
     return GetFutureDepth(this.client, exchangeName, contractType, pair)
    }

    MarketCenterClient.prototype.SubscribeFutureDepth = function(exchangeName, contractType, pair, period) {
        if(typeof(period) === 'undefined') {
            period = 200
        }
        if (typeof exchangeName === 'undefined' || exchangeName === '') {
            throw 'SubscribeFutureDepth exchangeName not defined'
        }
        if (typeof pair === 'undefined' || pair === '') {
            throw 'SubscribeFutureDepth pair not defined'
        }
     var found = false
        _.each(this.list, function(item) {
            if (item === exchangeName) {
                found = true
                return false
            }
        })

        if(!found) {
            throw 'exchange ('+ exchangeName +') not support, please check it again, https://github.com/goex-top/market_center#support-exchanges'
        }
        return SubscribeFutureDepth(this.client, exchangeName, contractType, pair, period)
    }

    MarketCenterClient.prototype.SubscribeFutureTicker = function(exchangeName, contractType, pair, period) {
        if(typeof(period) === 'undefined') {
            period = 200
        }
        if (typeof exchangeName === 'undefined' || exchangeName === '') {
            throw 'SubscribeFutureTicker exchangeName not defined'
        }
        if (typeof pair === 'undefined' || pair === '') {
            throw 'SubscribeFutureTicker pair not defined'
        }
     var found = false
        _.each(this.list, function(item) {
            if (item === exchangeName) {
                found = true
                return false
            }
        })

        if(!found) {
            throw 'exchange ('+ exchangeName +') not support, please check it again, https://github.com/goex-top/market_center#support-exchanges'
        }
        return SubscribeFutureTicker(this.client, exchangeName, contractType, pair, period)
    }

    MarketCenterClient.prototype.GetSupportList = function() {
        return GetSupportList(this.client)
    }
    return MarketCenterClient
})()

$.NewMarketCenterClient = function() {
    return new MarketCenterClient()
}

function main() {
    mcc = $.NewMarketCenterClient()
    Log('support list'+mcc.GetSupportList())
    mcc.SubscribeSpotDepth('binance.com', 'BTC_USDT', 200)
    Sleep(1000)
    Log(mcc.GetSpotDepth('binance.com', 'BTC_USDT'))
    mcc.SubscribeSpotTicker('binance.com', 'BTC_USDT', 200)
    Sleep(1000)
    Log(mcc.GetSpotTicker('binance.com', 'BTC_USDT'))
}
  

---

• Modelo de diagrama de indicadores MACD em Python
• Estratégias de praia btc versão instantânea
• Modelo de moeda
• Robot Ctrl (estratégias de ensino)
• Taxa de negociação de taxa quantitativa
• A estratégia de equilíbrio da plataforma de folha de Python (instruções)
• Centro de Negócios atrasado
• Partilhar referências de modelos de rastreamento de erros
• Bybit Algorithm Plug - VWAP (BTC)
• Python versão multi-variedade de estratégias de perseguição e queda.
• A estratégia de sequestro e queda do Python (instruções)
• A estratégia de grelha simples em Python.
• Estratégias de teste de opções da Deribit
• A política de desbloqueio do FMEX em 1 BTC, após o mercado ficar vazio
• A partir de 1 BTC, a fmex iniciou uma estratégia de desbloqueio de múltiplos cabeças.
• Função de hedge simples
• Estratégias de salto triciclo V2.0_ Testes_Ponto a Ponto
• Redes de nevão - 7 * 24 horas robô de negociação, atualizando o efeito do disco real todos os dias
• Estratégias de ensino TCI Estratégias de transplante de línguas

---

17880207677O que é?

17880207677Como é que isto funciona?

Brinquedos de chocolateE o adiamento?

FmzeroVeja os resultados dos testes em https://www.fmz.com/strategy/183009 para testar você mesmo.

Fmzero https://www.fmz.com/strategy/183009

FmzeroO tempo de espera do cliente para o centro pode ser praticamente ignorado.