Skills, XP, and Progress: The Authoritative On-Chain Path

    <script type="module" src="./main.js"></script>

All browser claims begin at /play/index.html and modules imported by /play/main.js.

1. Line 1

   Load the current game module relative to /play/.

export function derivePlayerSkillsPda(owner, programId = NICECHUNK_SKILLS_PROGRAM_ID) {
  const normalizedOwner = typeof owner === "string" ? new PublicKey(owner) : owner;
  return PublicKey.findProgramAddressSync(
    [Buffer.from(playerSkillsSeed), deriveGlobalConfigPda().toBuffer(), normalizedOwner.toBuffer()],
    programId,
  );
}

export function deriveSkillRuleTablePda(programId = NICECHUNK_SKILLS_PROGRAM_ID) {
  return PublicKey.findProgramAddressSync(
    [Buffer.from(skillRuleTableSeed), deriveGlobalConfigPda().toBuffer()],
    programId,
  );
}

The browser derives the same Skills PDAs used by the program.

1. First function

   Bind PlayerSkills to GlobalConfig, owner, and Skills program.

2. Second function

   Bind SkillRuleTable to GlobalConfig and Skills program.

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",
  };
}

Final browser state has no local counter, storage fallback, or maximum merge.

1. Inputs

   Receive authoritative XP, levels, and thresholds.

2. Return

   Expose normalized chain-sourced skill state.

export function profileSkillExperienceRequirement(skill, level, thresholdsBySkill = null) {
  if (level >= PROFILE_SKILL_MAX_LEVEL) return 0;
  const thresholds = normalizedThresholdsForSkill(skill, thresholdsBySkill);
  if (thresholds) {
    const currentLevel = Math.max(0, Math.min(PROFILE_SKILL_MAX_LEVEL - 1, Math.trunc(level)));
    const previousTotal = currentLevel > 0 ? thresholds[currentLevel - 1] : 0;
    return thresholds[currentLevel] - previousTotal;
  }
  const nextLevel = Math.max(1, Math.min(PROFILE_SKILL_MAX_LEVEL, Math.trunc(level) + 1));
  return Math.round((skill?.xpBase ?? 100) * PROFILE_SKILL_XP_REQUIREMENT_MULTIPLIER * Math.pow(nextLevel, skill?.xpGrowth ?? 1.55));
}

export function profileSkillTotalExperienceForLevel(skill, level, thresholdsBySkill = null) {
  const capped = Math.max(0, Math.min(PROFILE_SKILL_MAX_LEVEL, Math.round(Number(level) || 0)));
  if (capped === 0) return 0;
  const thresholds = normalizedThresholdsForSkill(skill, thresholdsBySkill);
  if (thresholds) return thresholds[capped - 1];
  let total = 0;
  for (let previousLevel = 0; previousLevel < capped; previousLevel += 1) {
    total += profileSkillExperienceRequirement(skill, previousLevel);
  }
  return total;
}

export function profileSkillLevelFromXp(skill, xp, thresholdsBySkill = null) {
  const total = Math.max(0, Math.round(Number(xp) || 0));
  let level = 0;
  for (let nextLevel = 1; nextLevel <= PROFILE_SKILL_MAX_LEVEL; nextLevel += 1) {
    if (total < profileSkillTotalExperienceForLevel(skill, nextLevel, thresholdsBySkill)) break;
    level = nextLevel;
  }
  return level;
}

