+277 -14

lex/resolver/lex-resolver.ts

reviewed

··· 1 1 - import type { Cid } from "../data/mod.ts"; 1 1 + import * as crypto from "@atp/crypto"; 2 2 import { resolveTxt as resolveTxtWithNode } from "node:dns/promises"; 3 3 import { type AtprotoData, type DidCache, DidResolver } from "@atp/identity"; 4 4 import { ··· 9 9 } from "../external.ts"; 10 10 import * as l from "../external.ts"; 11 11 import { 12 12 + decode as decodeCbor, 13 13 + encode as encodeCbor, 14 14 + parseCidFromBytes, 15 15 + verifyCidForBytes, 16 16 + } from "../cbor/mod.ts"; 17 17 + import { asCid, type Cid } from "../data/mod.ts"; 18 18 + import { 12 19 type LexiconDocument, 13 20 lexiconDocumentSchema, 14 21 } from "../document/mod.ts"; 15 15 - import { 16 16 - def as repoDef, 17 17 - MemoryBlockstore, 18 18 - MST, 19 19 - readCarWithRoot, 20 20 - verifyCommitSig, 21 21 - } from "@atp/repo"; 22 22 import { AtUri, ensureValidDid, NSID } from "@atp/syntax"; 23 23 import { LexResolverError } from "./lex-resolver-error.ts"; 24 24 ··· 417 417 rkey: string, 418 418 ): Promise<LexResolverFetchResult> { 419 419 const { root, blocks } = await readCarWithRoot(car); 420 420 - const blockstore = new MemoryBlockstore(blocks); 421 421 - 422 422 - const commit = blockstore.readObj(root, repoDef.commit); 420 420 + const commit = readCommitBlock(blocks, root); 423 421 if (commit.did !== did) { 424 422 throw new Error(`Invalid repo did: ${commit.did}`); 425 423 } ··· 429 427 throw new Error(`Invalid signature on commit: ${root.toString()}`); 430 428 } 431 429 432 432 - const mst = MST.load(blockstore, (commit as { data: Cid }).data); 433 433 - const cid = await mst.get(`${collection}/${rkey}`); 430 430 + const cid = findRecordCid(blocks, commit.data, `${collection}/${rkey}`); 434 431 if (!cid) { 435 432 throw new Error("Record not found in proof"); 436 433 } 437 434 438 438 - const record = blockstore.readRecord(cid); 435 435 + const record = readRecordBlock(blocks, cid); 439 436 if (record.$type !== collection) { 440 437 throw new Error( 441 438 `Invalid record type: expected ${collection}, got ${record.$type}`, ··· 447 444 lexicon: record as LexiconDocument, 448 445 }; 449 446 } 447 447 + 448 448 + type BlockStore = Map<string, Uint8Array>; 449 449 + 450 450 + type CarHeader = { 451 451 + version: 1; 452 452 + roots: Cid[]; 453 453 + }; 454 454 + 455 455 + type Commit = { 456 456 + did: string; 457 457 + version: 3; 458 458 + data: Cid; 459 459 + rev: string; 460 460 + prev: Cid | null; 461 461 + sig: Uint8Array; 462 462 + }; 463 463 + 464 464 + type MstEntry = { 465 465 + p: number; 466 466 + k: Uint8Array; 467 467 + v: Cid; 468 468 + t: Cid | null; 469 469 + }; 470 470 + 471 471 + type MstNode = { 472 472 + l: Cid | null; 473 473 + e: MstEntry[]; 474 474 + }; 475 475 + 476 476 + type LexRecord = { 477 477 + [key: string]: unknown; 478 478 + $type?: unknown; 479 479 + }; 480 480 + 481 481 + const textDecoder = new TextDecoder(); 482 482 + 483 483 + async function readCarWithRoot( 484 484 + bytes: Uint8Array, 485 485 + ): Promise<{ root: Cid; blocks: BlockStore }> { 486 486 + const { header, blocks } = await readCar(bytes); 487 487 + if (header.roots.length !== 1) { 488 488 + throw new Error(`Expected one root, got ${header.roots.length}`); 489 489 + } 490 490 + 491 491 + return { 492 492 + root: header.roots[0], 493 493 + blocks, 494 494 + }; 495 495 + } 496 496 + 497 497 + async function readCar( 498 498 + bytes: Uint8Array, 499 499 + ): Promise<{ header: CarHeader; blocks: BlockStore }> { 500 500 + let offset = 0; 501 501 + const headerSize = readVarint(bytes, offset); 502 502 + offset = headerSize.offset; 503 503 + 504 504 + const header = parseCarHeader(readSlice(bytes, offset, headerSize.value)); 505 505 + offset += headerSize.value; 506 506 + 507 507 + const blocks: BlockStore = new Map(); 508 508 + while (offset < bytes.byteLength) { 509 509 + const blockSize = readVarint(bytes, offset); 510 510 + offset = blockSize.offset; 511 511 + 512 512 + const blockBytes = readSlice(bytes, offset, blockSize.value); 513 513 + offset += blockSize.value; 514 514 + 515 515 + const cid = parseCidFromBytes(blockBytes.subarray(0, 36)); 516 516 + const block = blockBytes.subarray(36); 517 517 + await verifyCidForBytes(cid, block); 518 518 + blocks.set(cid.toString(), block); 519 519 + } 520 520 + 521 521 + return { 522 522 + header, 523 523 + blocks, 524 524 + }; 525 525 + } 526 526 + 527 527 + function readVarint( 528 528 + bytes: Uint8Array, 529 529 + offset: number, 530 530 + ): { value: number; offset: number } { 531 531 + let value = 0; 532 532 + let shift = 0; 533 533 + let cursor = offset; 534 534 + 535 535 + while (cursor < bytes.byteLength) { 536 536 + const byte = bytes[cursor]; 537 537 + value |= (byte & 0x7f) << shift; 538 538 + cursor += 1; 539 539 + 540 540 + if ((byte & 0x80) === 0) { 541 541 + return { value, offset: cursor }; 542 542 + } 543 543 + 544 544 + shift += 7; 545 545 + } 546 546 + 547 547 + throw new Error("Invalid varint"); 548 548 + } 549 549 + 550 550 + function readSlice( 551 551 + bytes: Uint8Array, 552 552 + offset: number, 553 553 + length: number, 554 554 + ): Uint8Array { 555 555 + const end = offset + length; 556 556 + if (end > bytes.byteLength) { 557 557 + throw new Error("Unexpected end of CAR data"); 558 558 + } 559 559 + 560 560 + return bytes.subarray(offset, end); 561 561 + } 562 562 + 563 563 + function parseCarHeader(bytes: Uint8Array): CarHeader { 564 564 + const value = decodeCbor(bytes); 565 565 + const record = asObject(value); 566 566 + const version = record.version; 567 567 + const rootsValue = record.roots; 568 568 + 569 569 + if (version !== 1 || !Array.isArray(rootsValue)) { 570 570 + throw new Error("Invalid CAR header"); 571 571 + } 572 572 + 573 573 + const roots = rootsValue.map((root) => { 574 574 + const cid = asCid(root); 575 575 + if (cid == null) { 576 576 + throw new Error("Invalid CAR root"); 577 577 + } 578 578 + return cid; 579 579 + }); 580 580 + 581 581 + return { 582 582 + version: 1, 583 583 + roots, 584 584 + }; 585 585 + } 586 586 + 587 587 + function readCommitBlock(blocks: BlockStore, cid: Cid): Commit { 588 588 + return parseCommit(readDecodedBlock(blocks, cid)); 589 589 + } 590 590 + 591 591 + function parseCommit(value: unknown): Commit { 592 592 + const record = asObject(value); 593 593 + const data = asCid(record.data); 594 594 + const prev = record.prev === null ? null : asCid(record.prev); 595 595 + 596 596 + if ( 597 597 + typeof record.did !== "string" || 598 598 + record.version !== 3 || 599 599 + data == null || 600 600 + typeof record.rev !== "string" || 601 601 + !(record.sig instanceof Uint8Array) || 602 602 + (record.prev !== null && prev == null) 603 603 + ) { 604 604 + throw new Error("Invalid repo commit"); 605 605 + } 606 606 + 607 607 + return { 608 608 + did: record.did, 609 609 + version: 3, 610 610 + data, 611 611 + rev: record.rev, 612 612 + prev, 613 613 + sig: record.sig as Uint8Array, 614 614 + }; 615 615 + } 616 616 + 617 617 + function verifyCommitSig(commit: Commit, didKey: string): boolean { 618 618 + const { sig, ...unsigned } = commit; 619 619 + return crypto.verifySignature( 620 620 + didKey, 621 621 + encodeCbor(unsigned), 622 622 + sig, 623 623 + ); 624 624 + } 625 625 + 626 626 + function findRecordCid( 627 627 + blocks: BlockStore, 628 628 + root: Cid, 629 629 + key: string, 630 630 + ): Cid | null { 631 631 + const node = parseMstNode(readDecodedBlock(blocks, root)); 632 632 + let lastKey = ""; 633 633 + let subtree = node.l; 634 634 + 635 635 + for (const entry of node.e) { 636 636 + const entryKey = lastKey.slice(0, entry.p) + textDecoder.decode(entry.k); 637 637 + if (key < entryKey) { 638 638 + return subtree ? findRecordCid(blocks, subtree, key) : null; 639 639 + } 640 640 + if (key === entryKey) { 641 641 + return entry.v; 642 642 + } 643 643 + 644 644 + subtree = entry.t; 645 645 + lastKey = entryKey; 646 646 + } 647 647 + 648 648 + return subtree ? findRecordCid(blocks, subtree, key) : null; 649 649 + } 650 650 + 651 651 + function parseMstNode(value: unknown): MstNode { 652 652 + const record = asObject(value); 653 653 + const entriesValue = record.e; 654 654 + 655 655 + if (!Array.isArray(entriesValue)) { 656 656 + throw new Error("Invalid MST node"); 657 657 + } 658 658 + 659 659 + const left = record.l === null ? null : asCid(record.l); 660 660 + if (record.l !== null && left == null) { 661 661 + throw new Error("Invalid MST node"); 662 662 + } 663 663 + 664 664 + return { 665 665 + l: left, 666 666 + e: entriesValue.map(parseMstEntry), 667 667 + }; 668 668 + } 669 669 + 670 670 + function parseMstEntry(value: unknown): MstEntry { 671 671 + const record = asObject(value); 672 672 + const cid = asCid(record.v); 673 673 + const subtree = record.t === null ? null : asCid(record.t); 674 674 + 675 675 + if ( 676 676 + !Number.isInteger(record.p) || 677 677 + !(record.k instanceof Uint8Array) || 678 678 + cid == null || 679 679 + (record.t !== null && subtree == null) 680 680 + ) { 681 681 + throw new Error("Invalid MST entry"); 682 682 + } 683 683 + 684 684 + return { 685 685 + p: record.p as number, 686 686 + k: record.k as Uint8Array, 687 687 + v: cid, 688 688 + t: subtree, 689 689 + }; 690 690 + } 691 691 + 692 692 + function readRecordBlock(blocks: BlockStore, cid: Cid): LexRecord { 693 693 + const value = readDecodedBlock(blocks, cid); 694 694 + return asObject(value) as LexRecord; 695 695 + } 696 696 + 697 697 + function readDecodedBlock(blocks: BlockStore, cid: Cid): unknown { 698 698 + const bytes = blocks.get(cid.toString()); 699 699 + if (bytes == null) { 700 700 + throw new Error(`Missing block: ${cid.toString()}`); 701 701 + } 702 702 + 703 703 + return decodeCbor(bytes); 704 704 + } 705 705 + 706 706 + function asObject(value: unknown): Record<string, unknown> { 707 707 + if (value == null || typeof value !== "object" || Array.isArray(value)) { 708 708 + throw new Error("Expected object"); 709 709 + } 710 710 + 711 711 + return value as Record<string, unknown>; 712 712 + }

