@totemsdk/omnia-vtxo 0.1.0

package/dist/split.js

@@ -0,0 +1,97 @@
+"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");
+/**
+ * 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) {
+    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);
+    }
+    if (params.amounts.length < 2) {
+        throw new errors_js_1.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');
+    }
+    for (const amt of params.amounts) {
+        if (amt <= BigInt(0)) {
+            throw new errors_js_1.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}`);
+    }
+    const outputIds = params.amounts.map((amount, i) => (0, commitment_js_1.computeVtxoId)({
+        poolId: vtxo.poolId,
+        owner: vtxo.owner,
+        amount,
+        tokenId: vtxo.tokenId,
+        nonce: params.nonces[i],
+    }));
+    const inputVtxo = {
+        ...vtxo,
+        status: 'split',
+        updatedAt: ts,
+        history: [
+            ...vtxo.history,
+            {
+                op: 'split',
+                at: ts,
+                from: vtxo.owner,
+                relatedIds: outputIds,
+            },
+        ],
+    };
+    const rawOutputs = params.amounts.map((amount, i) => ({
+        vtxoId: outputIds[i],
+        poolId: vtxo.poolId,
+        owner: vtxo.owner,
+        amount,
+        tokenId: vtxo.tokenId,
+        status: 'active',
+        epoch: vtxo.epoch,
+        proof: {
+            leaf: '',
+            root: '',
+            siblings: [],
+            positions: [],
+            epoch: vtxo.epoch,
+            batchId: constants_js_1.MOCK_BATCH_ID,
+        },
+        history: [
+            {
+                op: 'split',
+                at: ts,
+                from: vtxo.owner,
+                relatedIds: [vtxo.vtxoId],
+                meta: { splitIndex: i },
+            },
+        ],
+        createdAt: ts,
+        updatedAt: ts,
+    }));
+    const { proofs } = (0, commitment_js_1.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);
+    return {
+        input: inputVtxo,
+        outputs,
+        receipt: {
+            receiptId,
+            poolId: vtxo.poolId,
+            op: 'split',
+            inputIds: [vtxo.vtxoId],
+            outputIds,
+            epoch: vtxo.epoch,
+            at: ts,
+            signature: constants_js_1.MOCK_OPERATOR_SIGNATURE,
+        },
+    };
+}

package/dist/transfer.d.ts

@@ -0,0 +1,8 @@
+import { OmniaVtxo, TransferVtxoParams, TransferResult, VtxoOperatorReceipt } from './types.js';
+/**
+ * Transfers a VTXO (fully or partially) to a recipient.
+ * @param now - Timestamp in ms. Defaults to Date.now() if omitted — pass explicitly for determinism.
+ */
+export declare function transferVtxo(vtxo: OmniaVtxo, params: TransferVtxoParams, now?: number): TransferResult & {
+    receipt: VtxoOperatorReceipt;
+};

