svm guide update

Author: aditya520

pages/lazer/integrate-as-consumer/how-lazer-works.mdx renamed to pages/lazer/how-lazer-works.mdx

@@ -14,21 +14,176 @@ Integrating with Pyth Lazer in smart contracts as a consumer is a three-step pro
 
 ### Use Pyth Lazer SDK into smart contracts
 
-Pyth Lazer provides [pyth-lazer-sdk]() crate, which allows consumers to parse the price updates.
+Pyth Lazer provides a [Rust SDK](https://github.com/pyth-network/pyth-crosschain/tree/main/lazer/sdk/rust), which allows consumers to parse the price updates.
+
+Add the following to your `Cargo.toml` file:
+
+```toml copy
+[dependencies]
+pyth-lazer-sdk = 0.1.0
+```
+
+Now you can create an instruction or multiple instructions that will receive Pyth Lazer messages.
+The instruction data sent to your program should include a byte array containing the Pyth Lazer message. The instruction data can also contain any other parameters your contracts may need.
+
+In order to successfully validate the Pyth Lazer message, the instruction needs to receive the standard Solana sysvar account and Pyth Lazer storage account (`3rdJbqfnagQ4yx9HXJViD4zc4xpiSqmFsKpPuSCQVyQL`). You may also add any other accounts you need.
+
+The following code can be used to set up a new instruction within a Solana contract:
+
+```rust copy
+use num_derive::FromPrimitive;
+use num_traits::FromPrimitive;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, FromPrimitive)]
+pub enum Instruction {
+    //...
+    /// Update price.
+    /// Data: `UpdateArgs` followed by a signed Pyth Lazer update.
+    /// Accounts:
+    /// 1. sysvar account [readonly] - required for Pyth Lazer
+    /// 2. data account [writable] - needed by our example contract
+    /// 3. pyth storage account [readonly] - required for Pyth Lazer
+    Update = 1,
+}
+
+/// Inputs to the `Update` instruction. `UpdateArgs` must be followed by a signed Pyth Lazer message.
+#[derive(Debug, Clone, Copy, Zeroable, Pod)]
+#[repr(C, packed)]
+pub struct UpdateArgs {
+    /// Example argument
+    pub hello: u64,
+}
+
+/// Program entrypoint's implementation.
+pub fn process_instruction(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> ProgramResult {
+    // In our example contract, the first byte is the ID of the instruction.
+    let instruction = *instruction_data
+        .first()
+        .ok_or(ProgramError::InvalidInstructionData)?;
+    let instruction =
+        Instruction::from_u8(instruction).ok_or(ProgramError::InvalidInstructionData)?;
+    let instruction_args = &instruction_data[1..];
+
+    match instruction {
+        Instruction::Initialize => {
+            process_initialize_instruction(program_id, accounts, instruction_args)
+        }
+        Instruction::Update => process_update_instruction(program_id, accounts, instruction_args),
+    }
+}
+
+pub fn process_update_instruction(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_args: &[u8],
+) -> ProgramResult {
+    // Verify accounts passed to the instruction.
+    if accounts.len() != 3 {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    }
+    let sysvar_account = &accounts[0];
+    let data_account = &accounts[1];
+    let pyth_storage_account = &accounts[2];
+    // See below for next steps...
+}
+```
+
+Call `pyth_lazer_sdk::verify_message{:rust}` function with appropriate arguments to validate the Pyth Lazer signature of the message.
+
+```rust copy
+// Offset of pyth message within the original instruction_data.
+// 1 byte is the instruction id.
+let pyth_message_total_offset = size_of::<UpdateArgs>() + 1;
+// We expect the instruction to the built-in ed25519 program to be
+// the first instruction within the transaction.
+let ed25519_instruction_index = 0;
+// We expect our signature to be the first (and only) signature to be checked
+// by the built-in ed25519 program within the transaction.
+let signature_index = 0;
+// Check signature verification.
+let verified = pyth_lazer_sdk::verify_message(
+    pyth_storage_account,
+    sysvar_account,
+    pyth_message,
+    ed25519_instruction_index,
+    signature_index,
+    pyth_message_total_offset.try_into().unwrap(),
+)?;
+```
+
+<Callout type="info" icon="💡">
+  Note: When using native ed25519 signatures on Solana, we must use the built-in
+  ed25519 program provided by the Solana runtime. This program can't be invoked
+  from another contract. Instead, it must be called in an explicit instruction
+  within the submitted transaction. This means that the sender of the
+  transaction must include that instruction in the transaction. Our SDK
+  leverages Solana runtime capabilities to ensure the ed25519 program has been
+  correctly called in the transaction.
+</Callout>
+
+Now Parse the Pyth Lazer message.
+
+```rust copy
+// Deserialize and use the payload.
+let data = PayloadData::deserialize_slice_le(verified.payload)
+    .map_err(|_| ProgramError::InvalidInstructionData)?;
+
+if data.feeds.is_empty() || data.feeds[0].properties.is_empty() {
+    return Err(ProgramError::InvalidInstructionData);
+}
+```
+
+Now you can update the state accourding to the contract's logic.
+
+```rust copy
+// Read the data PDA of our example contract.
+let mut state_data = data_account.data.borrow_mut();
+let state =
+    try_from_bytes_mut::<State>(*state_data).map_err(|_| ProgramError::InvalidAccountData)?;
+
+if state.price_feed != data.feeds[0].feed_id.0 {
+    return Err(ProgramError::InvalidInstructionData);
+}
+if data.channel_id != Channel::RealTime.id() {
+    return Err(ProgramError::InvalidInstructionData);
+}
+if data.timestamp_us.0 <= state.latest_timestamp {
+    return Err(ProgramError::AccountAlreadyInitialized);
+}
+let PayloadPropertyValue::Price(Some(price)) = data.feeds[0].properties[0] else {
+    return Err(ProgramError::InvalidInstructionData);
+};
+state.latest_price = price.into_inner().into();
+state.latest_timestamp = data.timestamp_us.0;
+```
+
+### Subscribe to Pyth Lazer to receive Price Updates
+
+Pyth Lazer provides a websocket endpoint to receive price updates. Moreover, Pyth Lazer also provides a [typescript SDK](https://github.com/pyth-network/pyth-crosschain/tree/main/lazer/sdk/js) to subscribe to the websocket endpoint.
+
+Consult [How to fetch price updates from Pyth Lazer](../fetch-price-updates.mdx) for a complete step-by-step guide.
+
+### Include the price updates into smart contract transactions
+
+Now that you have the price updates, and your smart contract is able to parse the price updates, you can include the price updates into the smart contract transactions by passing the price updates received from the previous step as an argument to the `update_price` method of your smart contract.
 
 </Steps>
 
 ## Additional Resources
 
-You may find these additional resources helpful for integrating Pyth Lazer into your EVM smart contracts.
+You may find these additional resources helpful for integrating Pyth Lazer into your Solana smart contracts.
 
 ### Price Feed IDs
 
 Pyth Lazer supports a wide range of price feeds. Consult the [Price Feed IDs](../price-feeds.mdx) page for a complete list of supported price feeds.
 
 ### Examples
 
-[Pyth-lazer-example-evm](https://github.com/pyth-network/pyth-examples/tree/main/lazer/evm) is a simple example contract that parses and consumes price updates from Pyth Lazer.
+[pyth-lazer-example-solana](https://github.com/pyth-network/pyth-examples/tree/main/lazer/solana) is a simple example contract that parses and consumes price updates from Pyth Lazer.
 
 [pyth-lazer-example-js](https://github.com/pyth-network/pyth-examples/tree/main/lazer/js) is a simple example for subscribing to the Pyth Lazer websocket.
 
@@ -38,4 +193,4 @@ TODO:
 
 ### Error Codes
 
-TODO: Add error codes for EVM.
+TODO: Add error codes for Solana.