Skip to content
Merged
Show file tree
Hide file tree
Changes from 6 commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
141 changes: 141 additions & 0 deletions .github/workflows/claude-review.yml
Original file line number Diff line number Diff line change
@@ -0,0 +1,141 @@
name: Perform a code review when a pull request is created.
on:
pull_request:
types: [opened, synchronize, reopened, ready_for_review]

jobs:
claude:
# Skip drafts, and skip fork PRs: on `pull_request` they don't get the
# ANTHROPIC_API_KEY secret, so the review would only fail.
if: >-
!github.event.pull_request.draft &&
github.event.pull_request.head.repo.full_name == github.repository
runs-on: ubuntu-latest
permissions:
contents: read
outputs:
structured_output: ${{ steps.run_claude.outputs.structured_output }}
steps:
- uses: actions/checkout@fbc6f3992d24b796d5a048ff273f7fcc4a7b6c09 # v5.1.0
with:
# Explicitly check out the PR's merge commit.
ref: refs/pull/${{ github.event.pull_request.number }}/merge
persist-credentials: false

- name: Pre-fetch base and head refs for the PR
env:
PR_BASE_REF: ${{ github.event.pull_request.base.ref }}
PR_NUMBER: ${{ github.event.pull_request.number }}
run: |
# Pass GitHub expressions through env and quote shell expansions.
git fetch --no-tags origin \
"$PR_BASE_REF" \
"+refs/pull/$PR_NUMBER/head"

# If you want Claude to build and run code, install any dependencies that
# need to be downloaded before the "Run Claude" step, and add the commands
# it may run to --allowedTools below (e.g. "Bash(npm test:*)"). Any tool
# not listed there is denied.

- name: Run Claude
id: run_claude
uses: anthropics/claude-code-action@86d88e619d8e6caf07b5c3944dd14f441c533718 # v1.0.243
with:
anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
# Use this job's read-only token instead of the Claude GitHub App,
# which needs `id-token: write` and would get write access.
github_token: ${{ github.token }}
prompt: |
This is PR #${{ github.event.pull_request.number }} for ${{ github.repository }}.

Review ONLY the changes introduced by the PR, so consider:
git log --oneline ${{ github.event.pull_request.base.sha }}...${{ github.event.pull_request.head.sha }}
git diff ${{ github.event.pull_request.base.sha }}...${{ github.event.pull_request.head.sha }}

Suggest any improvements, potential bugs, or issues.
Be concise and specific in your feedback.

Return your review in two parts:
- `summary`: a short Markdown overview of the PR and your overall assessment.
- `comments`: one entry per specific issue, anchored to the line it concerns.
`path` is relative to the repository root. `line` is the line number in
the PR head version of the file (${{ github.event.pull_request.head.sha }}),
and must be a line shown in the diff above. The working tree is the merge
commit, so its line numbers can differ; check them with
`git show ${{ github.event.pull_request.head.sha }}:<path>`.
Put issues that don't belong to a single line in `summary` instead.

Pull request title and body:
----
${{ github.event.pull_request.title }}
${{ github.event.pull_request.body }}
claude_args: |
--allowedTools "Read,Grep,Glob,Bash(git log:*),Bash(git diff:*),Bash(git show:*)"
--json-schema '{
"type": "object",
"properties": {
"summary": {
"type": "string",
"description": "Overall review as Markdown, posted as the review body."
},
"comments": {
"type": "array",
"description": "Inline comments, each anchored to one line of the PR diff.",
"items": {
"type": "object",
"properties": {
"path": { "type": "string", "description": "File path relative to the repository root." },
"line": { "type": "integer", "minimum": 1, "description": "Line number in the PR head version of the file. Must be within the diff." },
"body": { "type": "string", "description": "The comment, as Markdown." }
},
"required": ["path", "line", "body"]
}
}
},
"required": ["summary", "comments"]
}'

