Smelting Recipe PDAs: Stack Quantities, Yield Math, and Authority Boundaries

    if !payer.is_signer || !payer.is_writable {
        return Err(NicechunkSmeltingError::InvalidPayer.into());
    }
    validate_recipe_authority(payer.key)?;
    if !recipe_table.is_writable {
        return Err(NicechunkSmeltingError::InvalidWritableAccount.into());
    }
    require_key_eq(
        system_program_account.key,
        &system_program::ID,
        NicechunkSmeltingError::InvalidSystemProgram,
    )?;
    let bump = validate_recipe_table_pda(program_id, recipe_table.key, table_id)?;
    if recipe_table.owner == program_id {
        return Err(NicechunkSmeltingError::RecipeTableAlreadyInitialized.into());
    }
    if recipe_table.owner != &system_program::ID || recipe_table.data_len() != 0 {
        return Err(NicechunkSmeltingError::InvalidSystemAccount.into());
    }

    create_recipe_table_pda(
        payer,
        recipe_table,
        system_program_account,
        program_id,
        table_id,
        bump,
    )?;

    let clock = Clock::get()?;
    let mut data = recipe_table.try_borrow_mut_data()?;
    RecipeTable::pack_empty(
        &mut data,
        &RecipeTableInitArgs {
            bump,
            table_id,
            authority: &NICECHUNK_SMELTING_RECIPE_AUTHORITY,
            created_slot: clock.slot,
            created_at: clock.unix_timestamp,
        },
    )

The initializer requires a writable signing payer and then compares that key with the compiled recipe authority. It validates the requested PDA, allocates the fixed table, and stores the same fixed authority rather than assigning control to an arbitrary payer.

