PlayerProfile PDAs: Identity, Equipment Identities, and Chain Skills

    let outcome = {
        let mut backpack_data = backpack.try_borrow_mut_data()?;
        BackpackAccount::forge_equipment_from_verified_materials(
            &mut backpack_data,
            owner.key,
            indexes,
            item_id,
            design_hash,
            forged_item.key,
            forging_level,
            clock.slot,
            requirements,
        )?
    };

forged_item.key becomes the Backpack record's item_pda. It is an item-specific immutable PDA, not a shared PlayerProfile key.

1. Lines 1–2

   Open a scoped mutable borrow of the owner's authoritative Backpack before settling the verified forge operation.

2. Lines 3–13

   Pass the verified inputs, design hash, current forging level, and forged_item.key into the Backpack settlement routine.

3. Lines 14–15

   Return the forge outcome after the Backpack record has captured the immutable ForgedItem PDA as item_pda.

        let mut outcome = calculate_forge_outcome(&materials, forging_level);
        if let Some(required) = requirements {
            outcome.volume_mm3 = required.required_volume_mm3.min(u32::MAX as u64) as u32;
            outcome.mass_grams = required.output_mass_grams;
        } else {
            outcome.mass_grams = materials
                .iter()
                .filter_map(|material| material.mass_grams().ok())
                .fold(0_u32, u32::saturating_add);
        }
        Self::remove_resources_at(data, owner, indexes, updated_slot)?;
        let mut output = BackpackSlotRecord {
            kind: BACKPACK_SLOT_KIND_ITEM,
            category: BACKPACK_ITEM_CATEGORY_FORGED,
            flags: 0,
            quantity: 1,
            resource: BackpackResourceRecord::default(),
            item_code: BACKPACK_FORGED_ITEM_CODE,
            item_id,
            item_pda: *item_pda,
            volume_mm3: outcome.volume_mm3,
            durability_current: outcome.durability_max,
            durability_max: outcome.durability_max,
            grade: outcome.grade,
            item_level: outcome.item_level,
            quality_bps: outcome.quality_bps,
            metadata: design_hash,
        };
        output.set_mass_grams(outcome.mass_grams)?;
        Self::append_item(data, owner, &output, updated_slot)?;

The record stores the unique ForgedItem PDA. Verified geometry replaces provisional volume and mass before consumption; item ID, durability, quality, and design hash remain separate fields.

1. Lines 1–10

   Calculate the forge outcome, then replace provisional volume and mass with verified geometry requirements when those requirements are present.

2. Lines 11–29

   Consume the selected materials and construct one forged Backpack record containing the unique ForgedItem PDA plus independent physical and quality fields.

