feat(lazer/sui): init structs and basic example

Author: tejasbadadare

lazer/contracts/sui/Move.toml

@@ -1,35 +1,12 @@
 [package]
 name = "pyth_lazer"
 edition = "2024.beta" # edition = "legacy" to use legacy (pre-2024) Move
-# license = ""           # e.g., "MIT", "GPL", "Apache 2.0"
-# authors = ["..."]      # e.g., ["Joe Smith ([email protected])", "John Snow ([email protected])"]
 
 [dependencies]
 
-# For remote import, use the `{ git = "...", subdir = "...", rev = "..." }`.
-# Revision can be a branch, a tag, and a commit hash.
-# MyRemotePackage = { git = "https://some.remote/host.git", subdir = "remote/path", rev = "main" }
-
-# For local dependencies use `local = path`. Path is relative to the package root
-# Local = { local = "../path/to" }
-
-# To resolve a version conflict and force a specific version for dependency
-# override use `override = true`
-# Override = { local = "../conflicting/version", override = true }
-
 [addresses]
 pyth_lazer = "0x0"
 
-# Named addresses will be accessible in Move as `@name`. They're also exported:
-# for example, `std = "0x1"` is exported by the Standard Library.
-# alice = "0xA11CE"
-
 [dev-dependencies]
-# The dev-dependencies section allows overriding dependencies for `--test` and
-# `--dev` modes. You can introduce test-only dependencies here.
-# Local = { local = "../path/to/dev-build" }
 
 [dev-addresses]
-# The dev-addresses section allows overwriting named addresses for the `--test`
-# and `--dev` modes.
-# alice = "0xB0B"

lazer/contracts/sui/sources/channel.move

@@ -0,0 +1,49 @@
+module pyth_lazer::channel;
+
+public enum Channel has copy, drop {
+    Invalid,
+    RealTime,
+    FixedRate50ms,
+    FixedRate200ms,
+}
+
+/// Check if the channel is Invalid
+public fun is_invalid(channel: &Channel): bool {
+    match (channel) {
+        Channel::Invalid => true,
+        _ => false,
+    }
+}
+
+/// Check if the channel is RealTime
+public fun is_real_time(channel: &Channel): bool {
+    match (channel) {
+        Channel::RealTime => true,
+        _ => false,
+    }
+}
+
+/// Check if the channel is FixedRate50ms
+public fun is_fixed_rate_50ms(channel: &Channel): bool {
+    match (channel) {
+        Channel::FixedRate50ms => true,
+        _ => false,
+    }
+}
+
+/// Check if the channel is FixedRate200ms
+public fun is_fixed_rate_200ms(channel: &Channel): bool {
+    match (channel) {
+        Channel::FixedRate200ms => true,
+        _ => false,
+    }
+}
+
+/// Get the update interval in milliseconds for fixed rate channels, returns 0 for non-fixed rate channels
+public fun get_update_interval_ms(channel: &Channel): u64 {
+    match (channel) {
+        Channel::FixedRate50ms => 50,
+        Channel::FixedRate200ms => 200,
+        _ => 0,
+    }
+}

lazer/contracts/sui/sources/feed.move

@@ -0,0 +1,77 @@
+module pyth_lazer::feed;
+
+use pyth_lazer::i16::I16;
+use pyth_lazer::i64::I64;
+
+/// The feed struct is based on the Lazer rust protocol definition defined here:
+/// https://github.com/pyth-network/pyth-crosschain/blob/main/lazer/sdk/rust/protocol/src/types.rs#L10
+///
+/// Some fields in Lazer are optional, as in Lazer might return None for them due to some conditions (for example,
+/// not having enough publishers to calculate the price) and that is why they are represented as Option<Option<T>>.
+/// The first Option<T> is for the existence of the field within the update data and the second Option<T> is for the
+/// value of the field.
+public struct Feed has copy, drop {
+    /// Unique identifier for the price feed (e.g., 1 for BTC/USD, 2 for ETH/USD)
+    feed_id: u32,
+    /// Current aggregate price from all publishers
+    price: Option<Option<I64>>,
+    /// Best bid price available across all publishers
+    best_bid_price: Option<Option<I64>>,
+    /// Best ask price available across all publishers
+    best_ask_price: Option<Option<I64>>,
+    /// Number of publishers contributing to this price feed
+    publisher_count: Option<u16>,
+    /// Price exponent (typically negative, e.g., -8 means divide price by 10^8)
+    exponent: Option<I16>,
+    /// Confidence interval representing price uncertainty
+    confidence: Option<Option<I64>>,
+    /// Funding rate for derivative products (e.g., perpetual futures)
+    funding_rate: Option<Option<I64>>,
+    /// Timestamp when the funding rate was last updated
+    funding_timestamp: Option<Option<u64>>,
+}
+
+/// Get the feed ID
+public fun feed_id(feed: &Feed): u32 {
+    feed.feed_id
+}
+
+/// Get the price
+public fun price(feed: &Feed): Option<Option<I64>> {
+    feed.price
+}
+
+/// Get the best bid price
+public fun best_bid_price(feed: &Feed): Option<Option<I64>> {
+    feed.best_bid_price
+}
+
+/// Get the best ask price
+public fun best_ask_price(feed: &Feed): Option<Option<I64>> {
+    feed.best_ask_price
+}
+
+/// Get the publisher count
+public fun publisher_count(feed: &Feed): Option<u16> {
+    feed.publisher_count
+}
+
+/// Get the exponent
+public fun exponent(feed: &Feed): Option<I16> {
+    feed.exponent
+}
+
+/// Get the confidence interval
+public fun confidence(feed: &Feed): Option<Option<I64>> {
+    feed.confidence
+}
+
+/// Get the funding rate
+public fun funding_rate(feed: &Feed): Option<Option<I64>> {
+    feed.funding_rate
+}
+
+/// Get the funding timestamp
+public fun funding_timestamp(feed: &Feed): Option<Option<u64>> {
+    feed.funding_timestamp
+}

