@totemsdk/omnia-vtxo 0.1.0

package/dist/exit.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markExiting = markExiting;
+exports.markExited = markExited;
+exports.createExitDraft = createExitDraft;
+const errors_js_1 = require("./errors.js");
+const constants_js_1 = require("./constants.js");
+const commitment_js_1 = require("./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) {
+    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);
+    }
+    return {
+        ...vtxo,
+        status: 'exiting',
+        updatedAt: ts,
+        history: [
+            ...vtxo.history,
+            { op: 'exit_initiated', at: ts },
+        ],
+    };
+}
+/**
+ * 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();
+    if (vtxo.status !== 'exiting') {
+        throw new errors_js_1.VtxoStatusError(`Cannot mark VTXO ${vtxo.vtxoId} as exited: status is '${vtxo.status}'`, vtxo.status);
+    }
+    return {
+        ...vtxo,
+        status: 'exited',
+        updatedAt: ts,
+        history: [
+            ...vtxo.history,
+            { op: 'exit_complete', at: ts },
+        ],
+    };
+}
+/**
+ * Validates the VTXO's proof leaf integrity before creating an exit draft.
+ * Throws VtxoProofError if the proof leaf is present but does not match the VTXO fields.
+ */
+function assertProofLeafValid(vtxo) {
+    if (!vtxo.proof.leaf)
+        return;
+    const expectedLeaf = (0, commitment_js_1.computeVtxoLeaf)(vtxo);
+    if (vtxo.proof.leaf !== expectedLeaf) {
+        throw new errors_js_1.VtxoProofError(`Exit draft rejected: VTXO ${vtxo.vtxoId} proof leaf mismatch. ` +
+            `Expected ${expectedLeaf}, got ${vtxo.proof.leaf}`);
+    }
+}
+/**
+ * Creates a mock exit draft for a VTXO. Validates the proof leaf before drafting.
+ * @param now - Timestamp in ms. Defaults to Date.now() if omitted — pass explicitly for determinism.
+ */
+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}'`);
+    }
+    assertProofLeafValid(vtxo);
+    const draft = {
+        vtxoId: vtxo.vtxoId,
+        poolId: vtxo.poolId,
+        owner: vtxo.owner,
+        amount: vtxo.amount,
+        tokenId: vtxo.tokenId,
+        draftType: 'mock-exit',
+        timelockSeconds: 86400,
+        createdAt: ts,
+    };
+    const receiptId = (0, commitment_js_1.computeReceiptId)(vtxo.poolId, 'exit_initiated', [vtxo.vtxoId], [], ts);
+    const receipt = {
+        receiptId,
+        poolId: vtxo.poolId,
+        op: 'exit_initiated',
+        inputIds: [vtxo.vtxoId],
+        outputIds: [],
+        epoch: vtxo.epoch,
+        at: ts,
+        signature: constants_js_1.MOCK_OPERATOR_SIGNATURE,
+        draftType: 'mock-exit',
+    };
+    return { draft, receipt };
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export * from './types.js';
+export * from './errors.js';
+export * from './constants.js';
+export * from './commitment.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 './serialization.js';
+export * from './policy.js';

package/dist/index.js

@@ -0,0 +1,31 @@
+"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("./serialization.js"), exports);
+__exportStar(require("./policy.js"), exports);

package/dist/memory-store.d.ts

@@ -0,0 +1,17 @@
+import { OmniaVtxo, OmniaVtxoPool, OmniaVtxoStore, VtxoId } from './types.js';
+export declare class MemoryOmniaVtxoStore implements OmniaVtxoStore {
+    private readonly pools;
+    private readonly vtxos;
+    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[]>;
+    /**
+     * Marks a VTXO as spent. Accepts an optional `now` timestamp for deterministic testing.
+     * When `now` is omitted the store falls back to `Date.now()` — this is intentional
+     * and explicitly documented: the store is a persistence layer, not a pure function,
+     * so wall-clock time is an acceptable default for production use. Pass `now` in tests.
+     */
+    markVtxoSpent(vtxoId: VtxoId, now?: number): Promise<void>;
+}

