import { AppWallet } from '@hydra-sdk/core'

// Generate 24-word mnemonic (default)
const mnemonic24 = AppWallet.brew(256)

// Generate 12-word mnemonic
const mnemonic12 = AppWallet.brew(128)

// Generate 15-word mnemonic
const mnemonic15 = AppWallet.brew(160)

console.log('New mnemonic:', mnemonic24)
// => "abandon abandon ... zone"

import { AppWallet, NETWORK_ID, ProviderUtils } from '@hydra-sdk/core'

const blockfrostProvider = new ProviderUtils.BlockfrostProvider({
  apiKey: 'your-blockfrost-api-key',
  network: 'preprod'
})

const wallet = new AppWallet({
  networkId: NETWORK_ID.PREPROD,
  key: { type: 'mnemonic', words: ['word1', 'word2', ...] },
  fetcher: blockfrostProvider.fetcher,
  submitter: blockfrostProvider.submitter
})

// Get first account (account 0, address 0)
const account = wallet.getAccount(0, 0)

console.log({
  // Address information
  baseAddressBech32: account.baseAddressBech32,
  enterpriseAddressBech32: account.enterpriseAddressBech32,
  rewardAddressBech32: account.rewardAddressBech32,
  
  // Key information
  paymentKey: account.paymentKey,
  stakeKey: account.stakeKey,
  
  // Indices
  accountIndex: account.accountIndex,
  addressIndex: account.addressIndex
})

// Default: account 0, address 0
const defaultAccount = wallet.getAccount()

const baseAddr = wallet.getPaymentAddress(0, 0)
console.log('Base address:', baseAddr)
// => "addr_test1qz2fxv2umyhttkxyxp8x0..."

const enterpriseAddr = wallet.getEnterpriseAddress(0, 0)
console.log('Enterprise address:', enterpriseAddr)
// => "addr_test1vz2fxv2umyhttkxyxp8x0..."

const rewardAddr = wallet.getRewardAddress(0, 0)
console.log('Reward address:', rewardAddr)
// => "stake_test1uqz2fxv2umyhttkxyxp8x0..."

const networkId = wallet.getNetworkId()
console.log('Network ID:', networkId)
// => 0 (Preprod testnet) or 1 (Mainnet)

// Full signing
const signedTx = await wallet.signTx(unsignedTxCbor, false, 0, 0)

// Partial signing (multi-sig)
const partialSigned = await wallet.signTx(unsignedTxCbor, true, 0, 0)

console.log('Signed transaction:', signedTx)

const signedTxs = await wallet.signTxs(
  [txCbor1, txCbor2, txCbor3],
  false
)

console.log('Signed transactions:', signedTxs)

const signature = await wallet.signData(
  'addr_test1qz2fxv2umyhttkxyxp8x0...',
  'Hello World',
  0,
  0
)

console.log('Data signature:', signature)
// => { signature: '...', key: '...' }

const txHash = await wallet.submitTx(signedTxCbor)
console.log('Transaction hash:', txHash)
// => "a1b2c3d4e5f6..."

const address = wallet.getPaymentAddress()
const utxos = await wallet.queryUTxOs(address)

console.log('UTxOs:', utxos)
// => [{ input: { txHash: '...', index: 0 }, output: { address: '...', amount: [...] } }, ...]

import { EmbeddedWallet } from '@hydra-sdk/core'

const mnemonic = EmbeddedWallet.generateMnemonic(256)
console.log('Mnemonic:', mnemonic)

const privateKeyHex = EmbeddedWallet.mnemonicToPrivateKeyHex(
  ['abandon', 'abandon', ...],
  ''
)
console.log('Private key:', privateKeyHex)

const bech32Key = EmbeddedWallet.privateKeyHexToBech32(privateKeyHex)
console.log('Bech32 key:', bech32Key)

const hexKey = EmbeddedWallet.privateKeyBech32ToPrivateKeyHex('xprv1...')
console.log('Hex key:', hexKey)

