Carbon Player Profile Decoder

Rust decoder for the Star Atlas Player Profile program on Solana, generated using Carbon CLI.

Program Information

Program ID: pprofELXjL5Kck7Jn5hCpwAL82DpTkSYBENzahVtbc9
Network: Solana Mainnet
Description: Star Atlas Player Profile program for managing player identities, permissions, and role-based access control within the Star Atlas ecosystem.

Features

Decodes all Player Profile account types
Full instruction parsing support
Integration with Carbon indexing framework
Permission bitflags support for ergonomic permission checking
Helper methods for key expiration and authorization checks

Usage

Add this crate to your Cargo.toml:

[dependencies]
carbon-player-profile-decoder = "0.12.0"

Decoding Accounts

use carbon_player_profile_decoder::{PlayerProfileDecoder, PlayerProfileAccount};
use carbon_core::account::AccountDecoder;

let decoder = PlayerProfileDecoder;
let decoded_account = decoder.decode_account(&account);

if let Some(decoded) = decoded_account {
    match decoded.data {
        PlayerProfileAccount::Profile(profile) => {
            println!("Profile has {} keys", profile.profile_keys.len());
            for key in &profile.profile_keys {
                println!("  Key: {}, Scope: {}", key.key, key.scope);
            }
        }
        PlayerProfileAccount::PlayerName(player_name) => {
            let name_str = String::from_utf8_lossy(&player_name.name);
            println!("Player Name: {}", name_str);
        }
        PlayerProfileAccount::Role(role) => {
            println!("Role has {} members", role.members.len());
            for member in &role.members {
                println!("  Member: {}", member.key);
            }
        }
        PlayerProfileAccount::ProfileRoleMembership(membership) => {
            println!("Profile has {} role memberships", membership.memberships.len());
        }
    }
}

Decoding Instructions

The decoder supports parsing all Player Profile instructions with full account resolution:

use carbon_player_profile_decoder::{PlayerProfileDecoder, PlayerProfileInstruction};
use carbon_core::instruction::InstructionDecoder;

let decoder = PlayerProfileDecoder;
let decoded_ix = decoder.decode_instruction(&instruction);

if let Some(decoded) = decoded_ix {
    match decoded.data {
        PlayerProfileInstruction::AddKeys(add_keys) => {
            println!("Adding {} keys to profile", add_keys.keys_to_add.len());

            // Access the instruction data (permissions)
            for (i, key_input) in add_keys.keys_to_add.iter().enumerate() {
                println!("  Key {}: scope={}, expire={}",
                    i, key_input.scope, key_input.expire_time);
            }

            // Access the actual account pubkeys being added
            for (i, pubkey) in decoded.accounts.keys_to_add_accounts.iter().enumerate() {
                println!("  Account {}: {}", i, pubkey);
            }
        }
        PlayerProfileInstruction::CreateProfile(create_profile) => {
            println!("Creating profile with {} keys", create_profile.key_permissions.len());
            println!("Key threshold: {}", create_profile.key_threshold);

            // Access the initial key account pubkeys
            for pubkey in &decoded.accounts.init_keys_accounts {
                println!("  Init key: {}", pubkey);
            }
        }
        _ => {
            // Handle other instructions
        }
    }
}

Note: The AddKeys and CreateProfile instructions include both:

Instruction data (keys_to_add, key_permissions) - Contains permission scopes and metadata
Account lists (keys_to_add_accounts, init_keys_accounts) - Contains the actual pubkeys of the keys being added

Working with Permissions

The decoder includes ergonomic permission handling with bitflags:

use carbon_player_profile_decoder::{ProfileKey, ProfilePermissions};

// Check if a key has specific permissions
let key: ProfileKey = /* ... */;

if key.is_auth() {
    println!("This is an auth key");
}

if key.has_permission(ProfilePermissions::ADD_KEYS) {
    println!("This key can add other keys");
}

// Check if a key has expired
let current_time = /* current unix timestamp */;
if key.is_expired(current_time) {
    println!("This key has expired");
}

// Get permission flags
let flags = key.permissions_flags();
if flags.contains(ProfilePermissions::CREATE_ROLE | ProfilePermissions::REMOVE_ROLE) {
    println!("This key can manage roles");
}

Account Types

This decoder supports all Player Profile account types:

Profile - Player profile with keys and metadata
PlayerName - Player name registration
Role - Role definition with permissions
ProfileRoleMembership - Membership relationship between profiles and roles

Account Fields (RemainingData)

All account types include dynamically-sized fields deserialized from RemainingData:

Profile

profile_keys: Vec<ProfileKey> - List of all keys associated with this profile
- Each key includes: public key, scope, expiration time, and permissions
- Maximum of 65,535 keys (u16 length prefix)

PlayerName

name: Vec<u8> - UTF-8 encoded player name bytes
- Variable length, stored as raw bytes without length prefix
- Example: String::from_utf8_lossy(&player_name.name)

Role

members: Vec<RoleMembership> - List of all members in this role
- Each membership includes: member key and status (Active/Inactive)
- Maximum of 256 members (u32 length prefix, enforced by MAX_MEMBERSHIPS)

ProfileRoleMembership

memberships: Vec<RoleMembership> - List of all roles this profile belongs to
- Each membership includes: role key and status (Active/Inactive)
- Maximum of 256 memberships (u32 length prefix, enforced by MAX_MEMBERSHIPS)

Permission Flags

The ProfilePermissions bitflags type includes:

AUTH - Auth key with full profile control
ADD_KEYS - Can add non-auth keys
REMOVE_KEYS - Can remove non-auth keys
CHANGE_NAME - Can change player name
CREATE_ROLE - Can create new roles
REMOVE_ROLE - Can remove roles
SET_AUTHORIZER - Can set role authorizer
JOIN_ROLE - Can add profile to a role
LEAVE_ROLE - Can remove profile from a role
TOGGLE_ACCEPTING_NEW_MEMBERS - Can toggle accepting new members
ADD_MEMBER - Can add members to roles
REMOVE_MEMBER - Can remove members from roles
DRAIN_SOL_VAULT - Can withdraw from SOL vault (scope-agnostic)

Documentation

Full documentation is available at docs.rs.

Repository

See the main repository for build instructions and contribution guidelines.

License

Licensed under the Apache-2.0 license.

carbon-player-profile-decoder 0.12.0