package/dist/transfer.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transferVtxo = transferVtxo;
+const errors_js_1 = require("./errors.js");
+const commitment_js_1 = require("./commitment.js");
+const constants_js_1 = require("./constants.js");
+/**
+ * Transfers a VTXO (fully or partially) to a recipient.
+ * @param now - Timestamp in ms. Defaults to Date.now() if omitted — pass explicitly for determinism.
+ */
+function transferVtxo(vtxo, params, now) {
+    const ts = now !== undefined ? now : Date.now();
+    if (vtxo.status !== 'active') {
+        throw new errors_js_1.VtxoStatusError(`Cannot transfer VTXO ${vtxo.vtxoId}: status is '${vtxo.status}'`, vtxo.status);
+    }
+    if (params.amount <= BigInt(0)) {
+        throw new errors_js_1.VtxoAmountError(`Transfer amount must be > 0, got ${params.amount}`);
+    }
+    if (params.amount > vtxo.amount) {
+        throw new errors_js_1.VtxoAmountError(`Transfer amount ${params.amount} exceeds VTXO amount ${vtxo.amount}`);
+    }
+    const isPartial = params.amount < vtxo.amount;
+    const changeAmount = vtxo.amount - params.amount;
+    const outputId = (0, commitment_js_1.computeVtxoId)({
+        poolId: vtxo.poolId,
+        owner: params.recipient,
+        amount: params.amount,
+        tokenId: vtxo.tokenId,
+        nonce: params.nonce,
+    });
+    let changeVtxo;
+    let changeId;
+    if (isPartial) {
+        const changeNonce = params.changeNonce ?? params.nonce + ':change';
+        changeId = (0, commitment_js_1.computeVtxoId)({
+            poolId: vtxo.poolId,
+            owner: vtxo.owner,
+            amount: changeAmount,
+            tokenId: vtxo.tokenId,
+            nonce: changeNonce,
+        });
+    }
+    const inputVtxo = {
+        ...vtxo,
+        status: isPartial ? 'split' : 'transferred',
+        updatedAt: ts,
+        history: [
+            ...vtxo.history,
+            {
+                op: isPartial ? 'split' : 'transfer',
+                at: ts,
+                from: vtxo.owner,
+                to: params.recipient,
+                relatedIds: changeId ? [outputId, changeId] : [outputId],
+            },
+        ],
+    };
+    const outputVtxo = {
+        vtxoId: outputId,
+        poolId: vtxo.poolId,
+        owner: params.recipient,
+        amount: params.amount,
+        tokenId: vtxo.tokenId,
+        status: 'active',
+        epoch: vtxo.epoch,
+        proof: {
+            leaf: '',
+            root: '',
+            siblings: [],
+            positions: [],
+            epoch: vtxo.epoch,
+            batchId: constants_js_1.MOCK_BATCH_ID,
+        },
+        history: [
+            {
+                op: 'transfer',
+                at: ts,
+                from: vtxo.owner,
+                to: params.recipient,
+                relatedIds: [vtxo.vtxoId],
+            },
+        ],
+        createdAt: ts,
+        updatedAt: ts,
+    };
+    const outputIds = [outputId];
+    if (isPartial && changeId) {
+        changeVtxo = {
+            vtxoId: changeId,
+            poolId: vtxo.poolId,
+            owner: vtxo.owner,
+            amount: changeAmount,
+            tokenId: vtxo.tokenId,
+            status: 'active',
+            epoch: vtxo.epoch,
+            proof: {
+                leaf: '',
+                root: '',
+                siblings: [],
+                positions: [],
+                epoch: vtxo.epoch,
+                batchId: constants_js_1.MOCK_BATCH_ID,
+            },
+            history: [
+                {
+                    op: 'split',
+                    at: ts,
+                    from: vtxo.owner,
+                    relatedIds: [vtxo.vtxoId],
+                    meta: { role: 'change' },
+                },
+            ],
+            createdAt: ts,
+            updatedAt: ts,
+        };
+        outputIds.push(changeId);
+    }
+    const activeOutputs = changeVtxo ? [outputVtxo, changeVtxo] : [outputVtxo];
+    const { proofs } = (0, commitment_js_1.buildVtxoProofSet)(activeOutputs);
+    const patchedOutput = { ...outputVtxo, proof: proofs[outputId] };
+    const patchedChange = changeVtxo
+        ? { ...changeVtxo, proof: proofs[changeId] }
+        : undefined;
+    const transfer = {
+        inputId: vtxo.vtxoId,
+        outputId,
+        changeId,
+        from: vtxo.owner,
+        to: params.recipient,
+        amount: params.amount,
+        changeAmount: isPartial ? changeAmount : undefined,
+        poolId: vtxo.poolId,
+        tokenId: vtxo.tokenId,
+        at: ts,
+    };
+    const receiptId = (0, commitment_js_1.computeReceiptId)(vtxo.poolId, 'transfer', [vtxo.vtxoId], outputIds, ts);
+    return {
+        input: inputVtxo,
+        output: patchedOutput,
+        change: patchedChange,
+        transfer,
+        receipt: {
+            receiptId,
+            poolId: vtxo.poolId,
+            op: 'transfer',
+            inputIds: [vtxo.vtxoId],
+            outputIds,
+            epoch: vtxo.epoch,
+            at: ts,
+            signature: constants_js_1.MOCK_OPERATOR_SIGNATURE,
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,155 @@
+export type VtxoId = string;
+export type VtxoStatus = 'active' | 'transferred' | 'split' | 'merged' | 'refreshed' | 'exiting' | 'exited' | 'spent' | 'expired' | 'invalid';
+export type VtxoOp = 'mint' | 'transfer' | 'split' | 'merge' | 'refresh' | 'exit_initiated' | 'exit_complete' | 'spent';
+export interface VtxoPoolPolicy {
+    minAmount: bigint;
+    maxAmount: bigint;
+    maxMergeInputs: number;
+    maxSplitOutputs: number;
+    exitTimelockSeconds: number;
+}
+export interface OmniaVtxoPool {
+    poolId: string;
+    operator: string;
+    tokenId: string;
+    totalCapacity: bigint;
+    availableCapacity: bigint;
+    epoch: number;
+    commitmentRoot: string;
+    createdAt: number;
+    policy: VtxoPoolPolicy;
+}
+export interface VtxoProof {
+    leaf: string;
+    root: string;
+    siblings: string[];
+    positions: Array<'left' | 'right'>;
+    epoch: number;
+    batchId: string;
+}
+export interface VtxoHistoryEntry {
+    op: VtxoOp;
+    at: number;
+    from?: string;
+    to?: string;
+    relatedIds?: VtxoId[];
+    meta?: Record<string, unknown>;
+}
+export interface OmniaVtxo {
+    vtxoId: VtxoId;
+    poolId: string;
+    owner: string;
+    amount: bigint;
+    tokenId: string;
+    status: VtxoStatus;
+    epoch: number;
+    proof: VtxoProof;
+    history: VtxoHistoryEntry[];
+    createdAt: number;
+    updatedAt: number;
+    expiresAt?: number;
+}
+export interface VtxoTransfer {
+    inputId: VtxoId;
+    outputId: VtxoId;
+    changeId?: VtxoId;
+    from: string;
+    to: string;
+    amount: bigint;
+    changeAmount?: bigint;
+    poolId: string;
+    tokenId: string;
+    at: number;
+}
+export interface VtxoOperatorReceipt {
+    receiptId: string;
+    poolId: string;
+    op: VtxoOp;
+    inputIds: VtxoId[];
+    outputIds: VtxoId[];
+    epoch: number;
+    at: number;
+    signature: string;
+    draftType?: string;
+}
+export interface CreatePoolParams {
+    operator: string;
+    tokenId: string;
+    totalCapacity: bigint;
+    policy?: Partial<VtxoPoolPolicy>;
+    nonce: string;
+}
+export interface MintVtxoParams {
+    owner: string;
+    amount: bigint;
+    nonce: string;
+    expiresAt?: number;
+}
+export interface TransferVtxoParams {
+    recipient: string;
+    amount: bigint;
+    nonce: string;
+    changeNonce?: string;
+}
+export interface SplitVtxoParams {
+    amounts: bigint[];
+    nonces: string[];
+}
+export interface MergeVtxosParams {
+    nonce: string;
+    owner: string;
+}
+export interface RefreshVtxoParams {
+    newEpoch: number;
+    nonce: string;
+}
+export interface MintResult {
+    pool: OmniaVtxoPool;
+    vtxo: OmniaVtxo;
+    receipt: VtxoOperatorReceipt;
+}
+export interface TransferResult {
+    input: OmniaVtxo;
+    output: OmniaVtxo;
+    change?: OmniaVtxo;
+    transfer: VtxoTransfer;
+}
+export interface SplitResult {
+    input: OmniaVtxo;
+    outputs: OmniaVtxo[];
+}
+export interface MergeResult {
+    inputs: OmniaVtxo[];
+    output: OmniaVtxo;
+}
+export interface RefreshResult {
+    old: OmniaVtxo;
+    refreshed: OmniaVtxo;
+}
+export interface ExitDraft {
+    vtxoId: VtxoId;
+    poolId: string;
+    owner: string;
+    amount: bigint;
+    tokenId: string;
+    draftType: 'mock-exit';
+    timelockSeconds: number;
+    createdAt: number;
+}
+export interface VerifyVtxoResult {
+    valid: boolean;
+    errors: string[];
+}
+export interface OmniaVtxoStore {
+    savePool(pool: OmniaVtxoPool): Promise<void>;
+    getPool(poolId: string): Promise<OmniaVtxoPool | undefined>;
+    saveVtxo(vtxo: OmniaVtxo): Promise<void>;
+    getVtxo(vtxoId: VtxoId): Promise<OmniaVtxo | undefined>;
+    listVtxos(poolId?: string): Promise<OmniaVtxo[]>;
+    markVtxoSpent(vtxoId: VtxoId, now?: number): Promise<void>;
+}
+export interface OmniaVtxoOperator {
+    poolId: string;
+    sign(data: Uint8Array): Promise<string>;
+    verify(data: Uint8Array, sig: string): Promise<boolean>;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/verify.d.ts

@@ -0,0 +1,23 @@
+import { OmniaVtxo, VtxoProof, VtxoTransfer, VerifyVtxoResult } from './types.js';
+export declare function verifyVtxo(vtxo: OmniaVtxo): VerifyVtxoResult;
+export declare function verifyVtxoProof(vtxo: OmniaVtxo, proof: VtxoProof): VerifyVtxoResult;
+export declare function verifyVtxoTransfer(input: OmniaVtxo, output: OmniaVtxo, transfer: VtxoTransfer): VerifyVtxoResult;
+export interface ConservationInput {
+    inputs: OmniaVtxo[];
+    outputs: OmniaVtxo[];
+    /**
+     * Conservation mode:
+     * - `'lte'` (default) — outputs may be less than or equal to inputs (allows exit/fee/burn flows)
+     * - `'strict'` — outputs must equal inputs exactly (required for transfer, split, merge)
+     */
+    mode?: 'lte' | 'strict';
+}
+/**
+ * Verifies amount conservation across a set of inputs and outputs.
+ *
+ * Default mode (`'lte'`): `sum(outputs) <= sum(inputs)` — allows exits, fees, and burn flows.
+ * Strict mode (`'strict'`): `sum(outputs) === sum(inputs)` — required for transfer, split, merge.
+ *
+ * Always requires: same `poolId` and `tokenId` across all inputs and outputs.
+ */
+export declare function verifyConservation(params: ConservationInput): VerifyVtxoResult;

package/dist/verify.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyVtxo = verifyVtxo;
+exports.verifyVtxoProof = verifyVtxoProof;
+exports.verifyVtxoTransfer = verifyVtxoTransfer;
+exports.verifyConservation = verifyConservation;
+const commitment_js_1 = require("./commitment.js");
+function verifyVtxo(vtxo) {
+    const errors = [];
+    if (!vtxo.vtxoId)
+        errors.push('Missing vtxoId');
+    if (!vtxo.poolId)
+        errors.push('Missing poolId');
+    if (!vtxo.owner)
+        errors.push('Missing owner');
+    if (vtxo.amount <= BigInt(0))
+        errors.push(`Amount must be > 0, got ${vtxo.amount}`);
+    if (!vtxo.tokenId)
+        errors.push('Missing tokenId');
+    if (!vtxo.status)
+        errors.push('Missing status');
+    if (vtxo.proof && vtxo.proof.leaf && vtxo.proof.root) {
+        const proofResult = verifyVtxoProof(vtxo, vtxo.proof);
+        if (!proofResult.valid) {
+            errors.push(...proofResult.errors.map(e => `Proof: ${e}`));
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+function verifyVtxoProof(vtxo, proof) {
+    const errors = [];
+    const expectedLeaf = (0, commitment_js_1.computeVtxoLeaf)(vtxo);
+    if (proof.leaf !== expectedLeaf) {
+        errors.push(`Proof leaf mismatch: expected ${expectedLeaf}, got ${proof.leaf}`);
+    }
+    if (proof.siblings.length > 0) {
+        const proofNodes = proof.siblings.map((sibling, i) => ({
+            sibling,
+            position: proof.positions[i],
+        }));
+        const valid = (0, commitment_js_1.verifyMerkleProof)(proof.leaf, proofNodes, proof.root);
+        if (!valid) {
+            errors.push('Merkle proof verification failed');
+        }
+    }
+    else {
+        if (proof.leaf !== proof.root) {
+            errors.push('Single-leaf proof: leaf must equal root');
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+function verifyVtxoTransfer(input, output, transfer) {
+    const errors = [];
+    if (transfer.inputId !== input.vtxoId) {
+        errors.push(`Transfer inputId ${transfer.inputId} does not match input VTXO ${input.vtxoId}`);
+    }
+    if (transfer.outputId !== output.vtxoId) {
+        errors.push(`Transfer outputId ${transfer.outputId} does not match output VTXO ${output.vtxoId}`);
+    }
+    if (input.poolId !== output.poolId) {
+        errors.push(`Pool mismatch: input ${input.poolId}, output ${output.poolId}`);
+    }
+    if (input.tokenId !== output.tokenId) {
+        errors.push(`Token mismatch: input ${input.tokenId}, output ${output.tokenId}`);
+    }
+    if (transfer.amount > input.amount) {
+        errors.push(`Transfer amount ${transfer.amount} exceeds input amount ${input.amount}`);
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Verifies amount conservation across a set of inputs and outputs.
+ *
+ * Default mode (`'lte'`): `sum(outputs) <= sum(inputs)` — allows exits, fees, and burn flows.
+ * Strict mode (`'strict'`): `sum(outputs) === sum(inputs)` — required for transfer, split, merge.
+ *
+ * Always requires: same `poolId` and `tokenId` across all inputs and outputs.
+ */
+function verifyConservation(params) {
+    const errors = [];
+    const { inputs, outputs, mode = 'lte' } = params;
+    if (inputs.length === 0 || outputs.length === 0) {
+        errors.push('Conservation check requires at least one input and one output');
+        return { valid: false, errors };
+    }
+    const poolId = inputs[0].poolId;
+    const tokenId = inputs[0].tokenId;
+    for (const vtxo of inputs) {
+        if (vtxo.poolId !== poolId) {
+            errors.push(`Input pool mismatch: ${vtxo.poolId} vs ${poolId}`);
+        }
+        if (vtxo.tokenId !== tokenId) {
+            errors.push(`Input token mismatch: ${vtxo.tokenId} vs ${tokenId}`);
+        }
+    }
+    for (const vtxo of outputs) {
+        if (vtxo.poolId !== poolId) {
+            errors.push(`Output pool mismatch: ${vtxo.poolId} vs ${poolId}`);
+        }
+        if (vtxo.tokenId !== tokenId) {
+            errors.push(`Output token mismatch: ${vtxo.tokenId} vs ${tokenId}`);
+        }
+    }
+    if (errors.length > 0) {
+        return { valid: false, errors };
+    }
+    const inputSum = inputs.reduce((sum, v) => sum + v.amount, BigInt(0));
+    const outputSum = outputs.reduce((sum, v) => sum + v.amount, BigInt(0));
+    if (mode === 'strict') {
+        if (outputSum !== inputSum) {
+            errors.push(`Conservation violation (strict): input sum ${inputSum} !== output sum ${outputSum}`);
+        }
+    }
+    else {
+        if (outputSum > inputSum) {
+            errors.push(`Conservation violation: output sum ${outputSum} exceeds input sum ${inputSum}`);
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}

package/dist/vtxo.d.ts

@@ -0,0 +1,14 @@
+import { OmniaVtxoPool, OmniaVtxo, MintVtxoParams, MintResult } from './types.js';
+export declare function isVtxoActive(vtxo: OmniaVtxo): boolean;
+/**
+ * Mints a new VTXO against a pool.
+ * @param pool - The pool to mint from.
+ * @param params - Mint parameters (owner, amount, nonce).
+ * @param now - Timestamp in ms. Defaults to Date.now() if omitted — pass explicitly for determinism.
+ */
+export declare function mintVtxo(pool: OmniaVtxoPool, params: MintVtxoParams, now?: number): MintResult;
+/**
+ * Marks an active VTXO as spent.
+ * @param now - Timestamp in ms. Defaults to Date.now() if omitted — pass explicitly for determinism.
+ */
+export declare function markVtxoSpent(vtxo: OmniaVtxo, now?: number): OmniaVtxo;

package/dist/vtxo.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVtxoActive = isVtxoActive;
+exports.mintVtxo = mintVtxo;
+exports.markVtxoSpent = markVtxoSpent;
+const errors_js_1 = require("./errors.js");
+const constants_js_1 = require("./constants.js");
+const commitment_js_1 = require("./commitment.js");
+const pool_js_1 = require("./pool.js");
+function isVtxoActive(vtxo) {
+    return vtxo.status === 'active';
+}
+/**
+ * Mints a new VTXO against a pool.
+ * @param pool - The pool to mint from.
+ * @param params - Mint parameters (owner, amount, nonce).
+ * @param now - Timestamp in ms. Defaults to Date.now() if omitted — pass explicitly for determinism.
+ */
+function mintVtxo(pool, params, now) {
+    const ts = now !== undefined ? now : Date.now();
+    (0, pool_js_1.assertPoolCanMint)(pool, params.amount);
+    const vtxoId = (0, commitment_js_1.computeVtxoId)({
+        poolId: pool.poolId,
+        owner: params.owner,
+        amount: params.amount,
+        tokenId: pool.tokenId,
+        nonce: params.nonce,
+    });
+    const vtxo = {
+        vtxoId,
+        poolId: pool.poolId,
+        owner: params.owner,
+        amount: params.amount,
+        tokenId: pool.tokenId,
+        status: 'active',
+        epoch: pool.epoch,
+        proof: {
+            leaf: '',
+            root: '',
+            siblings: [],
+            positions: [],
+            epoch: pool.epoch,
+            batchId: constants_js_1.MOCK_BATCH_ID,
+        },
+        history: [
+            {
+                op: 'mint',
+                at: ts,
+                to: params.owner,
+                meta: { poolId: pool.poolId },
+            },
+        ],
+        createdAt: ts,
+        updatedAt: ts,
+        expiresAt: params.expiresAt,
+    };
+    const { root, proofs } = (0, commitment_js_1.buildVtxoProofSet)([vtxo]);
+    const proof = proofs[vtxoId];
+    const mintedVtxo = { ...vtxo, proof };
+    const updatedPool = {
+        ...pool,
+        availableCapacity: pool.availableCapacity - params.amount,
+        commitmentRoot: root,
+    };
+    const receiptId = (0, commitment_js_1.computeReceiptId)(pool.poolId, 'mint', [], [vtxoId], ts);
+    const receipt = {
+        receiptId,
+        poolId: pool.poolId,
+        op: 'mint',
+        inputIds: [],
+        outputIds: [vtxoId],
+        epoch: pool.epoch,
+        at: ts,
+        signature: constants_js_1.MOCK_OPERATOR_SIGNATURE,
+    };
+    return { pool: updatedPool, vtxo: mintedVtxo, receipt };
+}
+/**
+ * Marks an active VTXO as spent.
+ * @param now - Timestamp in ms. Defaults to Date.now() if omitted — pass explicitly for determinism.
+ */
+function markVtxoSpent(vtxo, now) {
+    const ts = now !== undefined ? now : Date.now();
+    if (!isVtxoActive(vtxo)) {
+        throw new errors_js_1.VtxoStatusError(`Cannot mark VTXO ${vtxo.vtxoId} as spent: status is '${vtxo.status}'`, vtxo.status);
+    }
+    return {
+        ...vtxo,
+        status: 'spent',
+        updatedAt: ts,
+        history: [
+            ...vtxo.history,
+            { op: 'spent', at: ts },
+        ],
+    };
+}