338 lines
9.9 KiB
TypeScript
338 lines
9.9 KiB
TypeScript
/* Imports */
|
|
import {or} from "ajv/dist/compile/codegen";
|
|
import axios from "axios";
|
|
|
|
import {FetchedQuestion, Platform} from ".";
|
|
import {QuestionOption} from "../../common/types";
|
|
import toMarkdown from "../utils/toMarkdown";
|
|
import { average } from "../../utils";
|
|
|
|
/* Definitions */
|
|
const platformName = "insight";
|
|
const marketsEnpoint = "https://insightprediction.com/api/markets?orderBy=is_resolved&sortedBy=asc";
|
|
const getMarketEndpoint = (id : number) => `https://insightprediction.com/api/markets/${id}`;
|
|
const SPORTS_CATEGORIES = [
|
|
'World Cup',
|
|
'MLB',
|
|
'Futures',
|
|
'Sports',
|
|
'EPL',
|
|
'Golf',
|
|
'NHL',
|
|
'College Football'
|
|
]
|
|
|
|
/* Support functions */
|
|
|
|
// Stubs
|
|
const excludeMarketFromTitle = (title : any) => {
|
|
if (!!title) {
|
|
return title.includes(" vs ") || title.includes(" Over: ") || title.includes("NFL") || title.includes("Will there be a first time winner") || title.includes("Premier League")
|
|
} else {
|
|
return true
|
|
}
|
|
}
|
|
|
|
const hasActiveYesNoOrderBook = (orderbook : any) => {
|
|
if (!!orderbook) {
|
|
let yes = !!orderbook.yes && !!orderbook.yes.buy && Array.isArray(orderbook.yes.buy) && orderbook.yes.buy.length != 0 && !!orderbook.yes.buy[0].price && !!orderbook.yes.sell && Array.isArray(orderbook.yes.sell) && orderbook.yes.sell.length != 0 && !!orderbook.yes.sell[0].price
|
|
let no = !!orderbook.no && !!orderbook.no.buy && Array.isArray(orderbook.no.buy) && orderbook.no.buy.length != 0 && !!orderbook.no.buy[0].price && !!orderbook.no.sell && Array.isArray(orderbook.no.sell) && orderbook.no.sell.length != 0 && !!orderbook.no.sell[0].price
|
|
return yes && no
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
const isBinaryQuestion = (data : any) => Array.isArray(data) && data.length == 1
|
|
|
|
const geomMean = (a : number, b : number) => Math.sqrt(a * b)
|
|
|
|
const processRelativeUrls = (a : string) => a.replaceAll("] (/", "](http://insightprediction.com/").replaceAll("](/", "](http://insightprediction.com/")
|
|
|
|
const processDescriptionText = (text : any) => {
|
|
if (typeof text === 'string') {
|
|
return processRelativeUrls(toMarkdown(text))
|
|
} else {
|
|
return ""
|
|
}
|
|
}
|
|
|
|
const getOrderbookPrize = (orderbook : any) => {
|
|
let yes_min_cents = orderbook.yes.buy[0].price
|
|
let yes_max_cents = orderbook.yes.sell[0].price
|
|
let yes_min = Number(yes_min_cents.slice(0, -1))
|
|
let yes_max = Number(yes_max_cents.slice(0, -1))
|
|
let yes_price_orderbook = geomMean(yes_min, yes_max)
|
|
return yes_price_orderbook
|
|
}
|
|
|
|
const getAnswerProbability = (answer : any) => {
|
|
let orderbook = answer.orderbook
|
|
let latest_yes_price = answer.latest_yes_price
|
|
if (!! orderbook && hasActiveYesNoOrderBook(orderbook)) {
|
|
let yes_price_orderbook = getOrderbookPrize(orderbook)
|
|
let yes_probability = (latest_yes_price ? geomMean(latest_yes_price, yes_price_orderbook) : yes_price_orderbook) / 100
|
|
return yes_probability
|
|
} else if (!! latest_yes_price) {
|
|
return latest_yes_price / 100
|
|
} else {
|
|
return -1
|
|
}
|
|
}
|
|
|
|
// Fetching
|
|
async function fetchPage(bearer: string, pageNum: number) {
|
|
let pageUrl = `${marketsEnpoint}&page=${pageNum}`
|
|
console.log(`Fetching page #${pageNum}`) // : ${pageUrl}
|
|
const response = await axios({
|
|
url: pageUrl, // &orderBy=is_resolved&sortedBy=desc`,
|
|
method: "GET",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
Accept: "application/json",
|
|
Authorization: `Bearer ${bearer}`
|
|
}
|
|
}).then((res) => res.data);
|
|
// console.log(response);
|
|
return response;
|
|
}
|
|
|
|
async function fetchMarket(bearer: string, marketId: number) {
|
|
const response = await axios({
|
|
url: getMarketEndpoint(marketId),
|
|
method: "GET",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
Accept: "application/json",
|
|
Authorization: `Bearer ${bearer}`
|
|
}
|
|
}).then((res) => res.data);
|
|
// console.log(response)
|
|
return response;
|
|
|
|
}
|
|
|
|
const processMarket = (market : any) => {
|
|
let options: FetchedQuestion["options"] = []
|
|
|
|
if (!!market && !!market.answer && !!market.answer.data) {
|
|
let data = market.answer.data
|
|
if (isBinaryQuestion(data)) { // Binary questions
|
|
let answer = data[0]
|
|
let probability = getAnswerProbability(answer)
|
|
if (probability != -1) {
|
|
options = [
|
|
{
|
|
name: "Yes",
|
|
probability: probability,
|
|
type: "PROBABILITY"
|
|
}, {
|
|
name: "No",
|
|
probability: 1 - probability,
|
|
type: "PROBABILITY"
|
|
},
|
|
];
|
|
}
|
|
} else { // non binary question
|
|
for (let answer of data) {
|
|
let probability = getAnswerProbability(answer)
|
|
if (probability != -1) {
|
|
let newOption: QuestionOption = ({
|
|
name: String(answer.title),
|
|
probability: probability,
|
|
type: "PROBABILITY"
|
|
});
|
|
options.push(newOption)
|
|
}
|
|
}
|
|
}
|
|
if (!! options && Array.isArray(options) && options.length > 0) {
|
|
const id = `${platformName}-${
|
|
market.id
|
|
}`
|
|
const result: FetchedQuestion = {
|
|
id: id,
|
|
title: market.title,
|
|
url: market.url,
|
|
description: processDescriptionText(market.rules),
|
|
options,
|
|
qualityindicators: market.coin_id == "USD" ? (
|
|
{volume: market.volume}
|
|
) : ({})
|
|
};
|
|
return result;
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
|
|
async function fetchAllMarkets(bearer: string) {
|
|
let pageNum = 1
|
|
let markets = []
|
|
let categories = []
|
|
let isEnd = false
|
|
while (! isEnd) {
|
|
let page = await fetchPage(bearer, pageNum)
|
|
// console.log(JSON.stringify(page, null, 2))
|
|
let data = page.data
|
|
if (!! data && Array.isArray(data) && data.length > 0) {
|
|
let lastMarket = data[data.length - 1]
|
|
let isLastMarketResolved = lastMarket.is_resolved
|
|
if (isLastMarketResolved == true) {
|
|
isEnd = true
|
|
}
|
|
let newMarkets = data.filter(market => !market.is_resolved && !market.is_expired && ! excludeMarketFromTitle(market.title))
|
|
for (let initMarketData of newMarkets) {
|
|
let fullMarketDataResponse = await fetchMarket(bearer, initMarketData.id)
|
|
let fullMarketData = fullMarketDataResponse.data
|
|
let processedMarketData = processMarket(fullMarketData)
|
|
|
|
if (processedMarketData != null && ! SPORTS_CATEGORIES.includes(fullMarketData.category)) {
|
|
console.log(`- Adding: ${
|
|
fullMarketData.title
|
|
}`)
|
|
console.group()
|
|
console.log(fullMarketData)
|
|
console.log(JSON.stringify(processedMarketData, null, 2))
|
|
console.groupEnd()
|
|
|
|
markets.push(processedMarketData)
|
|
}
|
|
|
|
let category = fullMarketData.category
|
|
categories.push(category)
|
|
|
|
}
|
|
} else {
|
|
isEnd = true
|
|
} pageNum = pageNum + 1
|
|
}
|
|
console.log(markets)
|
|
console.log(categories)
|
|
return markets
|
|
}
|
|
/*
|
|
async function fetchQuestionStats(bearer : string, marketId : number) {
|
|
const response = await axios({
|
|
url: getMarketEndpoint(marketId),
|
|
method: "GET",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
Accept: "application/json",
|
|
Authorization: `Bearer ${bearer}`
|
|
}
|
|
}).then((res) => res.data);
|
|
// console.log(response)
|
|
return response;
|
|
}
|
|
|
|
|
|
|
|
async function fetchData(bearer : string) {
|
|
let pageNum = 1;
|
|
let reachedEnd = false;
|
|
let results = [];
|
|
while (! reachedEnd) {
|
|
let newPage = await fetchPage(bearer, pageNum);
|
|
let newPageData = newPage.data;
|
|
let marketsFromPage = []
|
|
for (let market of newPageData) {
|
|
let response = await fetchQuestionStats(bearer, market.id);
|
|
let marketData = response.data
|
|
let marketAnswer = marketData.answer.data
|
|
delete marketData.answer
|
|
// These are the options and their prices.
|
|
let marketOptions = marketAnswer.map(answer => {
|
|
return({name: answer.title, probability: answer.latest_yes_price, type: "PROBABILITY"})
|
|
})
|
|
marketsFromPage.push({
|
|
... marketData,
|
|
options: marketOptions
|
|
});
|
|
}
|
|
|
|
let finalObject = marketsFromPage
|
|
|
|
console.log(`Page = #${pageNum}`);
|
|
// console.log(newPageData)
|
|
console.dir(finalObject, {depth: null});
|
|
results.push(... finalObject);
|
|
|
|
let newPagination = newPage.meta.pagination;
|
|
if (newPagination.total_pages == pageNum) {
|
|
reachedEnd = true;
|
|
} else {
|
|
pageNum = pageNum + 1;
|
|
}
|
|
}
|
|
return results
|
|
}
|
|
|
|
async function processPredictions(predictions : any[]) {
|
|
let results = await predictions.map((prediction) => {
|
|
const id = `${platformName}-${
|
|
prediction.id
|
|
}`;
|
|
const probability = prediction.probability;
|
|
const options: FetchedQuestion["options"] = [
|
|
{
|
|
name: "Yes",
|
|
probability: probability,
|
|
type: "PROBABILITY"
|
|
}, {
|
|
name: "No",
|
|
probability: 1 - probability,
|
|
type: "PROBABILITY"
|
|
},
|
|
];
|
|
const result: FetchedQuestion = {
|
|
id,
|
|
title: prediction.title,
|
|
url: "https://example.com",
|
|
description: prediction.description,
|
|
options,
|
|
qualityindicators: {
|
|
// other: prediction.otherx,
|
|
// indicators: prediction.indicatorx,
|
|
}
|
|
};
|
|
return result;
|
|
});
|
|
return results; // resultsProcessed
|
|
}
|
|
*/
|
|
/* Body */
|
|
export const insight: Platform = {
|
|
name: platformName,
|
|
label: "Insight Prediction",
|
|
color: "#ff0000",
|
|
version: "v1",
|
|
async fetcher() {
|
|
let bearer = process.env.INSIGHT_BEARER;
|
|
if (!! bearer) {
|
|
let data = await fetchAllMarkets(bearer);
|
|
return data
|
|
} else {
|
|
throw Error("No INSIGHT_BEARER available in environment")
|
|
}
|
|
// let results: FetchedQuestion[] = []; // await processPredictions(data); // somehow needed
|
|
// return results;
|
|
},
|
|
calculateStars(data) {
|
|
let nuno = () => {
|
|
if((data.qualityindicators.volume || 0) > 10000){
|
|
return 4
|
|
} else if((data.qualityindicators.volume || 0) > 1000){
|
|
return 3
|
|
} else{
|
|
return 2
|
|
}
|
|
}
|
|
let eli = () => null;
|
|
let misha = () => null;
|
|
let starsDecimal = average([nuno()]); //, eli(data), misha(data)])
|
|
let starsInteger = Math.round(starsDecimal);
|
|
return starsInteger;
|
|
}
|
|
};
|