@totemsdk/omnia-vtxo 0.6.2 → 0.7.0

package/dist/cjs/index.d.ts

@@ -5,6 +5,7 @@ export * from './commitment.js';
 export * from './operator.js';
 export * from './receipt.js';
 export * from './pool-script.js';
+export * from './owner-pool.js';
 export * from './anchor.js';
 export * from './exit-tx.js';
 export * from './pool.js';

package/dist/cjs/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./commitment.js"), exports);
 __exportStar(require("./operator.js"), exports);
 __exportStar(require("./receipt.js"), exports);
 __exportStar(require("./pool-script.js"), exports);
+__exportStar(require("./owner-pool.js"), exports);
 __exportStar(require("./anchor.js"), exports);
 __exportStar(require("./exit-tx.js"), exports);
 __exportStar(require("./pool.js"), exports);

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

@@ -0,0 +1,95 @@
+/**
+ * V1 transferable owner-pool covenant.
+ *
+ * A single-owner claim coin whose **current owner is committed in state**, not
+ * in the script. The owner can:
+ *
+ *   - transfer the whole coin by signing a state update that recreates it at
+ *     the same address/amount with a new owner (epoch increments); or
+ *   - exit after `exitBlock` to the committed owner address, with no operator
+ *     signature or liveness.
+ *
+ * The script authenticates the **previous** committed owner
+ * (`SIGNEDBY(PREVSTATE(103))`), so a spender cannot substitute their own key.
+ * `PREVSTATE(104)` is the committed payout address. This is the V1 recovery
+ * path: a recipient holds a coin they can spend unilaterally.
+ */
+import type { OmniaTxDraft, StateValue } from '@totemsdk/omnia';
+export declare const OWNER_POOL_ROOT_PORT = 100;
+export declare const OWNER_POOL_EPOCH_PORT = 101;
+export declare const OWNER_POOL_EXIT_BLOCK_PORT = 102;
+export declare const OWNER_POOL_PK_PORT = 103;
+export declare const OWNER_POOL_ADDR_PORT = 104;
+export interface OwnerPoolState {
+    /** Batch/root commitment (opaque to this covenant; owner cannot change it). */
+    root: string;
+    /** Monotonic state epoch; every transfer increments it. */
+    epoch: number;
+    /** Absolute block after which the committed owner may exit unilaterally. */
+    exitBlock: number;
+    /** Current owner public-key digest (32-byte hex, `0x`-prefixed). */
+    ownerPk: string;
+    /** Current owner payout address (derived from `ownerPk` by the transfer builder). */
+    ownerAddr: string;
+}
+/** Derive the committed payout address from an owner public-key digest. */
+export declare function ownerAddressFor(ownerPk: string): string;
+/**
+ * The transferable owner-pool script. State ports 100–104 are the only state;
+ * there are no fixed holder constants.
+ */
+export declare function buildOwnerPoolScript(): string;
+export declare function buildOwnerPoolState(state: OwnerPoolState): StateValue[];
+export declare function ownerPoolAddress(): string;
+export interface OwnerPoolCoin {
+    coinId: string;
+    address: string;
+    amount: bigint;
+    tokenId: string;
+    scriptHex?: string;
+    mmrEntry?: bigint;
+}
+export interface OwnerTransferParams {
+    /** The coin being transferred (input). */
+    coin: OwnerPoolCoin;
+    /** The previously committed state (must match the input coin's state). */
+    from: OwnerPoolState;
+    /** The new owner. `epoch` must be greater than `from.epoch`. */
+    to: OwnerPoolState;
+}
+/**
+ * Build the transfer transaction: same script address, same amount/token,
+ * new owner state and a higher epoch.
+ */
+export declare function buildOwnerTransferDraft(params: OwnerTransferParams): OmniaTxDraft;
+export interface OwnerExitParams {
+    coin: OwnerPoolCoin;
+    state: OwnerPoolState;
+}
+/** Build the unilateral exit: full amount to the committed owner address. */
+export declare function buildOwnerExitDraft(params: OwnerExitParams): OmniaTxDraft;
+import type { ChainStateProvider } from '@totemsdk/chain-provider';
+export interface OwnerPoolTxDeps {
+    /** Sign the transaction digest with the previous (transfer) or current (exit) owner key. */
+    signDigest: (digest: Uint8Array) => Promise<Uint8Array>;
+    coinProofs?: Uint8Array[];
+    scriptProofs?: Uint8Array[];
+    chainProvider?: ChainStateProvider;
+    mine?: (txBody: Uint8Array, difficulty: Uint8Array) => Promise<{
+        minedHeaderBytes: Uint8Array;
+        txpowId: Uint8Array;
+    }>;
+}
+export interface OwnerPoolTxResult {
+    kind: 'owner-transfer' | 'owner-exit';
+    txHex: string;
+    digest: string;
+    witnessHex: string;
+    txpowId?: string;
+    /** The state committed by the new pool output (transfer) or spent state (exit). */
+    state: OwnerPoolState;
+}
+/** Sign and assemble the owner-rotation transfer transaction. */
+export declare function buildOwnerTransferTransaction(params: OwnerTransferParams, deps: OwnerPoolTxDeps): Promise<OwnerPoolTxResult>;
+/** Sign and assemble the unilateral owner exit transaction. */
+export declare function buildOwnerExitTransaction(params: OwnerExitParams, deps: OwnerPoolTxDeps): Promise<OwnerPoolTxResult>;

