@bsv/overlay 2.3.0 → 2.6.1

package/dist/cjs/src/storage/mongo/MongoAdmissionStorage.js

@@ -0,0 +1,675 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoAdmissionStorage = void 0;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:timers/promises");
+const AdmissionStorage_js_1 = require("../AdmissionStorage.js");
+const MongoAdmissionPlan_js_1 = require("./MongoAdmissionPlan.js");
+const MongoPayloadStore_js_1 = require("./MongoPayloadStore.js");
+const MongoReadGuards_js_1 = require("./MongoReadGuards.js");
+const MongoSchema_js_1 = require("./MongoSchema.js");
+const MongoTransactionRunner_js_1 = require("./MongoTransactionRunner.js");
+function isMongoWriteConflict(error) {
+    if (typeof error !== 'object' || error === null)
+        return false;
+    const code = 'code' in error ? error.code : undefined;
+    if (code === 112 || code === '112')
+        return true;
+    if ('codeName' in error && error.codeName === 'WriteConflict')
+        return true;
+    const text = [
+        error instanceof Error ? error.message : '',
+        'errmsg' in error ? String(error.errmsg) : ''
+    ].join(' ');
+    return text.includes('Write conflict');
+}
+const majority = { w: 'majority', j: true };
+const schemaVersion = 1;
+const duplicateKey = (error) => typeof error === 'object' && error !== null && 'code' in error && error.code === 11000;
+const isPayloadKind = (value) => value === 'raw-transaction' ||
+    value === 'merkle-path' ||
+    value === 'beef-manifest' ||
+    value === 'locking-script' ||
+    value === 'outbox-data';
+/**
+ * Opt-in Mongo AdmissionStorage. Engine submit uses this only when
+ * getAdmissionStorage(storage) observes overlay-admission-v1.
+ */
+class MongoAdmissionStorage {
+    constructor(db, scope, options = {}) {
+        var _a, _b, _c, _d;
+        this.db = db;
+        this.protocol = 'overlay-admission-v1';
+        this.peers = new Map();
+        this.scope = { ...scope };
+        this.runner = (_a = options.runner) !== null && _a !== void 0 ? _a : new MongoTransactionRunner_js_1.MongoTransactionRunner(db, this.scope);
+        this.payloads = (_b = options.payloads) !== null && _b !== void 0 ? _b : new MongoPayloadStore_js_1.MongoPayloadStore(db, this.scope);
+        this.guards = (_c = options.readGuards) !== null && _c !== void 0 ? _c : new MongoReadGuards_js_1.MongoReadGuards(db);
+        this.enlisted = [...((_d = options.enlistedIndexes) !== null && _d !== void 0 ? _d : [])];
+        this.projector = options.projector;
+        if (this.enlisted.some(index => index.protocol !== 'overlay-mongo-index-v1' || index.target.length === 0)) {
+            throw new Error('Invalid enlisted Mongo lookup index');
+        }
+        if (new Set(this.enlisted.map(index => index.target)).size !== this.enlisted.length) {
+            throw new Error('Duplicate enlisted Mongo lookup index target');
+        }
+    }
+    enlistedTargets() {
+        return this.enlisted.map(index => index.target);
+    }
+    async commitAdmission(plan) {
+        if (!(0, MongoAdmissionPlan_js_1.sameScope)(plan.key.scope, this.scope) || !(0, MongoAdmissionPlan_js_1.sameScope)(plan.identity.scope, this.scope)) {
+            return await this.peerFor(plan.key.scope).commitAdmission(plan);
+        }
+        let semanticDigest;
+        try {
+            semanticDigest = (0, AdmissionStorage_js_1.admissionSemanticDigest)(plan.identity);
+        }
+        catch {
+            return { state: 'rejected', code: 'digest-mismatch' };
+        }
+        if (plan.key.semanticDigest !== semanticDigest ||
+            !(0, MongoAdmissionPlan_js_1.sameScope)(plan.key.scope, plan.identity.scope)) {
+            return { state: 'rejected', code: 'digest-mismatch' };
+        }
+        if (this.projector !== undefined && !(0, AdmissionStorage_js_1.isReplaySafeProjection)(this.projector)) {
+            return { state: 'rejected', code: 'unsupported-projection' };
+        }
+        const existing = await this.runner.reconcile(plan.key);
+        if (existing.state === 'committed' || existing.state === 'rejected')
+            return existing;
+        if (existing.state === 'pending' && existing.attemptId !== 'unlocated') {
+            const waited = await this.waitForPending(plan.key, existing.attemptId);
+            if (waited.state === 'committed' || waited.state === 'rejected')
+                return waited;
+        }
+        const rejected = (0, MongoAdmissionPlan_js_1.validateAdmissionPlan)(plan);
+        if (rejected !== undefined)
+            return { state: 'rejected', code: rejected };
+        let receipt;
+        try {
+            receipt = (0, MongoAdmissionPlan_js_1.admissionReceiptFor)(plan, this.enlistedTargets());
+        }
+        catch (error) {
+            return this.asResult(error);
+        }
+        await this.prepareReadGuards(plan);
+        await this.publishHistoryUpdatePayloads(plan);
+        return await this.runAdmissionWithWriteConflictRetry(plan, receipt);
+    }
+    async runAdmissionWithWriteConflictRetry(plan, receipt) {
+        for (let attempt = 0; attempt < 8; attempt += 1) {
+            try {
+                const result = await this.runner.run({ key: plan.key, identity: plan.identity, receipt }, async (context) => {
+                    await this.applyPlan(context, plan);
+                });
+                if (result.state !== 'pending')
+                    return result;
+                return await this.waitForPending(plan.key, result.attemptId);
+            }
+            catch (error) {
+                if (isMongoWriteConflict(error) && attempt < 7)
+                    continue;
+                return this.asResult(error);
+            }
+        }
+        return { state: 'rejected', code: 'spend-conflict' };
+    }
+    async waitForPending(key, attemptId) {
+        let current = { state: 'pending', attemptId };
+        for (let index = 0; index < 50 && current.state === 'pending'; index += 1) {
+            await (0, promises_1.setTimeout)(20);
+            const reconciled = await this.runner.reconcile(key, current.state === 'pending' ? current.attemptId : attemptId);
+            if (reconciled.state === 'committed' || reconciled.state === 'rejected')
+                return reconciled;
+            if (reconciled.state === 'aborted') {
+                return { state: 'pending', attemptId };
+            }
+            current = reconciled;
+        }
+        return current;
+    }
+    async reconcileAdmission(key, attemptId, options = {}) {
+        if (!(0, MongoAdmissionPlan_js_1.sameScope)(key.scope, this.scope))
+            return await this.peerFor(key.scope).reconcileAdmission(key, attemptId, options);
+        return await this.runner.reconcile(key, attemptId, options);
+    }
+    async close() {
+        await Promise.all([
+            this.runner.close(),
+            ...[...this.peers.values()].map(async (peer) => await peer.close())
+        ]);
+    }
+    peerFor(scope) {
+        const id = (0, MongoSchema_js_1.mongoNodeKey)(scope);
+        const existing = this.peers.get(id);
+        if (existing !== undefined)
+            return existing;
+        const peer = new MongoAdmissionStorage(this.db, scope, {
+            enlistedIndexes: this.enlisted,
+            projector: this.projector
+        });
+        this.peers.set(id, peer);
+        return peer;
+    }
+    async claimOutbox(kind, leaseMS = 15000) {
+        if (!Number.isSafeInteger(leaseMS) || leaseMS < 1 || leaseMS > 60000) {
+            throw new Error('Invalid Mongo outbox lease');
+        }
+        const claimed = await this.outbox(kind).findOneAndUpdate({
+            network: this.scope.network,
+            genesisHash: this.scope.genesisHash,
+            nodeId: this.scope.nodeId,
+            $or: [{ state: 'pending' }, { state: 'leased', $expr: { $lte: ['$leaseUntil', '$$NOW'] } }]
+        }, [
+            {
+                $set: {
+                    state: 'leased',
+                    leaseUntil: { $dateAdd: { startDate: '$$NOW', unit: 'millisecond', amount: leaseMS } },
+                    nextAttemptAt: {
+                        $dateAdd: { startDate: '$$NOW', unit: 'millisecond', amount: leaseMS }
+                    },
+                    updatedAt: '$$NOW'
+                }
+            }
+        ], { returnDocument: 'after', writeConcern: majority });
+        if (claimed === null)
+            return null;
+        return {
+            eventId: claimed.eventId,
+            kind,
+            target: claimed.target,
+            payloads: await this.outboxPayloads(kind, claimed.eventId)
+        };
+    }
+    async acknowledgeOutbox(kind, eventId) {
+        const result = await this.outbox(kind).updateOne({
+            _id: this.outboxId(kind, eventId),
+            eventId,
+            state: { $in: ['leased', 'delivered'] }
+        }, { $set: { state: 'delivered', updatedAt: new Date() } }, { writeConcern: majority });
+        if (result.matchedCount !== 1)
+            throw new Error('Mongo outbox event is not leased');
+    }
+    asResult(error) {
+        if (error instanceof MongoAdmissionPlan_js_1.AdmissionRejectedError)
+            return { state: 'rejected', code: error.code };
+        if (error instanceof MongoReadGuards_js_1.MongoReadGuardConflictError)
+            return { state: 'rejected', code: 'read-conflict' };
+        if (error instanceof Error && error.message === 'Mongo payload is not ready for reference') {
+            return { state: 'rejected', code: 'payload-not-ready' };
+        }
+        throw error;
+    }
+    async prepareReadGuards(plan) {
+        for (const decision of plan.decisions) {
+            for (const read of decision.reads)
+                await this.guards.initialize(this.scope, read.key);
+        }
+    }
+    async publishHistoryUpdatePayloads(plan) {
+        for (const decision of plan.decisions) {
+            if (decision.historyUpdate === undefined)
+                continue;
+            const bytes = Buffer.from(JSON.stringify(this.historyUpdateRecord(decision)), 'utf8');
+            const digest = (0, node_crypto_1.createHash)('sha256').update(bytes).digest('hex');
+            await this.payloads.publish({
+                kind: 'outbox-data',
+                digest,
+                byteLength: String(bytes.byteLength),
+                bytes: (async function* () {
+                    yield bytes;
+                })()
+            });
+        }
+    }
+    historyUpdateRecord(decision) {
+        if (decision.historyUpdate === undefined)
+            return { affectedFromHeight: '0' };
+        return {
+            affectedFromHeight: decision.historyUpdate.affectedFromHeight,
+            ...(decision.historyUpdate.handoff === undefined
+                ? {}
+                : { checkpoint: decision.historyUpdate.handoff.checkpoint })
+        };
+    }
+    async applyPlan(context, plan) {
+        var _a;
+        var _b;
+        await this.assertReadyPayloads(context, plan);
+        for (const decision of plan.decisions) {
+            await this.checkReads(context, decision);
+            await this.checkHistory(context, decision);
+            await this.assertAppliedAvailable(context, plan, decision);
+        }
+        for (const intent of plan.outbox)
+            await this.assertOutboxAvailable(context, intent);
+        for (const decision of plan.decisions) {
+            for (const spend of decision.spends)
+                await this.applySpend(context, decision.topic, spend);
+            for (const eviction of decision.evictions)
+                await this.applyEviction(context, decision.topic, eviction);
+            for (const output of decision.outputs)
+                await this.insertOutput(context, decision, output);
+            for (const edge of decision.edges)
+                await this.insertEdge(context, decision.topic, edge);
+            await this.insertApplied(context, plan, decision);
+            await this.applyHistoryUpdate(context, decision, (_b = (_a = plan.identity.topics.find(item => item.topic === decision.topic)) === null || _a === void 0 ? void 0 : _a.policyId) !== null && _b !== void 0 ? _b : 'default');
+        }
+        await this.upsertTransaction(context, plan);
+        for (const ref of (0, MongoAdmissionPlan_js_1.admissionPlanPayloads)(plan)) {
+            await this.pin(context, ref, 'transaction', plan.identity.txid, `${ref.kind}:${ref.digest}`);
+        }
+        for (const intent of (0, MongoAdmissionPlan_js_1.lookupOutboxIntents)(plan))
+            await this.insertOutbox(context, 'lookup', intent);
+        for (const intent of (0, MongoAdmissionPlan_js_1.propagationOutboxIntents)(plan)) {
+            await this.insertOutbox(context, 'propagation', intent);
+        }
+        for (const index of this.enlisted)
+            await index.apply(context, plan);
+    }
+    async assertReadyPayloads(context, plan) {
+        const seen = new Set();
+        for (const ref of (0, MongoAdmissionPlan_js_1.admissionPlanPayloads)(plan)) {
+            const id = this.payloadId(ref);
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            const found = await this.db
+                .collection(MongoSchema_js_1.MongoCollectionNames.payloads)
+                .findOne({ _id: id, state: 'ready', digest: ref.digest, kind: ref.kind }, context.options());
+            if (found === null || (0, MongoSchema_js_1.decodeMongoUint64)(String(found.byteLength)) !== ref.byteLength) {
+                (0, MongoAdmissionPlan_js_1.rejectAdmission)('payload-not-ready');
+            }
+        }
+    }
+    async checkReads(context, decision) {
+        for (const read of decision.reads) {
+            const options = context.options();
+            await this.guards.check(options.session, { scope: this.scope, key: read.key, expectedVersion: read.expectedVersion }, { timeoutMS: options.timeoutMS, signal: context.signal });
+        }
+    }
+    async checkHistory(context, decision) {
+        const document = await this.generations().findOne({ _id: this.generationId(decision.topic) }, context.options());
+        const epoch = document === null ? '0' : (0, MongoSchema_js_1.decodeMongoUint64)(document.chainEpoch);
+        const generation = document === null ? '0' : (0, MongoSchema_js_1.decodeMongoUint64)(document.topicHistoryGeneration);
+        if (epoch !== decision.expectedHistory.chainEpoch ||
+            generation !== decision.expectedHistory.topicHistoryGeneration) {
+            (0, MongoAdmissionPlan_js_1.rejectAdmission)('read-conflict');
+        }
+    }
+    async assertAppliedAvailable(context, plan, decision) {
+        const existing = await this.applied().findOne({ _id: this.appliedId(decision.topic, decision.applied.txid) }, context.options());
+        if (existing !== null && existing.admissionId !== plan.key.operationId) {
+            (0, MongoAdmissionPlan_js_1.rejectAdmission)('invalid-plan');
+        }
+    }
+    async assertOutboxAvailable(context, intent) {
+        const existing = await this.outbox(intent.kind).findOne({ _id: this.outboxId(intent.kind, intent.eventId) }, context.options());
+        if (existing !== null)
+            (0, MongoAdmissionPlan_js_1.rejectAdmission)('invalid-plan');
+    }
+    async applySpend(context, topic, spend) {
+        const id = this.outputId(topic, spend.outpoint);
+        const result = await this.outputs().findOneAndUpdate({
+            _id: id,
+            version: spend.expectedVersion,
+            state: 'unspent'
+        }, {
+            $set: {
+                state: 'spent',
+                spender: spend.spender,
+                updatedAt: new Date()
+            }
+        }, { ...context.options(), returnDocument: 'after' });
+        if (result === null) {
+            const current = await this.outputs().findOne({ _id: id }, context.options());
+            if ((current === null || current === void 0 ? void 0 : current.spender) === spend.spender && current.state === 'spent')
+                return;
+            (0, MongoAdmissionPlan_js_1.rejectAdmission)('spend-conflict');
+        }
+    }
+    async applyEviction(context, topic, eviction) {
+        const id = this.outputId(topic, eviction);
+        const result = await this.outputs().updateOne({ _id: id }, { $set: { state: 'evicted', updatedAt: new Date() } }, context.options());
+        if (result.matchedCount !== 1)
+            (0, MongoAdmissionPlan_js_1.rejectAdmission)('invalid-plan');
+    }
+    async insertOutput(context, decision, output) {
+        const now = new Date();
+        const payloadId = this.payloadId(output.script.payload);
+        try {
+            await this.outputs().insertOne({
+                _id: this.outputId(decision.topic, output),
+                schemaVersion,
+                network: this.scope.network,
+                genesisHash: this.scope.genesisHash,
+                nodeId: this.scope.nodeId,
+                topic: decision.topic,
+                txid: output.txid,
+                outputIndex: (0, MongoSchema_js_1.encodeMongoOutputIndex)(output.outputIndex),
+                satoshis: (0, MongoSchema_js_1.encodeMongoUint64)(output.satoshis),
+                score: (0, MongoSchema_js_1.encodeMongoUint64)(output.score),
+                scriptPayloadId: payloadId,
+                scriptOffset: (0, MongoSchema_js_1.encodeMongoUint64)(output.script.offset),
+                scriptByteLength: (0, MongoSchema_js_1.encodeMongoUint64)(output.script.byteLength),
+                state: 'unspent',
+                version: '1',
+                createdAt: now,
+                updatedAt: now
+            }, context.options());
+        }
+        catch (error) {
+            if (duplicateKey(error))
+                (0, MongoAdmissionPlan_js_1.rejectAdmission)('invalid-plan');
+            throw error;
+        }
+        await this.pin(context, output.script.payload, 'output', this.outputId(decision.topic, output), 'script');
+    }
+    async insertEdge(context, topic, edge) {
+        const now = new Date();
+        const id = (0, MongoSchema_js_1.mongoRecordKey)((0, MongoSchema_js_1.mongoNodeKey)(this.scope), 'edge', topic, edge.source.txid, (0, MongoSchema_js_1.encodeMongoOutputIndex)(edge.source.outputIndex), edge.consumer.txid, (0, MongoSchema_js_1.encodeMongoOutputIndex)(edge.consumer.outputIndex));
+        await this.db.collection(MongoSchema_js_1.MongoCollectionNames.consumptionEdges).updateOne({ _id: id }, {
+            $setOnInsert: {
+                _id: id,
+                schemaVersion,
+                network: this.scope.network,
+                genesisHash: this.scope.genesisHash,
+                nodeId: this.scope.nodeId,
+                topic,
+                sourceTxid: edge.source.txid,
+                sourceOutputIndex: (0, MongoSchema_js_1.encodeMongoOutputIndex)(edge.source.outputIndex),
+                consumerTxid: edge.consumer.txid,
+                consumerOutputIndex: (0, MongoSchema_js_1.encodeMongoOutputIndex)(edge.consumer.outputIndex),
+                createdAt: now
+            },
+            $set: { updatedAt: now }
+        }, { upsert: true, ...context.options() });
+    }
+    async insertApplied(context, plan, decision) {
+        const now = new Date();
+        const proven = decision.applied.block !== undefined;
+        try {
+            await this.applied().insertOne({
+                _id: this.appliedId(decision.topic, decision.applied.txid),
+                schemaVersion,
+                network: this.scope.network,
+                genesisHash: this.scope.genesisHash,
+                nodeId: this.scope.nodeId,
+                topic: decision.topic,
+                txid: decision.applied.txid,
+                state: proven ? 'active' : 'unproven',
+                admissionId: plan.key.operationId,
+                ...(decision.applied.firstSeenHeight === undefined
+                    ? {}
+                    : { firstSeenHeight: (0, MongoSchema_js_1.encodeMongoUint64)(decision.applied.firstSeenHeight) }),
+                ...(decision.applied.proof === undefined
+                    ? {}
+                    : { proofPayloadId: this.payloadId(decision.applied.proof) }),
+                createdAt: now,
+                updatedAt: now
+            }, context.options());
+        }
+        catch (error) {
+            if (duplicateKey(error))
+                (0, MongoAdmissionPlan_js_1.rejectAdmission)('invalid-plan');
+            throw error;
+        }
+        if (decision.applied.proof !== undefined) {
+            await this.pin(context, decision.applied.proof, 'applied-history', this.appliedId(decision.topic, decision.applied.txid), 'proof');
+        }
+    }
+    async applyHistoryUpdate(context, decision, policyId) {
+        if (decision.historyUpdate === undefined)
+            return;
+        const now = new Date();
+        const next = decision.historyUpdate.nextTopicHistoryGeneration;
+        const updated = await this.generations().findOneAndUpdate({
+            _id: this.generationId(decision.topic),
+            chainEpoch: (0, MongoSchema_js_1.encodeMongoUint64)(decision.expectedHistory.chainEpoch),
+            topicHistoryGeneration: (0, MongoSchema_js_1.encodeMongoUint64)(decision.expectedHistory.topicHistoryGeneration)
+        }, {
+            $set: {
+                topicHistoryGeneration: (0, MongoSchema_js_1.encodeMongoUint64)(next),
+                policyId,
+                updatedAt: now
+            }
+        }, { ...context.options(), returnDocument: 'after' });
+        if (updated === null) {
+            if (decision.expectedHistory.chainEpoch !== '0' ||
+                decision.expectedHistory.topicHistoryGeneration !== '0') {
+                (0, MongoAdmissionPlan_js_1.rejectAdmission)('read-conflict');
+            }
+            try {
+                await this.generations().insertOne({
+                    _id: this.generationId(decision.topic),
+                    schemaVersion,
+                    network: this.scope.network,
+                    genesisHash: this.scope.genesisHash,
+                    nodeId: this.scope.nodeId,
+                    topic: decision.topic,
+                    chainEpoch: (0, MongoSchema_js_1.encodeMongoUint64)(decision.expectedHistory.chainEpoch),
+                    topicHistoryGeneration: (0, MongoSchema_js_1.encodeMongoUint64)(next),
+                    policyId,
+                    createdAt: now,
+                    updatedAt: now
+                }, context.options());
+            }
+            catch (error) {
+                if (duplicateKey(error))
+                    (0, MongoAdmissionPlan_js_1.rejectAdmission)('read-conflict');
+                throw error;
+            }
+        }
+        if (decision.historyUpdate.handoff !== undefined) {
+            await this.applyHandoff(context, decision, decision.historyUpdate.handoff.expected, next);
+        }
+        const bytes = Buffer.from(JSON.stringify(this.historyUpdateRecord(decision)), 'utf8');
+        const digest = (0, node_crypto_1.createHash)('sha256').update(bytes).digest('hex');
+        const ref = {
+            kind: 'outbox-data',
+            digest,
+            byteLength: (0, AdmissionStorage_js_1.asStorageUint64)(String(bytes.byteLength))
+        };
+        const payload = await this.db
+            .collection(MongoSchema_js_1.MongoCollectionNames.payloads)
+            .findOne({ _id: this.payloadId(ref), state: 'ready' }, context.options());
+        if (payload === null)
+            (0, MongoAdmissionPlan_js_1.rejectAdmission)('payload-not-ready');
+        await this.replaceHistoryPin(context, decision.topic, decision.expectedHistory.topicHistoryGeneration, next, ref);
+    }
+    historyUpdateSlot(generation) {
+        return `history-update:${generation}`;
+    }
+    async replaceHistoryPin(context, topic, previousGeneration, nextGeneration, ref) {
+        const previousSlot = this.historyUpdateSlot(previousGeneration);
+        const previous = await this.db
+            .collection(MongoSchema_js_1.MongoCollectionNames.payloadReferences)
+            .findOne({
+            network: this.scope.network,
+            genesisHash: this.scope.genesisHash,
+            nodeId: this.scope.nodeId,
+            ownerKind: 'basm-job',
+            ownerId: topic,
+            slot: previousSlot
+        }, context.options());
+        if (previous !== null) {
+            const previousPayload = await this.db
+                .collection(MongoSchema_js_1.MongoCollectionNames.payloads)
+                .findOne({ _id: String(previous.payloadId) }, context.options());
+            if (previousPayload !== null &&
+                isPayloadKind(String(previousPayload.kind)) &&
+                typeof previousPayload.digest === 'string') {
+                const options = context.options();
+                await this.payloads.releaseReference(options.session, {
+                    scope: this.scope,
+                    payload: {
+                        kind: previousPayload.kind,
+                        digest: previousPayload.digest
+                    },
+                    ownerKind: 'basm-job',
+                    ownerId: topic,
+                    slot: previousSlot
+                }, { timeoutMS: options.timeoutMS, signal: context.signal });
+            }
+        }
+        await this.pin(context, ref, 'basm-job', topic, this.historyUpdateSlot(nextGeneration));
+    }
+    async applyHandoff(context, decision, expected, nextGeneration) {
+        var _a, _b;
+        var _c;
+        if (!(0, MongoAdmissionPlan_js_1.sameScope)(expected.scope, this.scope) ||
+            expected.topic !== decision.topic ||
+            expected.chainEpoch !== decision.expectedHistory.chainEpoch ||
+            expected.topicHistoryGeneration !== decision.expectedHistory.topicHistoryGeneration) {
+            (0, MongoAdmissionPlan_js_1.rejectAdmission)('read-conflict');
+        }
+        const now = new Date();
+        const result = await this.jobs().findOneAndUpdate({
+            _id: this.jobId(expected),
+            topic: expected.topic,
+            peerId: expected.peerId,
+            jobId: expected.jobId,
+            chainEpoch: (0, MongoSchema_js_1.encodeMongoUint64)(expected.chainEpoch),
+            topicHistoryGeneration: (0, MongoSchema_js_1.encodeMongoUint64)(expected.topicHistoryGeneration),
+            leaseToken: (0, MongoSchema_js_1.encodeMongoUint64)(expected.leaseToken),
+            $expr: { $gt: ['$leaseUntil', '$$NOW'] }
+        }, {
+            $set: {
+                topicHistoryGeneration: (0, MongoSchema_js_1.encodeMongoUint64)(nextGeneration),
+                checkpoint: (_c = (_b = (_a = decision.historyUpdate) === null || _a === void 0 ? void 0 : _a.handoff) === null || _b === void 0 ? void 0 : _b.checkpoint) !== null && _c !== void 0 ? _c : expected.jobId,
+                updatedAt: now
+            }
+        }, { ...context.options(), returnDocument: 'after' });
+        if (result === null)
+            (0, MongoAdmissionPlan_js_1.rejectAdmission)('read-conflict');
+    }
+    async upsertTransaction(context, plan) {
+        const raw = plan.payloads.find(ref => ref.kind === 'raw-transaction');
+        const manifest = plan.payloads.find(ref => ref.kind === 'beef-manifest');
+        const now = new Date();
+        const id = (0, MongoSchema_js_1.mongoRecordKey)((0, MongoSchema_js_1.mongoChainKey)(this.scope), 'transaction', plan.identity.txid);
+        await this.db.collection(MongoSchema_js_1.MongoCollectionNames.transactions).updateOne({ _id: id }, {
+            $setOnInsert: {
+                _id: id,
+                schemaVersion,
+                network: this.scope.network,
+                genesisHash: this.scope.genesisHash,
+                txid: plan.identity.txid,
+                ...(raw === undefined ? {} : { rawPayloadId: this.payloadId(raw) }),
+                ...(manifest === undefined ? {} : { manifestPayloadId: this.payloadId(manifest) }),
+                createdAt: now
+            },
+            $set: { updatedAt: now }
+        }, { upsert: true, ...context.options() });
+    }
+    async insertOutbox(context, kind, intent) {
+        const now = new Date();
+        try {
+            await this.outbox(kind).insertOne({
+                _id: this.outboxId(kind, intent.eventId),
+                schemaVersion,
+                network: this.scope.network,
+                genesisHash: this.scope.genesisHash,
+                nodeId: this.scope.nodeId,
+                eventId: intent.eventId,
+                target: intent.target,
+                state: 'pending',
+                nextAttemptAt: now,
+                leaseUntil: new Date(0),
+                createdAt: now,
+                updatedAt: now
+            }, context.options());
+        }
+        catch (error) {
+            if (duplicateKey(error))
+                (0, MongoAdmissionPlan_js_1.rejectAdmission)('invalid-plan');
+            throw error;
+        }
+        for (const [index, payload] of intent.payloads.entries()) {
+            await this.pin(context, payload, `${kind}-outbox`, intent.eventId, String(index));
+        }
+    }
+    async pin(context, ref, ownerKind, ownerId, slot) {
+        if (!isPayloadKind(ref.kind))
+            (0, MongoAdmissionPlan_js_1.rejectAdmission)('invalid-plan');
+        const options = context.options();
+        try {
+            await this.payloads.addReference(options.session, {
+                scope: this.scope,
+                payload: { kind: ref.kind, digest: ref.digest },
+                ownerKind,
+                ownerId,
+                slot
+            }, { timeoutMS: options.timeoutMS, signal: context.signal });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === 'Mongo payload is not ready for reference') {
+                (0, MongoAdmissionPlan_js_1.rejectAdmission)('payload-not-ready');
+            }
+            throw error;
+        }
+    }
+    async outboxPayloads(kind, eventId) {
+        const refs = await this.db
+            .collection(MongoSchema_js_1.MongoCollectionNames.payloadReferences)
+            .find({
+            network: this.scope.network,
+            genesisHash: this.scope.genesisHash,
+            nodeId: this.scope.nodeId,
+            ownerKind: `${kind}-outbox`,
+            ownerId: eventId
+        })
+            .sort({ slot: 1 })
+            .toArray();
+        const result = [];
+        for (const reference of refs) {
+            const payload = await this.db
+                .collection(MongoSchema_js_1.MongoCollectionNames.payloads)
+                .findOne({ _id: String(reference.payloadId) });
+            if (payload === null || !isPayloadKind(payload.kind))
+                continue;
+            result.push({
+                kind: payload.kind,
+                digest: payload.digest,
+                byteLength: (0, MongoSchema_js_1.decodeMongoUint64)(payload.byteLength)
+            });
+        }
+        return result;
+    }
+    payloadId(ref) {
+        return (0, MongoSchema_js_1.mongoRecordKey)((0, MongoSchema_js_1.mongoChainKey)(this.scope), ref.kind, ref.digest);
+    }
+    outputId(topic, outpoint) {
+        return (0, MongoSchema_js_1.mongoRecordKey)((0, MongoSchema_js_1.mongoNodeKey)(this.scope), 'output', topic, outpoint.txid, (0, MongoSchema_js_1.encodeMongoOutputIndex)(outpoint.outputIndex));
+    }
+    appliedId(topic, txid) {
+        return (0, MongoSchema_js_1.mongoRecordKey)((0, MongoSchema_js_1.mongoNodeKey)(this.scope), 'applied', topic, txid);
+    }
+    generationId(topic) {
+        return (0, MongoSchema_js_1.mongoRecordKey)((0, MongoSchema_js_1.mongoNodeKey)(this.scope), 'generation', topic);
+    }
+    jobId(lease) {
+        return (0, MongoSchema_js_1.mongoRecordKey)((0, MongoSchema_js_1.mongoNodeKey)(this.scope), 'job', lease.topic, lease.peerId, lease.jobId);
+    }
+    outboxId(kind, eventId) {
+        return (0, MongoSchema_js_1.mongoRecordKey)((0, MongoSchema_js_1.mongoNodeKey)(this.scope), `${kind}-outbox`, eventId);
+    }
+    outputs() {
+        return this.db.collection(MongoSchema_js_1.MongoCollectionNames.outputs);
+    }
+    applied() {
+        return this.db.collection(MongoSchema_js_1.MongoCollectionNames.appliedTransactions);
+    }
+    generations() {
+        return this.db.collection(MongoSchema_js_1.MongoCollectionNames.topicGenerations);
+    }
+    jobs() {
+        return this.db.collection(MongoSchema_js_1.MongoCollectionNames.basmRecoveryJobs);
+    }
+    outbox(kind) {
+        return this.db.collection(kind === 'lookup' ? MongoSchema_js_1.MongoCollectionNames.lookupOutbox : MongoSchema_js_1.MongoCollectionNames.propagationOutbox);
+    }
+}
+exports.MongoAdmissionStorage = MongoAdmissionStorage;
+//# sourceMappingURL=MongoAdmissionStorage.js.map