show magic, account type and version usage; simplify rust package

Author: richardbrooks2000

pcrust/Cargo.toml

@@ -1,12 +1,19 @@
 [package]
-name = "pcrust"
+name = "pyth-client"
 version = "0.1.0"
-authors = ["Richard Brooks <[email protected]>"]
+authors = ["Richard Brooks"]
 edition = "2018"
+license = "Apache-2.0"
+homepage = "https://pyth.network"
+repository = "https://github.com/pyth-network/pyth-client"
+description = "pyth price oracle data structures and example usage"
+readme = "false"
+keywords = [ "pyth", "solana", "oracle" ]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-solana-client = { path="../../solana/client" }
-solana-sdk = { path="../../solana/sdk" }
-solana-program = { path="../../solana/sdk/program" }
+solana-client = "1.6.7"
+solana-sdk = "1.6.7"
+solana-program = "1.6.7"
+

pcrust/src/lib.rs

@@ -1 +1,137 @@
-pub mod pc;
+pub const MAGIC          : u32   = 0xa1b2c3d4;
+pub const VERSION_1      : u32   = 1;
+pub const VERSION        : u32   = VERSION_1;
+pub const MAP_TABLE_SIZE : usize = 640;
+pub const PROD_ACCT_SIZE : usize = 512;
+pub const PROD_HDR_SIZE  : usize = 48;
+pub const PROD_ATTR_SIZE : usize = PROD_ACCT_SIZE - PROD_HDR_SIZE;
+
+// each account has its own type
+#[repr(C)]
+pub enum AccountType
+{
+  Unknown,
+  Mapping,
+  Product,
+  Price
+}
+
+// aggregate and contributing prices are associated with a status
+// only Trading status is valid
+#[repr(C)]
+pub enum PriceStatus
+{
+  Unknown,
+  Trading,
+  Halted,
+  Auction
+}
+
+// ongoing coporate action event - still undergoing dev
+#[repr(C)]
+pub enum CorpAction
+{
+  NoCorpAct
+}
+
+// different types of prices associated with a product
+#[repr(C)]
+pub enum PriceType
+{
+  Unknown,
+  Price,
+  TWAP,
+  Volatility
+}
+
+// solana public key
+#[repr(C)]
+pub struct AccKey
+{
+  pub val: [u8;32]
+}
+
+// Mapping account structure
+#[repr(C)]
+pub struct Mapping
+{
+  pub magic      : u32,        // pyth magic number
+  pub ver        : u32,        // program version
+  pub atype      : u32,        // account type
+  pub size       : u32,        // account used size
+  pub num        : u32,        // number of product accounts
+  pub unused     : u32,
+  pub next       : AccKey,     // next mapping account (if any)
+  pub products   : [AccKey;MAP_TABLE_SIZE]
+}
+
+// Product account structure
+#[repr(C)]
+pub struct Product
+{
+  pub magic      : u32,        // pyth magic number
+  pub ver        : u32,        // program version
+  pub atype      : u32,        // account type
+  pub size       : u32,        // price account size
+  pub px_acc     : AccKey,     // first price account in list
+  pub attr       : [u8;PROD_ATTR_SIZE]
+}
+
+// contributing or aggregate price component
+#[repr(C)]
+pub struct PriceInfo
+{
+  pub price      : i64,
+  pub conf       : u64,
+  pub status     : PriceStatus,
+  pub corp_act   : CorpAction,
+  pub pub_slot   : u64
+}
+
+// latest component price and price used in aggregate snapshot
+#[repr(C)]
+pub struct PriceComp
+{
+  publisher  : AccKey,
+  agg        : PriceInfo,
+  latest     : PriceInfo
+}
+
+// Price account structure
+#[repr(C)]
+pub struct Price
+{
+  pub magic      : u32,        // pyth magic number
+  pub ver        : u32,        // program version
+  pub atype      : u32,        // account type
+  pub size       : u32,        // price account size
+  pub ptype      : PriceType,  // price or calculation type
+  pub expo       : i32,        // price exponent
+  pub num        : u32,        // number of component prices
+  pub unused     : u32,
+  pub curr_slot  : u64,        // currently accumulating price slot
+  pub valid_slot : u64,        // valid slot-time of agg. price
+  pub prod       : AccKey,
+  pub next       : AccKey,
+  pub agg_pub    : AccKey,
+  pub agg        : PriceInfo,
+  pub comp       : [PriceComp;16]
+}
+
+struct AccKeyU64
+{
+  pub val: [u64;4]
+}
+
+pub fn cast<T>( d: &[u8] ) -> &T {
+  let (_, pxa, _) = unsafe { d.align_to::<T>() };
+  &pxa[0]
+}
+
+impl AccKey
+{
+  pub fn is_valid( &self ) -> bool  {
+    let k8 = cast::<AccKeyU64>( &self.val );
+    return k8.val[0]!=0 || k8.val[1]!=0 || k8.val[2]!=0 || k8.val[3]!=0;
+  }
+}

pcrust/src/main.rs

@@ -1,12 +1,18 @@
-use pcrust::{
-  pc::Mapping,
-  pc::Product,
-  pc::Price,
-  pc::PriceType,
-  pc::PriceStatus,
-  pc::CorpAction,
-  pc::cast,
-  pc::PROD_HDR_SIZE
+// example usage of pyth-client account structure
+// bootstrap all product and pricing accounts from root mapping account
+
+use pyth_client::{
+  AccountType,
+  Mapping,
+  Product,
+  Price,
+  PriceType,
+  PriceStatus,
+  CorpAction,
+  cast,
+  MAGIC,
+  VERSION_1,
+  PROD_HDR_SIZE
 };
 use solana_client::{
   rpc_client::RpcClient
@@ -68,13 +74,23 @@ fn main() {
     // get Mapping account from key
     let map_data = clnt.get_account_data( &akey ).unwrap();
     let map_acct = cast::<Mapping>( &map_data );
+    assert_eq!( map_acct.magic, MAGIC, "not a valid pyth account" );
+    assert_eq!( map_acct.atype, AccountType::Mapping as u32,
+                "not a valid pyth mapping account" );
+    assert_eq!( map_acct.ver, VERSION_1,
+                "unexpected pyth mapping account version" );
 
     // iget and print each Product in Mapping directory
     let mut i = 0;
     for prod_akey in &map_acct.products {
       let prod_pkey = Pubkey::new( &prod_akey.val );
       let prod_data = clnt.get_account_data( &prod_pkey ).unwrap();
       let prod_acct = cast::<Product>( &prod_data );
+      assert_eq!( prod_acct.magic, MAGIC, "not a valid pyth account" );
+      assert_eq!( prod_acct.atype, AccountType::Product as u32,
+                  "not a valid pyth product account" );
+      assert_eq!( prod_acct.ver, VERSION_1,
+                  "unexpected pyth product account version" );
 
       // print key and reference data for this Product
       println!( "product_account .. {:?}", prod_pkey );
@@ -93,6 +109,11 @@ fn main() {
         loop {
           let pd = clnt.get_account_data( &px_pkey ).unwrap();
           let pa = cast::<Price>( &pd );
+          assert_eq!( pa.magic, MAGIC, "not a valid pyth account" );
+          assert_eq!( pa.atype, AccountType::Price as u32,
+                     "not a valid pyth price account" );
+          assert_eq!( pa.ver, VERSION_1,
+                      "unexpected pyth price account version" );
           println!( "  price_account .. {:?}", px_pkey );
           println!( "    price_type ... {}", get_price_type(&pa.ptype));
           println!( "    exponent ..... {}", pa.expo );