SatLayer BVS Slashing

...
// ill-liquidate the receipt token from the staker
// by moving the asset into this vault balance.
// We can't burn until the actual unstaking (redeem withdrawal) occurs.
// due to total supply mutation can impact the exchange rate to change prematurely.

cw20_base::contract::execute_transfer(
    deps.branch(),
    env.clone(),
    info.clone(),
    env.contract.address.to_string(), //@Dedaub: token sender is info.sender
    msg.amount,
)?;
...

...
let request_resolution = env
    .block
    .time
    .plus_seconds(slashing_parameters.resolution_window);

// request_expiry will be using `resolution_window`
// value from the timestamp's slashing_parameters,
// instead of the most recent slashing param.
// This ensures that both parties agree upon all parameters used.
let request_expiry = env
    .block
    .time
    .plus_seconds(slashing_parameters.resolution_window)
    .plus_seconds(SLASHING_REQUEST_EXPIRY_WINDOW.u64());

let new_request = SlashingRequest {
    request: data.clone(),
    request_time: env.block.time,
    request_resolution, //@Dedaub: slashing cannot take place until resolution window passes
    request_expiry,
    status: SlashingRequestStatus::Pending.into(),
    service: service.clone(),
};
...

...
// require active status between operator and service
let StatusResponse(operator_service_status) = deps.querier.query_wasm_smart(
    registry.to_string(),
    &bvs_registry::msg::QueryMsg::Status {
        service: service.to_string(),
        operator: operator.to_string(),
        timestamp: Some(data.timestamp.seconds()), //@Dedaub: Slashable action timestamp
    },
)?;
...

// get slashing params of the service at the given timestamp, also checks if slashing is enabled
let SlashingParametersResponse(slashing_parameters) = deps.querier.query_wasm_smart(
    registry.clone(),
    &bvs_registry::msg::QueryMsg::SlashingParameters {
        service: service.to_string(),
        timestamp: Some(data.timestamp.seconds()),
    },
)?;
...

// ensure that bips is greater than zero
if data.bips < 1 {
    return Err(InvalidSlashingRequest {
        msg: "Slashing bips must be greater than zero".to_string(),
    });
}
...
// ensure bips must not exceed max_slashing_bips set by service
if data.bips > slashing_parameters.max_slashing_bips {
    return Err(InvalidSlashingRequest {
        msg: "Slashing bips exceeds the maximum allowed by service".to_string(),
    });
}

