import {
    AppWallet,
    Converter,
    NETWORK_ID,
    ProviderUtils,
    UTxO,
    UTxOObject
} from '@hydra-sdk/core'
import axios from 'axios'

// Blockfrost provider (preprod)
const blockfrostProvider = new ProviderUtils.BlockfrostProvider({
    apiKey: process.env.BLOCKFROST_PROVIDER_API_KEY || '',
    network: 'preprod'
})

// Wallet (test wallet)
export const wallet = new AppWallet({
    key: {
        type: 'mnemonic',
        words: 'your test mnemonic words here ...'.split(' ')
    },
    networkId: NETWORK_ID.PREPROD,
    fetcher: blockfrostProvider.fetcher,
    submitter: blockfrostProvider.submitter
})

export const walletAddress = wallet.getAccount().baseAddressBech32

// Hydra endpoints
export const hydraConfig = {
    httpUrl: 'http://localhost:10005',
    wsUrl: 'ws://localhost:10005'
}

export type DepositToken = [string, Record<string, number>]

// Minimal API wrapper
export class HydraApi {
    static instance = axios.create({
        baseURL: hydraConfig.httpUrl,
        headers: { 'Content-Type': 'application/json' }
    })

    static async queryAddressUTxO(address: string): Promise<UTxO[]> {
        try {
            const utxos = await this.instance.get('/snapshot/utxo')
            const utxoObj = utxos.data as Record<string, any>
            return Converter.convertUTxOObjectToUTxO(utxoObj).filter(
                u => u.output.address === address
            )
        } catch (error) {
            console.error('Error querying address UTxO:', error)
            return []
        }
    }

    static async partialDeposit(
        blueprintTxCbor: string,
        utxo: UTxOObject,
        changeAddress: string
    ) {
        try {
            const response = await this.instance.post('/commit', {
                blueprintTx: {
                    cborHex: blueprintTxCbor,
                    type: 'Tx ConwayEra',
                    description: 'Partial commit from NodeJS Playground'
                },
                utxo,
                changeAddress
            })
            return response.data as {
                cborHex: string
                description: string
                txId: string
                type: 'Tx ConwayEra'
            }
        } catch (error) {
            console.error('Error during partial deposit:', error)
            throw error
        }
    }

    static async commit(utxo: UTxOObject) {
        try {
            const response = await this.instance.post('/commit', {
                ...utxo
            })
            return response.data as {
                cborHex: string
                description: string
                txId: string
                type: 'Tx ConwayEra'
            }
        } catch (error) {
            console.error('Error during commit:', error)
            throw error
        }
    }
}

import { CardanoWASM } from '@hydra-sdk/cardano-wasm'
import { wallet } from './common'
import { Converter, Deserializer, hexToString } from '@hydra-sdk/core'
import BigNumber from 'bignumber.js'

async function main(address?: string) {
    const utxos = await wallet.queryUTxOs(
        address || wallet.getAccount().baseAddressBech32
    )
    console.log(
        '>>> UTxOs:',
        JSON.stringify(Converter.convertUTxOToUTxOObject(utxos), null, 2)
    )
    const totalLovelace = utxos.reduce(
        (a, b) =>
            a + Number(b.output.amount.find(x => x.unit === 'lovelace')?.quantity || 0),
        0
    )
    console.log(
        '>>> Total lovelace:',
        BigNumber(totalLovelace).toFormat(),
        'lovelace',
        ' => ',
        (Number(totalLovelace) / 1_000_000).toFixed(6),
        'ADA'
    )
    const totalAssets = utxos.reduce(
        (acc, utxo) => {
            utxo.output.amount.forEach(a => {
                if (a.unit !== 'lovelace') {
                    if (!acc[a.unit]) {
                        acc[a.unit] = 0
                    }
                    acc[a.unit] += Number(a.quantity)
                }
            })
            return acc
        },
        {} as Record<string, number>
    )
    console.log('>>> Total assets:', Object.keys(totalAssets).length)
    for (const [unit, quantity] of Object.entries(totalAssets)) {
        const { policyId, assetName } = Deserializer.deserializeAssetUnit(unit)
        console.log(
            `  - ${policyId}${assetName ? '.' + assetName : ''}: ${BigNumber(quantity).toFormat()} ${hexToString(assetName)}`
        )
    }
}

if (process.argv[2] && typeof process.argv[2] === 'string') {
    const address = process.argv[2]
    try {
        CardanoWASM.Address.from_bech32(address)
    } catch (error) {
        console.error('>>> address is invalid:', error)
        process.exit(1)
    }
} else {
    main()
}

import { HydraApi, wallet } from './common'

async function main() {
    // Empty commit: send commit request without specifying concrete UTxOs
    const commitTx = await HydraApi.commit({} as any)
    if (commitTx) {
        const signedTx = await wallet.signTx(commitTx.cborHex, true)
        console.log('Signed commit tx:', signedTx)
        // Submit the signed CBOR to the Hydra node (if needed)
        const result = await HydraApi.submitCardanoTx({
            cborHex: signedTx,
            description: 'Empty commit from NodeJS Playground',
            type: 'Witnesses Tx ConwayEra'
        })
    }
}