package/dist/memory-store.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryOmniaVtxoStore = void 0;
+const errors_js_1 = require("./errors.js");
+class MemoryOmniaVtxoStore {
+    constructor() {
+        this.pools = new Map();
+        this.vtxos = new Map();
+    }
+    async savePool(pool) {
+        this.pools.set(pool.poolId, pool);
+    }
+    async getPool(poolId) {
+        return this.pools.get(poolId);
+    }
+    async saveVtxo(vtxo) {
+        this.vtxos.set(vtxo.vtxoId, vtxo);
+    }
+    async getVtxo(vtxoId) {
+        return this.vtxos.get(vtxoId);
+    }
+    async listVtxos(poolId) {
+        const all = Array.from(this.vtxos.values());
+        if (poolId === undefined)
+            return all;
+        return all.filter(v => v.poolId === poolId);
+    }
+    /**
+     * Marks a VTXO as spent. Accepts an optional `now` timestamp for deterministic testing.
+     * When `now` is omitted the store falls back to `Date.now()` — this is intentional
+     * and explicitly documented: the store is a persistence layer, not a pure function,
+     * so wall-clock time is an acceptable default for production use. Pass `now` in tests.
+     */
+    async markVtxoSpent(vtxoId, now) {
+        const vtxo = this.vtxos.get(vtxoId);
+        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);
+        }
+        // NOTE: Date.now() fallback is intentional and documented above.
+        const ts = now !== undefined ? now : Date.now();
+        this.vtxos.set(vtxoId, {
+            ...vtxo,
+            status: 'spent',
+            updatedAt: ts,
+            history: [...vtxo.history, { op: 'spent', at: ts }],
+        });
+    }
+}
+exports.MemoryOmniaVtxoStore = MemoryOmniaVtxoStore;

package/dist/merge.d.ts

@@ -0,0 +1,8 @@
+import { OmniaVtxo, MergeVtxosParams, MergeResult, VtxoOperatorReceipt } from './types.js';
+/**
+ * Merges multiple VTXOs into one.
+ * @param now - Timestamp in ms. Defaults to Date.now() if omitted — pass explicitly for determinism.
+ */
+export declare function mergeVtxos(vtxos: OmniaVtxo[], params: MergeVtxosParams, now?: number): MergeResult & {
+    receipt: VtxoOperatorReceipt;
+};

package/dist/merge.js