3. Lines 30–31

   Apply the verified mass encoding and append the complete output record to the owner's Backpack.

    pub fn pack(dst: &mut [u8], args: &PlayerAppearanceInitArgs) -> ProgramResult {
        if dst.len() != Self::LEN {
            return Err(NicechunkPlayerError::InvalidAppearanceData.into());
        }
        Self::validate_model_kind(args.model_kind)?;
        PlayerProfile::validate_name(args.display_name.as_bytes())?;
        Self::validate_title(args.title)?;
        Self::validate_model_code(args.model_code)?;

        let mut writer = ByteWriter { dst, offset: 0 };
        writer.bytes(&PLAYER_APPEARANCE_MAGIC)?;
        writer.u16(PLAYER_APPEARANCE_VERSION)?;
        writer.u8(args.bump)?;
        writer.u8(1)?;
        writer.pubkey(args.owner)?;
        writer.pubkey(args.player_profile)?;
        writer.pubkey(args.global_config)?;
        writer.pubkey(args.treasury_authority)?;
        writer.u8(args.model_kind)?;
        writer.u16(0)?;
        writer.u16(args.display_name.as_bytes().len() as u16)?;
        writer.u16(args.title.len() as u16)?;
        writer.u16(args.model_code.len() as u16)?;
        writer.u8(APPEARANCE_EQUIPMENT_SLOT_COUNT as u8)?;
        writer.u64(args.created_slot)?;
        writer.u64(args.updated_slot)?;
        writer.i64(args.created_at)?;
        writer.i64(args.updated_at)?;
        writer.bytes(&[0_u8; Self::HEADER_LEN - Self::RESERVED_OFFSET])?;

        let display_name_bytes = args.display_name.as_bytes();
        writer.bytes(display_name_bytes)?;
        writer.bytes(
            &[0_u8; PLAYER_NAME_MAX_BYTES][..PLAYER_NAME_MAX_BYTES - display_name_bytes.len()],
        )?;
        writer.bytes(args.title)?;
        writer.bytes(
            &[0_u8; APPEARANCE_TITLE_MAX_BYTES][..APPEARANCE_TITLE_MAX_BYTES - args.title.len()],
        )?;
        writer.bytes(args.model_code)?;
        writer.bytes(
            &[0_u8; APPEARANCE_MODEL_CODE_MAX_BYTES]
                [..APPEARANCE_MODEL_CODE_MAX_BYTES - args.model_code.len()],
        )?;
        for slot in 0..APPEARANCE_EQUIPMENT_SLOT_COUNT {
            writer.u8(0)?;
            writer.u8(slot as u8)?;
            writer.bytes(&[0_u8; APPEARANCE_EQUIPMENT_SLOT_LEN - 2])?;
        }

The packer validates and rewrites the full visible identity record. Its final loop gives every rich equipment record state zero and a zero-filled payload.

1. Lines 1–8

   Require the exact account size and validate model kind, name, title, and model-code envelope.

2. Lines 10–29

   Write account relationships, lengths, timestamps, and the fixed header.

3. Lines 31–44

   Write bounded display name, title, and model code with zero padding.

4. Lines 45–49

   Reset every one of the twelve rich equipment records.

    } else {
        let backpack_record = {
            let backpack_data = backpack.try_borrow_data()?;
            BackpackAccountView::validate_pda_and_owner(
                &backpack_data,
                backpack.key,
                backpack.owner,
                authority.key,
            )?;
            BackpackAccountView::equipment_record_at(&backpack_data, authority.key, backpack_index)?
        };
        invoke_backpack_equipment_transfer(
            game_program,
            transfer_authority,
            authority,
            backpack,
            player_equipment,
            material_physics,
            &[1, 10, slot, backpack_index],
            transfer_bump,
        )?;
        {
            let mut equipment_data = player_equipment.try_borrow_mut_data()?;
            PlayerEquipment::write_custodied_slot(
                &mut equipment_data,
                slot,
                backpack_index,
                backpack.key,
                &backpack_record,
                &payload[4..],
                clock.slot,
            )?;
            next_identity = PlayerEquipment::slot_identity(&equipment_data, slot)?;
        }
    }

    let mut profile_data = player_profile.try_borrow_mut_data()?;
    PlayerProfile::write_equipment_slot(&mut profile_data, slot, &next_identity, clock.slot)

Player validates and removes the Backpack record, writes the complete record and model bytes into PlayerEquipment, and stores only the derived identity in PlayerProfile.

1. Lines 2–11

   Validate the owner-derived Backpack and copy the requested equipment record before custody changes.

2. Lines 12–21

   Invoke the unified Game Backpack transfer so the source record leaves Backpack custody atomically.

3. Lines 22–35

   Write the full source record and model bytes into PlayerEquipment, then derive its compact slot identity.

4. Lines 38–39

   Store only that derived identity in PlayerProfile after the custody record has been written.

fn read_equipment_slot_for_listing(
    player_profile: &AccountInfo,
    player_equipment: &AccountInfo,
    owner: &Pubkey,
    equipment_slot: u8,
    player_program: &Pubkey,
    global_config: &Pubkey,
) -> Result<[u8; BACKPACK_SLOT_RECORD_LEN], solana_program::program_error::ProgramError> {
    require_key_eq(
        player_profile.owner,
        player_program,
        NicechunkMarketError::InvalidPlayerProgram,
    )?;
    require_key_eq(
        player_equipment.owner,
        player_program,
        NicechunkMarketError::InvalidPlayerProgram,
    )?;
    let profile_data = player_profile.try_borrow_data()?;
    validate_player_profile_data_and_pda(
        player_profile.key,
        &profile_data,
        owner,
        player_program,
        global_config,
    )?;
    if equipment_slot as usize >= PLAYER_PROFILE_EQUIPMENT_SLOT_COUNT {
        return Err(NicechunkMarketError::InvalidEquipmentSource.into());
    }
    let equipment_data = player_equipment.try_borrow_data()?;
    validate_player_equipment_data_and_pda(
        player_equipment.key,
        &equipment_data,
        owner,
        player_profile.key,
        player_program,
        global_config,
    )?;
    validate_equipment_source_record(&profile_data, &equipment_data, equipment_slot)
}

