polkamarkets-js 3.1.1 → 3.1.2

package/lib/reality-eth-monorepo/packages/cli-tools/add_owner.js

@@ -0,0 +1,24 @@
+const rc_common = require('./rc_common.js');
+
+rc_common.checkArgumentLength(5, 'Usage: node add_owner.js <nonce> <gas_price_in_gwei> <owner>');
+
+if (!rc_common.configParam('multisig_wallet')) {
+    console.log('You cannot add an owner unless you have configured a multisig wallet in config.json');
+    process.exit(1);
+}
+const wal = rc_common.walletContract();
+const addr = rc_common.sanitizeAddress(process.argv[4]);
+
+const params = rc_common.commonParams(process.argv);
+console.log(params);
+console.log('Generating a transaction to add the owner ' + addr + ' to the wallet ' + wal.address);
+
+//console.log('GWEI_TO_WEI', rc_common.GWEI_TO_WEI);
+
+const req = wal.addOwner.request(addr);
+const data = req.params[0].data;
+
+const stx = rc_common.serializedTX(params, wal, data);
+
+rc_common.output(stx);
+

package/lib/reality-eth-monorepo/packages/cli-tools/allocate_splitter_funds.js

@@ -0,0 +1,15 @@
+const rc_common = require('./rc_common.js');
+
+rc_common.checkArgumentLength(4, 'Usage: node allocate_splitter_funds.js <nonce> <gas_price_in_gwei>');
+
+const params = rc_common.commonParams(process.argv);
+console.log(params);
+console.log('Generating a transaction to withdraw funds from the arbitrator contract to the splitter wallet');
+
+const wal = rc_common.splitterContract();
+const req = wal.allocate.request();
+const data = req.params[0].data;
+
+const stx = rc_common.serializedTX(params, wal, data, 600000, true);
+
+rc_common.output(stx);

package/lib/reality-eth-monorepo/packages/cli-tools/arbitrate.js

@@ -0,0 +1,30 @@
+
+const rc_common = require('./rc_common.js');
+const arbitration_requests = require(rc_common.configParam('arbitration_requests_file'));
+
+const arb = rc_common.arbContract();
+const rc = rc_common.rcContract();
+const rc_address = rc.address;
+
+rc_common.checkArgumentLength(5, 'Usage: node arbitrate.js <nonce> <gas_price_in_gwei> <entry_id>');
+
+const params = rc_common.commonParams(process.argv);
+console.log(params);
+
+const item = parseInt(process.argv[4]);
+if (item > arbitration_requests.length) throw 'Item ID higher than length of request list';
+
+const req_item = arbitration_requests[item];
+const question_id = rc_common.sanitizeBytes32(req_item[0], 'question_id', false);
+const answer_data = rc_common.sanitizeBytes32(req_item[1], 'answer_data', true);
+const answerer_address = rc_common.sanitizeAddress(req_item[2]);
+
+console.log('Generating a transaction to set question_id ' + req_item[0]+ ' to ' + req_item[1] + ' and answerer to ' + req_item[2]);
+
+const req = arb.submitAnswerByArbitrator.request(req_item[0], req_item[1], req_item[2]);
+const data = req.params[0].data;
+
+const stx = rc_common.serializedTX(params, arb, data);
+
+rc_common.output(stx);
+

package/lib/reality-eth-monorepo/packages/cli-tools/broadcast.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+# Quick-and-dirty script to send output to a local node for quicker testing
+# Usually your node should be offline so you can"t do this
+# Raw TX output should be the first line beginning "0x"
+
+while read LINE; do
+    if [[ $LINE == 0x* ]] 
+    then
+        #echo $LINE
+        curl -X POST --data "{\"jsonrpc\":\"2.0\",\"method\":\"eth_sendRawTransaction\",\"params\":[\"$LINE\"],\"id\":1}" http://localhost:8545
+        exit
+    fi
+done < /dev/stdin
+

package/lib/reality-eth-monorepo/packages/cli-tools/call.js

