# claim-root-with-hotkey (/docs/tx/claim-root-with-hotkey)

Redeems the signing coldkey's owed shares on the given validator only:
that basket pays out pro-rata (subnet alpha holdings are sold to TAO at
the current pool price) and the proceeds are staked back to root on the
same validator. Other validators' accrued yield is left untouched.
Claims whose estimated payout is below the chain's claim threshold
(see `root_claim_threshold`) are silently skipped and keep accruing.
Orphaned dust holdings in the basket (subnets outside the validator's
current weight vector, worth less than the same threshold) are
consolidated into the fund's root (TAO) slot as a side effect, so the
per-holding claim fee shrinks over time; curated positions are left to
compound. The transaction fee is charged by work actually done:
holdings redeemed pay full weight, holdings merely scanned pay a small
per-row cost.
Preview per-validator payouts with `root_basket_owed_breakdown`.

| Signer    | Origin                                 | Pallet          | Wraps                                                                                                    |
| --------- | -------------------------------------- | --------------- | -------------------------------------------------------------------------------------------------------- |
| `coldkey` | signed account (pallet role may apply) | SubtensorModule | [`SubtensorModule.claim_root_with_hotkey`](/code/pallets/subtensor/src/macros/dispatches.rs#L1954-L1969) |

## Parameters [#parameters]

| Parameter     | Type   | Required | Description                                    |
| ------------- | ------ | -------- | ---------------------------------------------- |
| `hotkey_ss58` | string | yes      | Validator whose accrued basket yield to claim. |

Address parameters (`--hotkey`, `--coldkey`, `--dest`, ...) accept a raw ss58
address, an address-book or proxy-book name, or a local wallet/hotkey name.

## CLI [#cli]

Preview with `--dry-run` (shows fee, effects, and policy result without
submitting), then submit:

```bash
btcli tx claim-root-with-hotkey \
  --hotkey <ss58|name> --dry-run
btcli tx claim-root-with-hotkey \
  --hotkey <ss58|name> -w my_coldkey
```

## Python [#python]

```python
import bittensor as bt
from bittensor.wallet import Wallet

wallet = Wallet(name="my_coldkey", hotkey="my_hotkey")
intent = bt.ClaimRootWithHotkey(hotkey_ss58="5F...")

sub = bt.Subtensor()
plan = sub.plan(intent, wallet)   # fee, effects, policy — no submission
result = sub.execute(intent, wallet)
if not result.success:
    print(result.error.code, result.error.remediation)
```

(`bt.Subtensor` is also the async client — `async with bt.Subtensor() as client:`
— see [The client](/docs/concepts/client).) Or build the intent by op name, as
an agent would:

```python
result = sub.execute_tool("claim_root_with_hotkey", {...}, wallet)
```

## On-chain implementation [#on-chain-implementation]

`SubtensorModule.claim_root_with_hotkey` — [`pallets/subtensor/src/macros/dispatches.rs#L1958`](/code/pallets/subtensor/src/macros/dispatches.rs#L1954-L1969):

```rust
#[pallet::call_index(148)]
#[pallet::weight(
    <T as crate::pallet::Config>::WeightInfo::claim_root(MAX_ROOT_CLAIM_WORK)
)]
pub fn claim_root_with_hotkey(
    origin: OriginFor<T>,
    hotkey: T::AccountId,
) -> DispatchResultWithPostInfo {
    let coldkey: T::AccountId = ensure_signed(origin)?;

    let outcome = Self::do_root_claim(coldkey.clone(), vec![hotkey])?;
    Self::maybe_add_coldkey_index(&coldkey);

    let weight = Self::root_claim_actual_weight(1, &outcome);
    Ok((Some(weight), Pays::Yes).into())
}
```

Delegates to [`do_root_claim`](/code/pallets/subtensor/src/staking/claim_root.rs#L767), [`maybe_add_coldkey_index`](/code/pallets/subtensor/src/staking/claim_root.rs#L796), [`root_claim_actual_weight`](/code/pallets/subtensor/src/staking/claim_root.rs#L754).

Every file is browsable under [/code](/code) exactly as built into the runtime, or as plain text under `/code/raw/<path>` (index: [`/code/index.json`](/code/index.json)).