fn validate_equipment_source_record(
    profile_data: &[u8],
    equipment_data: &[u8],
    equipment_slot: u8,
) -> Result<[u8; BACKPACK_SLOT_RECORD_LEN], solana_program::program_error::ProgramError> {
    if profile_data.len() != PLAYER_PROFILE_LEN
        || equipment_data.len() != PLAYER_EQUIPMENT_LEN
        || equipment_slot as usize >= PLAYER_PROFILE_EQUIPMENT_SLOT_COUNT
    {
        return Err(NicechunkMarketError::InvalidEquipmentSource.into());
    }
    let offset =
        PLAYER_EQUIPMENT_SLOTS_OFFSET + equipment_slot as usize * PLAYER_EQUIPMENT_SLOT_LEN;
    if equipment_data[offset + PLAYER_EQUIPMENT_RECORD_STATE_OFFSET] != 1
        || equipment_data[offset + PLAYER_EQUIPMENT_RECORD_SLOT_OFFSET] != equipment_slot
        || equipment_data[offset + PLAYER_EQUIPMENT_RECORD_FLAGS_OFFSET]
            & PLAYER_EQUIPMENT_FLAG_CUSTODY
            == 0
    {
        return Err(NicechunkMarketError::InvalidEquipmentSource.into());
    }
    let source_slot = copy_valid_backpack_slot(
        &equipment_data[offset + PLAYER_EQUIPMENT_RECORD_BACKPACK_SLOT_OFFSET
            ..offset + PLAYER_EQUIPMENT_RECORD_BACKPACK_SLOT_OFFSET + BACKPACK_SLOT_RECORD_LEN],
    )?;
    let identity = Pubkey::new_from_array(
        hashv(&[
            b"equipment-v2",
            &equipment_data[offset + PLAYER_EQUIPMENT_RECORD_BACKPACK_OFFSET
                ..offset + PLAYER_EQUIPMENT_RECORD_BACKPACK_OFFSET + 32],
            &source_slot,
        ])
        .to_bytes(),
    );
    let profile_offset = PLAYER_PROFILE_EQUIPMENT_OFFSET + equipment_slot as usize * 32;
    if &profile_data[profile_offset..profile_offset + 32] != identity.as_ref() {
        return Err(NicechunkMarketError::InvalidEquipmentSource.into());
    }
    Ok(source_slot)
}

Market validates canonical Profile and PlayerEquipment PDAs, requires custody, reconstructs the identity from the full source record, and requires PlayerProfile to contain that identity.

1. Lines 1–37

   Require both accounts to belong to Player Program and validate their canonical owner, Profile, and GlobalConfig relationships.

2. Lines 39–57

   Require exact account sizes, a valid slot index, initialized slot state, matching slot number, and the custody flag.

3. Lines 58–72

   Copy the embedded Backpack source record and reconstruct its equipment-v2 identity from Backpack address plus record bytes.

4. Lines 73–78

   Reject the listing source unless PlayerProfile stores that reconstructed identity in the same equipment slot.

function derivePlayerProgressPdaForContext(owner, context = gameContext) {
  return derivePlayerProgressPdaForProgram(owner, context.chunkProgramId);
}

function deriveSmeltingPlayerProgressPdaForContext(owner, context = gameContext) {
  return derivePlayerProgressPdaForProgram(owner, context.smeltingProgramId);
}

The seed helper is shared, but context.chunkProgramId and context.smeltingProgramId place the addresses in different program domains.

1. Lines 1–3

   Derive the progress address under Chunk.

2. Lines 5–7

   Derive the Smelting progress address under its configured program, currently unified Game.

