Events and errors

This layer defines the 26 event structs the program emits and the 100 error variants the program returns.

Files

Responsibilities

• Define one #[event] struct per observable effect with #[derive(Clone)] at events.rs:108-481.
• Provide ReusableEventEmitter, an emitter that reuses one buffer across a batch of self-CPIs at events.rs:64-106.
• Check every event discriminator against sha256("event:<Name>")[..8] in a unit test at events.rs:492-540.
• Define the SickleError enum. Anchor assigns code 6000 plus the variant index at errors.rs:3-4.
• Keep the variant order append-only, as the comments at errors.rs:103, errors.rs:196, and errors.rs:213 require.

The layer does not emit events and does not return errors itself. The handlers and runners do both. This page lists where.

Public items

events.rs

Every event has #[event] and #[derive(Clone)]. The Clone derive exists so a handler can pass the same value to emit_cpi! and then to emit!. The module comment at events.rs:14-20 shows the pattern.

Untyped fields are Pubkey, u64, i32, or bool as their names suggest. Read the declared line for the exact type.

A runner builds an event and returns it inside a receipt struct. The handler emits it. Example: venue/open_increase.rs:87 stores a PositionOpened in the run receipt, and instructions/orca/open_position.rs:96-97 emits it.

Two Anchor accounts make emission possible. #[event_cpi] on an accounts struct appends event_authority and program to the account list. Source: anchor-attribute-event-1.1.2/src/lib.rs:201-214. 49 handler files carry the attribute. 16 do not: the 12 admin handlers, set_manager, set_custom_automator, create_sickle_ata, and initialize_intent_domain.

Four handlers use the emitter: instructions/raydium/rebalance_for.rs:244, instructions/raydium/exit_for.rs:254, instructions/meteora/rebalance_for.rs:407, and instructions/meteora/exit_for.rs:327. The other 45 emitting files use the Anchor macros.

The emitter exists because the SBF bump allocator does not free a dropped Vec inside one instruction. The comment at events.rs:55-63 states that Anchor's emit_cpi! allocates 3 vectors per event and that the late Raydium event batch ran out of the 32 KiB heap. The emitter allocates once and recovers the capacity after each self-CPI.

errors.rs

SickleError is one #[error_code] enum at errors.rs:3-216. Anchor assigns each variant the code 6000 plus its index. The test at venue/adapters/raydium_flows.rs:1261 computes 6000 + SickleError::RewardCollectorMismatch as u32 and compares it with error_code_number. The comment at errors.rs:103 states the order rule.

The table lists every variant, its code, its message, the number of SickleError::<Variant> sites outside errors.rs, and one representative site. Sites include unit tests. There are 905 sites in total.

How a call flows through it

This follows the Swept event of sweep_token, then the emitter path of raydium_rebalance_for, then one error.

Macro path.

1. The handler builds Swept and calls emit_cpi!(event.clone()). instructions/sickle/sweep_token.rs:76-82.
2. The macro reads ctx.accounts.event_authority, prepends the event tag to Event::data, and calls invoke_signed with seeds [b"__event_authority", bump]. Source: anchor-attribute-event-1.1.2/src/lib.rs:170-198.
3. The self-CPI re-enters the program. The dispatcher sees the event tag and returns. Source: anchor-syn-1.1.2/src/codegen/program/dispatch.rs:90-93.
4. The handler calls emit!(event). The macro logs the same bytes without the tag as a Program data: line. instructions/sickle/sweep_token.rs:83.

Emitter path.

1. The handler creates one ReusableEventEmitter from ctx.accounts.event_authority. instructions/raydium/rebalance_for.rs:244-245.
2. emit_user(&run.fees_collected) serializes into the reused buffer, runs the self-CPI, restores the buffer, and logs the bytes after the tag. instructions/raydium/rebalance_for.rs:246, events.rs:99-105.
3. Each FeeCharged goes through emit_cpi only. instructions/raydium/rebalance_for.rs:248, instructions/raydium/rebalance_for.rs:253.
4. Rebalanced, PositionOpened, and the optional SettingsUpdated go through emit_user. instructions/raydium/rebalance_for.rs:256-259.

Error path.

1. A handler or runner writes require!(cond, SickleError::FeeTooHigh). instructions/admin/set_fee.rs:21.
2. Anchor builds an AnchorError with error_code_number 6003 and the message from errors.rs:11.
3. The runtime returns the custom error to the caller. The TypeScript tests read err.error.errorCode.code and compare the variant name. tests/sickle/core.ts:1004.

