diff --git a/docs/subnets/crowdloans/crowdloans-tutorial.md b/docs/subnets/crowdloans/crowdloans-tutorial.md
new file mode 100644
index 0000000000..89fe6e1e22
--- /dev/null
+++ b/docs/subnets/crowdloans/crowdloans-tutorial.md
@@ -0,0 +1,305 @@
+---
+title: "Create a Subnet with a Crowdloan"
+---
+
+# Create a Subnet with a Crowdloan
+
+This page describes creating a subnet via **crowdloan** on a locally deployed Bittensor chain. We will use the Polkadot‑JS web app to submit extrinsics.
+
+See also [Crowdloans Overview](./index.md)
+
+The following steps will take us through the lifecycle of a subnet creation crowdloan:
+
+- First, we will **create** a crowdloan for a subnet. This is a special contract that will conditionally create the subnet if enough funds are raised (this threshold is called a crowdloan's **cap**).
+- Next, we will **contribute** enough funds for the crowdloan to reach its cap.
+- Next we must **finalize** the crowdloan, which executes the action wrapped inside the crowdloan—the creation of the subnet.
+- Finally, we will verify the successful creation of the subnet by starting its emissions and observing the flow of liquidity to validator and creator hotkeys.
+
+## Prerequisites
+
+- A locally running subtensor development chain. For more information, see [run a local Bittensor blockchain instance](../../local-build/deploy.md).
+- [Polkadot‑JS browser app](https://polkadot.js.org/apps/?#/explorer) and [Polkadot‑JS browser extension](https://chrome.google.com/webstore/detail/polkadot%7Bjs%7D-extension/mopnmbcafieddcagagdcbnhejhlodfdd) installed.
+- An accessible 'Alice' wallet (see: [Provision Wallets for Local Deploy](../../local-build/provision-wallets))
+
+## Step 1: Connect Polkadot‑JS to your local chain
+
+1. Open the Polkadot‑JS app.
+2. In the network selector, choose Development → custom endpoint `ws://127.0.0.1:9944`.
+3. Confirm your local chain metadata loads and your test accounts appear in the Accounts tab. To do this, see [create and import accounts to the Polkadot-JS extension](../../keys/multisig.md#create-and-import-3-coldkey-pairs-accounts-in-the-polkadot-js-browser-extension).
+
+:::tip
+If the web app does not connect to your local chain, your browser’s privacy or security settings may be blocking it. Try adjusting those settings and reconnecting.
+:::
+
+## Step 2: Generate call hash
+
+Before creating the crowdloan, you must first generate the hash that registers the subnet and creates a dedicated proxy for the designated beneficiary.
+To begin:
+
+1. Go to **Developer** → **Extrinsics**.
+2. Under “**using the selected account**”, pick the crowdloan "`creator`" account.
+3. Under “**submit the following extrinsic**”, choose module `subtensorModule`, call `registerLeasedNetwork(emissionsShare, endBlock)`.
+4. Fill the parameters:
+
+ - `emissionsShare`: choose a percentage, e.g, 30.
+ - `endBlock`: leave as none.
+
+5. Copy the hex code shown in the **encoded call data** field. You will use this to create the crowdloan in the next step.
+
+:::info
+Do not submit the transaction after entering the parameters. Only copy the encoded call data once all parameters are provided.
+:::
+
+## Step 3: Create a crowdloan
+
+We will create a campaign whose purpose is to register a leased subnet on finalize.
+
+1. Go to **Developer** → **Extrinsics**.
+2. Under “**using the selected account**”, pick the crowdloan "`creator`" account.
+3. Under “**submit the following extrinsic**”, choose module `crowdloan`, call `create`.
+4. Fill the parameters:
+
+ - `deposit`: choose an amount (e.g., `10,000,000,000` = 10 TAO on default dev config)
+ - `min_contribution`: e.g., `100,000,000` (0.1 TAO)
+ - `cap`: e.g., `2,000,000,000,000` (2000 TAO)
+ - `end`: pick a block height in the near future (e.g., current + 5000)
+ - `call`: put the hex code of the encoded call data saved from the previous step.
+ - `target_address`: leave as **None**.
+
+ :::info
+
+ - Set the `cap` value higher than the projected subnet lock cost plus proxy deposit (and a small fee buffer). On most dev setups the baseline lock cost is 1,000 TAO (1,000,000,000,000 RAO). If `cap` equals the lock cost exactly, the lease coldkey may lack enough to pay proxy deposits and finalize can fail with insufficient balance.
+ - If your local subtensor node uses non-fast blocks, the minimum duration for a crowdloan is one week (≈ 50,400 blocks). Therefore, the `end` value must be set at least 50,400 blocks after the current block. This limitation also applies on testnet and mainnet.
+ :::
+
+5. Click **Submit Transaction** and sign with the `creator` account.
+
+### Get the crowdloan ID
+
+Crowdloan IDs are allocated sequentially, starting from `0`, with each new crowdloan assigned the next incremental ID. There is no extrinsic to list created crowdloans. Therefore, to check the identity of crowdloans created, you must use one of these methods.
+
+- **From Events**:
+
+ 1. Navigate to the **block explorer** after submitting the crowdload transaction.
+ 2. In the **Explorer** tab, find the block in which the transaction occured.
+ 3. In the **Events** panel, locate the `crowdloan.create` extrinsic. The `crowdloan.Created` event payload includes `crowdloanId` that represents the ID of the crowdloan.
+
+- **From storage**:
+
+ 1. From the **Developer** dropdown, navigate to **Chain state** → **Storage**.
+ 2. Click the **selected state query** menu and select `crowdloan.nextCrowdloanId`.
+ 3. Click the **+** icon to run the query.
+
+ :::tip
+ This query returns the ID assigned to the next crowdloan that will be created. Subtract 1 from the returned value to determine the total number of crowdloans that currently exist.
+ :::
+
+- **From the JS console**:
+ 1. From the **Developer** dropdown, navigate to **Javascript**.
+ 2. Next, paste the following code block in the editor and run:
+
+```javascript
+// List all existing crowdloan ids
+const keys = await api.query.crowdloan.crowdloans.keys();
+console.log(keys.map((k) => k.args[0].toNumber()));
+```
+
+## Step 4: Contribute to the crowdloan
+
+All contributions must occur before the defined `end` block and will be clipped to the `cap` value provided.
+
+To contribute to the crowdloan, repeat the following steps for each contributor account:
+
+1. From the **Developer** dropdown, navigate to **Extrinsics**
+2. Under “**using the selected account**”, select the crowdloan "contributor(s)" account.
+3. Under “**submit the following extrinsic**”, choose module `crowdloan`, call `contribute (crowdloan_id, amount)`.
+4. Provide the `crowdloan_id` (typically 0 on a fresh chain) and an amount.
+5. Submit and sign.
+
+:::info
+
+The crowdloan cap is the maximum total raise. If a contribution would push the total above this cap, the contribution is clipped to fit the remaining available amount. Once the cap is reached, any further contributions are rejected and a `crowdloan.CapRaised` event is triggered.
+:::
+
+### Verify crowdloan contributions
+
+To verify crowdload contributions:
+
+- **From Events**:
+
+ 1. Navigate to the **block explorer** after contributing to the crowdload.
+ 2. In the **Explorer** tab, find the block in which the transaction occured.
+ 3. In the **Events** panel, locate the `crowdloan.contribute` extrinsic. The `crowdloan.Contributed` event payload contains the `crowdloanId`, the contributing account, and amount contributed.
+
+- **From storage**:
+
+ 1. From the **Developer** dropdown, navigate to **Chain state** → **Storage**.
+ 2. Click the **selected state query** menu and select one of the following:
+
+ - `crowdloan.Crowdloans(crowdloan_id)` to check details of the crowdloan
+ - `crowdloan.Contributions(crowdloan_id, contributor)` to check contributions by an account.
+
+ 3. Click the **+** icon to run the query.
+
+## Step 5: Finalize the crowdloan
+
+The crowdload can be finalized by the creator when the end block has passed and the cap has been fully raised (`raised == cap`).
+
+1. Wait for the chain to reach the `end` block.
+2. From the **Developer** dropdown, go to **Extrinsics**.
+3. Under **using the selected account**, select the crowdloan creator account.
+4. Select `crowdloan.finalize(crowdloan_id)` and put the ID of the crowdload.
+5. Submit and sign.
+
+
+Show Event Output
+```
+system.ExtrinsicSuccess
+balances.Withdraw (x2)
+system.NewAccount (x2)
+balances.Endowed
+balances.Transfer (x2)
+subtensorModule.RegistrationAllowed
+subtensorModule.MaxAllowedUidsSet
+subtensorModule.MaxAllowedValidatorsSet
+subtensorModule.MinAllowedWeightSet
+subtensorModule.MaxWeightLimitSet
+subtensorModule.AdjustmentIntervalSet
+subtensorModule.RegistrationPerIntervalSet
+subtensorModule.AdjustmentAlphaSet
+subtensorModule.ImmunityPeriodSet
+subtensorModule.MinDifficultySet
+subtensorModule.MaxDifficultySet
+subtensorModule.NetworkAdded
+balances.Reserved
+proxy.ProxyAdded
+subtensorModule.SubnetLeaseCreated
+crowdloan.Finalized
+balances.Deposit
+transactionPayment.TransactionFeePaid
+extrinsic event
+```
+
+
+:::info
+
+- Even if the `cap` has been raised, the crowdloan cannot be finalized before the `end` block. Finalizing before the contribution period ends fails with a `ContributionPeriodNotEnded` event.
+- If `target_address` was provided, the raised amount is transferred there.
+- The stored `subtensor.register_leased_network` call executes with creator origin, and the subnet lease is created.
+- The created subnet lease includes the coldkey and hotkey of the proxy wallet that manages the subnet. See [Get the lease coldkey](#get-the-lease-coldkey).
+ :::
+
+### Verify the leased subnet
+
+Finalizing the crowdloan registers a new subnet and creates a dedicated proxy for the designated beneficiary. Use one of the following methods to verify the creation of the leased subnet:
+
+- **Using BTCLI**:
+
+ You can verify the creation of the new subnet by running the following command in your terminal:
+
+ ```sh
+ btcli subnets list --network local
+ ```
+
+ This command lists all created subnets on the chain. Notice the addition of a new subnet among the listed subnets—netuid `2` in the following output.
+
+
+Show Sample Output
+
+```console
+Using the specified network local from config
+[15:49:40] Warning: Verify your local subtensor is running on port 9944. subtensor_interface.py:89
+
+ Subnets
+ Network: local
+
+
+ ┃ ┃ Price ┃ Market Cap ┃ ┃ ┃ ┃ ┃
+Netuid ┃ Name ┃ (Τ_in/α_in) ┃ (α * Price) ┃ Emission (Τ) ┃ P (Τ_in, α_in) ┃ Stake (α_out) ┃ Supply (α) ┃ Tempo (k/n)
+━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━
+ 0 │ τ root │ 1.0000 τ/Τ │ τ 0.00 │ τ 0.0000 │ -, - │ Τ 0.00 │ 0.00 Τ /21M │ -/-
+ 2 │ β omron │ 0.0000 τ/β │ τ 0.00 │ τ 0.0000 │ τ 1.00k, 1.00k β │ 0.00 β │ 1.00k β /21M │ 3/10
+ 1 │ α apex │ 0.0000 τ/α │ τ 0.00 │ τ 0.0000 │ τ 10.00, 10.00 α │ 1.00 α │ 11.00 α /21M │ 28/100
+────────┼───────────┼─────────────┼─────────────┼──────────────┼────────────────────────┼───────────────┼──────────────┼─────────────
+ 4 │ │ τ 0.0 │ │ τ 0.0 │ τ 2.01k/20.93k (9.60%) │ │ │
+
+```
+
+
+
+## Step 6: Start the leased subnet (via proxy)
+
+Before starting the subnet, you must first get the address of the proxy wallet specified in the subnet lease, as this wallet controls the subnet.
+
+#### **Get the lease coldkey**
+
+1. From the **Developer** dropdown, navigate to **Chain state** → **Storage**.
+2. Click the **selected state query** menu and select `subtensorModule.SubnetLeases(lease_id)` to display details of the subnet lease, including the beneficiary, emission share, end block, lease coldkey and hotkey, netuid, and creation cost.
+3. Click the **+** icon to run the query.
+4. Copy the value of the `lease.coldkey` in the response. You can add the lease coldkey to the address book on the Polkadot.js web app so that it's selectable in the UI.
+
+:::tip
+
+- In your local environment, the `lease_id` would be the same as the ID of the crowdloan created. You can confirm the `lease_id` by examining the block where the subnet lease was created for a `subtensorModule.SubnetLeaseCreated` event.
+
+ :::
+
+Next, follow the following steps to start the subnet:
+
+1. Go to **Developer** → **Extrinsics**.
+2. Under “**using the selected account**”, pick the crowdloan "`creator`" account.
+3. Under “**submit the following extrinsic**”, choose module `proxy`, call `proxy(real, forceProxyType, call)`.
+4. Fill the parameters:
+
+ - `real`: enter the `lease.coldkey` gotten from the previous query.
+ - `forceProxyType`: click the toggle and then choose the `SubnetLeaseBeneficiary`option in the dropdown.
+ - `call`: choose `subtensorModule.start_call` and then enter the netuid of the subnet you want to start.
+ - Submit and sign.
+
+## Observe dividends distribution
+
+Emissions accrue in Alpha (subnet share units), but are distributed in TAO. On distribution, the contributors' alpha is unstaked/swapped to TAO using the subnet pool; if swap/unstake cannot proceed (liquidity/price), the alpha is accumulated for later.
+
+Owner emissions are periodically split among contributors and the beneficiary, but only when all of these are true:
+
+- The subnet is leased and active (lease has not ended).
+- A coinbase cycle paid an owner cut to the subnet owner for the given `netuid`.
+- Current block is an exact multiple of `LeaseDividendsDistributionInterval` (check in Constants).
+- There is sufficient liquidity to unstake the contributors’ cut from the subnet at or above the minimum swap price.
+
+Balances credited go to each contributor’s coldkey and the beneficiary’s coldkey. You can observe changes by querying balances over time.
+
+## Alternative path: Refund and dissolve
+
+If the cap is not reached by `end`:
+
+1. Anyone can call `crowdloan.refund(crowdloan_id)` repeatedly until all contributors (except the creator) are refunded (batched per call).
+2. After refunds complete (only the creator’s deposit remains), the `creator` can call `crowdloan.dissolve(crowdloan_id)` to clean up and recover the deposit.
+
+### Optional: Withdraw
+
+Before finalization:
+
+- Any contributor can `crowdloan.withdraw(crowdloan_id)` to recover their contribution.
+- The creator can only withdraw amounts above the kept deposit; the deposit itself remains until refund/dissolve.
+
+## Troubleshooting
+
+- Call fails with `InvalidCrowdloadId`
+ - Ensure that the crowdloan ID exists.
+- Call fails with `InvalidOrigin`
+ - Ensure that the selected account that is responsible for signing the transaction.
+- Call fails with `BlockDurationTooShort`
+ - Ensure that the crowdloan `end` is set at least one week away—~50,400 blocks.
+- Call fails with `BlockDurationTooLong`
+ - Ensure that the crowdloan `end` is set between a week to 2 months away.
+- Contribution call fails with `ContributionPeriodEnded`
+ - Extend the `end` value on the crowdloan using the `crowdloan.updateEnd` extrinsic.
+- Finalize fails with `CapNotRaised`
+ - Ensure total `raised` equals `cap`. Add contributions or adjust `cap` via `update_cap` (creator‑only) before `finalize`.
+- Finalize fails with `ContributionPeriodNotEnded`
+ - Wait until the `end` block is reached.
+- Finalize fails with `CallUnavailable`
+ - Ensure the nested call was supplied during `create`. The pallet stores it as a preimage; if unavailable, it errors and drops the reference.
+- Refund does nothing
+ - Refunds only after `end` and only for non‑finalized campaigns. It processes up to `RefundContributorsLimit` contributors per call.
diff --git a/docs/subnets/crowdloans/index.md b/docs/subnets/crowdloans/index.md
new file mode 100644
index 0000000000..82e071d56a
--- /dev/null
+++ b/docs/subnets/crowdloans/index.md
@@ -0,0 +1,120 @@
+---
+title: "Crowdloans"
+---
+
+### Overview
+
+The crowdloan feature lets a group of people collectively fund an extrinsic execution or a balance transfer to a specific address. For example, it can be used to fund the registration of a new Bittensor subnet and share the resulting emissions according to each person's contribution. Instead of a single sponsor paying the full lease cost up front, a creator opens a crowdloan with a funding cap and end block, contributors deposit funds until the cap is met, and—on success—the pallet finalizes the crowdloan by funding subnet registration and activating emissions for the group.
+
+At finalization, the system executes an on‑chain call—typically `subtensor::register_leased_network`—using the crowdloan's funds. This registers the subnet and creates a dedicated proxy, `SubnetLeaseBeneficiary`, for the designated beneficiary (the crowdloan creator). That proxy is authorized to operate the subnet (for example, configuring subnet parameters and other allowed controls) without having custody of contributor funds or emissions splits.
+
+If the crowdloan is finalized and a lease is created, emissions flow to contributors pro‑rata based on their contributed share. If the crowdloan is not finalized after the end block, anyone can call refunds; once all contributors are refunded, the creator can dissolve the crowdloan. The call and target address specified at creation are immutable, ensuring that the purpose of the crowdloan cannot be changed mid‑campaign. This model makes subnet bootstrapping collaborative, transparent, and permissioned through a narrowly scoped proxy for safe, ongoing operations.
+
+Design features:
+- Strong defaults: immutable target and call, capped funding, clear end block
+- Shared upside: emissions distributed proportionally to contributions
+- Safe operations: a dedicated proxy to manage the subnet within defined permissions
+
+:::info
+**Crowdloans** and **Leasing** are two different but related concepts:
+
+**Crowdloan** enables someone to fund some extrinsic execution or a balance transfer at some end date, with contributors able to participate to a cap. When finalized, this will execute the extrinsic (substrate defined logic where we can move the funds and do something else) or transfer the balance to an address (EVM smart contract address for example).
+
+**Leasing** is split profit ownership of a subnet. This is tightly coupled to Crowdloan because a lease can only be created through a Crowdloan where the crowdloan extrinsic will be the `register_leased_network`. The logic to create a lease uses the contributors from the crowdloan as the lease shareholders, and the crowdloan creator as the lease beneficiary. Parameters like the lease end block and lease emissions shares are defined when you create the crowdloan.
+:::
+
+See also [Create a Subnet with a Crowdloan](./crowdloans-tutorial.md)
+
+## Crowdloan Lifecycle
+
+- **Create** a campaign with deposit, cap, end, min contribution, optional `call` and `target_address`. [Source code](https://github.com/opentensor/subtensor/blob/main/pallets/crowdloan/src/lib.rs#L318-L326)
+
+- **Contribute** funds; amounts are clipped to remaining cap; contributors are counted. [Source code](https://github.com/opentensor/subtensor/blob/main/pallets/crowdloan/src/lib.rs#L413-L420)
+
+- **Withdraw** before finalization; creator cannot withdraw below their deposit. [Source code](https://github.com/opentensor/subtensor/blob/main/pallets/crowdloan/src/lib.rs#L505-L525)
+
+- **Finalize** after end when cap is fully raised. Optionally transfers to `target_address` and dispatches the stored `call`. [Source code](https://github.com/opentensor/subtensor/blob/main/pallets/crowdloan/src/lib.rs#L566-L581)
+
+- **Refund** loop refunds up to `RefundContributorsLimit` per call; may need multiple calls. [Source code](https://github.com/opentensor/subtensor/blob/main/pallets/crowdloan/src/lib.rs#L637-L646)
+
+- **Dissolve** after refunds; creator's deposit is returned and storage cleaned up. [Source code](https://github.com/opentensor/subtensor/blob/main/pallets/crowdloan/src/lib.rs#L711-L721)
+
+- **Update** parameters while crowdloan is running (creator only):
+ - `update_min_contribution` - adjust minimum contribution amount
+ - `update_end` - extend the end block
+ - `update_cap` - adjust the funding cap
+
+## Emissions distribution during a lease
+
+- When owner rewards are paid to a leased subnet, they are split into contributor dividends and a beneficiary cut. [Source code](https://github.com/opentensor/subtensor/blob/81ee047fd124f8837555fd79e8a3957688c5b0c6/pallets/subtensor/src/subnets/leasing.rs#L250)
+
+- Distribution is pro‑rata by recorded share; any remainder goes to the beneficiary. A lease can be created with an emissions share from 0 to 100%, which determines the share distributed to contributors. For example, if the emissions share is 50%, it means that 50% of the owner cut (18% currently) so 9% will be split proportionally to their share to contributors. [Source code](https://github.com/opentensor/subtensor/blob/main/pallets/subtensor/src/subnets/leasing.rs#L324-L339)
+
+## Operating the leased subnet via proxy
+
+- On successful registration, a `SubnetLeaseBeneficiary` proxy is added from the lease coldkey to the beneficiary. This proxy can call a narrowly scoped set of operations to operate the subnet. [Source code](https://github.com/opentensor/subtensor/blob/main/runtime/src/lib.rs#L886-L907)
+
+- Allowed calls for `ProxyType::SubnetLeaseBeneficiary` include starting subnet calls and selected admin‑utils setters (hyperparameters), not unrestricted sudo. [Source code](https://github.com/opentensor/subtensor/blob/main/runtime/src/lib.rs#L792-L852)
+
+## Runtime parameters (defaults)
+
+These constants define crowdloan requirements and operational limits in the runtime: [Source code](https://github.com/opentensor/subtensor/blob/main/runtime/src/lib.rs#L1556-L1571)
+
+Implications:
+
+- **Refund batching**: Up to 50 contributors are processed per `refund` call.
+- **Duration bounds**: Ensures campaigns are neither too short nor too long.
+- **Contribution floor**: Enforces a minimum "ticket size" for contributors.
+
+## FAQ
+
+### What problem do crowdloans solve?
+
+Crowdloans enable someone to fund some extrinsic execution or a balance transfer at some end date, with contributors able to participate to a cap. When finalized, this will execute the extrinsic (substrate defined logic where we can move the funds and do something else) or transfer the balance to an address (EVM smart contract address for example).
+
+Leasing is defined as split profit ownership of a subnet. This is tightly coupled to Crowdloan because a lease can only be created through a Crowdloan where the crowdloan extrinsic will be the "register_leased_network". The logic to create a lease will use the contributors from the crowdloan as the lease shareholders, the lease beneficiary will be crowdloan creator. Parameters like lease end block (some block in the future, probably much farther than crowdloan end) or lease emissions share are defined when you create the crowdloan and you pass the register_lease_network call with the parameters filled.
+
+### How does the end‑to‑end flow work?
+
+Creator calls `create` with deposit, cap, end, and a `call` of `subtensor::register_leased_network`. Contributors fund until the cap is hit. After the end block, creator calls `finalize`; funds transfer and the stored call executes with creator origin. A subnet and a `SubnetLeaseBeneficiary` proxy are set up; contributor shares are recorded, leftover cap is refunded.
+
+### Can the purpose of a crowdloan be changed after it starts?
+
+No. The `call` and optional `target_address` are bound at creation and used at `finalize`. The pallet exposes `CurrentCrowdloanId` only during dispatch to the called extrinsic, preventing mid‑campaign repurposing.
+
+### Who can finalize a crowdloan and when?
+
+Only the creator, after the end block, and only if `raised == cap` and it hasn’t already been finalized.
+
+### What happens if the cap is not reached?
+
+Anyone can call `refund` to batch‑refund contributors (excluding the creator) up to `RefundContributorsLimit` per call. After all refunds, only the creator can `dissolve` to recover the deposit and clean storage.
+
+### How are emissions split during a lease?
+
+Owner rewards are split to contributors by their recorded `SubnetLeaseShares`; any remainder goes to the beneficiary. The emissions are swapped for TAO and TAO is distributed to the contributors, not alpha. This runs automatically during coinbase distribution.
+
+### What permissions does the beneficiary proxy have?
+
+They can invoke a curated set of calls (e.g., start subnet calls and selected admin‑utils setters like difficulty, weights, limits).
+
+
+### Can the campaign parameters be updated mid‑flight?
+
+The creator can update `min_contribution`, `end`, and `cap` on a non‑finalized crowdloan, subject to checks (duration bounds, cap >= raised, etc.). The `call` and `target_address` are immutable.
+
+### Is there a maximum number of contributors?
+
+Yes. `MaxContributors` limits unique contributors per crowdloan; contributions beyond that will be rejected.
+
+### How are leftover funds handled at lease creation?
+
+Any leftover cap (after paying registration + proxy cost) is refunded to contributors; the residual remainder goes to the beneficiary.
+
+### How do I track my expected emissions?
+
+Your share equals your contribution divided by total raised at `finalize`. Emissions are distributed to your coldkey during the lease according to that share.
+
+### Can a lease be terminated early?
+
+No. The beneficiary may terminate only after the optional `end_block` has passed; for perpetual leases there is no end block.
diff --git a/sidebars.js b/sidebars.js
index 573a557c16..3e98cae6cc 100644
--- a/sidebars.js
+++ b/sidebars.js
@@ -142,6 +142,14 @@ const sidebars = {
items: [
"subnets/metagraph",
"subnets/create-a-subnet",
+ {
+ type: "category",
+ label: "Crowdloans",
+ collapsible: true,
+ collapsed: true,
+ link: { type: "doc", id: "subnets/crowdloans/index" },
+ items: ["subnets/crowdloans/crowdloans-tutorial"],
+ },
"subnets/subnet-creators-btcli-guide",
"subnets/subnet-hyperparameters",
"subnets/working-with-subnets",