export async function fetchPlayerProgress(ownerAddress, {
  connection: connectionOverride = null,
  context = gameContext,
} = {}) {
  if (!ownerAddress) return null;
  const owner = typeof ownerAddress === "string" ? new PublicKey(ownerAddress) : ownerAddress;
  const globalConfig = deriveGlobalConfigPda();
  const [chunkProgress, chunkBump] = derivePlayerProgressPdaForContext(owner, context);
  const [smeltingProgress, smeltingBump] = deriveSmeltingPlayerProgressPdaForContext(owner, context);
  const [playerSkills, skillsBump] = derivePlayerSkillsPda(owner);
  const conn = connectionOverride ?? getNicechunkConnection();
  const [accounts, initialRuleTable] = await Promise.all([
    conn.getMultipleAccountsInfo([chunkProgress, smeltingProgress, playerSkills], "confirmed"),
    fetchSkillRuleTable({ connection: conn }),
  ]);
  const [chunkAccount, smeltingAccount, skillsAccount] = accounts;
  const chunkDomain = decodePlayerProgressDomain({
    account: chunkAccount,
    expectedProgramId: context.chunkProgramId,
    expectedBump: chunkBump,
    owner,
    globalConfig,
  });
  const smeltingDomain = decodePlayerProgressDomain({
    account: smeltingAccount,
    expectedProgramId: context.smeltingProgramId,
    expectedBump: smeltingBump,
    owner,
    globalConfig,
  });
  const skillsDomain = decodePlayerSkillsDomain({
    account: skillsAccount,
    expectedBump: skillsBump,
    owner,
    globalConfig,
  });
  const skillRuleTable = skillsDomain && initialRuleTable.revision !== skillsDomain.ruleRevision
    ? await fetchSkillRuleTable({ connection: conn, force: true })
    : initialRuleTable;
  const emptySkills = Object.fromEntries(PLAYER_SKILL_IDS.map((skillId) => [skillId, 0]));
  return {
    publicKey: chunkProgress.toBase58(),
    smeltingPublicKey: smeltingProgress.toBase58(),
    owner: owner.toBase58(),
    precisionGatheringXp: chunkDomain?.precisionGatheringXp ?? 0,
    smeltingXp: smeltingDomain?.smeltingXp ?? 0,
    explorationXp: chunkDomain?.explorationXp ?? 0,
    playerSkillsPublicKey: playerSkills.toBase58(),
    playerSkillsInitialized: Boolean(skillsDomain),
    skillXp: skillsDomain?.xp ?? emptySkills,
    skillLevels: skillsDomain?.levels ?? emptySkills,
    skillCursorMask: skillsDomain?.cursorMask ?? 0,
    skillThresholds: skillRuleTable.thresholds,
    skillRuleRevision: skillsDomain?.ruleRevision ?? 0,
    skillRuleTableRevision: skillRuleTable.revision,
    skillRulesCurrent: Boolean(skillsDomain && skillsDomain.ruleRevision === skillRuleTable.revision),
    programId: context.chunkProgramId.toBase58(),
    smeltingProgramId: context.smeltingProgramId.toBase58(),
    skillsProgramId: NICECHUNK_SKILLS_PROGRAM_ID.toBase58(),
  };
}

The helper fetches Chunk Progress, Smelting Progress, and PlayerSkills, validates every domain, refreshes mismatched SkillRuleTable data, and returns chain XP, levels, and thresholds.

1. Lines 1–13

   Derive the three owner-scoped progress accounts and fetch them with the current SkillRuleTable at confirmed commitment.

2. Lines 14–34

   Decode Chunk, Smelting, and Skills domains against their expected programs, bumps, owner, and GlobalConfig.

3. Lines 35–39

   Force-refresh the rule table when the PlayerSkills revision differs from the initially fetched revision.

4. Lines 40–59

   Return chain-derived XP, levels, thresholds, revision status, and the three authoritative program identifiers.

export function buildProfileSkillState({
  chainXp = null,
  chainLevels = null,
  chainThresholds = null,
} = {}) {
  const levels = normalizeSkillLevels(chainLevels);
  const xpBySkill = normalizeSkillXp(chainXp);
  const thresholdsBySkill = normalizeSkillThresholds(chainThresholds);
  return {
    levels,
    xpBySkill,
    thresholdsBySkill,
    resolvedLevels: { ...levels },
    source: "chain",
  };
}

The profile normalizes XP, levels, and thresholds from chain fetches. It no longer reads or max-merges localStorage skill history.

1. Lines 1–8

   Normalize only the supplied chain XP, levels, and threshold maps into complete per-skill values.

2. Lines 9–14

   Expose those normalized levels as both displayed and resolved values and label the source explicitly as chain.