export function profileSkillExperienceProgress(skill, level, xpBySkill = {}, thresholdsBySkill = null) {
  const minimumTotal = profileSkillTotalExperienceForLevel(skill, level, thresholdsBySkill);
  const rawTotal = Number(xpBySkill?.[skill.id] ?? minimumTotal);
  const total = Number.isFinite(rawTotal) ? Math.max(0, Math.round(rawTotal)) : minimumTotal;
  const required = profileSkillExperienceRequirement(skill, level, thresholdsBySkill);
  if (level >= PROFILE_SKILL_MAX_LEVEL) {
    return {
      total,
      current: 0,
      required: 0,
      ratio: 1,
      label: `Total XP ${formatProfileSkillXp(total)}`,
    };
  }
  const current = Math.max(0, Math.min(required, total - minimumTotal));
  return {
    total,
    current,
    required,
    ratio: required > 0 ? current / required : 1,
    label: `XP ${formatProfileSkillXp(current)}/${formatProfileSkillXp(required)}`,
  };
}

Requirement, level, and progress use decoded table thresholds.

1. Requirement

   Subtract adjacent cumulative thresholds.

2. Level

   Select the highest reached total.

3. Progress

   Subtract the current level start from total XP.

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 aggregate read returns PlayerSkills as the ten-skill authority.

1. Batch

   Read Chunk, Smelting, and PlayerSkills while loading rules.

2. Revision

   Force one refetch when revisions differ.

3. Return

   Expose XP, levels, thresholds, and revision metadata.

function decodeSkillRuleTableDomain({ account, expectedBump, globalConfig }) {
  if (!account?.data?.length) throw new Error("skill-rule-table-uninitialized");
  if (!account.owner?.equals?.(NICECHUNK_SKILLS_PROGRAM_ID)) {
    throw new Error("skill-rule-table-owner-invalid");
  }
  const data = Buffer.from(account.data);
  const valid = data.length === skillRuleTableLength
    && data.subarray(0, 8).toString("utf8") === skillRuleTableMagic
    && data.readUInt16LE(8) === skillRuleTableVersion
    && data.readUInt8(10) === expectedBump
    && data.readUInt8(11) === 1
    && data.readUInt8(skillRuleTableSkillCountOffset) === PLAYER_SKILL_IDS.length
    && data.subarray(44, 76).equals(globalConfig.toBuffer());
  if (!valid) throw new Error("skill-rule-table-domain-invalid");

  const thresholds = {};
  for (let skillIndex = 0; skillIndex < PLAYER_SKILL_IDS.length; skillIndex += 1) {
    const values = [];
    let previous = 0;
    for (let levelIndex = 0; levelIndex < 10; levelIndex += 1) {
      const offset = skillRuleTableThresholdsOffset + (skillIndex * 10 + levelIndex) * 8;
      const value = safeChainInteger(data.readBigUInt64LE(offset), "skill threshold");
      if (value <= previous) throw new Error("skill-rule-table-thresholds-invalid");
      values.push(value);
      previous = value;
    }
    thresholds[PLAYER_SKILL_IDS[skillIndex]] = Object.freeze(values);
  }
  return Object.freeze({
    revision: data.readUInt32LE(skillRuleTableRevisionOffset),
    thresholds: Object.freeze(thresholds),
  });
}

Substituted identity, invalid layout, or non-increasing thresholds are rejected.

1. Identity

   Validate owner, size, magic, version, bump, state, skill count, and GlobalConfig.

2. Thresholds

   Decode ten safe increasing values per skill.

