feat: Execute CommitDiff as BufferTask #616

snawaz · 2025-11-06T05:08:39Z

Problem

The previous PR #575 in this stack implements support for CommitDiff that executes as ArgsTask. When the transaction size grows beyond the limit, CommitDiff first degrades to CommitState and then gets executed as BufferTask to reduce the transaction size.

Degration of CommitDiff to CommitState is not a desirable thing.

Solution

So this PR implements support for CommitDiff as BufferTask. Means degradation of CommitDiff to CommitState is not required anymore.

Screenshot

Summary by CodeRabbit

Chores
- Updated a dependency to a newer revision and adjusted its manifest formatting.
Refactor
- Simplified and unified commit handling into Args vs Buffer strategies, improved diff computation and buffer-backed commit instruction creation.
Tests
- Expanded order-book test data ranges to exercise much larger datasets and improve reliability.

_{✏️ Tip: You can customize this high-level summary in your review settings.}

coderabbitai · 2025-11-06T05:08:48Z

📝 Walkthrough

Walkthrough

Refactors the committor service commit flow to use a public TaskStrategy (Args or Buffer) instead of a force_commit_state flag, adding buffer-path support and dispatching commit instruction creation based on strategy and optional base_account. Adds compute_diff and buffer-based instruction helpers (create_commit_state_from_buffer_ix, create_commit_diff_from_buffer_ix), introduces CommitTask::switch_to_buffer_strategy, and removes is_commit_diff/force_commit_state. Updates args_task and buffer_task to use the new strategy and diff-aware commit construction. Updates magicblock-delegation-program dependency rev in Cargo.toml files and increases randomized order-book entry ranges in an integration test.

Possibly related PRs

Handling of intent execution failures #564 — Modifies the same commit/task flow (args_task.rs, buffer_task.rs, tasks/mod.rs) and introduces strategy-based commit-path logic, showing direct code-level overlap.

Suggested reviewers

GabrielePicco
thlorenz
taco-paco

✨ 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/commit-diff-buffer

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

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

snawaz · 2025-11-06T05:08:56Z

Warning

This pull request is not mergeable via GitHub because a downstack PR is open. Once all requirements are satisfied, merge this PR as a stack on Graphite.
Learn more

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

coderabbitai

Actionable comments posted: 1

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (1)

magicblock-committor-service/src/tasks/args_task.rs (1)

87-99: Production change in args_task.rs is correct; test cases violate the buffer strategy invariant

The change at args_task.rs:92 correctly applies switch_to_buffer_strategy() to ensure optimized ArgsTaskType::Commit tasks are executed via buffer-based strategy. This is the right pattern.

However, test cases in mod.rs:567 and mod.rs:595 construct BufferTask with CommitTask instances in TaskStrategy::Args (the default from CommitTaskBuilder::create_commit_task()), without calling switch_to_buffer_strategy(). When BufferTask::instruction() is called, it will emit Args-based commit instructions (CommitState/CommitDiff) instead of buffer-based ones, violating the invariant that BufferTask should only produce buffer-strategy commits.

Update both test cases to apply switch_to_buffer_strategy() before passing to BufferTask::new_preparation_required(), matching the production pattern in args_task.rs:92.

📜 Review details

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between effba68 and d445507.

⛔ Files ignored due to path filters (3)

