0398d7481b
Real WC2026-fixture bet placed and settled on chipnet; deployable web platform in design/football-tote plus the chipnet test and tote server; the oracle-result-publish path for third-party totes. Snapshot 0176. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
199 lines
12 KiB
JavaScript
199 lines
12 KiB
JavaScript
#!/usr/bin/env node
|
|
/**
|
|
* chipnet-football-tote-test.mjs — a LIVE Football Tote on chipnet for a real
|
|
* fixture. Ties together the two validated primitives:
|
|
* - OpenTote (oracle-settled pari-mutuel pool, contracts/OpenTote.cash)
|
|
* - on-chain result publishing (OP_RETURN, as in chipnet-game-oracle-test.mjs)
|
|
*
|
|
* Fixture: FIFA World Cup 2026 opener, Mexico vs South Africa (Jun 11, Estadio
|
|
* Azteca). Binary market "Mexico to win?": A backs YES (side 0), B backs NO
|
|
* (side 1). The result oracle signs (gameId, outcome) AND publishes it on-chain;
|
|
* the tote settles against that exact attestation; the winning side takes the pool.
|
|
*
|
|
* Roles: founder+operator+oracle-payer = C; bettors = A (YES), B (NO).
|
|
* Fresh each run. Requires .chipnet-keys{,-b,-c}.json funded.
|
|
*
|
|
* Run: node --import tsx scripts/chipnet-football-tote-test.mjs
|
|
*/
|
|
import { readFileSync } from 'node:fs';
|
|
import { join } from 'node:path';
|
|
import { randomBytes } from 'node:crypto';
|
|
import { TestNetWallet } from 'mainnet-js';
|
|
import { Contract, ElectrumNetworkProvider, TransactionBuilder, SignatureTemplate } from 'cashscript';
|
|
import { secp256k1, sha256, decodeTransaction } from '@bitauth/libauth';
|
|
|
|
const ROOT = join(import.meta.dirname, '..');
|
|
const MBA_ARTIFACT = JSON.parse(readFileSync(join(ROOT, 'contracts/dist/DeviantOpenMintFT.json'), 'utf8'));
|
|
const TOTE_ARTIFACT = JSON.parse(readFileSync(join(ROOT, 'contracts/dist/OpenTote.json'), 'utf8'));
|
|
const KEYS = { a: '.chipnet-keys.json', b: '.chipnet-keys-b.json', c: '.chipnet-keys-c.json' };
|
|
|
|
const RESERVOIR = 1_000_000_000_000_000_000n;
|
|
const RATE = 1000n, FEE = 0n, MF = 6000n;
|
|
const TAG = 'DEVGAME-RESULT';
|
|
const GAME = 'FIFA World Cup 2026 — Mexico vs South Africa (Jun 11, Estadio Azteca)';
|
|
const MARKET = 'Mexico to win? YES=side0 NO=side1';
|
|
|
|
const hx = (h) => { const o = new Uint8Array(h.length / 2); for (let i = 0; i < o.length; i++) o[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16); return o; };
|
|
const bh = (b) => Array.from(b, (x) => x.toString(16).padStart(2, '0')).join('');
|
|
const txidLE = (h) => { const d = hx(h); const o = new Uint8Array(d.length); for (let i = 0; i < d.length; i++) o[i] = d[d.length - 1 - i]; return o; };
|
|
function p2pkh(pkh) { const o = new Uint8Array(25); o[0] = 0x76; o[1] = 0xa9; o[2] = 0x14; o.set(pkh, 3); o[23] = 0x88; o[24] = 0xac; return o; }
|
|
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
|
|
const line = (c = '=') => console.log(c.repeat(80));
|
|
const step = (t) => { console.log(''); line(); console.log(t); line(); };
|
|
const txidOf = (s) => (typeof s === 'string' ? s : s?.txid ?? s?.txId);
|
|
function pickBch(utxos, need) { const p = []; let t = 0n; for (const u of utxos) { p.push(u); t += BigInt(u.satoshis); if (t >= need) break; } return { p, t }; }
|
|
function oracleSign(privHex, eventIdBin, outcomeByte) {
|
|
const message = new Uint8Array([...eventIdBin, outcomeByte]);
|
|
const sig = secp256k1.signMessageHashDER(hx(privHex), sha256.hash(message));
|
|
if (typeof sig === 'string') throw new Error('oracle sign failed: ' + sig);
|
|
return { message, sig };
|
|
}
|
|
function parseOpReturn(lb) { if (!lb || lb[0] !== 0x6a) return null; const c = []; let i = 1; while (i < lb.length) { let n = lb[i++]; if (n === 0x4c) n = lb[i++]; else if (n > 0x4b) break; c.push(lb.slice(i, i + n)); i += n; } return c; }
|
|
|
|
async function main() {
|
|
line();
|
|
console.log('CHIPNET FOOTBALL TOTE — live, oracle-settled, on-chain result');
|
|
line();
|
|
console.log(`Fixture: ${GAME}`);
|
|
console.log(`Market: ${MARKET}`);
|
|
const A = await TestNetWallet.fromWIF(JSON.parse(readFileSync(join(ROOT, KEYS.a), 'utf8')).wif);
|
|
const B = await TestNetWallet.fromWIF(JSON.parse(readFileSync(join(ROOT, KEYS.b), 'utf8')).wif);
|
|
const C = await TestNetWallet.fromWIF(JSON.parse(readFileSync(join(ROOT, KEYS.c), 'utf8')).wif);
|
|
const provider = new ElectrumNetworkProvider('chipnet');
|
|
const sig = { a: new SignatureTemplate(A.privateKey), b: new SignatureTemplate(B.privateKey), c: new SignatureTemplate(C.privateKey) };
|
|
const flbC = p2pkh(C.publicKeyHash);
|
|
const operatorPk = C.publicKeyCompressed;
|
|
|
|
let opriv; do { opriv = randomBytes(32); } while (typeof secp256k1.derivePublicKeyCompressed(opriv) === 'string');
|
|
const oraclePub = secp256k1.derivePublicKeyCompressed(opriv);
|
|
const oraclePubHex = bh(oraclePub);
|
|
console.log(`Oracle: ${oraclePubHex} (named result oracle)`);
|
|
|
|
// ---- MBA genesis (founder C) ----
|
|
step('Deploy stake token (DeviantOpenMintFT, rate 1000)');
|
|
async function eligible(w) {
|
|
let u = await w.getUtxos(); let e = u.filter((x) => x.vout === 0 && !x.token);
|
|
if (e.length) return e[0];
|
|
const bad = u.filter((x) => !(x.vout === 0 && !x.token));
|
|
await w.send([{ cashaddr: w.cashaddr, value: 4000n, unit: 'sat' }], bad.length ? { utxoIds: bad } : undefined);
|
|
await sleep(12000);
|
|
u = await w.getUtxos(); e = u.filter((x) => x.vout === 0 && !x.token);
|
|
if (!e.length) throw new Error('no vout-0 genesis UTXO'); return e[0];
|
|
}
|
|
const elig = await eligible(C); const cat = elig.txid;
|
|
const mba = new Contract(MBA_ARTIFACT, [txidLE(cat), RATE, FEE, flbC], { provider });
|
|
await C.tokenGenesis({ cashaddr: mba.tokenAddress, amount: RESERVOIR, value: 1000n, nft: { capability: 'minting', commitment: '' } }, [], { utxoIds: [elig] });
|
|
console.log(` stake token category ${cat.slice(0, 16)}…`);
|
|
await sleep(10000);
|
|
|
|
async function mint(who, s, amount, label) {
|
|
const ru = await provider.getUtxos(mba.tokenAddress);
|
|
const res = ru.find((x) => x.token?.nft?.capability === 'minting' && x.token?.category === cat && x.token?.amount > 0n);
|
|
const gross = amount * RATE;
|
|
const bch = (await provider.getUtxos(who.cashaddr)).filter((x) => !x.token).sort((a, b) => Number(b.satoshis - a.satoshis));
|
|
const { p, t } = pickBch(bch, gross + MF + 1000n);
|
|
const change = BigInt(res.satoshis) + t - 1000n - gross - MF;
|
|
const tb = new TransactionBuilder({ provider });
|
|
tb.addInput(res, mba.unlock.claim(amount, p2pkh(who.publicKeyHash)));
|
|
for (const x of p) tb.addInput(x, s.unlockP2PKH());
|
|
tb.addOutput({ to: mba.tokenAddress, amount: 1000n, token: { amount: res.token.amount - amount, category: cat, nft: { capability: 'minting', commitment: '' } } });
|
|
tb.addOutput({ to: who.tokenaddr, amount: gross, token: { amount, category: cat } });
|
|
tb.addOutput({ to: who.cashaddr, amount: change });
|
|
console.log(` ${label}: ${amount} stake-tokens — ${txidOf(await tb.send())}`); await sleep(10000);
|
|
}
|
|
step('Bettors acquire stake tokens: A=30, B=20');
|
|
await mint(A, sig.a, 30n, 'A (backs Mexico/YES)');
|
|
await mint(B, sig.b, 20n, 'B (backs NO)');
|
|
|
|
const findExact = async (who, amount) => (await provider.getUtxos(who.cashaddr)).find((x) => x.token?.category === cat && !x.token?.nft && BigInt(x.token?.amount) === amount);
|
|
const cFee = async (need) => pickBch((await provider.getUtxos(C.cashaddr)).filter((x) => !x.token).sort((a, b) => Number(b.satoshis - a.satoshis)), need);
|
|
|
|
// ---- deploy the tote for this fixture ----
|
|
step('Open the tote for the fixture (gameId = match id)');
|
|
const gameId = randomBytes(16); const ev = gameId; const gameIdHex = bh(gameId);
|
|
const tip = await provider.getBlockHeight();
|
|
const betDeadline = BigInt(tip), refundDeadline = BigInt(tip + 500000);
|
|
const tote = new Contract(TOTE_ARTIFACT, [txidLE(cat), RATE, oraclePub, ev, operatorPk, betDeadline, refundDeadline], { provider });
|
|
console.log(` gameId ${gameIdHex} · tote ${tote.tokenAddress}`);
|
|
|
|
// A opens the pool with its 30 (side 0 = Mexico/YES)
|
|
{
|
|
const a30 = await findExact(A, 30n); if (!a30) throw new Error('A 30 stake missing');
|
|
const { p, t } = pickBch((await provider.getUtxos(A.cashaddr)).filter((x) => !x.token).sort((a, b) => Number(b.satoshis - a.satoshis)), MF + 1000n);
|
|
const tb = new TransactionBuilder({ provider });
|
|
tb.addInput(a30, sig.a.unlockP2PKH());
|
|
for (const x of p) tb.addInput(x, sig.a.unlockP2PKH());
|
|
tb.addOutput({ to: tote.tokenAddress, amount: 30000n, token: { amount: 30n, category: cat } });
|
|
tb.addOutput({ to: A.cashaddr, amount: BigInt(a30.satoshis) + t - 30000n - MF });
|
|
console.log(` A opened pool (30 on Mexico/YES) — ${txidOf(await tb.send())}`); await sleep(10000);
|
|
}
|
|
// B folds its 20 (side 1 = NO) → pool = 50
|
|
{
|
|
const pool = (await provider.getUtxos(tote.tokenAddress)).find((x) => x.token?.category === cat && !x.token?.nft && BigInt(x.token?.amount) === 30n);
|
|
const b20 = await findExact(B, 20n); if (!b20) throw new Error('B 20 stake missing');
|
|
const { p, t } = pickBch((await provider.getUtxos(B.cashaddr)).filter((x) => !x.token).sort((a, b) => Number(b.satoshis - a.satoshis)), MF + 1000n);
|
|
const tb = new TransactionBuilder({ provider });
|
|
tb.addInput(pool, tote.unlock.bet(20n));
|
|
tb.addInput(b20, sig.b.unlockP2PKH());
|
|
for (const x of p) tb.addInput(x, sig.b.unlockP2PKH());
|
|
tb.addOutput({ to: tote.tokenAddress, amount: 50000n, token: { amount: 50n, category: cat } });
|
|
tb.addOutput({ to: B.cashaddr, amount: BigInt(pool.satoshis) + BigInt(b20.satoshis) + t - 50000n - MF });
|
|
console.log(` B bet (20 on NO) → pool 50 — ${txidOf(await tb.send())}`); await sleep(10000);
|
|
}
|
|
|
|
// ---- the match ends: Mexico win (outcome 0). Oracle signs + PUBLISHES on-chain. ----
|
|
step('Full time — oracle signs the result AND publishes it on-chain (OP_RETURN)');
|
|
const OUTCOME = 0x00; // Mexico win → side 0 (YES) wins
|
|
const { message, sig: oSig } = oracleSign(bh(opriv), ev, OUTCOME);
|
|
let publishTx;
|
|
{
|
|
const { p, t } = await cFee(MF + 1000n);
|
|
const tb = new TransactionBuilder({ provider });
|
|
for (const x of p) tb.addInput(x, sig.c.unlockP2PKH());
|
|
tb.addOpReturnOutput([TAG, '0x' + gameIdHex, '0x00', '0x' + oraclePubHex, '0x' + bh(oSig)]);
|
|
tb.addOutput({ to: C.cashaddr, amount: t - MF });
|
|
publishTx = txidOf(await tb.send());
|
|
console.log(` result "Mexico win" published on-chain — ${publishTx}`); await sleep(8000);
|
|
}
|
|
|
|
// ---- settle against the published attestation: side 0 (A) takes the 50 pool ----
|
|
step('Settle the tote against the oracle attestation → Mexico backers win the pool');
|
|
{
|
|
const pool = (await provider.getUtxos(tote.tokenAddress)).find((x) => x.token?.category === cat && !x.token?.nft && BigInt(x.token?.amount) === 50n);
|
|
if (!pool) throw new Error('pool@50 not found');
|
|
const { p, t } = await cFee(MF + 1000n);
|
|
const tb = new TransactionBuilder({ provider });
|
|
tb.setLocktime(Number(betDeadline));
|
|
tb.addInput(pool, tote.unlock.settle(oSig, message, sig.c));
|
|
for (const x of p) tb.addInput(x, sig.c.unlockP2PKH());
|
|
tb.addOutput({ to: A.tokenaddr, amount: 50000n, token: { amount: 50n, category: cat } }); // A (only side-0 backer) takes all 50
|
|
tb.addOutput({ to: C.cashaddr, amount: BigInt(pool.satoshis) + t - 50000n - MF });
|
|
console.log(` settled → A wins 50 stake-tokens — ${txidOf(await tb.send())}`); await sleep(10000);
|
|
}
|
|
|
|
// ---- verify ----
|
|
step('VERIFY');
|
|
const aWon = (await provider.getUtxos(A.cashaddr)).some((x) => x.token?.category === cat && !x.token?.nft && BigInt(x.token?.amount) === 50n);
|
|
const raw = await provider.getRawTransaction(publishTx);
|
|
const dec = decodeTransaction(hx(raw));
|
|
const opret = typeof dec === 'string' ? null : dec.outputs.map((o) => parseOpReturn(o.lockingBytecode)).find(Boolean);
|
|
const resultVerifies = opret && secp256k1.verifySignatureDERLowS(opret[4], opret[3], sha256.hash(new Uint8Array([...opret[1], opret[2][0]])));
|
|
const checks = [
|
|
['Pari-mutuel: Mexico backer (A) won the 50-token pool', aWon],
|
|
['Result is published on-chain and the signature verifies from chain data', resultVerifies === true],
|
|
];
|
|
let ok = true; for (const [l, p] of checks) { console.log(` [${p ? 'PASS' : 'FAIL'}] ${l}`); ok = ok && p; }
|
|
|
|
step('SUMMARY — a real fixture, bet and settled live on chipnet');
|
|
console.log(` Fixture: ${GAME}`);
|
|
console.log(` gameId: ${gameIdHex}`);
|
|
console.log(` Result published on-chain: ${publishTx}`);
|
|
console.log(' A backed Mexico/YES (30), B backed NO (20); pool 50. Oracle signed');
|
|
console.log(' "Mexico win", published it on-chain, and the tote paid the Mexico');
|
|
console.log(' side. Anyone can fetch the result tx and verify it — third-party Totes');
|
|
console.log(' can settle on the same attestation without trusting any server.');
|
|
line();
|
|
if (!ok) { console.error('VERIFY FAILED'); process.exit(1); }
|
|
process.exit(0);
|
|
}
|
|
main().catch((e) => { console.error('FAILED:', e?.message ?? e); if (e?.stack) console.error(e.stack); process.exit(1); });
|