@totemsdk/omnia-vtxo 0.2.0 → 0.3.0

package/dist/commitment.d.ts

@@ -1,4 +1,17 @@
 import { OmniaVtxo, VtxoId, VtxoProof } from './types.js';
+/** Domain-separated hash prefixes (#33) — a hash on one record cannot replay against another. */
+export declare const VTXO_ID_DOMAIN = "totemsdk/omnia-vtxo/vtxo/v1";
+export declare const VTXO_POOL_ID_DOMAIN = "totemsdk/omnia-vtxo/pool/v1";
+export declare const VTXO_LEAF_DOMAIN = "totemsdk/omnia-vtxo/leaf/v1";
+export declare const VTXO_RECEIPT_DOMAIN = "totemsdk/omnia-vtxo/receipt/v1";
+export declare const VTXO_BATCH_DOMAIN = "totemsdk/omnia-vtxo/batch/v1";
+/**
+ * Canonical batch commitment (RFC-038 §3.2): the operator signs this over the
+ * pool, epoch, Merkle root, and the ordered VTXO ids in the batch.
+ */
+export declare function computeBatchCommitment(poolId: string, epoch: number, root: string, orderedIds: readonly string[]): string;
+/** The 32-byte digest of a batch commitment, for signing. */
+export declare function computeBatchCommitmentBytes(poolId: string, epoch: number, root: string, orderedIds: readonly string[]): Uint8Array;
 export declare function computeVtxoLeaf(vtxo: OmniaVtxo): string;
 export interface ComputeVtxoIdParams {
     poolId: string;

package/dist/commitment.js

@@ -1,26 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.computeVtxoLeaf = computeVtxoLeaf;
-exports.computeVtxoId = computeVtxoId;
-exports.computePoolId = computePoolId;
-exports.computeCommitmentRoot = computeCommitmentRoot;
-exports.verifyMerkleProof = verifyMerkleProof;
-exports.buildVtxoProofSet = buildVtxoProofSet;
-exports.computeReceiptId = computeReceiptId;
-const core_1 = require("@totemsdk/core");
-const constants_js_1 = require("./constants.js");
+import { sha3_256, bytesToHex, hexToBytes } from '@totemsdk/core';
+import { EMPTY_LEAF } from './constants.js';
+/** Domain-separated hash prefixes (#33) — a hash on one record cannot replay against another. */
+export const VTXO_ID_DOMAIN = 'totemsdk/omnia-vtxo/vtxo/v1';
+export const VTXO_POOL_ID_DOMAIN = 'totemsdk/omnia-vtxo/pool/v1';
+export const VTXO_LEAF_DOMAIN = 'totemsdk/omnia-vtxo/leaf/v1';
+export const VTXO_RECEIPT_DOMAIN = 'totemsdk/omnia-vtxo/receipt/v1';
+export const VTXO_BATCH_DOMAIN = 'totemsdk/omnia-vtxo/batch/v1';
+/**
+ * Canonical batch commitment (RFC-038 §3.2): the operator signs this over the
+ * pool, epoch, Merkle root, and the ordered VTXO ids in the batch.
+ */
+export function computeBatchCommitment(poolId, epoch, root, orderedIds) {
+    return sha3hex(`${VTXO_BATCH_DOMAIN}|${poolId}|${epoch}|${root}|${[...orderedIds].join(',')}`);
+}
+/** The 32-byte digest of a batch commitment, for signing. */
+export function computeBatchCommitmentBytes(poolId, epoch, root, orderedIds) {
+    return hexToBytes(computeBatchCommitment(poolId, epoch, root, orderedIds));
+}
 function sha3hex(input) {
     const bytes = new TextEncoder().encode(input);
-    return (0, core_1.bytesToHex)((0, core_1.sha3_256)(bytes));
+    return bytesToHex(sha3_256(bytes));
 }
 function hashPair(a, b) {
     const [left, right] = a <= b ? [a, b] : [b, a];
     const combined = left + right;
-    const bytes = (0, core_1.hexToBytes)(combined);
-    return (0, core_1.bytesToHex)((0, core_1.sha3_256)(bytes));
+    const bytes = hexToBytes(combined);
+    return bytesToHex(sha3_256(bytes));
 }
-function computeVtxoLeaf(vtxo) {
+export function computeVtxoLeaf(vtxo) {
     const input = [
+        VTXO_LEAF_DOMAIN,
         vtxo.vtxoId,
         vtxo.owner,
         vtxo.amount.toString(),
@@ -30,9 +39,9 @@ function computeVtxoLeaf(vtxo) {
     ].join(':');
     return sha3hex(input);
 }
-function computeVtxoId(params) {
+export function computeVtxoId(params) {
     const input = [
-        'vtxo',
+        VTXO_ID_DOMAIN,
         params.poolId,
         params.owner,
         params.amount.toString(),
@@ -41,9 +50,9 @@ function computeVtxoId(params) {
     ].join(':');
     return sha3hex(input);
 }
-function computePoolId(params) {
+export function computePoolId(params) {
     const input = [
-        'pool',
+        VTXO_POOL_ID_DOMAIN,
         params.operator,
         params.tokenId,
         params.nonce,
@@ -58,11 +67,11 @@ function nextPowerOfTwo(n) {
         p <<= 1;
     return p;
 }
-function computeCommitmentRoot(leaves) {
+export function computeCommitmentRoot(leaves) {
     if (leaves.length === 0)
-        return constants_js_1.EMPTY_LEAF;
+        return EMPTY_LEAF;
     const size = nextPowerOfTwo(leaves.length);
-    const level = new Array(size).fill(constants_js_1.EMPTY_LEAF);
+    const level = new Array(size).fill(EMPTY_LEAF);
     for (let i = 0; i < leaves.length; i++) {
         level[i] = leaves[i];
     }
@@ -76,7 +85,7 @@ function computeCommitmentRoot(leaves) {
     }
     return current[0];
 }
-function verifyMerkleProof(leaf, proof, root) {
+export function verifyMerkleProof(leaf, proof, root) {
     let current = leaf;
     for (const node of proof) {
         if (node.position === 'left') {
@@ -88,9 +97,9 @@ function verifyMerkleProof(leaf, proof, root) {
     }
     return current === root;
 }
-function buildVtxoProofSet(vtxos) {
+export function buildVtxoProofSet(vtxos) {
     if (vtxos.length === 0) {
-        return { root: constants_js_1.EMPTY_LEAF, proofs: {} };
+        return { root: EMPTY_LEAF, proofs: {} };
     }
     const sorted = [...vtxos].sort((a, b) => a.vtxoId < b.vtxoId ? -1 : a.vtxoId > b.vtxoId ? 1 : 0);
     const leafMap = new Map();
@@ -102,7 +111,7 @@ function buildVtxoProofSet(vtxos) {
     const size = nextPowerOfTwo(leaves.length);
     const paddedLeaves = [...leaves];
     while (paddedLeaves.length < size)
-        paddedLeaves.push(constants_js_1.EMPTY_LEAF);
+        paddedLeaves.push(EMPTY_LEAF);
     const levels = [paddedLeaves];
     let current = paddedLeaves;
     while (current.length > 1) {
@@ -122,7 +131,7 @@ function buildVtxoProofSet(vtxos) {
         for (let lvl = 0; lvl < levels.length - 1; lvl++) {
             const isLeft = pos % 2 === 0;
             const siblingIdx = isLeft ? pos + 1 : pos - 1;
-            const sibling = levels[lvl][siblingIdx] ?? constants_js_1.EMPTY_LEAF;
+            const sibling = levels[lvl][siblingIdx] ?? EMPTY_LEAF;
             siblings.push(sibling);
             positions.push(isLeft ? 'right' : 'left');
             pos = Math.floor(pos / 2);
@@ -134,14 +143,14 @@ function buildVtxoProofSet(vtxos) {
             siblings,
             positions,
             epoch: vtxo.epoch,
-            batchId: constants_js_1.MOCK_BATCH_ID,
+            batchId: root,
         };
     });
     return { root, proofs };
 }
-function computeReceiptId(poolId, op, inputIds, outputIds, at) {
+export function computeReceiptId(poolId, op, inputIds, outputIds, at) {
     const input = [
-        'receipt',
+        VTXO_RECEIPT_DOMAIN,
         poolId,
         op,
         inputIds.sort().join(','),

package/dist/constants.d.ts

@@ -8,5 +8,3 @@ export declare const DEFAULT_POLICY: {
     readonly maxSplitOutputs: 8;
     readonly exitTimelockSeconds: 86400;
 };
-export declare const MOCK_OPERATOR_SIGNATURE = "mock-operator-sig-v0";
-export declare const MOCK_BATCH_ID = "batch-local-mvp";

package/dist/constants.js

@@ -1,15 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MOCK_BATCH_ID = exports.MOCK_OPERATOR_SIGNATURE = exports.DEFAULT_POLICY = exports.EPOCH_ZERO = exports.EMPTY_TREE_ROOT = exports.EMPTY_LEAF = void 0;
-exports.EMPTY_LEAF = '0000000000000000000000000000000000000000000000000000000000000000';
-exports.EMPTY_TREE_ROOT = '0000000000000000000000000000000000000000000000000000000000000000';
-exports.EPOCH_ZERO = 0;
-exports.DEFAULT_POLICY = {
+export const EMPTY_LEAF = '0000000000000000000000000000000000000000000000000000000000000000';
+export const EMPTY_TREE_ROOT = '0000000000000000000000000000000000000000000000000000000000000000';
+export const EPOCH_ZERO = 0;
+export const DEFAULT_POLICY = {
     minAmount: BigInt(1),
     maxAmount: BigInt(1000000000000000),
     maxMergeInputs: 8,
     maxSplitOutputs: 8,
     exitTimelockSeconds: 86400,
 };
-exports.MOCK_OPERATOR_SIGNATURE = 'mock-operator-sig-v0';
-exports.MOCK_BATCH_ID = 'batch-local-mvp';

package/dist/durable-store.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Durable VTXO/pool snapshot store (RFC-007 G6).
+ *
+ * Drop-in replacement for `MemoryOmniaVtxoStore` — same `OmniaVtxoStore` port
+ * — backed by a storage adapter instead of heap maps: the whole pool/VTXO
+ * registry is a single revision-CAS snapshot record, so concurrent pool/VTXO
+ * transitions never lose an update, reopen restores every VTXO (incl. spent
+ * status and history), and corruption is surfaced — never treated as absence.
+ */
+import type { StorageAdapterWithCapabilities, CasStore, WriteAckMode } from '@totemsdk/storage/types';
+import type { OmniaVtxo, OmniaVtxoPool, OmniaVtxoStore } from './types.js';
+export interface OmniaVtxoRegistryState {
+    pools: Record<string, OmniaVtxoPool>;
+    vtxos: Record<string, OmniaVtxo>;
+}
+export interface DurableOmniaVtxoStoreOptions {
+    /** Key namespace prefix; default `totem_omnia_vtxo:v1:`. */
+    readonly namespace?: string;
+    /**
+     * Required write acknowledgment; default `durably-acknowledged`. Pass
+     * `volatile` only for tests/scratch adapters (e.g. `MemoryStore`).
+     */
+    readonly requireAckMode?: WriteAckMode;
+}
+export interface DurableOmniaVtxoStore extends OmniaVtxoStore {
+    /** Current registry transition counter (0 before the first write). */
+    getRevision(): Promise<number>;
+    /** True once any snapshot record has been persisted. */
+    hasState(): Promise<boolean>;
+    /** Current persisted snapshot state (pool + vtxo maps). */
+    getSnapshot(): Promise<OmniaVtxoRegistryState>;
+}
+export declare function createDurableOmniaVtxoStore(adapter: StorageAdapterWithCapabilities & CasStore, options?: DurableOmniaVtxoStoreOptions): DurableOmniaVtxoStore;

package/dist/durable-store.js

@@ -0,0 +1,90 @@
+/**
+ * Durable VTXO/pool snapshot store (RFC-007 G6).
+ *
+ * Drop-in replacement for `MemoryOmniaVtxoStore` — same `OmniaVtxoStore` port
+ * — backed by a storage adapter instead of heap maps: the whole pool/VTXO
+ * registry is a single revision-CAS snapshot record, so concurrent pool/VTXO
+ * transitions never lose an update, reopen restores every VTXO (incl. spent
+ * status and history), and corruption is surfaced — never treated as absence.
+ */
+import { createRevisionedSnapshotStore, } from '@totemsdk/storage/snapshot';
+import { StorageError } from '@totemsdk/storage/errors';
+import { VtxoStatusError } from './errors.js';
+const DEFAULT_NAMESPACE = 'totem_omnia_vtxo:v1:';
+function assertRegistryState(state) {
+    if (typeof state !== 'object' || state === null || Array.isArray(state)) {
+        throw new StorageError('omnia-vtxo registry state is not an object', 'corrupt');
+    }
+    for (const section of ['pools', 'vtxos']) {
+        const value = state[section];
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            throw new StorageError(`omnia-vtxo registry state is missing section "${section}"`, 'corrupt');
+        }
+    }
+}
+export function createDurableOmniaVtxoStore(adapter, options = {}) {
+    const snapshots = createRevisionedSnapshotStore(adapter, {
+        namespace: options.namespace ?? DEFAULT_NAMESPACE,
+        requireAckMode: options.requireAckMode,
+        empty: () => ({ pools: {}, vtxos: {} }),
+        validate: assertRegistryState,
+    });
+    async function mutate(fn) {
+        await snapshots.mutate(fn);
+    }
+    return {
+        async savePool(pool) {
+            await mutate((state) => {
+                const pools = { ...state.pools, [pool.poolId]: pool };
+                return { ...state, pools };
+            });
+        },
+        async getPool(poolId) {
+            return (await snapshots.load()).pools[poolId];
+        },
+        async saveVtxo(vtxo) {
+            await mutate((state) => {
+                const vtxos = { ...state.vtxos, [vtxo.vtxoId]: vtxo };
+                return { ...state, vtxos };
+            });
+        },
+        async getVtxo(vtxoId) {
+            return (await snapshots.load()).vtxos[vtxoId];
+        },
+        async listVtxos(poolId) {
+            const state = await snapshots.load();
+            const all = Object.values(state.vtxos);
+            if (poolId === undefined)
+                return all;
+            return all.filter((v) => v.poolId === poolId);
+        },
+        async markVtxoSpent(vtxoId, now) {
+            await mutate((state) => {
+                const existing = state.vtxos[vtxoId];
+                if (!existing) {
+                    // Preserve MemoryOmniaVtxoStore error behaviour exactly.
+                    throw new Error(`VTXO ${vtxoId} not found`);
+                }
+                if (existing.status !== 'active') {
+                    throw new VtxoStatusError(`Cannot mark VTXO ${vtxoId} as spent: status is '${existing.status}'`, existing.status);
+                }
+                const ts = now !== undefined ? now : Date.now();
+                const vtxos = {
+                    ...state.vtxos,
+                    [vtxoId]: {
+                        ...existing,
+                        status: 'spent',
+                        updatedAt: ts,
+                        history: [...existing.history, { op: 'spent', at: ts }],
+                    },
+                };
+                return { ...state, vtxos };
+            });
+        },
+        getRevision: () => snapshots.getRevision(),
+        hasState: () => snapshots.hasState(),
+        async getSnapshot() {
+            return snapshots.load();
+        },
+    };
+}

package/dist/errors.js

@@ -1,44 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VtxoExitError = exports.VtxoSplitError = exports.VtxoMergeError = exports.VtxoPolicyError = exports.VtxoPoolCapacityError = exports.VtxoProofError = exports.VtxoOwnershipError = exports.VtxoStatusError = exports.VtxoAmountError = exports.OmniaVtxoError = void 0;
-class OmniaVtxoError extends Error {
+export class OmniaVtxoError extends Error {
     constructor(message) {
         super(message);
         this.name = 'OmniaVtxoError';
         Object.setPrototypeOf(this, new.target.prototype);
     }
 }
-exports.OmniaVtxoError = OmniaVtxoError;
-class VtxoAmountError extends OmniaVtxoError {
+export class VtxoAmountError extends OmniaVtxoError {
     constructor(message) {
         super(message);
         this.name = 'VtxoAmountError';
     }
 }
-exports.VtxoAmountError = VtxoAmountError;
-class VtxoStatusError extends OmniaVtxoError {
+export class VtxoStatusError extends OmniaVtxoError {
     constructor(message, currentStatus) {
         super(message);
         this.name = 'VtxoStatusError';
         this.currentStatus = currentStatus;
     }
 }
-exports.VtxoStatusError = VtxoStatusError;
-class VtxoOwnershipError extends OmniaVtxoError {
+export class VtxoOwnershipError extends OmniaVtxoError {
     constructor(message) {
         super(message);
         this.name = 'VtxoOwnershipError';
     }
 }
-exports.VtxoOwnershipError = VtxoOwnershipError;
-class VtxoProofError extends OmniaVtxoError {
+export class VtxoProofError extends OmniaVtxoError {
     constructor(message) {
         super(message);
         this.name = 'VtxoProofError';
     }
 }
-exports.VtxoProofError = VtxoProofError;
-class VtxoPoolCapacityError extends OmniaVtxoError {
+export class VtxoPoolCapacityError extends OmniaVtxoError {
     constructor(message, requested, available) {
         super(message);
         this.name = 'VtxoPoolCapacityError';
@@ -46,32 +38,27 @@ class VtxoPoolCapacityError extends OmniaVtxoError {
         this.available = available;
     }
 }
-exports.VtxoPoolCapacityError = VtxoPoolCapacityError;
-class VtxoPolicyError extends OmniaVtxoError {
+export class VtxoPolicyError extends OmniaVtxoError {
     constructor(message) {
         super(message);
         this.name = 'VtxoPolicyError';
     }
 }
-exports.VtxoPolicyError = VtxoPolicyError;
-class VtxoMergeError extends OmniaVtxoError {
+export class VtxoMergeError extends OmniaVtxoError {
     constructor(message) {
         super(message);
         this.name = 'VtxoMergeError';
     }
 }
-exports.VtxoMergeError = VtxoMergeError;
-class VtxoSplitError extends OmniaVtxoError {
+export class VtxoSplitError extends OmniaVtxoError {
     constructor(message) {
         super(message);
         this.name = 'VtxoSplitError';
     }
 }
-exports.VtxoSplitError = VtxoSplitError;
-class VtxoExitError extends OmniaVtxoError {
+export class VtxoExitError extends OmniaVtxoError {
     constructor(message) {
         super(message);
         this.name = 'VtxoExitError';
     }
 }
-exports.VtxoExitError = VtxoExitError;

package/dist/exit-tx.d.ts

@@ -0,0 +1,55 @@
+/**
+ * VTXO exit transaction (RFC-038 V2).
+ *
+ * Builds a real exit transaction: spend the pool's on-chain coin and pay the
+ * VTXO's owner, carrying the exit delay in STATE(102). The digest is signed
+ * (injected signer) and, when a chain provider is supplied, mined + broadcast
+ * (injected miner). This replaces the `'mock-exit'` draft with a concrete tx.
+ *
+ * NOTE (RFC-038 §3.4): the full owner-unilateral covenant (a timelock branch the
+ * owner can exercise without the operator, or a pre-signed exit tx) is a
+ * follow-on; this builds and broadcasts the transaction with the delay encoded.
+ */
+import { type OmniaTxDraft } from '@totemsdk/omnia';
+import type { ChainStateProvider } from '@totemsdk/chain-provider';
+import type { OmniaVtxo } from './types.js';
+/** State port carrying the exit delay. */
+export declare const EXIT_DELAY_PORT = 102;
+export interface ExitTxParams {
+    vtxo: OmniaVtxo;
+    /** The pool's on-chain coin (input). */
+    fundingCoinId: string;
+    fundingAddress: string;
+    fundingScript: string;
+    /** Raw base-unit amount to pay the owner (the VTXO amount, pre-scaled). */
+    amount: bigint;
+    /** Exit delay carried as STATE(102). */
+    exitDelayBlocks: number;
+}
+/** Draft that spends the pool coin to the VTXO owner with the exit delay encoded. */
+export declare function buildExitTransactionDraft(params: ExitTxParams): OmniaTxDraft;
+export declare function exitTransactionDigest(draft: OmniaTxDraft): Uint8Array;
+export declare function exitTransactionHex(draft: OmniaTxDraft): string;
+interface MinedTxPow {
+    minedHeaderBytes: Uint8Array;
+    txpowId: Uint8Array;
+}
+export interface ExitTxDeps {
+    signDigest: (digest: Uint8Array) => Promise<Uint8Array>;
+    chainProvider?: ChainStateProvider;
+    mine?: (txBody: Uint8Array, difficulty: Uint8Array) => Promise<MinedTxPow>;
+}
+export interface ExitTxResult {
+    vtxoId: string;
+    owner: string;
+    amount: string;
+    exitDelayBlocks: number;
+    draftType: 'vtxo-exit';
+    txHex: string;
+    digest: string;
+    witnessHex: string;
+    txpowId?: string;
+}
+/** Build, sign (and optionally mine + broadcast) a VTXO exit transaction. */
+export declare function buildExitTransaction(params: ExitTxParams, deps: ExitTxDeps): Promise<ExitTxResult>;
+export {};

package/dist/exit-tx.js

@@ -0,0 +1,74 @@
+/**
+ * VTXO exit transaction (RFC-038 V2).
+ *
+ * Builds a real exit transaction: spend the pool's on-chain coin and pay the
+ * VTXO's owner, carrying the exit delay in STATE(102). The digest is signed
+ * (injected signer) and, when a chain provider is supplied, mined + broadcast
+ * (injected miner). This replaces the `'mock-exit'` draft with a concrete tx.
+ *
+ * NOTE (RFC-038 §3.4): the full owner-unilateral covenant (a timelock branch the
+ * owner can exercise without the operator, or a pre-signed exit tx) is a
+ * follow-on; this builds and broadcasts the transaction with the delay encoded.
+ */
+import { computeOmniaTxDigest, omniaDraftToMinimaBytes, serializeTxDraft, } from '@totemsdk/omnia';
+import { serializeTxBody, mineTxPoW, TX_POW_MIN_DIFFICULTY } from '@totemsdk/txpow';
+import { concatBytes } from '@totemsdk/core';
+/** State port carrying the exit delay. */
+export const EXIT_DELAY_PORT = 102;
+/** Draft that spends the pool coin to the VTXO owner with the exit delay encoded. */
+export function buildExitTransactionDraft(params) {
+    const stateVariables = [
+        { port: EXIT_DELAY_PORT, value: BigInt(params.exitDelayBlocks), type: 'number' },
+    ];
+    return {
+        type: 'settlement',
+        inputs: [{
+                coinId: params.fundingCoinId,
+                address: params.fundingAddress,
+                amount: params.amount,
+                tokenId: params.vtxo.tokenId,
+                scriptHex: params.fundingScript,
+            }],
+        outputs: [{
+                address: params.vtxo.owner,
+                amount: params.amount,
+                tokenId: params.vtxo.tokenId,
+                storeState: false,
+                stateVariables,
+            }],
+        storeState: false,
+        stateVariables,
+    };
+}
+export function exitTransactionDigest(draft) {
+    return computeOmniaTxDigest(draft);
+}
+export function exitTransactionHex(draft) {
+    return serializeTxDraft(draft);
+}
+/** Build, sign (and optionally mine + broadcast) a VTXO exit transaction. */
+export async function buildExitTransaction(params, deps) {
+    const draft = buildExitTransactionDraft(params);
+    const digest = exitTransactionDigest(draft);
+    const signature = await deps.signDigest(digest);
+    const result = {
+        vtxoId: params.vtxo.vtxoId,
+        owner: params.vtxo.owner,
+        amount: params.vtxo.amount.toString(),
+        exitDelayBlocks: params.exitDelayBlocks,
+        draftType: 'vtxo-exit',
+        txHex: exitTransactionHex(draft),
+        digest: Buffer.from(digest).toString('hex'),
+        witnessHex: Buffer.from(signature).toString('hex'),
+    };
+    if (deps.chainProvider) {
+        const mine = deps.mine ?? ((txBody, difficulty) => mineTxPoW(txBody, difficulty));
+        const draftBytes = omniaDraftToMinimaBytes(draft);
+        const txBody = serializeTxBody(draftBytes, signature);
+        const mined = await mine(txBody, TX_POW_MIN_DIFFICULTY);
+        const fullTxPoW = concatBytes(concatBytes(mined.minedHeaderBytes, new Uint8Array([0x01])), txBody);
+        await deps.chainProvider.broadcastTxPoW(Buffer.from(fullTxPoW).toString('hex'));
+        result.txpowId = Buffer.from(mined.txpowId).toString('hex');
+    }
+    return result;
+}

package/dist/exit.d.ts

@@ -8,12 +8,22 @@ export declare function markExiting(vtxo: OmniaVtxo, now?: number): OmniaVtxo;
  * Transitions an exiting VTXO to 'exited' status.
  * @param now - Timestamp in ms. Defaults to Date.now() if omitted — pass explicitly for determinism.
  */
-export declare function markExited(vtxo: OmniaVtxo, now?: number): OmniaVtxo;
+export declare function markExited(vtxo: OmniaVtxo, options?: {
+    txpowId?: string;
+    now?: number;
+}): OmniaVtxo;
 /**
- * Creates a mock exit draft for a VTXO. Validates the proof leaf before drafting.
+ * Creates a mock exit draft for a VTXO. Validates the proof leaf before
+ * drafting, caps the exit at the verified share, and consumes the VTXO's
+ * receipt so a second exit draft is refused (double-exit prevention, #28).
  * @param now - Timestamp in ms. Defaults to Date.now() if omitted — pass explicitly for determinism.
  */
 export declare function createExitDraft(vtxo: OmniaVtxo, now?: number): {
     draft: ExitDraft;
     receipt: VtxoOperatorReceipt;
 };
+/**
+ * Consume a VTXO's exit receipt — the single-spend marker that prevents a
+ * second exit draft for the same VTXO. Returns the updated VTXO.
+ */
+export declare function consumeExitReceipt(vtxo: OmniaVtxo, receiptId: string, now?: number): OmniaVtxo;