pythnet: replace pythnet_sdk with the right files (#803)

Author: Reisen

pythnet/pythnet_sdk/Cargo.toml

@@ -1,30 +1,40 @@
 [package]
-name = "solana-pyth"
+name = "pythnet-sdk"
 version = "1.13.6"
 description = "Pyth Runtime for Solana"
 authors = ["Pyth Data Association"]
 repository = "https://github.com/pyth-network/pythnet"
 edition = "2021"
 
+[lib]
+crate-type = ["lib"]
+name = "solana_pyth"
+
 [dependencies]
-borsh = "0.9.1"
 bincode = "1.3.1"
+borsh = "0.9.1"
 bytemuck = { version = "1.11.0", features = ["derive"] }
 fast-math = "0.1"
 hex = { version = "0.4.3", features = ["serde"] }
 serde = { version = "1.0.144", features = ["derive"] }
+serde_wormhole = { git = "https://github.com/wormhole-foundation/wormhole" }
 sha3 = "0.10.4"
 slow_primes = "0.1.14"
+wormhole-sdk = { git = "https://github.com/wormhole-foundation/wormhole" }
 
 [dev-dependencies]
+base64 = "0.21.0"
 rand = "0.7.0"
-
-[lib]
-crate-type = ["lib"]
-name = "solana_pyth"
+serde_json = "1.0.96"
+solana-client = { path = "../client" }
+solana-sdk = { path = "../sdk" }
+proptest = "1.1.0"
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
 
 [build-dependencies]
 rustc_version = "0.4"
+
+[patch.crates-io]
+serde_wormhole = { git = "https://github.com/wormhole-foundation/wormhole" }

pythnet/pythnet_sdk/examples/generate_pyth_data.rs

@@ -0,0 +1,124 @@
+// Use the Solana client library to pull the addresses of all relevant accounts from PythNet so we
+// can test locally.
+
+// #![feature(proc_macro_hygiene)]
+
+use {
+    serde_json::json,
+    solana_client::rpc_client::RpcClient,
+    solana_pyth::PYTH_PID,
+    solana_sdk::pubkey::Pubkey,
+    std::str::FromStr,
+    std::io::Write,
+};
+
+fn main() {
+    let client = RpcClient::new("http://pythnet.rpcpool.com/".to_string());
+    let pythnet = Pubkey::from_str("FsJ3A3u2vn5cTVofAjvy6y5kwABJAqYWpe4975bi2epH").unwrap();
+    let wormhole = Pubkey::from_str("H3fxXJ86ADW2PNuDDmZJg6mzTtPxkYCpNuQUTgmJ7AjU").unwrap();
+
+    // Create a folder called `accounts` in the current directory, if it already exists that is OK
+    // but only if the folder is empty.
+    std::fs::create_dir_all("accounts").unwrap();
+
+    // Download all PythNet accounts into .json files in the current directory.
+    {
+        let pythnet_accounts = client.get_program_accounts(&pythnet).map_err(|e| {
+            println!("{e}");
+            e
+        });
+
+        pythnet_accounts
+            .unwrap()
+            .into_iter()
+            .for_each(|(pubkey, _account)| {
+                // This writes the account as JSON into a file that solana-test-validator can read into
+                // the ledger. Each account should be written into a file named `<pubkey>.json`
+                let account = client.get_account(&pubkey).unwrap();
+
+                // Now write to <pubkey>.json.
+                std::fs::write(
+                    format!("accounts/{pubkey}.json"),
+                    json!({
+                        "pubkey": pubkey.to_string(),
+                        "account": {
+                            "lamports": account.lamports,
+                            "data": [
+                                base64::encode(&account.data),
+                                "base64"
+                            ],
+                            "owner": account.owner.to_string(),
+                            "executable": account.executable,
+                            "rentEpoch": account.rent_epoch,
+                        }
+                    })
+                    .to_string(),
+                )
+                .unwrap();
+            });
+    }
+
+    // Download the Wormhole program only into a .json file in the current directory. Instead of
+    // getting the program accounts we just want the wormhole one itself.
+    {
+        let wormhole_account = client.get_account(&wormhole).unwrap();
+
+        // Now write to wormhole.json.
+        std::fs::write(
+            format!("accounts/{wormhole}.json"),
+            json!({
+                "pubkey": wormhole.to_string(),
+                "account": {
+                    "lamports": wormhole_account.lamports,
+                    "data": [
+                        base64::encode(&wormhole_account.data),
+                        "base64"
+                    ],
+                    "owner": wormhole_account.owner.to_string(),
+                    "executable": wormhole_account.executable,
+                    "rentEpoch": wormhole_account.rent_epoch,
+                }
+            })
+            .to_string(),
+        )
+        .unwrap();
+    }
+
+    // Same for the Pyth program.
+    {
+        let pyth_account = client.get_account(&pythnet).unwrap();
+
+        // Now write to pyth.json.
+        std::fs::write(
+            format!("accounts/{pythnet}.json"),
+            json!({
+                "pubkey": pythnet.to_string(),
+                "account": {
+                    "lamports": pyth_account.lamports,
+                    "data": [
+                        base64::encode(&pyth_account.data),
+                        "base64"
+                    ],
+                    "owner": pyth_account.owner.to_string(),
+                    "executable": pyth_account.executable,
+                    "rentEpoch": pyth_account.rent_epoch,
+                }
+            })
+            .to_string(),
+        )
+        .unwrap();
+    }
+
+    // Write names of AccumulatorState accounts to pdas.txt
+    {
+        let mut file = std::fs::File::create("pdas.txt").unwrap();
+        for i in (0..10_000u32) {
+            let (accumulator_account, _) = Pubkey::find_program_address(
+                &[b"AccumulatorState", &PYTH_PID, &i.to_be_bytes()],
+                &solana_sdk::system_program::id(),
+            );
+            file.write_all(format!("{}\n", accumulator_account).as_bytes())
+                .unwrap();
+        }
+    }
+}

pythnet/pythnet_sdk/src/accumulators.rs

@@ -1,9 +1,31 @@
+//! Accumulators
+//!
+//! This module defines the Accumulator abstraction as well as the implementation details for
+//! several different accumulators. This library can be used for interacting with PythNet state
+//! proofs for account content.
+
 pub mod merkle;
-mod mul;
+pub mod mul;
+
+/// The Accumulator trait defines the interface for an accumulator.
+///
+/// This trait assumes an accumulator has an associated proof type that can be used to prove
+/// membership of a specific item. The choice to return Proof makes this the most generic
+/// implementation possible for any accumulator.
+pub trait Accumulator<'a>
+where
+    Self: Sized,
+    Self::Proof: 'a,
+    Self::Proof: Sized,
+{
+    type Proof;
 
-pub trait Accumulator<'a>: Sized {
-    type Proof: 'a;
-    fn from_set(items: impl Iterator<Item = &'a &'a [u8]>) -> Option<Self>;
+    /// Prove an item is a member of the accumulator.
     fn prove(&'a self, item: &[u8]) -> Option<Self::Proof>;
-    fn verify(&'a self, proof: Self::Proof, item: &[u8]) -> bool;
+
+    /// Verify an item is a member of the accumulator.
+    fn check(&'a self, proof: Self::Proof, item: &[u8]) -> bool;
+
+    /// Create an accumulator from a set of items.
+    fn from_set(items: impl Iterator<Item = &'a [u8]>) -> Option<Self>;
 }