@totemsdk/omnia-vtxo 0.2.1 → 0.4.0

package/dist/commitment.d.ts

@@ -4,6 +4,14 @@ 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,33 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VTXO_RECEIPT_DOMAIN = exports.VTXO_LEAF_DOMAIN = exports.VTXO_POOL_ID_DOMAIN = exports.VTXO_ID_DOMAIN = void 0;
-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. */
-exports.VTXO_ID_DOMAIN = 'totemsdk/omnia-vtxo/vtxo/v1';
-exports.VTXO_POOL_ID_DOMAIN = 'totemsdk/omnia-vtxo/pool/v1';
-exports.VTXO_LEAF_DOMAIN = 'totemsdk/omnia-vtxo/leaf/v1';
-exports.VTXO_RECEIPT_DOMAIN = 'totemsdk/omnia-vtxo/receipt/v1';
+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 = [
-        exports.VTXO_LEAF_DOMAIN,
+        VTXO_LEAF_DOMAIN,
         vtxo.vtxoId,
         vtxo.owner,
         vtxo.amount.toString(),
@@ -37,9 +39,9 @@ function computeVtxoLeaf(vtxo) {
     ].join(':');
     return sha3hex(input);
 }
-function computeVtxoId(params) {
+export function computeVtxoId(params) {
     const input = [
-        exports.VTXO_ID_DOMAIN,
+        VTXO_ID_DOMAIN,
         params.poolId,
         params.owner,
         params.amount.toString(),
@@ -48,9 +50,9 @@ function computeVtxoId(params) {
     ].join(':');
     return sha3hex(input);
 }
-function computePoolId(params) {
+export function computePoolId(params) {
     const input = [
-        exports.VTXO_POOL_ID_DOMAIN,
+        VTXO_POOL_ID_DOMAIN,
         params.operator,
         params.tokenId,
         params.nonce,
@@ -65,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];
     }
@@ -83,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') {
@@ -95,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();
@@ -109,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) {
@@ -129,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);
@@ -141,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 = [
-        exports.VTXO_RECEIPT_DOMAIN,
+        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.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Durable VTXO/pool snapshot store (RFC-007 G6).
  *
@@ -8,25 +7,23 @@
  * transitions never lose an update, reopen restores every VTXO (incl. spent
  * status and history), and corruption is surfaced — never treated as absence.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDurableOmniaVtxoStore = createDurableOmniaVtxoStore;
-const snapshot_1 = require("@totemsdk/storage/snapshot");
-const errors_1 = require("@totemsdk/storage/errors");
-const errors_js_1 = require("./errors.js");
+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 errors_1.StorageError('omnia-vtxo registry state is not an object', 'corrupt');
+        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 errors_1.StorageError(`omnia-vtxo registry state is missing section "${section}"`, 'corrupt');
+            throw new StorageError(`omnia-vtxo registry state is missing section "${section}"`, 'corrupt');
         }
     }
 }
