= serde_json::to_string(&json_object).unwrap().into_bytes();
// Send transaction
let response_tx = wallet.send_vm_data(vidaId, data).await;
if response_tx.success {
println!("Transaction sent successfully!");
println!("Transaction hash: {:?}", response_tx.data.unwrap());
} else {
println!("Transaction failed: {:?}", response_tx.message);
}
```
{% endtab %}
{% tab title="Go" %}
// Write transaction data
jsonObject := map[string]string{
"action": "send-message-v1",
"message": "Hello World!",
}
data, _ := json.Marshal(jsonObject)
// Send transaction
response := wallet.SendVMData(vidaId, data)
if response.Success {
fmt.Println("Transaction sent successfully!")
fmt.Printf("Transaction hash: %s\n", response.TxHash)
} else {
fmt.Printf("Transaction failed: %s\n", response.Error)
}
{% endtab %}
{% endtabs %}
***
#### **7. Read Data from PWR Chain & Handle it.**
The PWR SDK provides functions to easily read and handle data from PWR Chain.
{% tabs %}
{% tab title="Java" %}
```java
PWRJ pwrj = new PWRJ("https://pwrrpc.pwrlabs.io/");
long vidaId = 1; // Replace with your VIDA's ID
/*Since our VIDA is global chat room and we don't care about historical messages,
we will start reading transactions startng from the latest PWR Chain block*/
long startingBlock = pwrj.getBlockNumber();
VidaTransactionSubscription vidaTransactionSubscription = pwrj.subscribeToVidaTransactions(pwrj, vidaId, startingBlock, (transaction) -> {
VmDataTransaction vmDataTransaction = transaction;
//Get the address of the transaction sender
String sender = vmDataTransaction.getSender();
//Get the data sent in the transaction (In Hex Format)
String data = vmDataTransaction.getData();
try {
//Decode the data from Hex to byte array
if (data.startsWith("0x")) data = data.substring(2);
byte[] dataBytes = Hex.decode(data);
//Convert the byte array to a JSON Object
JSONObject jsonObject = new JSONObject(new String(dataBytes));
String action = jsonObject.optString("action", "no-action");
//Check the action and execute the necessary code
if (action.equalsIgnoreCase("send-message-v1")) {
String message = jsonObject.getString("message");
System.out.println("Message from " + sender + ": " + message);
} else {
//ignore
}
} catch (Exception e) {
e.printStackTrace();
//This most likely indicates Malformed data from the sender
}
});
//To pause, resume, and stop the subscription
vidaTransactionSubscription.pause();
vidaTransactionSubscription.resume();
vidaTransactionSubscription.stop();
vidaTransactionSubscription.start();
//To get the block number of the latest checked PWR Chain block
vidaTransactionSubscription.getLatestCheckedBlock();
```
{% endtab %}
{% tab title="Javascript" %}
```javascript
const pwrj = new PWRJS("https://pwrrpc.pwrlabs.io/");
const vidaId = 1n; // Replace with your VIDA's ID
// Since our VIDA is global chat room and we don't care about historical messages, we will start reading transactions startng from the latest PWR Chain block/ long startingBlock = pwrj.getBlockNumber();
function handler(transaction: VmDataTransaction){
//Get the address of the transaction sender
const sender = VmDataTransaction.sender;
//Get the data sent in the transaction (In Hex Format)
let data = VmDataTransaction.data;
try {
// convert data string to bytes
if (data.startsWith("0x")) data = data.substring(2);
const bytes = hexToBytes(data);
const dataStr = new TextDecoder().decode(bytes);
const dataJson = JSON.parse(dataStr);
//Check the action and execute the necessary cod
if (dataJson.action === "send-message-v1") {
const message = data.message;
console.log("Message from " + sender + ": " + message);
}
} catch (e) {
console.error(e)
}
}
const subscription = pwrjs.subscribeToVidaTransactions(
pwrjs,
vidaId,
startingBlock,
{handler}
);
//To pause, resume, and stop the subscription vidaTransactionSubscription.pause(); vidaTransactionSubscription.resume(); vidaTransactionSubscription.stop(); vidaTransactionSubscription.start();
//To get the block number of the latest checked PWR Chain block vidaTransactionSubscription.getLatestCheckedBlock();
```
{% endtab %}
{% tab title="Python" %}
```python
from pwrpy.pwrsdk import PWRPY
from pwrpy.models.Transaction import VmDataTransaction
import json
import time
rpc = PWRPY()
vida_id = 1
# Since our VIDA is global chat room and we don't care about historical messages,
# we will start reading transactions startng from the latest PWR Chain block
starting_block = rpc.get_latest_block_number()
def handle_transaction(txn: VmDataTransaction):
try:
sender = txn.sender
data_hex = txn.data
data_bytes = bytes.fromhex(data_hex[2:])
obj = json.loads(data_bytes.decode('utf-8'))
if obj["action"] == "send-message-v1":
print(f"Message from {sender}: {obj['message']}")
except Exception as e:
print(f"Error processing transaction: {e}")
rpc.subscribe_to_vida_transactions(vida_id, starting_block, handler=handle_transaction)
while True:
time.sleep(1)
```
{% endtab %}
{% tab title="Rust" %}
```rust
use pwr_rs::{
RPC,
transaction::types::VMDataTransaction,
rpc::tx_subscription::VidaTransactionHandler
};
use std::sync::Arc;
use serde_json::Value;
#[tokio::main]
async fn main() {
let rpc = Arc::new(RPC::new("https://pwrrpc.pwrlabs.io/").await.unwrap());
let vida_id = 1;
let starting_block = rpc.get_latest_block_number().await.unwrap();
struct Handler(Box);
impl VidaTransactionHandler for Handler {
fn process_vida_transactions(&self, tx: VMDataTransaction) {
(self.0)(tx)
}
}
let handler = Arc::new(Handler(Box::new(|txn: VMDataTransaction| {
let sender = txn.sender;
let data = txn.data;
let data_str = String::from_utf8(data).unwrap();
let object: Value = serde_json::from_str(&data_str).unwrap();
let obj_map = object.as_object().unwrap();
if obj_map.get("action").and_then(|val| val.as_str()) == Some("send-message-v1")
{
if let Some(message_str) = obj_map
.get("message")
.and_then(|val| val.as_str())
{
println!("Message from {}: {}", sender, message_str);
}
}
})));
rpc.subscribe_to_vida_transactions(vida_id, starting_block, handler, None);
loop {
tokio::time::sleep(std::time::Duration::from_millis(1)).await;
}
}
```
{% endtab %}
{% tab title="Go" %}
import (
"fmt"
"encoding/json"
"encoding/hex"
"github.com/pwrlabs/pwrgo/rpc"
)
type MyHandler struct{}
func (h *MyHandler) ProcessVidaTransactions(tx rpc.VMDataTransaction) {
sender := tx.Sender
data := tx.Data
dataBytes, _ := hex.DecodeString(data[2:])
var obj map[string]interface{}
if err := json.Unmarshal(dataBytes, &obj); err != nil {
fmt.Println("Error parsing JSON:", err)
}
if action, _ := obj["action"].(string); action == "send-message-v1" {
message, _ := obj["message"].(string)
fmt.Printf("Message from %s: %s\n", sender, message)
}
}
func main() {
vidaId := 1
startingBlock := rpc.GetLatestBlockNumber()
handler := &MyHandler{}
rpc.SubscribeToVidaTransactions(
vidaId,
startingBlock,
handler,
)
select {}
}
{% endtab %}
{% endtabs %}
***
#### **8. Make Your App Public**
Once your VIDA is ready, share it with others by publishing it:
* **Option 1:** Open-source your code on GitHub with clear instructions.
* **Option 2:** Publish it on the PWR Chain registry for decentralized discovery. *(Coming Soon)*
***
#### **Key Considerations for Stateless VIDAs**
* **No State Management:** Stateless VIDAs do not track or validate past transactions, making them fast but unsuitable for critical use cases.
* **Ideal Use Cases:** Applications prioritizing speed and simplicity over consistency (e.g., chat apps, simple games).
By following these steps, you can build a lightweight and efficient Stateless VIDA that leverages the power of PWR Chain while keeping development simple!
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://whitepaperv2.pwrlabs.io/how-to/how-to-build-a-vida/building-a-stateless-vida.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.