lazer/contracts/sui/sources/i16.move

@@ -0,0 +1,150 @@
+/// Adopted from pyth::i64, adapted for i16
+
+module pyth_lazer::i16;
+
+const MAX_POSITIVE_MAGNITUDE: u64 = (1 << 15) - 1;  // 32767
+const MAX_NEGATIVE_MAGNITUDE: u64 = (1 << 15);      // 32768
+
+/// To consume these values, first call `get_is_negative()` to determine if the I16
+/// represents a negative or positive value. Then call `get_magnitude_if_positive()` or
+/// `get_magnitude_if_negative()` to get the magnitude of the number in unsigned u64 format.
+/// This API forces consumers to handle positive and negative numbers safely.
+public struct I16 has copy, drop, store {
+    negative: bool,
+    magnitude: u64,
+}
+
+public fun new(magnitude: u64, mut negative: bool): I16 {
+    let mut max_magnitude = MAX_POSITIVE_MAGNITUDE;
+    if (negative) {
+        max_magnitude = MAX_NEGATIVE_MAGNITUDE;
+    };
+    assert!(magnitude <= max_magnitude, 0); //error::magnitude_too_large()
+
+    // Ensure we have a single zero representation: (0, false).
+    // (0, true) is invalid.
+    if (magnitude == 0) {
+        negative = false;
+    };
+
+    I16 {
+        magnitude,
+        negative,
+    }
+}
+
+public fun get_is_negative(i: &I16): bool {
+    i.negative
+}
+
+public fun get_magnitude_if_positive(in: &I16): u64 {
+    assert!(!in.negative, 0); // error::negative_value()
+    in.magnitude
+}
+
+public fun get_magnitude_if_negative(in: &I16): u64 {
+    assert!(in.negative, 0); //error::positive_value()
+    in.magnitude
+}
+
+public fun from_u16(from: u16): I16 {
+    // Use the MSB to determine whether the number is negative or not.
+    let from_u64 = (from as u64);
+    let negative = (from_u64 >> 15) == 1;
+    let magnitude = parse_magnitude(from_u64, negative);
+
+    new(magnitude, negative)
+}
+
+fun parse_magnitude(from: u64, negative: bool): u64 {
+    // If positive, then return the input verbatim
+    if (!negative) {
+        return from
+    };
+
+    // Otherwise convert from two's complement by inverting and adding 1
+    // For 16-bit numbers, we only invert the lower 16 bits
+    let inverted = from ^ 0xFFFF;
+    inverted + 1
+}
+
+#[test]
+fun test_max_positive_magnitude() {
+    new(0x7FFF, false);  // 32767
+    assert!(&new((1<<15) - 1, false) == &from_u16(((1<<15) - 1) as u16), 1);
+}
+
+#[test]
+#[expected_failure]
+fun test_magnitude_too_large_positive() {
+    new(0x8000, false);  // 32768
+}
+
+#[test]
+fun test_max_negative_magnitude() {
+    new(0x8000, true);   // 32768
+    assert!(&new(1<<15, true) == &from_u16((1<<15) as u16), 1);
+}
+
+#[test]
+#[expected_failure]
+fun test_magnitude_too_large_negative() {
+    new(0x8001, true);   // 32769
+}
+
+#[test]
+fun test_from_u16_positive() {
+    assert!(from_u16(0x1234) == new(0x1234, false), 1);
+}
+
+#[test]
+fun test_from_u16_negative() {
+    assert!(from_u16(0xEDCC) == new(0x1234, true), 1);
+}
+
+#[test]
+fun test_get_is_negative() {
+    assert!(get_is_negative(&new(234, true)) == true, 1);
+    assert!(get_is_negative(&new(767, false)) == false, 1);
+}
+
+#[test]
+fun test_get_magnitude_if_positive_positive() {
+    assert!(get_magnitude_if_positive(&new(7686, false)) == 7686, 1);
+}
+
+#[test]
+#[expected_failure]
+fun test_get_magnitude_if_positive_negative() {
+    assert!(get_magnitude_if_positive(&new(7686, true)) == 7686, 1);
+}
+
+#[test]
+fun test_get_magnitude_if_negative_negative() {
+    assert!(get_magnitude_if_negative(&new(7686, true)) == 7686, 1);
+}
+
+#[test]
+#[expected_failure]
+fun test_get_magnitude_if_negative_positive() {
+    assert!(get_magnitude_if_negative(&new(7686, false)) == 7686, 1);
+}
+
+#[test]
+fun test_single_zero_representation() {
+    assert!(&new(0, true) == &new(0, false), 1);
+    assert!(&new(0, true) == &from_u16(0), 1);
+    assert!(&new(0, false) == &from_u16(0), 1);
+}
+
+#[test]
+fun test_boundary_values() {
+    // Test positive boundary
+    assert!(from_u16(0x7FFF) == new(32767, false), 1);
+
+    // Test negative boundary
+    assert!(from_u16(0x8000) == new(32768, true), 1);
+
+    // Test -1
+    assert!(from_u16(0xFFFF) == new(1, true), 1);
+}