@totemsdk/omnia-vtxo 0.2.1 → 0.4.0

package/dist/memory-store.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryOmniaVtxoStore = void 0;
-const errors_js_1 = require("./errors.js");
-class MemoryOmniaVtxoStore {
+import { VtxoStatusError } from './errors.js';
+export class MemoryOmniaVtxoStore {
     constructor() {
         this.pools = new Map();
         this.vtxos = new Map();
@@ -36,7 +33,7 @@ class MemoryOmniaVtxoStore {
         if (!vtxo)
             throw new Error(`VTXO ${vtxoId} not found`);
         if (vtxo.status !== 'active') {
-            throw new errors_js_1.VtxoStatusError(`Cannot mark VTXO ${vtxoId} as spent: status is '${vtxo.status}'`, vtxo.status);
+            throw new VtxoStatusError(`Cannot mark VTXO ${vtxoId} as spent: status is '${vtxo.status}'`, vtxo.status);
         }
         // NOTE: Date.now() fallback is intentional and documented above.
         const ts = now !== undefined ? now : Date.now();
@@ -48,4 +45,3 @@ class MemoryOmniaVtxoStore {
         });
     }
 }
-exports.MemoryOmniaVtxoStore = MemoryOmniaVtxoStore;

package/dist/merge.js

@@ -1,26 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeVtxos = mergeVtxos;
-const errors_js_1 = require("./errors.js");
-const commitment_js_1 = require("./commitment.js");
-const constants_js_1 = require("./constants.js");
+import { VtxoStatusError, VtxoMergeError, VtxoOwnershipError } from './errors.js';
+import { computeVtxoId, buildVtxoProofSet, computeReceiptId } from './commitment.js';
 /**
  * Merges multiple VTXOs into one.
  * @param now - Timestamp in ms. Defaults to Date.now() if omitted — pass explicitly for determinism.
  */
-function mergeVtxos(vtxos, params, now) {
+export function mergeVtxos(vtxos, params, now) {
     const ts = now !== undefined ? now : Date.now();
     if (vtxos.length < 2) {
-        throw new errors_js_1.VtxoMergeError('Merge requires at least 2 VTXOs');
+        throw new VtxoMergeError('Merge requires at least 2 VTXOs');
     }
     const ids = vtxos.map(v => v.vtxoId);
     const uniqueIds = new Set(ids);
     if (uniqueIds.size !== ids.length) {
-        throw new errors_js_1.VtxoMergeError('Duplicate VTXO IDs detected in merge — double-counting prevented');
+        throw new VtxoMergeError('Duplicate VTXO IDs detected in merge — double-counting prevented');
     }
     for (const vtxo of vtxos) {
         if (vtxo.status !== 'active') {
-            throw new errors_js_1.VtxoStatusError(`Cannot merge VTXO ${vtxo.vtxoId}: status is '${vtxo.status}'`, vtxo.status);
+            throw new VtxoStatusError(`Cannot merge VTXO ${vtxo.vtxoId}: status is '${vtxo.status}'`, vtxo.status);
         }
     }
     const poolId = vtxos[0].poolId;
@@ -28,20 +24,20 @@ function mergeVtxos(vtxos, params, now) {
     const inputOwner = vtxos[0].owner;
     for (const vtxo of vtxos) {
         if (vtxo.poolId !== poolId) {
-            throw new errors_js_1.VtxoMergeError(`Cannot merge VTXOs from different pools: ${vtxo.poolId} vs ${poolId}`);
+            throw new VtxoMergeError(`Cannot merge VTXOs from different pools: ${vtxo.poolId} vs ${poolId}`);
         }
         if (vtxo.tokenId !== tokenId) {
-            throw new errors_js_1.VtxoMergeError(`Cannot merge VTXOs with different tokenIds: ${vtxo.tokenId} vs ${tokenId}`);
+            throw new VtxoMergeError(`Cannot merge VTXOs with different tokenIds: ${vtxo.tokenId} vs ${tokenId}`);
         }
         if (vtxo.owner !== inputOwner) {
-            throw new errors_js_1.VtxoOwnershipError(`Cannot merge VTXOs with different owners: ${vtxo.owner} vs ${inputOwner}`);
+            throw new VtxoOwnershipError(`Cannot merge VTXOs with different owners: ${vtxo.owner} vs ${inputOwner}`);
         }
     }
     if (params.owner !== inputOwner) {
-        throw new errors_js_1.VtxoOwnershipError(`Merge output owner '${params.owner}' must match input owner '${inputOwner}'`);
+        throw new VtxoOwnershipError(`Merge output owner '${params.owner}' must match input owner '${inputOwner}'`);
     }
     const totalAmount = vtxos.reduce((sum, v) => sum + v.amount, BigInt(0));
-    const outputId = (0, commitment_js_1.computeVtxoId)({
+    const outputId = computeVtxoId({
         poolId,
         owner: params.owner,
         amount: totalAmount,
@@ -75,7 +71,7 @@ function mergeVtxos(vtxos, params, now) {
             siblings: [],
             positions: [],
             epoch: vtxos[0].epoch,
-            batchId: constants_js_1.MOCK_BATCH_ID,
+            batchId: '',
         },
         history: [
             {
@@ -87,9 +83,9 @@ function mergeVtxos(vtxos, params, now) {
         createdAt: ts,
         updatedAt: ts,
     };
-    const { proofs } = (0, commitment_js_1.buildVtxoProofSet)([rawOutput]);
+    const { proofs } = buildVtxoProofSet([rawOutput]);
     const output = { ...rawOutput, proof: proofs[outputId] };
-    const receiptId = (0, commitment_js_1.computeReceiptId)(poolId, 'merge', ids, [outputId], ts);
+    const receiptId = computeReceiptId(poolId, 'merge', ids, [outputId], ts);
     return {
         inputs: inputVtxos,
         output,
@@ -101,7 +97,7 @@ function mergeVtxos(vtxos, params, now) {
             outputIds: [outputId],
             epoch: vtxos[0].epoch,
             at: ts,
-            signature: constants_js_1.MOCK_OPERATOR_SIGNATURE,
+            signature: '',
         },
     };
 }

package/dist/operator.d.ts

@@ -0,0 +1,29 @@
+/**
+ * VTXO operator co-signature (RFC-038 V0).
+ *
+ * The operator signs the canonical batch commitment with a unified WOTS
+ * `TreeKey` (RFC-037), allocating one leaf per signature under a WOTS lease
+ * (RFC-013). This retires the mock operator-signature placeholder: a receipt's
+ * `signature` is now a real serialized `TreeSignature` over the commitment, and
+ * `verify` checks it against the operator's tree-root public key.
+ *
+ * The operator's identity is the TreeKey root public key, so a holder can verify
+ * a receipt without trusting transport identity.
+ */
+import { type TreeKey } from '@totemsdk/core';
+import type { WotsLeaseProvider } from '@totemsdk/wots-lease';
+import type { OmniaVtxoOperator } from './types.js';
+/** Lease treeId for a pool's operator signatures. */
+export declare function vtxoOperatorTreeId(poolId: string): string;
+export interface VtxoOperatorOptions {
+    poolId: string;
+    /** The operator's unified WOTS TreeKey (RFC-037). */
+    treeKey: TreeKey;
+    /** Lease provider for one-time leaf allocation (RFC-013). */
+    leaseProvider: WotsLeaseProvider;
+}
+export interface VtxoOperatorWithIdentity extends OmniaVtxoOperator {
+    /** The operator's tree-root public key (its identity). */
+    readonly publicKey: string;
+}
+export declare function createVtxoOperator(options: VtxoOperatorOptions): VtxoOperatorWithIdentity;

package/dist/operator.js

@@ -0,0 +1,61 @@
+/**
+ * VTXO operator co-signature (RFC-038 V0).
+ *
+ * The operator signs the canonical batch commitment with a unified WOTS
+ * `TreeKey` (RFC-037), allocating one leaf per signature under a WOTS lease
+ * (RFC-013). This retires the mock operator-signature placeholder: a receipt's
+ * `signature` is now a real serialized `TreeSignature` over the commitment, and
+ * `verify` checks it against the operator's tree-root public key.
+ *
+ * The operator's identity is the TreeKey root public key, so a holder can verify
+ * a receipt without trusting transport identity.
+ */
+import { bytesToHex, deserializeTreeSignature, hexToBytes, serializeTreeSignature, sha3_256, verifyTreeSignature, } from '@totemsdk/core';
+/** Keys per tree level — the flat leaf index is `l1 * KEYS_PER_LEVEL + l2`. */
+const KEYS_PER_LEVEL = 64;
+/** Lease treeId for a pool's operator signatures. */
+export function vtxoOperatorTreeId(poolId) {
+    return `omnia-vtxo:${poolId}`;
+}
+export function createVtxoOperator(options) {
+    const { poolId, treeKey, leaseProvider } = options;
+    const rootPubkey = treeKey.getPublicKey();
+    // The TreeKey carries mutable state (setUses + sign); serialize signing so
+    // concurrent co-signs cannot race on a shared key.
+    let signLock = Promise.resolve();
+    const doSign = async (data) => {
+        const reservation = await leaseProvider.reserveKeyUse({
+            treeId: vtxoOperatorTreeId(poolId),
+            purpose: 'vtxo-operator',
+            payloadHash: bytesToHex(sha3_256(data)),
+        });
+        const flat = reservation.indices.l1 * KEYS_PER_LEVEL + reservation.indices.l2;
+        try {
+            treeKey.setUses(flat);
+            const signature = serializeTreeSignature(treeKey.sign(data));
+            await leaseProvider.commitKeyUse(reservation.reservationId, 'vtxo-operator');
+            return '0x' + bytesToHex(signature);
+        }
+        catch (err) {
+            await leaseProvider.burnReservation(reservation.reservationId, 'sign-failed').catch(() => { });
+            throw err;
+        }
+    };
+    return {
+        poolId,
+        publicKey: '0x' + bytesToHex(rootPubkey).toLowerCase(),
+        sign(data) {
+            const run = signLock.then(() => doSign(data), () => doSign(data));
+            signLock = run.then(() => undefined, () => undefined);
+            return run;
+        },
+        async verify(data, sig) {
+            try {
+                return verifyTreeSignature(rootPubkey, data, deserializeTreeSignature(hexToBytes(sig)));
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}

package/dist/policy.d.ts

@@ -16,7 +16,7 @@ export interface VtxoExitIntent {
     owner: string;
     amount: bigint;
     tokenId: string;
-    draftType: 'mock-exit';
+    draftType: 'vtxo-exit';
 }
 export declare function buildVtxoTransferIntent(vtxo: OmniaVtxo, recipient: string, amount: bigint, nonce: string, changeNonce?: string): VtxoTransferIntent;
 export declare function buildVtxoExitIntent(vtxo: OmniaVtxo): VtxoExitIntent;

package/dist/policy.js

@@ -1,8 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildVtxoTransferIntent = buildVtxoTransferIntent;
-exports.buildVtxoExitIntent = buildVtxoExitIntent;
-function buildVtxoTransferIntent(vtxo, recipient, amount, nonce, changeNonce) {
+export function buildVtxoTransferIntent(vtxo, recipient, amount, nonce, changeNonce) {
     return {
         type: 'vtxo-transfer',
         poolId: vtxo.poolId,
@@ -14,7 +10,7 @@ function buildVtxoTransferIntent(vtxo, recipient, amount, nonce, changeNonce) {
         changeNonce,
     };
 }
-function buildVtxoExitIntent(vtxo) {
+export function buildVtxoExitIntent(vtxo) {
     return {
         type: 'vtxo-exit',
         poolId: vtxo.poolId,
@@ -22,6 +18,6 @@ function buildVtxoExitIntent(vtxo) {
         owner: vtxo.owner,
         amount: vtxo.amount,
         tokenId: vtxo.tokenId,
-        draftType: 'mock-exit',
+        draftType: 'vtxo-exit',
     };
 }

package/dist/pool-script.d.ts

@@ -0,0 +1,36 @@
+/**
+ * VTXO pool on-chain script (RFC-038 V2 — non-custodial).
+ *
+ * The pool is an on-chain state output holding `totalCapacity`. An epoch's batch
+ * root is committed as STATE(100), the epoch number in STATE(101), and the
+ * owner's absolute exit-eligibility block in STATE(102).
+ *
+ * Custody (RFC-044 / CUSTODY-POLICY §2):
+ *   - **Unilateral owner exit.** After `@BLOCK GT EXITBLOCK` the owner alone may
+ *     spend (`RETURN SIGNEDBY(OWNER)`) — no operator signature or liveness. This
+ *     is exercised by the pre-signed exit tx (`exit-tx.ts`).
+ *   - **Cooperative update.** Before the exit window the pool may only move by
+ *     `MULTISIG(2 OPERATOR OWNER)`, epoch-monotone (`ASSERT EPOCH GT
+ *     PREVSTATE(101)`), with the exit block immutable (`ASSERT SAMESTATE(102
+ *     102)`) so the operator can never push the owner's escape clock, and the
+ *     value confined to the same script address (`ASSERT VERIFYOUT(@INPUT
+ *     @ADDRESS @AMOUNT @TOKENID TRUE)`) so the operator can never pay itself.
+ *
+ * The operator holds no unilateral path: it cannot move funds, cannot advance
+ * the exit block, and cannot stop the owner's exit. It is a liveness-only peer.
+ */
+export interface PoolScriptParams {
+    /** Operator WOTS public-key digest (64 hex). */
+    operatorPublicKeyDigest: string;
+    /** Pool owner WOTS public-key digest (64 hex). */
+    ownerPublicKeyDigest: string;
+    /** Absolute block height after which the owner may exit unilaterally. */
+    exitBlock: number;
+}
+/** Non-custodial, epoch-monotone, owner-escapable state-carrying pool script. */
+export declare function buildPoolScript(params: PoolScriptParams): string;
+export declare function poolScriptAddress(script: string): string;
+export declare function buildAndHashPoolScript(params: PoolScriptParams): {
+    script: string;
+    address: string;
+};

package/dist/pool-script.js

@@ -0,0 +1,55 @@
+/**
+ * VTXO pool on-chain script (RFC-038 V2 — non-custodial).
+ *
+ * The pool is an on-chain state output holding `totalCapacity`. An epoch's batch
+ * root is committed as STATE(100), the epoch number in STATE(101), and the
+ * owner's absolute exit-eligibility block in STATE(102).
+ *
+ * Custody (RFC-044 / CUSTODY-POLICY §2):
+ *   - **Unilateral owner exit.** After `@BLOCK GT EXITBLOCK` the owner alone may
+ *     spend (`RETURN SIGNEDBY(OWNER)`) — no operator signature or liveness. This
+ *     is exercised by the pre-signed exit tx (`exit-tx.ts`).
+ *   - **Cooperative update.** Before the exit window the pool may only move by
+ *     `MULTISIG(2 OPERATOR OWNER)`, epoch-monotone (`ASSERT EPOCH GT
+ *     PREVSTATE(101)`), with the exit block immutable (`ASSERT SAMESTATE(102
+ *     102)`) so the operator can never push the owner's escape clock, and the
+ *     value confined to the same script address (`ASSERT VERIFYOUT(@INPUT
+ *     @ADDRESS @AMOUNT @TOKENID TRUE)`) so the operator can never pay itself.
+ *
+ * The operator holds no unilateral path: it cannot move funds, cannot advance
+ * the exit block, and cannot stop the owner's exit. It is a liveness-only peer.
+ */
+import { computeScriptAddress } from '@totemsdk/core';
+function pkHex(digest, label) {
+    const raw = digest.replace(/^0x/i, '');
+    if (!/^[0-9a-fA-F]{64}$/.test(raw)) {
+        throw new Error(`${label} public key digest must be 64 hex chars, got ${JSON.stringify(digest)}`);
+    }
+    return '0X' + raw.toUpperCase();
+}
+/** Non-custodial, epoch-monotone, owner-escapable state-carrying pool script. */
+export function buildPoolScript(params) {
+    const owner = pkHex(params.ownerPublicKeyDigest, 'owner');
+    const operator = pkHex(params.operatorPublicKeyDigest, 'operator');
+    if (!Number.isInteger(params.exitBlock) || params.exitBlock < 0) {
+        throw new Error(`exitBlock must be a non-negative integer, got ${JSON.stringify(params.exitBlock)}`);
+    }
+    return [
+        'LET EPOCH=STATE(101)',
+        'LET EXITBLOCK=STATE(102)',
+        'IF @BLOCK GT EXITBLOCK THEN',
+        `  RETURN SIGNEDBY(${owner})`,
+        'ENDIF',
+        'ASSERT EPOCH GT PREVSTATE(101)',
+        'ASSERT SAMESTATE(102 102)',
+        'ASSERT VERIFYOUT(@INPUT @ADDRESS @AMOUNT @TOKENID TRUE)',
+        `RETURN MULTISIG(2 ${operator} ${owner})`,
+    ].join('\n');
+}
+export function poolScriptAddress(script) {
+    return computeScriptAddress(script);
+}
+export function buildAndHashPoolScript(params) {
+    const script = buildPoolScript(params);
+    return { script, address: poolScriptAddress(script) };
+}

package/dist/pool.js

@@ -1,24 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPool = createPool;
-exports.assertPoolCanMint = assertPoolCanMint;
-exports.updatePoolRoot = updatePoolRoot;
-exports.advancePoolEpoch = advancePoolEpoch;
-const errors_js_1 = require("./errors.js");
-const constants_js_1 = require("./constants.js");
-const commitment_js_1 = require("./commitment.js");
-function createPool(params, now) {
+import { VtxoPoolCapacityError, VtxoPolicyError } from './errors.js';
+import { DEFAULT_POLICY, EMPTY_TREE_ROOT, EPOCH_ZERO } from './constants.js';
+import { computePoolId } from './commitment.js';
+export function createPool(params, now) {
     const policy = {
-        minAmount: params.policy?.minAmount ?? constants_js_1.DEFAULT_POLICY.minAmount,
-        maxAmount: params.policy?.maxAmount ?? constants_js_1.DEFAULT_POLICY.maxAmount,
-        maxMergeInputs: params.policy?.maxMergeInputs ?? constants_js_1.DEFAULT_POLICY.maxMergeInputs,
-        maxSplitOutputs: params.policy?.maxSplitOutputs ?? constants_js_1.DEFAULT_POLICY.maxSplitOutputs,
-        exitTimelockSeconds: params.policy?.exitTimelockSeconds ?? constants_js_1.DEFAULT_POLICY.exitTimelockSeconds,
+        minAmount: params.policy?.minAmount ?? DEFAULT_POLICY.minAmount,
+        maxAmount: params.policy?.maxAmount ?? DEFAULT_POLICY.maxAmount,
+        maxMergeInputs: params.policy?.maxMergeInputs ?? DEFAULT_POLICY.maxMergeInputs,
+        maxSplitOutputs: params.policy?.maxSplitOutputs ?? DEFAULT_POLICY.maxSplitOutputs,
+        exitTimelockSeconds: params.policy?.exitTimelockSeconds ?? DEFAULT_POLICY.exitTimelockSeconds,
     };
     if (params.totalCapacity <= BigInt(0)) {
-        throw new errors_js_1.VtxoPolicyError('Pool totalCapacity must be > 0');
+        throw new VtxoPolicyError('Pool totalCapacity must be > 0');
     }
-    const poolId = (0, commitment_js_1.computePoolId)({
+    const poolId = computePoolId({
         operator: params.operator,
         tokenId: params.tokenId,
         nonce: params.nonce,
@@ -29,32 +23,32 @@ function createPool(params, now) {
         tokenId: params.tokenId,
         totalCapacity: params.totalCapacity,
         availableCapacity: params.totalCapacity,
-        epoch: constants_js_1.EPOCH_ZERO,
-        commitmentRoot: constants_js_1.EMPTY_TREE_ROOT,
+        epoch: EPOCH_ZERO,
+        commitmentRoot: EMPTY_TREE_ROOT,
         createdAt: now,
         policy,
     };
 }
-function assertPoolCanMint(pool, amount) {
+export function assertPoolCanMint(pool, amount) {
     if (amount <= BigInt(0)) {
-        throw new errors_js_1.VtxoPolicyError(`Mint amount must be > 0, got ${amount}`);
+        throw new VtxoPolicyError(`Mint amount must be > 0, got ${amount}`);
     }
     if (amount < pool.policy.minAmount) {
-        throw new errors_js_1.VtxoPolicyError(`Mint amount ${amount} is below pool minimum ${pool.policy.minAmount}`);
+        throw new VtxoPolicyError(`Mint amount ${amount} is below pool minimum ${pool.policy.minAmount}`);
     }
     if (amount > pool.policy.maxAmount) {
-        throw new errors_js_1.VtxoPolicyError(`Mint amount ${amount} exceeds pool maximum ${pool.policy.maxAmount}`);
+        throw new VtxoPolicyError(`Mint amount ${amount} exceeds pool maximum ${pool.policy.maxAmount}`);
     }
     if (amount > pool.availableCapacity) {
-        throw new errors_js_1.VtxoPoolCapacityError(`Insufficient pool capacity: requested ${amount}, available ${pool.availableCapacity}`, amount, pool.availableCapacity);
+        throw new VtxoPoolCapacityError(`Insufficient pool capacity: requested ${amount}, available ${pool.availableCapacity}`, amount, pool.availableCapacity);
     }
 }
-function updatePoolRoot(pool, root) {
+export function updatePoolRoot(pool, root) {
     return { ...pool, commitmentRoot: root };
 }
-function advancePoolEpoch(pool, newEpoch) {
+export function advancePoolEpoch(pool, newEpoch) {
     if (newEpoch <= pool.epoch) {
-        throw new errors_js_1.VtxoPolicyError(`New epoch ${newEpoch} must be greater than current epoch ${pool.epoch}`);
+        throw new VtxoPolicyError(`New epoch ${newEpoch} must be greater than current epoch ${pool.epoch}`);
     }
     return { ...pool, epoch: newEpoch };
 }

package/dist/receipt.d.ts

@@ -0,0 +1,31 @@
+/**
+ * VTXO receipt co-signing (RFC-038 V0, verify-before-sign per §3.5).
+ *
+ * A mutation emits its `VtxoOperatorReceipt` **unsigned**; the operator co-signs
+ * it only after **recomputing** the batch root from the batch's leaves and
+ * checking epoch monotonicity, output membership, and (when supplied) amount
+ * conservation. This prevents a caller from getting the operator to co-sign an
+ * arbitrary `(root, epoch, ids)` tuple whose root does not commit the outputs.
+ */
+import type { OmniaVtxo, OmniaVtxoOperator, VtxoOperatorReceipt } from './types.js';
+/** The batch the receipt belongs to — the operator's source of truth. */
+export interface VtxoReceiptBatch {
+    /** The VTXOs committed in this epoch's batch. */
+    outputs: OmniaVtxo[];
+    /** The batch root the receipt claims (the operator recomputes and compares). */
+    root: string;
+    /** The batch epoch. */
+    epoch: number;
+    /** The pool's current epoch, for monotonicity (must be strictly less). */
+    previousEpoch?: number;
+    /** Optional: total input amount, for a conservation check. */
+    inputsAmount?: bigint;
+}
+/**
+ * Co-sign a receipt with the operator, after verifying the batch.
+ * @throws if the root does not commit the leaves, the epoch is stale, an output
+ * is not in the batch, or conservation fails.
+ */
+export declare function signVtxoReceipt(operator: OmniaVtxoOperator, receipt: VtxoOperatorReceipt, batch: VtxoReceiptBatch): Promise<VtxoOperatorReceipt>;
+/** Verify a co-signed receipt against the operator and the batch root. */
+export declare function verifyVtxoReceipt(operator: OmniaVtxoOperator, receipt: VtxoOperatorReceipt, root: string): Promise<boolean>;

package/dist/receipt.js

@@ -0,0 +1,48 @@
+/**
+ * VTXO receipt co-signing (RFC-038 V0, verify-before-sign per §3.5).
+ *
+ * A mutation emits its `VtxoOperatorReceipt` **unsigned**; the operator co-signs
+ * it only after **recomputing** the batch root from the batch's leaves and
+ * checking epoch monotonicity, output membership, and (when supplied) amount
+ * conservation. This prevents a caller from getting the operator to co-sign an
+ * arbitrary `(root, epoch, ids)` tuple whose root does not commit the outputs.
+ */
+import { computeBatchCommitmentBytes, computeCommitmentRoot, computeVtxoLeaf } from './commitment.js';
+/**
+ * Co-sign a receipt with the operator, after verifying the batch.
+ * @throws if the root does not commit the leaves, the epoch is stale, an output
+ * is not in the batch, or conservation fails.
+ */
+export async function signVtxoReceipt(operator, receipt, batch) {
+    if (receipt.epoch !== batch.epoch) {
+        throw new Error(`receipt epoch ${receipt.epoch} does not match batch epoch ${batch.epoch}`);
+    }
+    if (batch.previousEpoch !== undefined && batch.epoch <= batch.previousEpoch) {
+        throw new Error(`batch epoch ${batch.epoch} is not greater than the pool epoch ${batch.previousEpoch}`);
+    }
+    const idSet = new Set(batch.outputs.map((v) => v.vtxoId));
+    for (const id of receipt.outputIds) {
+        if (!idSet.has(id))
+            throw new Error(`receipt output '${id}' is not a VTXO in the batch`);
+    }
+    const recomputedRoot = computeCommitmentRoot(batch.outputs.map(computeVtxoLeaf));
+    if (recomputedRoot !== batch.root) {
+        throw new Error('batch root does not commit the batch leaves');
+    }
+    if (batch.inputsAmount !== undefined) {
+        const outputSum = batch.outputs.reduce((sum, v) => sum + v.amount, 0n);
+        if (outputSum > batch.inputsAmount) {
+            throw new Error(`conservation violated: outputs ${outputSum} exceed inputs ${batch.inputsAmount}`);
+        }
+    }
+    const data = computeBatchCommitmentBytes(receipt.poolId, receipt.epoch, batch.root, receipt.outputIds);
+    const signature = await operator.sign(data);
+    return { ...receipt, signature };
+}
+/** Verify a co-signed receipt against the operator and the batch root. */
+export async function verifyVtxoReceipt(operator, receipt, root) {
+    if (!receipt.signature)
+        return false;
+    const data = computeBatchCommitmentBytes(receipt.poolId, receipt.epoch, root, receipt.outputIds);
+    return operator.verify(data, receipt.signature);
+}

package/dist/refresh.js

@@ -1,22 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.refreshVtxo = refreshVtxo;
-const errors_js_1 = require("./errors.js");
-const commitment_js_1 = require("./commitment.js");
-const constants_js_1 = require("./constants.js");
+import { VtxoStatusError, VtxoPolicyError } from './errors.js';
+import { computeVtxoId, buildVtxoProofSet, computeReceiptId } from './commitment.js';
 /**
  * Refreshes a VTXO to a new epoch.
  * @param now - Timestamp in ms. Defaults to Date.now() if omitted — pass explicitly for determinism.
  */
-function refreshVtxo(vtxo, params, now) {
+export function refreshVtxo(vtxo, params, now) {
     const ts = now !== undefined ? now : Date.now();
     if (vtxo.status !== 'active') {
-        throw new errors_js_1.VtxoStatusError(`Cannot refresh VTXO ${vtxo.vtxoId}: status is '${vtxo.status}'`, vtxo.status);
+        throw new VtxoStatusError(`Cannot refresh VTXO ${vtxo.vtxoId}: status is '${vtxo.status}'`, vtxo.status);
     }
     if (params.newEpoch <= vtxo.epoch) {
-        throw new errors_js_1.VtxoPolicyError(`Refresh epoch ${params.newEpoch} must be strictly greater than current epoch ${vtxo.epoch}`);
+        throw new VtxoPolicyError(`Refresh epoch ${params.newEpoch} must be strictly greater than current epoch ${vtxo.epoch}`);
     }
-    const refreshedId = (0, commitment_js_1.computeVtxoId)({
+    const refreshedId = computeVtxoId({
         poolId: vtxo.poolId,
         owner: vtxo.owner,
         amount: vtxo.amount,
@@ -51,7 +47,7 @@ function refreshVtxo(vtxo, params, now) {
             siblings: [],
             positions: [],
             epoch: params.newEpoch,
-            batchId: constants_js_1.MOCK_BATCH_ID,
+            batchId: '',
         },
         history: [
             {
@@ -65,9 +61,9 @@ function refreshVtxo(vtxo, params, now) {
         updatedAt: ts,
         expiresAt: vtxo.expiresAt,
     };
-    const { proofs } = (0, commitment_js_1.buildVtxoProofSet)([rawRefreshed]);
+    const { proofs } = buildVtxoProofSet([rawRefreshed]);
     const refreshedVtxo = { ...rawRefreshed, proof: proofs[refreshedId] };
-    const receiptId = (0, commitment_js_1.computeReceiptId)(vtxo.poolId, 'refresh', [vtxo.vtxoId], [refreshedId], ts);
+    const receiptId = computeReceiptId(vtxo.poolId, 'refresh', [vtxo.vtxoId], [refreshedId], ts);
     return {
         old: oldVtxo,
         refreshed: refreshedVtxo,
@@ -79,7 +75,7 @@ function refreshVtxo(vtxo, params, now) {
             outputIds: [refreshedId],
             epoch: params.newEpoch,
             at: ts,
-            signature: constants_js_1.MOCK_OPERATOR_SIGNATURE,
+            signature: '',
         },
     };
 }

package/dist/serialization.js

@@ -1,9 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeVtxo = serializeVtxo;
-exports.deserializeVtxo = deserializeVtxo;
-exports.serializePool = serializePool;
-exports.deserializePool = deserializePool;
 const BIGINT_PREFIX = '__bigint__:';
 function replacer(_key, value) {
     if (typeof value === 'bigint') {
@@ -17,15 +11,15 @@ function reviver(_key, value) {
     }
     return value;
 }
-function serializeVtxo(vtxo) {
+export function serializeVtxo(vtxo) {
     return JSON.stringify(vtxo, replacer);
 }
-function deserializeVtxo(json) {
+export function deserializeVtxo(json) {
     return JSON.parse(json, reviver);
 }
-function serializePool(pool) {
+export function serializePool(pool) {
     return JSON.stringify(pool, replacer);
 }
-function deserializePool(json) {
+export function deserializePool(json) {
     return JSON.parse(json, reviver);
 }

package/dist/split.js

@@ -1,34 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitVtxo = splitVtxo;
-const errors_js_1 = require("./errors.js");
-const commitment_js_1 = require("./commitment.js");
-const constants_js_1 = require("./constants.js");
+import { VtxoStatusError, VtxoAmountError, VtxoSplitError } from './errors.js';
+import { computeVtxoId, buildVtxoProofSet, computeReceiptId } from './commitment.js';
 /**
  * Splits a VTXO into multiple outputs.
  * @param now - Timestamp in ms. Defaults to Date.now() if omitted — pass explicitly for determinism.
  */
-function splitVtxo(vtxo, params, now) {
+export function splitVtxo(vtxo, params, now) {
     const ts = now !== undefined ? now : Date.now();
     if (vtxo.status !== 'active') {
-        throw new errors_js_1.VtxoStatusError(`Cannot split VTXO ${vtxo.vtxoId}: status is '${vtxo.status}'`, vtxo.status);
+        throw new VtxoStatusError(`Cannot split VTXO ${vtxo.vtxoId}: status is '${vtxo.status}'`, vtxo.status);
     }
     if (params.amounts.length < 2) {
-        throw new errors_js_1.VtxoSplitError('Split requires at least 2 output amounts');
+        throw new VtxoSplitError('Split requires at least 2 output amounts');
     }
     if (params.amounts.length !== params.nonces.length) {
-        throw new errors_js_1.VtxoSplitError('amounts and nonces arrays must have the same length');
+        throw new VtxoSplitError('amounts and nonces arrays must have the same length');
     }
     for (const amt of params.amounts) {
         if (amt <= BigInt(0)) {
-            throw new errors_js_1.VtxoAmountError(`All split amounts must be > 0, got ${amt}`);
+            throw new VtxoAmountError(`All split amounts must be > 0, got ${amt}`);
         }
     }
     const sum = params.amounts.reduce((a, b) => a + b, BigInt(0));
     if (sum !== vtxo.amount) {
-        throw new errors_js_1.VtxoAmountError(`Split amounts sum ${sum} does not equal VTXO amount ${vtxo.amount}`);
+        throw new VtxoAmountError(`Split amounts sum ${sum} does not equal VTXO amount ${vtxo.amount}`);
     }
-    const outputIds = params.amounts.map((amount, i) => (0, commitment_js_1.computeVtxoId)({
+    const outputIds = params.amounts.map((amount, i) => computeVtxoId({
         poolId: vtxo.poolId,
         owner: vtxo.owner,
         amount,
@@ -63,7 +59,7 @@ function splitVtxo(vtxo, params, now) {
             siblings: [],
             positions: [],
             epoch: vtxo.epoch,
-            batchId: constants_js_1.MOCK_BATCH_ID,
+            batchId: '',
         },
         history: [
             {
@@ -77,9 +73,9 @@ function splitVtxo(vtxo, params, now) {
         createdAt: ts,
         updatedAt: ts,
     }));
-    const { proofs } = (0, commitment_js_1.buildVtxoProofSet)(rawOutputs);
+    const { proofs } = buildVtxoProofSet(rawOutputs);
     const outputs = rawOutputs.map(o => ({ ...o, proof: proofs[o.vtxoId] }));
-    const receiptId = (0, commitment_js_1.computeReceiptId)(vtxo.poolId, 'split', [vtxo.vtxoId], outputIds, ts);
+    const receiptId = computeReceiptId(vtxo.poolId, 'split', [vtxo.vtxoId], outputIds, ts);
     return {
         input: inputVtxo,
         outputs,
@@ -91,7 +87,7 @@ function splitVtxo(vtxo, params, now) {
             outputIds,
             epoch: vtxo.epoch,
             at: ts,
-            signature: constants_js_1.MOCK_OPERATOR_SIGNATURE,
+            signature: '',
         },
     };
 }