@totemsdk/core 1.2.6 → 1.2.8

package/dist/cjs/scripts/contract-helpers.d.ts

@@ -0,0 +1,252 @@
+/**
+ * Contract Helpers
+ *
+ * Provides high-level helpers for building specific contract types:
+ * - Timelock contracts
+ * - HTLC (Hashed Timelock Contracts)
+ * - MAST (Merkelized Abstract Syntax Trees)
+ * - Exchange contracts
+ * - Vault/covenant contracts
+ * - Flash/slow cash
+ * - Stateful game contracts
+ *
+ * Each helper validates inputs and builds the appropriate ScriptDescriptor
+ * for use with the EnhancedTransactionBuilder.
+ */
+import type { ScriptDescriptor, StateValue } from './types.js';
+/**
+ * Timelock Helper
+ *
+ * Creates timelocked scripts that can only be spent after a certain block.
+ */
+export declare class TimelockHelper {
+    /**
+     * Create a timelock script that unlocks at a specific block.
+     */
+    static createBlockTimelock(publicKey: string, unlockBlock: bigint): {
+        script: string;
+        address: string;
+    };
+    /**
+     * Create a timelock script based on coin age.
+     */
+    static createCoinageTimelock(publicKey: string, minCoinAge: bigint): {
+        script: string;
+        address: string;
+    };
+    /**
+     * Check if a timelock is satisfied given current block.
+     */
+    static isUnlocked(unlockBlock: bigint, currentBlock: bigint): boolean;
+    /**
+     * Build ScriptDescriptor for a timelock spend.
+     */
+    static buildDescriptor(address: string, publicKey: string, unlockBlock: bigint): ScriptDescriptor;
+}
+/**
+ * HTLC Helper
+ *
+ * Creates Hashed Timelock Contracts for atomic swaps and lightning-style payments.
+ */
+export declare class HTLCHelper {
+    /**
+     * Generate a random preimage and its hash.
+     */
+    static generateSecret(): {
+        preimage: string;
+        hash: string;
+    };
+    /**
+     * Hash a preimage using SHA3 (default) or SHA2.
+     */
+    static hashPreimage(preimage: string, algorithm?: 'sha3' | 'sha2'): string;
+    /**
+     * Verify a preimage matches a hash.
+     */
+    static verifyPreimage(preimage: string, expectedHash: string, algorithm?: 'sha3' | 'sha2'): boolean;
+    /**
+     * Create an HTLC script.
+     *
+     * The script allows:
+     * - Recipient to claim with preimage before timeout
+     * - Sender to refund after timeout
+     */
+    static createHTLC(senderPublicKey: string, recipientPublicKey: string, hashLock: string, timeoutBlock: bigint, algorithm?: 'sha3' | 'sha2'): {
+        script: string;
+        address: string;
+    };
+    /**
+     * Build ScriptDescriptor to claim HTLC with preimage.
+     */
+    static buildClaimDescriptor(address: string, senderPublicKey: string, recipientPublicKey: string, hashLock: string, timeoutBlock: bigint, preimage: string): ScriptDescriptor;
+    /**
+     * Build ScriptDescriptor to refund HTLC after timeout.
+     */
+    static buildRefundDescriptor(address: string, senderPublicKey: string, recipientPublicKey: string, hashLock: string, timeoutBlock: bigint): ScriptDescriptor;
+}
+/**
+ * MAST Helper
+ *
+ * Creates Merkelized Abstract Syntax Tree contracts for privacy and scalability.
+ */
+export declare class MASTHelper {
+    /**
+     * Compute hash of a script for MAST leaf.
+     */
+    static hashScript(script: string): string;
+    /**
+     * Build a simple MAST tree from multiple scripts.
+     * Returns the root hash and proofs for each script.
+     *
+     * For a proper implementation, this should call the mmrcreate RPC.
+     * This is a simplified local version for 2 scripts.
+     */
+    static buildSimpleTree(scripts: string[]): {
+        root: string;
+        proofs: Map<string, {
+            proof: string;
+            index: number;
+        }>;
+    };
+    /**
+     * Create a MAST script with the given root hash.
+     */
+    static createMASTScript(rootHash: string): {
+        script: string;
+        address: string;
+    };
+    /**
+     * Build ScriptDescriptor for spending a MAST branch.
+     */
+    static buildDescriptor(address: string, rootHash: string, branchScript: string, branchProof: string, wotsPublicKey?: string): ScriptDescriptor;
+}
+/**
+ * Exchange Contract Helper
+ *
+ * Creates DEX-style exchange contracts using VERIFYOUT.
+ */
+export declare class ExchangeHelper {
+    /**
+     * Create an exchange offer script.
+     *
+     * Owner can cancel, or anyone can take the offer by providing
+     * the specified output.
+     */
+    static createOffer(ownerPublicKey: string, desiredAddress: string, desiredAmount: string, desiredTokenId: string): {
+        script: string;
+        address: string;
+    };
+    /**
+     * Build state variables for an exchange offer.
+     */
+    static buildOfferState(ownerPublicKey: string, desiredAddress: string, desiredAmount: string, desiredTokenId: string): StateValue[];
+    /**
+     * Build ScriptDescriptor for taking an exchange offer.
+     */
+    static buildTakeOfferDescriptor(address: string, ownerPublicKey: string, desiredAddress: string, desiredAmount: string, desiredTokenId: string): ScriptDescriptor;
+    /**
+     * Validate VERIFYOUT for an exchange transaction.
+     */
+    static validateExchange(outputs: Array<{
+        address: string;
+        amount: string;
+        tokenId: string;
+    }>, expectedAddress: string, expectedAmount: string, expectedTokenId: string, inputIndex: number): {
+        valid: boolean;
+        error?: string;
+    };
+}
+/**
+ * Vault Helper
+ *
+ * Creates vault/covenant contracts with safe house enforcement.
+ */
+export declare class VaultHelper {
+    /**
+     * Generate safe house script from vault parameters.
+     */
+    static generateSafeHouseScript(coldKey: string, hotKey: string, cooldownBlocks?: bigint): string;
+    /**
+     * Create a vault script.
+     */
+    static createVault(coldKey: string, hotKey: string, cooldownBlocks?: bigint): {
+        vaultScript: string;
+        vaultAddress: string;
+        safeHouseScript: string;
+        safeHouseAddress: string;
+    };
+    /**
+     * Build state for vault withdrawal.
+     */
+    static buildWithdrawalState(amount: string, recipientAddress: string): StateValue[];
+}
+/**
+ * Flash Cash Helper
+ *
+ * Creates flash loan contracts for single-transaction borrowing.
+ */
+export declare class FlashCashHelper {
+    /**
+     * Create a flash cash contract.
+     */
+    static createFlashCash(ownerPublicKey: string, interestMultiplier?: string): {
+        script: string;
+        address: string;
+    };
+    /**
+     * Calculate return amount with interest.
+     */
+    static calculateReturn(borrowAmount: bigint, interestMultiplier: number): bigint;
+    /**
+     * Build ScriptDescriptor for borrowing flash cash.
+     */
+    static buildBorrowDescriptor(address: string, ownerPublicKey: string, interestMultiplier?: string): ScriptDescriptor;
+}
+/**
+ * Slow Cash Helper
+ *
+ * Creates rate-limited withdrawal contracts.
+ */
+export declare class SlowCashHelper {
+    /**
+     * Create a slow cash contract.
+     */
+    static createSlowCash(ownerPublicKey: string, withdrawalPercent?: string, cooldownBlocks?: bigint): {
+        script: string;
+        address: string;
+    };
+    /**
+     * Calculate withdrawal amount.
+     */
+    static calculateWithdrawal(currentAmount: bigint, withdrawalPercent: number): {
+        withdrawal: bigint;
+        remaining: bigint;
+    };
+    /**
+     * Check if withdrawal is allowed based on coin age.
+     */
+    static canWithdraw(coinAge: bigint, cooldownBlocks: bigint): boolean;
+    /**
+     * Build ScriptDescriptor for slow cash withdrawal.
+     */
+    static buildWithdrawalDescriptor(address: string, ownerPublicKey: string, withdrawalPercent?: string, cooldownBlocks?: bigint): ScriptDescriptor;
+}
+/**
+ * Stateful Game Helper
+ *
+ * Creates multi-round stateful contracts (like coin flip).
+ */
+export declare class StatefulGameHelper {
+    /**
+     * Create a round increment assertion.
+     */
+    static createRoundCheck(): string;
+    /**
+     * Build state for next round.
+     */
+    static buildNextRoundState(currentRound: number, preservedPorts: number[], newStates: StateValue[]): StateValue[];
+    /**
+     * Validate round progression.
+     */
+    static validateRound(previousRound: number, currentRound: number): boolean;
+}

