Delay in API Res #230
Description
I'm trying to make a request of buy contract in a async ticksHistoryResponse, who is called in every response of the async ticksResponse. This ticksHistoryResponse function contains a condition that analyze the last 10 open, high, low and close prices of candles and the currently epoch, and make a buy request when all the condition are satisfied.
This function works good when i get in the computer and when i interact with it.
However, after a period of not interacting with the computer, the server responses are out of sync within 2 minutes, and the logs displayed on the console stop showing real-time information and show information from exactly 2 minutes ago. This causes purchase requests to be delayed.
I tried keeping tabs always on by enabling Chrome browser performance functions, but it didn't work. I'm calling the async functions through the await. Below is the script:
import DerivAPIBasic from "https://cdn.skypack.dev/@deriv/deriv-api/dist/DerivAPIBasic";
const token = "my_token";
const app_id = my_number_app;
function createWebSocket(app_id) {
let connection;
function connect() {
connection = new WebSocket(
wss://ws.derivws.com/websockets/v3?app_id=${app_id},
);
connection.onopen = function (event) {
console.log("Conexão estabelecida:", event);
connection;
};
connection.onmessage = function (event) {
console.log("Mensagem recebida:", event.data);
};
connection.onclose = function (event) {
console.log("Conexão fechada:", event);
reconnect();
};
connection.onerror = function (event) {
console.error("Erro na conexão:", event);
reconnect();
};
return connection;
}
function reconnect() {
console.log("Tentando reconectar em 500 milisegundos...");
setTimeout(() => {
connect();
}, 500); // Tentar reconectar após 500 milisegundos
}
// Inicializa a conexão
return connect();
}
const a1 = createWebSocket(app_id);
let api = new DerivAPIBasic({ connection: a1 });
const onCloseObservable = api.onClose();
const onOpenObservable = api.onOpen();
// Subscrever aos eventos de fechamento
onCloseObservable.subscribe(() => {
console.log("Conexão fechada. Tentando reconectar...");
setTimeout(() => {
try {
window.location.reload();
console.log("Método reload() chamado.");
} catch (error) {
console.error("Erro ao tentar reconectar:", error);
}
}, 1000); // Tempo de espera de 1 segundos
});
window.addEventListener("offline", () => {
console.log("O dispositivo está offline.");
window.location.reload();
});
// Subscrever aos eventos de abertura
onOpenObservable.subscribe(() => {
autorization();
subscribeTicks();
ping()
console.log("Conexão aberta.");
});
const autorizacao = {
authorize: "my_token",
};
const autorization = async () => {
await api.authorize(autorizacao);
};
const ticks_history_request = {
ticks_history: "Any_VIX",
adjust_start_time: 1,
count: 10,
end: "latest",
start: 1,
style: "candles",
granularity: 60,
};
const ticks_request = {
...ticks_history_request,
subscribe: 1,
};
const ping = () => {
setInterval(() => {
api.ping();
}, 15000);
};
const balance1 = {
balance: 1,
subscribe: 1,
account: "current",
loginid: "my_loginid",
};
const balance2 = async () => {
api.balance(balance1);
};
const observable = api.onMessage(); // Assumindo que api.onMessage() retorna um Observable
let saldo;
let saldoAtual;
let balancinha;
let balanca3
const subscription1 = observable.subscribe((message) => {
// Exibe os dados recebidos no console para depuração
// Verifica se a estrutura da mensagem está conforme o esperado
if (
message &&
message.name === 'message' &&
message.data &&
message.data.balance &&
message.data.balance.balance !== undefined
) {
saldo = message.data.balance.balance
saldoAtual = parseFloat(saldo.toFixed(2));
balancinha = saldoAtual * 0.01
balanca3 = parseFloat(balancinha.toFixed(2))
}
});
const createBuyContract = async () => {
const buyContract = {
buy: 1,
price: 25000,
parameters: {
contract_type: "CALLE",
amount: balanca3,
basis: "stake",
symbol: "Any_VIX",
currency: "USD",
duration: 1,
duration_unit: "m",
},
};
return buyContract;
};
const buy = async () => {
const contract = await createBuyContract(); // Espera a resolução da função assíncrona
const buy1 = api.buy(contract);
return buy1
};
let timeepoch
let timeepoch2
let timeepoch3
let logs
const subscription2 = observable.subscribe((message) => {
// Exibe os dados recebidos no console para depuração
logs = console.log(message)
// Verifica se a estrutura da mensagem está conforme o esperado
if (
message &&
message.name === 'message' &&
message.data &&
message.data.ohlc &&
message.data.ohlc.epoch !== undefined
) {
timeepoch = message.data.ohlc.epoch;
timeepoch2 = parseInt(timeepoch.toFixed())
timeepoch3 = timeepoch2 % 60
}
});
const tickSubscriber = () => api.subscribe(ticks_request);
const ticksHistoryResponse = async (res) => {
const data = JSON.parse(res.data);
if (data.error !== undefined) {
console.log("Error : ", data.error.message);
}
if (data.msg_type === "candles") {
if (
timeepoch3 = 0 &&
(data.candles[data.candles.length - x].open - data.candles[data.candles.length - x].close) / (data.candles[data.candles.length - x].high - data.candles[data.candles.length - x].low) >= 0.05 &&
data.candles[data.candles.length - x].open > data.candles[data.candles.length - x].close
) {
console.log("Buy");
console.log(timeepoch);
logs;
await buy();
} else {
console.log("Dbuy");
logs
}
}
}
const ticksResponse = async (res) => {
const data = JSON.parse(res.data);
// This example returns an object with a selected amount of past ticks.
if (data.error !== undefined) {
console.log("Error : ", data.error.message);
}
// Allows you to monitor ticks.
if (data.msg_type === "ohlc") {
await getTicksHistory();
}
if (data.msg_type === "ping") {
console.log("ping");
}
if (data.msg_type === "buy") {
console.log(data.buy);
}
if (data.msg_type === "authorize") {
console.log(data.authorize.email);
await balance2();
}
if (data.msg_type === "balance") {
console.log(data.balance.balance);
}
};
const subscribeTicks = async () => {
a1.addEventListener("message", ticksResponse);
await tickSubscriber();
};
const unsubscribeTicks = async () => {
a1.removeEventListener("message", ticksResponse, false);
await tickSubscriber().unsubscribe();
};
const getTicksHistory = async () => {
a1.addEventListener("message", ticksHistoryResponse);
await api.ticksHistory(ticks_history_request);
};
const subscribe_ticks_button = document.querySelector("#ticks");
subscribe_ticks_button.addEventListener("click", subscribeTicks);
const unsubscribe_ticks_button = document.querySelector("#ticks-unsubscribe");
unsubscribe_ticks_button.addEventListener("click", unsubscribeTicks);
const ticks_history_button = document.querySelector("#ticks-history");
ticks_history_button.addEventListener("click", getTicksHistory);