main()

import { Converter, UTxOObject } from '@hydra-sdk/core'
import { HydraApi, wallet, walletAddress } from './common'

async function main() {
    // 1) Prepare the specific UTxO to commit
    const utxoToCommit: UTxOObject = {
        'c2e3452de098d13ae536c3fb9df599d119631d618aaa2738522aeced2d2a1ac2#0': {
            address:
                'addr_test1qpxsf0x8xypuhq5k408f9kh0meyy6jv2lxgqw2fefvjlte0u06dugtmxuhhw8hschdn4q59g64q5s9z42ax6qyg7ewsqt6e548',
            datum: null,
            datumhash: null,
            inlineDatum: null,
            inlineDatumRaw: null,
            referenceScript: null,
            value: {
                lovelace: 1327480,
                e16c2dc8ae937e8d3790c7fd7168d7b994621ba14ca11415f39fed72: {
                    '4d494e': 2000000000
                },
                fef67460342d081cb7881318b1f33b87626d1a1042b4c2acbbc0725d: {
                    '7441424f': 1000000
                }
            }
        }
    }

    // 2) Call commit with the specific UTxO
    const result = await HydraApi.commit(utxoToCommit)

    if (result) {
        const signedTx = await wallet.signTx(result.cborHex, true)
        console.log('Signed commit tx:', signedTx)

        // 3) Submit the signed CBOR to the Hydra node
        const submitResult = await HydraApi.submitCardanoTx({
            cborHex: signedTx,
            description: 'Commit specific UTxO from NodeJS Playground',
            type: 'Witnesses Tx ConwayEra'
        })
    }
}

main()

import { Converter, Deserializer, Resolver, UTxO } from '@hydra-sdk/core'
import { HydraApi, wallet, walletAddress } from './common'
import { TxBuilder } from '@hydra-sdk/transaction'

/**
 * Partial commit example
 * 1. Make sure you have some assets in your wallet
 * 2. Run this script to create a partial commit transaction
 * 3. Sign the transaction and submit it to Hydra node
 *
 * Note: Build the blueprint transaction
 * - https://hydra.iohk.io/docs/hydra-node/tutorials/blueprint-tx/
 * - The outputs of the blueprint transaction will be used as inputs for the partial commit transaction
 *
 * Command:
 * > npx tsx src/hydra/partial-commit.ts
 */
async function main() {
    console.log('>>> walletAddress:', walletAddress)
    const l1UTxOs = await wallet.queryUTxOs(walletAddress)

    const depositLovelace = 180_000_000 // 180 ADA
    // assets to deposit
    const depositAssetUnits = [
        {
            unit: 'e16c2dc8ae937e8d3790c7fd7168d7b994621ba14ca11415f39fed724d494e',
            quantity: '1000000' // 1,000,000 token units
        }
    ]

    // check if asset exists in the wallet
    const hasAsset = l1UTxOs.some(utxo =>
        utxo.output.amount.some(a => depositAssetUnits.findIndex(b => b.unit === a.unit) >= 0)
    )
    if (!hasAsset) {
        throw new Error(`No asset ${depositAssetUnits.join(', ')} found in the wallet`)
    }

    const txBuilder = new TxBuilder({
        errorLogger: true,
        isHydra: true,
        params: {
            minFeeA: 0,
            minFeeB: 0
        }
    })

    // build the blueprint transaction
    const blueprintTx = await txBuilder
        .setInputs(l1UTxOs)
        .addOutput({
            address: walletAddress,
            amount: [{ unit: 'lovelace', quantity: depositLovelace.toString() }, ...depositAssetUnits]
        })
        .setFee('0')
        .complete()

    console.log('>>> blueprintTx.to_hex():', blueprintTx.to_hex())
    const txHash = Resolver.resolveTxHash(blueprintTx.to_hex())
    console.log('>>> txHash:', txHash)

    const txInputs = Deserializer.deserializeTx(blueprintTx.to_hex()).body().inputs()
    const utxoToCommit: UTxO[] = []
    for (let i = 0; i < txInputs.len(); i++) {
        const input = txInputs.get(i)
        if (input) {
            const utxo = l1UTxOs.find(
                u => u.input.txHash === input.transaction_id().to_hex() && u.input.outputIndex === input.index()
            )
            if (utxo) {
                utxoToCommit.push(utxo)
            }
        }
    }

    const partialCommitResult = await HydraApi.partialDeposit(
        blueprintTx.to_hex(),
        Converter.convertUTxOToUTxOObject(utxoToCommit),
        walletAddress
    )
    if (partialCommitResult) {
        const signedTx = await wallet.signTx(partialCommitResult.cborHex, true)
        console.log('>>> Signed partial commit tx:', { ...partialCommitResult, cborHex: signedTx })
    }
}

main()