@@ -0,0 +1,96 @@
+const fs = require('fs');
+const ethers = require('ethers');
+const rc_contracts = require('@reality.eth/contracts');
+
+var undef;
+
+const defaultConfigs = {
+    //maxFeePerGas:         81000000000,
+    //maxFeePerGas:         1000000008,
+    //maxPriorityFeePerGas:  1000000000,
+    //gasPrice: 70000000000,
+    //gasLimit: 1000000,
+    //etherscanApiKey: 'TPA4BFDDIH8Q7YBQ4JMGN6WDDRRPAV6G34'
+    // gasLimit: 155734867 // arbitrum
+}
+const task = process.argv[2]
+const version = process.argv[3]
+const chain_id = process.argv[4]
+const token_name = process.argv[5]
+
+// For askQuestion
+const delim = '\u241f';
+//const qtext = 'reality' + delim + 'QmVSKvdV5TUBQkrqstNZtUAyTepAMbDqvhh4zP3SJKRXAs';
+const qtext = 'rapture';
+const timeout_val = ethers.BigNumber.from(86401);
+const opening_ts = ethers.BigNumber.from(0);
+const arbitrator = '0xf72cfd1b34a91a64f9a98537fe63fbab7530adca';
+
+// for createTemplate
+const tmpl = '{"title":"When will %s happen?", "type": "datetime", "precision":"i", "lang": "en_US", "category": "test"}';
+
+if (!task || !version || !chain_id || !token_name) {
+    usage_error("Usage: node call.js <askQuestion|createTemplate> <2.0|2.1|3.0> <chain_id> <token> [<template_id>]");
+}
+
+let template_id;
+if (task != 'createTemplate') {
+    template_id = ethers.BigNumber.from(parseInt(process.argv[6]));
+}
+
+const chain_info = rc_contracts.chainData(chain_id);
+const rpc_node = chain_info['hostedRPC'];
+
+//const chain_name = (chain_info['network']== 'mainnet' && 'shortName' in chain_info) ? chain_info['shortName'] : chain_info['network'];
+const chain_name = chain_info['network_name'];
+const config = rc_contracts.realityETHConfig(chain_id, token_name, version);
+const inst = rc_contracts.realityETHInstance(config);
+
+const is_infura = rpc_node.includes('infura');
+const provider = is_infura ? new ethers.providers.InfuraProvider(chain_id) : new ethers.providers.JsonRpcProvider(rpc_node);
+
+console.log('provider', provider);
+
+const ctn = new ethers.Contract(config.address, inst.abi, provider);
+
+const priv = fs.readFileSync('/home/ed/secrets/' + chain_name + '.sec', 'utf8').replace(/\n/, '')
+const signer = new ethers.Wallet(priv, provider);
+
+const signed_ctn = ctn.connect(signer);
+
+function usage_error(msg) {
+    throw msg;
+}
+
+doCall();
+
+async function doCall() {
+    await waitForGas(provider);
+    const conf = defaultConfigs;
+    conf['value'] = ethers.BigNumber.from(0);
+    if (task == 'askQuestion') {
+        const tx_response = await signed_ctn.functions.askQuestion(template_id, qtext, arbitrator, timeout_val, opening_ts, 0, conf);
+        console.log(tx_response);
+    } else if (task == 'createTemplate') {
+        const tx_response = await signed_ctn.functions.createTemplate(tmpl);
+        console.log(tx_response);
+    }
+}
+
+async function waitForGas(provider) {
+    if (!defaultConfigs.maxFeePerGas) {
+        return true;
+    }
+    // console.log('in waitForGas');
+    const sleep = (milliseconds) => {
+      return new Promise(resolve => setTimeout(resolve, milliseconds))
+    }
+
+    const f = await provider.getFeeData()
+    // console.log('fee', f)
+    if (f.gasPrice.gt(ethers.BigNumber.from(defaultConfigs.maxFeePerGas))) {
+        console.log('Gas is too expensive, got', f.gasPrice.toString(), 'but you will only pay ', defaultConfigs.maxFeePerGas, ', retrying...')
+        await sleep(2000);
+        await waitForGas(provider);
+    } 
+}

package/lib/reality-eth-monorepo/packages/cli-tools/call_withdraw.js

@@ -0,0 +1,19 @@
+const rc_common = require('./rc_common.js');
+
+rc_common.checkArgumentLength(4, 'Usage: node call_withdraw.js <nonce> <gas_price_in_gwei>');
+
+const params = rc_common.commonParams(process.argv);
+
+const rc = rc_common.rcContract();
+const arb = rc_common.arbContract();
+
+console.log(params);
+console.log('Generating a transaction to withdraw funds from the reality check contract at ' + rc.address + ' to the arbitrator contract ' + arb.address);
+
+const req = arb.callWithdraw.request();
+const data = req.params[0].data;
+
+const stx = rc_common.serializedTX(params, arb, data);
+
+rc_common.output(stx);
+

package/lib/reality-eth-monorepo/packages/cli-tools/config.1.json

