@odatano/core 0.3.1

package/srv/blockchain/transaction-building/csl-tx.js

@@ -0,0 +1,766 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSLTxBuilder = void 0;
+const cds_1 = __importDefault(require("@sap/cds"));
+const CSL = __importStar(require("@emurgo/cardano-serialization-lib-nodejs"));
+const blake2b_1 = __importDefault(require("blake2b"));
+const tx_build_helper_1 = require("../../utils/tx-build-helper");
+const const_1 = require("../../utils/const");
+const logger = cds_1.default.log('CSLTxBuilder');
+/**
+ * CSLTxBuilder - Implementation of CardanoTxBuilder using cardano-serialization-lib (CSL)
+ */
+class CSLTxBuilder {
+    name = "CslTxBuilder";
+    txBuilderConfig;
+    protocolParameters; // Store for cost models
+    cardanoClient;
+    /**
+     * Initialize the builder
+     * @param cardanoClient - The CardanoClient instance
+     * @param protocolParams - Optional protocol parameters (if not provided, fetched from backend)
+     */
+    async init(cardanoClient, protocolParams) {
+        this.protocolParameters = protocolParams ?? await cardanoClient.getProtocolParameters();
+        this.txBuilderConfig = this._createTxBuilderConfig(this.protocolParameters);
+        this.cardanoClient = cardanoClient;
+        logger.info(`Initialized with protocol parameters.`);
+    }
+    /**
+     * Build unsigned ADA transfer transaction
+     * @param req transaction build request
+     * @param ctx transaction build context
+     * @returns {Promise<TxBuildResult>} transaction build result
+     */
+    async buildUnsignedAdaTransfer(req, ctx) {
+        try {
+            // prepare addresses
+            const recipientAddress = CSL.Address.from_bech32(req.recipientAddress);
+            const changeAddress = CSL.Address.from_bech32(req.changeAddress ?? req.senderAddress);
+            // map ODATANO UTxOs -> CSL TransactionUnspentOutputs (with multi-asset support)
+            // This allows spending UTxOs that contain native assets - they will be returned in the change output
+            const cslUtxos = this._mapMultiAssetUtxosToCslUtxos(ctx.utxos);
+            // create Transaction Builder from stored config
+            const txb = CSL.TransactionBuilder.new(this.txBuilderConfig);
+            // add recipient & output (lovelace), with optional inline datum
+            const amount = CSL.BigNum.from_str(String(req.lovelaceAmount));
+            const outValue = CSL.Value.new(amount);
+            const out = CSL.TransactionOutput.new(recipientAddress, outValue);
+            if (req.outputDatum) {
+                const plutusData = CSL.PlutusData.from_json(JSON.stringify(req.outputDatum), CSL.PlutusDatumSchema.DetailedSchema);
+                out.set_plutus_data(plutusData);
+            }
+            txb.add_output(out);
+            // add inputs via coin selection + add change
+            txb.add_inputs_from(cslUtxos, CSL.CoinSelectionStrategyCIP2.LargestFirstMultiAsset);
+            txb.add_change_if_needed(changeAddress);
+            // build unsigned tx
+            const unsignedTx = txb.build_tx();
+            // Export the complete transaction (with empty witness set) for cardano-cli
+            const unsignedTxCbor = Buffer.from(unsignedTx.to_bytes()).toString("hex");
+            // hash + fee + outputs
+            const body = unsignedTx.body();
+            const bodyBytes = body.to_bytes();
+            const hash = (0, blake2b_1.default)(32).update(bodyBytes).digest('hex');
+            const txBodyHash = hash;
+            const feeLovelace = body.fee().to_str();
+            const outputs = [];
+            const txOuts = body.outputs();
+            for (let i = 0; i < txOuts.len(); i++) {
+                const o = txOuts.get(i);
+                outputs.push({
+                    address: o.address().to_bech32(),
+                    lovelace: o.amount().coin().to_str(),
+                });
+            }
+            logger.info(`Built unsigned transaction successfully.`);
+            return {
+                unsignedTxCbor,
+                txBodyHash,
+                senderAddress: req.senderAddress,
+                network: this.cardanoClient.network,
+                sizeBytes: unsignedTxCbor.length / 2, // hex to bytes
+                builderEngine: this.name,
+                feeLovelace: feeLovelace,
+                inputs: ctx.utxos.map(u => ({
+                    txHash: u.txHash,
+                    index: u.outputIndex,
+                    lovelace: (0, tx_build_helper_1.getLovelace)(u).toString(),
+                })),
+                outputs,
+                warnings: [],
+            };
+        }
+        catch (err) {
+            (0, tx_build_helper_1.mapBuilderError)(err, 'lovelace');
+        }
+    }
+    async buildUnsignedTransactionWithMetadata(req, ctx) {
+        try {
+            // prepare addresses
+            const recipientAddress = CSL.Address.from_bech32(req.recipientAddress);
+            const changeAddress = CSL.Address.from_bech32(req.changeAddress ?? req.senderAddress);
+            // map ODATANO UTxOs -> CSL TransactionUnspentOutputs (with multi-asset support)
+            // This allows spending UTxOs that contain native assets - they will be returned in the change output
+            const cslUtxos = this._mapMultiAssetUtxosToCslUtxos(ctx.utxos);
+            // create Transaction Builder from stored config
+            const txb = CSL.TransactionBuilder.new(this.txBuilderConfig);
+            // add recipient & output (lovelace)
+            const amount = CSL.BigNum.from_str(String(req.lovelaceAmount));
+            const outValue = CSL.Value.new(amount);
+            const out = CSL.TransactionOutput.new(recipientAddress, outValue);
+            txb.add_output(out);
+            // add metadata if provided
+            if (req.metadataJson) {
+                const metadata = this._mapOdatanoMetadataToCSLMetadata(req.metadataJson);
+                txb.set_metadata(metadata);
+            }
+            // add inputs via coin selection + add change
+            txb.add_inputs_from(cslUtxos, CSL.CoinSelectionStrategyCIP2.LargestFirstMultiAsset);
+            txb.add_change_if_needed(changeAddress);
+            // build unsigned tx
+            const unsignedTx = txb.build_tx();
+            // Export the complete transaction (with empty witness set) for cardano-cli
+            const unsignedTxCbor = Buffer.from(unsignedTx.to_bytes()).toString("hex");
+            // hash + fee + outputs
+            const body = unsignedTx.body();
+            const bodyBytes = body.to_bytes();
+            const hash = (0, blake2b_1.default)(32).update(bodyBytes).digest('hex');
+            const txBodyHash = hash;
+            const feeLovelace = body.fee().to_str();
+            const outputs = [];
+            const txOuts = body.outputs();
+            for (let i = 0; i < txOuts.len(); i++) {
+                const o = txOuts.get(i);
+                outputs.push({
+                    address: o.address().to_bech32(),
+                    lovelace: o.amount().coin().to_str(),
+                });
+            }
+            logger.info(`Built unsigned transaction with metadata successfully.`);
+            return {
+                unsignedTxCbor,
+                txBodyHash,
+                senderAddress: req.senderAddress,
+                network: this.cardanoClient.network,
+                sizeBytes: unsignedTxCbor.length / 2, // hex to bytes
+                builderEngine: this.name,
+                feeLovelace,
+                inputs: ctx.utxos.map(u => ({
+                    txHash: u.txHash,
+                    index: u.outputIndex,
+                    lovelace: (0, tx_build_helper_1.getLovelace)(u).toString(),
+                })),
+                outputs,
+                warnings: [],
+            };
+        }
+        catch (err) {
+            (0, tx_build_helper_1.mapBuilderError)(err, 'lovelace');
+        }
+    }
+    async buildUnsignedMultiAssetTransaction(req, ctx) {
+        if (!req.assets || req.assets.length === 0) {
+            throw new Error('[CSLTxBuilder] buildUnsignedMultiAssetTransaction requires assets to be specified');
+        }
+        try {
+            // prepare addresses
+            const recipientAddress = CSL.Address.from_bech32(req.recipientAddress);
+            const changeAddress = CSL.Address.from_bech32(req.changeAddress ?? req.senderAddress);
+            // map ODATANO UTxOs -> CSL TransactionUnspentOutputs (with multi-asset support)
+            const cslUtxos = this._mapMultiAssetUtxosToCslUtxos(ctx.utxos);
+            // create Transaction Builder from stored config
+            const txb = CSL.TransactionBuilder.new(this.txBuilderConfig);
+            // Build output value with ADA + multi-assets
+            const lovelace = CSL.BigNum.from_str(String(req.lovelaceAmount));
+            const outputValue = CSL.Value.new(lovelace);
+            // Create MultiAsset structure for native tokens
+            const multiAsset = CSL.MultiAsset.new();
+            for (const asset of req.assets) {
+                // Skip 'lovelace' unit (already handled above)
+                if (asset.unit === 'lovelace')
+                    continue;
+                const { policyId, assetName } = (0, tx_build_helper_1.parseAssetUnit)(asset.unit);
+                // Get or create Assets for this policy
+                const policyHash = CSL.ScriptHash.from_bytes(Buffer.from(policyId, 'hex'));
+                let assets = multiAsset.get(policyHash);
+                if (!assets) {
+                    assets = CSL.Assets.new();
+                }
+                // Add asset with quantity
+                const assetNameBytes = Buffer.from(assetName, 'hex');
+                const cslAssetName = CSL.AssetName.new(assetNameBytes);
+                const quantity = CSL.BigNum.from_str(asset.quantity);
+                assets.insert(cslAssetName, quantity);
+                multiAsset.insert(policyHash, assets);
+            }
+            // Set multi-asset on output value
+            outputValue.set_multiasset(multiAsset);
+            // Create output with all assets
+            const recipientOutput = CSL.TransactionOutput.new(recipientAddress, outputValue);
+            txb.add_output(recipientOutput);
+            // add inputs via coin selection + add change
+            txb.add_inputs_from(cslUtxos, CSL.CoinSelectionStrategyCIP2.LargestFirstMultiAsset);
+            txb.add_change_if_needed(changeAddress);
+            // build unsigned tx
+            const unsignedTx = txb.build_tx();
+            // Export the complete transaction (with empty witness set) for cardano-cli
+            const unsignedTxCbor = Buffer.from(unsignedTx.to_bytes()).toString("hex");
+            // hash + fee + outputs
+            const body = unsignedTx.body();
+            const bodyBytes = body.to_bytes();
+            const hash = (0, blake2b_1.default)(32).update(bodyBytes).digest('hex');
+            const txBodyHash = hash;
+            const feeLovelace = body.fee().to_str();
+            const outputs = [];
+            const txOuts = body.outputs();
+            for (let i = 0; i < txOuts.len(); i++) {
+                const o = txOuts.get(i);
+                outputs.push({
+                    address: o.address().to_bech32(),
+                    lovelace: o.amount().coin().to_str(),
+                });
+            }
+            logger.info(`Built unsigned multi-asset transaction successfully.`);
+            return {
+                unsignedTxCbor,
+                txBodyHash,
+                senderAddress: req.senderAddress,
+                network: this.cardanoClient.network,
+                sizeBytes: unsignedTxCbor.length / 2, // hex to bytes
+                builderEngine: this.name,
+                feeLovelace,
+                inputs: ctx.utxos.map(u => ({
+                    txHash: u.txHash,
+                    index: u.outputIndex,
+                    lovelace: (0, tx_build_helper_1.getLovelace)(u).toString(),
+                })),
+                outputs,
+                warnings: [],
+            };
+        }
+        catch (err) {
+            // Extract asset unit from error message if possible
+            const assetMatch = err?.message?.match(/not enough\s+([a-f0-9.]+)/i);
+            const assetUnit = assetMatch?.[1] || 'assets';
+            (0, tx_build_helper_1.mapBuilderError)(err, assetUnit);
+        }
+    }
+    async buildUnsignedMintTransaction(req, ctx) {
+        try {
+            // Determine execution units based on evaluator availability
+            let finalExUnits = {
+                mem: String(const_1.DEFAULT_EXECUTION_UNITS.mem),
+                cpu: String(const_1.DEFAULT_EXECUTION_UNITS.cpu)
+            };
+            if (ctx.evaluateTransaction) {
+                // Build first pass with high execution units for evaluation
+                logger.debug(`[CSLTxBuilder] Building evaluation pass with high execution units`);
+                const evalTx = this._buildMintTx(req, ctx, {
+                    mem: String(const_1.HIGH_EXECUTION_UNITS.mem),
+                    cpu: String(const_1.HIGH_EXECUTION_UNITS.cpu)
+                });
+                const evalTxCbor = Buffer.from(evalTx.to_bytes()).toString('hex');
+                try {
+                    // Evaluate to get exact execution units
+                    const evalResults = await ctx.evaluateTransaction(evalTxCbor);
+                    logger.debug(`[CSLTxBuilder] Evaluation results: ${JSON.stringify(evalResults)}`);
+                    if (evalResults && evalResults.length > 0) {
+                        // Use the evaluated budget (take first result for single script)
+                        const budget = evalResults[0].budget;
+                        // Add safety margin to evaluated units
+                        finalExUnits = {
+                            mem: Math.ceil(budget.memory * const_1.EXECUTION_UNIT_BUFFER).toString(),
+                            cpu: Math.ceil(budget.cpu * const_1.EXECUTION_UNIT_BUFFER).toString()
+                        };
+                        logger.info(`[CSLTxBuilder] Using evaluated execution units: mem=${finalExUnits.mem}, cpu=${finalExUnits.cpu}`);
+                    }
+                }
+                catch (evalError) {
+                    logger.warn(`[CSLTxBuilder] Evaluation failed, using default units: ${evalError.message}`);
+                    // Fall back to defaults on evaluation failure
+                }
+            }
+            else {
+                logger.debug(`[CSLTxBuilder] No evaluator available, using default execution units`);
+            }
+            // Build final transaction with determined execution units
+            const unsignedTx = this._buildMintTx(req, ctx, finalExUnits);
+            logger.debug(`[CSLTxBuilder] Transaction built successfully`);
+            // Export as CBOR hex
+            const unsignedTxCbor = Buffer.from(unsignedTx.to_bytes()).toString('hex');
+            // Extract transaction details from the transaction
+            const body = unsignedTx.body();
+            const bodyBytes = body.to_bytes();
+            const hash = (0, blake2b_1.default)(32).update(bodyBytes).digest('hex');
+            const txBodyHash = hash;
+            const feeLovelace = body.fee().to_str();
+            // Extract outputs
+            const outputs = [];
+            const txOuts = body.outputs();
+            for (let i = 0; i < txOuts.len(); i++) {
+                const o = txOuts.get(i);
+                outputs.push({
+                    address: o.address().to_bech32(),
+                    lovelace: o.amount().coin().to_str(),
+                });
+            }
+            logger.info(`[CSLTxBuilder] Built unsigned minting transaction successfully. Fee: ${feeLovelace}`);
+            return {
+                unsignedTxCbor,
+                txBodyHash,
+                senderAddress: req.senderAddress,
+                network: this.cardanoClient.network,
+                sizeBytes: unsignedTxCbor.length / 2, // hex to bytes
+                builderEngine: this.name,
+                feeLovelace,
+                inputs: ctx.utxos.map(u => ({
+                    txHash: u.txHash,
+                    index: u.outputIndex,
+                    lovelace: (0, tx_build_helper_1.getLovelace)(u).toString(),
+                })),
+                outputs,
+                warnings: [],
+            };
+        }
+        catch (error) {
+            logger.error(`[CSLTxBuilder] buildUnsignedMintTransaction error: ${error?.message || error}`);
+            (0, tx_build_helper_1.mapBuilderError)(error, 'lovelace');
+        }
+    }
+    /**
+     * Helper to build mint transaction with specified execution units
+     */
+    _buildMintTx(req, ctx, exUnits) {
+        // Prepare addresses
+        const recipientAddress = CSL.Address.from_bech32(req.recipientAddress);
+        const changeAddress = CSL.Address.from_bech32(req.changeAddress ?? req.senderAddress);
+        // Map ODATANO UTxOs -> CSL TransactionUnspentOutputs (with multi-asset support for burn transactions)
+        const cslUtxos = this._mapMultiAssetUtxosToCslUtxos(ctx.utxos);
+        // Create Transaction Builder
+        const txb = CSL.TransactionBuilder.new(this.txBuilderConfig);
+        // Parse the Plutus script from CBOR hex (CBOR-wrapped flat UPLC bytecode)
+        const scriptBytes = Buffer.from(req.mintingPolicyScript, 'hex');
+        const plutusScript = CSL.PlutusScript.new_v3(scriptBytes);
+        const scriptHash = plutusScript.hash();
+        // Create PlutusScriptSource - wrapper for the script
+        const scriptSource = CSL.PlutusScriptSource.new(plutusScript);
+        // Create MintBuilder
+        const mintBuilder = CSL.MintBuilder.new();
+        // Track total minted value for output
+        let totalMintedValue = CSL.Value.new(CSL.BigNum.from_str('0'));
+        // Process each mint action
+        for (const mintAction of req.mintActions) {
+            const { assetName } = (0, tx_build_helper_1.parseAssetUnit)(mintAction.assetUnit);
+            // Create asset name
+            const assetNameBytes = Buffer.from(assetName, 'hex');
+            const cslAssetName = CSL.AssetName.new(assetNameBytes);
+            // Create mint quantity (can be negative for burning)
+            const mintQuantity = CSL.Int.new_i32(Number(mintAction.quantity));
+            // Create redeemer with specified execution units
+            const redeemerData = CSL.PlutusData.new_integer(CSL.BigInt.from_str(String(mintAction.redeemer ?? 0)));
+            const redeemer = CSL.Redeemer.new(CSL.RedeemerTag.new_mint(), CSL.BigNum.from_str('0'), redeemerData, CSL.ExUnits.new(CSL.BigNum.from_str(exUnits.mem), CSL.BigNum.from_str(exUnits.cpu)));
+            // Create MintWitness directly from PlutusScriptSource + Redeemer
+            const mintWitness = CSL.MintWitness.new_plutus_script(scriptSource, redeemer);
+            // Add to mint builder
+            mintBuilder.add_asset(mintWitness, cslAssetName, mintQuantity);
+            // Add to total minted value for output construction (only if quantity > 0)
+            if (Number(mintAction.quantity) > 0) {
+                const assetValue = CSL.Value.new(CSL.BigNum.from_str('0'));
+                const multiAsset = CSL.MultiAsset.new();
+                const assets = CSL.Assets.new();
+                assets.insert(cslAssetName, CSL.BigNum.from_str(String(mintAction.quantity)));
+                multiAsset.insert(scriptHash, assets);
+                assetValue.set_multiasset(multiAsset);
+                totalMintedValue = totalMintedValue.checked_add(assetValue);
+            }
+        }
+        // Set the mint builder on transaction
+        txb.set_mint_builder(mintBuilder);
+        // Create output with minted assets + minimum lovelace
+        const minLovelace = CSL.BigNum.from_str(String(req.lovelaceAmount));
+        const outputValue = CSL.Value.new(minLovelace);
+        const finalOutputValue = outputValue.checked_add(totalMintedValue);
+        const recipientOutput = CSL.TransactionOutput.new(recipientAddress, finalOutputValue);
+        txb.add_output(recipientOutput);
+        // Add collateral for Plutus script execution
+        if (ctx.utxos.length > 0) {
+            const collateralUtxo = ctx.utxos[0];
+            const collateralBuilder = CSL.TxInputsBuilder.new();
+            const txHash = CSL.TransactionHash.from_bytes(Buffer.from(collateralUtxo.txHash, 'hex'));
+            const input = CSL.TransactionInput.new(txHash, collateralUtxo.outputIndex);
+            const address = CSL.Address.from_bech32(collateralUtxo.address);
+            const value = CSL.Value.new(CSL.BigNum.from_str((0, tx_build_helper_1.getLovelace)(collateralUtxo).toString()));
+            collateralBuilder.add_regular_input(address, input, value);
+            txb.set_collateral(collateralBuilder);
+        }
+        // Add inputs via coin selection
+        txb.add_inputs_from(cslUtxos, CSL.CoinSelectionStrategyCIP2.LargestFirstMultiAsset);
+        // Calculate script data hash BEFORE add_change_if_needed
+        // Always call calc_script_data_hash for Plutus transactions - CSL requires it
+        const costModels = this._createCostModels('v3');
+        txb.calc_script_data_hash(costModels);
+        // Now add change
+        txb.add_change_if_needed(changeAddress);
+        // Build and return transaction
+        return txb.build_tx();
+    }
+    async buildUnsignedPlutusSpendTransaction(req, ctx) {
+        try {
+            // Determine execution units - default or from evaluator
+            let finalExUnits = {
+                mem: const_1.DEFAULT_EXECUTION_UNITS.mem.toString(),
+                cpu: const_1.DEFAULT_EXECUTION_UNITS.cpu.toString()
+            };
+            if (ctx.evaluateTransaction) {
+                // Build evaluation pass with high execution units
+                logger.debug(`[CSLTxBuilder] Building evaluation pass for Plutus spending`);
+                const highExUnits = {
+                    mem: const_1.HIGH_EXECUTION_UNITS.mem.toString(),
+                    cpu: const_1.HIGH_EXECUTION_UNITS.cpu.toString()
+                };
+                const evalTx = this._buildPlutusSpendTx(req, ctx, highExUnits);
+                const evalTxCbor = Buffer.from(evalTx.to_bytes()).toString('hex');
+                try {
+                    const evalResults = await ctx.evaluateTransaction(evalTxCbor);
+                    logger.debug(`[CSLTxBuilder] Evaluation results: ${JSON.stringify(evalResults)}`);
+                    if (evalResults && evalResults.length > 0) {
+                        const budget = evalResults[0].budget;
+                        finalExUnits = {
+                            mem: Math.ceil(budget.memory * const_1.EXECUTION_UNIT_BUFFER).toString(),
+                            cpu: Math.ceil(budget.cpu * const_1.EXECUTION_UNIT_BUFFER).toString()
+                        };
+                        logger.info(`[CSLTxBuilder] Using evaluated execution units: mem=${finalExUnits.mem}, cpu=${finalExUnits.cpu}`);
+                    }
+                }
+                catch (evalError) {
+                    logger.warn(`[CSLTxBuilder] Evaluation failed, using default units: ${evalError.message}`);
+                }
+            }
+            else {
+                logger.debug(`[CSLTxBuilder] No evaluator available, using default execution units`);
+            }
+            // Build final transaction with determined execution units
+            const unsignedTx = this._buildPlutusSpendTx(req, ctx, finalExUnits);
+            // Export as CBOR hex
+            const unsignedTxCbor = Buffer.from(unsignedTx.to_bytes()).toString('hex');
+            // Extract transaction details
+            const body = unsignedTx.body();
+            const bodyBytes = body.to_bytes();
+            const hash = (0, blake2b_1.default)(32).update(bodyBytes).digest('hex');
+            const txBodyHash = hash;
+            const feeLovelace = body.fee().to_str();
+            // Extract outputs
+            const outputs = [];
+            const txOuts = body.outputs();
+            for (let i = 0; i < txOuts.len(); i++) {
+                const o = txOuts.get(i);
+                outputs.push({
+                    address: o.address().to_bech32(),
+                    lovelace: o.amount().coin().to_str(),
+                });
+            }
+            logger.info(`[CSLTxBuilder] Built unsigned Plutus spending transaction. Fee: ${feeLovelace}`);
+            return {
+                unsignedTxCbor,
+                txBodyHash,
+                senderAddress: req.senderAddress,
+                network: this.cardanoClient.network,
+                sizeBytes: unsignedTxCbor.length / 2,
+                builderEngine: this.name,
+                feeLovelace,
+                inputs: ctx.utxos.map(u => ({
+                    txHash: u.txHash,
+                    index: u.outputIndex,
+                    lovelace: (0, tx_build_helper_1.getLovelace)(u).toString(),
+                })),
+                outputs,
+                warnings: [],
+            };
+        }
+        catch (error) {
+            logger.error(`[CSLTxBuilder] buildUnsignedPlutusSpendTransaction error: ${error?.message || error}`);
+            (0, tx_build_helper_1.mapBuilderError)(error, 'lovelace');
+        }
+    }
+    /**
+     * Helper to build Plutus spending transaction with specified execution units
+     */
+    _buildPlutusSpendTx(req, ctx, exUnits) {
+        const { plutusScriptExecution } = req;
+        const scriptUtxoRef = plutusScriptExecution.scriptUtxo;
+        // Prepare addresses
+        const recipientAddress = CSL.Address.from_bech32(req.recipientAddress);
+        const changeAddress = CSL.Address.from_bech32(req.changeAddress ?? req.senderAddress);
+        // Create Transaction Builder
+        const txb = CSL.TransactionBuilder.new(this.txBuilderConfig);
+        // Parse the Plutus validator script from CBOR hex (CBOR-wrapped flat UPLC bytecode)
+        const scriptBytes = Buffer.from(plutusScriptExecution.validatorScript, 'hex');
+        const plutusScript = CSL.PlutusScript.new_v3(scriptBytes);
+        const scriptSource = CSL.PlutusScriptSource.new(plutusScript);
+        // Build redeemer (using DetailedSchema: { "constructor": 0, "fields": [] } format)
+        const redeemerPlutusData = CSL.PlutusData.from_json(JSON.stringify(plutusScriptExecution.redeemer), CSL.PlutusDatumSchema.DetailedSchema);
+        const redeemer = CSL.Redeemer.new(CSL.RedeemerTag.new_spend(), CSL.BigNum.from_str('0'), // index will be corrected by CSL
+        redeemerPlutusData, CSL.ExUnits.new(CSL.BigNum.from_str(exUnits.mem), CSL.BigNum.from_str(exUnits.cpu)));
+        // Build datum source
+        let datumSource;
+        if (plutusScriptExecution.datum) {
+            // Datum provided explicitly (hash-based datum)
+            const datumPlutusData = CSL.PlutusData.from_json(JSON.stringify(plutusScriptExecution.datum), CSL.PlutusDatumSchema.DetailedSchema);
+            datumSource = CSL.DatumSource.new(datumPlutusData);
+        }
+        else {
+            // No datum provided - for inline datums, pass a unit datum placeholder.
+            // The node will validate against the actual inline datum on-chain.
+            const unitDatum = CSL.PlutusData.new_constr_plutus_data(CSL.ConstrPlutusData.new(CSL.BigNum.from_str('0'), CSL.PlutusList.new()));
+            datumSource = CSL.DatumSource.new(unitDatum);
+        }
+        // Add the script input using TxInputsBuilder
+        const scriptInputsBuilder = CSL.TxInputsBuilder.new();
+        const scriptTxHash = CSL.TransactionHash.from_bytes(Buffer.from(scriptUtxoRef.txHash, 'hex'));
+        const scriptInput = CSL.TransactionInput.new(scriptTxHash, scriptUtxoRef.outputIndex);
+        // Find the script UTxO to get its value
+        const scriptOdatanoUtxo = ctx.utxos.find(u => u.txHash === scriptUtxoRef.txHash && u.outputIndex === scriptUtxoRef.outputIndex);
+        if (!scriptOdatanoUtxo) {
+            throw new Error(`[CSLTxBuilder] Script UTxO ${scriptUtxoRef.txHash}#${scriptUtxoRef.outputIndex} not found in provided UTxOs`);
+        }
+        const scriptUtxoValue = CSL.Value.new(CSL.BigNum.from_str((0, tx_build_helper_1.getLovelace)(scriptOdatanoUtxo).toString()));
+        // Add Plutus script input
+        scriptInputsBuilder.add_plutus_script_input(CSL.PlutusWitness.new_with_ref(scriptSource, datumSource, redeemer), scriptInput, scriptUtxoValue);
+        txb.set_inputs(scriptInputsBuilder);
+        // Add sender UTxOs for fee payment via coin selection
+        const senderUtxos = ctx.utxos.filter(u => !(u.txHash === scriptUtxoRef.txHash && u.outputIndex === scriptUtxoRef.outputIndex));
+        const cslSenderUtxos = this._mapMultiAssetUtxosToCslUtxos(senderUtxos);
+        txb.add_inputs_from(cslSenderUtxos, CSL.CoinSelectionStrategyCIP2.LargestFirstMultiAsset);
+        // Create output for recipient
+        const outputValue = CSL.Value.new(CSL.BigNum.from_str(String(req.lovelaceAmount || 2_000_000)));
+        const recipientOutput = CSL.TransactionOutput.new(recipientAddress, outputValue);
+        txb.add_output(recipientOutput);
+        // Add collateral (from sender UTxOs)
+        if (senderUtxos.length > 0) {
+            const collateralUtxo = senderUtxos[0];
+            const collateralBuilder = CSL.TxInputsBuilder.new();
+            const colTxHash = CSL.TransactionHash.from_bytes(Buffer.from(collateralUtxo.txHash, 'hex'));
+            const colInput = CSL.TransactionInput.new(colTxHash, collateralUtxo.outputIndex);
+            const colAddress = CSL.Address.from_bech32(collateralUtxo.address);
+            const colValue = CSL.Value.new(CSL.BigNum.from_str((0, tx_build_helper_1.getLovelace)(collateralUtxo).toString()));
+            collateralBuilder.add_regular_input(colAddress, colInput, colValue);
+            txb.set_collateral(collateralBuilder);
+        }
+        // Calculate script data hash
+        const costModels = this._createCostModels('v3');
+        txb.calc_script_data_hash(costModels);
+        // Add change
+        txb.add_change_if_needed(changeAddress);
+        // Build and return transaction
+        return txb.build_tx();
+    }
+    //---------------------------------------------------------------------------
+    // Private Helper Methods
+    //---------------------------------------------------------------------------
+    /**
+     * Map ODATANO UTxOs to CSL TransactionUnspentOutputs (with multi-asset support)
+     * @param utxos ODATANO UTxO array
+     * @returns CSL TransactionUnspentOutputs
+     */
+    _mapMultiAssetUtxosToCslUtxos(utxos) {
+        const outs = CSL.TransactionUnspentOutputs.new();
+        logger.debug(`Mapping ${utxos.length} UTxOs to CSL format`);
+        for (const u of utxos) {
+            logger.debug(`UTxO ${u.txHash}:${u.outputIndex} has ${u.amount.length} amounts: ${JSON.stringify(u.amount)}`);
+            const txHashBytes = Buffer.from(u.txHash, "hex");
+            const txHash = CSL.TransactionHash.from_bytes(txHashBytes);
+            const input = CSL.TransactionInput.new(txHash, u.outputIndex);
+            const addr = CSL.Address.from_bech32(u.address);
+            // Build value with ADA + all native assets
+            const lovelace = CSL.BigNum.from_str((0, tx_build_helper_1.getLovelace)(u).toString());
+            const value = CSL.Value.new(lovelace);
+            // Add native assets if any
+            const nonAdaAssets = u.amount.filter(a => a.unit.toLowerCase() !== 'lovelace' && BigInt(a.quantity) > 0n);
+            if (nonAdaAssets.length > 0) {
+                const multiAsset = CSL.MultiAsset.new();
+                for (const asset of nonAdaAssets) {
+                    const { policyId, assetName } = (0, tx_build_helper_1.parseAssetUnit)(asset.unit);
+                    const policyHash = CSL.ScriptHash.from_bytes(Buffer.from(policyId, 'hex'));
+                    let assets = multiAsset.get(policyHash);
+                    if (!assets) {
+                        assets = CSL.Assets.new();
+                    }
+                    const assetNameBytes = Buffer.from(assetName, 'hex');
+                    const assetNameObj = CSL.AssetName.new(assetNameBytes);
+                    assets.insert(assetNameObj, CSL.BigNum.from_str(asset.quantity));
+                    multiAsset.insert(policyHash, assets);
+                }
+                value.set_multiasset(multiAsset);
+            }
+            const output = CSL.TransactionOutput.new(addr, value);
+            outs.add(CSL.TransactionUnspentOutput.new(input, output));
+        }
+        return outs;
+    }
+    /**
+     * Create a CSL TransactionBuilderConfig from protocol parameters
+     * This config is created once and reused for all transactions
+     * @param protocolParams LedgerProtocolParameter
+     * @returns CSL.TransactionBuilderConfig
+     */
+    _createTxBuilderConfig(protocolParams) {
+        // required values for CSL config
+        const minFeeA = protocolParams.minFeeA;
+        const minFeeB = protocolParams.minFeeB;
+        const poolDeposit = protocolParams.poolDeposit;
+        const keyDeposit = protocolParams.keyDeposit;
+        const maxTxSize = protocolParams.maxTxSize;
+        const maxValueSize = protocolParams.maxValSize;
+        const coinsPerUtxoByte = protocolParams.coinsPerUtxoSize;
+        const feeAlgo = CSL.LinearFee.new(CSL.BigNum.from_str(String(minFeeA)), CSL.BigNum.from_str(String(minFeeB)));
+        // Plutus execution unit prices for script fee calculation
+        // Protocol params may contain decimal prices (e.g., 0.0577) - convert to integer numerators
+        const priceMemValue = protocolParams.priceMem;
+        const priceStepValue = protocolParams.priceStep;
+        // Convert decimal prices to integer numerators (or use defaults if already integers or missing)
+        const priceMemNumerator = (typeof priceMemValue === 'number' && priceMemValue < 1)
+            ? Math.round(priceMemValue * 10000) // 0.0577 -> 577
+            : (priceMemValue || 577);
+        const priceStepNumerator = (typeof priceStepValue === 'number' && priceStepValue < 1)
+            ? Math.round(priceStepValue * 10000000) // 0.0000721 -> 721
+            : (priceStepValue || 721);
+        const exUnitPrices = CSL.ExUnitPrices.new(CSL.UnitInterval.new(CSL.BigNum.from_str(String(priceMemNumerator)), // numerator
+        CSL.BigNum.from_str('10000') // denominator (0.0577 per memory unit)
+        ), CSL.UnitInterval.new(CSL.BigNum.from_str(String(priceStepNumerator)), // numerator
+        CSL.BigNum.from_str('10000000') // denominator (0.0000721 per CPU step)
+        ));
+        const cfg = CSL.TransactionBuilderConfigBuilder.new()
+            .fee_algo(feeAlgo)
+            .pool_deposit(CSL.BigNum.from_str(String(poolDeposit)))
+            .key_deposit(CSL.BigNum.from_str(String(keyDeposit)))
+            .max_tx_size(Number(maxTxSize))
+            .max_value_size(Number(maxValueSize))
+            .coins_per_utxo_byte(CSL.BigNum.from_str(String(coinsPerUtxoByte)))
+            .ex_unit_prices(exUnitPrices) // Critical for Plutus fee calculation
+            .build();
+        logger.info(`TransactionBuilderConfig created with Plutus execution unit prices.`);
+        return cfg;
+    }
+    /**
+     * Map ODATANO metadata JSON to CSL GeneralTransactionMetadata
+     * @param metadataJson JSON metadata object
+     * @returns CSL GeneralTransactionMetadata
+     */
+    _mapOdatanoMetadataToCSLMetadata(metadataJson) {
+        // Metadata must be an object with labels as keys
+        if (typeof metadataJson !== 'object' || Array.isArray(metadataJson) || metadataJson === null) {
+            throw new Error(`[CSLTxBuilder] Invalid metadata format. Expected object, got ${typeof metadataJson}`);
+        }
+        const metadata = CSL.GeneralTransactionMetadata.new();
+        for (const [label, value] of Object.entries(metadataJson)) {
+            // Convert label to BigNum
+            const numericLabel = parseInt(label, 10);
+            // Convert JSON Value to CSL TransactionMetadatum
+            const txMetadatum = this._jsonToCSLMetadatum(value);
+            logger.debug(`Created TransactionMetadatum for label ${numericLabel}`);
+            metadata.insert(CSL.BigNum.from_str(String(numericLabel)), txMetadatum);
+        }
+        logger.debug(`Created metadata with ${metadata.len()} labels`);
+        return metadata;
+    }
+    /**
+     * Create Costmdls from protocol parameters for specific Plutus version
+     * Required for correct script integrity hash calculation
+     * @param version - Optional: specific Plutus version ('v1', 'v2', 'v3'). If not provided, adds all versions.
+     * @returns CSL.Costmdls
+     */
+    _createCostModels(version) {
+        const costModels = CSL.Costmdls.new();
+        try {
+            // Parse cost models JSON from protocol parameters
+            // Format: { "plutus:v1": [array of 166 numbers], "plutus:v2": [array of 175 numbers], ... }
+            const costModelsJson = JSON.parse(this.protocolParameters.costModels || '{}');
+            // PlutusV3 cost model (check both "plutus:v3" and "PlutusV3" formats)
+            if (!version || version === 'v3') {
+                const plutusV3Costs = costModelsJson['plutus:v3'] || costModelsJson['PlutusV3'];
+                if (plutusV3Costs && Array.isArray(plutusV3Costs)) {
+                    const plutusV3CostModel = CSL.CostModel.new();
+                    for (let i = 0; i < plutusV3Costs.length; i++) {
+                        plutusV3CostModel.set(i, CSL.Int.new_i32(plutusV3Costs[i]));
+                    }
+                    costModels.insert(CSL.Language.new_plutus_v3(), plutusV3CostModel);
+                    logger.debug(`[CSLTxBuilder] Added PlutusV3 cost model with ${plutusV3Costs.length} parameters`);
+                }
+            }
+        }
+        catch (error) {
+            logger.warn(`[CSLTxBuilder] Failed to parse cost models: ${error}. Using empty cost models.`);
+        }
+        return costModels;
+    }
+    /**
+     * Convert JSON value to CSL TransactionMetadatum
+     * @param value JSON value
+     * @returns CSL TransactionMetadatum
+     */
+    _jsonToCSLMetadatum(value) {
+        if (typeof value === 'number' || typeof value === 'bigint') {
+            const intValue = CSL.Int.new_i32(Number(value));
+            return CSL.TransactionMetadatum.new_int(intValue);
+        }
+        if (typeof value === 'string') {
+            return CSL.TransactionMetadatum.new_text(value);
+        }
+        if (Array.isArray(value)) {
+            const list = CSL.MetadataList.new();
+            for (const item of value) {
+                list.add(this._jsonToCSLMetadatum(item));
+            }
+            return CSL.TransactionMetadatum.new_list(list);
+        }
+        if (typeof value === 'object' && value !== null) {
+            const map = CSL.MetadataMap.new();
+            for (const [k, v] of Object.entries(value)) {
+                const key = CSL.TransactionMetadatum.new_text(k);
+                const val = this._jsonToCSLMetadatum(v);
+                map.insert(key, val);
+            }
+            return CSL.TransactionMetadatum.new_map(map);
+        }
+        throw new Error(`[CSLTxBuilder] Unsupported metadata value type: ${typeof value}`);
+    }
+}
+exports.CSLTxBuilder = CSLTxBuilder;
+//# sourceMappingURL=csl-tx.js.map