Invariants the layer owns

1. Every event discriminator equals sha256("event:<Name>")[..8]. The test at events.rs:492-540 recomputes it for all 26 events.
2. The event data layout is the 8-byte discriminator followed by the borsh fields. The test at events.rs:547-586 checks a Protocol enum byte and an Option<FeeAction> tail.
3. The emitter produces the same bytes as Anchor's macros and never reallocates its buffer across 7 event kinds. The test at events.rs:589-695 compares the buffer with EVENT_IX_TAG_LE + Event::data and checks the pointer and capacity after each event.
4. A user-facing event reaches both the inner-instruction record and the log. The handlers write emit_cpi! then emit!, or call emit_user. No check enforces the pair. See L06-N006.
5. FeeCharged reaches only the inner-instruction record, and only for a nonzero amount. Every site sits under an amount > 0 or fee > 0 test. Examples: instructions/raydium/harvest_for.rs:140-148, venue/owner_rebalance.rs:360. For the six reward sites the test now lives once in reward_event_pair (venue/claim.rs:126), which returns None for a zero fee, and each caller emits only what it is handed.
6. The error code of a variant never changes. The comments at errors.rs:103, errors.rs:196, and errors.rs:213 require appends only. The test at venue/adapters/raydium_flows.rs:1261 depends on it.

Tests

Gaps. No test asserts that each user-facing event appears once in the inner instructions and once in the logs for every emitting instruction. No test asserts that FeeCharged never appears in the logs. The reallocation test covers 7 event kinds, not the DlmmLiquidityRemoved and DlmmRebalanced kinds that meteora_exit_for and meteora_rebalance_for send through the emitter. The list at events.rs:493-532 is hand-written. No test checks that every #[event] struct is in it.

The variant-name grep over tests/**/*.ts and over the Rust #[cfg(test)] modules finds no test for 29 variants. They are: InvalidBufferTicks, InvalidSlippageBps, InvalidPriceImpactBps, InvalidHarvestTokenOut, InvalidExitTriggers, InvalidMetadataUpdateAuth, SwapConsentRequired, InvalidInstructionsSysvar, InvalidIntentDomainVersion, InvalidEd25519Instruction, IntentEdgeNotAllowed, IntentBudgetExceeded, IntentMinOutNotMet, VaultBelowBaseline, RewardGroupMissing, RewardGroupMismatch, SettingsCandidateRequired, RebalanceNoOp, WithdrawalFloorMismatch, WithdrawalMinimumNotMet, IntentDustPolicyExceeded, InvalidDlmmPositionRange, InvalidDlmmResize, UnsupportedDlmmPair, InvalidDlmmBinArrays, InvalidDlmmReward, InvalidDlmmBitmapExtension, InvalidDlmmRemovalBps, InvalidDlmmLiquidityParameters. Some Rust tests may reach these variants through is_err() without naming them.

Simplification and audit notes

