Claim a VIDA

In the PWR Chain ecosystem, Verifiable Immutable Data Applications (VIDAs) play a crucial role in enabling developers to build and deploy decentralized applications (dApps). Each VIDA is identified by a unique ID, known as the VIDA. As a developer, you need to claim a VIDA to indicate that it is being used by your application and to receive certain benefits.

In this guide, we'll walk you through the process of claiming a VIDA on the PWR Chain using the PWR SDK.

Understanding VIDAs

A VIDA is a unique identifier that represents a specific Virtual Machine on the PWR Chain. It serves as an address for your application, allowing it to interact with the PWR Chain and other applications.

Claiming a VIDA has the following benefits:

1. Ownership: By claiming a VIDA, you establish ownership of that particular VIDA. It informs others that the VIDA is being used by your application and is not available for others to claim.
2. Transaction Fee Rewards: When you claim a VIDA, you become eligible to receive 15% of the transaction fees generated by transactions sent to your VIDA. This serves as a reward for developers and helps incentivize the development of dApps on the PWR Chain.

Claiming a VIDA

To claim a VIDA on the PWR Chain, follow these steps:

1. Create a PWR Wallet: If you haven't already, create a PWR wallet that will be used to claim the VIDA. You can refer to the Wallets in PWR Chain guide for detailed instructions.
2. Unique VIDA: Choose a unique VIDA, no one has claimed it.
3. Claim the VIDA: Use the PWR SDK to claim the VIDA by sending a "Claim VIDA" transaction.

JavaScript

const { PWRWallet } = require('@pwrjs/core');

// Setting up your wallet in the SDK
const privateKey = "YOUR_PRIVATE_KEY_HERE";
const wallet = new PWRWallet(privateKey);

async function claim() {
    // Add a unique VIDA ID
    const vidaId = 102030;

    // Claim the VIDA ID
    const txHash = await wallet.claimVmId(vidaId);

    // Error handling
    if (txHash.success) {
        console.log("Transaction Hash:", txHash.transactionHash);
    } else {
        console.log("Error:", txHash.message);
    }
}
claim()

Python

from pwrpy.pwrwallet import PWRWallet

# Setting up your wallet in the SDK
private_key = "YOUR_PRIVATE_KEY_HERE"
wallet = PWRWallet(private_key)

def claim():
    # Add a unique VIDA
    vida_id = 102030

    # Claim the VIDA
    tx = wallet.claim_vm_id(vida_id)

    # Error handling
    if tx.success:
        print("Transaction Hash:", tx.data)
    else:
        print("Error:", tx.message)
claim()

Rust

use pwr_rs::Wallet;

async fn claim() {
    // Setting up your wallet in the SDK
    let private_key = "YOUR_PRIVATE_KEY_HERE";
    let wallet = Wallet::from_hex(&private_key).unwrap();

    // Add a unique VIDA ID
    let vida_id = 102030;

    // Claim the VIDA ID
    let tx = wallet.claim_vm_id(vida_id).await;

    // Error handling
    if tx.success {
        println!("Transaction Hash: {tx.data.unwrap()}");
    } else {
        println!("Error: {tx.error}");
    }
}

Go

package main

import (
    "github.com/pwrlabs/pwrgo/wallet"
    "fmt"
)

// Add your private key here
var privateKey = "YOUR_PRIVATE_KEY_HERE"

func ClaimVmId() {
    // Setting up your wallet in the SDK
    wallet := wallet.FromPrivateKey(privateKey)

    // Add a unique VIDA ID
    vidaId := 102030

    // Claim the VIDA ID
    tx := wallet.ClaimVMId(vidaId)

    // Error handling
    if tx.Success {
        fmt.Printf("Transaction Hash: %s\n", tx.TxHash)
    } else {
        fmt.Println("Error:", tx.Error)
    }
}

C#

using PWR;
using PWR.Models;

class Program
{
    static async Task Main()
    {
        // Add your private key here
        string privateKey = "YOUR_PRIVATE_KEY_HERE";
        // Setting up your wallet in the SDK
        var wallet = new PwrWallet(privateKey);

        // Add a unique VIDA ID
        ulong vidaId = 102030;

        // Claim the VIDA ID
        WalletResponse tx = await wallet.ClaimVMId(vidaId);

        // Error handling
        if (tx.Success) {
            Console.WriteLine($"Transaction Hash: {tx.TxnHash}");
        } else {
            Console.WriteLine($"Error: {tx.Error}");
        }
    }
}

Java

Using the wallet's claimVmId method, we claim the VIDA by providing the VIDA ID. The SDK will handle the creation and signing of the "Claim VIDA" transaction.

If the transaction is successfully sent, we receive a response containing the transaction hash. Otherwise, we handle the error accordingly.

Once the transaction is confirmed, the VIDA is successfully claimed, and you become the owner of that VIDA. You will start receiving 15% of the transaction fees generated by transactions sent to your VIDA.

Best Practices for Claiming VIDAs

When claiming VIDAs on the PWR Chain, consider the following best practices:

1. Choose a Unique VIDA: Ensure that the VIDA you generate is unique and not already claimed by another application. Collision of VIDAs can lead to conflicts and unexpected behavior.
2. Secure Your Private Key: Keep your wallet's private key secure and never share it with anyone.
3. Monitor Your VIDA: Regularly monitor your claimed VIDA for any suspicious activities or unauthorized transactions.
4. Update Your Application: Keep your application up to date with the latest PWR Chain features and security patches.

By following these best practices and leveraging the PWR SDK's VIDA claiming capabilities, you can securely claim a VIDA for your application on the PWR Chain, establish ownership, and receive transaction fee rewards for your dApp's usage.