Smart contracts

Technical reference for the SadClaw Solana program.

Program Overview

The SadClaw program handles on-chain logic for VM purchases, NFT minting, and ownership management.

Program ID: SADCLAWvmProgram111111111111111111111111111

Source: github.com/techwebc/sadclaw/programs/sadclaw-vm

Instructions

Initialize

Initialize the program configuration. Called once by the admin.

pub fn initialize(
    ctx: Context<Initialize>,
    admin: Pubkey,
    treasury: Pubkey,
    usdc_mint: Pubkey,
) -> Result<()>

Accounts:

Account	Type	Description
config	PDA	Program config account
payer	Signer	Transaction payer
system_program	Program	System program

CreateTier

Create a new VM pricing tier.

pub fn create_tier(
    ctx: Context<CreateTier>,
    tier_id: u8,
    name: String,
    price_per_hour: u64,
    vcpus_min: u8,
    vcpus_max: u8,
    ram_gb_min: u8,
    ram_gb_max: u8,
) -> Result<()>

Accounts:

Account	Type	Description
config	PDA	Program config
tier	PDA	New tier account
admin	Signer	Admin authority

PurchaseVm

Purchase a new VM with USDC.

pub fn purchase_vm(
    ctx: Context<PurchaseVm>,
    tier_id: u8,
    duration_hours: u32,
    region: String,
) -> Result<()>

Accounts:

Account	Type	Description
config	PDA	Program config
tier	PDA	Selected tier
vm_instance	PDA	New VM instance
nft_mint	Mint	New NFT mint
nft_metadata	Metaplex	NFT metadata
buyer	Signer	Purchaser
buyer_usdc	TokenAccount	Buyer's USDC account
treasury_usdc	TokenAccount	Treasury USDC account
token_program	Program	SPL Token program
metadata_program	Program	Metaplex program

Logic:

1. Calculate cost: tier.price_per_hour * duration_hours

2. Transfer USDC from buyer to treasury

3. Create VM instance PDA

4. Mint NFT to buyer

5. Create NFT metadata

ExtendVm

Extend an existing VM's duration.

pub fn extend_vm(
    ctx: Context<ExtendVm>,
    additional_hours: u32,
) -> Result<()>

Accounts:

Account	Type	Description
vm_instance	PDA	Existing VM
tier	PDA	VM's tier
nft_mint	Mint	VM's NFT
owner	Signer	NFT owner
owner_usdc	TokenAccount	Owner's USDC
treasury_usdc	TokenAccount	Treasury USDC

DestroyVm

Destroy a VM and burn its NFT.

pub fn destroy_vm(
    ctx: Context<DestroyVm>,
) -> Result<()>

Accounts:

Account	Type	Description
vm_instance	PDA	VM to destroy
nft_mint	Mint	VM's NFT
nft_token_account	TokenAccount	Owner's NFT account
owner	Signer	NFT owner
token_program	Program	SPL Token program

Logic:

1. Verify owner holds the NFT

2. Burn the NFT

3. Mark VM instance as destroyed

4. Close the VM instance account

PDAs

Config

Global program configuration.

Seeds: ["config"]

pub struct VmConfig {
    pub admin: Pubkey,
    pub treasury: Pubkey,
    pub usdc_mint: Pubkey,
    pub total_vms: u64,
    pub total_revenue: u64,
    pub bump: u8,
}

Tier

VM pricing tier.

Seeds: ["tier", tier_id]

pub struct VmTier {
    pub id: u8,
    pub name: String,
    pub price_per_hour: u64,  // In USDC lamports (6 decimals)
    pub vcpus_min: u8,
    pub vcpus_max: u8,
    pub ram_gb_min: u8,
    pub ram_gb_max: u8,
    pub active: bool,
    pub bump: u8,
}

VM Instance

Individual VM state.

Seeds: ["vm", vm_id]

pub struct VmInstance {
    pub id: u64,
    pub owner: Pubkey,
    pub nft_mint: Pubkey,
    pub tier_id: u8,
    pub region: String,
    pub status: VmStatus,
    pub created_at: i64,
    pub expires_at: i64,
    pub ip_address: Option<String>,
    pub bump: u8,
}

pub enum VmStatus {
    Pending,
    Provisioning,
    Active,
    Expired,
    Destroyed,
}

Events

VmPurchased

Emitted when a VM is purchased.

#[event]
pub struct VmPurchased {
    pub vm_id: u64,
    pub owner: Pubkey,
    pub nft_mint: Pubkey,
    pub tier_id: u8,
    pub duration_hours: u32,
    pub cost: u64,
    pub region: String,
}

VmExtended

Emitted when a VM is extended.

#[event]
pub struct VmExtended {
    pub vm_id: u64,
    pub additional_hours: u32,
    pub new_expires_at: i64,
    pub cost: u64,
}

VmDestroyed

Emitted when a VM is destroyed.

#[event]
pub struct VmDestroyed {
    pub vm_id: u64,
    pub nft_mint: Pubkey,
}

Errors

pub enum SadClawError {
    #[msg("Invalid tier")]
    InvalidTier,

    #[msg("Insufficient funds")]
    InsufficientFunds,

    #[msg("VM not found")]
    VmNotFound,

    #[msg("VM expired")]
    VmExpired,

    #[msg("Not the owner")]
    NotOwner,

    #[msg("Invalid duration")]
    InvalidDuration,

    #[msg("Tier not active")]
    TierNotActive,
}

Integration

Building Transactions

import { Connection, PublicKey, Transaction } from '@solana/web3.js';

const PROGRAM_ID = new PublicKey('SADCLAWvmProgram111111111111111111111111111');

// Find PDAs
const [configPda] = PublicKey.findProgramAddressSync(
  [Buffer.from('config')],
  PROGRAM_ID
);

const [tierPda] = PublicKey.findProgramAddressSync(
  [Buffer.from('tier'), Buffer.from([tierId])],
  PROGRAM_ID
);

const [vmPda] = PublicKey.findProgramAddressSync(
  [Buffer.from('vm'), new BN(vmId).toArrayLike(Buffer, 'le', 8)],
  PROGRAM_ID
);

Listening to Events

const connection = new Connection(rpcUrl);

connection.onProgramAccountChange(
  PROGRAM_ID,
  (accountInfo) => {
    // Decode and process account changes
  },
  'confirmed'
);

Security

• All instructions verify signer authority

• NFT ownership verified before operations

• USDC transfers are atomic with state changes

• PDAs prevent account spoofing

• Duration limits prevent overflow attacks