@kubun/store-p2p 0.18.1 → 0.20.0

package/lib/ops/mls.js

@@ -1,17 +1,25 @@
+import { decodeJSON } from '@kubun/db-adapter';
+function decodeMLSState(adapter, row) {
+    return {
+        ...row,
+        credential: row.is_deleted === 1 ? null : decodeJSON(adapter.kind, row.credential),
+        ledger_entries: decodeJSON(adapter.kind, row.ledger_entries)
+    };
+}
 export function createMLSOps(db, adapter) {
     return {
         async saveMLSState (state, expected) {
             if (expected === null) {
-                const inserted = await db.insertInto('kubun_p2p_group_mls_state').values({
+                const inserted = await db.insertInto('p2p_group_mls_state').values({
                     group_id: state.group_id,
                     device_id: state.device_id,
                     mls_state: adapter.encodeBinary(state.mls_state),
-                    credential: state.credential,
+                    credential: adapter.encodeJSON(JSON.parse(state.credential)),
                     epoch: state.epoch,
                     state_version: state.state_version ?? 0,
                     is_deleted: 0,
                     sender_generation_hwm: state.sender_generation_hwm ?? 0,
-                    ledger_entries: state.ledger_entries
+                    ledger_entries: state.ledger_entries == null ? undefined : adapter.encodeJSON(JSON.parse(state.ledger_entries))
                 }).onConflict((oc)=>oc.columns([
                         'group_id',
                         'device_id'
@@ -23,28 +31,28 @@ export function createMLSOps(db, adapter) {
                 if ((state.state_version ?? 0) <= expected.stateVersion) {
                     throw new Error(`MLS state version must advance for group ${state.group_id}`);
                 }
-                const saved = await db.updateTable('kubun_p2p_group_mls_state').set((eb)=>({
+                const saved = await db.updateTable('p2p_group_mls_state').set((eb)=>({
                         mls_state: adapter.encodeBinary(state.mls_state),
-                        credential: state.credential,
+                        credential: adapter.encodeJSON(JSON.parse(state.credential)),
                         epoch: state.epoch,
                         state_version: state.state_version ?? 0,
                         is_deleted: 0,
                         sender_generation_hwm: state.epoch === expected.epoch ? eb.ref('sender_generation_hwm') : 0,
-                        ledger_entries: state.ledger_entries ?? '[]',
+                        ledger_entries: adapter.encodeJSON(JSON.parse(state.ledger_entries ?? '[]')),
                         updated_at: adapter.encodeTimestamp(new Date())
                     })).where('group_id', '=', state.group_id).where('device_id', '=', state.device_id).where('epoch', '=', expected.epoch).where('state_version', '=', expected.stateVersion).returning('state_version').executeTakeFirst();
                 return saved != null;
             }
-            const saved = await db.insertInto('kubun_p2p_group_mls_state').values({
+            const saved = await db.insertInto('p2p_group_mls_state').values({
                 group_id: state.group_id,
                 device_id: state.device_id,
                 mls_state: adapter.encodeBinary(state.mls_state),
-                credential: state.credential,
+                credential: adapter.encodeJSON(JSON.parse(state.credential)),
                 epoch: state.epoch,
                 state_version: state.state_version ?? 0,
                 is_deleted: 0,
                 sender_generation_hwm: state.sender_generation_hwm ?? 0,
-                ledger_entries: state.ledger_entries
+                ledger_entries: state.ledger_entries == null ? undefined : adapter.encodeJSON(JSON.parse(state.ledger_entries))
             }).onConflict((oc)=>oc.columns([
                     'group_id',
                     'device_id'
@@ -54,17 +62,17 @@ export function createMLSOps(db, adapter) {
                         epoch: eb.ref('excluded.epoch'),
                         state_version: eb.ref('excluded.state_version'),
                         is_deleted: 0,
-                        sender_generation_hwm: eb.case().when('kubun_p2p_group_mls_state.epoch', '=', eb.ref('excluded.epoch')).then(eb.ref('kubun_p2p_group_mls_state.sender_generation_hwm')).else(0).end(),
+                        sender_generation_hwm: eb.case().when('p2p_group_mls_state.epoch', '=', eb.ref('excluded.epoch')).then(eb.ref('p2p_group_mls_state.sender_generation_hwm')).else(0).end(),
                         ledger_entries: eb.ref('excluded.ledger_entries'),
                         updated_at: adapter.encodeTimestamp(new Date())
                     }))// Epochs order commits; the state version orders in-place secret-tree
                 // mutations within an epoch. A late persist of an older snapshot
                 // must never overwrite a newer generation at the same epoch.
                 .where((eb)=>eb.or([
-                        eb('kubun_p2p_group_mls_state.epoch', '<', eb.ref('excluded.epoch')),
+                        eb('p2p_group_mls_state.epoch', '<', eb.ref('excluded.epoch')),
                         eb.and([
-                            eb('kubun_p2p_group_mls_state.epoch', '=', eb.ref('excluded.epoch')),
-                            eb('kubun_p2p_group_mls_state.state_version', '<', eb.ref('excluded.state_version'))
+                            eb('p2p_group_mls_state.epoch', '=', eb.ref('excluded.epoch')),
+                            eb('p2p_group_mls_state.state_version', '<', eb.ref('excluded.state_version'))
                         ])
                     ]))).returning('state_version').executeTakeFirst();
             return saved != null;
@@ -74,7 +82,7 @@ export function createMLSOps(db, adapter) {
                 throw new Error('Invalid sender generation reservation');
             }
             for(;;){
-                const row = await db.selectFrom('kubun_p2p_group_mls_state').select([
+                const row = await db.selectFrom('p2p_group_mls_state').select([
                     'epoch',
                     'sender_generation_hwm'
                 ]).where('group_id', '=', groupID).where('device_id', '=', deviceID).where('is_deleted', '=', 0).executeTakeFirst();
@@ -86,7 +94,7 @@ export function createMLSOps(db, adapter) {
                 if (!Number.isSafeInteger(next)) throw new Error('Sender generation reservation overflow');
                 let reserved = next;
                 if (next !== row.sender_generation_hwm) {
-                    const updated = await db.updateTable('kubun_p2p_group_mls_state').set({
+                    const updated = await db.updateTable('p2p_group_mls_state').set({
                         sender_generation_hwm: next
                     }).where('group_id', '=', groupID).where('device_id', '=', deviceID).where('epoch', '=', epoch).where('is_deleted', '=', 0).where('sender_generation_hwm', '=', row.sender_generation_hwm).returning('sender_generation_hwm').executeTakeFirst();
                     if (updated == null) continue;
@@ -94,7 +102,7 @@ export function createMLSOps(db, adapter) {
                 }
                 if (senderState != null) {
                     // A later reservation by another holder wins: its state is newer.
-                    await db.updateTable('kubun_p2p_group_mls_state').set({
+                    await db.updateTable('p2p_group_mls_state').set({
                         mls_state: adapter.encodeBinary(senderState.mlsState)
                     }).where('group_id', '=', groupID).where('device_id', '=', deviceID).where('epoch', '=', epoch).where('is_deleted', '=', 0).where('state_version', '=', senderState.stateVersion).where('sender_generation_hwm', '=', reserved).execute();
                 }
@@ -102,15 +110,16 @@ export function createMLSOps(db, adapter) {
             }
         },
         async getMLSState (groupID, deviceID, options) {
-            let query = db.selectFrom('kubun_p2p_group_mls_state').selectAll().where('group_id', '=', groupID).where('device_id', '=', deviceID);
+            let query = db.selectFrom('p2p_group_mls_state').selectAll().where('group_id', '=', groupID).where('device_id', '=', deviceID);
             if (options?.includeDeleted !== true) query = query.where('is_deleted', '=', 0);
-            return await query.executeTakeFirst();
+            const row = await query.executeTakeFirst();
+            return row == null ? undefined : decodeMLSState(adapter, row);
         },
         async deleteMLSState (groupID, deviceID, expected) {
-            let query = db.updateTable('kubun_p2p_group_mls_state').set((eb)=>({
+            let query = db.updateTable('p2p_group_mls_state').set((eb)=>({
                     mls_state: adapter.encodeBinary(new Uint8Array()),
-                    credential: '',
-                    ledger_entries: '[]',
+                    credential: adapter.encodeJSON(''),
+                    ledger_entries: adapter.encodeJSON([]),
                     sender_generation_hwm: 0,
                     is_deleted: 1,
                     state_version: eb('state_version', '+', 1),
@@ -123,17 +132,18 @@ export function createMLSOps(db, adapter) {
             return deleted != null;
         },
         async listMLSStates (groupID) {
-            return await db.selectFrom('kubun_p2p_group_mls_state').selectAll().where('group_id', '=', groupID).where('is_deleted', '=', 0).execute();
+            const rows = await db.selectFrom('p2p_group_mls_state').selectAll().where('group_id', '=', groupID).where('is_deleted', '=', 0).execute();
+            return rows.map((row)=>decodeMLSState(adapter, row));
         },
         async listMLSStateGroupIDs (deviceID) {
-            const rows = await db.selectFrom('kubun_p2p_group_mls_state').select('group_id').where('device_id', '=', deviceID).where('is_deleted', '=', 0).execute();
+            const rows = await db.selectFrom('p2p_group_mls_state').select('group_id').where('device_id', '=', deviceID).where('is_deleted', '=', 0).execute();
             return rows.map((row)=>row.group_id);
         },
         async deleteGroupMLSStates (groupID) {
-            await db.updateTable('kubun_p2p_group_mls_state').set((eb)=>({
+            await db.updateTable('p2p_group_mls_state').set((eb)=>({
                     mls_state: adapter.encodeBinary(new Uint8Array()),
-                    credential: '',
-                    ledger_entries: '[]',
+                    credential: adapter.encodeJSON(''),
+                    ledger_entries: adapter.encodeJSON([]),
                     sender_generation_hwm: 0,
                     is_deleted: 1,
                     state_version: eb('state_version', '+', 1),

package/lib/ops/own-agents.d.ts

@@ -1,6 +1,7 @@
+import { type RecordDecision, type RecordDecisionMap, type RecordKey, type SignedRecord } from '@kokuin/records';
 import { type MethodRegistry } from '@kokuin/token';
+import type { StoreAPIContext } from '@kubun/db';
 import { type Adapter } from '@kubun/db-adapter';
-import { type RecordDecision, type RecordDecisionMap, type RecordKey, type SignedRecord } from '@kubun/records';
 import { type Kysely } from 'kysely';
 import type { GroupKind, OwnAgentsGrantKind, P2PStoreTables } from '../tables.js';
 export type OwnAgentsRecordKey = RecordKey;
@@ -64,5 +65,4 @@ export type OwnAgentsOps = {
     deleteJoinCapability(groupID: string): Promise<void>;
 };
 export declare const ownAgentsRecordLockKey: (key: RecordKey) => string;
-export declare function ownAgentsAdvisoryLockIDs(ids: ReadonlyArray<bigint>): Array<bigint>;
-export declare function createOwnAgentsOps(db: Kysely<P2PStoreTables>, adapter: Adapter): OwnAgentsOps;
+export declare function createOwnAgentsOps(db: Kysely<P2PStoreTables>, adapter: Adapter, context: StoreAPIContext): OwnAgentsOps;

package/lib/ops/own-agents.js

@@ -1,7 +1,8 @@
+import { recordClaimDigest, recordDecisionFromVerifiedCopies, recordKeyText, recordPayloadMatches, recordSignerKey, verifySignedRecord } from '@kokuin/records';
 import { normalizeDID } from '@kokuin/token';
-import { AbstractPostgresAdapter, chunked } from '@kubun/db-adapter';
-import { recordClaimDigest, recordDecisionFromVerifiedCopies, recordKeyText, recordPayloadMatches, recordSignerKey, verifySignedRecord } from '@kubun/records';
+import { chunked, decodeJSON } from '@kubun/db-adapter';
 import { sql } from 'kysely';
+import { withP2PKeyLocks } from '../scope.js';
 export class OwnAgentsTransactionError extends Error {
     constructor(){
         super('Own agents operation requires a transaction');
@@ -35,9 +36,13 @@ export const ownAgentsRecordLockKey = (key)=>JSON.stringify([
 function requireType(type) {
     if (type !== 'ownAgents.group' && type !== 'ownAgents.capability') throw new OwnAgentsRecordError(`Unsupported own agents record type: ${type}`);
 }
-async function verifiedRows(rows, methods) {
+async function verifiedRows({ rows, adapter, methods, crypto }) {
     const valid = [];
-    for (const row of rows){
+    for (const encoded of rows){
+        const row = {
+            ...encoded,
+            meta: decodeJSON(adapter.kind, encoded.meta)
+        };
         const copy = {
             type: row.type,
             owner: row.owner,
@@ -47,39 +52,35 @@ async function verifiedRows(rows, methods) {
             opHash: row.op_hash,
             payload: row.payload === null ? null : Uint8Array.from(row.payload)
         };
-        const op = await verifySignedRecord(copy, methods);
-        if (op !== null && recordPayloadMatches(copy, op.claim)) valid.push({
+        const op = await verifySignedRecord({
+            record: copy,
+            opKind: 'kubun/record-op',
+            methods,
+            crypto
+        });
+        if (op !== null && await recordPayloadMatches({
+            record: copy,
+            claim: op.claim,
+            crypto
+        })) valid.push({
             copy,
             op
         });
     }
     return valid;
 }
-export function ownAgentsAdvisoryLockIDs(ids) {
-    return [
-        ...new Set(ids)
-    ].sort((left, right)=>left < right ? -1 : left > right ? 1 : 0);
-}
-export function createOwnAgentsOps(db, adapter) {
-    const lockKeys = async (tx, keys)=>{
-        if (!(adapter instanceof AbstractPostgresAdapter)) return;
-        const ids = new Set();
-        for (const key of new Set(keys)){
-            const result = await sql`select hashtextextended(${key}, 0)::text as id`.execute(tx);
-            for (const row of result.rows)ids.add(BigInt(row.id));
-        }
-        for (const id of ownAgentsAdvisoryLockIDs([
-            ...ids
-        ])){
-            await sql`select pg_advisory_xact_lock(${id.toString()}::bigint)`.execute(tx);
-        }
+export function createOwnAgentsOps(db, adapter, context) {
+    const withRecordLocks = async (keys, run)=>{
+        return await withP2PKeyLocks(context, 'p2p_own_agents_records', keys.map((key)=>[
+                key
+            ]), run);
     };
-    const rowsFor = (tx, key)=>tx.selectFrom('kubun_p2p_own_agents_records').selectAll().where('type', '=', key.type).where('owner', '=', key.owner).where('id', '=', key.id).execute();
-    const deleteCopy = (tx, key, hash)=>tx.deleteFrom('kubun_p2p_own_agents_records').where('type', '=', key.type).where('owner', '=', key.owner).where('id', '=', key.id).where('op_hash', '=', hash).execute();
+    const rowsFor = (tx, key)=>tx.selectFrom('p2p_own_agents_records').selectAll().where('type', '=', key.type).where('owner', '=', key.owner).where('id', '=', key.id).execute();
+    const deleteCopy = (tx, key, hash)=>tx.deleteFrom('p2p_own_agents_records').where('type', '=', key.type).where('owner', '=', key.owner).where('id', '=', key.id).where('op_hash', '=', hash).execute();
     return {
         async retainAccessDefaultRevocations (controllerDID, deviceDIDs) {
             if (deviceDIDs.length === 0) return;
-            await db.insertInto('kubun_p2p_access_default_revocations').values(deviceDIDs.map((did)=>({
+            await db.insertInto('p2p_access_default_revocations').values(deviceDIDs.map((did)=>({
                     controller_did: controllerDID,
                     device_did: normalizeDID(did)
                 }))).onConflict((oc)=>oc.columns([
@@ -88,7 +89,7 @@ export function createOwnAgentsOps(db, adapter) {
                 ]).doNothing()).execute();
         },
         async isAccessDefaultSignerRevoked (controllerDID, deviceDID) {
-            return await db.selectFrom('kubun_p2p_access_default_revocations').select('device_did').where('controller_did', '=', controllerDID).where('device_did', '=', normalizeDID(deviceDID)).executeTakeFirst() != null;
+            return await db.selectFrom('p2p_access_default_revocations').select('device_did').where('controller_did', '=', controllerDID).where('device_did', '=', normalizeDID(deviceDID)).executeTakeFirst() != null;
         },
         async recordBindingEvidence (bindings) {
             const rows = new Map();
@@ -103,7 +104,7 @@ export function createOwnAgentsOps(db, adapter) {
                 ]), row);
             }
             if (rows.size === 0) return;
-            await db.insertInto('kubun_p2p_binding_evidence').values([
+            await db.insertInto('p2p_binding_evidence').values([
                 ...rows.values()
             ]).onConflict((oc)=>oc.columns([
                     'controller_did',
@@ -111,28 +112,37 @@ export function createOwnAgentsOps(db, adapter) {
                 ]).doNothing()).execute();
         },
         async listBindingControllers (deviceDID) {
-            const rows = await db.selectFrom('kubun_p2p_binding_evidence').select('controller_did').where('device_did', '=', normalizeDID(deviceDID)).orderBy('controller_did').execute();
+            const rows = await db.selectFrom('p2p_binding_evidence').select('controller_did').where('device_did', '=', normalizeDID(deviceDID)).orderBy('controller_did').execute();
             return rows.map((row)=>row.controller_did);
         },
         async setGroupKind (groupID, kind) {
             if (!db.isTransaction) throw new OwnAgentsTransactionError();
-            let update = db.updateTable('kubun_p2p_groups').set({
+            let update = db.updateTable('p2p_groups').set({
                 kind
             }).where('id', '=', groupID);
             if (kind === 'standard') update = update.where('kind', '=', 'standard');
             const result = await update.executeTakeFirst();
             if (result.numUpdatedRows === 0n) {
-                const row = await db.selectFrom('kubun_p2p_groups').select('kind').where('id', '=', groupID).executeTakeFirst();
+                const row = await db.selectFrom('p2p_groups').select('kind').where('id', '=', groupID).executeTakeFirst();
                 if (row === undefined) throw new OwnAgentsGroupNotFoundError(groupID);
                 throw new OwnAgentsKindDowngradeError(groupID);
             }
         },
         async getGroupKind (groupID) {
-            return (await db.selectFrom('kubun_p2p_groups').select('kind').where('id', '=', groupID).executeTakeFirst())?.kind;
+            return (await db.selectFrom('p2p_groups').select('kind').where('id', '=', groupID).executeTakeFirst())?.kind;
         },
         async getOwnAgentsRecordDecision (key, methods) {
             requireType(key.type);
-            return recordDecisionFromVerifiedCopies(key, await verifiedRows(await rowsFor(db, key), methods), 'hlc');
+            return recordDecisionFromVerifiedCopies({
+                key,
+                entries: await verifiedRows({
+                    rows: await rowsFor(db, key),
+                    adapter,
+                    methods,
+                    crypto: context.crypto
+                }),
+                stampSource: 'hlc'
+            });
         },
         async getOwnAgentsRecordDecisions (keys, methods) {
             const wanted = new Map();
@@ -150,7 +160,7 @@ export function createOwnAgentsOps(db, adapter) {
                     ...idSet
                 ];
                 for (const chunk of chunked(ids)){
-                    const rows = await db.selectFrom('kubun_p2p_own_agents_records').selectAll().where('type', '=', type).where('id', 'in', chunk).execute();
+                    const rows = await db.selectFrom('p2p_own_agents_records').selectAll().where('type', '=', type).where('id', 'in', chunk).execute();
                     for (const row of rows){
                         const text = recordKeyText(row);
                         if (!wanted.has(text)) continue;
@@ -163,7 +173,16 @@ export function createOwnAgentsOps(db, adapter) {
             const decisions = new Map();
             for (const [text, rows] of groups){
                 const key = wanted.get(text);
-                const decision = recordDecisionFromVerifiedCopies(key, await verifiedRows(rows, methods), 'hlc');
+                const decision = recordDecisionFromVerifiedCopies({
+                    key,
+                    entries: await verifiedRows({
+                        rows,
+                        adapter,
+                        methods,
+                        crypto: context.crypto
+                    }),
+                    stampSource: 'hlc'
+                });
                 if (decision !== null) decisions.set(text, decision);
             }
             return decisions;
@@ -171,7 +190,7 @@ export function createOwnAgentsOps(db, adapter) {
         async listOwnAgentsRecordDecisions (types, methods) {
             for (const type of types)requireType(type);
             if (types.length === 0) return [];
-            const rows = await db.selectFrom('kubun_p2p_own_agents_records').selectAll().where('type', 'in', [
+            const rows = await db.selectFrom('p2p_own_agents_records').selectAll().where('type', 'in', [
                 ...types
             ]).orderBy('type').orderBy('owner').orderBy('id').execute();
             const groups = new Map();
@@ -190,30 +209,60 @@ export function createOwnAgentsOps(db, adapter) {
                     owner: first.owner,
                     id: first.id
                 };
-                const decision = recordDecisionFromVerifiedCopies(key, await verifiedRows(rows, methods), 'hlc');
+                const decision = recordDecisionFromVerifiedCopies({
+                    key,
+                    entries: await verifiedRows({
+                        rows,
+                        adapter,
+                        methods,
+                        crypto: context.crypto
+                    }),
+                    stampSource: 'hlc'
+                });
                 if (decision !== null) decisions.push(decision);
             }
             return decisions;
         },
         async putOwnAgentsRecordCopy (record, methods) {
             requireType(record.type);
-            const op = await verifySignedRecord(record, methods);
-            if (op === null || !recordPayloadMatches(record, op.claim)) throw new OwnAgentsRecordError('Invalid signed own agents copy');
-            const signerKey = recordSignerKey(op.issuer, record.opJWT);
+            const op = await verifySignedRecord({
+                record,
+                opKind: 'kubun/record-op',
+                methods,
+                crypto: context.crypto
+            });
+            if (op === null || !await recordPayloadMatches({
+                record,
+                claim: op.claim,
+                crypto: context.crypto
+            })) throw new OwnAgentsRecordError('Invalid signed own agents copy');
+            const signerKey = recordSignerKey({
+                issuer: op.issuer,
+                opJWT: record.opJWT
+            });
             if (signerKey === null) throw new OwnAgentsRecordError('Invalid own agents signer key');
             const key = {
                 type: record.type,
                 owner: record.owner,
                 id: record.id
             };
-            const digest = recordClaimDigest(op.claim);
+            const digest = await recordClaimDigest({
+                claim: op.claim,
+                crypto: context.crypto
+            });
             const write = async (tx)=>{
-                await lockKeys(tx, [
-                    ownAgentsRecordLockKey(key)
-                ]);
                 const rows = await rowsFor(tx, key);
-                const valid = await verifiedRows(rows, methods);
-                const winner = recordDecisionFromVerifiedCopies(key, valid, 'hlc');
+                const valid = await verifiedRows({
+                    rows,
+                    adapter,
+                    methods,
+                    crypto: context.crypto
+                });
+                const winner = recordDecisionFromVerifiedCopies({
+                    key,
+                    entries: valid,
+                    stampSource: 'hlc'
+                });
                 const retained = winner?.decisionHLC === record.hlc && winner.contentDigest === digest ? valid : [];
                 const keepBySigner = new Map([
                     [
@@ -222,18 +271,24 @@ export function createOwnAgentsOps(db, adapter) {
                     ]
                 ]);
                 for (const entry of retained){
-                    const key = recordSignerKey(entry.op.issuer, entry.copy.opJWT);
+                    const key = recordSignerKey({
+                        issuer: entry.op.issuer,
+                        opJWT: entry.copy.opJWT
+                    });
                     if (key === null) continue;
                     const previous = keepBySigner.get(key);
                     if (previous === undefined || compareStrings(entry.copy.opHash, previous) < 0) keepBySigner.set(key, entry.copy.opHash);
                 }
                 for (const row of rows){
                     const entry = retained.find((entry)=>entry.copy.opHash === row.op_hash);
-                    const signer = entry === undefined ? null : recordSignerKey(entry.op.issuer, entry.copy.opJWT);
+                    const signer = entry === undefined ? null : recordSignerKey({
+                        issuer: entry.op.issuer,
+                        opJWT: entry.copy.opJWT
+                    });
                     if (signer === null || keepBySigner.get(signer) !== row.op_hash) await deleteCopy(tx, key, row.op_hash);
                 }
                 if (keepBySigner.get(signerKey) !== record.opHash) return false;
-                await tx.insertInto('kubun_p2p_own_agents_records').values({
+                await tx.insertInto('p2p_own_agents_records').values({
                     type: record.type,
                     owner: record.owner,
                     id: record.id,
@@ -252,28 +307,32 @@ export function createOwnAgentsOps(db, adapter) {
                     ]).doNothing()).execute();
                 return true;
             };
-            if (db.isTransaction) return await write(db);
-            return await db.transaction().execute(write);
+            return await withRecordLocks([
+                ownAgentsRecordLockKey(key)
+            ], write);
         },
         async pruneOwnAgentsRecordCopy (key, signerDID, methods) {
             requireType(key.type);
             const signer = normalizeDID(signerDID);
             const write = async (tx)=>{
-                await lockKeys(tx, [
-                    ownAgentsRecordLockKey(key)
-                ]);
-                const valid = await verifiedRows(await rowsFor(tx, key), methods);
+                const valid = await verifiedRows({
+                    rows: await rowsFor(tx, key),
+                    adapter,
+                    methods,
+                    crypto: context.crypto
+                });
                 if (!valid.some((entry)=>entry.op.issuer !== signer)) return;
                 for (const entry of valid){
                     if (entry.op.issuer === signer) await deleteCopy(tx, key, entry.copy.opHash);
                 }
             };
-            if (db.isTransaction) await write(db);
-            else await db.transaction().execute(write);
+            await withRecordLocks([
+                ownAgentsRecordLockKey(key)
+            ], write);
         },
         async lockOwnAgentsRecordKeys (keys) {
             if (!db.isTransaction) throw new OwnAgentsTransactionError();
-            await lockKeys(db, keys);
+            await withRecordLocks(keys, async ()=>{});
         },
         async putOwnGrant (controllerDID, kind, token, issuedAt, expiresAt) {
             const row = {
@@ -283,13 +342,10 @@ export function createOwnAgentsOps(db, adapter) {
                 issued_at: issuedAt,
                 expires_at: expiresAt
             };
-            await db.insertInto('kubun_p2p_own_agents_grants').values(row).onConflict((oc)=>oc.columns([
-                    'controller_did',
-                    'kind'
-                ]).doUpdateSet(row).whereRef('excluded.issued_at', '>', 'kubun_p2p_own_agents_grants.issued_at')).execute();
+            await context.compareWrite('p2p_own_agents_grants', row);
         },
         async getOwnGrants (controllerDID) {
-            let query = db.selectFrom('kubun_p2p_own_agents_grants').selectAll();
+            let query = db.selectFrom('p2p_own_agents_grants').selectAll();
             if (controllerDID != null) query = query.where('controller_did', '=', controllerDID);
             const rows = await query.orderBy('kind').execute();
             return rows.map((row)=>({
@@ -316,11 +372,11 @@ export function createOwnAgentsOps(db, adapter) {
             };
             const preserveBinding = (column)=>{
                 return sql`case
-          when kubun_p2p_own_agents_join_capabilities.token = excluded.token
-          then ${sql.ref(`kubun_p2p_own_agents_join_capabilities.${column}`)}
+          when ${sql.ref('p2p_own_agents_join_capabilities.token')} = excluded.token
+          then ${sql.ref(`p2p_own_agents_join_capabilities.${column}`)}
           else null end`;
             };
-            await db.insertInto('kubun_p2p_own_agents_join_capabilities').values(row).onConflict((oc)=>{
+            await db.insertInto('p2p_own_agents_join_capabilities').values(row).onConflict((oc)=>{
                 return oc.column('group_id').doUpdateSet({
                     ...row,
                     // Re-accepting the same consent must not erase authenticated admission evidence.
@@ -334,23 +390,23 @@ export function createOwnAgentsOps(db, adapter) {
             }).execute();
         },
         async deleteJoinCapability (groupID) {
-            await db.deleteFrom('kubun_p2p_own_agents_join_capabilities').where('group_id', '=', groupID).execute();
+            await db.deleteFrom('p2p_own_agents_join_capabilities').where('group_id', '=', groupID).execute();
         },
         async getJoinCapability (groupID) {
-            const row = await db.selectFrom('kubun_p2p_own_agents_join_capabilities').selectAll().where('group_id', '=', groupID).executeTakeFirst();
+            const row = await db.selectFrom('p2p_own_agents_join_capabilities').selectAll().where('group_id', '=', groupID).executeTakeFirst();
+            const prefix = decodeJSON(adapter.kind, row?.signer_prefix);
             return row == null ? undefined : {
                 groupID: row.group_id,
                 recipientDID: row.recipient_did,
                 capabilityID: row.capability_id,
                 token: row.token,
                 expiresAt: Number(row.expires_at),
-                ...row.signer_did == null || row.signer_leaf_key == null || row.signer_capability == null || row.signer_prefix == null ? {} : {
+                ...row.signer_did == null || row.signer_leaf_key == null || row.signer_capability == null || prefix == null ? {} : {
                     signerBinding: {
                         did: row.signer_did,
                         leafKey: new Uint8Array(row.signer_leaf_key),
                         capability: row.signer_capability,
-                        // The JSON results plugin also parses serialized events inside arrays.
-                        prefix: row.signer_prefix.events.map((event)=>typeof event === 'string' ? event : JSON.stringify(event))
+                        prefix: prefix.events
                     }
                 }
             };

package/lib/ops/sync.d.ts

@@ -1,4 +1,4 @@
-import type { Adapter } from '@kubun/db-adapter';
+import { type Adapter } from '@kubun/db-adapter';
 import type { Kysely } from 'kysely';
 import type { InsertSyncPeer, P2PStoreTables, SyncPeer } from '../tables.js';
 export declare class BroadcastLogPruneParamsError extends Error {

package/lib/ops/sync.js

@@ -1,4 +1,5 @@
 import { normalizeDID } from '@kokuin/token';
+import { decodeJSON } from '@kubun/db-adapter';
 export class BroadcastLogPruneParamsError extends Error {
     get code() {
         return 'P2P_BROADCAST_LOG_PRUNE_PARAMS';
@@ -12,7 +13,7 @@ export function createSyncOps(db, adapter) {
     return {
         async addSyncPeer (peer) {
             const config = adapter.encodeJSON(peer.config);
-            await db.insertInto('kubun_p2p_sync_peers').values({
+            await db.insertInto('p2p_sync_peers').values({
                 ...peer,
                 peer_did: normalizeDID(peer.peer_did),
                 config
@@ -23,10 +24,18 @@ export function createSyncOps(db, adapter) {
                 })).execute();
         },
         async getSyncPeer (peerDID) {
-            return await db.selectFrom('kubun_p2p_sync_peers').selectAll().where('peer_did', '=', normalizeDID(peerDID)).executeTakeFirst();
+            const row = await db.selectFrom('p2p_sync_peers').selectAll().where('peer_did', '=', normalizeDID(peerDID)).executeTakeFirst();
+            return row == null ? undefined : {
+                ...row,
+                config: decodeJSON(adapter.kind, row.config)
+            };
         },
         async listSyncPeers () {
-            return await db.selectFrom('kubun_p2p_sync_peers').selectAll().execute();
+            const rows = await db.selectFrom('p2p_sync_peers').selectAll().execute();
+            return rows.map((row)=>({
+                    ...row,
+                    config: decodeJSON(adapter.kind, row.config)
+                }));
         },
         async updateSyncPeer (peerDID, update) {
             const values = {};
@@ -35,14 +44,14 @@ export function createSyncOps(db, adapter) {
             // Through the adapter, like every sibling write: the column is a
             // `timestamptz(3)` on Postgres, which a raw epoch number is not.
             values.updated_at = adapter.encodeTimestamp(new Date());
-            await db.updateTable('kubun_p2p_sync_peers').set(values).where('peer_did', '=', normalizeDID(peerDID)).execute();
+            await db.updateTable('p2p_sync_peers').set(values).where('peer_did', '=', normalizeDID(peerDID)).execute();
         },
         async removeSyncPeer (peerDID) {
-            await db.deleteFrom('kubun_p2p_sync_peers').where('peer_did', '=', normalizeDID(peerDID)).execute();
+            await db.deleteFrom('p2p_sync_peers').where('peer_did', '=', normalizeDID(peerDID)).execute();
         },
         // --- Broadcast log operations ---
         async recordBroadcast (entry) {
-            const result = await db.insertInto('kubun_p2p_broadcast_log').values({
+            const result = await db.insertInto('p2p_broadcast_log').values({
                 doc_id: entry.docID,
                 version: entry.version,
                 mls_group_id: entry.mlsGroupID
@@ -54,7 +63,7 @@ export function createSyncOps(db, adapter) {
             return (result.numInsertedOrUpdatedRows ?? 0n) > 0n;
         },
         async hasBroadcast (entry) {
-            const row = await db.selectFrom('kubun_p2p_broadcast_log').select('doc_id').where('doc_id', '=', entry.docID).where('version', '=', entry.version).where('mls_group_id', '=', entry.mlsGroupID).limit(1).executeTakeFirst();
+            const row = await db.selectFrom('p2p_broadcast_log').select('doc_id').where('doc_id', '=', entry.docID).where('version', '=', entry.version).where('mls_group_id', '=', entry.mlsGroupID).limit(1).executeTakeFirst();
             return row != null;
         },
         async pruneBroadcastLog (params) {
@@ -66,7 +75,7 @@ export function createSyncOps(db, adapter) {
                 throw new BroadcastLogPruneParamsError('pruneBroadcastLog: limit must be a positive integer');
             }
             const before = adapter.encodeTimestamp(new Date(params.olderThan));
-            const result = await db.deleteFrom('kubun_p2p_broadcast_log').where((eb)=>eb(eb.refTuple('doc_id', 'version', 'mls_group_id'), 'in', eb.selectFrom('kubun_p2p_broadcast_log').select([
+            const result = await db.deleteFrom('p2p_broadcast_log').where((eb)=>eb(eb.refTuple('doc_id', 'version', 'mls_group_id'), 'in', eb.selectFrom('p2p_broadcast_log').select([
                     'doc_id',
                     'version',
                     'mls_group_id'

package/lib/scope.d.ts

@@ -0,0 +1,8 @@
+import type { StoreAPIContext } from '@kubun/db';
+import type { Kysely } from 'kysely';
+import type { P2PStoreTables } from './tables.js';
+export declare const runP2PScope: unique symbol;
+export type P2PScope = {
+    [runP2PScope]<R>(run: (db: Kysely<P2PStoreTables>, context: StoreAPIContext) => Promise<R>): Promise<R>;
+};
+export declare function withP2PKeyLocks<R>(context: StoreAPIContext, table: string, keys: ReadonlyArray<ReadonlyArray<string | number>>, run: (db: Kysely<P2PStoreTables>, context: StoreAPIContext) => Promise<R>): Promise<R>;