@odatano/core 0.3.1

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

@@ -0,0 +1,636 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildooorTxBuilder = void 0;
+const buildooor_1 = require("@harmoniclabs/buildooor");
+const uint8array_utils_1 = require("@harmoniclabs/uint8array-utils");
+const tx_build_helper_1 = require("../../utils/tx-build-helper");
+const cds_1 = __importDefault(require("@sap/cds"));
+const cardano_ledger_ts_1 = require("@harmoniclabs/cardano-ledger-ts");
+const TxMetadata_1 = require("@harmoniclabs/cardano-ledger-ts/dist/tx/metadata/TxMetadata");
+const TxMetadatum_1 = require("@harmoniclabs/cardano-ledger-ts/dist/tx/metadata/TxMetadatum");
+const plutus_data_1 = require("@harmoniclabs/plutus-data");
+const const_1 = require("../../utils/const");
+const logger = cds_1.default.log('BuildooorTxBuilder');
+/**
+ * BuildooorTxBuilder - Implementation of CardanoTxBuilder using Buildooor library
+ */
+class BuildooorTxBuilder {
+    name = 'BuildooorTxBuilder';
+    txBuilder;
+    cardanoClient;
+    /**
+     * Initialize the builder
+     * @param client - The CardanoClient instance
+     * @param protocolParams - Optional protocol parameters (if not provided, fetched from backend)
+     */
+    async init(client, protocolParams) {
+        this.cardanoClient = client;
+        const params = protocolParams ?? await client.getProtocolParameters();
+        const txbParameters = this._mapLedgerParametersToBuildooorParams(params);
+        this.txBuilder = new buildooor_1.TxBuilder(txbParameters);
+        logger.debug(`TxBuilder 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 {
+            // mapping of ODATANO UTxO Type to ledger-ts UTxO objects (with multi-asset support)
+            // This allows spending UTxOs that contain native assets - they will be returned in the change output
+            const ledgerUtxos = ctx.utxos.map(utxo => this._mapMultiAssetUtxoToLedgerUtxo(utxo));
+            // and map to Buildooor TxIn objects for inputs
+            const inputs = ledgerUtxos.map(utxo => ({ utxo }));
+            // set Addresses
+            const recipientAddress = cardano_ledger_ts_1.Address.fromString(req.recipientAddress);
+            const changeAddress = cardano_ledger_ts_1.Address.fromString(req.changeAddress ?? req.senderAddress);
+            // set Amount
+            const amount = BigInt(String(req.lovelaceAmount));
+            // build new outputs for recipient
+            const txOutParams = {
+                address: recipientAddress,
+                value: cardano_ledger_ts_1.Value.lovelaces(amount),
+            };
+            if (req.outputDatum) {
+                txOutParams.datum = (0, tx_build_helper_1.jsonToPlutusData)(req.outputDatum);
+            }
+            const outputs = [new cardano_ledger_ts_1.TxOut(txOutParams)];
+            // build the transaction
+            const tx = await this.txBuilder.build({
+                inputs,
+                outputs,
+                changeAddress,
+            });
+            // full unsigned tx cbor (4-tuple, witness empty)
+            const unsignedTxBytes = tx.toCbor().toBuffer();
+            const unsignedTxCbor = (0, uint8array_utils_1.toHex)(unsignedTxBytes);
+            const txBodyHash = tx.hash.toString();
+            logger.debug(`Built unsigned transaction successfully.`);
+            return {
+                unsignedTxCbor: unsignedTxCbor,
+                txBodyHash: txBodyHash,
+                senderAddress: req.senderAddress,
+                network: this.cardanoClient.network,
+                sizeBytes: unsignedTxBytes.length,
+                builderEngine: this.name,
+                feeLovelace: tx.body.fee.toString(),
+                inputs: ctx.utxos.map(u => ({
+                    txHash: u.txHash,
+                    index: u.outputIndex,
+                    lovelace: (0, tx_build_helper_1.getLovelace)(u).toString()
+                })),
+                outputs: tx.body.outputs.map((o) => ({
+                    address: o.address?.toString?.() ?? "",
+                    lovelace: o.value?.lovelaces?.toString?.() ?? "0"
+                })),
+                warnings: []
+            };
+        }
+        catch (err) {
+            (0, tx_build_helper_1.mapBuilderError)(err, 'lovelace');
+        }
+    }
+    async buildUnsignedTransactionWithMetadata(req, ctx) {
+        try {
+            // mapping of ODATANO UTxO Type to ledger-ts UTxO objects (with multi-asset support)
+            // This allows spending UTxOs that contain native assets - they will be returned in the change output
+            const ledgerUtxos = ctx.utxos.map(utxo => this._mapMultiAssetUtxoToLedgerUtxo(utxo));
+            // Buildooor TxIn objects for inputs
+            const inputs = ledgerUtxos.map(utxo => ({ utxo }));
+            // Addresses
+            const recipientAddress = cardano_ledger_ts_1.Address.fromString(req.recipientAddress);
+            const changeAddress = cardano_ledger_ts_1.Address.fromString(req.changeAddress ?? req.senderAddress);
+            // Amount
+            const amount = BigInt(String(req.lovelaceAmount));
+            const metadata = this._mapOdatanoMetadataToLedgerMetadata(req.metadataJson);
+            // build new outputs for recipient
+            const outputs = [
+                new cardano_ledger_ts_1.TxOut({
+                    address: recipientAddress,
+                    value: cardano_ledger_ts_1.Value.lovelaces(amount)
+                })
+            ];
+            // build the transaction
+            const tx = await this.txBuilder.build({
+                inputs,
+                outputs,
+                changeAddress,
+                metadata
+            });
+            // full unsigned tx cbor (4-tuple, witness empty)
+            const unsignedTxBytes = tx.toCbor().toBuffer();
+            const unsignedTxCbor = (0, uint8array_utils_1.toHex)(unsignedTxBytes);
+            const txBodyHash = tx.hash.toString();
+            logger.debug(`Built unsigned transaction successfully.`);
+            return {
+                unsignedTxCbor: unsignedTxCbor,
+                txBodyHash: txBodyHash,
+                senderAddress: req.senderAddress,
+                network: this.cardanoClient.network,
+                builderEngine: this.name,
+                sizeBytes: unsignedTxBytes.length,
+                feeLovelace: tx.body.fee.toString(),
+                inputs: ctx.utxos.map(u => ({
+                    txHash: u.txHash,
+                    index: u.outputIndex,
+                    lovelace: (0, tx_build_helper_1.getLovelace)(u).toString()
+                })),
+                outputs: tx.body.outputs.map((o) => ({
+                    address: o.address?.toString?.() ?? "",
+                    lovelace: o.value?.lovelaces?.toString?.() ?? "0"
+                })),
+                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('[BuildooorTxBuilder] buildUnsignedMultiAssetTransaction requires assets to be specified');
+        }
+        try {
+            // Map all available UTxOs to ledger UTxOs for Buildooor (let builder handle selection)
+            const ledgerUtxos = ctx.utxos.map(utxo => this._mapMultiAssetUtxoToLedgerUtxo(utxo));
+            // Buildooor TxIn objects for inputs
+            const inputs = ledgerUtxos.map(utxo => ({ utxo }));
+            // Addresses
+            const recipientAddress = cardano_ledger_ts_1.Address.fromString(req.recipientAddress);
+            const changeAddress = cardano_ledger_ts_1.Address.fromString(req.changeAddress ?? req.senderAddress);
+            // Build output value with ADA + assets
+            let outputValue = cardano_ledger_ts_1.Value.lovelaces(BigInt(req.lovelaceAmount));
+            for (const asset of req.assets) {
+                // Parse policyId and assetName from unit (format: policyId.assetName or policyId+assetName)
+                const { policyId, assetName } = (0, tx_build_helper_1.parseAssetUnit)(asset.unit);
+                const policyHash = new cardano_ledger_ts_1.Hash28(policyId);
+                const assetValue = cardano_ledger_ts_1.Value.singleAsset(policyHash, Buffer.from(assetName, 'hex'), BigInt(asset.quantity));
+                outputValue = cardano_ledger_ts_1.Value.add(outputValue, assetValue);
+            }
+            // Build output
+            const outputs = [
+                new cardano_ledger_ts_1.TxOut({
+                    address: recipientAddress,
+                    value: outputValue
+                })
+            ];
+            // Build the transaction
+            const tx = await this.txBuilder.build({
+                inputs,
+                outputs,
+                changeAddress,
+            });
+            // Full unsigned tx cbor (4-tuple, witness empty)
+            const unsignedTxBytes = tx.toCbor().toBuffer();
+            const unsignedTxCbor = (0, uint8array_utils_1.toHex)(unsignedTxBytes);
+            const txBodyHash = tx.hash.toString();
+            logger.debug(`Built unsigned multi-asset transaction successfully.`);
+            return {
+                unsignedTxCbor: unsignedTxCbor,
+                txBodyHash: txBodyHash,
+                senderAddress: req.senderAddress,
+                network: this.cardanoClient.network,
+                sizeBytes: unsignedTxBytes.length,
+                builderEngine: this.name,
+                feeLovelace: tx.body.fee.toString(),
+                inputs: ctx.utxos.map(u => ({
+                    txHash: u.txHash,
+                    index: u.outputIndex,
+                    lovelace: (0, tx_build_helper_1.getLovelace)(u).toString()
+                })),
+                outputs: tx.body.outputs.map((o) => ({
+                    address: o.address?.toString?.() ?? "",
+                    lovelace: o.value?.lovelaces?.toString?.() ?? "0"
+                })),
+                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];
+            (0, tx_build_helper_1.mapBuilderError)(err, assetUnit);
+        }
+    }
+    async buildUnsignedMintTransaction(req, ctx) {
+        try {
+            // Map all available UTxOs to ledger UTxOs (let builder handle selection)
+            // Use multi-asset mapper to support burn transactions
+            const ledgerUtxos = ctx.utxos.map(utxo => this._mapMultiAssetUtxoToLedgerUtxo(utxo));
+            // Buildooor TxIn objects for inputs
+            const inputs = ledgerUtxos.map(utxo => ({ utxo }));
+            // Addresses
+            const recipientAddress = cardano_ledger_ts_1.Address.fromString(req.recipientAddress);
+            const changeAddress = cardano_ledger_ts_1.Address.fromString(req.changeAddress ?? req.senderAddress);
+            // Parse the minting policy script once
+            const scriptBytes = Buffer.from(req.mintingPolicyScript, 'hex');
+            const script = cardano_ledger_ts_1.Script.fromCbor(scriptBytes);
+            // Helper to build mints array with specified execution units
+            const buildMints = (exUnits) => {
+                const mints = [];
+                for (const mintAction of req.mintActions) {
+                    const { policyId, assetName } = (0, tx_build_helper_1.parseAssetUnit)(mintAction.assetUnit);
+                    const policyHash = new cardano_ledger_ts_1.Hash28(policyId);
+                    const assetValue = cardano_ledger_ts_1.Value.singleAsset(policyHash, Buffer.from(assetName, 'hex'), BigInt(mintAction.quantity));
+                    mints.push({
+                        value: assetValue,
+                        script: {
+                            inline: script,
+                            redeemer: new plutus_data_1.DataI(mintAction.redeemer ?? 0),
+                            executionUnits: exUnits
+                        }
+                    });
+                }
+                return mints;
+            };
+            // Calculate total mint value for output (only positive quantities - mints, not burns)
+            let mintValue = cardano_ledger_ts_1.Value.lovelaces(0n);
+            for (const mintAction of req.mintActions) {
+                const quantity = BigInt(mintAction.quantity);
+                if (quantity > 0n) {
+                    const { policyId, assetName } = (0, tx_build_helper_1.parseAssetUnit)(mintAction.assetUnit);
+                    const policyHash = new cardano_ledger_ts_1.Hash28(policyId);
+                    const assetValue = cardano_ledger_ts_1.Value.singleAsset(policyHash, Buffer.from(assetName, 'hex'), quantity);
+                    mintValue = cardano_ledger_ts_1.Value.add(mintValue, assetValue);
+                }
+            }
+            // Build output value - recipient gets the minted assets + min ADA
+            let outputValue = cardano_ledger_ts_1.Value.lovelaces(BigInt(req.lovelaceAmount || 1_000_000));
+            outputValue = cardano_ledger_ts_1.Value.add(outputValue, mintValue);
+            // Build output
+            const outputs = [
+                new cardano_ledger_ts_1.TxOut({
+                    address: recipientAddress,
+                    value: outputValue
+                })
+            ];
+            // Find an ADA-only UTxO for collateral (Plutus scripts require ADA-only collateral)
+            const adaOnlyUtxo = ctx.utxos.find(u => u.amount.every(a => a.unit.toLowerCase() === 'lovelace'));
+            if (!adaOnlyUtxo) {
+                throw new Error('[BuildooorTxBuilder] No ADA-only UTxO available for collateral. Plutus scripts require ADA-only collateral.');
+            }
+            // Use only 1 collateral to minimize tx size
+            const collateralUtxos = [this._mapOdatanoUtxoToLedgerUtxo(adaOnlyUtxo)];
+            // Determine execution units based on evaluator availability
+            let finalExUnits = const_1.DEFAULT_EXECUTION_UNITS;
+            if (ctx.evaluateTransaction) {
+                // Build first pass with high execution units for evaluation
+                logger.debug(`Building evaluation pass with high execution units`);
+                const evalMints = buildMints(const_1.HIGH_EXECUTION_UNITS);
+                const evalTx = await this.txBuilder.build({
+                    inputs,
+                    outputs,
+                    changeAddress,
+                    mints: evalMints,
+                    collaterals: collateralUtxos
+                });
+                const evalTxCbor = (0, uint8array_utils_1.toHex)(evalTx.toCbor().toBuffer());
+                try {
+                    // Evaluate to get exact execution units
+                    const evalResults = await ctx.evaluateTransaction(evalTxCbor);
+                    logger.debug(`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),
+                            cpu: Math.ceil(budget.cpu * const_1.EXECUTION_UNIT_BUFFER)
+                        };
+                        logger.info(`Using evaluated execution units: mem=${finalExUnits.mem}, cpu=${finalExUnits.cpu}`);
+                    }
+                }
+                catch (evalError) {
+                    logger.warn(`Evaluation failed, using default units: ${evalError.message}`);
+                    // Fall back to defaults on evaluation failure
+                }
+            }
+            else {
+                logger.debug(`No evaluator available, using default execution units`);
+            }
+            // Build with final execution units
+            const mints = buildMints(finalExUnits);
+            // First build to calculate base fee
+            const txFirstPass = await this.txBuilder.build({
+                inputs,
+                outputs,
+                changeAddress,
+                mints: mints,
+                collaterals: collateralUtxos
+            });
+            // Add minimal buffer for witness set CBOR overhead (signing adds ~44 bytes)
+            const calculatedFee = BigInt(txFirstPass.body.fee.toString());
+            const witnessBuffer = BigInt(const_1.WITNESS_BUFFER_BYTES);
+            const adjustedMinFee = calculatedFee + witnessBuffer;
+            logger.debug(`First pass fee: ${calculatedFee}, rebuilding with witness buffer: ${adjustedMinFee}`);
+            // Final build with adjusted minimum fee to account for witness overhead
+            const tx = await this.txBuilder.build({
+                inputs,
+                outputs,
+                changeAddress,
+                mints: mints,
+                collaterals: collateralUtxos,
+                fee: adjustedMinFee
+            });
+            // Full unsigned tx cbor (4-tuple, witness empty)
+            const unsignedTxBytes = tx.toCbor().toBuffer();
+            const unsignedTxCbor = (0, uint8array_utils_1.toHex)(unsignedTxBytes);
+            const txBodyHash = tx.hash.toString();
+            logger.debug(`Built unsigned minting transaction successfully with fee: ${tx.body.fee.toString()}`);
+            return {
+                unsignedTxCbor: unsignedTxCbor,
+                txBodyHash: txBodyHash,
+                senderAddress: req.senderAddress,
+                network: this.cardanoClient.network,
+                builderEngine: this.name,
+                sizeBytes: unsignedTxBytes.length,
+                feeLovelace: tx.body.fee.toString(),
+                inputs: ctx.utxos.map(u => ({
+                    txHash: u.txHash,
+                    index: u.outputIndex,
+                    lovelace: (0, tx_build_helper_1.getLovelace)(u).toString()
+                })),
+                outputs: tx.body.outputs.map((o) => ({
+                    address: o.address?.toString?.() ?? "",
+                    lovelace: o.value?.lovelaces?.toString?.() ?? "0"
+                })),
+                warnings: []
+            };
+        }
+        catch (err) {
+            (0, tx_build_helper_1.mapBuilderError)(err, 'lovelace');
+        }
+    }
+    async buildUnsignedPlutusSpendTransaction(req, ctx) {
+        try {
+            const { plutusScriptExecution } = req;
+            // Parse the validator script
+            const scriptBytes = Buffer.from(plutusScriptExecution.validatorScript, 'hex');
+            const script = cardano_ledger_ts_1.Script.fromCbor(scriptBytes);
+            // Convert redeemer JSON to PlutusData
+            const redeemerData = (0, tx_build_helper_1.jsonToPlutusData)(plutusScriptExecution.redeemer);
+            // Determine datum: "inline" if no datum provided (assumes inline datum on UTxO), otherwise convert
+            const datum = plutusScriptExecution.datum
+                ? (0, tx_build_helper_1.jsonToPlutusData)(plutusScriptExecution.datum)
+                : "inline";
+            // Find the specific script UTxO in the provided context UTxOs
+            // The coordinator is responsible for including the script UTxO in ctx.utxos
+            const scriptUtxoRef = plutusScriptExecution.scriptUtxo;
+            const scriptOdatanoUtxo = ctx.utxos.find(u => u.txHash === scriptUtxoRef.txHash && u.outputIndex === scriptUtxoRef.outputIndex);
+            if (!scriptOdatanoUtxo) {
+                throw new Error(`[BuildooorTxBuilder] Script UTxO ${scriptUtxoRef.txHash}#${scriptUtxoRef.outputIndex} not found in provided UTxOs`);
+            }
+            // Map the script UTxO to ledger format
+            const scriptLedgerUtxo = this._mapMultiAssetUtxoToLedgerUtxo(scriptOdatanoUtxo);
+            // Map sender UTxOs (excluding the script UTxO) as regular inputs
+            const senderUtxos = ctx.utxos.filter(u => !(u.txHash === scriptUtxoRef.txHash && u.outputIndex === scriptUtxoRef.outputIndex));
+            const senderLedgerUtxos = senderUtxos.map(utxo => this._mapMultiAssetUtxoToLedgerUtxo(utxo));
+            // Addresses
+            const recipientAddress = cardano_ledger_ts_1.Address.fromString(req.recipientAddress);
+            const changeAddress = cardano_ledger_ts_1.Address.fromString(req.changeAddress ?? req.senderAddress);
+            // Build output
+            const outputValue = cardano_ledger_ts_1.Value.lovelaces(BigInt(req.lovelaceAmount || 2_000_000));
+            const outputs = [
+                new cardano_ledger_ts_1.TxOut({
+                    address: recipientAddress,
+                    value: outputValue
+                })
+            ];
+            // Find an ADA-only UTxO for collateral (from sender UTxOs only)
+            const adaOnlyUtxo = senderUtxos.find(u => u.amount.every(a => a.unit.toLowerCase() === 'lovelace'));
+            if (!adaOnlyUtxo) {
+                throw new Error('[BuildooorTxBuilder] No ADA-only UTxO available for collateral. Plutus scripts require ADA-only collateral.');
+            }
+            const collateralUtxos = [this._mapOdatanoUtxoToLedgerUtxo(adaOnlyUtxo)];
+            // Helper to build inputs with specified execution units
+            const buildInputs = (exUnits) => {
+                // Script input with witness
+                const scriptInput = {
+                    utxo: scriptLedgerUtxo,
+                    inputScript: {
+                        script,
+                        datum,
+                        redeemer: redeemerData,
+                        executionUnits: exUnits
+                    }
+                };
+                // Regular sender inputs for fees
+                const regularInputs = senderLedgerUtxos.map(utxo => ({ utxo }));
+                return [scriptInput, ...regularInputs];
+            };
+            // Determine execution units based on evaluator availability
+            let finalExUnits = const_1.DEFAULT_EXECUTION_UNITS;
+            if (ctx.evaluateTransaction) {
+                // Build first pass with high execution units for evaluation
+                logger.debug(`Building evaluation pass with high execution units`);
+                const evalInputs = buildInputs(const_1.HIGH_EXECUTION_UNITS);
+                const evalTx = await this.txBuilder.build({
+                    inputs: evalInputs,
+                    outputs,
+                    changeAddress,
+                    collaterals: collateralUtxos
+                });
+                const evalTxCbor = (0, uint8array_utils_1.toHex)(evalTx.toCbor().toBuffer());
+                try {
+                    const evalResults = await ctx.evaluateTransaction(evalTxCbor);
+                    logger.debug(`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),
+                            cpu: Math.ceil(budget.cpu * const_1.EXECUTION_UNIT_BUFFER)
+                        };
+                        logger.info(`Using evaluated execution units: mem=${finalExUnits.mem}, cpu=${finalExUnits.cpu}`);
+                    }
+                }
+                catch (evalError) {
+                    logger.warn(`Evaluation failed, using default units: ${evalError.message}`);
+                }
+            }
+            else {
+                logger.debug(`No evaluator available, using default execution units`);
+            }
+            // Build with final execution units
+            const inputs = buildInputs(finalExUnits);
+            // First build to calculate base fee
+            const txFirstPass = await this.txBuilder.build({
+                inputs,
+                outputs,
+                changeAddress,
+                collaterals: collateralUtxos
+            });
+            // Add minimal buffer for witness set CBOR overhead
+            const calculatedFee = BigInt(txFirstPass.body.fee.toString());
+            const witnessBuffer = BigInt(const_1.WITNESS_BUFFER_BYTES);
+            const adjustedMinFee = calculatedFee + witnessBuffer;
+            logger.debug(`First pass fee: ${calculatedFee}, rebuilding with witness buffer: ${adjustedMinFee}`);
+            // Final build with adjusted minimum fee
+            const tx = await this.txBuilder.build({
+                inputs,
+                outputs,
+                changeAddress,
+                collaterals: collateralUtxos,
+                fee: adjustedMinFee
+            });
+            const unsignedTxBytes = tx.toCbor().toBuffer();
+            const unsignedTxCbor = (0, uint8array_utils_1.toHex)(unsignedTxBytes);
+            const txBodyHash = tx.hash.toString();
+            logger.debug(`Built unsigned Plutus spending transaction successfully with fee: ${tx.body.fee.toString()}`);
+            return {
+                unsignedTxCbor,
+                txBodyHash,
+                senderAddress: req.senderAddress,
+                network: this.cardanoClient.network,
+                builderEngine: this.name,
+                sizeBytes: unsignedTxBytes.length,
+                feeLovelace: tx.body.fee.toString(),
+                inputs: ctx.utxos.map(u => ({
+                    txHash: u.txHash,
+                    index: u.outputIndex,
+                    lovelace: (0, tx_build_helper_1.getLovelace)(u).toString()
+                })),
+                outputs: tx.body.outputs.map((o) => ({
+                    address: o.address?.toString?.() ?? "",
+                    lovelace: o.value?.lovelaces?.toString?.() ?? "0"
+                })),
+                warnings: []
+            };
+        }
+        catch (err) {
+            (0, tx_build_helper_1.mapBuilderError)(err, 'lovelace');
+        }
+    }
+    //---------------------------------------------------------------------------
+    // Private Helper Methods
+    //---------------------------------------------------------------------------
+    /**
+     * Map ODATANO LedgerProtocolParameter to Buildooor's ProtocolParameters shape
+     * @param protocolParameters ledger protocol parameters
+     * @returns mapped protocol parameters
+     */
+    _mapLedgerParametersToBuildooorParams(protocolParameters) {
+        // Map LedgerProtocolParameter to Buildooor's ProtocolParameters shape
+        // Using defaultProtocolParameters as base and overriding with actual values
+        return {
+            ...cardano_ledger_ts_1.defaultProtocolParameters,
+            txFeePerByte: Number(protocolParameters.minFeeA),
+            txFeeFixed: Number(protocolParameters.minFeeB),
+            utxoCostPerByte: Number(protocolParameters.coinsPerUtxoSize),
+            poolDeposit: Number(protocolParameters.poolDeposit),
+            keyDeposit: Number(protocolParameters.keyDeposit),
+            maxTxSize: Number(protocolParameters.maxTxSize),
+            maxValueSize: Number(protocolParameters.maxValSize),
+        };
+    }
+    /**
+     * Map ODATANO UTxO to Ledger UTxO (ADA-only)
+     * @param utxos ODATANO UTxO
+     * @returns mapped Ledger UTxO
+     */
+    _mapOdatanoUtxoToLedgerUtxo(utxos) {
+        (0, tx_build_helper_1.assertAdaOnly)(utxos);
+        const outRef = new cardano_ledger_ts_1.TxOutRef({
+            id: utxos.txHash,
+            index: utxos.outputIndex
+        });
+        const addr = cardano_ledger_ts_1.Address.fromString(utxos.address);
+        const value = cardano_ledger_ts_1.Value.lovelaces((0, tx_build_helper_1.getLovelace)(utxos));
+        return new cardano_ledger_ts_1.UTxO({
+            utxoRef: outRef,
+            resolved: new cardano_ledger_ts_1.TxOut({
+                address: addr,
+                value,
+                datum: undefined,
+                refScript: undefined
+            })
+        });
+    }
+    /**
+     * Map ODATANO UTxO to Ledger UTxO (with multi-asset support)
+     * @param utxo ODATANO UTxO
+     * @returns mapped Ledger UTxO
+     */
+    _mapMultiAssetUtxoToLedgerUtxo(utxo) {
+        const outRef = new cardano_ledger_ts_1.TxOutRef({
+            id: utxo.txHash,
+            index: utxo.outputIndex
+        });
+        const addr = cardano_ledger_ts_1.Address.fromString(utxo.address);
+        // Build Value from all amounts
+        let value = cardano_ledger_ts_1.Value.lovelaces((0, tx_build_helper_1.getLovelace)(utxo));
+        for (const amount of utxo.amount) {
+            if (amount.unit.toLowerCase() !== 'lovelace') {
+                const { policyId, assetName } = (0, tx_build_helper_1.parseAssetUnit)(amount.unit);
+                const policyHash = new cardano_ledger_ts_1.Hash28(policyId);
+                const assetValue = cardano_ledger_ts_1.Value.singleAsset(policyHash, Buffer.from(assetName, 'hex'), BigInt(amount.quantity));
+                value = cardano_ledger_ts_1.Value.add(value, assetValue);
+            }
+        }
+        return new cardano_ledger_ts_1.UTxO({
+            utxoRef: outRef,
+            resolved: new cardano_ledger_ts_1.TxOut({
+                address: addr,
+                value,
+                datum: undefined,
+                refScript: undefined
+            })
+        });
+    }
+    /**
+     * Map ODATANO metadata JSON to Ledger TxMetadata
+     * @param metadataJson  metadata in JSON format
+     * @returns mapped TxMetadata
+     */
+    _mapOdatanoMetadataToLedgerMetadata(metadataJson) {
+        if (!metadataJson) {
+            return new TxMetadata_1.TxMetadata({});
+        }
+        const metadata = {};
+        for (const [label, value] of Object.entries(metadataJson)) {
+            // convert label to number
+            const numericLabel = parseInt(label, 10);
+            // convert JSON value to TxMetadatum
+            const txMetadatum = this._jsonToTxMetadatum(value);
+            logger.debug(`Created TxMetadatum for label ${numericLabel}: ${txMetadatum.constructor.name}`);
+            metadata[numericLabel] = txMetadatum;
+        }
+        logger.debug(`Creating TxMetadata with ${Object.keys(metadata).length} labels`);
+        const txMetadata = new TxMetadata_1.TxMetadata(metadata);
+        logger.debug(`TxMetadata created: ${txMetadata.constructor.name}, instanceof check: ${txMetadata instanceof TxMetadata_1.TxMetadata}`);
+        return txMetadata;
+    }
+    /**
+     * Recursively convert JSON value to TxMetadatum
+     * @param value JSON value
+     * @returns corresponding TxMetadatum
+     */
+    _jsonToTxMetadatum(value) {
+        if (typeof value === 'number' || typeof value === 'bigint') {
+            return new TxMetadatum_1.TxMetadatumInt(BigInt(value));
+        }
+        if (typeof value === 'string') {
+            return new TxMetadatum_1.TxMetadatumText(value);
+        }
+        if (Array.isArray(value)) {
+            return new TxMetadatum_1.TxMetadatumList(value.map(v => this._jsonToTxMetadatum(v)));
+        }
+        if (typeof value === 'object' && value !== null) {
+            const map = [];
+            for (const [k, v] of Object.entries(value)) {
+                map.push({
+                    k: new TxMetadatum_1.TxMetadatumText(k),
+                    v: this._jsonToTxMetadatum(v)
+                });
+            }
+            return new TxMetadatum_1.TxMetadatumMap(map);
+        }
+        throw new Error(`[BuildooorTxBuilder] Unsupported metadata value type: ${typeof value}`);
+    }
+}
+exports.BuildooorTxBuilder = BuildooorTxBuilder;
+//# sourceMappingURL=buildooor-tx.js.map