import { CardanoCliWallet, NETWORK_ID, ProviderUtils } from '@hydra-sdk/core'

const blockfrostProvider = new ProviderUtils.BlockfrostProvider({
  apiKey: 'your-blockfrost-api-key',
  network: 'preprod'
})

const cliWallet = new CardanoCliWallet({
  networkId: NETWORK_ID.PREPROD,
  skey: '5820245120cdf333f8ea6910922b3f05bcbc0d5c8e8486ca94c020623d5cca822e04',
  vkey: '5820216f72947d1b97d56825c5f9f8a2e6f14234c02171853264f2f552a2685b25e0',
  fetcher: blockfrostProvider.fetcher,
  submitter: blockfrostProvider.submitter
})

const address = cliWallet.getAddressBech32()
console.log('Wallet address:', address)

const networkId = cliWallet.getNetworkId()
console.log('Network ID:', networkId) // 0 or 1

const signedTx = await cliWallet.signTx(unsignedTxCbor, false)
console.log('Signed transaction:', signedTx)

const txHash = await cliWallet.submitTx(signedTxCbor)
console.log('Transaction hash:', txHash)

const address = cliWallet.getAddressBech32()
const utxos = await cliWallet.queryUTxOs(address)
console.log('UTxOs:', utxos)

import { ProviderUtils } from '@hydra-sdk/core'

const blockfrostProvider = new ProviderUtils.BlockfrostProvider({
  apiKey: 'your-blockfrost-api-key',
  network: 'preprod' // or 'mainnet'
})

// Access fetcher and submitter
const fetcher = blockfrostProvider.fetcher
const submitter = blockfrostProvider.submitter

// Use with wallet
const wallet = new AppWallet({
  networkId: NETWORK_ID.PREPROD,
  key: { type: 'mnemonic', words: mnemonic },
  fetcher: blockfrostProvider.fetcher,
  submitter: blockfrostProvider.submitter
})

import { ProviderUtils } from '@hydra-sdk/core'

const ogmiosProvider = new ProviderUtils.OgmiosProvider({
  apiEndpoint: 'https://preprod.cardano-rpc.hydrawallet.app',
  network: 'preprod' // or 'mainnet'
})

// Access fetcher and submitter
const fetcher = ogmiosProvider.fetcher
const submitter = ogmiosProvider.submitter

// Use with wallet
const wallet = new AppWallet({
  networkId: NETWORK_ID.PREPROD,
  key: { type: 'mnemonic', words: mnemonic },
  fetcher: ogmiosProvider.fetcher,
  submitter: ogmiosProvider.submitter
})

import { getPubkeyHashFromAddress } from '@hydra-sdk/core'

const pubkeyHash = getPubkeyHashFromAddress('addr_test1qz2fxv2umyhttkxyxp8x0...')
console.log('Public key hash:', pubkeyHash)
// => "00000000000000000000000000000000000000000000000000000000"

import { isValidAddress } from '@hydra-sdk/core'

const isValid = isValidAddress('addr_test1qz2fxv2umyhttkxyxp8x0...')
console.log('Valid:', isValid) // => true or false

import { isValidTxOutput } from '@hydra-sdk/core'

const isValid = isValidTxOutput(txOutput)
console.log('Output valid:', isValid)

import { slotToBeginUnixTime } from '@hydra-sdk/core'

const unixTime = slotToBeginUnixTime(45700800)
console.log('Unix time:', unixTime)
// => 1671292800000 (milliseconds)

import { unixTimeToEnclosingSlot } from '@hydra-sdk/core'

const slot = unixTimeToEnclosingSlot(Date.now())
console.log('Current slot:', slot)

import { resolveSlotNo } from '@hydra-sdk/core'

const slotNo = resolveSlotNo(Date.now())
console.log('Slot number:', slotNo)

import { resolveEpochNo } from '@hydra-sdk/core'

const epochNo = resolveEpochNo(Date.now())
console.log('Epoch number:', epochNo)