export function createSyncPlayerSkillsInstruction({
  payer,
  owner,
  sourceAccounts = [],
  miningCoordinate = null,
  programId = NICECHUNK_SKILLS_PROGRAM_ID,
}) {
  const normalizedPayer = typeof payer === "string" ? new PublicKey(payer) : payer;
  const normalizedOwner = typeof owner === "string" ? new PublicKey(owner) : owner;
  const [playerSkills] = derivePlayerSkillsPda(normalizedOwner, programId);
  const [ruleTable] = deriveSkillRuleTablePda(programId);
  const uniqueSources = [...new Map(sourceAccounts.map((source) => {
    const publicKey = typeof source === "string" ? new PublicKey(source) : source;
    return [publicKey.toBase58(), publicKey];
  })).values()];
  const coordinate = miningCoordinate ? normalizeSkillMiningCoordinate(miningCoordinate) : null;
  const data = Buffer.alloc(coordinate ? 13 : 1);
  data.writeUInt8(3, 0);
  if (coordinate) {
    data.writeInt32LE(coordinate.x, 1);
    data.writeInt32LE(coordinate.y, 5);
    data.writeInt32LE(coordinate.z, 9);
  }
  return new TransactionInstruction({
    programId,
    keys: [
      { pubkey: normalizedPayer, isSigner: true, isWritable: true },
      { pubkey: normalizedOwner, isSigner: false, isWritable: false },
      { pubkey: playerSkills, isSigner: false, isWritable: true },
      { pubkey: ruleTable, isSigner: false, isWritable: false },
      { pubkey: deriveGlobalConfigPda(), isSigner: false, isWritable: false },
      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
      ...(coordinate ? [{ pubkey: SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false }] : []),
      ...uniqueSources.map((pubkey) => ({ pubkey, isSigner: false, isWritable: false })),
    ],
    data,
  });
}

The Instructions sysvar appears only when a mining coordinate must be proven.

1. Payload

   Encode tag or tag plus coordinate.

2. Accounts

   Pass Skills state, rules, proof sysvar, and deduplicated sources.

        let backfill = rule.flags & RULE_FLAG_BACKFILL_ON_FIRST_SYNC != 0;
        let available_delta = if initialized {
            current_counter.saturating_sub(previous_cursor)
        } else if backfill {
            current_counter
        } else {
            0
        };
        let applied_delta = available_delta.min(rule.max_delta_per_sync);
        let next_cursor = if !initialized && !backfill {
            current_counter
        } else {
            previous_cursor
                .checked_add(applied_delta)
                .ok_or(NicechunkSkillsError::ArithmeticOverflow)?
        };

        let next_mask = state.cursor_mask | bit;
        data[PLAYER_SKILLS_CURSOR_MASK_OFFSET..PLAYER_SKILLS_CURSOR_MASK_OFFSET + 4]
            .copy_from_slice(&next_mask.to_le_bytes());
        data[cursor_offset..cursor_offset + 8].copy_from_slice(&next_cursor.to_le_bytes());

        if applied_delta == 0 {
            return Ok(CounterApplyResult {
                changed: !initialized || next_cursor != previous_cursor,
                applied_delta,
            });
        }

        for (skill_index, rate) in rule.xp_per_unit.iter().enumerate() {
            if *rate == 0 {
                continue;
            }
            let previous_scaled = (previous_cursor as u128)
                .checked_mul(*rate as u128)
                .ok_or(NicechunkSkillsError::ArithmeticOverflow)?
                / rule.unit_divisor as u128;
            let next_scaled = (next_cursor as u128)
                .checked_mul(*rate as u128)
                .ok_or(NicechunkSkillsError::ArithmeticOverflow)?
                / rule.unit_divisor as u128;
            let gained = next_scaled
                .checked_sub(previous_scaled)
                .ok_or(NicechunkSkillsError::ArithmeticOverflow)?;
            let gained =
                u64::try_from(gained).map_err(|_| NicechunkSkillsError::ArithmeticOverflow)?;
            let xp_offset = PLAYER_SKILLS_XP_OFFSET + skill_index * 8;
            let next_xp = read_u64(data, xp_offset)
                .checked_add(gained)
                .ok_or(NicechunkSkillsError::ArithmeticOverflow)?;
            data[xp_offset..xp_offset + 8].copy_from_slice(&next_xp.to_le_bytes());
        }
        Ok(CounterApplyResult {
            changed: true,
            applied_delta,
        })
    }

The state function advances one cursor and calculates integer XP from scaled cumulative values.

1. Delta

   Choose backfill or monotonic difference and clamp it.

2. XP

   Apply every nonzero rate with the divisor.