Cargo.lock is excluded by !**/*.lock
test-integration/Cargo.lock is excluded by !**/*.lock
test-integration/schedulecommit/elfs/dlp.so is excluded by !**/*.so

📒 Files selected for processing (6)

Cargo.toml (1 hunks)
magicblock-committor-service/src/tasks/args_task.rs (1 hunks)
magicblock-committor-service/src/tasks/buffer_task.rs (2 hunks)
magicblock-committor-service/src/tasks/mod.rs (5 hunks)
test-integration/Cargo.toml (1 hunks)
test-integration/schedulecommit/test-scenarios/tests/02_commit_and_undelegate.rs (1 hunks)

🧰 Additional context used

🧠 Learnings (4)

📓 Common learnings

Learnt from: taco-paco
Repo: magicblock-labs/magicblock-validator PR: 661
File: magicblock-committor-service/src/intent_executor/single_stage_executor.rs:20-28
Timestamp: 2025-11-21T10:22:07.520Z
Learning: In magicblock-committor-service's SingleStageExecutor and TwoStageExecutor (single_stage_executor.rs and two_stage_executor.rs), the fields transaction_strategy, junk, and patched_errors are intentionally public because these executors are designed to be used independently outside of the IntentExecutor scope, and callers need access to these execution reports for cleanup and error handling.

📚 Learning: 2025-10-14T09:56:14.047Z

Learnt from: taco-paco
Repo: magicblock-labs/magicblock-validator PR: 564
File: test-integration/programs/flexi-counter/src/processor/call_handler.rs:122-125
Timestamp: 2025-10-14T09:56:14.047Z
Learning: The file test-integration/programs/flexi-counter/src/processor/call_handler.rs contains a test smart contract used for integration testing, not production code.

Applied to files:

test-integration/schedulecommit/test-scenarios/tests/02_commit_and_undelegate.rs

📚 Learning: 2025-10-26T16:54:39.084Z

Learnt from: thlorenz
Repo: magicblock-labs/magicblock-validator PR: 587
File: test-manual/Cargo.toml:0-0
Timestamp: 2025-10-26T16:54:39.084Z
Learning: In the magicblock-validator repository, use git branch references (not commit hashes or tags) for the helius-laserstream dependency to allow automatic updates when the branch is pushed to.

Applied to files:

Cargo.toml

📚 Learning: 2025-11-21T10:22:07.520Z

Learnt from: taco-paco
Repo: magicblock-labs/magicblock-validator PR: 661
File: magicblock-committor-service/src/intent_executor/single_stage_executor.rs:20-28
Timestamp: 2025-11-21T10:22:07.520Z
Learning: In magicblock-committor-service's SingleStageExecutor and TwoStageExecutor (single_stage_executor.rs and two_stage_executor.rs), the fields transaction_strategy, junk, and patched_errors are intentionally public because these executors are designed to be used independently outside of the IntentExecutor scope, and callers need access to these execution reports for cleanup and error handling.

Applied to files:

magicblock-committor-service/src/tasks/mod.rs

🧬 Code graph analysis (1)

magicblock-committor-service/src/tasks/buffer_task.rs (3)

magicblock-committor-program/src/state/chunks.rs (1)

from_data_length (46-49)

magicblock-committor-service/src/tasks/mod.rs (1)

optimize (78-80)

magicblock-committor-service/src/tasks/args_task.rs (1)

optimize (87-100)

🔇 Additional comments (6)

test-integration/schedulecommit/test-scenarios/tests/02_commit_and_undelegate.rs (1)

256-267: Expanded order book size fuzzing looks good; just watch test runtime

The wider 5..100 ranges for bids/asks should better exercise large book handling and the new buffer-based CommitDiff path without changing test semantics. Just ensure CI runtime remains acceptable and that this level of randomness doesn’t make failures too rare or slow to reproduce beyond the logged seed.

magicblock-committor-service/src/tasks/buffer_task.rs (1)

48-55: BufferTask diff/state preparation and delegation to CommitTask look coherent

Using CommitTask::compute_diff() to decide between diff bytes and full state for committed_data, and deriving Chunks from that length, aligns with the new buffer-based commit flow. Deferring instruction() to CommitTask::create_commit_ix keeps BufferTask thin and ensures it follows the chosen TaskStrategy without extra size optimizations, which matches the intent described in the comment.

Also applies to: 59-59, 65-69, 75-77

test-integration/Cargo.toml (1)

60-62: Verify updated magicblock-delegation-program revision and cross-file consistency

The new git rev for magicblock-delegation-program with "no-entrypoint" looks fine and matches the root Cargo.toml. Please double-check that this commit exists on the remote and is the intended one for the paired CommitDiffFromBuffer changes.

Cargo.toml (1)

112-114: Root magicblock-delegation-program rev bump matches integration workspace

The workspace-level dependency now points at the same delegation-program git revision as the integration workspace. Please confirm this rev is correct for the new buffer-based commit instructions and that downstream crates depending on dlp still build and pass tests with it.

magicblock-committor-service/src/tasks/mod.rs (2)

149-156: CommitTask strategy-based dispatch for Args vs Buffer and diff vs state looks correct

The new CommitTask shape and create_commit_ix dispatch cover all four cases cleanly:

TaskStrategy::Args + Some(base_account) → CommitDiffArgs via commit_diff.

TaskStrategy::Args + None → CommitStateArgs via commit_state.

TaskStrategy::Buffer + Some(base_account) → commit_diff_from_buffer using the buffer PDA.

TaskStrategy::Buffer + None → commit_state_from_buffer using the buffer PDA.

Defaulting CommitTaskBuilder to TaskStrategy::Args and then flipping to Buffer via switch_to_buffer_strategy() when optimizing keeps the creation API simple while making the execution path explicit. The separation between args-based and buffer-based instruction builders also makes it easier to reason about fallbacks when base_account is unavailable (graceful degradation to CommitState).

Also applies to: 160-166, 169-193

196-203: compute_diff helper centralizes diff computation for buffer preparation

Exposing compute_diff on CommitTask (wrapping dlp::compute_diff over base_account.data() and committed data) is a good consolidation for BufferTask preparation logic. Using Option<AlignedVec> keeps the call sites straightforward and clearly signals that diff-based commits are only applicable when a base_account is present.

coderabbitai · 2025-11-21T19:29:01Z

magicblock-committor-service/src/tasks/mod.rs

    fn create_commit_diff_ix(
        &self,
        validator: &Pubkey,
-        fetched_account: &Account,
+        base_account: &Account,
    ) -> Instruction {
-        if self.force_commit_state {
-            return self.create_commit_state_ix(validator);
-        }
-
        let args = CommitDiffArgs {
            nonce: self.commit_id,
            lamports: self.committed_account.account.lamports,
            diff: compute_diff(
-                fetched_account.data(),
+                base_account.data(),
                self.committed_account.account.data(),
            )
            .to_vec(),


🧹 Nitpick | 🔵 Trivial

❓ Verification inconclusive

Buffer-based commit instruction builders are consistent with PreparationTask PDAs but currently untested

The new create_commit_state_from_buffer_ix and create_commit_diff_from_buffer_ix:

Derive the buffer PDA with (validator, committed_account.pubkey, commit_id.to_le_bytes()), matching PreparationTask::buffer_pda.

Use CommitStateFromBufferArgs { nonce, lamports, allow_undelegation }, with actual state or diff bytes coming solely from the buffer account.

This is structurally sound and lines up with how PreparationTask initializes and writes to the buffer.

One gap is tests: the test_buffer_task_instruction_serialization and related preparation tests currently construct BufferTask from a CommitTaskBuilder::create_commit_task(...) without switching to buffer strategy, so they still serialize the args-based commit instruction and never hit these new *_from_buffer builders. It would be valuable to:

Either update those tests to use a CommitTask that has strategy: TaskStrategy::Buffer (via switch_to_buffer_strategy()), or

Add dedicated tests that directly exercise create_commit_state_from_buffer_ix and create_commit_diff_from_buffer_ix, asserting serialization and basic structure.

That would give direct coverage of the new buffer commit paths.

Also applies to: 244-268, 269-293

🏁 Script executed:

#!/bin/bash # Inspect existing tests that mention commit_*from_buffer and BufferTask usage rg -n "commit_.*from_buffer" magicblock-committor-service rg -n "BufferTask::new_preparation_required" magicblock-committor-service

Length of output: 1114

I need to locate and inspect the test files to verify the coverage claim. Let me search for tests related to buffer tasks and instruction serialization.

--- 🏁 Script executed: ```shell #!/bin/bash # Find test files and test functions related to buffer tasks fd -e rs -path "*test*" magicblock-committor-service | head -20 rg -n "test_buffer_task_instruction_serialization|test.*commit.*instruction" magicblock-committor-service --type=rs

Length of output: 195

Let me fix the command syntax:

--- 🏁 Script executed: ```shell #!/bin/bash # Find test files with Rust extension in any test-related directories find magicblock-committor-service -name "*test*.rs" -o -name "tests" -type d # Search for test functions related to buffer task instruction serialization rg -n "fn test_.*buffer.*task|fn test_.*commit.*instruction" magicblock-committor-service

Length of output: 109

Now let me inspect the actual test implementation to verify the review's claim:

--- 🏁 Script executed: ```shell #!/bin/bash # Examine the test_buffer_task_instruction_serialization test sed -n '563,650p' magicblock-committor-service/src/tasks/mod.rs

Length of output: 3040

Let me inspect the CommitTaskBuilder and BufferTask instruction method to understand the dispatch logic:

--- 🏁 Script executed: ```shell #!/bin/bash # Find CommitTaskBuilder::create_commit_task implementation rg -n "impl CommitTaskBuilder|fn create_commit_task" magicblock-committor-service/src/tasks/mod.rs -A 20 | head -50 # Find BufferTask::instruction method rg -n "fn instruction" magicblock-committor-service/src/tasks/mod.rs -B 2 -A 15 | grep -A 15 "BufferTask"

Length of output: 1417

Let me get more of the create_commit_task implementation and locate the instruction method:

--- 🏁 Script executed: ```shell #!/bin/bash # Get full create_commit_task implementation sed -n '120,180p' magicblock-committor-service/src/tasks/mod.rs # Search for impl BufferTask and instruction method rg -n "impl BufferTask" magicblock-committor-service/src/tasks/mod.rs -A 100 | grep -E "fn instruction|CommitTask"

Length of output: 2056

Now let me see the complete create_commit_ix match statement and the BufferTask::instruction() method:

--- 🏁 Script executed: ```shell #!/bin/bash # Get the full create_commit_ix match statement sed -n '168,210p' magicblock-committor-service/src/tasks/mod.rs # Find BufferTask::instruction method rg -n "pub fn instruction" magicblock-committor-service/src/tasks/mod.rs -B 2 -A 25 | head -60

Length of output: 2419

Let me search more specifically for the BufferTask instruction method:

--- 🏁 Script executed: ```shell #!/bin/bash # Find BufferTask struct and impl blocks rg -n "struct BufferTask|impl BufferTask" magicblock-committor-service/src/tasks/mod.rs # Search for instruction method more broadly rg -n "\.instruction\(&validator\)" magicblock-committor-service/src/tasks/mod.rs -B 5 -A 5

Length of output: 1871

Let me search across all files for BufferTask definition:

--- 🏁 Script executed: ```shell #!/bin/bash # Search for BufferTask struct definition and impl across all files rg -n "pub struct BufferTask|impl BufferTask" magicblock-committor-service # Check args_task.rs since it appeared in earlier search rg -n "pub fn instruction|pub struct BufferTask" magicblock-committor-service/src/tasks/args_task.rs -A 10 | head -40

Length of output: 155

Now let me examine the BufferTask implementation:

--- 🏁 Script executed: ```shell #!/bin/bash # Read the buffer_task.rs file to find instruction() method cat magicblock-committor-service/src/tasks/buffer_task.rs

Length of output: 3557

Add tests for buffer instruction builders to ensure coverage of new create_commit_state_from_buffer_ix and create_commit_diff_from_buffer_ix paths

The test_buffer_task_instruction_serialization test constructs CommitTask via CommitTaskBuilder::create_commit_task(), which defaults to TaskStrategy::Args. Since the test never calls switch_to_buffer_strategy(), the instruction dispatch in CommitTask::create_commit_ix() always takes the Args branch and never exercises the new buffer instruction builders.

To cover these paths, either:

Modify test_buffer_task_instruction_serialization to call switch_to_buffer_strategy() on the CommitTask before wrapping it in BufferTask, or

Add dedicated tests that directly construct a CommitTask with TaskStrategy::Buffer and verify the buffer instruction builders are called.

🤖 Prompt for AI Agents

In magicblock-committor-service/src/tasks/mod.rs around lines 220 to 232, the unit tests never exercise the new buffer-based instruction builders because CommitTask is constructed with the default TaskStrategy::Args; update tests to cover the buffer paths by either calling switch_to_buffer_strategy() on the CommitTask instance inside test_buffer_task_instruction_serialization before wrapping it in BufferTask, or add a new test that directly constructs a CommitTask with TaskStrategy::Buffer (or uses the builder to set the strategy) and asserts that create_commit_state_from_buffer_ix and create_commit_diff_from_buffer_ix are produced/used; ensure the test verifies serialization and expected instruction variants so both buffer branches are covered.

coderabbitai

Actionable comments posted: 2

♻️ Duplicate comments (1)

magicblock-committor-service/src/tasks/mod.rs (1)

561-586: Tests still serialize Args-style commit instructions for BufferTask; add coverage for buffer strategy and *_from_buffer builders

test_buffer_task_instruction_serialization constructs BufferTaskType::Commit with a CommitTask from CommitTaskBuilder::create_commit_task(...), which still defaults to TaskStrategy::Args. Because BufferTask::instruction() now just delegates to CommitTask::create_commit_ix(), this test ends up exercising the Args path (plain commit_state / commit_diff) rather than the new buffer-based commit_*_from_buffer instructions.

To actually cover the buffer paths and the new buffer instruction builders, update the test to either:

call switch_to_buffer_strategy() on the CommitTask before wrapping it in BufferTaskType::Commit, or

construct a CommitTask with TaskStrategy::Buffer via the builder or a helper, and assert that create_commit_ix() produces the expected *_from_buffer variants.

This aligns the test with the intended semantics of BufferTask and gives direct coverage of the new buffer commit flows.

📜 Review details

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between cbbf5ee and e3ce6e6.

⛔ Files ignored due to path filters (3)

Cargo.lock is excluded by !**/*.lock
test-integration/Cargo.lock is excluded by !**/*.lock
test-integration/schedulecommit/elfs/dlp.so is excluded by !**/*.so