package/dist/cjs/scripts/contract-helpers.js

@@ -0,0 +1,407 @@
+"use strict";
+/**
+ * Contract Helpers
+ *
+ * Provides high-level helpers for building specific contract types:
+ * - Timelock contracts
+ * - HTLC (Hashed Timelock Contracts)
+ * - MAST (Merkelized Abstract Syntax Trees)
+ * - Exchange contracts
+ * - Vault/covenant contracts
+ * - Flash/slow cash
+ * - Stateful game contracts
+ *
+ * Each helper validates inputs and builds the appropriate ScriptDescriptor
+ * for use with the EnhancedTransactionBuilder.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatefulGameHelper = exports.SlowCashHelper = exports.FlashCashHelper = exports.VaultHelper = exports.ExchangeHelper = exports.MASTHelper = exports.HTLCHelper = exports.TimelockHelper = void 0;
+const wasm_sync_js_1 = require("../wasm-sync.js");
+const node_crypto_1 = require("node:crypto");
+function sha256(data) {
+    return new Uint8Array((0, node_crypto_1.createHash)('sha256').update(data).digest());
+}
+const types_js_1 = require("./types.js");
+function kissHex(hex) {
+    const raw = hex.startsWith('0x') || hex.startsWith('0X') ? hex.slice(2) : hex;
+    return '0x' + raw.toUpperCase();
+}
+function hexToBytes(hex) {
+    const cleanHex = hex.startsWith('0x') ? hex.slice(2) : hex;
+    const bytes = new Uint8Array(cleanHex.length / 2);
+    for (let i = 0; i < cleanHex.length; i += 2) {
+        bytes[i / 2] = parseInt(cleanHex.slice(i, i + 2), 16);
+    }
+    return bytes;
+}
+function bytesToHex(bytes) {
+    return '0x' + Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+}
+/**
+ * Timelock Helper
+ *
+ * Creates timelocked scripts that can only be spent after a certain block.
+ */
+class TimelockHelper {
+    /**
+     * Create a timelock script that unlocks at a specific block.
+     */
+    static createBlockTimelock(publicKey, unlockBlock) {
+        const script = `RETURN SIGNEDBY(${kissHex(publicKey)}) AND @BLOCK GT ${unlockBlock}`;
+        const address = computeScriptAddress(script);
+        return { script, address };
+    }
+    /**
+     * Create a timelock script based on coin age.
+     */
+    static createCoinageTimelock(publicKey, minCoinAge) {
+        const script = `RETURN SIGNEDBY(${kissHex(publicKey)}) AND @COINAGE GT ${minCoinAge}`;
+        const address = computeScriptAddress(script);
+        return { script, address };
+    }
+    /**
+     * Check if a timelock is satisfied given current block.
+     */
+    static isUnlocked(unlockBlock, currentBlock) {
+        return currentBlock > unlockBlock;
+    }
+    /**
+     * Build ScriptDescriptor for a timelock spend.
+     */
+    static buildDescriptor(address, publicKey, unlockBlock) {
+        return (0, types_js_1.createTimelockDescriptor)(address, publicKey, unlockBlock);
+    }
+}
+exports.TimelockHelper = TimelockHelper;
+/**
+ * HTLC Helper
+ *
+ * Creates Hashed Timelock Contracts for atomic swaps and lightning-style payments.
+ */
+class HTLCHelper {
+    /**
+     * Generate a random preimage and its hash.
+     */
+    static generateSecret() {
+        const preimageBytes = (0, node_crypto_1.randomBytes)(32);
+        const preimage = bytesToHex(preimageBytes);
+        const hashBytes = (0, wasm_sync_js_1.sha3_256)(preimageBytes);
+        const hash = bytesToHex(hashBytes);
+        return { preimage, hash };
+    }
+    /**
+     * Hash a preimage using SHA3 (default) or SHA2.
+     */
+    static hashPreimage(preimage, algorithm = 'sha3') {
+        const preimageBytes = hexToBytes(preimage);
+        if (algorithm === 'sha2') {
+            const hashBytes = sha256(preimageBytes);
+            return bytesToHex(hashBytes);
+        }
+        else {
+            const hashBytes = (0, wasm_sync_js_1.sha3_256)(preimageBytes);
+            return bytesToHex(hashBytes);
+        }
+    }
+    /**
+     * Verify a preimage matches a hash.
+     */
+    static verifyPreimage(preimage, expectedHash, algorithm = 'sha3') {
+        const computedHash = this.hashPreimage(preimage, algorithm);
+        return computedHash.toLowerCase() === expectedHash.toLowerCase();
+    }
+    /**
+     * Create an HTLC script.
+     *
+     * The script allows:
+     * - Recipient to claim with preimage before timeout
+     * - Sender to refund after timeout
+     */
+    static createHTLC(senderPublicKey, recipientPublicKey, hashLock, timeoutBlock, algorithm = 'sha3') {
+        const hashFunc = algorithm === 'sha2' ? 'SHA2' : 'SHA3';
+        const script = `IF @BLOCK GT ${timeoutBlock} AND SIGNEDBY(${kissHex(senderPublicKey)}) THEN RETURN TRUE ENDIF RETURN (SIGNEDBY(${kissHex(recipientPublicKey)}) AND ${hashFunc}(STATE(1)) EQ ${kissHex(hashLock)})`;
+        const address = computeScriptAddress(script);
+        return { script, address };
+    }
+    /**
+     * Build ScriptDescriptor to claim HTLC with preimage.
+     */
+    static buildClaimDescriptor(address, senderPublicKey, recipientPublicKey, hashLock, timeoutBlock, preimage) {
+        return (0, types_js_1.createHTLCDescriptor)(address, senderPublicKey, recipientPublicKey, hashLock, timeoutBlock, false, preimage);
+    }
+    /**
+     * Build ScriptDescriptor to refund HTLC after timeout.
+     */
+    static buildRefundDescriptor(address, senderPublicKey, recipientPublicKey, hashLock, timeoutBlock) {
+        return (0, types_js_1.createHTLCDescriptor)(address, senderPublicKey, recipientPublicKey, hashLock, timeoutBlock, true);
+    }
+}
+exports.HTLCHelper = HTLCHelper;
+/**
+ * MAST Helper
+ *
+ * Creates Merkelized Abstract Syntax Tree contracts for privacy and scalability.
+ */
+class MASTHelper {
+    /**
+     * Compute hash of a script for MAST leaf.
+     */
+    static hashScript(script) {
+        const scriptBytes = new TextEncoder().encode(script.trim().toUpperCase());
+        const hashBytes = (0, wasm_sync_js_1.sha3_256)(scriptBytes);
+        return bytesToHex(hashBytes);
+    }
+    /**
+     * Build a simple MAST tree from multiple scripts.
+     * Returns the root hash and proofs for each script.
+     *
+     * For a proper implementation, this should call the mmrcreate RPC.
+     * This is a simplified local version for 2 scripts.
+     */
+    static buildSimpleTree(scripts) {
+        if (scripts.length === 0) {
+            throw new Error('MAST requires at least one script');
+        }
+        if (scripts.length === 1) {
+            const hash = this.hashScript(scripts[0]);
+            return {
+                root: hash,
+                proofs: new Map([[scripts[0], { proof: '', index: 0 }]])
+            };
+        }
+        const hashes = scripts.map(s => this.hashScript(s));
+        const proofs = new Map();
+        for (let i = 0; i < scripts.length; i++) {
+            const siblingIndex = i % 2 === 0 ? i + 1 : i - 1;
+            const siblingHash = hashes[siblingIndex] || hashes[i];
+            const isLeft = i % 2 === 1;
+            const proofHex = encodeSimpleProof(siblingHash, isLeft);
+            proofs.set(scripts[i], { proof: proofHex, index: i });
+        }
+        const combinedBytes = hexToBytes(hashes[0].slice(2) + hashes[1].slice(2));
+        const rootBytes = (0, wasm_sync_js_1.sha3_256)(combinedBytes);
+        const root = bytesToHex(rootBytes);
+        return { root, proofs };
+    }
+    /**
+     * Create a MAST script with the given root hash.
+     */
+    static createMASTScript(rootHash) {
+        const script = `MAST ${kissHex(rootHash)}`;
+        const address = computeScriptAddress(script);
+        return { script, address };
+    }
+    /**
+     * Build ScriptDescriptor for spending a MAST branch.
+     */
+    static buildDescriptor(address, rootHash, branchScript, branchProof, wotsPublicKey) {
+        return (0, types_js_1.createMASTDescriptor)(address, rootHash, branchScript, branchProof, wotsPublicKey);
+    }
+}
+exports.MASTHelper = MASTHelper;
+/**
+ * Exchange Contract Helper
+ *
+ * Creates DEX-style exchange contracts using VERIFYOUT.
+ */
+class ExchangeHelper {
+    /**
+     * Create an exchange offer script.
+     *
+     * Owner can cancel, or anyone can take the offer by providing
+     * the specified output.
+     */
+    static createOffer(ownerPublicKey, desiredAddress, desiredAmount, desiredTokenId) {
+        const script = `IF SIGNEDBY(PREVSTATE(0)) THEN RETURN TRUE ENDIF ASSERT VERIFYOUT(@INPUT PREVSTATE(1) PREVSTATE(2) PREVSTATE(3) TRUE) RETURN TRUE`;
+        const address = computeScriptAddress(script);
+        return { script, address };
+    }
+    /**
+     * Build state variables for an exchange offer.
+     */
+    static buildOfferState(ownerPublicKey, desiredAddress, desiredAmount, desiredTokenId) {
+        return [
+            { port: 0, value: ownerPublicKey, type: 'hex' },
+            { port: 1, value: desiredAddress, type: 'hex' },
+            { port: 2, value: desiredAmount, type: 'number' },
+            { port: 3, value: desiredTokenId, type: 'hex' }
+        ];
+    }
+    /**
+     * Build ScriptDescriptor for taking an exchange offer.
+     */
+    static buildTakeOfferDescriptor(address, ownerPublicKey, desiredAddress, desiredAmount, desiredTokenId) {
+        return (0, types_js_1.createExchangeDescriptor)(address, ownerPublicKey, desiredAddress, desiredAmount, desiredTokenId);
+    }
+    /**
+     * Validate VERIFYOUT for an exchange transaction.
+     */
+    static validateExchange(outputs, expectedAddress, expectedAmount, expectedTokenId, inputIndex) {
+        if (inputIndex >= outputs.length) {
+            return { valid: false, error: `Output at index ${inputIndex} does not exist` };
+        }
+        const output = outputs[inputIndex];
+        if (output.address.toLowerCase() !== expectedAddress.toLowerCase()) {
+            return { valid: false, error: 'Address mismatch' };
+        }
+        if (output.amount !== expectedAmount) {
+            return { valid: false, error: 'Amount mismatch' };
+        }
+        if (output.tokenId.toLowerCase() !== expectedTokenId.toLowerCase()) {
+            return { valid: false, error: 'TokenId mismatch' };
+        }
+        return { valid: true };
+    }
+}
+exports.ExchangeHelper = ExchangeHelper;
+/**
+ * Vault Helper
+ *
+ * Creates vault/covenant contracts with safe house enforcement.
+ */
+class VaultHelper {
+    /**
+     * Generate safe house script from vault parameters.
+     */
+    static generateSafeHouseScript(coldKey, hotKey, cooldownBlocks = 20n) {
+        return `LET pkcold = ${kissHex(coldKey)} LET pkhot = ${kissHex(hotKey)} IF SIGNEDBY(pkcold) THEN RETURN TRUE ENDIF IF SIGNEDBY(pkhot) THEN IF @COINAGE GT ${cooldownBlocks} THEN RETURN VERIFYOUT(@INPUT PREVSTATE(21) @AMOUNT @TOKENID TRUE) ENDIF ENDIF`;
+    }
+    /**
+     * Create a vault script.
+     */
+    static createVault(coldKey, hotKey, cooldownBlocks = 20n) {
+        const safeHouseScript = this.generateSafeHouseScript(coldKey, hotKey, cooldownBlocks);
+        const safeHouseAddress = computeScriptAddress(safeHouseScript);
+        const vaultScript = `LET pkcold = ${kissHex(coldKey)} LET pkhot = ${kissHex(hotKey)} IF SIGNEDBY(pkcold) THEN RETURN TRUE ENDIF LET amt = STATE(20) LET recip = STATE(21) LET safehouse = [${safeHouseScript}] ASSERT VERIFYOUT(@INPUT ADDRESS(safehouse) amt @TOKENID TRUE) LET chg = @AMOUNT - amt IF chg GT 0 THEN ASSERT VERIFYOUT(INC(@INPUT) @ADDRESS (@AMOUNT - amt) @TOKENID TRUE) ENDIF RETURN SIGNEDBY(pkhot)`;
+        const vaultAddress = computeScriptAddress(vaultScript);
+        return {
+            vaultScript,
+            vaultAddress,
+            safeHouseScript,
+            safeHouseAddress
+        };
+    }
+    /**
+     * Build state for vault withdrawal.
+     */
+    static buildWithdrawalState(amount, recipientAddress) {
+        return [
+            { port: 20, value: amount, type: 'number' },
+            { port: 21, value: recipientAddress, type: 'hex' }
+        ];
+    }
+}
+exports.VaultHelper = VaultHelper;
+/**
+ * Flash Cash Helper
+ *
+ * Creates flash loan contracts for single-transaction borrowing.
+ */
+class FlashCashHelper {
+    /**
+     * Create a flash cash contract.
+     */
+    static createFlashCash(ownerPublicKey, interestMultiplier = '1.01') {
+        const script = `IF SIGNEDBY(PREVSTATE(1)) THEN RETURN TRUE ENDIF ASSERT SAMESTATE(1 1) RETURN VERIFYOUT(@INPUT @ADDRESS @AMOUNT*${interestMultiplier} @TOKENID TRUE)`;
+        const address = computeScriptAddress(script);
+        return { script, address };
+    }
+    /**
+     * Calculate return amount with interest.
+     */
+    static calculateReturn(borrowAmount, interestMultiplier) {
+        const multiplied = Number(borrowAmount) * interestMultiplier;
+        return BigInt(Math.ceil(multiplied));
+    }
+    /**
+     * Build ScriptDescriptor for borrowing flash cash.
+     */
+    static buildBorrowDescriptor(address, ownerPublicKey, interestMultiplier = '1.01') {
+        return (0, types_js_1.createFlashCashDescriptor)(address, ownerPublicKey, interestMultiplier);
+    }
+}
+exports.FlashCashHelper = FlashCashHelper;
+/**
+ * Slow Cash Helper
+ *
+ * Creates rate-limited withdrawal contracts.
+ */
+class SlowCashHelper {
+    /**
+     * Create a slow cash contract.
+     */
+    static createSlowCash(ownerPublicKey, withdrawalPercent = '0.9', cooldownBlocks = 10000n) {
+        const script = `IF @COINAGE LT ${cooldownBlocks} THEN RETURN FALSE ENDIF ASSERT SIGNEDBY(${kissHex(ownerPublicKey)}) AND VERIFYOUT(@INPUT @ADDRESS @AMOUNT*${withdrawalPercent} @TOKENID TRUE)`;
+        const address = computeScriptAddress(script);
+        return { script, address };
+    }
+    /**
+     * Calculate withdrawal amount.
+     */
+    static calculateWithdrawal(currentAmount, withdrawalPercent) {
+        const remaining = BigInt(Math.floor(Number(currentAmount) * withdrawalPercent));
+        const withdrawal = currentAmount - remaining;
+        return { withdrawal, remaining };
+    }
+    /**
+     * Check if withdrawal is allowed based on coin age.
+     */
+    static canWithdraw(coinAge, cooldownBlocks) {
+        return coinAge >= cooldownBlocks;
+    }
+    /**
+     * Build ScriptDescriptor for slow cash withdrawal.
+     */
+    static buildWithdrawalDescriptor(address, ownerPublicKey, withdrawalPercent = '0.9', cooldownBlocks = 10000n) {
+        return (0, types_js_1.createSlowCashDescriptor)(address, ownerPublicKey, withdrawalPercent, cooldownBlocks);
+    }
+}
+exports.SlowCashHelper = SlowCashHelper;
+/**
+ * Stateful Game Helper
+ *
+ * Creates multi-round stateful contracts (like coin flip).
+ */
+class StatefulGameHelper {
+    /**
+     * Create a round increment assertion.
+     */
+    static createRoundCheck() {
+        return `LET round = STATE(0) LET prevround = PREVSTATE(0) ASSERT round EQ INC(prevround)`;
+    }
+    /**
+     * Build state for next round.
+     */
+    static buildNextRoundState(currentRound, preservedPorts, newStates) {
+        const states = [
+            { port: 0, value: BigInt(currentRound + 1), type: 'number' }
+        ];
+        for (const sv of newStates) {
+            states.push(sv);
+        }
+        return states;
+    }
+    /**
+     * Validate round progression.
+     */
+    static validateRound(previousRound, currentRound) {
+        return currentRound === previousRound + 1;
+    }
+}
+exports.StatefulGameHelper = StatefulGameHelper;
+function computeScriptAddress(script) {
+    const cleanScript = script.trim().toUpperCase();
+    const scriptBytes = new TextEncoder().encode(cleanScript);
+    const hashBytes = (0, wasm_sync_js_1.sha3_256)(scriptBytes);
+    return bytesToHex(hashBytes);
+}
+function encodeSimpleProof(siblingHash, isLeft) {
+    const parts = [];
+    parts.push(0, 0, 0, 1, 0, 1);
+    parts.push(isLeft ? 1 : 0);
+    const hashBytes = hexToBytes(siblingHash);
+    parts.push(0, 0, 0, hashBytes.length);
+    parts.push(...Array.from(hashBytes));
+    parts.push(0, 0, 0, 0, 1, 0);
+    return bytesToHex(new Uint8Array(parts));
+}