Karaknetwork vaults in legacy token and native ETH restaking
Karaknetwork vaults in the July 2024 restaking design held token collateral or accounted for native validator ETH under an operator. Standard token vaults issued transferable shares. NativeVault tracked validator withdrawal credentials and balance proofs, with nontransferable shares. Both exposed the position to service penalties and delayed exits. The compatible deposit and withdrawal methods followed the vault implementation and underlying collateral.
Jump to a section
Karak announced its rebrand to OpenGDP on November 16, 2025. V1 Staking, V2 Staking and K2 Bridge appear as separate legacy entries. The July 2024 contracts gave token deposits and validator ETH different accounting and exit interfaces.
Both vault types backed an operator's service commitments
Operators could allocate either vault type to Distributed Secure Services, or DSSs, as economic security. Stakers supplied the collateral. The operator performed service tasks and chose which vaults to stake with each service. In the July 2024 design, every selected vault committed its entire balance to that DSS. A service could penalize an operator's failures by slashing the allocated funds. This exposed the staker's collateral to consequences arising from the operator's work, even though the staker did not perform those tasks.
Which vault type matched token collateral or validator ETH?
The standard Vault accepted token collateral; NativeVault accounted for validator ETH through an owner's NativeNode. Each accepted asset had its own vault under the operator. A standard deposit transferred the underlying token into that vault and minted shares for its recipient. The token's contract identity determined the collateral, even when different assets used similar names. Operator acceptance alone did not make every asset compatible with every vault. Standard token vaults also offered a deposit overload with a
minSharesOut
check. That overload reverted if minted shares fell below the specified minimum. Native admission relied on validator credentials and proofs.
NativeVault used a separate node and validator proofs to account for ETH participating in Ethereum validation. The withdrawal credentials pointed to the owner's NativeNode. Its initialization required a special asset marker. Ordinary token deposit calls did not populate the native position. A token wallet balance therefore differed from the validator-backed records this implementation expected.
Core's July 2024 deployment path checked configured assets against registered slashing handlers and checked non-default implementations against its approval rules. That validation governed this deployment function. An approved implementation could still use specialized entry points, so its approval status did not make NativeVault behave like a standard token vault.
Matching an existing position to its exit interface
An existing token position and validator-backed ETH position required different contract interfaces. Before choosing an exit call, match the position to its deployed implementation. The historical design supplied the rules; the deployment's collateral identity, function availability and position records supplied the changing details.
- Match the recorded vault address to its chain and operator before comparing the supported calls.
-
For a standard token vault, match the collateral contract with
asset()and identify the holder's share balance. - For NativeVault, identify the node owner, NativeNode and validator withdrawal credentials backing the position.
-
Select the supported exit pair:
startRedeemandfinishRedeemfor tokens, orstartWithdrawalandfinishWithdrawalfor native ETH. - Check the queued request and relevant function pause state before treating a recorded balance as an executable withdrawal.
Agreement between the collateral record and supported calls established a compatible exit path for that position. A queued request recorded a pending exit; the completed asset transfer to its recipient established payment.
Token shares and native shares carried different rights
Standard vault shares recorded ownership of the corresponding underlying assets and could take the form of transferable ERC-20 tokens. A transfer moved the share claim to its new holder. The asset value of that claim followed the vault's asset-to-share accounting, so a share amount and a collateral amount described different quantities. Slashing could lower the assets backing the shares. Transferability did not make a delayed redemption immediate or remove the position's service exposure.
NativeVault disabled
transfer
and
transferFrom
in the July 2024 implementation. Its minted and burned shares supported the node owner's accounting.
Native balances depended on completed snapshots
In the July 2024 code, a native snapshot completed only after proofs covered every active validator in the node. The snapshot combined previously uncredited ETH on the NativeNode with validator balance changes. Finishing that calculation updated the owner's accounting and credited node ETH for withdrawal. Proofs concerned an identified beacon state, so a wallet's token balance could not replace them.
An incomplete snapshot blocked another snapshot for that node. Missing proofs could therefore interrupt later balance updates.
Snapshot timing also affected withdrawals. The code measured snapshot age from its recorded start timestamp, which became
lastSnapshotTimestamp
when the proofs finished. A
startWithdrawal
call rejected a new request once that timestamp reached the seven-day expiry boundary. The expired-snapshot function could begin a replacement without requiring newly arrived node ETH. That exception did not bypass the active-validator proofs needed to complete it. Expiry also did not clear an unfinished snapshot; the same pending-snapshot check still applied. A snapshot's age and its proof completion therefore described separate conditions.
Initial validator admission used effective balance and could leave excess validator ETH for a later snapshot. Subsequent snapshots handled balance changes through share minting or burning. This gave native positions a proof-based accounting path distinct from token transfers.
What determined the native ETH available for withdrawal?
NativeVault calculated withdrawable ETH as the lower of the owner's share-equivalent assets and credited node ETH. The July 2024
withdrawableWei
function expressed that limit in wei. Because ETH on the Beacon Chain could contribute to restaking accounting without immediately funding a withdrawal, the available amount followed both the owner's share-equivalent claim and the ETH already credited on the NativeNode.
The queued amount could shrink before completion. During
finishWithdrawal
, the code capped the payment at the then-withdrawable amount if the request exceeded it. It decreased the owner's accounting, sent ETH to the recorded recipient and removed the queued request. The requested amount did not guarantee an unchanged payment throughout the waiting period. Native slashing and accounting defects also affected historical revisions, so later mitigation status mattered alongside the mathematical cap.
Token redemption and native withdrawal used different calls
With sufficient share allowance to the vault, the holder could initiate a standard token exit through
startRedeem
, which took shares and a beneficiary. The July 2024 contract transferred those shares into the vault while recording a queued request. Its event also included an asset conversion for the share amount. That conversion described the request-time accounting. The separate
finishRedeem
call recalculated the assets due for the queued shares at completion. It burned those shares and paid the beneficiary when its conditions passed. Ordinary
withdraw
and
redeem
calls reverted in this implementation.
Native exit requests used
startWithdrawal
with an ETH amount in wei, followed by
finishWithdrawal
. NativeVault also disabled the ordinary
deposit
,
mint
,
withdraw
and
redeem
functions. Sharing an ERC4626 base class did not make the standard and native entry points interchangeable. An adapter expecting an immediate ERC4626 exit would need a different integration for these queued operations.
Shared service allocations exposed the same vault assets
An operator could allocate a vault to multiple DSSs in the July 2024 design. Each allocation staked the full vault balance to that service. The protocol measured leverage by the number of services using the vault. Each service's allocation referred to the same underlying collateral. A deposit into a vault with more allocations therefore carried exposure to more service relationships. A DSS could choose to reject or jail an operator it considered overleveraged. Jailing belonged to the service's own policy and could affect task participation or rewards.
Service rewards stayed outside the vault core
A DSS handled reward distribution separately from the core vault contracts. The July 2024 design recommended an off-chain indexer to calculate entitlements and a Merkle distribution to pay them. Sending rewards directly to a vault raised front-running concerns in that design. Because service rewards could use a different asset and a nonlinear allocation, the transferable shares of a token vault and the nontransferable shares of NativeVault did not by themselves determine the amount or currency of a DSS payment.
NativeVault risks varied across reviewed revisions
The 2024 mitigation review confirmed a fix for native withdrawal accounting capable of locking ETH after slashing. It also confirmed a correction for zero-amount slashing failures in token vaults. Those statuses concerned the reviewed revisions. Reading the original contract alone could describe behavior a later implementation had changed, while merely seeing a completed audit could hide issues the review left unresolved.
One high-severity native-vault finding retained an unmitigated status in that review. The issue involved operator-supplied configuration capable of preventing successful slashing. Before mitigation, operators supplied native configuration values including the manager, slashing store and node implementation. A mismatched slashing store could make penalties fail. The reviewed mitigation removed SlashStore and moved ETH burning into NativeVault. The follow-up review retained an unmitigated status because an operator could appoint itself manager and install a malicious NativeNode implementation to steal stakers' funds. The review treated manager trustworthiness as the remaining assumption. Compatibility included the precise implementation and its authority settings.
Did token and native vaults have the same withdrawal delay?
Both token and native vaults used a nine-day minimum withdrawal delay in the July 2024 design. The constants combined a seven-day slashing window with a two-day veto window. The native finishing function rejected a request before its minimum delay elapsed. Token redemptions likewise used a queued request followed by a finishing call. This waiting period allowed a service time to penalize qualifying earlier conduct before assets exited.
Expiry of the minimum wait did not establish immediate payment. A paused finishing function could block execution. Available assets still constrained the payout. The nine-day value concerned this contract revision, without establishing a blanket waiting period for V1 or later deployments. Operator stake changes used a different constant,
MIN_STAKE_UPDATE_DELAY
, which the July 2024 design also set to nine days.
Quick answers
Can the recipient of a native ETH withdrawal differ from the node owner?
The July 2024 NativeVault allowed a node owner to specify a separate withdrawal recipient. Its startWithdrawal function accepted a to address and stored it with the queued amount and owner. The finishing function used that recorded address for the ETH payment. Choosing a recipient did not transfer the native shares or change ownership of the validator-backed node.
When could someone else submit balance proofs for a native restaking position?
The July 2024 NativeVault allowed any address to submit valid balance proofs for an active snapshot. The proofs had to concern active validators in the identified owner's node and match the snapshot's beacon root. The contract rejected a validator already proved for that snapshot. Submitting proofs did not assign the caller the node owner's shares or withdrawal rights.
Does a DSS calculate slashing from the original deposit amount?
The July 2024 slashing code calculated a requested penalty from the vault's totalAssets at request time. It applied the requested percentage to that balance and recorded the amount for later finalization. The DSS maximum percentage limited each request; repeated requests could create further losses. A two-day cooldown governed when that DSS could request another penalty for the operator.
What happened when a native withdrawal exceeded the uncommitted withdrawable amount?
The July 2024 NativeVault rejected an excessive withdrawal request with WithdrawMoreThanMax if pending commitments did not already exceed withdrawableWei. If they did, the subtraction reverted before the comparison. It compared the requested wei amount with withdrawableWei minus amounts already committed to pending withdrawals. A positive total balance did not authorize another request for the same committed ETH. This initiation check differed from the finishing function's cap, which could reduce a previously accepted request's payment if availability later fell.
Would a positive ERC4626 preview prove an immediate vault withdrawal could execute?
A positive preview did not establish an executable immediate withdrawal in the July 2024 standard Vault. The implementation overrode ordinary withdraw and redeem to revert, while inherited previewWithdraw and previewRedeem could still return values. Those estimates reflected conversion logic; they did not bypass queued redemption. NativeVault had separate overrides, so a base-library estimate could not substitute for its native withdrawal interface.
Who could veto a pending slashing request against either vault type?
Only the configured veto committee role could cancel a queued slashing request through the July 2024 Core contract. Holding token vault shares or owning a NativeNode did not grant that role. The two-day veto window set the earliest finalization time. In that code, a still-pending request could remain cancellable by the authorized committee after the window elapsed.
Should a DSS count queued withdrawal assets toward ongoing rewards?
The July 2024 design instructed a DSS to stop counting a staker's withdrawing assets once withdrawal began. This covered reward calculations and voting weight, even while the withdrawal delay preserved exposure to potential penalties. The design placed that responsibility on the service. A queued withdrawal therefore did not imply reward eligibility continued until payout, or guarantee every service implemented the accounting correctly.
Updated -