3. Write

   Persist cursor and XP together.

    pub fn apply_burden_mining_action(
        data: &mut [u8],
        owner: &Pubkey,
        global_config: &Pubkey,
        rule: BurdenMiningRule,
        pre_mine_mass_grams: u64,
        mine_sequence: u64,
        coordinate: MiningCoordinate,
    ) -> Result<CounterApplyResult, NicechunkSkillsError> {
        let state = Self::validate(data, owner, global_config)?;
        rule.validate()?;
        if !rule.enabled || mine_sequence == 0 {
            return Ok(CounterApplyResult {
                changed: false,
                applied_delta: 0,
            });
        }

        let sequence_bit = 1_u32 << BURDEN_SEQUENCE_CURSOR_INDEX;
        let xp_bit = 1_u32 << BURDEN_XP_CURSOR_INDEX;
        let sequence_initialized = state.cursor_mask & sequence_bit != 0;
        let sequence_offset = PLAYER_SKILLS_CURSORS_OFFSET + BURDEN_SEQUENCE_CURSOR_INDEX * 8;
        let previous_sequence = read_u64(data, sequence_offset);
        if sequence_initialized && mine_sequence < previous_sequence {
            return Err(NicechunkSkillsError::SourceCounterRegressed);
        }
        if sequence_initialized && mine_sequence == previous_sequence {
            return Ok(CounterApplyResult {
                changed: false,
                applied_delta: 0,
            });
        }

        let xp_cursor_offset = PLAYER_SKILLS_CURSORS_OFFSET + BURDEN_XP_CURSOR_INDEX * 8;
        let previous_awarded_xp = if state.cursor_mask & xp_bit != 0 {
            read_u64(data, xp_cursor_offset)
        } else {
            0
        };
        let has_previous =
            data[PLAYER_SKILLS_MINING_FLAGS_OFFSET] & PLAYER_SKILLS_FLAG_HAS_LAST_MINE != 0;
        let distance_chunks = if has_previous {
            burden_chunk_distance(
                MiningCoordinate {
                    x: read_i32(data, PLAYER_SKILLS_LAST_MINE_X_OFFSET),
                    y: read_i32(data, PLAYER_SKILLS_LAST_MINE_Y_OFFSET),
                    z: read_i32(data, PLAYER_SKILLS_LAST_MINE_Z_OFFSET),
                },
                coordinate,
                rule.chunk_size_blocks,
            )
            .min(rule.max_distance_chunks as u64)
        } else {
            0
        };
        let mass_points = pre_mine_mass_grams / rule.mass_step_grams;
        let gained_xp = mass_points
            .checked_mul(distance_chunks)
            .ok_or(NicechunkSkillsError::ArithmeticOverflow)?;
        let next_awarded_xp = previous_awarded_xp
            .checked_add(gained_xp)
            .ok_or(NicechunkSkillsError::ArithmeticOverflow)?;
        if gained_xp > 0 {
            let xp_offset = PLAYER_SKILLS_XP_OFFSET + rule.skill_index as usize * 8;
            let next_xp = read_u64(data, xp_offset)
                .checked_add(gained_xp)
                .ok_or(NicechunkSkillsError::ArithmeticOverflow)?;
            data[xp_offset..xp_offset + 8].copy_from_slice(&next_xp.to_le_bytes());
        }
        let next_mask = state.cursor_mask | xp_bit | sequence_bit;
        data[PLAYER_SKILLS_CURSOR_MASK_OFFSET..PLAYER_SKILLS_CURSOR_MASK_OFFSET + 4]
            .copy_from_slice(&next_mask.to_le_bytes());
        data[xp_cursor_offset..xp_cursor_offset + 8]
            .copy_from_slice(&next_awarded_xp.to_le_bytes());
        data[sequence_offset..sequence_offset + 8].copy_from_slice(&mine_sequence.to_le_bytes());
        Ok(CounterApplyResult {
            changed: true,
            applied_delta: gained_xp,
        })
    }