📒 Files selected for processing (6)

Cargo.toml (1 hunks)
magicblock-committor-service/src/tasks/args_task.rs (1 hunks)
magicblock-committor-service/src/tasks/buffer_task.rs (2 hunks)
magicblock-committor-service/src/tasks/mod.rs (5 hunks)
test-integration/Cargo.toml (1 hunks)
test-integration/schedulecommit/test-scenarios/tests/02_commit_and_undelegate.rs (1 hunks)

🧰 Additional context used

🧠 Learnings (3)

📓 Common learnings

Learnt from: taco-paco
Repo: magicblock-labs/magicblock-validator PR: 661
File: magicblock-committor-service/src/intent_executor/single_stage_executor.rs:20-28
Timestamp: 2025-11-21T10:22:07.520Z
Learning: In magicblock-committor-service's SingleStageExecutor and TwoStageExecutor (single_stage_executor.rs and two_stage_executor.rs), the fields transaction_strategy, junk, and patched_errors are intentionally public because these executors are designed to be used independently outside of the IntentExecutor scope, and callers need access to these execution reports for cleanup and error handling.

📚 Learning: 2025-10-26T16:54:39.084Z

Learnt from: thlorenz
Repo: magicblock-labs/magicblock-validator PR: 587
File: test-manual/Cargo.toml:0-0
Timestamp: 2025-10-26T16:54:39.084Z
Learning: In the magicblock-validator repository, use git branch references (not commit hashes or tags) for the helius-laserstream dependency to allow automatic updates when the branch is pushed to.

