Developer Hub

Example msg.data parsing with kotlin code.

Returns parsed data object with four fields:

tickerA, tickerB, epochSeconds, and price

@Serializable
data class OracleObject(
    val type: String,
    val msg: OracleMsg,
    val epochSeconds: Long,
    @Serializable(with = BigDecimalSerializer::class)val price: BigDecimal)
    val pairPriceUnit: String
)

data class ParsedOracleData(
    val tickerA: String,
    val tickerB: String,
    val epochSeconds: Long,
    val price: Long
)

fun parseOracleData(data: ByteArray): ParsedOracleData {
    require(data.size == 24) { "Data must be exactly 24 bytes" }

    val tickerA = String(data.sliceArray(0..3)).trimEnd { it.toInt() == 0 }
    val tickerB = String(data.sliceArray(4..7)).trimEnd { it.toInt() == 0 }

    val longBuffer1 = ByteBuffer.wrap(data.sliceArray(8..15))
                            .order(ByteOrder.LITTLE_ENDIAN)
    val epochSeconds = longBuffer1.long

    val longBuffer2 = ByteBuffer.wrap(data.sliceArray(16..23))
                            .order(ByteOrder.LITTLE_ENDIAN)
    val price = longBuffer2.long

    return ParsedOracleData(tickerA, tickerB, epochSeconds, price)
}


val response = client.get("https://wallywallet.org/_api/v0/hourlyavg/usdt/nexa?
                        time=1724382065").bodyAsText()
val message = Json.decodeFromString<OracleObject>(response).msg
val data = message.data
val signature = message.signature

val byteArray = data.fromHex()
val parsedOracleData = parseOracleData(byteArray)

Example msg.signature validation with kotlin code.

class PriceDataPoint(name: String? = null, _nsl: NSL? = null): PackedStructure(name, _nsl)
{
    constructor(_tickerA: String, _tickerB:String, _epochSeconds: Long, _priceAinB: Long):this()
    {
        tickerA.curVal = _tickerA.toPaddedByteArray(4)
        tickerB.curVal = _tickerB.toPaddedByteArray(4)
        epochSeconds.curVal = _epochSeconds
        priceAinB.curVal = _priceAinB
    }
                            
    val tickerA: Nexa.npl.NBytes by Nexa.npl.PBytes(4)
    val tickerB: Nexa.npl.NBytes by Nexa.npl.PBytes(4)
    val epochSeconds: Nexa.npl.NInt by Nexa.npl.PInt(8)
    val priceAinB: Nexa.npl.NInt by Nexa.npl.PInt(8)
}
                            
                            
val checkData = PriceDataPoint(
    parsedOracleData.tickerA,
    parsedOracleData.tickerB,
    parsedOracleData.epochSeconds,
    parsedOracleData.price
    ).toByteArray()
val hashedData = libnexa.sha256(checkData)
                            
// use wallywallet.org pubkey
val pubKey = "well-known pubKey goes here"
val pubKeyBytes = pubKey.fromHex()
val verify = libnexa.verifySignedHashSchnorr(hashedData, pubKeyBytes, signature.fromHex())
assertTrue(verify)