import { buildHydraSlotConfig } from '@hydra-sdk/core'

const config = buildHydraSlotConfig()
console.log('Slot config:', config)

import { buildPolicyScriptFromPubkey } from '@hydra-sdk/core'

const policyScript = buildPolicyScriptFromPubkey('a1b2c3...')
console.log('Policy script:', policyScript)

import { buildMintingPolicyScriptFromAddress } from '@hydra-sdk/core'

const policyScript = buildMintingPolicyScriptFromAddress('addr_test1...')
console.log('Policy script:', policyScript)

import { buildMintingPolicyScriptFromKeyHash } from '@hydra-sdk/core'

const policyScript = buildMintingPolicyScriptFromKeyHash('a1b2c3...')
console.log('Policy script:', policyScript)

import { policyIdFromNativeScript } from '@hydra-sdk/core'

const policyId = policyIdFromNativeScript(nativeScriptHex)
console.log('Policy ID:', policyId)

import { bytesToHex } from '@hydra-sdk/core'

const hexString = bytesToHex(new Uint8Array([1, 2, 3]))
console.log('Hex:', hexString) // => "010203"

import { hexToBytes } from '@hydra-sdk/core'

const bytes = hexToBytes('010203')
console.log('Bytes:', bytes) // => Uint8Array [ 1, 2, 3 ]

import { stringToHex } from '@hydra-sdk/core'

const hex = stringToHex('Hello')
console.log('Hex:', hex) // => "48656c6c6f"

import { hexToString } from '@hydra-sdk/core'

const str = hexToString('48656c6c6f')
console.log('String:', str) // => "Hello"

import { toBytes } from '@hydra-sdk/core'

const bytes1 = toBytes('48656c6c6f')
const bytes2 = toBytes('Hello')

import { fromUTF8 } from '@hydra-sdk/core'

const hex = fromUTF8('Hello')
console.log('Hex:', hex)

import { toUTF8 } from '@hydra-sdk/core'

const str = toUTF8('48656c6c6f')
console.log('String:', str)

import { metadataObjToMetadatum } from '@hydra-sdk/core'

const metadata = metadataObjToMetadatum({
  '1': 'Hello',
  '2': 12345
})
console.log('Metadata:', metadata)

import { cardanoCliKeygen } from '@hydra-sdk/core'

const { sk, vk } = cardanoCliKeygen()
console.log('Secret Key (cborHex):', sk.cborHex)
console.log('Verification Key (cborHex):', vk.cborHex)

import { hydraCliKeygen } from '@hydra-sdk/core'

const { sk, vk } = hydraCliKeygen()
console.log('Secret Key:', sk)
console.log('Verification Key:', vk)

import { genVkey, cardanoCliKeygen } from '@hydra-sdk/core'

const { sk } = cardanoCliKeygen()
const vk = genVkey(sk)
console.log('Verification Key:', vk.cborHex)

import { mkInt } from '@hydra-sdk/core'

const plutusInt = mkInt(42)
console.log('PlutusData:', plutusInt)

import { mkBytes } from '@hydra-sdk/core'

const plutusBytes = mkBytes('a1b2c3')
console.log('PlutusData:', plutusBytes)

import { mkConstr, mkInt } from '@hydra-sdk/core'

const constr = mkConstr(0, [mkInt(1), mkInt(2)])
console.log('Constructor:', constr)

import { mkMap, mkInt, mkBytes } from '@hydra-sdk/core'

const map = mkMap([
  [mkInt(1), mkBytes('a1b2')],
  [mkInt(2), mkBytes('c3d4')]
])
console.log('Map:', map)

import { buildCostModels } from '@hydra-sdk/core'

const costModels = buildCostModels()
console.log('Cost Models:', costModels)

import { NETWORK_ID } from '@hydra-sdk/core'

// Available network IDs
NETWORK_ID.TESTNET  // 0
NETWORK_ID.PREPROD  // 0
NETWORK_ID.MAINNET  // 1