Carbon Crafting Decoder

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

Program Information

• Program ID: CRAFT2RPXPJWCEix4WpJST3E7NLf79GTqZUL75wngXo5
• Network: Solana Mainnet
• Description: Star Atlas Crafting program for managing recipes, crafting facilities, and crafting processes. Enables players to create items using consumable and non-consumable inputs at specialized facilities.

Features

• Decodes all Crafting account types
• Full instruction parsing support
• Integration with Carbon indexing framework
• Type-safe enum support for process/recipe status and location types
• Support for recipes with dynamic inputs/outputs

Usage

Add this crate to your Cargo.toml:

[dependencies]
carbon-crafting-decoder = "0.12.0"

Decoding Accounts

use carbon_crafting_decoder::{CraftingDecoder, CraftingAccount};
use carbon_core::account::AccountDecoder;

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

if let Some(decoded) = decoded_account {
    match decoded.data {
        CraftingAccount::Recipe(recipe) => {
            println!("Recipe: {:?}", recipe);
            println!("Duration: {}", recipe.duration);
            println!("Status: {:?}", recipe.status);
            println!("Consumables: {}", recipe.consumables_count);
            println!("Outputs: {}", recipe.outputs_count);
            println!("Total items: {}", recipe.recipe_items.len());
            // Access recipe inputs/outputs from remaining data
            for (i, item) in recipe.recipe_items.iter().enumerate() {
                println!("Item {}: amount={}, mint={}", i, item.amount, item.mint);
            }
        }
        CraftingAccount::CraftingFacility(facility) => {
            println!("Crafting Facility: {:?}", facility);
            println!("Location: {}", facility.location);
            println!("Location Type: {:?}", facility.location_type);
            println!("Efficiency: {}", facility.efficiency);
            println!("Max Concurrent Processes: {}", facility.max_concurrent_processes);
            println!("Recipe categories: {}", facility.recipe_categories.len());
            // Access recipe category pubkeys from remaining data
            for (i, category) in facility.recipe_categories.iter().enumerate() {
                println!("Category {}: {}", i, category);
            }
        }
        CraftingAccount::CraftingProcess(process) => {
            println!("Crafting Process: {:?}", process);
            println!("Recipe: {}", process.recipe);
            println!("Status: {:?}", process.status);
            println!("Start Time: {}", process.start_time);
            println!("End Time: {}", process.end_time);
        }
        CraftingAccount::CraftableItem(item) => {
            println!("Craftable Item: {:?}", item);
            println!("Mint: {}", item.mint);
        }
        CraftingAccount::Domain(domain) => {
            println!("Crafting Domain: {:?}", domain);
            println!("Authority Profile: {}", domain.authority_profile);
        }
        CraftingAccount::RecipeCategory(category) => {
            println!("Recipe Category: {:?}", category);
        }
    }
}

Working with Status Enums

The decoder provides type-safe enums for status and type fields:

use carbon_crafting_decoder::{ProcessStatus, RecipeStatus, LocationType};

// Check process status
match process.status {
    ProcessStatus::Initialized => println!("Process initialized"),
    ProcessStatus::Started => println!("Process in progress"),
    ProcessStatus::Completed => println!("Process complete"),
}

// Check recipe status
match recipe.status {
    RecipeStatus::Initializing => println!("Recipe being set up"),
    RecipeStatus::Active => println!("Recipe available for use"),
    RecipeStatus::Deactivated => println!("Recipe disabled"),
}

// Check facility location type
match facility.location_type {
    LocationType::Starbase => println!("Located at a starbase"),
}

Account Types

This decoder supports all Crafting account types:

• Recipe - Blueprint defining inputs, outputs, duration, and requirements for crafting. Includes recipe_items (Vec) containing all consumable/non-consumable inputs and outputs with amounts and mint addresses.
• CraftingFacility - Physical location where crafting occurs with efficiency modifiers. Includes recipe_categories (Vec) listing all recipe categories available at this facility.
• CraftingProcess - Active crafting operation tracking progress and status
• CraftableItem - Item that can be produced through crafting
• Domain - Administrative domain controlling crafting permissions
• RecipeCategory - Classification system for organizing recipes

Status Enums

ProcessStatus

• Initialized - Process created but not yet started
• Started - Crafting in progress
• Completed - Crafting finished, ready to claim outputs

RecipeStatus

• Initializing - Recipe being configured
• Active - Recipe available for use
• Deactivated - Recipe disabled and unavailable

LocationType

• Starbase - Crafting facility located at a starbase

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.