fn execute_smelting(
    program_id: &Pubkey,
    accounts: &[AccountInfo],
    payload: &[u8],
) -> ProgramResult {
    if accounts.len() != 10 || payload.len() < 13 {
        return Err(NicechunkSmeltingError::InvalidInstruction.into());
    }
    let recipe_id = read_u64(payload, 0);
    let input_count = payload[8] as usize;
    let fuel_count = payload[9] as usize;
    let multiplier = read_u16(payload, 10);
    let index_offset = 12;
    // Ambient crafting recipes intentionally submit no fuel. Heated recipes
    // are still rejected later when max fuel tier is below min_heat_tier.
    if !smelting_payload_shape_is_valid(payload.len(), input_count, fuel_count, multiplier) {
        return Err(NicechunkSmeltingError::InvalidInstruction.into());
    }
    let indexes = &payload[index_offset..index_offset + input_count];
    let fuel_indexes = &payload[index_offset + input_count..];

    let account_info_iter = &mut accounts.iter();
    let owner = next_account_info(account_info_iter)?;
    let recipe_table = next_account_info(account_info_iter)?;
    let backpack = next_account_info(account_info_iter)?;
    let player_progress = next_account_info(account_info_iter)?;
    let global_config = next_account_info(account_info_iter)?;
    let material_physics = next_account_info(account_info_iter)?;
    let smelting_authority = next_account_info(account_info_iter)?;
    let backpack_program = next_account_info(account_info_iter)?;
    let player_skills = next_account_info(account_info_iter)?;
    let system_program_account = next_account_info(account_info_iter)?;

    if !owner.is_signer || !owner.is_writable {
        return Err(NicechunkSmeltingError::InvalidPayer.into());
    }
    if !backpack.is_writable || !player_progress.is_writable {
        return Err(NicechunkSmeltingError::InvalidWritableAccount.into());
    }
    require_key_eq(
        system_program_account.key,
        &system_program::ID,
        NicechunkSmeltingError::InvalidSystemProgram,
    )?;
    require_key_eq(
        recipe_table.owner,
        program_id,
        NicechunkSmeltingError::InvalidRecipeTableOwner,
    )?;
    require_key_eq(
        backpack.owner,
        &NICECHUNK_BACKPACK_PROGRAM_ID,
        NicechunkSmeltingError::InvalidBackpackProgram,
    )?;
    require_key_eq(
        backpack_program.key,
        &NICECHUNK_BACKPACK_PROGRAM_ID,
        NicechunkSmeltingError::InvalidBackpackProgram,
    )?;
    validate_global_config(global_config.key, global_config.owner)?;
    validate_smelting_authority(program_id, smelting_authority.key)?;
    let clock = Clock::get()?;
    let progress_bump = validate_player_progress_pda(
        program_id,
        player_progress.key,
        global_config.key,
        owner.key,
    )?;
    create_player_progress_if_needed(
        owner,
        player_progress,
        global_config,
        system_program_account,
        program_id,
        owner.key,
        progress_bump,
        &clock,
    )?;

    let recipe_table_data = recipe_table.try_borrow_data()?;
    RecipeTable::validate_identity(
        &recipe_table_data,
        program_id,
        recipe_table.key,
        &NICECHUNK_SMELTING_RECIPE_AUTHORITY,
    )?;
    let recipe = RecipeTable::find_recipe(&recipe_table_data, recipe_id)?;
    recipe.validate_outputs_for_table(recipe_table.key)?;
    drop(recipe_table_data);

Execution requires the final ten-account shape and validates GlobalConfig, RecipeTable identity, output provenance, PlayerProgress, and PlayerSkills before consuming inputs.

        let mut matched_inputs = [0_u64; RECIPE_MAX_INPUTS];
        let mut consumption_quantities = [0_u32; BACKPACK_MAX_CAPACITY];
        let mut input_volume_mm3 = 0_u64;
        let mut consumed_input_units = 0_u64;
        let merge_recipe = recipe_is_material_merge(recipe);
        if merge_recipe
            && (!fuel_indexes.is_empty()
                || indexes.len() < 2
                || multiplier as usize != indexes.len())
        {
            return Err(NicechunkSmeltingError::InputRecipeMismatch.into());
        }
        for index in indexes {
            let selected = *index as usize;
            if selected >= item_count || seen_indexes[selected] {
                return Err(NicechunkSmeltingError::InvalidInputIndex.into());
            }
            seen_indexes[selected] = true;
            let record = Self::slot_at(data, *index)?;
            if merge_recipe {
                if !recipe_input_matches(&recipe.inputs[0], &record) {
                    return Err(NicechunkSmeltingError::InputRecipeMismatch.into());
                }
                consumption_quantities[selected] = record.quantity;
                consumed_input_units = consumed_input_units.saturating_add(record.quantity as u64);
                input_volume_mm3 = input_volume_mm3.saturating_add(slot_volume_mm3(&record) as u64);
                continue;
            }

            let mut remaining = record.quantity as u64;
            for recipe_index in 0..recipe.input_count as usize {
                let required =
                    (recipe.inputs[recipe_index].quantity as u64).saturating_mul(multiplier as u64);
                if remaining == 0
                    || matched_inputs[recipe_index] >= required
                    || !recipe_input_matches(&recipe.inputs[recipe_index], &record)
                {
                    continue;
                }
                let consumed = remaining.min(required.saturating_sub(matched_inputs[recipe_index]));
                matched_inputs[recipe_index] =
                    matched_inputs[recipe_index].saturating_add(consumed);
                consumption_quantities[selected] = consumption_quantities[selected]
                    .saturating_add(consumed.min(u32::MAX as u64) as u32);
                remaining = remaining.saturating_sub(consumed);
            }
            let consumed = consumption_quantities[selected];
            if consumed == 0 {
                return Err(NicechunkSmeltingError::InputRecipeMismatch.into());
            }
            consumed_input_units = consumed_input_units.saturating_add(consumed as u64);
            input_volume_mm3 = input_volume_mm3
                .saturating_add(proportional_consumed_volume_mm3(&record, consumed)? as u64);
        }

The validator counts units rather than records. It records the exact quantity to consume from each unique input index; the Backpack CPI then either removes the complete record or proportionally updates its remaining physical state.

  const [recipeTable] = deriveSmeltingRecipeTablePdaForContext(recipeTableId, context);
  const recipeTableAccount = await conn.getAccountInfo(recipeTable, "confirmed");
  if (!recipeTableAccount?.data?.length) {
    return { submitted: false, reason: "smelting-table-uninitialized", recipeTable: recipeTable.toBase58() };
  }
  const smeltingProgress = deriveSmeltingPlayerProgressPdaForContext(provider.publicKey, context)[0];
  const baselineInstruction = await createPlayerSkillsBaselineInstructionIfNeeded({
    payer: provider.publicKey,
    owner: provider.publicKey,
    sourceAccounts: [smeltingProgress],
    ruleIndexes: smeltingRuleIndexes,
    connection: conn,
  });
  const tx = new Transaction();
  tx.add(ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 }));
  if (baselineInstruction) tx.add(baselineInstruction);
  tx.add(createExecuteSmeltingInstruction({
    owner: provider.publicKey,
    recipeTable,
    backpack,
    recipeId,
    inputIndexes: normalizedInputIndexes,
    fuelIndexes: normalizedFuelIndexes,
    batchMultiplier,
    context,
  }));
  tx.add(createSyncPlayerSkillsInstruction({
    payer: provider.publicKey,
    owner: provider.publicKey,
    sourceAccounts: [
      smeltingProgress,
      derivePlayerProfilePda(provider.publicKey)[0],
      backpack,
    ],
  }));

The website derives the bundled table and checks that it has data; the program performs canonical recipe validation. The transaction also appends PlayerSkills synchronization.

export function createSmeltingMaterialPreviewMesh(options = {}) {
  const materialId = normalizeMaterialId(options.materialId ?? options.id);
  const definition = MODEL_DEFS[materialId];
  if (!definition) return emptyMesh(materialId);
  const cached = modelCache.get(materialId);
  if (cached) return cached;
  const vertices = [];
  const indices = [];
  definition.build(createBuilder(vertices, indices));
  const colors = uniqueColors(vertices);
  const mesh = {
    id: `smelting_material_${materialId}`,
    materialId,
    name: definition.name,
    category: "smelting material",
    className: definition.className,
    shape: definition.shape,
    description: definition.description,
    roughness: definition.roughness,
    translucency: definition.translucency,
    emissive: definition.emissive,
    vertexFormat: "chunk-object",
    vertices,
    indices,
    layers: [],
    colors,
    quadCount: indices.length / 6,
    triangleCount: indices.length / 3,
    vertexCount: vertices.length,
    collision: false,
  };
  modelCache.set(materialId, mesh);
  if (modelCache.size > MODEL_CACHE_LIMIT) modelCache.delete(modelCache.keys().next().value);
  return mesh;
}

The material ID selects a low-poly Chunk.js definition and a cache limited to forty-eight entries. This reconstruction makes inventory and forge previews inexpensive, but no mesh, palette, roughness, translucency, emissive value, or triangle count is committed by the Smelting Program.