package/dist/cjs/owner-pool.js

@@ -0,0 +1,194 @@
+"use strict";
+/**
+ * V1 transferable owner-pool covenant.
+ *
+ * A single-owner claim coin whose **current owner is committed in state**, not
+ * in the script. The owner can:
+ *
+ *   - transfer the whole coin by signing a state update that recreates it at
+ *     the same address/amount with a new owner (epoch increments); or
+ *   - exit after `exitBlock` to the committed owner address, with no operator
+ *     signature or liveness.
+ *
+ * The script authenticates the **previous** committed owner
+ * (`SIGNEDBY(PREVSTATE(103))`), so a spender cannot substitute their own key.
+ * `PREVSTATE(104)` is the committed payout address. This is the V1 recovery
+ * path: a recipient holds a coin they can spend unilaterally.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OWNER_POOL_ADDR_PORT = exports.OWNER_POOL_PK_PORT = exports.OWNER_POOL_EXIT_BLOCK_PORT = exports.OWNER_POOL_EPOCH_PORT = exports.OWNER_POOL_ROOT_PORT = void 0;
+exports.ownerAddressFor = ownerAddressFor;
+exports.buildOwnerPoolScript = buildOwnerPoolScript;
+exports.buildOwnerPoolState = buildOwnerPoolState;
+exports.ownerPoolAddress = ownerPoolAddress;
+exports.buildOwnerTransferDraft = buildOwnerTransferDraft;
+exports.buildOwnerExitDraft = buildOwnerExitDraft;
+exports.buildOwnerTransferTransaction = buildOwnerTransferTransaction;
+exports.buildOwnerExitTransaction = buildOwnerExitTransaction;
+const core_1 = require("@totemsdk/core");
+exports.OWNER_POOL_ROOT_PORT = 100;
+exports.OWNER_POOL_EPOCH_PORT = 101;
+exports.OWNER_POOL_EXIT_BLOCK_PORT = 102;
+exports.OWNER_POOL_PK_PORT = 103;
+exports.OWNER_POOL_ADDR_PORT = 104;
+/** Derive the committed payout address from an owner public-key digest. */
+function ownerAddressFor(ownerPk) {
+    return (0, core_1.wotsAddressData)(ownerPk);
+}
+/**
+ * The transferable owner-pool script. State ports 100–104 are the only state;
+ * there are no fixed holder constants.
+ */
+function buildOwnerPoolScript() {
+    return (0, core_1.toNodeScript)([
+        // Unilateral exit: only the previously committed owner, only after the
+        // committed block, and only to the committed owner address.
+        'IF @BLOCK GT PREVSTATE(102) THEN',
+        '  ASSERT SIGNEDBY(PREVSTATE(103))',
+        '  ASSERT VERIFYOUT(0 PREVSTATE(104) @AMOUNT @TOKENID FALSE)',
+        '  RETURN TRUE',
+        'ENDIF',
+        // Transfer: the previous owner authorizes a new owner. Root and exit block
+        // are immutable; the coin stays at the same address with the same amount.
+        'ASSERT SIGNEDBY(PREVSTATE(103))',
+        'ASSERT STATE(101) GT PREVSTATE(101)',
+        'ASSERT STATE(100) EQ PREVSTATE(100)',
+        'ASSERT STATE(102) EQ PREVSTATE(102)',
+        'ASSERT STATE(103) NEQ PREVSTATE(103)',
+        'ASSERT STATE(103) NEQ 0x00',
+        'ASSERT STATE(104) NEQ 0x00',
+        'ASSERT VERIFYOUT(0 @ADDRESS @AMOUNT @TOKENID TRUE)',
+        'RETURN TRUE',
+    ].join('\n'));
+}
+function buildOwnerPoolState(state) {
+    if (!Number.isInteger(state.exitBlock) || state.exitBlock < 0) {
+        throw new Error(`owner pool: invalid exitBlock ${String(state.exitBlock)}`);
+    }
+    if (!/^0x[0-9a-fA-F]{64}$/.test(state.ownerPk)) {
+        throw new Error('owner pool: ownerPk must be a 0x-prefixed 32-byte hex digest');
+    }
+    if (!state.ownerAddr)
+        throw new Error('owner pool: ownerAddr is required');
+    return [
+        { port: exports.OWNER_POOL_ROOT_PORT, value: state.root, type: 'string' },
+        { port: exports.OWNER_POOL_EPOCH_PORT, value: BigInt(state.epoch), type: 'number' },
+        { port: exports.OWNER_POOL_EXIT_BLOCK_PORT, value: BigInt(state.exitBlock), type: 'number' },
+        { port: exports.OWNER_POOL_PK_PORT, value: state.ownerPk, type: 'string' },
+        { port: exports.OWNER_POOL_ADDR_PORT, value: state.ownerAddr, type: 'string' },
+    ];
+}
+function ownerPoolAddress() {
+    return (0, core_1.computeScriptAddress)(buildOwnerPoolScript());
+}
+/**
+ * Build the transfer transaction: same script address, same amount/token,
+ * new owner state and a higher epoch.
+ */
+function buildOwnerTransferDraft(params) {
+    if (params.to.epoch <= params.from.epoch) {
+        throw new Error('owner transfer: new epoch must be greater than the previous epoch');
+    }
+    if (params.to.exitBlock !== params.from.exitBlock) {
+        throw new Error('owner transfer: exitBlock is immutable');
+    }
+    if (params.to.ownerAddr !== ownerAddressFor(params.to.ownerPk)) {
+        throw new Error('owner transfer: ownerAddr must be derived from ownerPk');
+    }
+    return {
+        type: 'settlement',
+        inputs: [{
+                coinId: params.coin.coinId,
+                address: params.coin.address,
+                amount: params.coin.amount,
+                tokenId: params.coin.tokenId,
+                scriptHex: params.coin.scriptHex ?? buildOwnerPoolScript(),
+                ...(params.coin.mmrEntry !== undefined ? { mmrEntry: params.coin.mmrEntry } : {}),
+            }],
+        outputs: [{
+                address: params.coin.address,
+                amount: params.coin.amount,
+                tokenId: params.coin.tokenId,
+                storeState: true,
+                stateVariables: buildOwnerPoolState(params.to),
+            }],
+        storeState: true,
+        stateVariables: buildOwnerPoolState(params.to),
+    };
+}
+/** Build the unilateral exit: full amount to the committed owner address. */
+function buildOwnerExitDraft(params) {
+    if (params.state.ownerAddr !== ownerAddressFor(params.state.ownerPk)) {
+        throw new Error('owner exit: ownerAddr must be derived from ownerPk');
+    }
+    return {
+        type: 'settlement',
+        inputs: [{
+                coinId: params.coin.coinId,
+                address: params.coin.address,
+                amount: params.coin.amount,
+                tokenId: params.coin.tokenId,
+                scriptHex: params.coin.scriptHex ?? buildOwnerPoolScript(),
+                ...(params.coin.mmrEntry !== undefined ? { mmrEntry: params.coin.mmrEntry } : {}),
+            }],
+        outputs: [{
+                address: params.state.ownerAddr,
+                amount: params.coin.amount,
+                tokenId: params.coin.tokenId,
+                storeState: false,
+                stateVariables: [],
+            }],
+        storeState: false,
+        stateVariables: [],
+    };
+}
+// ── Signed transaction assembly ───────────────────────────────────────────────
+const omnia_1 = require("@totemsdk/omnia");
+const core_2 = require("@totemsdk/core");
+const txpow_1 = require("@totemsdk/txpow");
+async function assembleOwnerPoolTx(draft, kind, state, deps) {
+    const digest = (0, omnia_1.computeOmniaTxDigest)(draft);
+    const signature = await deps.signDigest(digest);
+    const witness = (0, omnia_1.serializeOmniaWitness)({
+        signatures: [signature],
+        coinProofs: deps.coinProofs ?? [],
+        scriptProofs: deps.scriptProofs ?? [],
+    });
+    const result = {
+        kind,
+        txHex: (0, omnia_1.serializeTxDraft)(draft),
+        digest: Buffer.from(digest).toString('hex'),
+        witnessHex: Buffer.from(witness).toString('hex'),
+        state,
+    };
+    if (deps.chainProvider) {
+        const draftBytes = (0, omnia_1.omniaDraftToMinimaBytes)(draft);
+        if (typeof deps.chainProvider.submitTransaction === 'function') {
+            const submitted = await deps.chainProvider.submitTransaction(draftBytes, witness);
+            if (submitted?.success === false) {
+                throw new Error(`owner-pool submit failed: ${submitted.message ?? 'unknown error'}`);
+            }
+            result.txpowId = submitted?.txpowid;
+        }
+        else {
+            const mine = deps.mine ?? ((txBody, difficulty) => (0, txpow_1.mineTxPoW)(txBody, difficulty));
+            const txBody = (0, txpow_1.serializeTxBody)(draftBytes, witness);
+            const mined = await mine(txBody, txpow_1.TX_POW_MIN_DIFFICULTY);
+            const fullTxPoW = (0, core_2.concatBytes)((0, core_2.concatBytes)(mined.minedHeaderBytes, new Uint8Array([0x01])), txBody);
+            const broadcast = await deps.chainProvider.broadcastTxPoW(Buffer.from(fullTxPoW).toString('hex'));
+            if (broadcast?.success === false) {
+                throw new Error(`owner-pool broadcast failed: ${broadcast.message ?? 'unknown error'}`);
+            }
+            result.txpowId = broadcast?.txpowid ?? Buffer.from(mined.txpowId).toString('hex');
+        }
+    }
+    return result;
+}
+/** Sign and assemble the owner-rotation transfer transaction. */
+async function buildOwnerTransferTransaction(params, deps) {
+    return assembleOwnerPoolTx(buildOwnerTransferDraft(params), 'owner-transfer', params.to, deps);
+}
+/** Sign and assemble the unilateral owner exit transaction. */
+async function buildOwnerExitTransaction(params, deps) {
+    return assembleOwnerPoolTx(buildOwnerExitDraft(params), 'owner-exit', params.state, deps);
+}

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export * from './commitment.js';
 export * from './operator.js';
 export * from './receipt.js';
 export * from './pool-script.js';