post_feedback:
runs-on: ubuntu-latest
needs: claude
if: needs.claude.outputs.structured_output != ''
permissions:
issues: write
pull-requests: write
steps:
- name: Report Claude feedback
uses: actions/github-script@f28e40c7f34bde8b3046d885e986cb6290c5673b # v7.1.0
env:
CLAUDE_STRUCTURED_OUTPUT: ${{ needs.claude.outputs.structured_output }}
with:
github-token: ${{ github.token }}
script: |
const { summary = '', comments = [] } = JSON.parse(process.env.CLAUDE_STRUCTURED_OUTPUT);
const pr = context.payload.pull_request;
if (!summary.trim() && comments.length === 0) {
core.info('Claude returned an empty review; nothing to post.');
return;
}

try {
await github.rest.pulls.createReview({
owner: context.repo.owner,
repo: context.repo.repo,
pull_number: pr.number,
commit_id: pr.head.sha,
event: 'COMMENT',
body: summary.trim() || 'See inline comments.',
comments: comments.map(({ path, line, body }) => ({ path, line, side: 'RIGHT', body })),
});
} catch (error) {
// GitHub rejects the whole review if any comment points outside the
// diff. Fall back to a single PR comment so no feedback is lost.
core.warning(`Could not post inline review (${error.message}); posting a plain comment instead.`);
const details = comments.map(({ path, line, body }) => `**\`${path}:${line}\`**\n\n${body}`);
await github.rest.issues.createComment({
owner: context.repo.owner,
repo: context.repo.repo,
issue_number: pr.number,
body: [summary.trim(), ...details].filter(Boolean).join('\n\n---\n\n'),
});
}
157 changes: 125 additions & 32 deletions crates/core/src/rpc/surfnet_cheatcodes.rs
Original file line number Diff line number Diff line change
Expand Up @@ -1428,11 +1428,14 @@ pub trait SurfnetCheatcodes {
/// - `fetchBeforeUse`: If true, fetch fresh account data just before transaction execution (useful for price feeds, oracle updates, and dynamic balances)
/// - `account`: Account address (either `{ "pubkey": "..." }` or `{ "pda": { "programId": "...", "seeds": [...] } }`)
/// - `tags`: Array of tags for categorization
/// - `slot` (optional): The base slot from which relative slot offsets are calculated. If omitted, uses the current slot.
/// - `slot` (optional): The base slot from which relative slot offsets are calculated. If omitted, the next slot the surfnet produces. A base slot that is already produced is rejected with InvalidParams.
///
/// ## Returns
/// A `RpcResponse<()>` indicating whether the Scenario registration was successful.
///
/// Overrides are applied when the surfnet produces their slot; nothing is applied during this call.
/// `surfnet_timeTravel` produces only the next slot before it jumps, so overrides scheduled in the slots it skips are never applied; step one slot at a time.
///
/// ## Example Request (with slot)
/// ```json
/// {
Expand Down Expand Up @@ -1464,7 +1467,7 @@ pub trait SurfnetCheatcodes {
/// ],
/// "tags": ["defi", "price-feed"]
/// },
/// 355684457
/// 355684458
/// ]
/// }
/// ```
Expand Down Expand Up @@ -2517,37 +2520,14 @@ impl SurfnetCheatcodes for SurfnetCheatcodesRpc {
scenario: Scenario,
slot: Option<Slot>,
) -> BoxFuture<Result<RpcResponse<()>>> {
let SurfnetRpcContext {
svm_locker,
remote_ctx,
} = match meta.get_rpc_context(CommitmentConfig::confirmed()) {
Ok(res) => res,
Err(e) => return e.into(),
};
let SurfnetRpcContext { svm_locker, .. } =
match meta.get_rpc_context(CommitmentConfig::confirmed()) {
Ok(res) => res,
Err(e) => return e.into(),
};

Box::pin(async move {
// Get the base slot for registration (either provided or current)
let base_slot = slot.unwrap_or_else(|| svm_locker.get_latest_absolute_slot());

// Register the scenario with explicit base slot
svm_locker
.register_scenario(scenario, Some(base_slot))
.map_err(|e| jsonrpc_core::Error {
code: jsonrpc_core::ErrorCode::InternalError,
message: format!("Failed to register scenario: {}", e),
data: None,
})?;

// Immediately materialize overrides for the BASE slot (not current slot)
// This ensures slot 0's override is applied right away
svm_locker
.materialize_overrides_for_slot(&remote_ctx, base_slot)
.await
.map_err(|e| jsonrpc_core::Error {
code: jsonrpc_core::ErrorCode::InternalError,
message: format!("Failed to materialize initial overrides: {}", e),
data: None,
})?;
svm_locker.register_scenario(scenario, slot)?;

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The response only reports get_latest_absolute_slot(), so callers can't tell which base slot was chosen, and the docs tell them to wait for that slot. Return the base slot from register_scenario, e.g. SurfpoolResult<Slot>, and include it in the response (as the value or in the context). That spares SDK and Studio callers from assuming context.slot + 1, which a block produced between registration and response would make wrong.


Ok(cheatcode_response(
svm_locker.get_latest_absolute_slot(),
Expand Down Expand Up @@ -2583,7 +2563,8 @@ mod tests {

use super::*;
use crate::{
rpc::surfnet_cheatcodes::SurfnetCheatcodesRpc, tests::helpers::TestSetup,
rpc::surfnet_cheatcodes::SurfnetCheatcodesRpc,
tests::helpers::{TestSetup, UNHEALTHY_OFFSET, scheduled_override_fixture},
types::confidential_key_signature,
};

Expand Down Expand Up @@ -6196,4 +6177,116 @@ mod tests {
"the wrong aesKey should fail rather than decrypt"
);
}

#[tokio::test(flavor = "multi_thread")]
async fn test_register_scenario_applies_overrides_when_the_next_slot_is_produced() {
let client = TestSetup::new(SurfnetCheatcodesRpc::empty());
let (account_pubkey, instance) = client
.context
.svm_locker
.with_svm_writer(scheduled_override_fixture);
let account = || {
client.context.svm_locker.with_svm_reader(|svm_reader| {
svm_reader
.inner
.get_account(&account_pubkey)
.unwrap()
.unwrap()
})
};
let scheduled_slots = || {
client
.context
.svm_locker
.with_svm_reader(|svm_reader| svm_reader.scheduled_overrides.keys().unwrap())
};
let before = account();
let mut scenario = Scenario::new("next slot".to_string(), String::new());
scenario.add_override(instance);

let response = client
.rpc
.register_scenario(Some(client.context.clone()), scenario, None)
.await
.expect("registering without a slot should succeed");

assert_eq!(response.context.slot, 123);
assert_eq!(account(), before, "registering must not apply anything");
assert_eq!(scheduled_slots(), vec![124]);

client
.context
.svm_locker
.confirm_current_block(&None)
.await
.unwrap();

assert_eq!(
&account().data[UNHEALTHY_OFFSET..UNHEALTHY_OFFSET + 16],
&1_234u128.to_le_bytes(),
"producing slot 124 applies its override"
);
assert!(scheduled_slots().is_empty());
}

#[tokio::test(flavor = "multi_thread")]
async fn test_register_scenario_rejects_a_produced_base_slot() {
let client = TestSetup::new(SurfnetCheatcodesRpc::empty());
let (_, instance) = client
.context
.svm_locker
.with_svm_writer(scheduled_override_fixture);

for produced_slot in [123, 100] {
let mut scenario = Scenario::new("produced slot".to_string(), String::new());
scenario.add_override(instance.clone());

let error = client
.rpc
.register_scenario(Some(client.context.clone()), scenario, Some(produced_slot))
.await
.expect_err("a base slot that is already produced must be rejected");

assert_eq!(error.code, jsonrpc_core::ErrorCode::InvalidParams);
assert_eq!(
error.message,
format!("base slot {produced_slot} is already produced; the next slot is 124")
);
}
let scheduled_slots = client
.context
.svm_locker
.with_svm_reader(|svm_reader| svm_reader.scheduled_overrides.keys().unwrap());
assert!(scheduled_slots.is_empty());
}

#[tokio::test(flavor = "multi_thread")]
async fn test_register_scenario_rejects_a_relative_slot_that_overflows() {
let client = TestSetup::new(SurfnetCheatcodesRpc::empty());
let (_, instance) = client
.context
.svm_locker
.with_svm_writer(scheduled_override_fixture);
let mut scenario = Scenario::new("overflow".to_string(), String::new());
scenario.add_override(instance.clone());
let mut far = instance;
far.scenario_relative_slot = u64::MAX;
scenario.add_override(far);

let error = client
.rpc
.register_scenario(Some(client.context.clone()), scenario, None)
.await
.expect_err("a relative slot that overflows must be rejected");

assert_eq!(error.code, jsonrpc_core::ErrorCode::InvalidParams);
let scheduled_slots = client
.context
.svm_locker
.with_svm_reader(|svm_reader| svm_reader.scheduled_overrides.keys().unwrap());
assert!(
scheduled_slots.is_empty(),
"nothing may be scheduled when one override is rejected"
);
}
}
7 changes: 5 additions & 2 deletions crates/core/src/scenarios/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -36,8 +36,11 @@ whole struct or array) also works, but it must be **complete** - every field of
padding included - because the account is re-encoded with Borsh. An out-of-range index or a
non-numeric segment on an array is a hard error, never a silent write elsewhere.

An override is applied once. Its resulting account state remains in later slots until a transaction
or another override writes that account again.
An override is applied once, when the surfnet produces its slot; nothing is applied during the
registration call. Its resulting account state remains in later slots until a transaction or another
override writes that account again.
`surfnet_timeTravel` produces only the next slot before it jumps, so overrides scheduled in the slots
it skips are never applied; step one slot at a time to play a scenario under a paused clock.

### Kamino integration tests

Expand Down
17 changes: 15 additions & 2 deletions crates/core/src/surfnet/locker.rs
Original file line number Diff line number Diff line change
Expand Up @@ -2855,13 +2855,26 @@ impl SurfnetSvmLocker {
self.with_svm_reader(Self::offline_account_owners)
}

/// Registers a scenario for execution
/// Schedules a scenario's overrides from `slot`, or from the next slot when omitted.
/// A base slot that is already produced is rejected: nothing would ever apply it.
pub fn register_scenario(
&self,
scenario: surfpool_types::Scenario,
slot: Option<Slot>,
) -> SurfpoolResult<()> {
self.with_svm_writer(move |svm_writer| svm_writer.register_scenario(scenario, slot))
self.with_svm_writer(move |svm_writer| {
let current_slot = svm_writer.get_latest_absolute_slot();
let next_slot = current_slot
.checked_add(1)
.ok_or_else(|| SurfpoolError::internal("the slot counter overflowed"))?;
let base_slot = slot.unwrap_or(next_slot);
if base_slot <= current_slot {

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This rejects slots that are already produced, but nothing guards against a slot the clock will skip. Time travel runs confirm_current_block once, which applies current+1, and then calls set_latest_absolute_slot(target). Anything scheduled in (current+1, target] is never applied and stays in scheduled_overrides. Since the first column now depends on slot production too, consider applying every pending slot <= new_slot during time travel, or document this limitation next to the rejection message.

return Err(SurfpoolError::invalid_params(format!(
"base slot {base_slot} is already produced; the next slot is {next_slot}"
)));
}
svm_writer.register_scenario(scenario, Some(base_slot))

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The base-slot check validates input up front, but svm.register_scenario still stores overrides one by one, and a later base + relative overflow fails with SurfpoolError::internal. When that happens:

  1. The scenario is left partly scheduled, because the overrides before the failing one are already stored.
  2. A bad caller input comes back as InternalError instead of InvalidParams.

Now that this function owns RPC validation, it's cheap to check every base_slot.checked_add(o.scenario_relative_slot) before calling into the SVM and return invalid_params on failure.

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The locker always passes Some(base_slot) here, but SurfnetSvm::register_scenario still defaults None to the current slot (svm.rs:4688), which is the old behaviour. Consider making the SVM parameter non-optional (base_slot: Slot) so the two layers can't drift apart. The pump and phoenix tests already pass explicit slots.

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

SurfnetSvm::register_scenario (svm.rs:4989) still defaults None to the current slot. This locker always passes Some, so the RPC path is fine. But the two layers now have different defaults, and any direct SVM caller (like the pump tests) gets the old "already produced" behaviour without being told. Make the SVM method take a Slot instead of Option<Slot>, or give both layers the same default.

})
}

/// Materializes overrides for a specific slot (not necessarily the current slot)
Expand Down
Loading
Loading