-function createDurableOmniaVtxoStore(adapter, options = {}) {
-    const snapshots = (0, snapshot_1.createRevisionedSnapshotStore)(adapter, {
+export function createDurableOmniaVtxoStore(adapter, options = {}) {
+    const snapshots = createRevisionedSnapshotStore(adapter, {
         namespace: options.namespace ?? DEFAULT_NAMESPACE,
         requireAckMode: options.requireAckMode,
         empty: () => ({ pools: {}, vtxos: {} }),
@@ -69,7 +66,7 @@ function createDurableOmniaVtxoStore(adapter, options = {}) {
                     throw new Error(`VTXO ${vtxoId} not found`);
                 }
                 if (existing.status !== 'active') {
-                    throw new errors_js_1.VtxoStatusError(`Cannot mark VTXO ${vtxoId} as spent: status is '${existing.status}'`, existing.status);
+                    throw new VtxoStatusError(`Cannot mark VTXO ${vtxoId} as spent: status is '${existing.status}'`, existing.status);
                 }
                 const ts = now !== undefined ? now : Date.now();
                 const vtxos = {

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,57 @@
+/**
+ * VTXO exit transaction (RFC-038 V2 — owner-unilateral).
+ *
+ * The exit spends the pool's on-chain coin and pays the VTXO's owner, carrying
+ * the exit delay in STATE(110). It is signed with the **owner's** key (not the
+ * operator's): the pool script's `IF @BLOCK GT EXITBLOCK THEN RETURN
+ * SIGNEDBY(OWNER)` branch authorizes it after the exit window, so the owner can
+ * broadcast it without any operator signature or liveness. The digest is signed
+ * (injected signer) and, when a chain provider is supplied, mined + broadcast
+ * (injected miner).
+ *
+ * The caller must pass the owner signer; the operator cannot construct a valid
+ * exit witness for itself.
+ */
+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 on the owner's output. */
+export declare const EXIT_DELAY_PORT = 110;
+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,76 @@
+/**
+ * VTXO exit transaction (RFC-038 V2 — owner-unilateral).
+ *
+ * The exit spends the pool's on-chain coin and pays the VTXO's owner, carrying
+ * the exit delay in STATE(110). It is signed with the **owner's** key (not the
+ * operator's): the pool script's `IF @BLOCK GT EXITBLOCK THEN RETURN
+ * SIGNEDBY(OWNER)` branch authorizes it after the exit window, so the owner can
+ * broadcast it without any operator signature or liveness. The digest is signed
+ * (injected signer) and, when a chain provider is supplied, mined + broadcast
+ * (injected miner).
+ *
+ * The caller must pass the owner signer; the operator cannot construct a valid
+ * exit witness for itself.
+ */
+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 on the owner's output. */
+export const EXIT_DELAY_PORT = 110;
+/** 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,7 +8,10 @@ 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, caps the exit at the verified share, and consumes the VTXO's

package/dist/exit.js

@@ -1,20 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.markExiting = markExiting;
-exports.markExited = markExited;
-exports.createExitDraft = createExitDraft;
-exports.consumeExitReceipt = consumeExitReceipt;
-const errors_js_1 = require("./errors.js");
-const constants_js_1 = require("./constants.js");
-const commitment_js_1 = require("./commitment.js");
+import { VtxoStatusError, VtxoExitError, VtxoProofError } from './errors.js';
+import { computeReceiptId, computeVtxoLeaf } from './commitment.js';
 /**
  * Transitions an active VTXO to 'exiting' status.
  * @param now - Timestamp in ms. Defaults to Date.now() if omitted — pass explicitly for determinism.
  */
-function markExiting(vtxo, now) {
+export function markExiting(vtxo, now) {
     const ts = now !== undefined ? now : Date.now();
     if (vtxo.status !== 'active') {
-        throw new errors_js_1.VtxoStatusError(`Cannot initiate exit for VTXO ${vtxo.vtxoId}: status is '${vtxo.status}'`, vtxo.status);
+        throw new VtxoStatusError(`Cannot initiate exit for VTXO ${vtxo.vtxoId}: status is '${vtxo.status}'`, vtxo.status);
     }
     return {
         ...vtxo,
@@ -30,18 +23,19 @@ function markExiting(vtxo, now) {
  * Transitions an exiting VTXO to 'exited' status.
  * @param now - Timestamp in ms. Defaults to Date.now() if omitted — pass explicitly for determinism.
  */
-function markExited(vtxo, now) {
-    const ts = now !== undefined ? now : Date.now();
+export function markExited(vtxo, options = {}) {
+    const ts = options.now !== undefined ? options.now : Date.now();
     if (vtxo.status !== 'exiting') {
-        throw new errors_js_1.VtxoStatusError(`Cannot mark VTXO ${vtxo.vtxoId} as exited: status is '${vtxo.status}'`, vtxo.status);
+        throw new VtxoStatusError(`Cannot mark VTXO ${vtxo.vtxoId} as exited: status is '${vtxo.status}'`, vtxo.status);
     }
     return {
         ...vtxo,
         status: 'exited',
         updatedAt: ts,
+        ...(options.txpowId ? { exitTxpowId: options.txpowId } : {}),
         history: [
             ...vtxo.history,
-            { op: 'exit_complete', at: ts },
+            { op: 'exit_complete', at: ts, ...(options.txpowId ? { meta: { txpowId: options.txpowId } } : {}) },
         ],
     };
 }
@@ -52,9 +46,9 @@ function markExited(vtxo, now) {
 function assertProofLeafValid(vtxo) {
     if (!vtxo.proof.leaf)
         return;
-    const expectedLeaf = (0, commitment_js_1.computeVtxoLeaf)(vtxo);
+    const expectedLeaf = computeVtxoLeaf(vtxo);
     if (vtxo.proof.leaf !== expectedLeaf) {
-        throw new errors_js_1.VtxoProofError(`Exit draft rejected: VTXO ${vtxo.vtxoId} proof leaf mismatch. ` +
+        throw new VtxoProofError(`Exit draft rejected: VTXO ${vtxo.vtxoId} proof leaf mismatch. ` +
             `Expected ${expectedLeaf}, got ${vtxo.proof.leaf}`);
     }
 }
@@ -64,13 +58,13 @@ function assertProofLeafValid(vtxo) {
  * 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.
  */
-function createExitDraft(vtxo, now) {
+export function createExitDraft(vtxo, now) {
     const ts = now !== undefined ? now : Date.now();
     if (vtxo.status !== 'active' && vtxo.status !== 'exiting') {
-        throw new errors_js_1.VtxoExitError(`Cannot create exit draft for VTXO ${vtxo.vtxoId}: status is '${vtxo.status}'`);
+        throw new VtxoExitError(`Cannot create exit draft for VTXO ${vtxo.vtxoId}: status is '${vtxo.status}'`);
     }
     if (vtxo.exitConsumedAt !== undefined) {
-        throw new errors_js_1.VtxoExitError(`Cannot create exit draft for VTXO ${vtxo.vtxoId}: exit already consumed by ${vtxo.exitReceiptId}`);
+        throw new VtxoExitError(`Cannot create exit draft for VTXO ${vtxo.vtxoId}: exit already consumed by ${vtxo.exitReceiptId}`);
     }
     assertProofLeafValid(vtxo);
     const draft = {
@@ -79,12 +73,12 @@ function createExitDraft(vtxo, now) {
         owner: vtxo.owner,
         amount: vtxo.amount,
         tokenId: vtxo.tokenId,
-        draftType: 'mock-exit',
+        draftType: 'vtxo-exit',
         timelockSeconds: 86400,
         createdAt: ts,
         verifiedShare: vtxo.amount,
     };
-    const receiptId = (0, commitment_js_1.computeReceiptId)(vtxo.poolId, 'exit_initiated', [vtxo.vtxoId], [], ts);
+    const receiptId = computeReceiptId(vtxo.poolId, 'exit_initiated', [vtxo.vtxoId], [], ts);
     const receipt = {
         receiptId,
         poolId: vtxo.poolId,
@@ -93,8 +87,8 @@ function createExitDraft(vtxo, now) {
         outputIds: [],
         epoch: vtxo.epoch,
         at: ts,
-        signature: constants_js_1.MOCK_OPERATOR_SIGNATURE,
-        draftType: 'mock-exit',
+        signature: '',
+        draftType: 'vtxo-exit',
     };
     return { draft, receipt };
 }
@@ -102,9 +96,9 @@ function createExitDraft(vtxo, now) {
  * Consume a VTXO's exit receipt — the single-spend marker that prevents a
  * second exit draft for the same VTXO. Returns the updated VTXO.
  */
-function consumeExitReceipt(vtxo, receiptId, now) {
+export function consumeExitReceipt(vtxo, receiptId, now) {
     if (vtxo.exitConsumedAt !== undefined) {
-        throw new errors_js_1.VtxoExitError(`VTXO ${vtxo.vtxoId} exit already consumed by ${vtxo.exitReceiptId}`);
+        throw new VtxoExitError(`VTXO ${vtxo.vtxoId} exit already consumed by ${vtxo.exitReceiptId}`);
     }
     return {
         ...vtxo,

package/dist/index.d.ts

@@ -2,6 +2,11 @@ export * from './types.js';
 export * from './errors.js';
 export * from './constants.js';
 export * from './commitment.js';
+export * from './operator.js';
+export * from './receipt.js';
+export * from './pool-script.js';
+export * from './anchor.js';
+export * from './exit-tx.js';
 export * from './pool.js';
 export * from './vtxo.js';
 export * from './transfer.js';

package/dist/index.js

@@ -1,32 +1,21 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types.js"), exports);
-__exportStar(require("./errors.js"), exports);
-__exportStar(require("./constants.js"), exports);
-__exportStar(require("./commitment.js"), exports);
-__exportStar(require("./pool.js"), exports);
-__exportStar(require("./vtxo.js"), exports);
-__exportStar(require("./transfer.js"), exports);
-__exportStar(require("./split.js"), exports);
-__exportStar(require("./merge.js"), exports);
-__exportStar(require("./refresh.js"), exports);
-__exportStar(require("./exit.js"), exports);
-__exportStar(require("./verify.js"), exports);
-__exportStar(require("./memory-store.js"), exports);
-__exportStar(require("./durable-store.js"), exports);
-__exportStar(require("./serialization.js"), exports);
-__exportStar(require("./policy.js"), exports);
+export * from './types.js';
+export * from './errors.js';
+export * from './constants.js';
+export * from './commitment.js';
+export * from './operator.js';
+export * from './receipt.js';
+export * from './pool-script.js';
+export * from './anchor.js';
+export * from './exit-tx.js';
+export * from './pool.js';
+export * from './vtxo.js';
+export * from './transfer.js';
+export * from './split.js';
+export * from './merge.js';
+export * from './refresh.js';
+export * from './exit.js';
+export * from './verify.js';
+export * from './memory-store.js';
+export * from './durable-store.js';
+export * from './serialization.js';
+export * from './policy.js';