...
match SlashingRequestStatus::try_from(prev_slashing_request.status)? {
    SlashingRequestStatus::Pending => {
        // slashing is pending within the expiry date
        if prev_slashing_request.request_expiry > env.block.time {
            return Err(ContractError::InvalidSlashingRequest {
                msg: "Cannot process new request while previous slashing request is pending".to_string(),
            });
        }
...

...
pub fn is_operator_opted_in_to_slashing(
    deps: Deps,
    service: Addr,
    operator: Addr,
    timestamp: Option<u64>,
) -> StdResult<IsOperatorOptedInToSlashingResponse> {
    let is_opted_in =
        state::is_operator_opted_in_to_slashing(deps.storage, &service, &operator, timestamp)?;
    Ok(IsOperatorOptedInToSlashingResponse(is_opted_in))
}
...

...
if !is_operator_opted_in {
    return Err(InvalidSlashingRequest {
        msg: "Operator must be opted-in to slashing at the specified timestamp".to_string(),
    });
}
...

/// Withdraw assets from the vault by burning receipt token.
/// The resulting staked assets are now unstaked and transferred to `msg.recipient`.
pub fn withdraw_to(
    mut deps: DepsMut,
    env: Env,
    info: MessageInfo,
    msg: RecipientAmount,
) -> Result<Response, ContractError> {
    router::assert_not_validating(&deps.as_ref())?;
...

pub fn assert_not_validating(deps: &Deps) -> Result<(), VaultError> {
    let router = get_router(deps.storage)?;
    let operator = get_operator(deps.storage)?;

    let is_delegated: bool = deps.querier.query_wasm_smart(
        router.to_string(),
        &QueryMsg::IsValidating {
            operator: operator.to_string(),
        },
    )?;
    if is_delegated {
        return Err(VaultError::Validating {});
    }
    Ok(())
}

/// Returns whether the operator is delegated or not.
/// Called by vaults to check if they are delegated.
/// Delegated vaults must queue withdrawals.
pub fn is_validating(deps: Deps, operator: Addr) -> StdResult<bool> {
    let registry = state::get_registry(deps.storage)?;
    let is_operator_active: bool = deps.querier.query_wasm_smart(
        registry.to_string(),
        &QueryMsg::IsOperatorActive(operator.to_string()),
    )?;

    Ok(is_operator_active)
}

/// Check if the operator is actively registered to any service
pub fn is_operator_active(store: &dyn Storage, operator: &Operator) -> StdResult<bool> {
    let active_count = OPERATOR_ACTIVE_REGISTRATION_COUNT
        .may_load(store, operator)?
        .unwrap_or(0);

    Ok(active_count > 0)
}

/// Deregister a service from an operator (info.sender is the Operator)
/// Set the registration status to [`RegistrationStatus::Inactive`] (0)
pub fn deregister_service_from_operator(
    deps: DepsMut,
    info: MessageInfo,
    env: Env,
    service: Addr,
) -> Result<Response, ContractError> {
    let operator = info.sender.clone();

    let key = (&operator, &service);
    let status = get_registration_status(deps.storage, key)?;

    if status == RegistrationStatus::Inactive {
        Err(ContractError::InvalidRegistrationStatus {
            msg: "Service is not registered with this operator".to_string(),
        })
    } else {
        set_registration_status(deps.storage, &env, key, RegistrationStatus::Inactive)?;
...

pub fn set_registration_status(
    store: &mut dyn Storage,
    env: &Env,
    key: (&Operator, &Service),
    status: RegistrationStatus,
) -> StdResult<()> {
    let (operator, service) = key;
    match status {
        RegistrationStatus::Active => {
            increase_operator_active_registration_count(store, operator)?;
            // if service has enabled slashing, opt-in operator to slashing
            if is_slashing_enabled(store, service, Some(env.block.time.seconds()))? {
                opt_in_to_slashing(store, env, service, operator)?;
            }
        }
        RegistrationStatus::Inactive => {
            decrease_operator_active_registration_count(store, operator)?;
        }
        _ => {}
    }
...

/// Decrease the operator active registration count by 1
pub fn decrease_operator_active_registration_count(
    store: &mut dyn Storage,
    operator: &Operator,
) -> StdResult<u64> {
    OPERATOR_ACTIVE_REGISTRATION_COUNT.update(store, operator, |count| {
        let new_count = count.unwrap_or(0).checked_sub(1);
        new_count.ok_or_else(|| {
            StdError::generic_err("Decrease operator active registration count failed")
        })
    })
}

...
let current_timestamp = env.block.time;
let unlock_timestamp = current_timestamp.plus_seconds(withdrawal_lock_period);
...
let new_queued_withdrawal_info = QueuedWithdrawalInfo {
    queued_shares: msg.amount,
    unlock_timestamp,
};

let result = shares::update_queued_withdrawal_info(
    deps.storage,
    &msg.recipient,
    new_queued_withdrawal_info,
)?;
...

...
if unlock_timestamp.seconds() > env.block.time.seconds() {
    return Err(VaultError::locked("The shares are locked").into());
}
...

...
let underlying_token_balance = UnderlyingToken::query_balance(&deps.as_ref(), &env)?;
let receipt_token_supply =
    cw20_base::contract::query_token_info(deps.as_ref())?.total_supply;
let vault = offset::VirtualOffset::new(receipt_token_supply, underlying_token_balance)?;
...

...
pub fn new(total_shares: Uint128, total_assets: Uint128) -> StdResult<Self> {
    let virtual_total_shares = total_shares.checked_add(OFFSET).map_err(StdError::from)?; //@Dedaub: OFFSET = 10^0 = 1
    let virtual_total_assets = total_assets.checked_add(OFFSET).map_err(StdError::from)?;
...

...
// bankSendRestrictionOnlyBondDenomToDistribution restricts that only the default bond denom should be allowed to send to distribution mod acc.
func bankSendRestrictionOnlyBondDenomToDistribution(ctx context.Context, fromAddr, toAddr sdk.AccAddress, amt sdk.Coins) (newToAddr sdk.AccAddress, err error) {
    if toAddr.Equals(appparams.AccDistribution) {
        denoms := amt.Denoms()
        switch len(denoms) {
        case 0:
            return toAddr, nil
        case 1:
            denom := denoms[0]
            if !strings.EqualFold(denom, appparams.DefaultBondDenom) {
                return nil, errBankRestrictionDistribution
            }
        default: // more than one length
            return nil, errBankRestrictionDistribution
        }
    }

    return toAddr, nil
}
...

...
if slashing_parameters.destination.is_some() {
...
            let exec_msg = BankMsg::Send {
                to_address: destination,
                amount: vec![Coin {
                    denom: vault_info.asset_reference,
                    amount: locked_amount,
                }],
            };
...

...
SlashingRequestStatus::Finalized => {
    // Previous slash has been finalized, eligible for new request
}
...

...
if let Some(prev_slashing_request) = prev_slashing_request {
    match SlashingRequestStatus::try_from(prev_slashing_request.status)? {
...