@reality.eth/reality-eth-lib 3.4.28 → 3.4.29

package/test/formatters.js

@@ -27,6 +27,14 @@ describe('Default template types', function() {
         expect(q.type).to.equal(t);
     }
   });
+  it('round-trips a title containing double quotes without breaking JSON', function() {
+    const title = 'Will Trump say "economics" in his speech?';
+    const qtext = rc_question.encodeText('bool', title, null, 'politics');
+    const q = rc_question.populatedJSONForTemplate(rc_template.defaultTemplateForType('bool'), qtext);
+    expect(q.title).to.equal(title);
+    expect(q.type).to.equal('bool');
+    expect(q.errors).to.be.undefined;
+  });
   it('marks the question if it has extra unused data', function() {
     const outcomes = ["oink", "oink2"];
     for (var i=0; i<option_types.length; i++) {
@@ -60,6 +68,31 @@ describe('Answer formatting', function() {
     expect(rc_question.answerToBytes32("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffFD", q)).to.equal('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd');
     expect(rc_question.answerToBytes32("1", q)).to.equal('0x0000000000000000000000000000000000000000000000000000000000000001');
   });
+  it('Encodes datetime timestamps correctly, including those whose hex representation contains digits a-f', function() {
+    var q = rc_question.populatedJSONForTemplate(rc_template.defaultTemplateForType('datetime'), '');
+    // Trivial: 0 and 1 are the same in hex and decimal, so they pass even with the double-parse bug.
+    expect(rc_question.answerToBytes32(0, q)).to.equal('0x0000000000000000000000000000000000000000000000000000000000000000');
+    expect(rc_question.answerToBytes32(1, q)).to.equal('0x0000000000000000000000000000000000000000000000000000000000000001');
+    // 16 = 0x10: the hex string '10' re-parses as decimal 10 (= 0xa), producing the wrong value.
+    expect(rc_question.answerToBytes32(16, q)).to.equal('0x0000000000000000000000000000000000000000000000000000000000000010');
+    // 1527638400 = 0x5b0de980 (2018-05-30 UTC): hex contains 'b', 'd', 'e' → NaN without fix.
+    expect(rc_question.answerToBytes32(1527638400, q)).to.equal('0x000000000000000000000000000000000000000000000000000000005b0de980');
+    // 1767225600 = 0x6955b900 (2026-01-01 UTC): hex contains 'b' → NaN without fix.
+    expect(rc_question.answerToBytes32(1767225600, q)).to.equal('0x000000000000000000000000000000000000000000000000000000006955b900');
+  });
+  it('Encodes single-select option indices correctly, including indices >= 10', function() {
+    var outcomes = [];
+    for (var i = 0; i < 20; i++) outcomes.push('option' + i);
+    var qtext = rc_question.encodeText('single-select', 'Which?', outcomes, 'misc');
+    var q = rc_question.populatedJSONForTemplate(rc_template.defaultTemplateForType('single-select'), qtext);
+    // Indices 0-9 have the same single-character hex and decimal representation: pass without fix.
+    expect(rc_question.answerToBytes32('0', q)).to.equal('0x0000000000000000000000000000000000000000000000000000000000000000');
+    expect(rc_question.answerToBytes32('9', q)).to.equal('0x0000000000000000000000000000000000000000000000000000000000000009');
+    // Index 10 = 0xa: hex string 'a' is invalid base-10 → NaN without fix.
+    expect(rc_question.answerToBytes32('10', q)).to.equal('0x000000000000000000000000000000000000000000000000000000000000000a');
+    // Index 16 = 0x10: hex string '10' re-parses as decimal 10 (= 0xa), silently wrong without fix.
+    expect(rc_question.answerToBytes32('16', q)).to.equal('0x0000000000000000000000000000000000000000000000000000000000000010');
+  });
   it('Turns options into hex', function() {
     var outcomes = ['thing1', 'thing2', 'thing3'];
     var qtext = rc_question.encodeText('multiple-select', 'oink', outcomes, 'my-category');
@@ -123,6 +156,21 @@ describe('Answer strings', function() {
     expect(rc_question.getAnswerString(q, '0x0000000000000000000000000000000000000000000000001BC16D674EC80000')).to.equal('2');
   });
 
+  it('Handles uints with 2 decimals: fractional, whole number, small fraction, zero', function() {
+    var q = rc_question.populatedJSONForTemplate(rc_template.defaultTemplateForType('uint'), '');
+    q.decimals = 2;
+    // 350 / 100 = 3.5 — the bug case: page was displaying 350 / 10^18
+    expect(rc_question.getAnswerString(q, '0x000000000000000000000000000000000000000000000000000000000000015e')).to.equal('3.5');
+    // 300 / 100 = 3.0 — whole number, trailing .00 must be stripped
+    expect(rc_question.getAnswerString(q, '0x000000000000000000000000000000000000000000000000000000000000012c')).to.equal('3');
+    // 1 / 100 = 0.01 — small fraction where fracStr must be zero-padded before strip
+    expect(rc_question.getAnswerString(q, '0x0000000000000000000000000000000000000000000000000000000000000001')).to.equal('0.01');
+    // 0 — zero is a whole number, no decimal point
+    expect(rc_question.getAnswerString(q, '0x0000000000000000000000000000000000000000000000000000000000000000')).to.equal('0');
+    // 105 / 100 = 1.05 — internal zero in fraction, only trailing zeros stripped
+    expect(rc_question.getAnswerString(q, '0x0000000000000000000000000000000000000000000000000000000000000069')).to.equal('1.05');
+  });
+
   it('Leaves bytes32 strings unchanged except forced to lower case', function() {
     // We don't have a built-in type for this yet so just switch out the uint one
     var q = rc_question.populatedJSONForTemplate(rc_template.defaultTemplateForType('uint'), '');
@@ -335,7 +383,7 @@ describe('Markdown questions', function() {
     expect(q.title).to.equal("`Inline code` with backticks\n\n```# code block\nprint '3 backticks or'\nprint 'indent 4 spaces'```");
     expect(q.title_html).to.equal(
 `<p><code>Inline code</code> with backticks</p>
-<p><code># code block print &#39;3 backticks or&#39; print &#39;indent 4 spaces&#39;</code></p>`+ "\n");
+<p><code># code block print '3 backticks or' print 'indent 4 spaces'</code></p>`+ "\n");
   });
 });
 

package/test-ponder.mjs

@@ -0,0 +1,265 @@
+/**
+ * Verify reality-eth-lib functions against Ponder's indexed question data.
+ *
+ * Tests:
+ *   1. contentHash(templateId, openingTimestamp, data) === ponder.contentHash
+ *   2. populatedJSONForTemplate(templateText, data).title === ponder.title
+ *   3. populatedJSONForTemplate(templateText, data).type  === ponder.type
+ *   4. questionID v3 round-trip (when min_bond=0 and contract is known)
+ */
+
+import * as lib from './dist/cjs/formatters/question.js';
+import * as tmpl from './dist/cjs/formatters/template.js';
+
+const PONDER_URL = 'http://localhost:42069/graphql';
+const PAGE_SIZE = 100;
+
+// --- GraphQL helpers --------------------------------------------------------
+
+async function gql(query) {
+    const res = await fetch(PONDER_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ query }),
+    });
+    const json = await res.json();
+    if (json.errors) throw new Error(JSON.stringify(json.errors));
+    return json.data;
+}
+
+async function* paginate(queryFn, pageSize = PAGE_SIZE) {
+    let cursor = null;
+    while (true) {
+        const after = cursor ? `, after: "${cursor}"` : '';
+        const data = await gql(queryFn(pageSize, after));
+        const result = data[Object.keys(data)[0]];
+        yield* result.items;
+        if (!result.pageInfo.hasNextPage) break;
+        cursor = result.pageInfo.endCursor;
+    }
+}
+
+// --- Template cache ---------------------------------------------------------
+
+const templateCache = new Map(); // key: `${chainId}-${contract}-${templateId}` -> questionText
+
+async function loadAllTemplates() {
+    const gen = paginate((limit, after) => `{
+        templates(limit: ${limit}${after}) {
+            pageInfo { hasNextPage endCursor }
+            items { id templateId chainId contract questionText }
+        }
+    }`);
+    for await (const t of gen) {
+        templateCache.set(t.id, t.questionText);
+    }
+    console.log(`Loaded ${templateCache.size} templates from Ponder.`);
+}
+
+// Get template text: prefer Ponder DB, fall back to built-in (ids 0-4)
+function getTemplateText(chainId, contract, templateId) {
+    const key = `${chainId}-${contract}-${templateId}`;
+    if (templateCache.has(key)) return templateCache.get(key);
+    // Fall back to built-in templates (ids 0-4 same across all contracts)
+    const builtin = tmpl.preloadedTemplateContents();
+    return builtin[String(templateId)] ?? null;
+}
+
+// --- Counters ---------------------------------------------------------------
+
+const stats = {
+    total: 0,
+    contentHashOk: 0,
+    contentHashFail: 0,
+    parseOk: 0,
+    parseTitleMismatch: 0,
+    parseTypeMismatch: 0,
+    parseNullType: 0,
+    qidOk: 0,
+    qidFail: 0,
+    qidSkip: 0,
+    templateMissing: 0,
+};
+
+const failures = {
+    contentHash: [],
+    title: [],
+    type: [],
+    qid: [],
+};
+const MAX_FAILURES = 5; // cap how many we print per category
+
+// --- Main test logic --------------------------------------------------------
+
+async function testQuestion(q) {
+    stats.total++;
+
+    const templateId = Number(q.templateId);
+    const templateText = getTemplateText(q.chainId, q.contract, templateId);
+
+    // 1. contentHash
+    try {
+        const computed = lib.contentHash(templateId, q.openingTimestamp, q.data);
+        if (computed.toLowerCase() === q.contentHash.toLowerCase()) {
+            stats.contentHashOk++;
+        } else {
+            stats.contentHashFail++;
+            if (failures.contentHash.length < MAX_FAILURES) {
+                failures.contentHash.push({
+                    id: q.id, computed, stored: q.contentHash,
+                });
+            }
+        }
+    } catch (e) {
+        stats.contentHashFail++;
+        if (failures.contentHash.length < MAX_FAILURES) {
+            failures.contentHash.push({ id: q.id, error: e.message });
+        }
+    }
+
+    // 2. populatedJSONForTemplate vs Ponder's parsed title/type
+    if (templateText) {
+        try {
+            const parsed = lib.populatedJSONForTemplate(templateText, q.data);
+
+            // Title comparison (only if Ponder has one)
+            if (q.title != null) {
+                const libTitle = parsed.title ?? '';
+                if (libTitle === q.title) {
+                    stats.parseOk++;
+                } else {
+                    stats.parseTitleMismatch++;
+                    if (failures.title.length < MAX_FAILURES) {
+                        failures.title.push({
+                            id: q.id,
+                            libTitle,
+                            ponderTitle: q.title,
+                            templateId,
+                            data: q.data.substring(0, 80),
+                        });
+                    }
+                }
+            }
+
+            // Type comparison
+            if (q.type != null) {
+                if (parsed.type === q.type) {
+                    // ok (counted above)
+                } else {
+                    stats.parseTypeMismatch++;
+                    if (failures.type.length < MAX_FAILURES) {
+                        failures.type.push({
+                            id: q.id,
+                            libType: parsed.type,
+                            ponderType: q.type,
+                            templateId,
+                        });
+                    }
+                }
+            } else {
+                stats.parseNullType++;
+            }
+        } catch (e) {
+            // parsing threw — count as title mismatch
+            stats.parseTitleMismatch++;
+        }
+    } else {
+        stats.templateMissing++;
+    }
+
+    // 3. questionID v3 round-trip (use min_bond=0x0 as default)
+    // We know contract and creator from Ponder, and nonce is now stored.
+    const contract = q.contract;
+    const version = contract.toLowerCase().includes('3_2') ? '3.2' : '3.0';
+    // Only test if nonce is available and it's a v3 question
+    if (q.nonce != null) {
+        try {
+            const computed_qid = lib.questionID(
+                templateId,
+                q.data,
+                q.arbitrator,
+                q.timeout,
+                q.openingTimestamp,
+                q.creator,
+                q.nonce,
+                '0x0',   // min_bond default (0 for most questions)
+                contract,
+                version
+            );
+            if (computed_qid.toLowerCase() === q.questionId.toLowerCase()) {
+                stats.qidOk++;
+            } else {
+                stats.qidFail++;
+                if (failures.qid.length < MAX_FAILURES) {
+                    failures.qid.push({
+                        id: q.id,
+                        computed: computed_qid,
+                        stored: q.questionId,
+                        note: 'may have non-zero min_bond',
+                    });
+                }
+            }
+        } catch (e) {
+            stats.qidFail++;
+            if (failures.qid.length < MAX_FAILURES) {
+                failures.qid.push({ id: q.id, error: e.message });
+            }
+        }
+    } else {
+        stats.qidSkip++;
+    }
+}
+
+// --- Entry point ------------------------------------------------------------
+
+async function main() {
+    console.log('Loading templates...');
+    await loadAllTemplates();
+
+    console.log('Testing questions...');
+    let count = 0;
+
+    const gen = paginate((limit, after) => `{
+        questions(limit: ${limit}${after}, orderBy: "createdTimestamp", orderDirection: "asc") {
+            pageInfo { hasNextPage endCursor }
+            items {
+                id questionId nonce data title type
+                templateId contentHash contract chainId
+                creator arbitrator openingTimestamp timeout
+            }
+        }
+    }`);
+
+    for await (const q of gen) {
+        await testQuestion(q);
+        count++;
+        if (count % 500 === 0) {
+            process.stdout.write(`  processed ${count}...\r`);
+        }
+    }
+
+    console.log(`\n\n=== Results (${stats.total} questions) ===`);
+    console.log(`contentHash: ${stats.contentHashOk} ok, ${stats.contentHashFail} fail`);
+    console.log(`title parse: ${stats.parseOk} ok, ${stats.parseTitleMismatch} mismatch, ${stats.parseNullType} null-type (malformed template), ${stats.templateMissing} template-missing`);
+    console.log(`type parse:  ${stats.parseTypeMismatch} mismatch`);
+    console.log(`questionID:  ${stats.qidOk} ok, ${stats.qidFail} fail (may have non-zero min_bond), ${stats.qidSkip} skipped`);
+
+    if (failures.contentHash.length) {
+        console.log('\ncontentHash failures (sample):');
+        failures.contentHash.forEach(f => console.log(' ', JSON.stringify(f)));
+    }
+    if (failures.title.length) {
+        console.log('\ntitle mismatches (sample):');
+        failures.title.forEach(f => console.log(' ', JSON.stringify(f)));
+    }
+    if (failures.type.length) {
+        console.log('\ntype mismatches (sample):');
+        failures.type.forEach(f => console.log(' ', JSON.stringify(f)));
+    }
+    if (failures.qid.length) {
+        console.log('\nquestionID failures (sample):');
+        failures.qid.forEach(f => console.log(' ', JSON.stringify(f)));
+    }
+}
+
+main().catch(e => { console.error(e); process.exit(1); });

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "lib": ["ES2021"],
+    "rootDir": "src",
+    "outDir": "dist/cjs",
+    "strict": false,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "declarationMap": false,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts"]
+}