@@ -0,0 +1,13 @@
+{
+    "network_id": 1,
+    "key_file": "./secrets/arbitrator.sec",
+    "arbitration_requests_file": "./requests/arbitration.json",
+    "contract_dir": "./../truffle/build/contracts",
+    "min_nonce": 0,
+    "max_nonce": 100,
+    "min_gas_price_in_gwei": 1,
+    "max_gas_price_in_gwei": 100,
+    "gas_limit": 900000,
+    "multisig_wallet": "0x7006c40e5a759876a10852f3b78c7c0874967c22",
+    "splitter_wallet": "0xd6455e86834563Bd11bbEC3Ad2A4969197ba4666"
+}

package/lib/reality-eth-monorepo/packages/cli-tools/config.example.json

@@ -0,0 +1,13 @@
+{
+    "network_id": 123411710,
+    "key_file": "./secrets/arbitrator.sec",
+    "arbitration_requests_file": "./requests/arbitration.json",
+    "contract_dir": "./../truffle/build/contracts",
+    "min_nonce": 0,
+    "max_nonce": 100,
+    "min_gas_price_in_gwei": 1,
+    "max_gas_price_in_gwei": 100,
+    "gas_limit": 900000,
+    "multisig_wallet": null,
+    "splitter_wallet": null 
+}

package/lib/reality-eth-monorepo/packages/cli-tools/confirm_transaction.js

@@ -0,0 +1,24 @@
+const rc_common = require('./rc_common.js');
+
+rc_common.checkArgumentLength(5, 'Usage: node confirm_transaction.js <nonce> <gas_price_in_gwei> <id>');
+
+if (!rc_common.configParam('multisig_wallet')) {
+    console.log('You cannot confirm a transaction unless you have configured a multisig wallet in config.json');
+    process.exit(1);
+}
+const wal = rc_common.walletContract();
+const id = parseInt(process.argv[4]);
+
+const params = rc_common.commonParams(process.argv);
+console.log(params);
+console.log('Generating a transaction to approve entry ' + id + ' of the wallet ' + wal.address);
+
+//console.log('GWEI_TO_WEI', rc_common.GWEI_TO_WEI);
+
+const req = wal.confirmTransaction.request(id);
+const data = req.params[0].data;
+
+const stx = rc_common.serializedTX(params, wal, data, 200000, true);
+
+rc_common.output(stx);
+

package/lib/reality-eth-monorepo/packages/cli-tools/load_questions_from_graph.js