Applied to files:

Cargo.toml

📚 Learning: 2025-11-21T10:22:07.520Z

Learnt from: taco-paco
Repo: magicblock-labs/magicblock-validator PR: 661
File: magicblock-committor-service/src/intent_executor/single_stage_executor.rs:20-28
Timestamp: 2025-11-21T10:22:07.520Z
Learning: In magicblock-committor-service's SingleStageExecutor and TwoStageExecutor (single_stage_executor.rs and two_stage_executor.rs), the fields transaction_strategy, junk, and patched_errors are intentionally public because these executors are designed to be used independently outside of the IntentExecutor scope, and callers need access to these execution reports for cleanup and error handling.

Applied to files:

magicblock-committor-service/src/tasks/mod.rs

🧬 Code graph analysis (3)

test-integration/schedulecommit/test-scenarios/tests/02_commit_and_undelegate.rs (1)

test-integration/programs/schedulecommit/src/order_book.rs (1)

bids (182-184)

magicblock-committor-service/src/tasks/buffer_task.rs (3)

magicblock-committor-program/src/state/chunks.rs (1)

from_data_length (46-49)

magicblock-committor-service/src/tasks/mod.rs (1)

optimize (78-80)

magicblock-committor-service/src/tasks/args_task.rs (1)

optimize (87-100)

