@totemsdk/omnia-vtxo 0.3.0 → 0.4.0

package/dist/anchor.d.ts

@@ -11,6 +11,9 @@ import { type OmniaTxDraft, type StateValue } from '@totemsdk/omnia';
 import type { ChainStateProvider } from '@totemsdk/chain-provider';
 export interface BatchAnchorParams {
     operatorPublicKeyDigest: string;
+    ownerPublicKeyDigest: string;
+    /** Absolute block height after which the owner may exit unilaterally (STATE(102)). */
+    exitBlock: number;
     /** The epoch's Merkle root (32-byte hex). */
     root: string;
     epoch: number;
@@ -22,8 +25,8 @@ export interface BatchAnchorParams {
     amount: bigint;
     tokenId: string;
 }
-/** State variables carried by the pool output: STATE(100)=root, STATE(101)=epoch. */
-export declare function poolStateVariables(root: string, epoch: number): StateValue[];
+/** Pool output state: STATE(100)=root, STATE(101)=epoch, STATE(102)=exitBlock. */
+export declare function poolStateVariables(root: string, epoch: number, exitBlock: number): StateValue[];
 /** Build the batch-anchor draft (input = pool coin, output = pool state output). */
 export declare function buildBatchAnchorDraft(params: BatchAnchorParams): OmniaTxDraft;
 export declare function batchAnchorDigest(draft: OmniaTxDraft): Uint8Array;

package/dist/anchor.js

@@ -11,24 +11,29 @@ import { computeOmniaTxDigest, omniaDraftToMinimaBytes, } from '@totemsdk/omnia'
 import { serializeTxBody, mineTxPoW, TX_POW_MIN_DIFFICULTY } from '@totemsdk/txpow';
 import { concatBytes } from '@totemsdk/core';
 import { buildAndHashPoolScript } from './pool-script.js';
-/** State variables carried by the pool output: STATE(100)=root, STATE(101)=epoch. */
-export function poolStateVariables(root, epoch) {
+/** Pool output state: STATE(100)=root, STATE(101)=epoch, STATE(102)=exitBlock. */
+export function poolStateVariables(root, epoch, exitBlock) {
     return [
         { port: 100, value: root, type: 'string' },
         { port: 101, value: BigInt(epoch), type: 'number' },
+        { port: 102, value: BigInt(exitBlock), type: 'number' },
     ];
 }
 /** Build the batch-anchor draft (input = pool coin, output = pool state output). */
 export function buildBatchAnchorDraft(params) {
-    const { script, address } = buildAndHashPoolScript(params.operatorPublicKeyDigest);
+    const { script, address } = buildAndHashPoolScript({
+        operatorPublicKeyDigest: params.operatorPublicKeyDigest,
+        ownerPublicKeyDigest: params.ownerPublicKeyDigest,
+        exitBlock: params.exitBlock,
+    });
     // The input must be the operator's own pool output, not a foreign script.
     if (params.fundingScript !== script) {
-        throw new Error('anchorBatch: fundingScript does not match the operator pool script');
+        throw new Error('anchorBatch: fundingScript does not match the pool script');
     }
     if (params.fundingAddress !== address) {
-        throw new Error('anchorBatch: fundingAddress does not match the operator pool address');
+        throw new Error('anchorBatch: fundingAddress does not match the pool address');
     }
-    const stateVariables = poolStateVariables(params.root, params.epoch);
+    const stateVariables = poolStateVariables(params.root, params.epoch, params.exitBlock);
     return {
         type: 'settlement',
         inputs: [{

package/dist/cjs/anchor.d.ts

@@ -11,6 +11,9 @@ import { type OmniaTxDraft, type StateValue } from '@totemsdk/omnia';
 import type { ChainStateProvider } from '@totemsdk/chain-provider';
 export interface BatchAnchorParams {
     operatorPublicKeyDigest: string;
+    ownerPublicKeyDigest: string;
+    /** Absolute block height after which the owner may exit unilaterally (STATE(102)). */
+    exitBlock: number;
     /** The epoch's Merkle root (32-byte hex). */
     root: string;
     epoch: number;
@@ -22,8 +25,8 @@ export interface BatchAnchorParams {
     amount: bigint;
     tokenId: string;
 }
-/** State variables carried by the pool output: STATE(100)=root, STATE(101)=epoch. */
-export declare function poolStateVariables(root: string, epoch: number): StateValue[];
+/** Pool output state: STATE(100)=root, STATE(101)=epoch, STATE(102)=exitBlock. */
+export declare function poolStateVariables(root: string, epoch: number, exitBlock: number): StateValue[];
 /** Build the batch-anchor draft (input = pool coin, output = pool state output). */
 export declare function buildBatchAnchorDraft(params: BatchAnchorParams): OmniaTxDraft;
 export declare function batchAnchorDigest(draft: OmniaTxDraft): Uint8Array;

package/dist/cjs/anchor.js

@@ -18,24 +18,29 @@ const omnia_1 = require("@totemsdk/omnia");
 const txpow_1 = require("@totemsdk/txpow");
 const core_1 = require("@totemsdk/core");
 const pool_script_js_1 = require("./pool-script.js");
-/** State variables carried by the pool output: STATE(100)=root, STATE(101)=epoch. */
-function poolStateVariables(root, epoch) {
+/** Pool output state: STATE(100)=root, STATE(101)=epoch, STATE(102)=exitBlock. */
+function poolStateVariables(root, epoch, exitBlock) {
     return [
         { port: 100, value: root, type: 'string' },
         { port: 101, value: BigInt(epoch), type: 'number' },
+        { port: 102, value: BigInt(exitBlock), type: 'number' },
     ];
 }
 /** Build the batch-anchor draft (input = pool coin, output = pool state output). */
 function buildBatchAnchorDraft(params) {
-    const { script, address } = (0, pool_script_js_1.buildAndHashPoolScript)(params.operatorPublicKeyDigest);
+    const { script, address } = (0, pool_script_js_1.buildAndHashPoolScript)({
+        operatorPublicKeyDigest: params.operatorPublicKeyDigest,
+        ownerPublicKeyDigest: params.ownerPublicKeyDigest,
+        exitBlock: params.exitBlock,
+    });
     // The input must be the operator's own pool output, not a foreign script.
     if (params.fundingScript !== script) {
-        throw new Error('anchorBatch: fundingScript does not match the operator pool script');
+        throw new Error('anchorBatch: fundingScript does not match the pool script');
     }
     if (params.fundingAddress !== address) {
-        throw new Error('anchorBatch: fundingAddress does not match the operator pool address');
+        throw new Error('anchorBatch: fundingAddress does not match the pool address');
     }
-    const stateVariables = poolStateVariables(params.root, params.epoch);
+    const stateVariables = poolStateVariables(params.root, params.epoch, params.exitBlock);
     return {
         type: 'settlement',
         inputs: [{

package/dist/cjs/exit-tx.d.ts

@@ -1,20 +1,22 @@
 /**
- * VTXO exit transaction (RFC-038 V2).
+ * VTXO exit transaction (RFC-038 V2 — owner-unilateral).
  *
- * Builds a real exit transaction: spend the pool's on-chain coin and pay the
- * VTXO's owner, carrying the exit delay in STATE(102). The digest is signed
+ * 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). This replaces the `'mock-exit'` draft with a concrete tx.
+ * (injected miner).
  *
- * NOTE (RFC-038 §3.4): the full owner-unilateral covenant (a timelock branch the
- * owner can exercise without the operator, or a pre-signed exit tx) is a
- * follow-on; this builds and broadcasts the transaction with the delay encoded.
+ * 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. */
-export declare const EXIT_DELAY_PORT = 102;
+/** 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). */

package/dist/cjs/exit-tx.js

@@ -1,15 +1,17 @@
 "use strict";
 /**
- * VTXO exit transaction (RFC-038 V2).
+ * VTXO exit transaction (RFC-038 V2 — owner-unilateral).
  *
- * Builds a real exit transaction: spend the pool's on-chain coin and pay the
- * VTXO's owner, carrying the exit delay in STATE(102). The digest is signed
+ * 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). This replaces the `'mock-exit'` draft with a concrete tx.
+ * (injected miner).
  *
- * NOTE (RFC-038 §3.4): the full owner-unilateral covenant (a timelock branch the
- * owner can exercise without the operator, or a pre-signed exit tx) is a
- * follow-on; this builds and broadcasts the transaction with the delay encoded.
+ * The caller must pass the owner signer; the operator cannot construct a valid
+ * exit witness for itself.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EXIT_DELAY_PORT = void 0;
@@ -20,8 +22,8 @@ exports.buildExitTransaction = buildExitTransaction;
 const omnia_1 = require("@totemsdk/omnia");
 const txpow_1 = require("@totemsdk/txpow");
 const core_1 = require("@totemsdk/core");
-/** State port carrying the exit delay. */
-exports.EXIT_DELAY_PORT = 102;
+/** State port carrying the exit delay on the owner's output. */
+exports.EXIT_DELAY_PORT = 110;
 /** Draft that spends the pool coin to the VTXO owner with the exit delay encoded. */
 function buildExitTransactionDraft(params) {
     const stateVariables = [

package/dist/cjs/pool-script.d.ts

@@ -1,19 +1,36 @@
 /**
- * VTXO pool on-chain script (RFC-038 V1).
+ * 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) with the epoch number in STATE(101), and the
- * update requires a strictly-greater epoch (`ASSERT EPOCH GT PREVSTATE(101)`) so a
- * old root cannot be re-anchored (RFC-038 §5 "stale/rolled-back root").
+ * 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 NOTE: this script is currently **operator-only** (`SIGNEDBY(operator)`),
- * so until V2 lands the owner-unilateral timelock branch the pool output is
- * custodied by the operator on-chain. This is surfaced in RFC-038 §3.3/§5.
+ * 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.
  */
-/** Operator-controlled, epoch-monotone state-carrying pool script. */
-export declare function buildPoolScript(operatorPublicKeyDigest: string): string;
+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(operatorPublicKeyDigest: string): {
+export declare function buildAndHashPoolScript(params: PoolScriptParams): {
     script: string;
     address: string;
 };

package/dist/cjs/pool-script.js

@@ -1,41 +1,60 @@
 "use strict";
 /**
- * VTXO pool on-chain script (RFC-038 V1).
+ * 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) with the epoch number in STATE(101), and the
- * update requires a strictly-greater epoch (`ASSERT EPOCH GT PREVSTATE(101)`) so a
- * old root cannot be re-anchored (RFC-038 §5 "stale/rolled-back root").
+ * 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 NOTE: this script is currently **operator-only** (`SIGNEDBY(operator)`),
- * so until V2 lands the owner-unilateral timelock branch the pool output is
- * custodied by the operator on-chain. This is surfaced in RFC-038 §3.3/§5.
+ * 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.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildPoolScript = buildPoolScript;
 exports.poolScriptAddress = poolScriptAddress;
 exports.buildAndHashPoolScript = buildAndHashPoolScript;
 const core_1 = require("@totemsdk/core");
-function operatorPkHex(operatorPublicKeyDigest) {
-    const raw = operatorPublicKeyDigest.replace(/^0x/i, '');
+function pkHex(digest, label) {
+    const raw = digest.replace(/^0x/i, '');
     if (!/^[0-9a-fA-F]{64}$/.test(raw)) {
-        throw new Error(`operator public key digest must be 64 hex chars, got ${JSON.stringify(operatorPublicKeyDigest)}`);
+        throw new Error(`${label} public key digest must be 64 hex chars, got ${JSON.stringify(digest)}`);
     }
     return '0X' + raw.toUpperCase();
 }
-/** Operator-controlled, epoch-monotone state-carrying pool script. */
-function buildPoolScript(operatorPublicKeyDigest) {
+/** Non-custodial, epoch-monotone, owner-escapable state-carrying pool script. */
+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 ROOT=STATE(100)',
         'LET EPOCH=STATE(101)',
+        'LET EXITBLOCK=STATE(102)',
+        'IF @BLOCK GT EXITBLOCK THEN',
+        `  RETURN SIGNEDBY(${owner})`,
+        'ENDIF',
         'ASSERT EPOCH GT PREVSTATE(101)',
-        `RETURN SIGNEDBY(${operatorPkHex(operatorPublicKeyDigest)})`,
+        'ASSERT SAMESTATE(102 102)',
+        'ASSERT VERIFYOUT(@INPUT @ADDRESS @AMOUNT @TOKENID TRUE)',
+        `RETURN MULTISIG(2 ${operator} ${owner})`,
     ].join('\n');
 }
 function poolScriptAddress(script) {
     return (0, core_1.computeScriptAddress)(script);
 }
-function buildAndHashPoolScript(operatorPublicKeyDigest) {
-    const script = buildPoolScript(operatorPublicKeyDigest);
+function buildAndHashPoolScript(params) {
+    const script = buildPoolScript(params);
     return { script, address: poolScriptAddress(script) };
 }

package/dist/exit-tx.d.ts

@@ -1,20 +1,22 @@
 /**
- * VTXO exit transaction (RFC-038 V2).
+ * VTXO exit transaction (RFC-038 V2 — owner-unilateral).
  *
- * Builds a real exit transaction: spend the pool's on-chain coin and pay the
- * VTXO's owner, carrying the exit delay in STATE(102). The digest is signed
+ * 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). This replaces the `'mock-exit'` draft with a concrete tx.
+ * (injected miner).
  *
- * NOTE (RFC-038 §3.4): the full owner-unilateral covenant (a timelock branch the
- * owner can exercise without the operator, or a pre-signed exit tx) is a
- * follow-on; this builds and broadcasts the transaction with the delay encoded.
+ * 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. */
-export declare const EXIT_DELAY_PORT = 102;
+/** 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). */

package/dist/exit-tx.js

@@ -1,20 +1,22 @@
 /**
- * VTXO exit transaction (RFC-038 V2).
+ * VTXO exit transaction (RFC-038 V2 — owner-unilateral).
  *
- * Builds a real exit transaction: spend the pool's on-chain coin and pay the
- * VTXO's owner, carrying the exit delay in STATE(102). The digest is signed
+ * 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). This replaces the `'mock-exit'` draft with a concrete tx.
+ * (injected miner).
  *
- * NOTE (RFC-038 §3.4): the full owner-unilateral covenant (a timelock branch the
- * owner can exercise without the operator, or a pre-signed exit tx) is a
- * follow-on; this builds and broadcasts the transaction with the delay encoded.
+ * 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. */
-export const EXIT_DELAY_PORT = 102;
+/** 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 = [

package/dist/pool-script.d.ts

@@ -1,19 +1,36 @@
 /**
- * VTXO pool on-chain script (RFC-038 V1).
+ * 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) with the epoch number in STATE(101), and the
- * update requires a strictly-greater epoch (`ASSERT EPOCH GT PREVSTATE(101)`) so a
- * old root cannot be re-anchored (RFC-038 §5 "stale/rolled-back root").
+ * 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 NOTE: this script is currently **operator-only** (`SIGNEDBY(operator)`),
- * so until V2 lands the owner-unilateral timelock branch the pool output is
- * custodied by the operator on-chain. This is surfaced in RFC-038 §3.3/§5.
+ * 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.
  */
-/** Operator-controlled, epoch-monotone state-carrying pool script. */
-export declare function buildPoolScript(operatorPublicKeyDigest: string): string;
+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(operatorPublicKeyDigest: string): {
+export declare function buildAndHashPoolScript(params: PoolScriptParams): {
     script: string;
     address: string;
 };

package/dist/pool-script.js

@@ -1,36 +1,55 @@
 /**
- * VTXO pool on-chain script (RFC-038 V1).
+ * 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) with the epoch number in STATE(101), and the
- * update requires a strictly-greater epoch (`ASSERT EPOCH GT PREVSTATE(101)`) so a
- * old root cannot be re-anchored (RFC-038 §5 "stale/rolled-back root").
+ * 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 NOTE: this script is currently **operator-only** (`SIGNEDBY(operator)`),
- * so until V2 lands the owner-unilateral timelock branch the pool output is
- * custodied by the operator on-chain. This is surfaced in RFC-038 §3.3/§5.
+ * 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 operatorPkHex(operatorPublicKeyDigest) {
-    const raw = operatorPublicKeyDigest.replace(/^0x/i, '');
+function pkHex(digest, label) {
+    const raw = digest.replace(/^0x/i, '');
     if (!/^[0-9a-fA-F]{64}$/.test(raw)) {
-        throw new Error(`operator public key digest must be 64 hex chars, got ${JSON.stringify(operatorPublicKeyDigest)}`);
+        throw new Error(`${label} public key digest must be 64 hex chars, got ${JSON.stringify(digest)}`);
     }
     return '0X' + raw.toUpperCase();
 }
-/** Operator-controlled, epoch-monotone state-carrying pool script. */
-export function buildPoolScript(operatorPublicKeyDigest) {
+/** 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 ROOT=STATE(100)',
         'LET EPOCH=STATE(101)',
+        'LET EXITBLOCK=STATE(102)',
+        'IF @BLOCK GT EXITBLOCK THEN',
+        `  RETURN SIGNEDBY(${owner})`,
+        'ENDIF',
         'ASSERT EPOCH GT PREVSTATE(101)',
-        `RETURN SIGNEDBY(${operatorPkHex(operatorPublicKeyDigest)})`,
+        '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(operatorPublicKeyDigest) {
-    const script = buildPoolScript(operatorPublicKeyDigest);
+export function buildAndHashPoolScript(params) {
+    const script = buildPoolScript(params);
     return { script, address: poolScriptAddress(script) };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/omnia-vtxo",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Virtual UTXO / payment-pool claim layer for Omnia — cash-like off-chain balance primitive for Totem Edge",
   "main": "dist/cjs/index.js",
   "types": "dist/cjs/index.d.ts",
@@ -25,11 +25,11 @@
   ],
   "dependencies": {
     "@totemsdk/chain-provider": "^0.2.1",
-    "@totemsdk/omnia": "^1.0.3",
-    "@totemsdk/core": "^1.2.11",
+    "@totemsdk/omnia": "^2.0.0",
     "@totemsdk/storage": "^0.1.0",
-    "@totemsdk/wots-lease": "^1.0.1",
-    "@totemsdk/txpow": "^1.0.2"
+    "@totemsdk/txpow": "^1.0.2",
+    "@totemsdk/core": "^1.2.11",
+    "@totemsdk/wots-lease": "^1.0.1"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",