@@ -0,0 +1,288 @@
+'use strict';
+
+const ethers = require("ethers");
+const axios = require('axios');
+
+const rc_question = require('@reality.eth/reality-eth-lib/formatters/question.js');
+const rc_template = require('@reality.eth/reality-eth-lib/formatters/template.js');
+const rc_contracts = require('@reality.eth/contracts');
+
+if(process.argv.length < 3) {
+    console.log('Usage: node load_questions_from_graph.js <chain_id> <offset|all> <num_per_fetch> <filter> <order>');
+}
+
+let chain_id = parseInt(process.argv[2]);
+let offset;
+let do_fetch_all = false;
+if (process.argv[3] == 'all') {
+    offset = 0;
+    do_fetch_all = true;
+} else {
+    offset = parseInt(process.argv[3]);
+}
+let num_display = parseInt(process.argv[4]);
+let filter_str = process.argv[5];
+let order = process.argv[6];
+let no_ts = true;
+
+offset = offset ? offset : 0;
+num_display = num_display ? num_display : 1000;
+filter_str = (filter_str == '') ? filter_str : '{}';
+
+let CONTRACT_CONFIGS = {};
+const chain_info = rc_contracts.chainData(chain_id);
+const tokens = rc_contracts.chainTokenList(chain_id);
+for(const t in tokens) {
+    const configs = rc_contracts.realityETHConfigs(chain_id, t); 
+    for(const c in configs) {
+        CONTRACT_CONFIGS[c.toLowerCase()] = configs[c];
+    }
+}
+
+if (do_fetch_all) {
+    fetch_all();
+} else {
+    fetchAndDisplayQuestionFromGraph(chain_info, offset, num_display, filter_str, order); 
+}
+
+async function fetch_all() {
+    let some_left = true;
+    while(some_left) {
+        some_left = await fetchAndDisplayQuestionFromGraph(chain_info, offset, num_display, filter_str, order); 
+        offset = offset + num_display;    
+    }
+}
+
+async function fetchAndDisplayQuestionFromGraph(CHAIN_INFO, offset, num_display, filter_str, order) {
+
+    const ts_now = parseInt(new Date()/1000);
+    // const contract_str = JSON.stringify(displayed_contracts);
+    /*
+    const ranking_where = {
+        'questions-active-answered': `{${extra_filter_str} contract_in: ${contract_str}, isPendingArbitration: false, answerFinalizedTimestamp_gt: ${ts_now}, openingTimestamp_lte: ${ts_now}}`,
+        'questions-active-unanswered': `{${extra_filter_str} contract_in: ${contract_str}, isPendingArbitration: false, answerFinalizedTimestamp: null, openingTimestamp_lte: ${ts_now}}`,
+        'questions-upcoming': `{${extra_filter_str} contract_in: ${contract_str}, isPendingArbitration: false, openingTimestamp_gt: ${ts_now}}`,
+        'questions-resolved': `{${extra_filter_str} contract_in: ${contract_str}, answerFinalizedTimestamp_lt: ${ts_now}}`,
+        'questions-awaiting-arbitration': `{${extra_filter_str} contract_in: ${contract_str}, isPendingArbitration: true}`,
+    }
+
+    const ranking_order = {
+        'questions-active-answered': 'lastBond',
+        'questions-active-unanswered': 'createdTimestamp',
+        'questions-upcoming': 'createdTimestamp',
+        'questions-resolved': 'answerFinalizedTimestamp',
+        'questions-awaiting-arbitration': 'lastBond'
+    }
+    */
+
+    const network_graph_url = CHAIN_INFO.graphURL;
+    if (!network_graph_url) {
+        throw new Error('No graph endpoint found for the chain', chain_id); 
+    }
+    // console.log('graph url is ', network_graph_url);
+    const question_fetch_fields = questionFetchFields();
+    // const question_fetch_fields = 'questionId'
+
+        // questions(first: ${num_display}, skip: ${offset}, where: ${filter_str}, orderBy: ${order}, orderDirection: desc) {
+
+    const query = `
+      {
+        questions(first: ${num_display}, skip: ${offset}, where: ${filter_str}, orderDirection: desc) {
+            ${question_fetch_fields}
+        }
+      }  
+      `;
+    
+
+    // console.log(query);
+    const fetched_ms = Date.now();
+
+    // console.log('sending graph query', query);
+    const res = await axios.post(network_graph_url, {query: query});
+    // console.log('graph res', res);
+    let found = false;
+    for (const q of res.data.data.questions) {
+        found = true;
+        handleQuestion(q, fetched_ms)
+        // const question_posted = RCInstance(q.contract).filters.LogNewQuestion(q.questionId);
+        // const result = await RCInstance(q.contract).queryFilter(question_posted, parseInt(q.createdBlock), parseInt(q.createdBlock));
+    }
+    return found;
+}
+
+function handleQuestion(q, fetched_ms) {
+    const fq = filledQuestion(q, fetched_ms);
+    console.log(fq);
+}
+
+function filledAnswer(item, fetched_ms) {
+
+    // For now we make this look like what we get from a log event
+    let ans = {};
+    if (item.isCommitment) {
+        ans.commitment_id = item.commitmentId;
+        ans.is_commitment = true;
+        ans.revealed_block = item.revealedBlock
+    } else {
+        ans.is_commitment = false;
+        ans.commitment_id = null;
+        ans.revealed_block = null;
+    }
+    ans.answer = item.answer;
+    // ans.isUnrevealed = = item.isUnrevealed; // TODO: use this later
+    ans.bond = ethers.BigNumber.from(item.bond);
+    ans.history_hash = item.historyHash;
+
+    ans.user = item.user; 
+    ans.ts = ethers.BigNumber.from(item.timestamp);
+
+    // txid isn't filled from the graph, only from our unconfirmed transactions
+    ans.txid = item.txid;
+
+    if (!no_ts) {
+        ans.fetched_ms = fetched_ms;
+    }
+
+
+    return ans;
+
+}
+
+function filledQuestion(item, fetched_ms) {
+
+    let question = {'history_unconfirmed': []};
+
+    question.arbitrator = item.arbitrator;
+    question.question_id = item.questionId;
+    question.creation_ts = ethers.BigNumber.from(item.createdTimestamp);
+    question.question_creator = item.user;
+    question.question_created_block = item.createdBlock;
+    question.content_hash = item.contentHash;
+    question.question_text= item.data;
+    question.template_id = item.template.templateId;
+    question.block_mined = item.createdBlock;
+
+    if (!no_ts) {
+        question.fetched_ms = fetched_ms;
+    }
+
+    if (item.openingTimestamp) {
+        question.opening_ts = ethers.BigNumber.from(item.openingTimestamp);
+    } else {
+        question.opening_ts = ethers.BigNumber.from(0);
+    }
+
+    question.contract = item.contract;
+    question.version_number = CONTRACT_CONFIGS[question.contract.toLowerCase()].version_number;
+    if (item.reopens) {
+        question.reopener_of_question_id = item.reopens.id;
+    }
+    if (item.reopenedBy) {
+        question.reopened_by = item.reopenedBy.id;
+    }
+    //question.bounty = data.args['bounty'];
+
+    try {
+        // question.question_json = JSON.parse(item.json_str);
+        question.question_json = rc_question.populatedJSONForTemplate(item.template.questionText, item.data, true);
+        question.has_invalid_option = rc_question.hasInvalidOption(question.question_json, question.version_number);
+        question.has_too_soon_option = rc_question.hasAnsweredTooSoonOption(question.question_json, question.version_number);
+    } catch (e) {
+        console.log('error parsing json', e);
+        return null;
+        // question.question_json = null;
+    }
+  
+    if (item.answerFinalizedTimestamp) {
+        question.finalization_ts = ethers.BigNumber.from(item.answerFinalizedTimestamp); // GRAPH_TODO - check this is what we need
+    } else {
+        question.finalization_ts = ethers.BigNumber.from(0);
+    }
+
+    question.is_pending_arbitration = item.isPendingArbitration;
+    question.timeout = ethers.BigNumber.from(item.timeout);
+    question.bounty = ethers.BigNumber.from(item.bounty);
+    question.best_answer = item.currentAnswer;
+    question.bond = ethers.BigNumber.from(item.lastBond);
+    question.history_hash = item.historyHash;
+
+    if (!question.history_hash) {
+        question.history_hash = "0x0000000000000000000000000000000000000000000000000000000000000000";
+    }
+
+    question.min_bond = ethers.BigNumber.from(item.minBond);
+    question.history = [];
+    for(let respi in item.responses) {
+        question.history.push(filledAnswer(item.responses[respi], fetched_ms));
+    }
+    question.history = question.history.sort((a, b) => 
+        (a.bond.isZero() || ( a.bond.gt(b.bond) && !b.bond.isZero() ) ) 
+        ? 1 : -1);
+
+    return question;
+
+}
+
+function questionFetchFields() {
+    const txt = `
+        id,
+        questionId,
+        contract,
+        createdBlock,
+        createdTimestamp,
+        updatedBlock,
+        updatedTimestamp,
+        data,
+        qJsonStr,
+        qTitle,
+        qCategory,
+        qLang,
+        qType,
+        arbitrator,
+        user,
+        openingTimestamp,
+        timeout,
+        bounty,
+        currentAnswer,
+        currentAnswerBond,
+        currentAnswerTimestamp,
+        contentHash,
+        historyHash,
+        minBond,
+        lastBond,
+        cumulativeBonds,
+        arbitrationRequestedTimestamp,
+        arbitrationRequestedBy,
+        isPendingArbitration,
+        arbitrationOccurred,
+        answerFinalizedTimestamp,
+        currentScheduledFinalizationTimestamp,
+        template {
+            id, 
+            templateId, 
+            questionText
+        },
+        reopenedBy {
+          id
+        },
+        reopens {
+          id
+        },
+        responses {
+          id,
+          timestamp,
+          answer,
+          isUnrevealed,
+          isCommitment,
+          commitmentId,
+          bond,
+          user,
+          historyHash,
+          createdBlock,
+          revealedBlock
+        }
+    `;
+    return txt;
+}
+
+