+98 -27

lex/tests/lex-resolver_test.ts

reviewed

··· 1 1 - import { cidForCbor, streamToBuffer } from "@atp/common"; 2 1 import * as crypto from "@atp/crypto"; 3 3 - import { 4 4 - getRecords, 5 5 - MemoryBlockstore, 6 6 - Repo, 7 7 - type RepoInputRecord, 8 8 - WriteOpAction, 9 9 - } from "@atp/repo"; 10 2 import { AtUri } from "@atp/syntax"; 11 3 import { assertEquals, assertInstanceOf, assertRejects } from "@std/assert"; 4 4 + import { cidForCbor, encode } from "../cbor/mod.ts"; 5 5 + import type { Cid, LexMap } from "../data/mod.ts"; 12 6 import { LexResolver, LexResolverError } from "../resolver/mod.ts"; 13 7 import { createDefaultResolveTxt } from "../resolver/lex-resolver.ts"; 14 8 ··· 21 15 did: string; 22 16 pds: string; 23 17 signingKey: string; 24 24 - lexicon: Record<string, unknown>; 18 18 + lexicon: LexMap; 19 19 + }; 20 20 + 21 21 + type CarBlock = { 22 22 + cid: Cid; 23 23 + bytes: Uint8Array; 24 24 + }; 25 25 + 26 26 + type Commit = { 27 27 + did: string; 28 28 + version: 3; 29 29 + data: Cid; 30 30 + rev: string; 31 31 + prev: null; 25 32 }; 26 33 27 34 const toArrayBuffer = (bytes: Uint8Array): ArrayBuffer => { ··· 32 39 33 40 const createLexiconRecord = ( 34 41 id: string, 35 35 - ): RepoInputRecord => ({ 42 42 + ): LexMap => ({ 36 43 $type: collection, 37 44 lexicon: 1, 38 45 id, ··· 46 53 const createProofFixture = async ( 47 54 record = createLexiconRecord(nsid), 48 55 ): Promise<ProofFixture> => { 49 49 - const storage = new MemoryBlockstore(); 50 56 const keypair = crypto.Secp256k1Keypair.create(); 51 57 const did = "did:plc:resolvertest"; 52 52 - const repo = await Repo.create(storage, did, keypair, [{ 53 53 - action: WriteOpAction.Create, 54 54 - collection, 55 55 - rkey: nsid, 56 56 - record, 57 57 - }]); 58 58 - const car = await streamToBuffer(getRecords(storage, repo.cid, [{ 59 59 - collection, 60 60 - rkey: nsid, 61 61 - }])); 62 62 - const fetched = await repo.data.get(`${collection}/${nsid}`); 63 63 - if (!fetched) { 64 64 - throw new Error("expected cid"); 65 65 - } 58 58 + const key = `${collection}/${nsid}`; 59 59 + const recordBytes = encode(record); 60 60 + const recordCid = await cidForCbor(recordBytes); 61 61 + const mstBytes = encode({ 62 62 + l: null, 63 63 + e: [{ 64 64 + p: 0, 65 65 + k: new TextEncoder().encode(key), 66 66 + v: recordCid, 67 67 + t: null, 68 68 + }], 69 69 + }); 70 70 + const mstCid = await cidForCbor(mstBytes); 71 71 + const unsignedCommit: Commit = { 72 72 + did, 73 73 + version: 3, 74 74 + data: mstCid, 75 75 + rev: "rev-resolvertest", 76 76 + prev: null, 77 77 + }; 78 78 + const sig = keypair.sign(encode(unsignedCommit)); 79 79 + const commitBytes = encode({ 80 80 + ...unsignedCommit, 81 81 + sig, 82 82 + }); 83 83 + const commitCid = await cidForCbor(commitBytes); 84 84 + const car = encodeCar(commitCid, [ 85 85 + { cid: commitCid, bytes: commitBytes }, 86 86 + { cid: mstCid, bytes: mstBytes }, 87 87 + { cid: recordCid, bytes: recordBytes }, 88 88 + ]); 89 89 + 66 90 return { 67 91 car, 68 68 - cid: fetched.toString(), 92 92 + cid: recordCid.toString(), 69 93 did, 70 94 pds: "https://pds.test", 71 95 signingKey: keypair.did(), 72 96 lexicon: record, 73 97 }; 74 98 }; 99 99 + 100 100 + function encodeCar( 101 101 + root: Cid, 102 102 + blocks: CarBlock[], 103 103 + ): Uint8Array { 104 104 + const header = encode({ 105 105 + version: 1, 106 106 + roots: [root], 107 107 + }); 108 108 + const chunks: Uint8Array[] = [encodeVarint(header.byteLength), header]; 109 109 + 110 110 + for (const block of blocks) { 111 111 + const size = block.cid.bytes.byteLength + block.bytes.byteLength; 112 112 + chunks.push(encodeVarint(size), block.cid.bytes, block.bytes); 113 113 + } 114 114 + 115 115 + return concatBytes(chunks); 116 116 + } 117 117 + 118 118 + function encodeVarint(value: number): Uint8Array { 119 119 + const bytes: number[] = []; 120 120 + let next = value; 121 121 + 122 122 + do { 123 123 + let byte = next & 0x7f; 124 124 + next >>= 7; 125 125 + if (next > 0) { 126 126 + byte |= 0x80; 127 127 + } 128 128 + bytes.push(byte); 129 129 + } while (next > 0); 130 130 + 131 131 + return Uint8Array.from(bytes); 132 132 + } 133 133 + 134 134 + function concatBytes(chunks: Uint8Array[]): Uint8Array { 135 135 + const length = chunks.reduce((total, chunk) => total + chunk.byteLength, 0); 136 136 + const bytes = new Uint8Array(length); 137 137 + let offset = 0; 138 138 + 139 139 + for (const chunk of chunks) { 140 140 + bytes.set(chunk, offset); 141 141 + offset += chunk.byteLength; 142 142 + } 143 143 + 144 144 + return bytes; 145 145 + } 75 146 76 147 Deno.test("get resolves and fetches lexicons through xrpc", async () => { 77 148 const fixture = await createProofFixture(); ··· 141 212 142 213 Deno.test("resolve and fetch hooks can short-circuit the network path", async () => { 143 214 const uri = AtUri.make("did:plc:hooked", collection, nsid); 144 144 - const cid = await cidForCbor({ ok: true }); 215 215 + const cid = await cidForCbor(encode({ ok: true })); 145 216 const lexicon = createLexiconRecord(nsid); 146 217 147 218 const resolver = new LexResolver({