magicblock-committor-service/src/tasks/mod.rs (1)

magicblock-committor-service/src/persist/types/commit_strategy.rs (1)

args (17-23)

🔇 Additional comments (6)

test-integration/schedulecommit/test-scenarios/tests/02_commit_and_undelegate.rs (1)

256-262: Change is appropriate for stress-testing the BufferTask implementation.

The 10x increase in test data (max 200 entries vs. 20 previously) aligns with the PR's goal of validating CommitDiff as BufferTask for large accounts. Verification confirms:

CI runs on extra-large runner with adequate resources

No explicit test timeout configured (relies on GitHub Actions default 360-minute limit)

Test is intentionally "huge" and properly instrumented with seed output for reproducibility

No environment capacity concerns identified.

Cargo.toml (1)

112-114: Delegation-program git rev bump looks consistent; verify compatibility with new buffer commit instructions

The new magicblock-delegation-program rev is pinned consistently here and in test-integration/Cargo.toml, and the feature set is unchanged ("no-entrypoint"), so workspace wiring looks good. Please just confirm this rev contains the *_from_buffer commit instructions your new CommitTask buffer paths rely on and that integration tests pass against it.

test-integration/Cargo.toml (1)

60-62: Test workspace dependency aligned with root; ensure integration tests cover new buffer commit paths

