/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.0.1-SNAPSHOT
 * User agent: apibuilder app.apibuilder.io/gimbalabs/hilltop-api/0.0.1-SNAPSHOT/http4s_0_18
 */
package io.gimbalabs.hilltop.api.v0.models {

  package object json {
    import io.circe.Decoder._
    import io.circe.Encoder._
    import scala.language.implicitConversions // See below - Make Scala 2.11 Either monadic
    import scala.util.Try
    import io.circe.{Json, JsonObject, Encoder, Decoder, DecodingFailure}
    import io.circe.syntax._
    import io.gimbalabs.hilltop.api.v0.models.json._

    // Make Scala 2.11 Either monadic
    private[v0] implicit def eitherOps[A,B](e: Either[A,B]) = cats.implicits.catsSyntaxEither(e)

    private[v0] implicit val decodeUUID: Decoder[_root_.java.util.UUID] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.util.UUID.fromString(str)))

    private[v0] implicit val encodeUUID: Encoder[_root_.java.util.UUID] =
      Encoder.encodeString.contramap[_root_.java.util.UUID](uuid => uuid.toString)

    private[v0] implicit val decodeInstant: Decoder[_root_.java.time.Instant] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.time.OffsetDateTime.parse(str).toInstant))

    private[v0] implicit val encodeInstant: Encoder[_root_.java.time.Instant] =
      Encoder.encodeString.contramap[_root_.java.time.Instant](_.toString)

    private[v0] implicit val decodeLocalDate: Decoder[_root_.java.time.LocalDate] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.time.LocalDate.parse(str)))

    private[v0] implicit val encodeLocalDate: Encoder[_root_.java.time.LocalDate] =
      Encoder.encodeString.contramap[_root_.java.time.LocalDate](_.toString)

    implicit val jsonDecoderHilltopApiCountry: Decoder[io.gimbalabs.hilltop.api.v0.models.Country] =
      Decoder.decodeString.map(io.gimbalabs.hilltop.api.v0.models.Country(_))

    implicit val jsonEncoderHilltopApiCountry: Encoder[io.gimbalabs.hilltop.api.v0.models.Country] =
      Encoder.encodeString.contramap[io.gimbalabs.hilltop.api.v0.models.Country](_.toString)

    implicit def decodeHilltopApiActiveStakeAmount: Decoder[ActiveStakeAmount] = Decoder.instance { c =>
     for {
        amountInLovelaces <- c.downField("amount_in_lovelaces").as[Long]
      } yield {
        ActiveStakeAmount(
          amountInLovelaces = amountInLovelaces
        )
      }
    }

    implicit def encodeHilltopApiActiveStakeAmount: Encoder[ActiveStakeAmount] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("amount_in_lovelaces" -> t.amountInLovelaces.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiAddressStakeAmount: Decoder[AddressStakeAmount] = Decoder.instance { c =>
     for {
        stakeAddress <- c.downField("stake_address").as[String]
        amountInLovelaces <- c.downField("amount_in_lovelaces").as[Long]
      } yield {
        AddressStakeAmount(
          stakeAddress = stakeAddress,
          amountInLovelaces = amountInLovelaces
        )
      }
    }

    implicit def encodeHilltopApiAddressStakeAmount: Encoder[AddressStakeAmount] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("stake_address" -> t.stakeAddress.asJson),
        Some("amount_in_lovelaces" -> t.amountInLovelaces.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiBlock: Decoder[Block] = Decoder.instance { c =>
     for {
        number <- c.downField("number").as[Long]
        epochNumber <- c.downField("epoch_number").as[Long]
        slotNumber <- c.downField("slot_number").as[Long]
        epochSlotNumber <- c.downField("epoch_slot_number").as[Long]
        size <- c.downField("size").as[Long]
        transactionCount <- c.downField("transaction_count").as[Long]
        time <- c.downField("time").as[_root_.java.time.Instant]
      } yield {
        Block(
          number = number,
          epochNumber = epochNumber,
          slotNumber = slotNumber,
          epochSlotNumber = epochSlotNumber,
          size = size,
          transactionCount = transactionCount,
          time = time
        )
      }
    }

    implicit def encodeHilltopApiBlock: Encoder[Block] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("number" -> t.number.asJson),
        Some("epoch_number" -> t.epochNumber.asJson),
        Some("slot_number" -> t.slotNumber.asJson),
        Some("epoch_slot_number" -> t.epochSlotNumber.asJson),
        Some("size" -> t.size.asJson),
        Some("transaction_count" -> t.transactionCount.asJson),
        Some("time" -> t.time.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiCnftMetadataV001: Decoder[CnftMetadataV001] = Decoder.instance { c =>
     for {
        policyId <- c.downField("policyId").as[String]
        tokens <- c.downField("tokens").as[Map[String, String]]
        asset <- c.downField("asset").as[io.gimbalabs.hilltop.api.v0.models.CnftMetadataV001Asset]
      } yield {
        CnftMetadataV001(
          policyId = policyId,
          tokens = tokens,
          asset = asset
        )
      }
    }

    implicit def encodeHilltopApiCnftMetadataV001: Encoder[CnftMetadataV001] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("policyId" -> t.policyId.asJson),
        Some("tokens" -> t.tokens.asJson),
        Some("asset" -> t.asset.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiCnftMetadataV001Asset: Decoder[CnftMetadataV001Asset] = Decoder.instance { c =>
     for {
        assetName <- c.downField("assetName").as[Option[String]]
        attributes <- c.downField("attributes").as[Option[_root_.io.circe.Json]]
        ipfs <- c.downField("ipfs").as[String]
        mimeType <- c.downField("mimeType").as[Option[String]]
      } yield {
        CnftMetadataV001Asset(
          assetName = assetName,
          attributes = attributes,
          ipfs = ipfs,
          mimeType = mimeType
        )
      }
    }

    implicit def encodeHilltopApiCnftMetadataV001Asset: Encoder[CnftMetadataV001Asset] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.assetName.map(t => "assetName" -> t.asJson),
        t.attributes.map(t => "attributes" -> t.asJson),
        Some("ipfs" -> t.ipfs.asJson),
        t.mimeType.map(t => "mimeType" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiDayBlock: Decoder[DayBlock] = Decoder.instance { c =>
     for {
        first <- c.downField("first").as[io.gimbalabs.hilltop.api.v0.models.Block]
        last <- c.downField("last").as[io.gimbalabs.hilltop.api.v0.models.Block]
      } yield {
        DayBlock(
          first = first,
          last = last
        )
      }
    }

    implicit def encodeHilltopApiDayBlock: Encoder[DayBlock] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("first" -> t.first.asJson),
        Some("last" -> t.last.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiDelegation: Decoder[Delegation] = Decoder.instance { c =>
     for {
        stakingAddress <- c.downField("staking_address").as[String]
        delegations <- c.downField("delegations").as[Seq[io.gimbalabs.hilltop.api.v0.models.StakepoolDelegation]]
      } yield {
        Delegation(
          stakingAddress = stakingAddress,
          delegations = delegations
        )
      }
    }

    implicit def encodeHilltopApiDelegation: Encoder[Delegation] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("staking_address" -> t.stakingAddress.asJson),
        Some("delegations" -> t.delegations.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiDelegatorsCount: Decoder[DelegatorsCount] = Decoder.instance { c =>
     for {
        delegatorsCountTotal <- c.downField("delegators_count_total").as[Int]
      } yield {
        DelegatorsCount(
          delegatorsCountTotal = delegatorsCountTotal
        )
      }
    }

    implicit def encodeHilltopApiDelegatorsCount: Encoder[DelegatorsCount] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("delegators_count_total" -> t.delegatorsCountTotal.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiEpoch: Decoder[Epoch] = Decoder.instance { c =>
     for {
        outSum <- c.downField("out_sum").as[Long]
        fees <- c.downField("fees").as[Long]
        txCount <- c.downField("tx_count").as[Int]
        blkCount <- c.downField("blk_count").as[Int]
        number <- c.downField("number").as[Int]
        startTime <- c.downField("start_time").as[_root_.java.time.Instant]
        endTime <- c.downField("end_time").as[_root_.java.time.Instant]
      } yield {
        Epoch(
          outSum = outSum,
          fees = fees,
          txCount = txCount,
          blkCount = blkCount,
          number = number,
          startTime = startTime,
          endTime = endTime
        )
      }
    }

    implicit def encodeHilltopApiEpoch: Encoder[Epoch] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("out_sum" -> t.outSum.asJson),
        Some("fees" -> t.fees.asJson),
        Some("tx_count" -> t.txCount.asJson),
        Some("blk_count" -> t.blkCount.asJson),
        Some("number" -> t.number.asJson),
        Some("start_time" -> t.startTime.asJson),
        Some("end_time" -> t.endTime.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiGenericError: Decoder[GenericError] = Decoder.instance { c =>
     for {
        description <- c.downField("description").as[String]
      } yield {
        GenericError(
          description = description
        )
      }
    }

    implicit def encodeHilltopApiGenericError: Encoder[GenericError] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("description" -> t.description.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiHealthcheck: Decoder[Healthcheck] = Decoder.instance { c =>
     for {
        status <- c.downField("status").as[String]
      } yield {
        Healthcheck(
          status = status
        )
      }
    }

    implicit def encodeHilltopApiHealthcheck: Encoder[Healthcheck] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("status" -> t.status.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNativeAsset: Decoder[NativeAsset] = Decoder.instance { c =>
     for {
        transactionId <- c.downField("transaction_id").as[String]
        policyId <- c.downField("policy_id").as[String]
        tokenName <- c.downField("token_name").as[String]
        metadata <- c.downField("metadata").as[_root_.io.circe.Json]
        blockNumber <- c.downField("block_number").as[Long]
        epochSlotNumber <- c.downField("epoch_slot_number").as[Long]
        epochNumber <- c.downField("epoch_number").as[Long]
        invalidBefore <- c.downField("invalid_before").as[Option[Long]]
        invalidHereafter <- c.downField("invalid_hereafter").as[Option[Long]]
        quantity <- c.downField("quantity").as[Long]
      } yield {
        NativeAsset(
          transactionId = transactionId,
          policyId = policyId,
          tokenName = tokenName,
          metadata = metadata,
          blockNumber = blockNumber,
          epochSlotNumber = epochSlotNumber,
          epochNumber = epochNumber,
          invalidBefore = invalidBefore,
          invalidHereafter = invalidHereafter,
          quantity = quantity
        )
      }
    }

    implicit def encodeHilltopApiNativeAsset: Encoder[NativeAsset] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("transaction_id" -> t.transactionId.asJson),
        Some("policy_id" -> t.policyId.asJson),
        Some("token_name" -> t.tokenName.asJson),
        Some("metadata" -> t.metadata.asJson),
        Some("block_number" -> t.blockNumber.asJson),
        Some("epoch_slot_number" -> t.epochSlotNumber.asJson),
        Some("epoch_number" -> t.epochNumber.asJson),
        t.invalidBefore.map(t => "invalid_before" -> t.asJson),
        t.invalidHereafter.map(t => "invalid_hereafter" -> t.asJson),
        Some("quantity" -> t.quantity.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNativeAssetDetails: Decoder[NativeAssetDetails] = Decoder.instance { c =>
     for {
        policyId <- c.downField("policy_id").as[String]
        assetName <- c.downField("asset_name").as[String]
        metadata <- c.downField("metadata").as[_root_.io.circe.Json]
        mintedAt <- c.downField("minted_at").as[_root_.java.time.Instant]
        lastMintedAt <- c.downField("last_minted_at").as[_root_.java.time.Instant]
        firstMintingTxBlock <- c.downField("first_minting_tx_block").as[Long]
        lastMintingTxBlock <- c.downField("last_minting_tx_block").as[Long]
        mintingTxHash <- c.downField("minting_tx_hash").as[String]
        circulatingSupply <- c.downField("circulating_supply").as[Long]
        fingerprint <- c.downField("fingerprint").as[String]
      } yield {
        NativeAssetDetails(
          policyId = policyId,
          assetName = assetName,
          metadata = metadata,
          mintedAt = mintedAt,
          lastMintedAt = lastMintedAt,
          firstMintingTxBlock = firstMintingTxBlock,
          lastMintingTxBlock = lastMintingTxBlock,
          mintingTxHash = mintingTxHash,
          circulatingSupply = circulatingSupply,
          fingerprint = fingerprint
        )
      }
    }

    implicit def encodeHilltopApiNativeAssetDetails: Encoder[NativeAssetDetails] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("policy_id" -> t.policyId.asJson),
        Some("asset_name" -> t.assetName.asJson),
        Some("metadata" -> t.metadata.asJson),
        Some("minted_at" -> t.mintedAt.asJson),
        Some("last_minted_at" -> t.lastMintedAt.asJson),
        Some("first_minting_tx_block" -> t.firstMintingTxBlock.asJson),
        Some("last_minting_tx_block" -> t.lastMintingTxBlock.asJson),
        Some("minting_tx_hash" -> t.mintingTxHash.asJson),
        Some("circulating_supply" -> t.circulatingSupply.asJson),
        Some("fingerprint" -> t.fingerprint.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNativeAssetDetailsRequest: Decoder[NativeAssetDetailsRequest] = Decoder.instance { c =>
     for {
        policyId <- c.downField("policy_id").as[String]
        assetNames <- c.downField("asset_names").as[Option[Seq[String]]]
      } yield {
        NativeAssetDetailsRequest(
          policyId = policyId,
          assetNames = assetNames
        )
      }
    }

    implicit def encodeHilltopApiNativeAssetDetailsRequest: Encoder[NativeAssetDetailsRequest] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("policy_id" -> t.policyId.asJson),
        t.assetNames.map(t => "asset_names" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNativeAssetId: Decoder[NativeAssetId] = Decoder.instance { c =>
     for {
        policyId <- c.downField("policy_id").as[String]
        assetName <- c.downField("asset_name").as[String]
        blockNumber <- c.downField("block_number").as[Long]
        blockTime <- c.downField("block_time").as[_root_.java.time.Instant]
        fingerprint <- c.downField("fingerprint").as[String]
      } yield {
        NativeAssetId(
          policyId = policyId,
          assetName = assetName,
          blockNumber = blockNumber,
          blockTime = blockTime,
          fingerprint = fingerprint
        )
      }
    }

    implicit def encodeHilltopApiNativeAssetId: Encoder[NativeAssetId] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("policy_id" -> t.policyId.asJson),
        Some("asset_name" -> t.assetName.asJson),
        Some("block_number" -> t.blockNumber.asJson),
        Some("block_time" -> t.blockTime.asJson),
        Some("fingerprint" -> t.fingerprint.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNftDetails: Decoder[NftDetails] = Decoder.instance { c =>
     for {
        policyId <- c.downField("policy_id").as[String]
        assetNameRaw <- c.downField("asset_name_raw").as[String]
        assetName <- c.downField("asset_name").as[Option[String]]
        metadata <- c.downField("metadata").as[_root_.io.circe.Json]
        mintedAt <- c.downField("minted_at").as[_root_.java.time.Instant]
        mintedAtBlock <- c.downField("minted_at_block").as[Long]
        mintingTxHash <- c.downField("minting_tx_hash").as[String]
        amount <- c.downField("amount").as[Long]
        fingerprint <- c.downField("fingerprint").as[String]
      } yield {
        NftDetails(
          policyId = policyId,
          assetNameRaw = assetNameRaw,
          assetName = assetName,
          metadata = metadata,
          mintedAt = mintedAt,
          mintedAtBlock = mintedAtBlock,
          mintingTxHash = mintingTxHash,
          amount = amount,
          fingerprint = fingerprint
        )
      }
    }

    implicit def encodeHilltopApiNftDetails: Encoder[NftDetails] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("policy_id" -> t.policyId.asJson),
        Some("asset_name_raw" -> t.assetNameRaw.asJson),
        t.assetName.map(t => "asset_name" -> t.asJson),
        Some("metadata" -> t.metadata.asJson),
        Some("minted_at" -> t.mintedAt.asJson),
        Some("minted_at_block" -> t.mintedAtBlock.asJson),
        Some("minting_tx_hash" -> t.mintingTxHash.asJson),
        Some("amount" -> t.amount.asJson),
        Some("fingerprint" -> t.fingerprint.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNftMetadata: Decoder[NftMetadata] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[Option[String]]
        image <- c.downField("image").as[Option[String]]
        mediaType <- c.downField("mediaType").as[Option[String]]
        files <- c.downField("files").as[Option[Seq[io.gimbalabs.hilltop.api.v0.models.NftMetadataFile]]]
      } yield {
        NftMetadata(
          name = name,
          image = image,
          mediaType = mediaType,
          files = files
        )
      }
    }

    implicit def encodeHilltopApiNftMetadata: Encoder[NftMetadata] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.name.map(t => "name" -> t.asJson),
        t.image.map(t => "image" -> t.asJson),
        t.mediaType.map(t => "mediaType" -> t.asJson),
        t.files.map(t => "files" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNftMetadataFile: Decoder[NftMetadataFile] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[Option[String]]
        src <- c.downField("src").as[Option[String]]
        mediaType <- c.downField("mediaType").as[Option[String]]
      } yield {
        NftMetadataFile(
          name = name,
          src = src,
          mediaType = mediaType
        )
      }
    }

    implicit def encodeHilltopApiNftMetadataFile: Encoder[NftMetadataFile] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.name.map(t => "name" -> t.asJson),
        t.src.map(t => "src" -> t.asJson),
        t.mediaType.map(t => "mediaType" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNftMetadataFilesAsObject: Decoder[NftMetadataFilesAsObject] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[Option[String]]
        image <- c.downField("image").as[Option[String]]
        mediaType <- c.downField("mediaType").as[Option[String]]
        files <- c.downField("files").as[Option[io.gimbalabs.hilltop.api.v0.models.NftMetadataFile]]
      } yield {
        NftMetadataFilesAsObject(
          name = name,
          image = image,
          mediaType = mediaType,
          files = files
        )
      }
    }

    implicit def encodeHilltopApiNftMetadataFilesAsObject: Encoder[NftMetadataFilesAsObject] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.name.map(t => "name" -> t.asJson),
        t.image.map(t => "image" -> t.asJson),
        t.mediaType.map(t => "mediaType" -> t.asJson),
        t.files.map(t => "files" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNftMetadataImgArray: Decoder[NftMetadataImgArray] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[Option[String]]
        image <- c.downField("image").as[Option[Seq[String]]]
        mediaType <- c.downField("mediaType").as[Option[String]]
        files <- c.downField("files").as[Option[Seq[io.gimbalabs.hilltop.api.v0.models.NftMetadataFile]]]
      } yield {
        NftMetadataImgArray(
          name = name,
          image = image,
          mediaType = mediaType,
          files = files
        )
      }
    }

    implicit def encodeHilltopApiNftMetadataImgArray: Encoder[NftMetadataImgArray] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.name.map(t => "name" -> t.asJson),
        t.image.map(t => "image" -> t.asJson),
        t.mediaType.map(t => "mediaType" -> t.asJson),
        t.files.map(t => "files" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiNftMetadataNoFiles: Decoder[NftMetadataNoFiles] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[Option[String]]
        image <- c.downField("image").as[Option[String]]
        mediaType <- c.downField("mediaType").as[Option[String]]
      } yield {
        NftMetadataNoFiles(
          name = name,
          image = image,
          mediaType = mediaType
        )
      }
    }

    implicit def encodeHilltopApiNftMetadataNoFiles: Encoder[NftMetadataNoFiles] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.name.map(t => "name" -> t.asJson),
        t.image.map(t => "image" -> t.asJson),
        t.mediaType.map(t => "mediaType" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiPoolRetiring: Decoder[PoolRetiring] = Decoder.instance { c =>
     for {
        tickerName <- c.downField("ticker_name").as[Option[String]]
        poolId <- c.downField("pool_id").as[String]
        certificateIndex <- c.downField("certificate_index").as[Int]
        epochNumber <- c.downField("epoch_number").as[Long]
        blockNumber <- c.downField("block_number").as[Long]
        retiringAtEpoch <- c.downField("retiring_at_epoch").as[Long]
        txHash <- c.downField("tx_hash").as[String]
      } yield {
        PoolRetiring(
          tickerName = tickerName,
          poolId = poolId,
          certificateIndex = certificateIndex,
          epochNumber = epochNumber,
          blockNumber = blockNumber,
          retiringAtEpoch = retiringAtEpoch,
          txHash = txHash
        )
      }
    }

    implicit def encodeHilltopApiPoolRetiring: Encoder[PoolRetiring] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.tickerName.map(t => "ticker_name" -> t.asJson),
        Some("pool_id" -> t.poolId.asJson),
        Some("certificate_index" -> t.certificateIndex.asJson),
        Some("epoch_number" -> t.epochNumber.asJson),
        Some("block_number" -> t.blockNumber.asJson),
        Some("retiring_at_epoch" -> t.retiringAtEpoch.asJson),
        Some("tx_hash" -> t.txHash.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiPoolUpdate: Decoder[PoolUpdate] = Decoder.instance { c =>
     for {
        epochNumber <- c.downField("epoch_number").as[Int]
        blockNumber <- c.downField("block_number").as[Long]
        txHash <- c.downField("tx_hash").as[String]
        poolTickerName <- c.downField("pool_ticker_name").as[Option[String]]
        poolBech32Id <- c.downField("pool_bech32_id").as[String]
        certificateIndex <- c.downField("certificate_index").as[Int]
        vrfKeyHash <- c.downField("vrf_key_hash").as[String]
        pledge <- c.downField("pledge").as[Long]
        rewardAddress <- c.downField("reward_address").as[String]
        activeEpochNumber <- c.downField("active_epoch_number").as[Long]
        margin <- c.downField("margin").as[Double]
        fixedCost <- c.downField("fixed_cost").as[Long]
      } yield {
        PoolUpdate(
          epochNumber = epochNumber,
          blockNumber = blockNumber,
          txHash = txHash,
          poolTickerName = poolTickerName,
          poolBech32Id = poolBech32Id,
          certificateIndex = certificateIndex,
          vrfKeyHash = vrfKeyHash,
          pledge = pledge,
          rewardAddress = rewardAddress,
          activeEpochNumber = activeEpochNumber,
          margin = margin,
          fixedCost = fixedCost
        )
      }
    }

    implicit def encodeHilltopApiPoolUpdate: Encoder[PoolUpdate] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("epoch_number" -> t.epochNumber.asJson),
        Some("block_number" -> t.blockNumber.asJson),
        Some("tx_hash" -> t.txHash.asJson),
        t.poolTickerName.map(t => "pool_ticker_name" -> t.asJson),
        Some("pool_bech32_id" -> t.poolBech32Id.asJson),
        Some("certificate_index" -> t.certificateIndex.asJson),
        Some("vrf_key_hash" -> t.vrfKeyHash.asJson),
        Some("pledge" -> t.pledge.asJson),
        Some("reward_address" -> t.rewardAddress.asJson),
        Some("active_epoch_number" -> t.activeEpochNumber.asJson),
        Some("margin" -> t.margin.asJson),
        Some("fixed_cost" -> t.fixedCost.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiReward: Decoder[Reward] = Decoder.instance { c =>
     for {
        stakingAddress <- c.downField("staking_address").as[String]
        epoch <- c.downField("epoch").as[Int]
        amount <- c.downField("amount").as[Long]
        poolId <- c.downField("pool_id").as[String]
      } yield {
        Reward(
          stakingAddress = stakingAddress,
          epoch = epoch,
          amount = amount,
          poolId = poolId
        )
      }
    }

    implicit def encodeHilltopApiReward: Encoder[Reward] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("staking_address" -> t.stakingAddress.asJson),
        Some("epoch" -> t.epoch.asJson),
        Some("amount" -> t.amount.asJson),
        Some("pool_id" -> t.poolId.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiSigma: Decoder[Sigma] = Decoder.instance { c =>
     for {
        sigma <- c.downField("sigma").as[Double]
        epoch <- c.downField("epoch").as[Int]
        totalStaked <- c.downField("total_staked").as[Long]
        activeStake <- c.downField("active_stake").as[Long]
        nonce <- c.downField("nonce").as[String]
        d <- c.downField("d").as[Double]
      } yield {
        Sigma(
          sigma = sigma,
          epoch = epoch,
          totalStaked = totalStaked,
          activeStake = activeStake,
          nonce = nonce,
          d = d
        )
      }
    }

    implicit def encodeHilltopApiSigma: Encoder[Sigma] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("sigma" -> t.sigma.asJson),
        Some("epoch" -> t.epoch.asJson),
        Some("total_staked" -> t.totalStaked.asJson),
        Some("active_stake" -> t.activeStake.asJson),
        Some("nonce" -> t.nonce.asJson),
        Some("d" -> t.d.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiStakepool: Decoder[Stakepool] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        poolIdBech32 <- c.downField("pool_id_bech32").as[String]
        metadata <- c.downField("metadata").as[Option[io.gimbalabs.hilltop.api.v0.models.StakepoolMetadata]]
        cost <- c.downField("cost").as[Long]
        margin <- c.downField("margin").as[Double]
        pledge <- c.downField("pledge").as[Long]
        activeStake <- c.downField("active_stake").as[Long]
        saturation <- c.downField("saturation").as[Double]
        retiringAtEpoch <- c.downField("retiring_at_epoch").as[Option[Long]]
      } yield {
        Stakepool(
          id = id,
          poolIdBech32 = poolIdBech32,
          metadata = metadata,
          cost = cost,
          margin = margin,
          pledge = pledge,
          activeStake = activeStake,
          saturation = saturation,
          retiringAtEpoch = retiringAtEpoch
        )
      }
    }

    implicit def encodeHilltopApiStakepool: Encoder[Stakepool] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("pool_id_bech32" -> t.poolIdBech32.asJson),
        t.metadata.map(t => "metadata" -> t.asJson),
        Some("cost" -> t.cost.asJson),
        Some("margin" -> t.margin.asJson),
        Some("pledge" -> t.pledge.asJson),
        Some("active_stake" -> t.activeStake.asJson),
        Some("saturation" -> t.saturation.asJson),
        t.retiringAtEpoch.map(t => "retiring_at_epoch" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiStakepoolDelegation: Decoder[StakepoolDelegation] = Decoder.instance { c =>
     for {
        stakepool <- c.downField("stakepool").as[io.gimbalabs.hilltop.api.v0.models.Stakepool]
        epoch <- c.downField("epoch").as[Int]
      } yield {
        StakepoolDelegation(
          stakepool = stakepool,
          epoch = epoch
        )
      }
    }

    implicit def encodeHilltopApiStakepoolDelegation: Encoder[StakepoolDelegation] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("stakepool" -> t.stakepool.asJson),
        Some("epoch" -> t.epoch.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiStakepoolMetadata: Decoder[StakepoolMetadata] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        ticker <- c.downField("ticker").as[String]
        homepage <- c.downField("homepage").as[String]
        description <- c.downField("description").as[String]
        extended <- c.downField("extended").as[Option[String]]
      } yield {
        StakepoolMetadata(
          name = name,
          ticker = ticker,
          homepage = homepage,
          description = description,
          extended = extended
        )
      }
    }

    implicit def encodeHilltopApiStakepoolMetadata: Encoder[StakepoolMetadata] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("ticker" -> t.ticker.asJson),
        Some("homepage" -> t.homepage.asJson),
        Some("description" -> t.description.asJson),
        t.extended.map(t => "extended" -> t.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiTransaction: Decoder[Transaction] = Decoder.instance { c =>
     for {
        hash <- c.downField("hash").as[String]
        block <- c.downField("block").as[Long]
        timestamp <- c.downField("timestamp").as[_root_.java.time.Instant]
      } yield {
        Transaction(
          hash = hash,
          block = block,
          timestamp = timestamp
        )
      }
    }

    implicit def encodeHilltopApiTransaction: Encoder[Transaction] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("hash" -> t.hash.asJson),
        Some("block" -> t.block.asJson),
        Some("timestamp" -> t.timestamp.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiTransactionHistoryRequest: Decoder[TransactionHistoryRequest] = Decoder.instance { c =>
     for {
        addresses <- c.downField("addresses").as[Seq[String]]
      } yield {
        TransactionHistoryRequest(
          addresses = addresses
        )
      }
    }

    implicit def encodeHilltopApiTransactionHistoryRequest: Encoder[TransactionHistoryRequest] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("addresses" -> t.addresses.asJson)
      ).flatten)
    }

    implicit def decodeHilltopApiWalletBalance: Decoder[WalletBalance] = Decoder.instance { c =>
     for {
        balance <- c.downField("balance").as[Long]
      } yield {
        WalletBalance(
          balance = balance
        )
      }
    }

    implicit def encodeHilltopApiWalletBalance: Encoder[WalletBalance] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("balance" -> t.balance.asJson)
      ).flatten)
    }
  }
}