The program derives chunk distance from the previous proven coordinate, multiplies it by whole mass steps, and prevents duplicate mine sequences.

1. Replay

   Reject regression and ignore a repeated sequence.

2. Route

   Measure capped horizontal chunk distance and multiply it by complete mass steps.

3. Writes

   Store XP, cumulative Burden awards, and the consumed sequence.

    pub fn record_mining_coordinate(
        data: &mut [u8],
        owner: &Pubkey,
        global_config: &Pubkey,
        coordinate: MiningCoordinate,
        rule: MiningTravelRule,
        updated_slot: u64,
    ) -> Result<bool, NicechunkSkillsError> {
        Self::validate(data, owner, global_config)?;
        rule.validate()?;
        let has_previous =
            data[PLAYER_SKILLS_MINING_FLAGS_OFFSET] & PLAYER_SKILLS_FLAG_HAS_LAST_MINE != 0;
        let qualifies = rule.enabled
            && has_previous
            && mining_distance_reaches(
                MiningCoordinate {
                    x: read_i32(data, PLAYER_SKILLS_LAST_MINE_X_OFFSET),
                    y: read_i32(data, PLAYER_SKILLS_LAST_MINE_Y_OFFSET),
                    z: read_i32(data, PLAYER_SKILLS_LAST_MINE_Z_OFFSET),
                },
                coordinate,
                rule.minimum_distance,
            );
        if qualifies {
            let skill_index = rule.skill_index as usize;
            let xp_offset = PLAYER_SKILLS_XP_OFFSET + skill_index * 8;
            let next_xp = read_u64(data, xp_offset)
                .checked_add(rule.xp_award as u64)
                .ok_or(NicechunkSkillsError::ArithmeticOverflow)?;
            data[xp_offset..xp_offset + 8].copy_from_slice(&next_xp.to_le_bytes());
            let next_count = read_u64(data, PLAYER_SKILLS_MINING_TRAVEL_COUNT_OFFSET)
                .checked_add(1)
                .ok_or(NicechunkSkillsError::ArithmeticOverflow)?;
            data[PLAYER_SKILLS_MINING_TRAVEL_COUNT_OFFSET
                ..PLAYER_SKILLS_MINING_TRAVEL_COUNT_OFFSET + 8]
                .copy_from_slice(&next_count.to_le_bytes());
        }
        data[PLAYER_SKILLS_LAST_MINE_X_OFFSET..PLAYER_SKILLS_LAST_MINE_X_OFFSET + 4]
            .copy_from_slice(&coordinate.x.to_le_bytes());
        data[PLAYER_SKILLS_LAST_MINE_Y_OFFSET..PLAYER_SKILLS_LAST_MINE_Y_OFFSET + 4]
            .copy_from_slice(&coordinate.y.to_le_bytes());
        data[PLAYER_SKILLS_LAST_MINE_Z_OFFSET..PLAYER_SKILLS_LAST_MINE_Z_OFFSET + 4]
            .copy_from_slice(&coordinate.z.to_le_bytes());
        data[PLAYER_SKILLS_MINING_FLAGS_OFFSET] |= PLAYER_SKILLS_FLAG_HAS_LAST_MINE;
        data[PLAYER_SKILLS_UPDATED_SLOT_OFFSET..PLAYER_SKILLS_UPDATED_SLOT_OFFSET + 8]
            .copy_from_slice(&updated_slot.to_le_bytes());
        Ok(qualifies)
    }

The previous coordinate and count live in PlayerSkills.

1. Qualification

   Compare current and last proven coordinates.

2. Award

   Add configured XP and count once.