The magicblock-delegation-program rev here matches the root workspace and keeps "no-entrypoint", so dependency alignment looks correct. Please make sure the updated integration tests actually exercise the new buffer-based commit/diff paths against this program version.

magicblock-committor-service/src/tasks/args_task.rs (1)

91-95: Commit optimization correctly switches to Buffer strategy before wrapping in BufferTask

Routing ArgsTaskType::Commit through value.switch_to_buffer_strategy() before constructing BufferTaskType::Commit ensures that optimized commit tasks consistently take the buffer-based path (and thus use the new *_from_buffer instructions). This aligns with the new TaskStrategy design and fixes the prior need for ad‑hoc flags.

magicblock-committor-service/src/tasks/mod.rs (2)

55-59: TaskStrategy + CommitTask refactor gives a clean two-path model (Args vs Buffer)

Introducing TaskStrategy and threading it through CommitTask (with CommitTaskBuilder defaulting to Args and switch_to_buffer_strategy() for buffer flows) makes the commit behavior explicit and removes the previous ad‑hoc flagging. The create_commit_ix() match on (strategy, base_account) cleanly encodes:

Args + no base account → CommitState.

Args + base account → CommitDiff.

Buffer + no base account → CommitStateFromBuffer.

Buffer + base account → CommitDiffFromBuffer.

This layout is straightforward to reason about and aligns well with the PR’s goal of supporting CommitDiff via BufferTask without degrading to CommitState purely due to transaction-size constraints.

Also applies to: 149-167, 169-193

4-6: I'll search the public magicblock repositories to verify the API contract.

I need to search for the actual source code of the delegation-program repository to verify the API contract. Let me look for the specific function signatures.

Based on my web search for the magicblock-delegation-program repository, I was unable to access the specific source code details needed to verify the API contract. The searches returned the repository index and documentation pages, but not the actual function signatures for commit_state_from_buffer, commit_diff_from_buffer, or the CommitStateFromBufferArgs struct definition.

To properly verify the concerns raised in this review comment, you would need to:

Review the delegation-program repository source code (specifically the instruction builders and args modules) to confirm that both commit_state_from_buffer and commit_diff_from_buffer accept the same CommitStateFromBufferArgs struct

Examine the on-chain processor implementations to verify that buffer contents are interpreted consistently as either full state or diff bytes, matching how BufferTask::preparation_required prepares them

Confirm the buffer PDA derivation uses the same parameters across all functions

The original concern about the API contract alignment is valid and warrants manual verification against the actual dlp crate implementation.

Verify that commit_state_from_buffer and commit_diff_from_buffer in the dlp crate both accept CommitStateFromBufferArgs, and confirm the on-chain handlers interpret buffer contents consistently with how BufferTask prepares them (lines 244-293 and related code).

coderabbitai · 2025-11-21T23:57:14Z

magicblock-committor-service/src/tasks/buffer_task.rs