@@ -0,0 +1,107 @@
+"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");
+/**
+ * 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) {
+    const ts = now !== undefined ? now : Date.now();
+    if (vtxos.length < 2) {
+        throw new errors_js_1.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');
+    }
+    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);
+        }
+    }
+    const poolId = vtxos[0].poolId;
+    const tokenId = vtxos[0].tokenId;
+    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}`);
+        }
+        if (vtxo.tokenId !== tokenId) {
+            throw new errors_js_1.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}`);
+        }
+    }
+    if (params.owner !== inputOwner) {
+        throw new errors_js_1.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)({
+        poolId,
+        owner: params.owner,
+        amount: totalAmount,
+        tokenId,
+        nonce: params.nonce,
+    });
+    const inputVtxos = vtxos.map(vtxo => ({
+        ...vtxo,
+        status: 'merged',
+        updatedAt: ts,
+        history: [
+            ...vtxo.history,
+            {
+                op: 'merge',
+                at: ts,
+                relatedIds: [outputId],
+            },
+        ],
+    }));
+    const rawOutput = {
+        vtxoId: outputId,
+        poolId,
+        owner: params.owner,
+        amount: totalAmount,
+        tokenId,
+        status: 'active',
+        epoch: vtxos[0].epoch,
+        proof: {
+            leaf: '',
+            root: '',
+            siblings: [],
+            positions: [],
+            epoch: vtxos[0].epoch,
+            batchId: constants_js_1.MOCK_BATCH_ID,
+        },
+        history: [
+            {
+                op: 'merge',
+                at: ts,
+                relatedIds: ids,
+            },
+        ],
+        createdAt: ts,
+        updatedAt: ts,
+    };
+    const { proofs } = (0, commitment_js_1.buildVtxoProofSet)([rawOutput]);
+    const output = { ...rawOutput, proof: proofs[outputId] };
+    const receiptId = (0, commitment_js_1.computeReceiptId)(poolId, 'merge', ids, [outputId], ts);
+    return {
+        inputs: inputVtxos,
+        output,
+        receipt: {
+            receiptId,
+            poolId,
+            op: 'merge',
+            inputIds: ids,
+            outputIds: [outputId],
+            epoch: vtxos[0].epoch,
+            at: ts,
+            signature: constants_js_1.MOCK_OPERATOR_SIGNATURE,
+        },
+    };
+}

package/dist/policy.d.ts

@@ -0,0 +1,22 @@
+import { OmniaVtxo, VtxoId } from './types.js';
+export interface VtxoTransferIntent {
+    type: 'vtxo-transfer';
+    poolId: string;
+    inputId: VtxoId;
+    recipient: string;
+    amount: bigint;
+    tokenId: string;
+    nonce: string;
+    changeNonce?: string;
+}
+export interface VtxoExitIntent {
+    type: 'vtxo-exit';
+    poolId: string;
+    vtxoId: VtxoId;
+    owner: string;
+    amount: bigint;
+    tokenId: string;
+    draftType: 'mock-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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildVtxoTransferIntent = buildVtxoTransferIntent;
+exports.buildVtxoExitIntent = buildVtxoExitIntent;
+function buildVtxoTransferIntent(vtxo, recipient, amount, nonce, changeNonce) {
+    return {
+        type: 'vtxo-transfer',
+        poolId: vtxo.poolId,
+        inputId: vtxo.vtxoId,
+        recipient,
+        amount,
+        tokenId: vtxo.tokenId,
+        nonce,
+        changeNonce,
+    };
+}
+function buildVtxoExitIntent(vtxo) {
+    return {
+        type: 'vtxo-exit',
+        poolId: vtxo.poolId,
+        vtxoId: vtxo.vtxoId,
+        owner: vtxo.owner,
+        amount: vtxo.amount,
+        tokenId: vtxo.tokenId,
+        draftType: 'mock-exit',
+    };
+}

package/dist/pool.d.ts

@@ -0,0 +1,5 @@
+import { OmniaVtxoPool, CreatePoolParams } from './types.js';
+export declare function createPool(params: CreatePoolParams, now: number): OmniaVtxoPool;
+export declare function assertPoolCanMint(pool: OmniaVtxoPool, amount: bigint): void;
+export declare function updatePoolRoot(pool: OmniaVtxoPool, root: string): OmniaVtxoPool;
+export declare function advancePoolEpoch(pool: OmniaVtxoPool, newEpoch: number): OmniaVtxoPool;

package/dist/pool.js

@@ -0,0 +1,60 @@
+"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) {
+    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,
+    };
+    if (params.totalCapacity <= BigInt(0)) {
+        throw new errors_js_1.VtxoPolicyError('Pool totalCapacity must be > 0');
+    }
+    const poolId = (0, commitment_js_1.computePoolId)({
+        operator: params.operator,
+        tokenId: params.tokenId,
+        nonce: params.nonce,
+    });
+    return {
+        poolId,
+        operator: params.operator,
+        tokenId: params.tokenId,
+        totalCapacity: params.totalCapacity,
+        availableCapacity: params.totalCapacity,
+        epoch: constants_js_1.EPOCH_ZERO,
+        commitmentRoot: constants_js_1.EMPTY_TREE_ROOT,
+        createdAt: now,
+        policy,
+    };
+}
+function assertPoolCanMint(pool, amount) {
+    if (amount <= BigInt(0)) {
+        throw new errors_js_1.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}`);
+    }
+    if (amount > pool.policy.maxAmount) {
+        throw new errors_js_1.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);
+    }
+}
+function updatePoolRoot(pool, root) {
+    return { ...pool, commitmentRoot: root };
+}
+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}`);
+    }
+    return { ...pool, epoch: newEpoch };
+}

package/dist/refresh.d.ts

@@ -0,0 +1,8 @@
+import { OmniaVtxo, RefreshVtxoParams, RefreshResult, VtxoOperatorReceipt } from './types.js';
+/**
+ * Refreshes a VTXO to a new epoch.
+ * @param now - Timestamp in ms. Defaults to Date.now() if omitted — pass explicitly for determinism.
+ */
+export declare function refreshVtxo(vtxo: OmniaVtxo, params: RefreshVtxoParams, now?: number): RefreshResult & {
+    receipt: VtxoOperatorReceipt;
+};

package/dist/refresh.js