+export * from './owner-pool.js';
 export * from './anchor.js';
 export * from './exit-tx.js';
 export * from './pool.js';

package/dist/index.js

@@ -5,6 +5,7 @@ export * from './commitment.js';
 export * from './operator.js';
 export * from './receipt.js';
 export * from './pool-script.js';
+export * from './owner-pool.js';
 export * from './anchor.js';
 export * from './exit-tx.js';
 export * from './pool.js';

package/dist/owner-pool.d.ts

@@ -0,0 +1,95 @@
+/**
+ * V1 transferable owner-pool covenant.
+ *
+ * A single-owner claim coin whose **current owner is committed in state**, not
+ * in the script. The owner can:
+ *
+ *   - transfer the whole coin by signing a state update that recreates it at
+ *     the same address/amount with a new owner (epoch increments); or
+ *   - exit after `exitBlock` to the committed owner address, with no operator
+ *     signature or liveness.
+ *
+ * The script authenticates the **previous** committed owner
+ * (`SIGNEDBY(PREVSTATE(103))`), so a spender cannot substitute their own key.
+ * `PREVSTATE(104)` is the committed payout address. This is the V1 recovery
+ * path: a recipient holds a coin they can spend unilaterally.
+ */
+import type { OmniaTxDraft, StateValue } from '@totemsdk/omnia';
+export declare const OWNER_POOL_ROOT_PORT = 100;
+export declare const OWNER_POOL_EPOCH_PORT = 101;
+export declare const OWNER_POOL_EXIT_BLOCK_PORT = 102;
+export declare const OWNER_POOL_PK_PORT = 103;
+export declare const OWNER_POOL_ADDR_PORT = 104;
+export interface OwnerPoolState {
+    /** Batch/root commitment (opaque to this covenant; owner cannot change it). */
+    root: string;
+    /** Monotonic state epoch; every transfer increments it. */
+    epoch: number;
+    /** Absolute block after which the committed owner may exit unilaterally. */
+    exitBlock: number;
+    /** Current owner public-key digest (32-byte hex, `0x`-prefixed). */
+    ownerPk: string;
+    /** Current owner payout address (derived from `ownerPk` by the transfer builder). */
+    ownerAddr: string;
+}
+/** Derive the committed payout address from an owner public-key digest. */
+export declare function ownerAddressFor(ownerPk: string): string;
+/**
+ * The transferable owner-pool script. State ports 100–104 are the only state;
+ * there are no fixed holder constants.
+ */
+export declare function buildOwnerPoolScript(): string;
+export declare function buildOwnerPoolState(state: OwnerPoolState): StateValue[];
+export declare function ownerPoolAddress(): string;
+export interface OwnerPoolCoin {
+    coinId: string;
+    address: string;
+    amount: bigint;
+    tokenId: string;
+    scriptHex?: string;
+    mmrEntry?: bigint;
+}
+export interface OwnerTransferParams {
+    /** The coin being transferred (input). */
+    coin: OwnerPoolCoin;
+    /** The previously committed state (must match the input coin's state). */
+    from: OwnerPoolState;
+    /** The new owner. `epoch` must be greater than `from.epoch`. */
+    to: OwnerPoolState;
+}
+/**
+ * Build the transfer transaction: same script address, same amount/token,
+ * new owner state and a higher epoch.
+ */
+export declare function buildOwnerTransferDraft(params: OwnerTransferParams): OmniaTxDraft;
+export interface OwnerExitParams {
+    coin: OwnerPoolCoin;
+    state: OwnerPoolState;
+}
+/** Build the unilateral exit: full amount to the committed owner address. */
+export declare function buildOwnerExitDraft(params: OwnerExitParams): OmniaTxDraft;
+import type { ChainStateProvider } from '@totemsdk/chain-provider';
+export interface OwnerPoolTxDeps {
+    /** Sign the transaction digest with the previous (transfer) or current (exit) owner key. */
+    signDigest: (digest: Uint8Array) => Promise<Uint8Array>;
+    coinProofs?: Uint8Array[];
+    scriptProofs?: Uint8Array[];
+    chainProvider?: ChainStateProvider;
+    mine?: (txBody: Uint8Array, difficulty: Uint8Array) => Promise<{
+        minedHeaderBytes: Uint8Array;
+        txpowId: Uint8Array;
+    }>;
+}
+export interface OwnerPoolTxResult {
+    kind: 'owner-transfer' | 'owner-exit';
+    txHex: string;
+    digest: string;
+    witnessHex: string;
+    txpowId?: string;
+    /** The state committed by the new pool output (transfer) or spent state (exit). */
+    state: OwnerPoolState;
+}
+/** Sign and assemble the owner-rotation transfer transaction. */
+export declare function buildOwnerTransferTransaction(params: OwnerTransferParams, deps: OwnerPoolTxDeps): Promise<OwnerPoolTxResult>;
+/** Sign and assemble the unilateral owner exit transaction. */
+export declare function buildOwnerExitTransaction(params: OwnerExitParams, deps: OwnerPoolTxDeps): Promise<OwnerPoolTxResult>;

