@odatano/core 0.3.1

package/srv/utils/mappers.js

@@ -0,0 +1,723 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapTransaction = mapTransaction;
+exports.mapTransactionInputs = mapTransactionInputs;
+exports.mapTransactionInputAssets = mapTransactionInputAssets;
+exports.mapTransactionOutputs = mapTransactionOutputs;
+exports.mapTransactionOutputAssets = mapTransactionOutputAssets;
+exports.mapAddress = mapAddress;
+exports.mapAddressTransactions = mapAddressTransactions;
+exports.mapAddressUtxos = mapAddressUtxos;
+exports.mapAddressAssets = mapAddressAssets;
+exports.mapAddressUtxoAssets = mapAddressUtxoAssets;
+exports.mapNetworkInfo = mapNetworkInfo;
+exports.mapBlock = mapBlock;
+exports.mapEpoch = mapEpoch;
+exports.mapTransactionMetadata = mapTransactionMetadata;
+exports.mapPool = mapPool;
+exports.mapDrep = mapDrep;
+exports.mapAccount = mapAccount;
+exports.mapError = mapError;
+exports.mapBuildResult = mapBuildResult;
+exports.mapBuildInputs = mapBuildInputs;
+exports.mapBuildOutputs = mapBuildOutputs;
+exports.mapProtocolParameters = mapProtocolParameters;
+exports.mapTransactionSubmission = mapTransactionSubmission;
+exports.mapAddressSigningRequest = mapAddressSigningRequest;
+exports.mapAddressTransactionBuild = mapAddressTransactionBuild;
+const errors_1 = require("./errors");
+const cds_1 = __importDefault(require("@sap/cds"));
+/**
+ * Maximum age for cached/indexed data in milliseconds
+ */
+/**
+ * Map Transaction Data
+ * Converts provider transaction data into TransactionRow format
+ * @param providerTx
+ * @returns {TransactionRow} mapped transaction row
+ */
+function mapTransaction(providerTx) {
+    // determine presence of optional data
+    const hasMetadata = providerTx.metadata != null && (Array.isArray(providerTx.metadata));
+    const hasInputs = Array.isArray(providerTx.inputs) && providerTx.inputs.length > 0;
+    const hasOutputs = Array.isArray(providerTx.outputs) && providerTx.outputs.length > 0;
+    return {
+        hash: providerTx.hash,
+        blockHash: providerTx.blockHash,
+        blockHeight: providerTx.blockHeight ?? null,
+        blockTime: providerTx.blockTime ?? null,
+        slot: providerTx.slot ?? null,
+        txIndex: providerTx.index ?? null,
+        fee: providerTx.fee != null ? Number(providerTx.fee) : 0,
+        deposit: providerTx.deposit != null ? Number(providerTx.deposit) : 0,
+        size: providerTx.size ?? null,
+        hasInputs: hasInputs,
+        hasOutputs: hasOutputs,
+        hasMetadata: hasMetadata,
+    };
+}
+/**
+ * Map Transaction Inputs
+ * Converts provider transaction input data into TransactionInputRow format
+ * @param txHash transaction hash
+ * @param txInputs transaction inputs from provider
+ * @returns {TransactionInputRow[]} mapped transaction input rows
+ */
+function mapTransactionInputs(txHash, txInputs) {
+    return txInputs.map((input, idx) => {
+        // Use array index as the input index (position in this transaction's inputs)
+        // Note: input.outputIndex is the output index from the ORIGINAL UTxO being spent, not for keying here
+        const inputIndex = idx;
+        // check presence of address and amount arrays
+        const hasAddress = !!input.address?.length;
+        const hasAssets = Array.isArray(input.amount) && input.amount.length > 0;
+        return {
+            tx_hash: txHash,
+            inputIndex: inputIndex,
+            address_address: input.address,
+            utxoData_dataHash: input.dataHash || null,
+            utxoData_inlineDatum: input.inlineDatum || null,
+            utxoData_referenceScriptHash: input.referenceScriptHash || null,
+            isCollateral: Boolean(input.isCollateral),
+            isReference: Boolean(input.isReference),
+            hasAddresses: hasAddress,
+            hasAssets: hasAssets,
+        };
+    });
+}
+/**
+ * Map Transaction Input Assets
+ * Converts provider transaction input asset data into TransactionInputAssetRow format
+ * @param txHash transaction hash
+ * @param inputs transaction inputs from provider
+ * @returns {TransactionInputAssetRow[]} mapped transaction input asset rows
+ */
+function mapTransactionInputAssets(txHash, inputs) {
+    return inputs.flatMap((input, idx) => {
+        // Use array index as the input index (must match mapTransactionInputs)
+        const inputIndex = idx;
+        if (!Array.isArray(input.amount))
+            return [];
+        return input.amount.map(a => {
+            const { policyId, assetName } = parseAssetUnit(a.unit);
+            return {
+                input_tx_hash: txHash,
+                input_inputIndex: inputIndex,
+                unit: a.unit,
+                asset_quantity: Number(a.quantity),
+                asset_policyId: policyId,
+                asset_assetName: assetName,
+            };
+        });
+    });
+}
+/**
+ * Map Transaction Outputs
+ * Converts provider transaction output data into TransactionOutputRow format
+ * @param txHash transaction hash
+ * @param txOutputs transaction outputs from provider
+ * @returns {TransactionOutputRow[]} mapped transaction output rows
+ */
+function mapTransactionOutputs(txHash, txOutputs) {
+    return txOutputs.map((output, idx) => {
+        const outputIndex = output.outputIndex ?? idx;
+        const hasAddresses = !!output.address?.length;
+        const hasAssets = Array.isArray(output.amount) && output.amount.length > 0;
+        return {
+            tx_hash: txHash,
+            outputIndex: outputIndex,
+            address_address: output.address,
+            utxo_dataHash: output.dataHash || null,
+            utxo_inlineDatum: output.inlineDatum || null,
+            utxo_referenceScriptHash: output.referenceScriptHash || null,
+            hasAddresses: hasAddresses,
+            hasAssets: hasAssets,
+        };
+    });
+}
+/**
+ * Map Transaction Output Assets
+ * Converts provider transaction output asset data into TransactionOutputAssetRow format
+ * @param txHash transaction hash
+ * @param outputs transaction outputs from provider
+ * @returns {TransactionOutputAssetRow[]} mapped transaction output asset rows
+ */
+function mapTransactionOutputAssets(txHash, outputs) {
+    return outputs.flatMap((output, idx) => {
+        const outputIndex = output.outputIndex ?? idx;
+        if (!Array.isArray(output.amount))
+            return [];
+        return output.amount.map(a => {
+            const { policyId, assetName } = parseAssetUnit(a.unit);
+            return {
+                output_tx_hash: txHash,
+                output_outputIndex: outputIndex,
+                unit: a.unit,
+                asset_quantity: Number(a.quantity),
+                asset_policyId: policyId,
+                asset_assetName: assetName,
+            };
+        });
+    });
+}
+/**
+ * Map Address Data
+ * Converts provider address data into AddressRow format
+ * @param address address string
+ * @param addressData address data from provider
+ * @returns {AddressRow} mapped address row
+ */
+function mapAddress(address, addressData, maxAge) {
+    const now = Date.now();
+    const nowIso = new Date(now).toISOString();
+    const validToIso = new Date(now + maxAge).toISOString();
+    const totalLovelace = Array.isArray(addressData.amount)
+        ? Number(addressData.amount.find((a) => a.unit === 'lovelace')?.quantity)
+        : 0;
+    const hasUtxos = Array.isArray(addressData.utxos) && addressData.utxos.length > 0;
+    const hasAssets = Array.isArray(addressData.amount) && addressData.amount.length > 0;
+    // Transactions are loaded separately via getAddressTransactions() - set to false initially
+    // Will be updated when transactions are indexed
+    const hasTransactions = false;
+    return {
+        address,
+        stakeAddress: addressData.stakeAddress || null,
+        type: addressData.type ?? 'base',
+        isScript: addressData.isScript ?? false,
+        totalLovelace: totalLovelace,
+        validFrom: nowIso,
+        validTo: validToIso,
+        hasAssets: hasAssets,
+        hasUTxOs: hasUtxos,
+        hasTransactions: hasTransactions,
+    };
+}
+/**
+ * Map Address Transactions
+ * Converts provider address transaction data into AddressTransactionRow format
+ * @param addr address string
+ * @param addressTxsData address transactions data from provider
+ * @returns {AddressTransactionRow[]} mapped address transaction rows
+ *  */
+function mapAddressTransactions(addr, addressTxsData, validFrom, validTo) {
+    return addressTxsData.map((tx) => {
+        // Calculate net amounts for this address in this transaction
+        const { netLovelace, netAssets } = calculateNetAmounts(addr, tx);
+        return {
+            address_address: addr,
+            tx_hash: tx.hash,
+            netAmount: netLovelace,
+            blockTime: tx.blockTime,
+            netAssets: netAssets.length > 0 ? JSON.stringify(netAssets) : null,
+            hasAssets: netAssets.length > 0,
+            validFrom: validFrom,
+            validTo: validTo,
+        };
+    });
+}
+/**
+ * Calculate net lovelace and asset changes for an address in a transaction
+ * @param addr the address to calculate for
+ * @param tx the transaction data
+ * @returns object with netLovelace and netAssets array
+ */
+function calculateNetAmounts(addr, tx) {
+    let inputLovelace = 0;
+    let outputLovelace = 0;
+    const assetBalances = new Map(); // unit -> net quantity
+    // Process inputs belonging to this address (subtract)
+    for (const input of tx.inputs || []) {
+        if (input.address === addr) {
+            for (const amount of input.amount || []) {
+                if (amount.unit === 'lovelace') {
+                    inputLovelace += parseInt(amount.quantity, 10) || 0;
+                }
+                else {
+                    // Native asset
+                    const current = assetBalances.get(amount.unit) || BigInt(0);
+                    assetBalances.set(amount.unit, current - BigInt(amount.quantity));
+                }
+            }
+        }
+    }
+    // Process outputs going to this address (add)
+    for (const output of tx.outputs || []) {
+        if (output.address === addr) {
+            for (const amount of output.amount || []) {
+                if (amount.unit === 'lovelace') {
+                    outputLovelace += parseInt(amount.quantity, 10) || 0;
+                }
+                else {
+                    // Native asset
+                    const current = assetBalances.get(amount.unit) || BigInt(0);
+                    assetBalances.set(amount.unit, current + BigInt(amount.quantity));
+                }
+            }
+        }
+    }
+    // Convert asset map to array, filtering out zero balances
+    const netAssets = [];
+    for (const [unit, quantity] of assetBalances) {
+        if (quantity !== BigInt(0)) {
+            // Parse unit into policyId and assetName
+            // Format: policyId (56 chars) + assetNameHex
+            const policyId = unit.substring(0, 56);
+            const assetNameHex = unit.substring(56);
+            const assetName = hexToUtf8(assetNameHex);
+            netAssets.push({
+                unit,
+                policyId,
+                assetName,
+                assetNameHex,
+                quantity: quantity.toString()
+            });
+        }
+    }
+    return {
+        netLovelace: outputLovelace - inputLovelace,
+        netAssets
+    };
+}
+/**
+ * Map Address UTxOs
+ * @param addr address string
+ * @param validFrom validFrom
+ * @param validTo validTo
+ * @param addressUtxosData address UTxOs data from provider
+ * @returns {AddressUTxORow[]} mapped address UTxO rows
+ */
+function mapAddressUtxos(addr, validFrom, validTo, addressUtxosData) {
+    return addressUtxosData.map((utxo) => {
+        const lovelace = Number(utxo.amount.find((a) => a.unit === 'lovelace')?.quantity ?? 0);
+        const hasAssets = Array.isArray(utxo.amount) && utxo.amount.some((a) => a.unit !== 'lovelace');
+        return {
+            address_address: addr,
+            hash: utxo.txHash,
+            index: utxo.outputIndex,
+            blockHash: utxo.blockHash,
+            utxodata_dataHash: utxo.datumHash,
+            utxodata_inlineDatum: null,
+            utxodata_referenceScriptHash: utxo.scriptRef,
+            lovelace: lovelace,
+            validFrom: validFrom,
+            validTo: validTo,
+            hasAssets: hasAssets,
+        };
+    });
+}
+/**
+ * Map Address Assets
+ * Converts provider address asset data into AddressAssetRow format
+ * @param addr address string
+ * @param validFrom validFrom
+ * @param validTo validTo
+ * @param AssetAssets address assets from provider
+ * @returns {AddressAssetRow[]} mapped address asset rows
+ */
+function mapAddressAssets(addr, validFrom, validTo, AssetAssets) {
+    return AssetAssets
+        .filter((asset) => asset.unit !== 'lovelace')
+        .map((asset) => {
+        const { policyId, assetName } = parseAssetUnit(asset.unit);
+        return {
+            address_address: addr,
+            unit: asset.unit,
+            validFrom: validFrom,
+            validTo: validTo,
+            asset_quantity: Number(asset.quantity),
+            asset_policyId: policyId,
+            asset_assetName: assetName,
+        };
+    });
+}
+/**
+ * Map UTxO Assets
+ * Converts provider address UTxO asset data into UTxOAssetRow format
+ * @param addressUtxosData address UTxOs data from provider
+ * @param validFrom validFrom
+ * @param validTo validTo
+ * @returns {UTxOAssetRow[]} mapped UTxO asset rows
+ */
+function mapAddressUtxoAssets(addressUtxosData, validFrom, validTo) {
+    const assets = [];
+    addressUtxosData.forEach((utxo) => {
+        for (const asset of utxo.amount) {
+            if (!asset || !asset.unit || asset.unit === 'lovelace')
+                continue;
+            const { policyId, assetName } = parseAssetUnit(asset.unit);
+            assets.push({
+                utxo_address_address: utxo.address,
+                utxo_hash: utxo.txHash,
+                utxo_index: utxo.outputIndex,
+                unit: asset.unit,
+                validFrom: validFrom,
+                validTo: validTo,
+                asset_quantity: Number(asset.quantity),
+                asset_policyId: policyId,
+                asset_assetName: assetName,
+            });
+        }
+    });
+    return assets;
+}
+/**
+ * Map Network Information
+ * Converts provider network information data into NetworkInfoRow format
+ * @param providerNetworkData
+ * @returns {NetworkInfoRow} mapped network information row
+ */
+function mapNetworkInfo(providerNetworkData, max_age, network) {
+    const now = Date.now();
+    const nowIso = new Date(now).toISOString();
+    const validToIso = new Date(now + max_age).toISOString();
+    return {
+        network: network,
+        validFrom: nowIso,
+        validTo: validToIso,
+        maxSupply: Number(providerNetworkData.supply.max),
+        circulatingSupply: Number(providerNetworkData.supply.circulating),
+        totalSupply: Number(providerNetworkData.supply.total),
+        lockedSupply: Number(providerNetworkData.supply.locked),
+        treasurySupply: Number(providerNetworkData.supply.treasury),
+        reservesSupply: Number(providerNetworkData.supply.reserves),
+        liveStake: Number(providerNetworkData.stake.live),
+        activeStake: Number(providerNetworkData.stake.active),
+    };
+}
+/**
+ * Map Block Data
+ * Converts provider block data into BlockRow format
+ * @param providerBlockData block data from provider
+ * @param epochData epoch data for the block's epoch
+ * @returns {BlockRow} mapped block row
+ */
+function mapBlock(providerBlockData, epochData) {
+    return {
+        time: new Date(providerBlockData.time * 1000).toISOString(),
+        height: providerBlockData.height,
+        hash: providerBlockData.hash,
+        slotLeader: String(providerBlockData.slot ?? null),
+        epochNumber: epochData.epoch,
+        epoch: epochData,
+        epochSlot: providerBlockData.epochSlot,
+        size: providerBlockData.size,
+        txCount: providerBlockData.txCount,
+        fees: Number(providerBlockData.fees),
+    };
+}
+/**
+ * Map Epoch Data
+ * Converts provider epoch data into EpochRow format
+ * @param providerEpochData epoch data from provider
+ * @returns {EpochRow} mapped epoch row
+ */
+function mapEpoch(providerEpochData) {
+    return {
+        epoch: providerEpochData.epoch,
+        startTime: providerEpochData.start_time,
+        endTime: providerEpochData.end_time,
+        firstBlockTime: providerEpochData.first_block_time,
+        lastBlockTime: providerEpochData.last_block_time,
+        blockCount: providerEpochData.block_count,
+        txCount: providerEpochData.tx_count,
+        output: providerEpochData.output,
+        fees: Number(providerEpochData.fees),
+        activeStake: Number(providerEpochData.active_stake),
+    };
+}
+/**
+ * Map Transaction Metadata
+ * Converts provider transaction metadata labels into TransactionMetadataRow format
+ * @param providerLabels array of metadata label data from provider
+ * @returns {TransactionMetadataRow[]} mapped transaction metadata rows
+ */
+function mapTransactionMetadata(providerLabels) {
+    const rows = [];
+    for (const [idx, lbl] of providerLabels.entries()) {
+        rows.push({
+            id: idx,
+            tx_hash: lbl.txHash,
+            label: lbl.label.toString(),
+            payload: lbl.json !== undefined ? JSON.stringify(lbl.json) : null,
+        });
+    }
+    return rows;
+}
+/**
+ * Map Pool Data
+ * Converts provider pool data into PoolRow format
+ * @param providerPoolData pool data from provider
+ * @returns {PoolRow} mapped pool row
+ */
+function mapPool(providerPoolData) {
+    return {
+        poolId: providerPoolData.poolId,
+        vrfKeyHash: providerPoolData.vrfKeyHash,
+        blocksMinted: providerPoolData.blocksMinted,
+        blocksEpoch: providerPoolData.blocksEpoch,
+        liveStake: Number(providerPoolData.liveStake),
+        liveSize: providerPoolData.liveSize,
+        liveDelegators: providerPoolData.liveDelegators,
+        liveSaturation: providerPoolData.liveSaturation,
+        activeStake: Number(providerPoolData.activeStake),
+        activeSize: providerPoolData.activeSize,
+        pledge: Number(providerPoolData.pledge),
+        margin: Number(providerPoolData.margin),
+        fixedCost: Number(providerPoolData.fixedCost),
+        rewardAccount: providerPoolData.rewardAccount,
+    };
+}
+/**
+ * Map Drep Data
+ * Converts provider drep data into DrepRow format
+ * @param providerDrepData drep data from provider
+ * @returns {DrepRow} mapped drep row
+ */
+function mapDrep(providerDrepData) {
+    return {
+        drepId: providerDrepData.drepId,
+        hex: providerDrepData.hex,
+        amount: Number(providerDrepData.amount),
+        hasScript: Boolean(providerDrepData.hasScript),
+        lastActiveEpoch: providerDrepData.lastActiveEpoch,
+        retired: Boolean(providerDrepData.retired),
+        expired: Boolean(providerDrepData.expired),
+    };
+}
+/**
+ * Map Account Data
+ * Converts provider account data into AccountRow format
+ * @param providerAccountData account data from provider
+ * @returns {AccountRow} mapped account row
+ */
+function mapAccount(providerAccountData, max_age) {
+    const validFrom = new Date().toISOString();
+    const validTo = new Date(Date.now() + max_age).toISOString();
+    return {
+        validFrom: validFrom,
+        validTo: validTo,
+        stakeAddress: providerAccountData.stakeaddress,
+        active: providerAccountData.active,
+        activeEpoch: providerAccountData.activeEpoch,
+        controlledAmount: Number(providerAccountData.controlledAmount),
+        rewardsSum: Number(providerAccountData.rewardsSum),
+        withdrawalsSum: Number(providerAccountData.withdrawalsSum),
+        reservesSum: Number(providerAccountData.reservesSum),
+        treasurySum: Number(providerAccountData.treasurySum),
+        withdrawableAmount: Number(providerAccountData.withdrawableAmount),
+        hasAddresses: providerAccountData.addresses.length > 0,
+    };
+}
+/**
+ * Map Backend Error
+ * Converts BackendError or unknown error into OData request rejection
+ * @param req OData request
+ * @param err error object (BackendError or unknown)
+ * @param ctx context string for error message
+ */
+function mapError(req, err, ctx) {
+    if (err instanceof errors_1.BackendError) {
+        return req.reject(err.statusCode, fmt(err.code, ctx, err.message), err.target);
+    }
+    // Handle non-BackendError (plain Error, string, etc.)
+    const message = err instanceof Error ? err.message : String(err);
+    return req.reject(500, fmt('INTERNAL_ERROR', ctx, message));
+}
+/**
+ * Map Transaction Build Result
+ * Converts provider transaction build result into TransactionBuildRow format
+ * @param txbuildResult transaction build result from provider
+ * @returns {TransactionBuildRow} mapped transaction build row
+ */
+function mapBuildResult(txbuildResult, max_age) {
+    const buildId = cds_1.default.utils.uuid();
+    const now = Math.floor(Date.now() / 1000);
+    const validFrom = new Date().toISOString();
+    const validTo = new Date(Date.now() + max_age).toISOString();
+    const hasInputs = Array.isArray(txbuildResult.inputs) && txbuildResult.inputs.length > 0;
+    const hasOutputs = Array.isArray(txbuildResult.outputs) && txbuildResult.outputs.length > 0;
+    return {
+        id: buildId,
+        validFrom: validFrom,
+        validTo: validTo,
+        builderEngine: txbuildResult.builderEngine,
+        network: txbuildResult.network,
+        senderAddress: txbuildResult.senderAddress,
+        changeAddress: txbuildResult.senderAddress,
+        unsignedTxCbor: txbuildResult.unsignedTxCbor,
+        txBodyHash: txbuildResult.txBodyHash,
+        fee: Number(txbuildResult.feeLovelace),
+        size: txbuildResult.sizeBytes, // size in bytes
+        createdAt: now, // epoch seconds
+        submission: null,
+        hasInputs: hasInputs, // indicates if build has inputs
+        hasOutputs: hasOutputs, // indicates if build has outputs
+        wasSubmitted: false, // indicates if this build was submitted
+    };
+}
+/**
+ * Map Transaction Build Inputs
+ * Converts transaction build result inputs into TransactionBuildInputRow format
+ * @param buildId the transaction build ID
+ * @param inputs transaction build result inputs
+ * @returns {TransactionBuildInputRow[]} mapped transaction build input rows
+ */
+function mapBuildInputs(buildId, inputs) {
+    return inputs.map((input, idx) => ({
+        build_id: buildId,
+        inputIndex: idx,
+        txHash: input.txHash,
+        outputIndex: input.index,
+        address: input.address || null,
+        lovelace: Number(input.lovelace),
+        hasAssets: false, // simple ADA transfers don't have assets
+    }));
+}
+/**
+ * Map Transaction Build Outputs
+ * Converts transaction build result outputs into TransactionBuildOutputRow format
+ * @param buildId the transaction build ID
+ * @param outputs transaction build result outputs
+ * @param changeAddress the change address to identify change outputs
+ * @returns {TransactionBuildOutputRow[]} mapped transaction build output rows
+ */
+function mapBuildOutputs(buildId, outputs, changeAddress) {
+    return outputs.map((output, idx) => ({
+        build_id: buildId,
+        outputIndex: idx,
+        address: output.address,
+        lovelace: Number(output.lovelace),
+        isChange: changeAddress ? output.address === changeAddress : false,
+        hasAssets: false, // simple ADA transfers don't have assets
+    }));
+}
+/**
+ * Map Protocol Parameters
+ * Converts provider protocol parameters into ProtocolParameterRow format
+ * @param providerParams protocol parameters from provider
+ * @returns {ProtocolParameterRow} mapped protocol parameter row
+ */
+function mapProtocolParameters(providerParams) {
+    return {
+        network: providerParams.network,
+        epoch: providerParams.epoch,
+        minFeeA: providerParams.minFeeA,
+        minFeeB: providerParams.minFeeB,
+        maxBlockSize: providerParams.maxBlockSize,
+        maxTxSize: providerParams.maxTxSize,
+        maxBlockHeaderSize: providerParams.maxBlockHeaderSize,
+        keyDeposit: providerParams.keyDeposit,
+        poolDeposit: providerParams.poolDeposit,
+        eMax: providerParams.eMax,
+        nOpt: providerParams.nOpt,
+        a0: providerParams.a0,
+        rho: providerParams.rho,
+        tau: providerParams.tau,
+        minPoolCost: providerParams.minPoolCost,
+        decentralisationParam: providerParams.decentralisationParam,
+        extraEntropy: providerParams.extraEntropy,
+        protocolMajorVer: providerParams.protocolMajorVer,
+        protocolMinorVer: providerParams.protocolMinorVer,
+        minUtxo: providerParams.minUtxo,
+        nonce: providerParams.nonce,
+        costModels: providerParams.costModels,
+        priceMem: providerParams.priceMem,
+        priceStep: providerParams.priceStep,
+        maxTxExMem: providerParams.maxTxExMem,
+        maxTxExSteps: providerParams.maxTxExSteps,
+        maxBlockExMem: providerParams.maxBlockExMem,
+        maxBlockExSteps: providerParams.maxBlockExSteps,
+        maxValSize: providerParams.maxValSize,
+        collateralPercent: providerParams.collateralPercent,
+        maxCollateralInputs: providerParams.maxCollateralInputs,
+        coinsPerUtxoSize: providerParams.coinsPerUtxoSize,
+        fetchedAt: providerParams.fetchedAt,
+        source: providerParams.source,
+    };
+}
+/**
+ * Map Transaction Submission
+ * Converts signed transaction CBOR and hash into TransactionSubmissionRow format
+ * @param signedTxCbor signed transaction in CBOR hex format
+ * @param txHash transaction hash
+ * @returns {TransactionSubmissionRow} mapped transaction submission row
+ */
+function mapTransactionSubmission(signedTxCbor, txHash) {
+    const now = Math.floor(Date.now() / 1000);
+    return {
+        signedTxCbor: signedTxCbor,
+        txHash: txHash,
+        submittedAt: now,
+    };
+}
+/**
+ * Map Address Signing Requests
+ * Creates AddressSigningRequest row for address-signing request association
+ * @param addr bech32 address
+ * @param signingRequestId signing request UUID
+ * @returns {AddressSigningRequestRow} mapped address signing request row
+ */
+function mapAddressSigningRequest(addr, signingRequestId) {
+    return {
+        address_address: addr,
+        signingRequest_id: signingRequestId,
+    };
+}
+/**
+ * Map Address Transaction Builds
+ * Creates AddressTransactionBuild row for address-build association
+ * @param addr bech32 address
+ * @param buildId transaction build UUID
+ * @returns {AddressTransactionBuildRow} mapped address transaction build row
+ */
+function mapAddressTransactionBuild(addr, buildId) {
+    return {
+        address_address: addr,
+        txBuild_id: buildId,
+    };
+}
+//-----------------------------------------------------------------------
+// Helper Functions
+//-----------------------------------------------------------------------
+/**
+ * Convert hex string to UTF-8 string, falling back to hex if conversion fails.
+ * This helper reduces code duplication and improves performance by centralizing
+ * the conversion logic.
+ *
+ * @param hex - Hexadecimal string to convert
+ * @returns {string} UTF-8 string or original hex if conversion fails
+ */
+function hexToUtf8(hex) {
+    if (!hex)
+        return hex;
+    return Buffer.from(hex, 'hex').toString('utf8');
+}
+/**
+ * Parse asset unit (policyId + assetNameHex) into components.
+ * Optimizes repeated parsing logic across multiple mapper functions.
+ * @param unit - Asset unit string (56 char policyId + asset name hex)
+ * @returns { policyId: string | null; assetName: string | null } Object with policyId and assetName
+ */
+function parseAssetUnit(unit) {
+    if (unit === 'lovelace') {
+        return { policyId: null, assetName: 'lovelace' };
+    }
+    const policyId = unit.slice(0, 56);
+    const assetNameHex = unit.slice(56);
+    const assetName = hexToUtf8(assetNameHex);
+    return { policyId, assetName };
+}
+/**
+ * Format error message
+ * @param code error code
+ * @param ctx context string
+ * @param msg error message
+ * @returns {string} formatted error message
+ */
+function fmt(code, ctx, msg) {
+    return `[${code}] ${ctx}: ${msg}`;
+}
+//# sourceMappingURL=mappers.js.map