feat: Optimize CommitDiff using efficient merge_diff_copy that avoids heap allocation

[snawaz]

It is the third PR in the current stack.

The previous PR #110 used an inefficient approach to diff application that allocates memory on the heap, which can be problematic for larger accounts.

Solution

This PR adds a new merge_diff_copy() function that applies diffs directly to a destination buffer without requiring additional memory allocation. This function takes a destination buffer, original data, and a DiffSet.. and then merges the original with the diff to produce the updated version in the destination buffer. The whole approach avoids unnecessary memory allocation.

Apart from that, it also adds enum NewState to represent either full bytes or a diff, and process_commit_state_internal() is modified to handle both full data and diffs using NewState.

Summary by CodeRabbit

• Refactor

  • Improved internal diff application and state management for enhanced performance and clarity.

• Bug Fixes

  • Enhanced error handling with new validation for diff operations.

[coderabbitai]

Walkthrough

This PR refactors diff application in the commitment processor by introducing a NewState enum that abstracts between full byte representations and diff-based state, alongside a new merge_diff_copy utility function to apply diffs to a destination buffer. Error handling is extended with a new MergeDiffError variant.

Changes

Cohort / File(s)	Summary
Diff module extension src/diff/algorithm.rs, src/error.rs	Adds public merge_diff_copy() function to apply diff segments to a destination buffer; exports OffsetInData type; adds MergeDiffError variant (discriminant 17) for precondition violations; updates InvalidDiff error message to specify "Invalid length of diff".
State abstraction layer src/processor/fast/commit_state.rs	Introduces NewState<'a> enum with FullBytes(&'a [u8]) and Diff(DiffSet<'a>) variants; updates CommitStateInternalArgs.commit_state_bytes field to use NewState<'a> instead of &[u8]; adds data_len() method to compute length polymorphically; modifies commit state copy logic to handle both variants (full bytes and diff merge).
State abstraction usage src/processor/fast/commit_diff.rs, src/processor/fast/commit_state_from_buffer.rs	Replaces direct diff application with NewState::Diff(diffset) in commit_diff; removes apply_diff_copy invocation; updates commit_state_from_buffer to wrap state buffer as NewState::FullBytes(&state) when constructing CommitStateInternalArgs.

Sequence Diagram(s)

sequenceDiagram
    participant Caller
    participant CommitState as commit_state.rs
    participant DiffModule as diff/algorithm.rs
    participant Account as Delegated Account

    Caller->>CommitState: process_commit_state_internal(args: NewState)
    alt args is FullBytes
        CommitState->>CommitState: copy FullBytes to destination
    else args is Diff
        CommitState->>Account: read original account data
        Account-->>CommitState: original bytes
        CommitState->>DiffModule: merge_diff_copy(destination, original, diffset)
        DiffModule->>DiffModule: apply diff segments to destination
        DiffModule-->>CommitState: Result
    end
    CommitState-->>Caller: commit state applied

Loading

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~25 minutes

• commit_state.rs: Core change with new NewState enum and polymorphic handling; verify data_len() consistency and both variant branches (FullBytes copy vs. Diff merge) are correct.
• commit_diff.rs: Verify transition from inline apply_diff_copy to NewState::Diff abstraction and CommitStateInternalArgs field compatibility.
• algorithm.rs: Review new merge_diff_copy function logic for boundary correctness and error validation.
• Error variant changes: Confirm error message updates and new discriminant do not conflict with existing enum values.

Possibly related PRs

• feat: Add CommitDiff Instruction for Efficient Account Updates #110: Introduced the original CommitDiff instruction and apply_diff_copy in process_commit_diff that this PR refactors into the new NewState::Diff abstraction.
• feat: Add diff module that provides compute_diff, apply_diff_*, DiffSet #111: Extended the diff module with DiffSet and OffsetInData that are now used in the new merge_diff_copy function and state handling.
• feat: optimize commit-from-buffer instruction using Pinocchio for lower CU consumption #97: Modified the fast commit-from-buffer path and CommitStateInternalArgs structure that this PR extends with NewState wrapper type.

Suggested reviewers

• thlorenz
• GabrielePicco

Pre-merge checks and finishing touches

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Description Check	⚠️ Warning	The PR description is incomplete and does not follow the required template structure. The description is missing several critical sections including the Status/Type/Issue table, a formal Problem section, Before & After screenshots, and Deploy Notes. While the description does provide relevant context about the PR being part of a stack and includes a Solution section with technical details about merge_diff_copy and the NewState enum, it fails to meet the structured requirements of the template. The absence of a formal Problem statement and status information means reviewers lack key context about the PR's purpose and scope, and there is no guidance on deployment considerations.	The author should revise the PR description to include all required template sections: add a Status/Type/Issue table at the top with appropriate selections, formally state the Problem being solved (heap allocation inefficiency in diff application), include Before & After code examples or explanations if applicable, document any Deploy Notes regarding new dependencies or breaking changes, and expand the Other changes section if needed. This will ensure the PR is properly documented for review and future reference.

✅ Passed checks (2 passed)

Check name	Status	Explanation
Title Check	✅ Passed	The title "feat: Optimize CommitDiff using efficient merge_diff_copy that avoids heap allocation" directly and accurately summarizes the main objective of the changeset. It clearly identifies the primary change (introducing an efficient merge_diff_copy function), specifies the component being optimized (CommitDiff), and articulates the key benefit (avoiding heap allocation). The title is concise, specific, and avoids vague language, making it immediately clear to reviewers scanning the commit history what this PR accomplishes.
Docstring Coverage	✅ Passed	Docstring coverage is 100.00% which is sufficient. The required threshold is 80.00%.

✨ Finishing touches

• 📝 Generate docstrings

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch snawaz/optimize-commit-diff

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[snawaz]

• feat: Optimize CommitDiff using efficient merge_diff_copy that avoids heap allocation  #113 👈 (View in Graphite)
• feat: Add CommitDiff Instruction for Efficient Account Updates #110
• feat: Add diff module that provides compute_diff, apply_diff_*, DiffSet #111
• main

This stack of pull requests is managed by Graphite. Learn more about stacking.

[GabrielePicco]

LGTM!

[coderabbitai]

Actionable comments posted: 1

📜 Review details

Configuration used: CodeRabbit UI

Review profile: ASSERTIVE

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 97174ec and 383919b.

📒 Files selected for processing (5)

• src/diff/algorithm.rs (5 hunks)
• src/error.rs (1 hunks)
• src/processor/fast/commit_diff.rs (2 hunks)
• src/processor/fast/commit_state.rs (5 hunks)
• src/processor/fast/commit_state_from_buffer.rs (2 hunks)

🧰 Additional context used

🧠 Learnings (1)

📚 Learning: 2025-10-15T11:45:25.802Z

Learnt from: snawaz
Repo: magicblock-labs/delegation-program PR: 107
File: src/entrypoint.rs:141-144
Timestamp: 2025-10-15T11:45:25.802Z
Learning: In the delegation-program codebase, prefer using `log!` (from pinocchio_log) over `msg!` for error and panic scenarios in the entrypoint code, as per maintainer preference.

Applied to files:

• src/processor/fast/commit_state.rs

🧬 Code graph analysis (1)

src/processor/fast/commit_state.rs (1)

src/diff/algorithm.rs (1)

• merge_diff_copy (240-262)