> ## Documentation Index
> Fetch the complete documentation index at: https://docs.soran.domains/llms.txt
> Use this file to discover all available pages before exploring further.

# Lifecycle & transfers

> Reclaim, renew, treasury routing, namespace transfers, resolver pointing, and the one-way permanence door — the rest of @sorandomains/owner.

Beyond [issuing](/owner/issuing-from-code), `@sorandomains/owner` covers the owner-authorized **lifecycle** operations — reclaim, renew, treasury, transfers, resolver pointing, permanence. Deployment-time flows (deploying a Registrar or Resolver) run through the console or the Registry contract directly. All of it is policy- and permission-checked **on chain** — the SDK is a convenience, never an authority.

## Reclaim and renew

```ts theme={null}
await owner.reclaim("acme", "alice");        // take a name back from its holder
await owner.renew("acme", "alice", 86_400);  // extend a finite term; returns the new expiry
```

* `reclaim` works only on namespaces whose immutable policy allows it — the contract answers `NotReclaimable` both when the policy never allowed it and after `makePermanent` removed the power forever.
* `renew` applies to finite-term names; on a permanent-term namespace it answers `PermanentName`.
* `setTreasury(namespace, address)` routes the custody of future reclaims to a treasury account instead of the owner wallet.

## Namespace transfers

Transferring the whole namespace is a two-step, accept-to-move flow — a typo'd recipient can never burn it:

```ts theme={null}
await owner.proposeNamespaceTransfer("acme", "G…NEWOWNER");
await owner.pendingNamespaceTransfer("acme");   // visible to both parties
await owner.cancelNamespaceTransfer("acme");    // withdraw while unaccepted
```

The recipient completes it from their side — same package, their signer:

```ts theme={null}
const newOwner = new SoranOwner({ signer: theirSigner });
await newOwner.acceptNamespaceTransfer("acme");
```

Nothing moves until acceptance; re-proposing replaces the pending offer.

## Pointing the resolver

```ts theme={null}
await owner.setResolver("acme", "C…RESOLVER"); // or null to clear
```

Holders' explicit records live on the resolver; names without one resolve through the Registrar's built-in target. Once the namespace is permanent, the resolver pointer is frozen (`ResolverFrozen`) — the pay-to path can never be silently redirected.

## The one-way door

```ts theme={null}
await owner.makePermanent("acme", { confirmIrreversible: true });
```

This is the [permanence guarantee](/concepts/ownership-guarantees) made real: reclaim locks off forever, the Registrar's code freezes, and every issued name becomes permanently its holder's. There is no path back — for you, for Soran, for anyone. The SDK requires the explicit `confirmIrreversible` flag, and the contract enforces its own preconditions: the policy must have always issued permanent terms (`FiniteTermPolicy` otherwise), and the namespace's Registrar/Resolver must carry clean deployment provenance.

Check where you stand first:

```ts theme={null}
await owner.policy("acme");       // { reclaimable, transferable, defaultTermSecs, … }
await owner.isPermanent("acme");  // has the door already closed?
await owner.nameState("acme", "alice"); // { holder, address, expiresAt, generation } | null
```

## Dormant state, handled

Stellar archives on-chain entries whose rent lapses. A dormant namespace is still owned — and the SDK treats archival honestly: write operations restore archived entries automatically (as extra owner-signed transactions), and reads report "archived" as a distinct error rather than pretending the entry doesn't exist.