Karaknetwork operators and their first legacy V2 DSS registration
Karaknetwork operators registered with Distributed Secure Services to perform security tasks backed by staker collateral in the July 2024 V2 restaking design. Registration established the service relationship; allocating a vault required a queued stake update and later finalization. Those contracts imposed a nine-day minimum on stake updates.
Karak announced its rebrand to OpenGDP on November 16, 2025, and the staking interfaces now appear as legacy entries. New operator registration depends on the selected deployment's function availability and service admission rules.
Service admission before the first vault commitment
A first operator session began by identifying the intended DSS contract and the account making registration calls on the selected V2 deployment. The DSS had to exist in Core's registered-service records, and its registration hook could enforce service-specific admission requirements. Before submitting, the operator checked that the account had no existing registration with that DSS and fewer than 32 DSS registrations under the July 2024 logic. The operator submitted registration with any data the service's hook required. A successful transaction established the operator-DSS relationship, which
isOperatorRegisteredToDSS
independently exposed as true for the exact account and service.
An existing token balance or vault did not establish whether an account could join the service. The registration read did not confirm vault allocation.
The operator could stop before submitting registration, leaving the existing service relationship unchanged.
Service obligations governed the allocation choice
The DSS defined the work operators performed and the penalties its rules allowed for failures. A DSS could request slashing of allocated collateral when an operator failed its service duties. Operators could stake a vault with several DSSs in the documented V2 design, committing the vault's entire balance to each service. Adding a service therefore added another obligation against the same collateral; it did not divide that balance into separate protected portions. Each DSS set its maximum slashable percentage once when registering, within the protocol's allowed range;
getDssMaxSlashablePercentageWad
exposed that configured value.
This setting differed from the timing constants and described a cap per slashing request. It did not describe an expected loss or a lifetime protection ceiling.
Vault configuration joined collateral to the operator
Through Core's vault deployment path, operators selected approved collateral and a compatible implementation before allocating a vault to a service. The July 2024 configuration checks required an asset-specific slashing handler. A nondefault custom implementation also needed approval. These requirements applied to deployment through
deployVaults
. Each asset an operator accepted had its own vault, and Core's
getOperatorVaults
read identified the vaults attached to that operator. Standard token vaults and NativeVault used different collateral accounting, so their implementations carried different setup requirements. NativeVault's designated manager also had node-upgrade authority in the reviewed design, which could let a malicious manager steal stakers' ETH by installing replacement node code.
Queued stake updates required later finalization
An operator with service registration and an attached vault without a pending stake update requested allocation through
requestUpdateVaultStakeInDSS
. The request named the vault and DSS, with
toStake
set to true for staking or false for unstaking. The recorded request described a pending change, so accepting it did not complete allocation.
Request timing and the recorded payload
A request awaiting its minimum delay
The July 2024 V2 contracts required a minimum nine-day delay before finalizing a queued vault stake update. The delay ran from the request's recorded start timestamp. Elapsed time did not execute the change automatically.
A finalized vault stake update
finalizeUpdateVaultStakeInDSS
used the original queued request, checking its recorded identity and elapsed delay before updating the service's vault set.
fetchVaultsStakedInDSS
exposed the operator-DSS allocation: successful staking added the selected vault to that set, while successful unstaking removed it.
The pause state belonged to each operation
Request and finalization functions had separate pause controls in the July 2024 contracts. An available request function did not establish that finalization could execute, even after a valid request reached its minimum age.
Registration fees changed with execution conditions
Registration costs followed the selected network's transaction pricing and the work Core and any DSS hook performed. The stake-update delay did not set a transaction price. A fee estimate described the proposed execution under the network conditions prevailing when someone requested it. Registration data and hook behavior could change the work a transaction attempted.
A rejected payload before a successful registration
This hypothetical legacy V2 session used an illustrative operator account, registered DSS, service payload, fee budget and network pricing. The relevant registration function was available. The operator had not yet committed a vault to that service. The selected service's registration hook required data acceptable under its own admission rules.
The service's hook rejected the initial payload during simulation, so the operator corrected that service-specific input and resolved the rejection. The operator then compared fee quotes for the same registration call. Higher network pricing raised the later quote, while the legacy minimum stake-update delay remained unchanged. The quotes concerned registration costs, not the waiting period for allocation.
With the later quote within budget, the operator submitted registration and obtained a successful transaction receipt. A separate
isOperatorRegisteredToDSS
read returned true for that account and service. The operator stopped before requesting vault allocation.
Service reward accounting followed operator work
DSSs coordinated operator tasks and reward calculations under their own rules. Legacy V2 core contracts did not distribute DSS rewards. The design recommended off-chain computation with a Merkle distribution handled by the service. Operators needed the service's reward terms when evaluating participation. A vault balance or completed allocation alone established neither a payout amount nor a payment schedule.
Unallocation and unresolved requests needed separate handling
Leaving a service with allocated vaults required their unallocation before operator unregistration. Operators queued unstaking through the same stake-update mechanism and finalized the changes after the applicable delay. Core allowed unregistration once the service's allocated vault set was empty. An unstake request alone did not satisfy that condition.
Service hooks could reject registration or staking admission. The July 2024 design handled failures from unallocation hooks without reverting the whole unallocation transaction. This prevented those hooks from blocking that exit path. A different cause, including a paused Core function, still needed its own diagnosis.
A reverted finalization left the attempted allocation change unapplied; the service's vault set remained the completion check.
Contract revision also affected recovery. The 2024 mitigation review identified cases where a failed slashing finalization left a pending slash recorded. The finding's applicability depended on the deployed revision. That review also left H-02 unmitigated because the NativeVault manager retained upgrade authority under a stated trust assumption.
Practical questions
Could another account finalize a queued operator stake update?
The July 2024 V2 finalization function allowed another account to complete a valid queued stake update. The operator controlled initiation, while finalization checked the queued request and its minimum age without requiring the caller to be that operator. Function pauses still applied. This permission concerned completing the existing request, not initiating a new stake-update request on the operator's behalf.
What blocked a second stake update for the same vault?
The July 2024 operator logic allowed only one pending stake update per vault. A further request for that vault failed while the existing update occupied its pending slot. This restriction followed the vault, even when a proposed second request concerned another DSS. Successful finalization cleared the pending record.
Which capacity limits applied to legacy V2 operators?
The July 2024 constants capped each operator at 32 vaults and 32 registered DSSs. Core rejected additional vault creation or DSS registration when the corresponding 32-item limit was reached. They did not describe the number of assets a live operator offered, the services currently accepting operators or the amount of collateral available. Actual participation depended on that operator's recorded configuration.
Did my first DSS registration grant permission to change Core settings?
Registering with a DSS did not grant an operator Core's owner or manager privileges in the July 2024 design. Core assigned privileged roles separately during initialization. Those roles governed actions such as asset approval, pause controls and hook gas configuration. An operator's service membership and vault commitments therefore differed from protocol administration rights.
When should a DSS stop counting an operator vault toward rewards?
The July 2024 design instructed a DSS to stop counting a vault toward off-chain rewards immediately when its operator initiated unstaking. The pending unallocation interval existed to preserve time for slashing, not to extend reward eligibility. This rule applied to that vault's participation in the affected DSS; it did not establish a universal payout schedule.
How did DSS-level jailing affect an operator's service access?
A DSS could implement operator jailing within its own service contract in the legacy design. Jailing was optional, and the service defined its effects. Those effects could include withholding rewards, preventing task participation or requiring unallocation. Core did not supply a uniform jailing policy, so the service's implementation governed this additional restriction.
Were DSS hook gas limits permanent protocol constants?
The July 2024 Core design allowed its owner or manager to update the configured gas limits and buffer for DSS hook calls. These settings constrained service callbacks and differed from network transaction prices. A changed hook gas limit could affect whether a callback completed, without redefining the minimum delay for a queued vault stake update.
Updated -