1. L06-N001 — errors.rs:92 SwapConsentRequired and errors.rs:96 MissingZapInLeg have 0 sites in programs/sickle/src. The IDL copy at management-ui/src/lib/idl/sickle.json:8665 and :8675 still lists them. Their codes are 6043 and 6045. Removing them renumbers the 54 variants after MissingZapInLeg, so every stored code above 6045 changes.
2. L06-N002 — errors.rs:91 gives SwapConsentRequired the message "jupiter_swap outside an intent flow requires the sickle owner". The live check for that condition at instructions/jupiter/swap.rs:72-76 returns Unauthorized. The message describes a check that returns a different variant.
3. L06-N003 — errors.rs:103 opens a comment block named "Phase-2 ActionIntent". The block runs to errors.rs:195 and contains variants unrelated to authorizations: RewardGroupMissing at :159, UnsupportedTransferHookMint at :169, UnsupportedMintExtension at :179, and InvalidRebalanceDelay at :195. The section header no longer matches its contents.
4. L06-N004 — Three variants account for 312 of the 905 sites: InvalidAccountOwner with 108, InvalidProtocolAccountData with 106, and InvalidPosition with 98. A failed transaction with one of these codes points to no specific check.
5. L06-N005 — errors.rs:6 Unauthorized has 49 sites and errors.rs:8 NotGuardianOrAdmin has 2 sites, including instructions/admin/pause.rs:26. Two variants cover the same category of failure.
6. L06-N006 — Every macro-path handler writes the pair emit_cpi!(event.clone()); emit!(event); by hand. The pair appears in 45 files. Every FeeCharged site skips emit! by hand at 32 sites. No helper or test enforces either convention on the macro path. The emitter has emit_user and emit_cpi for the same two cases.
7. L06-N007 — events.rs:8-9 says the funded Raydium keeper handlers use the emitter. instructions/meteora/rebalance_for.rs:407 and instructions/meteora/exit_for.rs:327 also use it. The comment names 2 of the 4 users.
8. L06-N008 — events.rs:325-326 says Exited comes from the keeper exit_for flow. venue/keeper_exit.rs:216 builds it for exit_for and raydium_exit_for, and instructions/meteora/exit_for.rs:397 builds it too. The comment names 1 of the 3 emitting instructions.
9. L06-N009 — events.rs:26-30 says admin and config instructions emit nothing. create_sickle_ata and initialize_intent_domain also emit nothing and have no #[event_cpi]. The comment does not name them.
10. L06-N010 — events.rs:89 reads crate::EVENT_AUTHORITY_AND_BUMP. declare_id! generates that constant only under Anchor's event-cpi feature. Source: anchor-attribute-account-1.1.2/src/id.rs:44-49. The emitter at events.rs:81-96 copies the body of Anchor's emit_cpi! expansion at anchor-attribute-event-1.1.2/src/lib.rs:170-198. An Anchor upgrade that changes the expansion does not change the emitter.
11. L06-N011 — events.rs:99-105 emit_user logs self.instruction_data[8..] after emit_cpi returns. The bytes are valid only because emit_cpi moves the buffer back at events.rs:94. The two methods share state through the buffer instead of through a return value.
12. L06-N012 — events.rs:43 sets the buffer capacity to 264 bytes. No compile-time or unit check proves every event kind fits. The reallocation test at events.rs:589-695 proves it for 7 kinds.
13. L06-N013 — events.rs:80 and events.rs:98 mark both emitter methods #[inline(never)]. The attribute has no comment in events.rs. The reason is the 4 KiB SBF stack frame, and only the CI grep at .github/workflows/ci.yml:106-108 catches an overflow.
14. L06-N014 — events.rs:50 calls .unwrap() on event.serialize(buffer). The comment on events.rs:49 says the writer is infallible. A panic here aborts the instruction without an Anchor error code.
15. L06-N015 — instructions/intent/finalize_dlmm_intent.rs:100 emits IntentFinalized. The DLMM authorization side has its own DlmmIntentAuthorized, DlmmIntentAuthorizationCancelled, and DlmmIntentAuthorizationExpired at events.rs:402-450. The DLMM finalization side reuses the CLMM struct. An indexer cannot tell the family from the finalization event alone.
16. L06-N016 — events.rs:493-532 lists the 26 event names as string literals beside the struct names. A new #[event] struct compiles and emits without joining the list.
17. L06-N017 — venue/owner_rebalance.rs:378 map_events builds Rebalanced and PositionOpened for both the owner rebalance and the keeper rebalance. venue/keeper_rebalance.rs:366 calls it. The function lives in the owner runner but serves both runners.

Resolved

1. L06-R001 — instructions/raydium/harvest_for.rs:271-280, instructions/raydium/compound_for.rs:310-318, and instructions/raydium/collect_fees.rs:190-198 emitted FeeCharged per reward but no RewardsCollected. instructions/orca/harvest_for.rs:274-284, instructions/orca/compound_for.rs:319, and instructions/orca/collect_rewards.rs:79 emit RewardsCollected per reward. An indexer saw the Raydium reward fee but not the Raydium reward amount for these 3 instructions, and saw nothing at all when the fee floored to zero, because FeeCharged is emitted only when it is non-zero. All six sites now derive both events from reward_event_pair in programs/sickle/src/venue/claim.rs, which withholds the pair for a Raydium reward whose payout is folded into a pool-token delta and therefore has no exact amount of its own. Named by symbol rather than by line: the checker skips resolved notes, so a line here would rot unchecked. Resolved in #184.

Related

• Entry points and program-wide plumbing
• Dependency graph
• Style guide