@@ -0,0 +1,85 @@
+"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");
+/**
+ * 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) {
+    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);
+    }
+    if (params.newEpoch <= vtxo.epoch) {
+        throw new errors_js_1.VtxoPolicyError(`Refresh epoch ${params.newEpoch} must be strictly greater than current epoch ${vtxo.epoch}`);
+    }
+    const refreshedId = (0, commitment_js_1.computeVtxoId)({
+        poolId: vtxo.poolId,
+        owner: vtxo.owner,
+        amount: vtxo.amount,
+        tokenId: vtxo.tokenId,
+        nonce: params.nonce,
+    });
+    const oldVtxo = {
+        ...vtxo,
+        status: 'refreshed',
+        updatedAt: ts,
+        history: [
+            ...vtxo.history,
+            {
+                op: 'refresh',
+                at: ts,
+                relatedIds: [refreshedId],
+                meta: { newEpoch: params.newEpoch },
+            },
+        ],
+    };
+    const rawRefreshed = {
+        vtxoId: refreshedId,
+        poolId: vtxo.poolId,
+        owner: vtxo.owner,
+        amount: vtxo.amount,
+        tokenId: vtxo.tokenId,
+        status: 'active',
+        epoch: params.newEpoch,
+        proof: {
+            leaf: '',
+            root: '',
+            siblings: [],
+            positions: [],
+            epoch: params.newEpoch,
+            batchId: constants_js_1.MOCK_BATCH_ID,
+        },
+        history: [
+            {
+                op: 'refresh',
+                at: ts,
+                relatedIds: [vtxo.vtxoId],
+                meta: { prevEpoch: vtxo.epoch, newEpoch: params.newEpoch },
+            },
+        ],
+        createdAt: ts,
+        updatedAt: ts,
+        expiresAt: vtxo.expiresAt,
+    };
+    const { proofs } = (0, commitment_js_1.buildVtxoProofSet)([rawRefreshed]);
+    const refreshedVtxo = { ...rawRefreshed, proof: proofs[refreshedId] };
+    const receiptId = (0, commitment_js_1.computeReceiptId)(vtxo.poolId, 'refresh', [vtxo.vtxoId], [refreshedId], ts);
+    return {
+        old: oldVtxo,
+        refreshed: refreshedVtxo,
+        receipt: {
+            receiptId,
+            poolId: vtxo.poolId,
+            op: 'refresh',
+            inputIds: [vtxo.vtxoId],
+            outputIds: [refreshedId],
+            epoch: params.newEpoch,
+            at: ts,
+            signature: constants_js_1.MOCK_OPERATOR_SIGNATURE,
+        },
+    };
+}

package/dist/serialization.d.ts

@@ -0,0 +1,5 @@
+import { OmniaVtxo, OmniaVtxoPool } from './types.js';
+export declare function serializeVtxo(vtxo: OmniaVtxo): string;
+export declare function deserializeVtxo(json: string): OmniaVtxo;
+export declare function serializePool(pool: OmniaVtxoPool): string;
+export declare function deserializePool(json: string): OmniaVtxoPool;

package/dist/serialization.js

@@ -0,0 +1,31 @@
+"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') {
+        return `${BIGINT_PREFIX}${value.toString()}`;
+    }
+    return value;
+}
+function reviver(_key, value) {
+    if (typeof value === 'string' && value.startsWith(BIGINT_PREFIX)) {
+        return BigInt(value.slice(BIGINT_PREFIX.length));
+    }
+    return value;
+}
+function serializeVtxo(vtxo) {
+    return JSON.stringify(vtxo, replacer);
+}
+function deserializeVtxo(json) {
+    return JSON.parse(json, reviver);
+}
+function serializePool(pool) {
+    return JSON.stringify(pool, replacer);
+}
+function deserializePool(json) {
+    return JSON.parse(json, reviver);
+}

package/dist/split.d.ts

@@ -0,0 +1,8 @@
+import { OmniaVtxo, SplitVtxoParams, SplitResult, VtxoOperatorReceipt } from './types.js';
+/**
+ * Splits a VTXO into multiple outputs.
+ * @param now - Timestamp in ms. Defaults to Date.now() if omitted — pass explicitly for determinism.
+ */
+export declare function splitVtxo(vtxo: OmniaVtxo, params: SplitVtxoParams, now?: number): SplitResult & {
+    receipt: VtxoOperatorReceipt;
+};