package/dist/owner-pool.js

@@ -0,0 +1,183 @@
+/**
+ * V1 transferable owner-pool covenant.
+ *
+ * A single-owner claim coin whose **current owner is committed in state**, not
+ * in the script. The owner can:
+ *
+ *   - transfer the whole coin by signing a state update that recreates it at
+ *     the same address/amount with a new owner (epoch increments); or
+ *   - exit after `exitBlock` to the committed owner address, with no operator
+ *     signature or liveness.
+ *
+ * The script authenticates the **previous** committed owner
+ * (`SIGNEDBY(PREVSTATE(103))`), so a spender cannot substitute their own key.
+ * `PREVSTATE(104)` is the committed payout address. This is the V1 recovery
+ * path: a recipient holds a coin they can spend unilaterally.
+ */
+import { computeScriptAddress, toNodeScript, wotsAddressData } from '@totemsdk/core';
+export const OWNER_POOL_ROOT_PORT = 100;
+export const OWNER_POOL_EPOCH_PORT = 101;
+export const OWNER_POOL_EXIT_BLOCK_PORT = 102;
+export const OWNER_POOL_PK_PORT = 103;
+export const OWNER_POOL_ADDR_PORT = 104;
+/** Derive the committed payout address from an owner public-key digest. */
+export function ownerAddressFor(ownerPk) {
+    return wotsAddressData(ownerPk);
+}
+/**
+ * The transferable owner-pool script. State ports 100–104 are the only state;
+ * there are no fixed holder constants.
+ */
+export function buildOwnerPoolScript() {
+    return toNodeScript([
+        // Unilateral exit: only the previously committed owner, only after the
+        // committed block, and only to the committed owner address.
+        'IF @BLOCK GT PREVSTATE(102) THEN',
+        '  ASSERT SIGNEDBY(PREVSTATE(103))',
+        '  ASSERT VERIFYOUT(0 PREVSTATE(104) @AMOUNT @TOKENID FALSE)',
+        '  RETURN TRUE',
+        'ENDIF',
+        // Transfer: the previous owner authorizes a new owner. Root and exit block
+        // are immutable; the coin stays at the same address with the same amount.
+        'ASSERT SIGNEDBY(PREVSTATE(103))',
+        'ASSERT STATE(101) GT PREVSTATE(101)',
+        'ASSERT STATE(100) EQ PREVSTATE(100)',
+        'ASSERT STATE(102) EQ PREVSTATE(102)',
+        'ASSERT STATE(103) NEQ PREVSTATE(103)',
+        'ASSERT STATE(103) NEQ 0x00',
+        'ASSERT STATE(104) NEQ 0x00',
+        'ASSERT VERIFYOUT(0 @ADDRESS @AMOUNT @TOKENID TRUE)',
+        'RETURN TRUE',
+    ].join('\n'));
+}
+export function buildOwnerPoolState(state) {
+    if (!Number.isInteger(state.exitBlock) || state.exitBlock < 0) {
+        throw new Error(`owner pool: invalid exitBlock ${String(state.exitBlock)}`);
+    }
+    if (!/^0x[0-9a-fA-F]{64}$/.test(state.ownerPk)) {
+        throw new Error('owner pool: ownerPk must be a 0x-prefixed 32-byte hex digest');
+    }
+    if (!state.ownerAddr)
+        throw new Error('owner pool: ownerAddr is required');
+    return [
+        { port: OWNER_POOL_ROOT_PORT, value: state.root, type: 'string' },
+        { port: OWNER_POOL_EPOCH_PORT, value: BigInt(state.epoch), type: 'number' },
+        { port: OWNER_POOL_EXIT_BLOCK_PORT, value: BigInt(state.exitBlock), type: 'number' },
+        { port: OWNER_POOL_PK_PORT, value: state.ownerPk, type: 'string' },
+        { port: OWNER_POOL_ADDR_PORT, value: state.ownerAddr, type: 'string' },
+    ];
+}
+export function ownerPoolAddress() {
+    return computeScriptAddress(buildOwnerPoolScript());
+}
+/**
+ * Build the transfer transaction: same script address, same amount/token,
+ * new owner state and a higher epoch.
+ */
+export function buildOwnerTransferDraft(params) {
+    if (params.to.epoch <= params.from.epoch) {
+        throw new Error('owner transfer: new epoch must be greater than the previous epoch');
+    }
+    if (params.to.exitBlock !== params.from.exitBlock) {
+        throw new Error('owner transfer: exitBlock is immutable');
+    }
+    if (params.to.ownerAddr !== ownerAddressFor(params.to.ownerPk)) {
+        throw new Error('owner transfer: ownerAddr must be derived from ownerPk');
+    }
+    return {
+        type: 'settlement',
+        inputs: [{
+                coinId: params.coin.coinId,
+                address: params.coin.address,
+                amount: params.coin.amount,
+                tokenId: params.coin.tokenId,
+                scriptHex: params.coin.scriptHex ?? buildOwnerPoolScript(),
+                ...(params.coin.mmrEntry !== undefined ? { mmrEntry: params.coin.mmrEntry } : {}),
+            }],
+        outputs: [{
+                address: params.coin.address,
+                amount: params.coin.amount,
+                tokenId: params.coin.tokenId,
+                storeState: true,
+                stateVariables: buildOwnerPoolState(params.to),
+            }],
+        storeState: true,
+        stateVariables: buildOwnerPoolState(params.to),
+    };
+}
+/** Build the unilateral exit: full amount to the committed owner address. */
+export function buildOwnerExitDraft(params) {
+    if (params.state.ownerAddr !== ownerAddressFor(params.state.ownerPk)) {
+        throw new Error('owner exit: ownerAddr must be derived from ownerPk');
+    }
+    return {
+        type: 'settlement',
+        inputs: [{
+                coinId: params.coin.coinId,
+                address: params.coin.address,
+                amount: params.coin.amount,
+                tokenId: params.coin.tokenId,
+                scriptHex: params.coin.scriptHex ?? buildOwnerPoolScript(),
+                ...(params.coin.mmrEntry !== undefined ? { mmrEntry: params.coin.mmrEntry } : {}),
+            }],
+        outputs: [{
+                address: params.state.ownerAddr,
+                amount: params.coin.amount,
+                tokenId: params.coin.tokenId,
+                storeState: false,
+                stateVariables: [],
+            }],
+        storeState: false,
+        stateVariables: [],
+    };
+}
+// ── Signed transaction assembly ───────────────────────────────────────────────
+import { computeOmniaTxDigest, omniaDraftToMinimaBytes, serializeOmniaWitness, serializeTxDraft, } from '@totemsdk/omnia';
+import { concatBytes } from '@totemsdk/core';
+import { serializeTxBody, mineTxPoW, TX_POW_MIN_DIFFICULTY } from '@totemsdk/txpow';
+async function assembleOwnerPoolTx(draft, kind, state, deps) {
+    const digest = computeOmniaTxDigest(draft);
+    const signature = await deps.signDigest(digest);
+    const witness = serializeOmniaWitness({
+        signatures: [signature],
+        coinProofs: deps.coinProofs ?? [],
+        scriptProofs: deps.scriptProofs ?? [],
+    });
+    const result = {
+        kind,
+        txHex: serializeTxDraft(draft),
+        digest: Buffer.from(digest).toString('hex'),
+        witnessHex: Buffer.from(witness).toString('hex'),
+        state,
+    };
+    if (deps.chainProvider) {
+        const draftBytes = omniaDraftToMinimaBytes(draft);
+        if (typeof deps.chainProvider.submitTransaction === 'function') {
+            const submitted = await deps.chainProvider.submitTransaction(draftBytes, witness);
+            if (submitted?.success === false) {
+                throw new Error(`owner-pool submit failed: ${submitted.message ?? 'unknown error'}`);
+            }
+            result.txpowId = submitted?.txpowid;
+        }
+        else {
+            const mine = deps.mine ?? ((txBody, difficulty) => mineTxPoW(txBody, difficulty));
+            const txBody = serializeTxBody(draftBytes, witness);
+            const mined = await mine(txBody, TX_POW_MIN_DIFFICULTY);
+            const fullTxPoW = concatBytes(concatBytes(mined.minedHeaderBytes, new Uint8Array([0x01])), txBody);
+            const broadcast = await deps.chainProvider.broadcastTxPoW(Buffer.from(fullTxPoW).toString('hex'));
+            if (broadcast?.success === false) {
+                throw new Error(`owner-pool broadcast failed: ${broadcast.message ?? 'unknown error'}`);
+            }
+            result.txpowId = broadcast?.txpowid ?? Buffer.from(mined.txpowId).toString('hex');
+        }
+    }
+    return result;
+}
+/** Sign and assemble the owner-rotation transfer transaction. */
+export async function buildOwnerTransferTransaction(params, deps) {
+    return assembleOwnerPoolTx(buildOwnerTransferDraft(params), 'owner-transfer', params.to, deps);
+}
+/** Sign and assemble the unilateral owner exit transaction. */
+export async function buildOwnerExitTransaction(params, deps) {
+    return assembleOwnerPoolTx(buildOwnerExitDraft(params), 'owner-exit', params.state, deps);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/omnia-vtxo",
-  "version": "0.6.2",
+  "version": "0.7.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 @@
     "NOTICE"
   ],
   "dependencies": {
+    "@totemsdk/chain-provider": "^0.3.0",
     "@totemsdk/core": "^1.4.0",
+    "@totemsdk/txpow": "^1.1.0",
     "@totemsdk/omnia": "^2.3.2",
     "@totemsdk/storage": "^0.2.1",
-    "@totemsdk/txpow": "^1.1.0",
-    "@totemsdk/chain-provider": "^0.3.0",
     "@totemsdk/wots-lease": "^1.0.1"
   },
   "devDependencies": {
@@ -37,7 +37,8 @@
     "@types/node": "^20.0.0",
     "jest": "^30.4.2",
     "ts-jest": "^29.0.0",
-    "typescript": "^7.0.2"
+    "typescript": "^7.0.2",
+    "@totemsdk/kissvm": "^1.3.0"
   },
   "engines": {
     "node": ">=18.0.0"