WikiDeck/wikideck
3
0
Fork 1
Code Issues 8 Pull Requests Actions Packages Projects 2 Releases Wiki Activity

Canonical indexes and recoverable market observation

Browse Source
This commit is contained in:
eric
2026-10-20 14:35:45 -04:00
parent fc65e497a8
commit e48081f041
11 changed files with 583 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/testnet-ledger.test.ts
+91 -1
View File
@@ -12,7 +12,7 @@ import { Ledger } from '../server/testnet/ledger.ts';
import { PeerNetwork } from '../server/testnet/peers.ts';
import { CHAIN_ID, GENESIS_HASH, GENESIS_TIME, MAX_TARGET, address, makeTemplate, miningBlob,
mintId, sha256, stateRoot, transferId, transition, workFor } from '../server/testnet/consensus.ts';
import { NETWORK, CONSENSUS, blockClaimMessage, nftTransferMessage, testnetOwnerOf,
import { NETWORK, CONSENSUS, blockClaimMessage, nftTransferMessage, testnetOwnerOf, transactionCardIds,
nftTradeMessage, type MiningTemplate, type NftState, type NftStateLayer, type NftStateView,
type NftTrade, type NftTransfer, type TestnetBlock } from '../shared/testnet.ts';
import { deriveStats } from '../shared/enrichment.ts';
@@ -259,6 +259,11 @@ test('signed multi-card trade is validated, mempooled, mined, and applied atomic
for (const block of offered) assert.equal(testnetOwnerOf(after, block.tokenId), bob.owner);
for (const block of requested) assert.equal(testnetOwnerOf(after, block.tokenId), alice.owner);
assert.deepEqual(after.transfers.at(-1), bundle);
for (const block of after.blocks) {
const indexed = ledger.nft(block.tokenId)!;
assert.equal(indexed.owner, testnetOwnerOf(after, block.tokenId));
assert.equal(indexed.sequence, after.transfers.filter(tx => transactionCardIds(tx).includes(block.tokenId)).length);
}
const deck = ledger.deck(alice.owner, 0, 2);
assert.equal(deck.total, after.blocks.filter(block => testnetOwnerOf(after, block.tokenId) === alice.owner).length);
assert.equal(deck.nfts.length, 2);
@@ -291,14 +296,99 @@ test('reorg rolls back NFT ownership and requeues only still-valid disconnected
assert.equal(testnetOwnerOf(snapshot, committed.tokenId), undefined);
assert.deepEqual(snapshot.transfers, []);
assert.deepEqual(snapshot.pendingTransfers, [tx, tx2]); // Orphan issuance is discarded.
assert.equal(ledger.nft(minted.tokenId)!.owner, alice.owner);
assert.equal(ledger.nft(minted.tokenId)!.sequence, 0);
assert.equal(ledger.nft(committed.tokenId), undefined);
assert.equal(ledger.canonicalTransaction(transferId(tx)), undefined);
assert.ok(ledger.block(committed.hash));
const restored = await Ledger.open(dir, new FakePow());
t.after(async () => { restored.close(); });
assert.deepEqual(restored.snapshot(), snapshot);
assert.equal(restored.canonicalHead(), ledger.canonicalHead());
assert.deepEqual(restored.canonicalEvents(0), ledger.canonicalEvents(0));
const next = await mine(ledger.template(bob.owner, bob.publicKey,
articleFor(ledger.snapshot().blocks), statsSnapshot()), bob);
await ledger.submit(next);
assert.equal(testnetOwnerOf(ledger.snapshot(), minted.tokenId), carol.owner);
assert.equal(ledger.nft(minted.tokenId)!.owner, carol.owner);
assert.equal(ledger.nft(minted.tokenId)!.sequence, 2);
});
test('canonical event pages record reorg order durably but exclude side branches, duplicates and mempool', async t => {
const { ledger, file, dir } = await fixture(t), original = branch();
const first = await extend(original); await ledger.submit(first);
const second = await extend(original); await ledger.submit(second);
const fork: Branch = structuredClone(original);
const tx = transfer(first.tokenId);
await ledger.submitTransfer(tx);
const beforePending = ledger.canonicalHead();
assert.equal(beforePending, 2);
const third = await extend(original, alice, [tx]); await ledger.submit(third);
assert.equal(ledger.canonicalTransaction(transferId(tx))?.blockHash, third.hash);
const competing = await extend(fork, bob); await ledger.submit(competing);
assert.equal(ledger.canonicalHead(), 3); // Equal-work branch does not change canonical state.
const winner = await extend(fork, bob); await ledger.submit(winner);
assert.equal(ledger.canonicalHead(), 6);
assert.equal(ledger.canonicalTransaction(transferId(tx)), undefined);
const events = ledger.canonicalEvents(0).events;
assert.deepEqual(events.map(e => [e.type, e.hash]), [
['connect', first.hash], ['connect', second.hash], ['connect', third.hash],
['disconnect', third.hash], ['connect', competing.hash], ['connect', winner.hash],
]);
assert.deepEqual(events[3].transactionIds, [transferId(tx)]);
const page = ledger.canonicalEvents(2, 1);
assert.equal(page.cursor, 3); assert.equal(page.caughtUp, false); assert.equal(page.head, 6);
page.events[0].transactionIds.length = 0;
assert.equal(ledger.canonicalEvents(2, 1).events[0].transactionIds.length, 1);
for (const [after, limit] of [[-1, 1], [7, 1], [0, 65], [0, 0], [0.5, 1]]) {
assert.throws(() => ledger.canonicalEvents(after, limit), /cursor/);
}
await ledger.submit(winner); assert.equal(ledger.canonicalHead(), 6);
ledger.close();
const reopened = await Ledger.open(dir, new FakePow());
try {
assert.equal(reopened.canonicalHead(), 6); assert.deepEqual(reopened.canonicalEvents(0).events, events);
const db = new DatabaseSync(file);
try { assert.throws(() => db.exec("UPDATE canonical_events SET type='connect'"), /Immutable/); } finally { db.close(); }
} finally { reopened.close(); }
});
test('block, mempool, canonical indexes and events roll back together on storage failure', async t => {
const { ledger, file } = await fixture(t), chain = branch();
const candidate = await extend(chain), db = new DatabaseSync(file);
try {
db.exec("CREATE TRIGGER fail_event BEFORE INSERT ON canonical_events BEGIN SELECT RAISE(ABORT,'injected storage failure'); END");
await assert.rejects(ledger.submit(candidate), /injected storage failure/);
assert.equal(ledger.size, 0); assert.equal(ledger.canonicalHead(), 0); assert.equal(ledger.nft(candidate.tokenId), undefined);
assert.equal((db.prepare('SELECT COUNT(*) AS n FROM blocks').get() as { n: number }).n, 0);
db.exec('DROP TRIGGER fail_event');
await ledger.submit(candidate);
assert.equal(ledger.nft(candidate.tokenId)!.owner, alice.owner); assert.equal(ledger.canonicalHead(), 1);
} finally { db.close(); }
});
test('validated existing ledgers backfill indexes once and refuse corrupt ownership or event history', async t => {
const { ledger, file, dir } = await fixture(t), chain = branch();
await ledger.submit(await extend(chain)); await ledger.submit(await extend(chain));
const expected = ledger.snapshot(); ledger.close();
const db = new DatabaseSync(file);
try {
// Simulate the prior schema: preserve original blocks/metadata/pending exactly, remove only new derived tables.
db.exec('DROP TABLE canonical_undo; DROP TABLE canonical_transactions; DROP TABLE canonical_nfts; DROP TABLE canonical_blocks; DROP TABLE canonical_events; DROP TABLE canonical_meta;');
} finally { db.close(); }
const migrated = await Ledger.open(dir, new FakePow());
assert.deepEqual(migrated.snapshot(), expected); assert.equal(migrated.canonicalHead(), 2); migrated.close();
const corrupt = new DatabaseSync(file);
try { corrupt.prepare('UPDATE canonical_nfts SET owner=? WHERE token=?').run(bob.owner, chain.blocks[0].tokenId); }
finally { corrupt.close(); }
await assert.rejects(Ledger.open(dir, new FakePow()), /ownership index mismatch/);
const repair = new DatabaseSync(file);
try {
repair.prepare('UPDATE canonical_nfts SET owner=? WHERE token=?').run(alice.owner, chain.blocks[0].tokenId);
repair.exec('DROP TRIGGER canonical_events_no_update');
repair.exec("UPDATE canonical_events SET transactions_json='[\"wrong\"]' WHERE sequence=1");
} finally { repair.close(); }
await assert.rejects(Ledger.open(dir, new FakePow()), /event integrity mismatch/);
});
test('reorg removes mempool conflicts and does not requeue already committed transfers', async t => {