+        let state_or_diff = if let Some(diff) = commit_task.compute_diff() {
+            diff.to_vec()
+        } else {
+            commit_task.committed_account.account.data.clone()
+        };
+        let chunks =
+            Chunks::from_data_length(state_or_diff.len(), MAX_WRITE_CHUNK_SIZE);

        PreparationState::Required(PreparationTask {
            commit_id: commit_task.commit_id,
            pubkey: commit_task.committed_account.pubkey,
-            committed_data,
+            committed_data: state_or_diff,
            chunks,


🛠️ Refactor suggestion | 🟠 Major

BufferTask now writes diff-or-state into buffer; ensure CommitTask is always in Buffer strategy when used here

Using commit_task.compute_diff() to decide whether to write a diff or full state into PreparationTask.committed_data, and deriving Chunks from that length, is the right behavior for committing via buffers: buffer contents and chunking will match what *_from_buffer instructions expect.

One subtle requirement, though, is that the embedded CommitTask must have strategy == TaskStrategy::Buffer; otherwise instruction() will still emit the args-based commit instruction and completely ignore the prepared buffer, wasting the prep work and potentially re‑hitting tx-size limits.

Since ArgsTask::optimize already calls value.switch_to_buffer_strategy() before wrapping in BufferTaskType::Commit, this is satisfied for the main flow, but any other construction of BufferTask::Commit (including the tests) currently relies on the caller remembering to switch strategies.

Consider tightening this by either:

Having BufferTask::new_preparation_required (or preparation_required) assert in debug builds that the inner CommitTask has TaskStrategy::Buffer, and/or

Moving the switch_to_buffer_strategy() call into the BufferTask construction path so callers cannot accidentally pass an Args‑strategy commit task.

That would make BufferTask semantics self-contained and prevent silent misuse.

Also applies to: 65-77

🤖 Prompt for AI Agents

In magicblock-committor-service/src/tasks/buffer_task.rs around lines 48-60 (and similarly 65-77), the code accepts a CommitTask but does not guarantee its TaskStrategy is Buffer, which can cause prepared buffer data to be ignored if the task remains in Args strategy; update BufferTask construction to enforce Buffer strategy by either calling commit_task.switch_to_buffer_strategy() before using it and/or adding a debug_assert!(commit_task.strategy == TaskStrategy::Buffer) (or equivalent) inside new_preparation_required/preparation_required so callers cannot accidentally pass an Args-strategy commit task and the buffer path will always be used.

coderabbitai · 2025-11-21T23:57:14Z

magicblock-committor-service/src/tasks/mod.rs

+    pub fn compute_diff(&self) -> Option<dlp::rkyv::AlignedVec> {
+        self.base_account.as_ref().map(|base_account| {
+            compute_diff(
+                base_account.data(),
+                self.committed_account.account.data(),
+            )
+        })
+    }
+


🧹 Nitpick | 🔵 Trivial

Reuse compute_diff() where possible to avoid duplicated diff logic (optional)

CommitTask::compute_diff() encapsulates the base-vs-committed diff computation and is already used by BufferTask for preparation. create_commit_diff_ix() still re‑implements the same compute_diff(base_account.data(), committed_account.data()) call inline.

Not a bug, but you could slightly simplify and DRY this by delegating to self.compute_diff() and unwrapping (since this method is only called when base_account is Some), e.g.,

let diff = self .compute_diff() .expect("base_account must be Some when using CommitDiff");

before constructing CommitDiffArgs. That keeps all diff computation logic in one place and ensures Args and Buffer strategies remain in lockstep if the diffing behavior ever changes.

Also applies to: 220-232

🤖 Prompt for AI Agents

In magicblock-committor-service/src/tasks/mod.rs around lines 196-204 and 220-232, duplicate diff computation is performed inline; instead call the existing CommitTask::compute_diff() and unwrap it (since these call-sites only occur when base_account is Some), e.g. replace the inline compute_diff(base_account.data(), committed_account.account.data()) usage with let diff = self.compute_diff().expect("base_account must be Some when using CommitDiff") and then use diff to construct CommitDiffArgs and other structures; this delegates all diff logic to the single method to avoid duplication and keep behaviors in sync.

This was referenced Nov 6, 2025

feat: Add support for CommitDiff to efficiently commit small changes in large delegated accounts #575

Open

refactor: Rename optimize() -> try_optimize_tx_size() #617

Open

feat: Make TaskStrategy more granular #618

Draft

snawaz requested a review from GabrielePicco November 6, 2025 05:23

snawaz marked this pull request as ready for review November 6, 2025 05:23

snawaz mentioned this pull request Nov 6, 2025

feat: Add CommitDiffFromBuffer ix magicblock-labs/delegation-program#118

Merged

snawaz force-pushed the snawaz/commit-diff-buffer branch 4 times, most recently from dd95c9a to 4a09180 Compare November 10, 2025 06:35

snawaz force-pushed the snawaz/commit-diff branch 2 times, most recently from 4ea5450 to 41493c5 Compare November 10, 2025 07:00

snawaz force-pushed the snawaz/commit-diff-buffer branch 2 times, most recently from 17f396e to 3259f79 Compare November 17, 2025 05:57

snawaz force-pushed the snawaz/commit-diff branch from 385e7a3 to 3999503 Compare November 17, 2025 05:59

snawaz force-pushed the snawaz/commit-diff-buffer branch 2 times, most recently from 23a797e to 64d79cc Compare November 17, 2025 06:16

snawaz force-pushed the snawaz/commit-diff branch from 3999503 to 256ab3f Compare November 17, 2025 06:16

snawaz force-pushed the snawaz/commit-diff-buffer branch 2 times, most recently from 5838b75 to e182eb1 Compare November 17, 2025 10:31

snawaz force-pushed the snawaz/commit-diff branch from 59b7935 to c07a177 Compare November 17, 2025 10:31

snawaz force-pushed the snawaz/commit-diff-buffer branch 2 times, most recently from 18adf1e to 5b95cad Compare November 17, 2025 13:36

snawaz force-pushed the snawaz/commit-diff branch from 9da0edd to cf6229d Compare November 17, 2025 13:36

snawaz force-pushed the snawaz/commit-diff-buffer branch 2 times, most recently from 2aada37 to 2eb5776 Compare November 18, 2025 12:36

snawaz mentioned this pull request Nov 21, 2025

refactor: Simplify Task types #665

Draft

snawaz force-pushed the snawaz/commit-diff-buffer branch from 9be6a8a to b94a549 Compare November 21, 2025 18:44

snawaz force-pushed the snawaz/commit-diff branch from 9e8da2d to 34d41c2 Compare November 21, 2025 18:44

snawaz force-pushed the snawaz/commit-diff-buffer branch from b94a549 to d445507 Compare November 21, 2025 19:23

snawaz force-pushed the snawaz/commit-diff branch from 34d41c2 to effba68 Compare November 21, 2025 19:23

coderabbitai bot reviewed Nov 21, 2025

View reviewed changes

snawaz force-pushed the snawaz/commit-diff branch from effba68 to 61c8c28 Compare November 21, 2025 20:30

snawaz force-pushed the snawaz/commit-diff-buffer branch from d445507 to cbbf5ee Compare November 21, 2025 20:30

snawaz force-pushed the snawaz/commit-diff branch from 61c8c28 to 7d6f839 Compare November 21, 2025 20:55

snawaz force-pushed the snawaz/commit-diff-buffer branch 2 times, most recently from 8f7f30d to 74155a6 Compare November 21, 2025 21:24

snawaz force-pushed the snawaz/commit-diff branch from 7d6f839 to faed161 Compare November 21, 2025 21:24

snawaz force-pushed the snawaz/commit-diff-buffer branch from 74155a6 to 280eeb7 Compare November 21, 2025 21:34

snawaz force-pushed the snawaz/commit-diff branch from faed161 to 9c11945 Compare November 21, 2025 21:34

snawaz added 3 commits November 22, 2025 03:52

feat: Execute CommitDiff as BufferTask

9ed3f64

Update dlp.so that now has CommitDiffFromBuffer

1bb9384

Remove is_commit_diff

e3ce6e6

snawaz force-pushed the snawaz/commit-diff branch from 9c11945 to a42745b Compare November 21, 2025 23:52

snawaz force-pushed the snawaz/commit-diff-buffer branch from 280eeb7 to e3ce6e6 Compare November 21, 2025 23:52

coderabbitai bot reviewed Nov 21, 2025

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

feat: Execute CommitDiff as BufferTask #616

feat: Execute CommitDiff as BufferTask #616

Uh oh!

snawaz commented Nov 6, 2025 •

edited by coderabbitai bot

Loading

Uh oh!

coderabbitai bot commented Nov 6, 2025 •

edited

Loading

Walkthrough

Possibly related PRs

Suggested reviewers

Uh oh!

snawaz commented Nov 6, 2025 •

edited

Loading

Uh oh!

coderabbitai bot left a comment

Uh oh!

coderabbitai bot Nov 21, 2025

Uh oh!

coderabbitai bot left a comment

Uh oh!

coderabbitai bot Nov 21, 2025

Uh oh!

coderabbitai bot Nov 21, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

feat: Execute CommitDiff as BufferTask #616

Are you sure you want to change the base?

feat: Execute CommitDiff as BufferTask #616

Uh oh!

Conversation

snawaz commented Nov 6, 2025 • edited by coderabbitai bot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Problem

Solution

Related

Screenshot

Summary by CodeRabbit

Uh oh!

coderabbitai bot commented Nov 6, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Walkthrough

Possibly related PRs

Suggested reviewers

Uh oh!

snawaz commented Nov 6, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

coderabbitai bot left a comment

Choose a reason for hiding this comment

Uh oh!

coderabbitai bot Nov 21, 2025

Choose a reason for hiding this comment

Uh oh!

coderabbitai bot left a comment

Choose a reason for hiding this comment

Uh oh!

coderabbitai bot Nov 21, 2025

Choose a reason for hiding this comment

Uh oh!

coderabbitai bot Nov 21, 2025

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

snawaz commented Nov 6, 2025 •

edited by coderabbitai bot

Loading

coderabbitai bot commented Nov 6, 2025 •

edited

Loading

snawaz commented Nov 6, 2025 •

edited

Loading