@ownables/platform-browser 0.8.1 → 0.9.1

package/dist/core/src/services/Ownable.service.js

@@ -1,31 +1,26 @@
-import { EventChain, Event, Binary } from "eqty-core";
-import { encode } from "cbor-x";
-import { withProgress } from "../progress.js";
-import WorkerRPC from "./WorkerRPC.service.js";
-import { DEFAULT_WORKER_SOURCE } from "./workerSource.js";
-import { dedupeIndexedPublicEvents, publicEventReplayKey } from "./ReplayAuthority.service.js";
+import { EventChain, Event, Binary } from 'eqty-core';
+import { encode } from 'cbor-x';
+import { ProgressService } from './Progress.service.js';
 export default class OwnableService {
+    SNAPSHOT_INTERVAL = 50;
+    PUBLIC_EVENT_REPLAY_STORE_SUFFIX = '.public-event-replays';
     stateStore;
     eventChains;
     eqty;
     packages;
     runtimeSource;
-    logger;
     runtimeRpc;
-    SNAPSHOT_INTERVAL = 50;
-    PUBLIC_EVENT_REPLAY_STORE_SUFFIX = ".public-event-replays";
-    constructor(stateStore, eventChains, eqty, packages, runtimeSource = {
-        getWorkerSource: () => DEFAULT_WORKER_SOURCE,
-    }, logger = console, runtimeRpc = {
-        create: (id) => new WorkerRPC(id),
-    }) {
-        this.stateStore = stateStore;
-        this.eventChains = eventChains;
-        this.eqty = eqty;
-        this.packages = packages;
-        this.runtimeSource = runtimeSource;
-        this.logger = logger;
-        this.runtimeRpc = runtimeRpc;
+    replay;
+    logger;
+    constructor(deps) {
+        this.stateStore = deps.stateStore;
+        this.eventChains = deps.eventChains;
+        this.eqty = deps.anchorProvider;
+        this.packages = deps.packages;
+        this.runtimeSource = deps.runtimeSource;
+        this.runtimeRpc = deps.runtimeRpc;
+        this.replay = deps.replay;
+        this.logger = deps.logger ?? console;
     }
     _rpc = new Map();
     get anchoring() {
@@ -59,19 +54,20 @@ export default class OwnableService {
         if (this._rpc.has(id))
             return;
         const js = this.runtimeSource.getWorkerSource();
-        const wasm = (await this.packages.getAsset(cid, "ownable_bg.wasm", (fr, file) => fr.readAsArrayBuffer(file)));
+        const wasm = (await this.packages.getAsset(cid, 'ownable_bg.wasm', (fr, file) => fr.readAsArrayBuffer(file)));
         const rpc = this.runtimeRpc.create(id);
         await rpc.initialize(js, new Uint8Array(wasm));
         this._rpc.set(id, rpc);
     }
     async create(pkg, onProgress) {
+        const progress = new ProgressService(onProgress);
         const address = this.eqty.address;
         const networkId = this.eqty.chainId;
         const chain = EventChain.create(address, networkId);
         const anchors = [];
         if (pkg.isDynamic || this.anchoring) {
             const msg = {
-                "@context": "instantiate_msg.json",
+                '@context': 'instantiate_msg.json',
                 ownable_id: chain.id,
                 package: pkg.cid,
                 network_id: networkId,
@@ -79,7 +75,7 @@ export default class OwnableService {
                 ...(pkg.title ? { name: pkg.title } : {}),
                 ...(pkg.description ? { description: pkg.description } : {}),
             };
-            await withProgress(onProgress)("signEvent", () => this.eqty.sign(new Event(msg).addTo(chain)));
+            await progress.step('signEvent', () => this.eqty.sign(new Event(msg).addTo(chain)));
         }
         if (this.anchoring) {
             const hash = chain.latestHash.hex;
@@ -88,7 +84,7 @@ export default class OwnableService {
         if (anchors.length > 0) {
             // Queue anchors and submit as single tx
             await this.eqty.anchor(...anchors);
-            const txHash = await withProgress(onProgress)("anchorEvent", () => this.eqty.submitAnchors());
+            const txHash = await progress.step('anchorEvent', () => this.eqty.submitAnchors());
             return txHash ? { chain, txHash } : { chain };
         }
         return { chain };
@@ -119,19 +115,17 @@ export default class OwnableService {
             const keys = await this.stateStore.keys(snapshotStoreId);
             if (keys.length > 3) {
                 const sortedKeys = keys
-                    .map((key) => parseInt(key.replace("snapshot_", "")))
+                    .map((key) => parseInt(key.replace('snapshot_', '')))
                     .sort((a, b) => b - a);
                 // Delete oldest snapshots, keep the 3 most recent
-                const keysToDelete = sortedKeys
-                    .slice(3)
-                    .map((index) => `snapshot_${index}`);
+                const keysToDelete = sortedKeys.slice(3).map((index) => `snapshot_${index}`);
                 for (const key of keysToDelete) {
                     await this.stateStore.delete(snapshotStoreId, key);
                 }
             }
         }
         catch (error) {
-            this.logger.error("Error creating snapshot:", error);
+            this.logger.error('Error creating snapshot:', error);
         }
     }
     async getLatestSnapshot(chainId) {
@@ -145,7 +139,7 @@ export default class OwnableService {
         if (snapshots.length === 0)
             return null;
         const latestKey = snapshots
-            .map((key) => parseInt(key.replace("snapshot_", "")))
+            .map((key) => parseInt(key.replace('snapshot_', '')))
             .sort((a, b) => b - a)[0];
         return await this.stateStore.get(snapshotStoreId, `snapshot_${latestKey}`);
     }
@@ -157,7 +151,7 @@ export default class OwnableService {
         }
         const snapshots = await this.stateStore.keys(snapshotStoreId);
         const sortedKeys = snapshots
-            .map((key) => parseInt(key.replace("snapshot_", "")))
+            .map((key) => parseInt(key.replace('snapshot_', '')))
             .sort((a, b) => a - b);
         return Promise.all(sortedKeys.map((index) => this.stateStore.get(snapshotStoreId, `snapshot_${index}`)));
     }
@@ -171,18 +165,96 @@ export default class OwnableService {
     publicEventReplayStoreId(chainId) {
         return `ownable:${chainId}${this.PUBLIC_EVENT_REPLAY_STORE_SUFFIX}`;
     }
+    replayRecord(event, status, sources) {
+        return {
+            replayKey: this.replay.key(event),
+            event,
+            status,
+            sources: [...new Set(sources)],
+        };
+    }
+    mergeReplayRecordSources(current, next) {
+        return current.includes(next) ? current : [...current, next];
+    }
+    async ensureReplayStore(chainId) {
+        const replayStoreId = this.publicEventReplayStoreId(chainId);
+        if (!(await this.stateStore.hasStore(replayStoreId))) {
+            await this.stateStore.createStore(replayStoreId);
+        }
+        return replayStoreId;
+    }
+    async listReplayRecords(chainId) {
+        const replayStoreId = this.publicEventReplayStoreId(chainId);
+        if (!(await this.stateStore.hasStore(replayStoreId))) {
+            return [];
+        }
+        const records = (await this.stateStore.getAll(replayStoreId));
+        return [...records].sort((left, right) => {
+            if (left.event.blockNumber !== right.event.blockNumber) {
+                return left.event.blockNumber - right.event.blockNumber;
+            }
+            if (left.event.transactionIndex !== right.event.transactionIndex) {
+                return left.event.transactionIndex - right.event.transactionIndex;
+            }
+            return left.event.logIndex - right.event.logIndex;
+        });
+    }
+    async listTrackedPublicEvents(chainId) {
+        return this.listReplayRecords(chainId);
+    }
+    emptyReplayAttemptResult(stateDump) {
+        return {
+            complete: true,
+            stateDump,
+            appliedEvents: [],
+            appliedReplayKeys: [],
+            duplicateReplayKeys: [],
+            appliedPublicEvents: [],
+            duplicatePublicEvents: [],
+            ignoredPublicEvents: [],
+            pendingPublicEvents: [],
+            confirmedPendingPublicEvents: [],
+        };
+    }
+    publicEventSubjectId(chain) {
+        return Binary.fromHex(chain.id).hash().hex;
+    }
+    provisionalPublicEventReplayKey(chain, eventType, data) {
+        return `pending:${this.publicEventSubjectId(chain)}:${eventType}:${new Binary(data).hash().hex}`;
+    }
+    provisionalPublicEventRecord(chain, eventType, data) {
+        const replayKey = this.provisionalPublicEventReplayKey(chain, eventType, data);
+        const payloadHex = new Binary(data).hex;
+        return {
+            replayKey,
+            event: {
+                source: this.eqty.address,
+                eventType,
+                data: payloadHex,
+                blockNumber: 0,
+                transactionHash: payloadHex,
+                transactionIndex: 0,
+                logIndex: 0,
+            },
+            status: 'pending',
+            sources: ['local'],
+        };
+    }
     toRegisterRuntimeEvent(event) {
+        const { subjectId: _subjectId, timestamp: _timestamp, ...publicEvent } = event;
         return {
-            ...event,
-            data: typeof event.data === "string"
-                ? event.data
-                : new Binary(event.data).hex,
+            ...publicEvent,
+            data: typeof publicEvent.data === 'string' ? publicEvent.data : new Binary(event.data).hex,
         };
     }
+    publicEventSubjectMatches(chain, event) {
+        return event.subjectId.toLowerCase() === this.publicEventSubjectId(chain).toLowerCase();
+    }
     toRegisterRpcPayload(event) {
         return {
             ...event,
             data: Binary.fromHex(event.data),
+            transactionHash: Binary.fromHex(event.transactionHash),
         };
     }
     async applyEvent(rpc, event, stateDump, chain, eventIndex) {
@@ -190,19 +262,19 @@ export default class OwnableService {
             sender: event.signerAddress || this.eqty.address,
             funds: [],
         };
-        const { "@context": context, ...msg } = event.parsedData;
+        const { '@context': context, ...msg } = event.parsedData;
         let result;
         switch (context) {
-            case "instantiate_msg.json":
+            case 'instantiate_msg.json':
                 result = await rpc.instantiate(msg, info);
                 break;
-            case "execute_msg.json":
+            case 'execute_msg.json':
                 result = await rpc.execute(msg, info, stateDump);
                 break;
-            case "register_msg.json":
+            case 'register_msg.json':
                 result = await rpc.register(this.toRegisterRpcPayload(msg), info, stateDump);
                 break;
-            case "ingest_msg.json":
+            case 'ingest_msg.json':
                 result = await rpc.ingest(msg, info, stateDump);
                 break;
             default:
@@ -252,101 +324,195 @@ export default class OwnableService {
         }
         return stateDump;
     }
-    async replayIndexedPublicEvents(chainId, stateDump, indexedPublicEvents) {
-        const replay = await this.attemptReplayIndexedPublicEvents(chainId, stateDump, indexedPublicEvents);
-        if (!replay.complete) {
-            if (replay.failure?.cause instanceof Error) {
-                throw replay.failure.cause;
-            }
-            throw new Error(`Failed to replay indexed public event ${replay.failure?.replayKey ?? "unknown"}`);
-        }
-        return replay;
+    async replayIndexedPublicEvents(chainId, stateDump, indexedPublicEvents, options) {
+        return this.attemptReplayIndexedPublicEvents(chainId, stateDump, indexedPublicEvents, options);
     }
-    async attemptReplayIndexedPublicEvents(chainId, stateDump, indexedPublicEvents) {
+    async attemptReplayIndexedPublicEvents(chainId, stateDump, indexedPublicEvents, options) {
         const info = {
             sender: this.eqty.address,
             funds: [],
         };
-        const { events, duplicateReplayKeys } = dedupeIndexedPublicEvents(indexedPublicEvents);
+        const deduped = this.replay.dedupe(indexedPublicEvents);
+        const selected = options
+            ? this.replay.selectReplayable(indexedPublicEvents, options)
+            : { events: deduped.events, ignoredPublicEvents: [] };
+        const events = selected.events;
+        const duplicateReplayKeys = deduped.duplicateReplayKeys;
         const appliedEvents = [];
         const appliedReplayKeys = [];
+        const appliedPublicEvents = [];
+        const duplicatePublicEvents = deduped.duplicateEvents.map((event) => ({
+            replayKey: this.replay.key(event),
+            event,
+        }));
+        const ignoredPublicEvents = [...selected.ignoredPublicEvents];
         let nextState = stateDump;
         for (const indexedEvent of events) {
             const runtimeEvent = this.toRegisterRuntimeEvent(indexedEvent);
-            const replayKey = publicEventReplayKey(indexedEvent);
+            const replayKey = this.replay.key(indexedEvent);
             try {
                 const { state } = await this.rpc(chainId).register(this.toRegisterRpcPayload(runtimeEvent), info, nextState);
                 nextState = state;
                 appliedEvents.push(indexedEvent);
                 appliedReplayKeys.push(replayKey);
+                appliedPublicEvents.push({
+                    replayKey,
+                    event: indexedEvent,
+                });
             }
             catch (cause) {
-                return {
-                    complete: false,
-                    stateDump: nextState,
-                    appliedEvents,
-                    appliedReplayKeys,
-                    duplicateReplayKeys,
-                    failure: {
-                        replayKey,
-                        event: indexedEvent,
-                        cause,
-                    },
-                };
+                ignoredPublicEvents.push({
+                    replayKey,
+                    event: indexedEvent,
+                    reason: 'register_failed',
+                    cause,
+                });
             }
         }
         return {
-            complete: true,
+            complete: ignoredPublicEvents.length === 0,
             stateDump: nextState,
             appliedEvents,
             appliedReplayKeys,
             duplicateReplayKeys,
+            appliedPublicEvents,
+            duplicatePublicEvents,
+            ignoredPublicEvents,
+            pendingPublicEvents: [],
+            confirmedPendingPublicEvents: [],
+        };
+    }
+    async applyIndexedPublicEventSnapshot(chain, indexedPublicEvents, onProgress) {
+        return this.reconcileIndexedPublicEvents(chain, indexedPublicEvents, 'snapshot', onProgress);
+    }
+    async applyIndexedPublicEventStream(chain, indexedPublicEvents, onProgress) {
+        return this.reconcileIndexedPublicEvents(chain, indexedPublicEvents, 'stream', onProgress);
+    }
+    async reconcileIndexedPublicEvents(chain, indexedPublicEvents, source, onProgress) {
+        const progress = new ProgressService(onProgress);
+        const stateDump = await this.eventChains.getStateDump(chain.id, chain.state.hex);
+        if (!stateDump)
+            throw Error('State mismatch for register public event');
+        const replayStoreId = await this.ensureReplayStore(chain.id);
+        const base = this.emptyReplayAttemptResult(stateDump);
+        const deduped = this.replay.dedupe(indexedPublicEvents);
+        const info = {
+            sender: this.eqty.address,
+            funds: [],
+        };
+        base.duplicateReplayKeys.push(...deduped.duplicateReplayKeys);
+        base.duplicatePublicEvents.push(...deduped.duplicateEvents.map((event) => this.replayRecord(event, 'confirmed', [source])));
+        let nextState = stateDump;
+        for (const indexedEvent of deduped.events) {
+            const replayKey = this.replay.key(indexedEvent);
+            const existing = (await this.stateStore
+                .get(replayStoreId, replayKey)
+                .catch(() => undefined));
+            if (existing?.status === 'confirmed') {
+                const updated = this.replayRecord(existing.event, 'confirmed', this.mergeReplayRecordSources(existing.sources, source));
+                await this.stateStore.set(replayStoreId, replayKey, updated);
+                base.duplicateReplayKeys.push(replayKey);
+                base.duplicatePublicEvents.push(updated);
+                continue;
+            }
+            const runtimeEvent = this.toRegisterRuntimeEvent(indexedEvent);
+            try {
+                const { state } = await this.rpc(chain.id).register(this.toRegisterRpcPayload(runtimeEvent), info, nextState);
+                nextState = state;
+                await progress.step('signPublicEvent', () => this.eqty.sign(new Event({
+                    '@context': 'register_msg.json',
+                    ...runtimeEvent,
+                }).addTo(chain)));
+                await this.store(chain, nextState);
+                const confirmedRecord = this.replayRecord(indexedEvent, 'confirmed', existing?.status === 'pending'
+                    ? this.mergeReplayRecordSources(existing.sources, source)
+                    : [source]);
+                await this.stateStore.set(replayStoreId, replayKey, confirmedRecord);
+                base.appliedEvents.push(indexedEvent);
+                base.appliedReplayKeys.push(replayKey);
+                base.appliedPublicEvents.push({ replayKey, event: indexedEvent });
+                if (existing?.status === 'pending') {
+                    base.confirmedPendingPublicEvents.push(confirmedRecord);
+                }
+            }
+            catch (cause) {
+                base.ignoredPublicEvents.push({
+                    replayKey,
+                    event: indexedEvent,
+                    reason: 'register_failed',
+                    cause,
+                });
+            }
+        }
+        return {
+            ...base,
+            complete: base.ignoredPublicEvents.length === 0,
+            stateDump: nextState,
         };
     }
     async execute(chain, msg, stateDump, onProgress, attachments = []) {
+        const progress = new ProgressService(onProgress);
         const info = { sender: this.eqty.address, funds: [] };
         const { state: newStateDump } = await this.rpc(chain.id).execute(msg, info, stateDump);
-        delete msg["@context"]; // Shouldn't be set
-        const event = new Event({ "@context": "execute_msg.json", ...msg }).addTo(chain);
+        delete msg['@context']; // Shouldn't be set
+        const event = new Event({ '@context': 'execute_msg.json', ...msg }).addTo(chain);
         for (const attachment of attachments) {
-            event.addAttachment(attachment.name, new Uint8Array(await attachment.file.arrayBuffer()), attachment.file.type || "application/octet-stream");
+            event.addAttachment(attachment.name, new Uint8Array(await attachment.file.arrayBuffer()), attachment.file.type || 'application/octet-stream');
         }
-        await withProgress(onProgress)("signEvent", () => this.eqty.sign(event));
+        await progress.step('signEvent', () => this.eqty.sign(event));
         // Store without submitting anchors yet; submission is controlled by caller
         await this.store(chain, newStateDump);
         return newStateDump;
     }
     async registerPublicEvent(chain, event, onProgress) {
+        const publicEvent = this.toRegisterRuntimeEvent(event);
+        return this.applyIndexedPublicEventStream(chain, [publicEvent], onProgress);
+    }
+    async emitPublicEvent(chain, eventType, payload, onProgress) {
+        const progress = new ProgressService(onProgress);
         const stateDump = await this.eventChains.getStateDump(chain.id, chain.state.hex);
         if (!stateDump)
-            throw Error("State mismatch for register public event");
-        const publicEvent = this.toRegisterRuntimeEvent(event);
-        const replayStoreId = this.publicEventReplayStoreId(chain.id);
-        const replayKey = publicEventReplayKey(publicEvent);
-        if ((await this.stateStore.hasStore(replayStoreId)) && (await this.stateStore.get(replayStoreId, replayKey))) {
-            return;
+            throw Error('State mismatch for emit public event');
+        const encodedPayload = await progress.step('encodePublicEvent', () => this.rpc(chain.id).encodePublicEvent(eventType, encode(payload)));
+        const subjectId = this.publicEventSubjectId(chain);
+        const replayStoreId = await this.ensureReplayStore(chain.id);
+        const provisionalPendingRecord = this.provisionalPublicEventRecord(chain, eventType, encodedPayload);
+        await this.stateStore.set(replayStoreId, provisionalPendingRecord.replayKey, provisionalPendingRecord);
+        let publicEvent;
+        try {
+            publicEvent = await progress.step('emitPublicEvent', () => this.eqty.emitPublicEvent(subjectId, eventType, encodedPayload));
         }
-        const replay = await this.replayIndexedPublicEvents(chain.id, stateDump, [publicEvent]);
-        const newStateDump = replay.stateDump;
-        await withProgress(onProgress)("signPublicEvent", () => this.eqty.sign(new Event({
-            "@context": "register_msg.json",
-            ...publicEvent,
-        }).addTo(chain)));
-        await this.store(chain, newStateDump);
-        if (!(await this.stateStore.hasStore(replayStoreId))) {
-            await this.stateStore.createStore(replayStoreId);
+        catch (cause) {
+            await this.stateStore.delete(replayStoreId, provisionalPendingRecord.replayKey);
+            throw cause;
         }
-        await this.stateStore.set(replayStoreId, replayKey, true);
-    }
-    async emitPublicEvent(chain, eventType, payload, onProgress) {
-        const encodedPayload = await withProgress(onProgress)("encodePublicEvent", () => this.rpc(chain.id).encodePublicEvent(eventType, encode(payload)));
-        const publicEvent = await withProgress(onProgress)("emitPublicEvent", () => this.eqty.emitPublicEvent(chain.id, eventType, encodedPayload));
-        await this.registerPublicEvent(chain, publicEvent, onProgress);
+        if (!this.publicEventSubjectMatches(chain, publicEvent)) {
+            await this.stateStore.delete(replayStoreId, provisionalPendingRecord.replayKey);
+            const result = this.emptyReplayAttemptResult(stateDump);
+            result.complete = false;
+            result.ignoredPublicEvents.push({
+                replayKey: this.replay.key(this.toRegisterRuntimeEvent(publicEvent)),
+                event: this.toRegisterRuntimeEvent(publicEvent),
+                reason: 'invalid_subject_id',
+                cause: {
+                    expectedSubjectId: subjectId,
+                    receivedSubjectId: publicEvent.subjectId,
+                },
+            });
+            return result;
+        }
+        const runtimeEvent = this.toRegisterRuntimeEvent(publicEvent);
+        const pendingRecord = this.replayRecord(runtimeEvent, 'pending', ['local']);
+        await this.stateStore.delete(replayStoreId, provisionalPendingRecord.replayKey);
+        await this.stateStore.set(replayStoreId, pendingRecord.replayKey, pendingRecord);
+        const result = this.emptyReplayAttemptResult(stateDump);
+        result.pendingPublicEvents.push(pendingRecord);
+        return result;
     }
     async submitAnchors(onProgress) {
         if (!this.anchoring)
             return undefined;
-        return await withProgress(onProgress)("anchor", () => this.eqty.submitAnchors());
+        return await new ProgressService(onProgress).step('anchor', () => this.eqty.submitAnchors());
     }
     async canConsume(consumer, info) {
         if (!this.packages.info(consumer.package).isConsumer)
@@ -364,11 +530,12 @@ export default class OwnableService {
             return result === true;
         }
         catch (error) {
-            this.logger.warn("Error checking canConsume:", error);
+            this.logger.warn('Error checking canConsume:', error);
             return false;
         }
     }
     async consume(consumer, consumable, onProgress) {
+        const progress = new ProgressService(onProgress);
         const info = {
             sender: this.eqty.address,
             funds: [],
@@ -377,11 +544,11 @@ export default class OwnableService {
         const consumerState = await this.eventChains.getStateDump(consumer.id, consumer.state.hex);
         const consumableState = await this.eventChains.getStateDump(consumable.id, consumable.state.hex);
         if (!consumerState || !consumableState)
-            throw Error("State mismatch for consume");
+            throw Error('State mismatch for consume');
         const { events, state: consumableStateDump } = await this.rpc(consumable.id).execute(consumeMessage, info, consumableState);
-        const consumeEvent = events.find((event) => event.type === "consume");
+        const consumeEvent = events.find((event) => event.type === 'consume');
         if (!consumeEvent)
-            throw Error("No consume event emitted");
+            throw Error('No consume event emitted');
         const consumableInfo = (await this.rpc(consumable.id).query({ get_info: {} }, consumableStateDump));
         const ingestEvent = {
             source: {
@@ -393,15 +560,15 @@ export default class OwnableService {
             eventType: consumeEvent.type,
         };
         const { state: consumerStateDump } = await this.rpc(consumer.id).ingest(ingestEvent, info, consumerState);
-        await withProgress(onProgress)("signConsumableEvent", () => this.eqty.sign(new Event({ "@context": "execute_msg.json", ...consumeMessage }).addTo(consumable)));
-        await withProgress(onProgress)("signConsumerEvent", () => this.eqty.sign(new Event({
-            "@context": "ingest_msg.json",
+        await progress.step('signConsumableEvent', () => this.eqty.sign(new Event({ '@context': 'execute_msg.json', ...consumeMessage }).addTo(consumable)));
+        await progress.step('signConsumerEvent', () => this.eqty.sign(new Event({
+            '@context': 'ingest_msg.json',
             ...ingestEvent,
         }).addTo(consumer)));
         // Store both chains; emit anchor progress only once to represent anchoring both
         // Queue anchors for both chains without submitting yet
         await this.store(consumable, consumableStateDump);
-        await this.stateStore.set(`ownable:${consumable.id}`, "isConsumed", true);
+        await this.stateStore.set(`ownable:${consumable.id}`, 'isConsumed', true);
         await this.store(consumer, consumerStateDump);
         // Submit a single anchor tx for both
         await this.submitAnchors(onProgress);
@@ -431,8 +598,7 @@ export default class OwnableService {
             created: new Date(),
             latestHash: chain.latestHash.hex,
             keywords: this.packages.info(pkg).keywords,
-            uniqueMessageHash: this.packages.info(pkg, uniqueMessageHash)
-                .uniqueMessageHash,
+            uniqueMessageHash: this.packages.info(pkg, uniqueMessageHash).uniqueMessageHash,
         };
         const stores = [storeId];
         if (stateDump)
@@ -454,17 +620,16 @@ export default class OwnableService {
             }
             catch (error) {
                 // If setAll fails, attempt to clean up
-                this.logger.error("Failed to set data, cleaning up stores...");
+                this.logger.error('Failed to set data, cleaning up stores...');
                 await Promise.all(stores.map((store) => this.stateStore.deleteStore(store).catch(() => { })));
                 throw error;
             }
             const verifyData = await Promise.all([
-                this.stateStore.get(storeId, "state"),
+                this.stateStore.get(storeId, 'state'),
                 stateDump ? this.stateStore.getAll(stateStoreId) : Promise.resolve(null),
             ]);
-            if (verifyData[0] !== chainData.state ||
-                (stateDump && !verifyData[1]?.length)) {
-                throw new Error("Data verification failed after write");
+            if (verifyData[0] !== chainData.state || (stateDump && !verifyData[1]?.length)) {
+                throw new Error('Data verification failed after write');
             }
         });
     }
@@ -473,7 +638,7 @@ export default class OwnableService {
         const storeId = `ownable:${chain.id}`;
         const stateStoreId = `${storeId}.state`;
         await this.retryOperation(async () => {
-            const storedState = await this.stateStore.get(storeId, "state");
+            const storedState = await this.stateStore.get(storeId, 'state');
             if (storedState === chain.state)
                 return;
             const data = {
@@ -485,7 +650,7 @@ export default class OwnableService {
                 [stateStoreId]: new Map(stateDump),
             };
             if (this.anchoring) {
-                const previousHash = await this.stateStore.get(`ownable:${chain.id}`, "latestHash");
+                const previousHash = await this.stateStore.get(`ownable:${chain.id}`, 'latestHash');
                 anchors.push(...chain.startingAfter(Binary.fromHex(previousHash)).anchorMap);
             }
             if (anchors.length > 0) {
@@ -498,9 +663,9 @@ export default class OwnableService {
                 await this.createSnapshot(chain, stateDump, eventCount - 1);
             }
             // Verify write
-            const verifyState = await this.stateStore.get(storeId, "state");
+            const verifyState = await this.stateStore.get(storeId, 'state');
             if (verifyState !== chain.state.hex) {
-                throw new Error("State verification failed after write");
+                throw new Error('State verification failed after write');
             }
         });
     }
@@ -513,10 +678,10 @@ export default class OwnableService {
     async zip(chain) {
         const firstEvent = chain.events[0];
         if (!firstEvent)
-            throw new Error("Cannot zip an empty ownable chain");
+            throw new Error('Cannot zip an empty ownable chain');
         const packageCid = firstEvent.parsedData.package;
         const zip = await this.packages.zip(packageCid);
-        zip.file("chain.json", JSON.stringify(chain.toJSON()));
+        zip.file('chain.json', JSON.stringify(chain.toJSON()));
         return zip;
     }
 }