package/lib/reality-eth-monorepo/packages/cli-tools/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@reality.eth/cli-tools",
+  "version": "1.4.27",
+  "description": "Command-line tools for interacting with the Reality.eth fact verification platform. Mainly intended for doing arbitration from an offline computer.",
+  "scripts": {
+    "test": "mocha ./test"
+  },
+  "keywords": [
+    "Ethereum",
+    "Realitio",
+    "Reality Check",
+    "Reality Keys",
+    "Arbitration",
+    "Solidity",
+    "Truffle"
+  ],
+  "author": "Edmund Edgar (https://realit.io)",
+  "license": "GPL-3.0",
+  "dependencies": {
+    "@reality.eth/contracts": "^3.0.26",
+    "@reality.eth/reality-eth-lib": "^3.2.10",
+    "axios": "^0.27.2",
+    "bignumber.js": "^4.0.2",
+    "ethereumjs-tx": "^1.3.7",
+    "ethers": "^5.4.7",
+    "keccak": "^1.4.0",
+    "qrcode-terminal": "^0.12.0",
+    "truffle-contract": "^3.0.6",
+    "web3-utils": "^1.0.0-beta.35"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/realitio/realitio-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/realitio/realitio-cli/issues"
+  },
+  "homepage": "https://realit.io",
+  "gitHead": "b9fcb24ff3274a58c4f98c0c97b58c4d5c5b0fcd"
+}