3. Update

   Store current coordinate for next mine.

    pub fn recompute_levels(
        data: &mut [u8],
        owner: &Pubkey,
        global_config: &Pubkey,
        rule_table_data: &[u8],
        updated_slot: u64,
    ) -> ProgramResult {
        Self::validate(data, owner, global_config)?;
        let rules = RuleTableState::validate(rule_table_data, global_config)?;
        for skill_index in 0..SKILL_COUNT {
            let xp = read_u64(data, PLAYER_SKILLS_XP_OFFSET + skill_index * 8);
            let mut level = 0_u8;
            let mut previous = 0_u64;
            for level_index in 0..LEVEL_COUNT {
                let threshold =
                    RuleTableState::threshold(rule_table_data, skill_index, level_index)?;
                if threshold == 0 || threshold <= previous {
                    return Err(NicechunkSkillsError::InvalidThresholds.into());
                }
                if xp >= threshold {
                    level = (level_index + 1) as u8;
                }
                previous = threshold;
            }
            data[PLAYER_SKILLS_LEVELS_OFFSET + skill_index] = level;
        }
        data[PLAYER_SKILLS_RULE_REVISION_OFFSET..PLAYER_SKILLS_RULE_REVISION_OFFSET + 4]
            .copy_from_slice(&rules.revision.to_le_bytes());
        data[PLAYER_SKILLS_UPDATED_SLOT_OFFSET..PLAYER_SKILLS_UPDATED_SLOT_OFFSET + 8]
            .copy_from_slice(&updated_slot.to_le_bytes());
        Ok(())
    }
}

Every sync refreshes all ten levels and records the table revision.

1. Validation

   Validate state and rules against GlobalConfig.

2. Loop

   Compare XP with ten thresholds.

3. Revision

   Store the revision used.

    tx.add(ComputeBudgetProgram.setComputeUnitLimit({ units: miningComputeUnitLimit }));
    if (baselineInstruction) tx.add(baselineInstruction);
    tx.add(createMineBlockWithRewardsInstruction({
      authority: session.keypair.publicKey,
      block,
      owner: provider.publicKey,
      backpack: equippedBackpack.publicKey,
      actionId: miningActionId,
      expectedBlockId: canonicalBlock.blockId,
      context,
    }));
    addEquipmentDurabilityInstructions(tx, {
      authority: session.keypair.publicKey,
      owner: provider.publicKey,
      damage: options.durabilityDamage,
    });
    const playerPositionSaved = maybeAddPlayerPositionUpdateInstruction(tx, {
      provider,
      session,
      position: playerPositionForResourceMine(canonicalBlock, options),
    });
    tx.add(createSyncPlayerSkillsInstruction({
      payer: session.keypair.publicKey,
      owner: provider.publicKey,
      sourceAccounts: [
        chunkProgress,
        derivePlayerProfilePda(provider.publicKey)[0],
        equippedBackpack.publicKey,
      ],
      miningCoordinate: canonicalBlock,
    }));

World, equipment, position, and skill writes share one transaction.

1. Mine

   Commit canonical block and reward.

2. Skills

   Pass source PDAs, Backpack, and coordinate.

3. Send

   Sign after assembling all instructions.

        if (action === "mine") {
          void Promise.resolve(refreshPlayerProgress({ force: true, quiet: true })).catch(() => null);
        }

Profile can update without waiting for background polling.

1. Condition

   Run only after confirmed mining.

2. Call

   Force Player progress refresh without blocking local confirmation.

      const refreshResult = await refreshBackpack({
        previousUpdatedSlot: snapshot.updatedSlot,
        force: true,
      });
      if (!refreshResult?.ok) {
        console.warn("[NiceChunk Smelting] Transaction confirmed but PDA refresh is pending.", refreshResult);
      }
      const playerRefreshResult = await refreshPlayerProgress({ force: true, quiet: true });
      if (!playerRefreshResult?.ok) {
        console.warn("[NiceChunk Smelting] Transaction confirmed but PlayerSkills refresh is pending.", playerRefreshResult);
      }

The result is followed by authoritative inventory and skill reads.

1. Backpack

   Wait for post-transaction inventory.

2. Skills

   Force PlayerSkills and rule metadata refresh.