feat(cketh): install a deposit address' delegation with its first sweep

[gregorydemay]

Part of DEFI-2917 (deposit-from-CEX), stacked on #11144, which gives the sweeper address the pipeline this teaches a second transaction type.

Why

A deposit address holds ERC-20 tokens but no code, so it cannot sweep itself. The minter delegates it to the sweeper contract with an EIP-7702 authorization, and the cheapest place to carry that authorization is the sweep that needs it: the first sweep touching an address installs the delegation on the way, and the delegation then persists, so every later sweep of that address is a plain EIP-1559 transaction. deposit_from_cex_demo measures 94'932 gas for the first sweep of one address against 63'252 for the next.

What

Two refactorings first, each a no-op: finalization and fee-bumping stop being EIP-1559-only, and a request names the transaction it turns into rather than the pipeline naming one type for both lanes. Both reduce to a single new primitive — a transaction that can restate itself at a different price — which is also what gives EIP-7702 fee-bumping for free, with no machinery of its own.

Then the sweeper lane carries either transaction type, and a sweep carries the signed authorizations it must install. Holding them in the request keeps building the transaction a pure function of it and puts them in the accepted event, so neither a replay nor a fee bump ever re-signs one: an authorization covers the chain, the delegate and the authority's nonce, and nothing of the outer transaction. One place decides which type a sweep becomes, from whether there is anything left to install, which is what keeps the two representations in step.

Scope

Nothing enqueues a sweep yet, so nothing builds an authorization in production. Which addresses still need delegating is deliberately left to the sweep-queue source, along with reading each address' delegation from the chain — the request carries signed authorizations rather than a "needs delegation" flag precisely so that decision lives there. The batch-dependent gas limit a delegating sweep needs is deferred with it; #11237's flat 100'000 does not cover one.

Tests

A two-variant transaction type goes wrong by signing the wrong preimage, so both variants are checked to hash and to encode byte-identically to the transaction they wrap, with golden CBOR for each since the event log stores them. On the pipeline side: which variant a request produces, delegations surviving a fee bump, and finalizing a sweep that installed them.

Candid compatibility

Two new type definitions, used only by the sweeper events #11144 adds and that therefore exist nowhere on mainnet. The UnsignedTransaction carried by the mainnet withdrawal events is left alone rather than widened with an optional authorization list, and the call data and signature components are blobs like their neighbours.

_{Stack created with GitHub Stacks CLI • Give Feedback 💬}

[Copilot]

Pull request overview

Adds EIP-7702 delegation installation to first-time ckETH deposit-address sweeps while generalizing transaction pipeline mechanics.

Changes:

• Introduces EIP-1559/EIP-7702 sweep transactions.
• Generalizes finalization and fee resubmission.
• Extends audit events and Candid types with signed authorizations.

Reviewed changes

Copilot reviewed 16 out of 16 changed files in this pull request and generated 2 comments.

Show a summary per file

File	Description
tests/dump_stable_memory.rs	Maps new sweep events.
src/tx/tests.rs	Tests sweep encoding and signing.
src/tx/sweep.rs	Defines variant sweep transactions.
src/tx/signed.rs	Expands the signable transaction interface.
src/tx/mod.rs	Generalizes fee resubmission.
src/tx/finalized.rs	Adds generic finalized transactions.
src/tx/eip_7702.rs	Enables EIP-7702 fee bumps.
src/tx/eip_1559.rs	Adopts generic transaction machinery.
src/state/transactions/tests.rs	Tests delegating sweep pipelines.
src/state/transactions/request.rs	Creates the appropriate sweep variant.
src/state/transactions/mod.rs	Generalizes transaction pipelines.
src/state/event.rs	Stores sweep transaction variants.
src/state/audit/tests.rs	Updates event replay mapping.
src/main.rs	Exposes authorization data in events.
src/endpoints.rs	Adds Candid-facing sweep types.
cketh_minter.did	Updates the public Candid interface.

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.

[Copilot]

Pull request overview

Copilot reviewed 16 out of 16 changed files in this pull request and generated no new comments.

Suppressed comments (2)

rs/ethereum/cketh/minter/tests/dump_stable_memory.rs:193

• Delegating sweeps are signed type-0x04 transactions, but this path always calls an EIP-1559-only decoder and then constructs SweepTransaction::Eip1559. Once a signed delegating sweep appears in get_events, decode_signed_transaction rejects it at its TypedTransaction::Eip1559 match, so stable-memory dumping cannot process the new event. Decode type 0x04 (including its authorization list) and construct the matching sweep variant.

fn map_signed_sweep_transaction(raw_transaction: &str) -> SignedSweepTransaction {
    let (transaction, signature) = decode_signed_transaction(raw_transaction);
    SignedSweepTransaction::from((SweepTransaction::Eip1559(transaction), signature))

rs/ethereum/cketh/minter/src/state/audit/tests.rs:250

• This replay mapper still accepts only TypedTransaction::Eip1559 and unconditionally rebuilds the signed sweep as that variant. A signed first sweep is type 0x04, so refreshing/replaying events after delegating sweeps begin will panic instead of reconstructing state. Decode EIP-7702 raw transactions and preserve their authorization list here.

        fn map_signed_sweep_transaction(raw_transaction: &str) -> SignedSweepTransaction {
            let (transaction, signature) = decode_signed_transaction(raw_transaction);
            SignedSweepTransaction::from((SweepTransaction::Eip1559(transaction), signature))