# Kastle Wallet Documentation

### Welcome to the Kastle Documentation!

Kastle is a fast, secure, and user-friendly **Kaspa wallet** designed to help you manage your assets across both L1 and emerging L2 networks with ease. Whether you’re new to crypto or an experienced user, our browser extension and mobile wallet provide:

✅ **Comprehensive Token Support** – Manage KRC-20 and KRC-721 tokens with full functionality to deploy, mint, transfer, and showcase NFTs.\
✅ **KNS Integration** – Send and receive assets using simple, human-readable Kaspa Names instead of long addresses.\
✅ **L2 Ready** – Fully compatible with Kaspa Layer 2s for faster, more scalable transactions and future dApp ecosystems.\
✅ **Enhanced Security** – Protect your funds with Ledger integration, biometrics, and advanced encryption.\
✅ **Intuitive Setup** – Import or create your wallet in seconds with a streamlined onboarding flow.\
✅ **Instant Transactions** – Enjoy rapid $KAS transfers and smooth connectivity with decentralized applications.

This documentation contains everything you need to understand how Kastle works and how to integrate it into your dApp. Follow our step-by-step guides and code snippets to quickly set up Kastle, connect it to your application, and enable seamless interactions.


# Architecture

Kastle is built with modern tools to ensure performance, security, and extensibility:

* **wxt**: A framework for building browser extensions with TypeScript, simplifying Chrome API integration.
* **React**: A component-based UI library for creating responsive, dynamic interfaces.
* **Kaspa WASM**: WebAssembly bindings for Kaspa’s core logic, enabling fast blockchain interactions (key generation, transaction signing) client-side.
* **TypeScript**: Type-safe codebase for reduced runtime errors.
* **Vite**: Bundling and development server for rapid iteration.

## Components

1. **Background Script** (Service Worker)
   * Handles wallet initialization, key management.
   * Listens for API requests from websites and forwards them to the UI for user approval.
2. **Content Script**
   * Injects a `window.kastle` object into websites to enable dApp interactions.
   * Relays messages between websites and the background script.
3. **UI Layer** (React)
   * **Popup**: Quick access to balance, send/receive buttons, and network settings.
   * **Options Page**: Manage seed phrases, view addresses, and configure security.
   * **Approval Dialogs**: User prompts for transaction signing or dApp connections.
4. **Kaspa WASM Module**
   * Compiled Rust code for address derivation, and transaction signing.
5. **Encrypted Storage**
   * Securely stores private keys and wallet metadata using Chrome’s `chrome.storage.local` API.


# Kastle Wallet Derivation Path

## Kastle Wallet Derivation Path Documentation

### What is a Derivation Path?

A derivation path is a sequence that determines how cryptographic keys are generated from a seed phrase or hardware device. It follows a hierarchical structure that allows multiple accounts and addresses to be derived from a single seed.

### Derivation Path Format

Kastle uses the following derivation path format:

```
m/44'/111111'/<account>'/0/<index>
```

Where:

* `m` represents the master key
* `44'` is the purpose (BIP44 standard)
* `111111'` is the coin type for Kaspa
* `<account>'` is the account number
* `0` represents the external chain (receiving addresses)
* `<index>` is the address index

### Supported Wallet Types and Their Derivation Paths

Kastle supports different wallet types, each with specific derivation path handling:

#### Private Key Wallet

**Derivation Path:** None

Private key wallets don't use derivation paths since they directly use the imported private key.

#### Ledger Hardware Wallet

**Derivation Path:** `m/44'/111111'/<account>'/0/0`

When connecting your Ledger hardware wallet, Kastle uses this fixed derivation path. You can select different accounts by changing the `<account>` value.

#### Seed Phrase Wallet

**Derivation Path:** `m/44'/111111'/<account>'/0/<index>`

For seed phrase wallets, you can manage the `<account>` part directly from the Kastle interface. This allows you to create multiple separate accounts from the same seed phrase.

### Address Scanning and UTXO Discovery

In seed phrase wallets, the `<index>` part is handled implicitly by the wallet. By default, Kastle scans addresses with indexes from 0 to 49 when looking for UTXOs (Unspent Transaction Outputs).

**Important:** These addresses are only used for scanning purposes and are not displayed in the interface. This approach manages the expectations of new crypto users or those coming from PoS chains.

### Managing Accounts

You can manage different accounts in the Settings section of the Kastle wallet:

1. Open the wallet; you should land on the dashboard if your wallet is set up.
2. Click on the account name at the top left of the screen.
3. You can add an account directly by clicking "Create new account" or clicking on the wallet sub-menu icon (three dots) and selecting Manage accounts.
4. You should be able to select or deselect account you are interested in, with associated balances.

### Best Practices

* **Backup your seed phrase:** Always keep a secure backup of your seed phrase.
* **Use multiple accounts:** For better privacy, consider using different accounts for different purposes.
* **Verify addresses:** When receiving funds, always verify the address displayed by Kastle.

### Wallet Compatibility and Migration

#### Different Derivation Paths Across Wallets

Other Kaspa wallets (such as Kasware, Kaspium, and Kasvault) might implement different derivation path schemes. While the coin type (`111111'`) remains the same across all Kaspa wallets, differences may exist in:

* The number of addresses scanned for UTXOs
* The specific account structure
* The way indexes are handled and displayed
* Whether hardened derivation is used for all path components

#### Migration Between Wallets

When migrating between wallets, compatibility issues related to derivation paths may arise. To ensure a smooth migration:

1. **Check derivation path compatibility**: Before migrating, verify that both wallets use the same derivation path structure. Some wallets may provide this information in their settings or documentation.
2. **Test with small amounts**: Always test the migration process with a small amount first to ensure compatibility.
3. **Recovery options**: If the new wallet cannot detect funds due to derivation path differences, you have several options:
   * Adjust the derivation path in the new wallet if it offers this option (Available soon)
   * Import the private keys directly instead of using the seed phrase
   * Return to the original wallet and transfer funds to a new wallet

#### Consolidation Strategy

If direct migration isn't possible due to derivation path incompatibilities, follow this strategy:

1. **Consolidate funds to index 0**: In your original wallet, transfer all your funds to the address at index 0 (`m/44'/111111'/<account>'/0/0`). This address is most likely to be recognized by all wallets.
2. **Use compound transactions**: If you have many UTXOs spread across multiple addresses, create a compound transaction that combines all these UTXOs and sends them to the address at index 0. This reduces transaction fees and simplifies the migration process.
3. **Then migrate**: After consolidation, import your seed phrase into the new wallet. Since all funds are now at the most standard index position, they should be detected regardless of scanning differences


# How to Integrate

To integrate Kastle with your dApp, you can choose one of two methods:

#### 1. Integrate with Kastle Wallet API

Use the Wallet API to directly interact with Kastle services. This approach gives you more control and flexibility in how you manage wallet-related actions.

👉[ Learn more about Kastle Wallet API integration](/readme/how-to-integrate/kastle-wallet-api)

***

#### 2. Use Kastle SDK

The SDK provides an easier and more streamlined integration experience. It's ideal for teams looking for quick setup and less manual configuration.

👉 [Explore the Kastle SDK guide](/readme/how-to-integrate/kastle-sdk)


# Kastle Wallet API

Integrate your dApp with Kastle Wallet.

{% hint style="warning" %}
**Note:** This API is subject to changes. Refer to [`docs/index.js`](https://github.com/forbole/kastle/blob/main/docs/index.js) for the most up-to-date working examples.
{% endhint %}

Each API method is available in two styles:

* **Direct method**: `kastle.methodName(...)`
* **KIP-style generic request**: `kastle.request('kas:method_name', args)`

***

## 1. Detect Kastle

```js
if (window.kastle) {
  console.log("Kastle Wallet detected!");
} else {
  alert("Please install Kastle Wallet.");
}
```

***

## 2. Connect

Opens the permission popup and requests wallet access.

{% tabs %}
{% tab title="Direct method" %}

```js
const isSuccess = await kastle.connect();
console.log("Connected:", isSuccess); // true
```

{% endtab %}

{% tab title="KIP-style" %}

```js
const isSuccess = await kastle.request("kas:connect");
console.log("Connected:", isSuccess); // true
```

{% endtab %}
{% endtabs %}

***

## 3. Get Version

> **Available since:** Extension `2.48.0` · Mobile `1.19.0`

Returns the current wallet version in [SemVer](https://semver.org/) format. The build metadata suffix identifies the platform:

| Suffix       | Platform          |
| ------------ | ----------------- |
| `+extension` | Browser extension |
| `+mobile`    | Mobile app        |

{% tabs %}
{% tab title="Direct method" %}

```js
const version = await kastle.getVersion();
console.log("Version:", version);
// Browser extension: "2.47.0+extension"
// Mobile:            "1.19.0+mobile"
```

{% endtab %}

{% tab title="KIP-style" %}

```js
const version = await kastle.request("kas:get_version");
// Browser extension: "2.47.0+extension"
// Mobile:            "1.19.0+mobile"
```

{% endtab %}
{% endtabs %}

***

## 4. Get Account

{% tabs %}
{% tab title="Direct method" %}

```js
const { address, publicKey } = await kastle.getAccount();
console.log("Address:", address);
console.log("Public Key:", publicKey);
```

{% endtab %}

{% tab title="KIP-style" %}

```js
const { address, publicKey } = await kastle.request("kas:get_account");
console.log("Address:", address);
console.log("Public Key:", publicKey);
```

{% endtab %}
{% endtabs %}

***

## 5. Get Network

Returns the currently active network ID.

{% tabs %}
{% tab title="Direct method" %}

```js
const network = await kastle.getNetwork();
console.log("Network:", network); // e.g. "mainnet"
```

{% endtab %}

{% tab title="KIP-style" %}

```js
const network = await kastle.request("kas:get_network");
console.log("Network:", network);
```

{% endtab %}
{% endtabs %}

***

## 6. Switch Network

Prompts the user to switch to a different network.

{% tabs %}
{% tab title="Direct method" %}

```js
// Valid values: "mainnet" | "testnet-10" | "testnet-11"
await kastle.switchNetwork("mainnet");
```

{% endtab %}

{% tab title="KIP-style" %}

```js
await kastle.request("kas:switch_network", "mainnet");
```

{% endtab %}
{% endtabs %}

***

## 7. Get Balance

> **Available since:** Extension `2.47.0` · Mobile `1.19.0`

Returns the current account balance in sompi.

{% tabs %}
{% tab title="Direct method" %}

```js
const { balance } = await kastle.getBalance();
console.log("Balance (sompi):", balance);
```

{% endtab %}

{% tab title="KIP-style" %}

```js
const { balance } = await kastle.request("kas:get_balance");
console.log("Balance (sompi):", balance);
```

{% endtab %}
{% endtabs %}

***

## 8. Get UTXO Entries

> **Available since:** Extension `2.47.0` · Mobile `1.19.0`

Returns all UTXOs for the current account.

{% tabs %}
{% tab title="Direct method" %}

```js
const { entries } = await kastle.getUtxoEntries();
entries.forEach((entry) => {
  console.log(
    "Outpoint:",
    entry.outpoint.transactionId,
    ":",
    entry.outpoint.index,
  );
  console.log("Amount (sompi):", entry.amount);
  console.log("Is Coinbase:", entry.isCoinbase);
});
```

{% endtab %}

{% tab title="KIP-style" %}

```js
const { entries } = await kastle.request("kas:get_utxo_entries");
```

{% endtab %}
{% endtabs %}

***

## 9. Send KAS

Builds, signs, and broadcasts a KAS transfer in one call. No RPC or WASM needed.

**Parameters**

| Parameter             | Type     | Required | Description                                                                                                       |
| --------------------- | -------- | -------- | ----------------------------------------------------------------------------------------------------------------- |
| `toAddress`           | `string` | ✅        | Recipient Kaspa address                                                                                           |
| `sompi`               | `number` | ✅        | Amount in sompi (minimum 0.2 KAS = 20,000,000 sompi)                                                              |
| `options.priorityFee` | `number` | ❌        | Priority fee in sompi (default: `0`)                                                                              |
| `options.payload`     | `string` | ❌        | Transaction payload as a **hex string** (even length, `0-9 a-f` only). Returns an error if the format is invalid. |

{% tabs %}
{% tab title="Direct method" %}

```js
const txId = await kastle.sendKaspa(
  "kaspa:qr...recipient",
  100000000, // amount in sompi (1 KAS = 100,000,000 sompi)
  {
    priorityFee: 1000000, // optional, in sompi
    payload: "6b61737061", // optional hex string
  },
);
console.log("Transaction ID:", txId);
```

{% endtab %}

{% tab title="KIP-style" %}

```js
const txId = await kastle.request("kas:send_sompi", {
  toAddress: "kaspa:qr...recipient",
  sompi: 100000000,
  options: { priorityFee: 1000000, payload: "6b61737061" },
});
console.log("Transaction ID:", txId);
```

{% endtab %}
{% endtabs %}

***

## 10. Build Transaction

> **Available since:** Extension `2.47.0` · Mobile `1.19.0`

Builds one or more transactions from the current account's UTXOs. Returns serialized `txJson` ready for signing. No RPC or WASM needed.

> `amount` and `priorityFee` are **strings** (sompi) to avoid JS BigInt precision loss. May return multiple transactions when UTXO compounding is needed.

**Parameters**

| Parameter             | Type                                    | Required | Description                                                                                                       |
| --------------------- | --------------------------------------- | -------- | ----------------------------------------------------------------------------------------------------------------- |
| `outputs`             | `{ address: string; amount: string }[]` | ✅        | Recipient addresses and amounts (in sompi)                                                                        |
| `options.priorityFee` | `string`                                | ❌        | Priority fee in sompi (default: `"0"`)                                                                            |
| `options.payload`     | `string`                                | ❌        | Transaction payload as a **hex string** (even length, `0-9 a-f` only). Returns an error if the format is invalid. |
| `options.inputs`      | `IUtxoEntry[]`                          | ❌        | to use as inputs. If omitted, all UTXOs of the current account are used automatically.                            |

**`IUtxoEntry` schema**

```ts
type IUtxoEntry = {
  address?: string;                          // Kaspa address (optional)
  outpoint: {
    transactionId: string;
    index: number;
  };
  amount: string;                            // sompi as string
  scriptPublicKey: {
    version: number;
    script: string;
  };
  blockDaaScore: string;
  isCoinbase: boolean;
};
```

{% tabs %}
{% tab title="Direct method" %}

```js
// Basic — uses all account UTXOs automatically
const { networkId, transactions } = await kastle.buildTransaction(
  [{ address: "kaspa:qr...recipient", amount: "100000000" }],
  {
    priorityFee: "1000000",
    payload: "6b61737061", // optional hex string
  },
);

// With explicit inputs
const { networkId, transactions } = await kastle.buildTransaction(
  [{ address: "kaspa:qr...recipient", amount: "100000000" }],
  {
    priorityFee: "1000000",
    inputs: [
      {
        address: "kaspa:qr...sender",
        outpoint: { transactionId: "abc123...", index: 0 },
        amount: "500000000",
        scriptPublicKey: { version: 0, script: "20ab...ac" },
        blockDaaScore: "443245436",
        isCoinbase: false,
      },
    ],
  },
);

for (const tx of transactions) {
  console.log("Tx ID:", tx.id);
  console.log("Fee:", tx.feeAmount, "sompi");
  console.log("Change:", tx.changeAmount, "sompi");
  console.log("Tx JSON:", tx.txJson);
}
```

{% endtab %}

{% tab title="KIP-style" %}

```js
const { networkId, transactions } = await kastle.request(
  "kas:build_transaction",
  {
    outputs: [{ address: "kaspa:qr...recipient", amount: "100000000" }],
    priorityFee: "1000000",
    payload: "6b61737061", // optional hex string
    inputs: [ /* optional IUtxoEntry[] */ ],
  },
);
```

{% endtab %}
{% endtabs %}

***

## 11. Sign & Broadcast Transaction

Signs a transaction and broadcasts it to the network. Opens a confirmation popup.

{% tabs %}
{% tab title="Direct method" %}

```js
const txId = await kastle.signAndBroadcastTx(networkId, txJson);
console.log("Transaction ID:", txId);
```

{% endtab %}

{% tab title="KIP-style" %}

```js
const txId = await kastle.request("kas:sign_and_broadcast_tx", {
  networkId,
  txJson,
});
console.log("Transaction ID:", txId);
```

{% endtab %}
{% endtabs %}

> To build `txJson` manually using Kaspa WASM and an RPC client, see [`docs/index.js`](https://github.com/forbole/kastle/blob/main/docs/index.js).

***

## 12. Sign Transaction

Signs a transaction **without** broadcasting it. Returns the signed transaction as a JSON string. Useful for marketplace flows (e.g. `SingleAnyOneCanPay`).

{% tabs %}
{% tab title="Direct method" %}

```js
const signedTxJson = await kastle.signTx(networkId, txJson);

// Broadcast manually:
const { transactionId } = await rpc.submitTransaction(
  kaspaWasm.Transaction.deserializeFromSafeJSON(signedTxJson),
);
```

{% endtab %}

{% tab title="KIP-style" %}

```js
const signedTxJson = await kastle.request("kas:sign_tx", {
  networkId,
  txJson,
});
```

{% endtab %}
{% endtabs %}

With a custom script (e.g. for P2SH spend):

```js
const signedTxJson = await kastle.signTx(networkId, txJson, [
  { inputIndex: 0, scriptHex: "...", signType: "SingleAnyOneCanPay" },
]);
```

***

## 13. Sign Message

Signs an arbitrary message string.

{% tabs %}
{% tab title="Direct method" %}

```js
const signature = await kastle.signMessage("Hello from my dApp!");
console.log("Signature:", signature);
```

{% endtab %}

{% tab title="KIP-style" %}

```js
const signature = await kastle.request(
  "kas:sign_message",
  "Hello from my dApp!",
);
console.log("Signature:", signature);
```

{% endtab %}
{% endtabs %}

***

## 14. KRC-20: Transfer Token

KRC-20 operations use a commit-reveal pattern. Kastle handles both steps — no WASM needed.

{% tabs %}
{% tab title="Direct method" %}

```js
const result = await kastle.commitReveal(
  "mainnet",
  "kasplex",
  JSON.stringify({
    p: "krc-20",
    op: "transfer",
    tick: "MYTOKEN",
    to: "kaspa:qr...recipient",
    amt: "500",
  }),
);
console.log("Commit Tx ID:", result.commitTxId);
console.log("Reveal Tx ID:", result.revealTxId);
```

{% endtab %}

{% tab title="KIP-style" %}

```js
const result = await kastle.request("kas:commit_reveal", {
  networkId: "mainnet",
  namespace: "kasplex",
  data: JSON.stringify({
    p: "krc-20",
    op: "transfer",
    tick: "MYTOKEN",
    to: "kaspa:qr...recipient",
    amt: "500",
  }),
  options: {},
});
console.log("Commit Tx ID:", result.commitTxId);
console.log("Reveal Tx ID:", result.revealTxId);
```

{% endtab %}
{% endtabs %}

***

## 15. Compound UTXOs

> **Available since:** Extension `2.52.0` · Mobile `1.20.0`

Consolidates all UTXOs in the current account into a single UTXO by sending the full balance back to the sender's own address. Opens a confirmation popup.

Useful for reducing future transaction fees caused by having many small UTXOs.

| Parameter             | Type     | Required | Description                            |
| --------------------- | -------- | -------- | -------------------------------------- |
| `options.priorityFee` | `string` | ❌        | Priority fee in sompi (default: `"0"`) |

{% tabs %}
{% tab title="Direct method" %}

```js
const txId = await kastle.compoundUtxos({ priorityFee: "1000" });
console.log("Transaction ID:", txId);
```

{% endtab %}

{% tab title="KIP-style" %}

```js
const txId = await kastle.request("kas:compound_utxos", {
  priorityFee: "1000",
});
console.log("Transaction ID:", txId);
```

{% endtab %}
{% endtabs %}

## 16. Events

Listen to wallet state changes. Events are emitted in both KasWare-compatible and KIP-style formats simultaneously.

```js
// KasWare-compatible
kastle.on("accountsChanged", (accounts) => {
  // string[] — empty array means disconnected
  console.log("Accounts changed:", accounts);
});

kastle.on("networkChanged", (network) => {
  console.log("Network changed:", network);
});

// KIP-style
kastle.on("kas:account_changed", (address) => {
  // string | null — null means disconnected
  console.log("Account changed:", address);
});

kastle.on("kas:network_changed", (network) => {
  console.log("Network changed:", network);
});

// Remove a listener
kastle.removeListener("accountsChanged", myHandler);
```

***

## API Reference

| Direct Method                                            | KIP-style (`kastle.request`) | Returns                                             |
| -------------------------------------------------------- | ---------------------------- | --------------------------------------------------- |
| `kastle.connect()`                                       | `kas:connect`                | `boolean`                                           |
| `kastle.getVersion()`                                    | `kas:get_version`            | `string` (e.g. `2.47.0+extension`, `1.19.0+mobile`) |
| `kastle.getAccount()`                                    | `kas:get_account`            | `{ address, publicKey }`                            |
| `kastle.getNetwork()`                                    | `kas:get_network`            | `string`                                            |
| `kastle.switchNetwork(networkId)`                        | `kas:switch_network`         | `string`                                            |
| `kastle.getBalance()`                                    | `kas:get_balance`            | `{ balance: string }`                               |
| `kastle.getUtxoEntries()`                                | `kas:get_utxo_entries`       | `{ entries[] }`                                     |
| `kastle.sendKaspa(toAddress, sompi, opts?)`              | `kas:send_sompi`             | `string` (txId)                                     |
| `kastle.buildTransaction(outputs, opts?)`                | `kas:build_transaction`      | `{ networkId, transactions[] }`                     |
| `kastle.signAndBroadcastTx(networkId, txJson, scripts?)` | `kas:sign_and_broadcast_tx`  | `string` (txId)                                     |
| `kastle.signTx(networkId, txJson, scripts?)`             | `kas:sign_tx`                | `string` (signed txJson)                            |
| `kastle.signMessage(message)`                            | `kas:sign_message`           | `string` (signature)                                |
| `kastle.commitReveal(networkId, namespace, data, opts?)` | `kas:commit_reveal`          | `{ commitTxId, revealTxId }`                        |
| `kastle.compoundUtxos(opts?)`                            | `kas:compound_utxos`         | `string` (txId)                                     |

***

## Full Working Example

See the interactive demo for a complete, runnable reference:

* [**docs/index.js**](https://github.com/forbole/kastle/blob/main/docs/index.js) — Full source code for all operations above


# Kastle SDK

To integrate with your dapp with Kastle Wallet by Kastle SDK, follow the steps below. These step-by-step instructions, along with code snippets, will guide you through connecting the wallet and interact with the wallet.

### Install Kastle SDK

```bash
npm i @forbole/kastle-sdk
```

### Detect Kastle

Check whether Kastle is installed or not

```typescript
import * as sdk from "@forbole/kastle-sdk";

const isInstalled = await sdk.isWalletInstalled();
```

## Interact with Kastle

```typescript
import * as sdk from "@forbole/kastle-sdk";

await sdk.switchNetwork("testnet-10");
const connected = await sdk.connect();
const txId = await sdk.sendKaspa("<receipt-address>", sdk.kaspaWasm.kaspaToSompi("1")!);
```

### Operate commit reveal script

```typescript
import * as sdk from "@forbole/kastle-sdk";

// KRC20 transfer
const publicKey = await sdk.getPublicKey();
const protocol = "kasplex";
const action = `{"p":"krc-20","op":"transfer","tick":"kasp","amt":"100000000","to":<reciept-address>"}`;
const script = sdk.buildRevealCommitScript(publicKey, protocol, action);
const { commitTxId, revealTxId, error } = await sdk.doCommitReveal(
  script, {
    revealPriorityFee: sdk.kaspaWasm.kaspaToSompi("1")
});
```

### Sign PSKT

```typescript
import * as sdk from "@forbole/kastle-sdk";

// prepare KRC20 send
const publicKey = await sdk.getPublicKey();
const script = sdk.buildRevealCommitScript(publicKey, "<protocol>", "<action>");
const scriptUtxo = await sdk.getCommitScriptUtxo(script, commitTxId);
const preparedTx = sdk.buildTransaction([scriptUtxo], [yourOutput1]);
const signedTx = await sdk.signPskt(preparedTx, [{
  inputIndex: 0,
  script,
  signType: sdk.SignType.SingleAnyOneCanPay,
}]);
```

### Send PSKT

<pre class="language-typescript"><code class="lang-typescript">import * as sdk from "@forbole/kastle-sdk";

<strong>const pskt = "&#x3C;transaction-in-json>"
</strong>const txId = await sdk.sendTransactionWithExtraOutputs(pskt, [yourOutput1, yourOutput2], sdk.kaspaWasm.kaspaToSompi("0.1")!);
</code></pre>

{% hint style="info" %}
For more code examples check here: <https://github.com/forbole/kastle-sdk/tree/main/examples/react-playground/src>
{% endhint %}


# EVM compatible

This guide will walk you through the process of integrating Kastle with your EVM-compatible decentralized application (dApp) using RainbowKit and wagmi.

{% hint style="danger" %}
Kastle currently only supports Kaia testnet (Kairos) and basic Ethereum methods.
{% endhint %}

### Installation

First, ensure you have the required dependencies:

```bash
npm install @rainbow-me/rainbowkit wagmi viem
# or
yarn add @rainbow-me/rainbowkit wagmi viem
```

### Integration

Add the following code to your RainbowKit configuration:

```typescript
import { getDefaultConfig, Wallet } from "@rainbow-me/rainbowkit";
import { kairos } from "wagmi/chains";
import { injected, createConnector } from "wagmi";

const kastleWallet = (): Wallet => ({
  id: "kastle",
  name: "Kastle",
  iconUrl:
    "https://media.rhyzome.co/media/kastle-symbol-logo.svg",
  downloadUrls: {
    chrome:
      "https://chromewebstore.google.com/detail/kastle/oambclflhjfppdmkghokjmpppmaebego?authuser=0&hl=en",
  },
  iconBackground: "#FFFFFF",
  createConnector: createKastleConnector(),
});

function getWindowProviderNamespace(namespace: string) {
  const providerSearch = (provider: any, namespace: string): any => {
    const [property, ...path] = namespace.split(".");
    const _provider = provider[property];
    if (_provider) {
      if (path.length === 0) return _provider;
      return providerSearch(_provider, path.join("."));
    }
  };
  if (typeof window === "undefined") return;
  const provider = providerSearch(window, namespace);
  if (provider) return provider;
}

function createKastleConnector() {
  return (walletDetails: any) => {
    const injectedConfig = {
      target: () => {
        const provider = getWindowProviderNamespace("kastle.ethereum");
        if (!provider) {
          return;
        }

        return {
          id: walletDetails.rkDetails.id,
          name: walletDetails.rkDetails.name,
          provider: provider,
        };
      },
    };

    return createConnector((config) => ({
      ...injected(injectedConfig)(config),
      ...walletDetails,
    }));
  };
}

export const config = getDefaultConfig({
  appName: "RainbowKit demo",
  projectId: "YOUR_PROJECT_ID",
  chains: [kairos],
  wallets: [
    {
      groupName: "Popular wallets",
      wallets: [kastleWallet],
    },
  ],
  ssr: true,
});
```


# Bug Report

## How do I report a bug?

1. File an issue on [GitHub Issues](https://github.com/forbole/kastle/issues)
2. Include:
   * Browser version
   * Kastle version (find in Settings page)
   * Steps to reproduce
   * Console errors (if any)

### Version Check

Ensure you're running the latest version:

* Open Chrome Extensions (`chrome://extensions`)
* Enable "Developer mode" (top-right)
* Click "Update" next to Kastle


# Kastle Wallet Help Center

> **Kastle support will NEVER DM you or ask you for your secret recovery phrase! Stay safe!**

### Welcome to the Kastle Help Center 👋

Your complete guide to using [**Kastle — the secure, intuitive Kaspa Wallet**](https://kastle.cc/) designed for the Kaspa ecosystem. Whether you’re just getting started or exploring advanced features, you’ll find everything you need to make the most of your wallet right here.

Here’s what you’ll discover inside:

#### 🧭 [Overview & Getting Started](#overview-and-getting-started)

New to Kastle? Learn how to install the simplest Kaspa wallet, create or import your account, and navigate the app with confidence.

#### 💼 [Wallet Operations](#wallet-operations)

Master the essentials of your Kaspa wallet — from sending and receiving $KAS to managing tokens, connecting to dApps, and swapping assets across supported networks.

#### 🧩 [Advanced Features](/kastle-wallet-help-center/advanced-features)

Dive deeper into Kastle’s power tools — from managing KRC20 tokens and integrating with the Kaspa network to deploying and minting your own tokens. Perfect for experienced users and developers who want more control and flexibility.

#### 🔐 [Security & Privacy](#security-and-privacy)

Protect your funds with proven Kaspa wallet security best practices, including how to enable biometrics, set up Auto-Lock, and safely back up your recovery phrase.

#### 🤝 [Ask For Help](#asking-more-help)

Need assistance or want to share feedback? Learn how to reach our support team or connect with the **Kastle community** for tips, updates, and discussions.


# Get Started

How to go from zero to one and start using Kastle.

* [**What Is Kastle Wallet?**](/kastle-wallet-help-center/get-started/what-is-kastle-wallet)
  * Discover Kastle, the next-generation Kaspa Wallet designed for speed, security, and simplicity. Learn how to manage $KAS, KRC-20 tokens, KRC-721 NFTs, and KNS domains seamlessly across Kaspa L1 and L2 networks.
* [**Download & Install Kastle**](/kastle-wallet-help-center/get-started/download-and-install-kastle)
  * Follow this guide to download and install Kastle Wallet as a browser extension or on other supported platforms. Set up your wallet in minutes and start managing your Kaspa assets safely.
* [**Create a New Wallet**](/kastle-wallet-help-center/get-started/create-a-new-wallet)
  * Learn how to create your first account in Kastle, the most user-friendly Kaspa Wallet, and secure your private keys with best-practice setup steps that keep your funds protected from day one.
* [**Import or Restore a Wallet**](/kastle-wallet-help-center/get-started/import-or-restore-a-wallet)
  * Switch to Kastle, the trusted Kaspa Wallet, without losing access to your funds. This guide explains how to import an existing wallet using your recovery phrase or private key securely and easily.
* [**Navigate the Kastle Interface**](/kastle-wallet-help-center/get-started/navigate-the-kastle-interface)
  * Get familiar with the Kastle Wallet dashboard, menus, and balance view. Learn where to find your tokens, NFTs, and settings for a smoother, faster wallet experience.
* [**Connect a Ledger Hardware Wallet**](/kastle-wallet-help-center/get-started/connect-a-ledger-hardware-wallet)
  * Step-by-step instructions to connect your Ledger hardware wallet to Kastle, ensuring secure access and signing for your Kaspa assets.


# What Is Kastle Wallet

[Kastle](https://kastle.cc/) is a fast, secure, and user-friendly **Kaspa wallet** designed to help you manage your assets across both L1 and emerging L2 networks with ease.

Whether you’re new to crypto or an experienced user, our browser extension and mobile wallet provide:

✅ **Comprehensive Token Support** – Manage KRC-20 and KRC-721 tokens with full functionality to deploy, mint, transfer, and showcase NFTs.\
✅ **KNS Integration** – Send and receive assets using simple, human-readable Kaspa Names instead of long addresses.\
✅ **L2 Ready** – Fully compatible with Kaspa Layer 2s for faster, more scalable transactions and future dApp ecosystems.\
✅ **Enhanced Security** – Protect your funds with Ledger integration, biometrics, and advanced encryption.\
✅ **Intuitive Setup** – Import or create your wallet in seconds with a streamlined onboarding flow.\
✅ **Instant Transactions** – Enjoy rapid $KAS transfers and smooth connectivity with decentralized applications.

Discover the convenience of a **Kaspa wallet** that makes your digital assets management a breeze both in mobile and browser extension.


# Download & Install Kastle

[Kastle](https://kastle.cc/) is available as both a **browser extension** and **mobile app**, giving you instant access to your **Kaspa Wallet** anywhere.\
You can get started in just a few clicks:

* **Chrome Web Store** (for browser extension): [Install from Chrome](https://chromewebstore.google.com/detail/kastle/oambclflhjfppdmkghokjmpppmaebego)
* **Google Play Store** (for Android): [Download from Google Play](https://play.google.com/store/apps/details?id=cc.kastle\&pcampaignid=web_share)
* **App Store** (for iOS): [Download from Apple Store](https://apps.apple.com/hk/app/kastle-crypto-wallet/id6745494363?l=en-GB)

After installation, follow the in-app setup to **create or import your wallet** and start managing your Kaspa assets.\
Kastle works best on the latest versions of **Chrome**, **Android**, and **iOS** for a fast and secure Kaspa Wallet experience.


# Create a New Wallet

To create a new wallet, simply follow these steps:

1. Accept the Terms of Service and Privacy Policy
2. Tap **“Create a new wallet”**

<div align="center" data-full-width="true"><figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-a415600258cb03bdd21363d04ed56da20fd6653a%2FIMG_A43ABE4C59FB-1.jpeg?alt=media" alt="Screenshot of Kastle Mobile Landing Page" width="375"><figcaption></figcaption></figure></div>

3. Set up your PIN code for security

<div align="center"><figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-4117ea79522bc974e7e43624fada92ef9ad2ea79%2FIMG_8076.jpg?alt=media" alt="Screenshot of Kastle Pin Set Up Page" width="375"><figcaption></figcaption></figure></div>

4. Choose whether to enable biometric authentication or not

<div align="center"><figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-a8c1f493cd413b78a73586fe6dee6550631d631b%2FIMG_8077.jpg?alt=media" alt="Screenshot of Kastle FaceID Set Up Page" width="375"><figcaption></figcaption></figure></div>

5. And that’s it — your wallet is ready to use!

<div align="center"><figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-6d6e87a9669bd790aa9580edc76105bb5d4afa5e%2FIMG_8625.jpg?alt=media" alt="Screenshot of Kastle Wallet Created Successful Page" width="375"><figcaption></figcaption></figure></div>

### Extension (coming soon)


# Import or Restore a Wallet

To import/restore an existing wallet, simply follow these steps:

1. Accept the Terms of Service and Privacy Policy
2. Tap **“Import existing wallet"**
3. Set up your PIN code for security

<div align="center"><figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-4117ea79522bc974e7e43624fada92ef9ad2ea79%2FIMG_8076.jpg?alt=media" alt="Screenshot of Kastle Pin Set Up Page" width="375"><figcaption></figcaption></figure></div>

4. Choose whether to enable Face ID or biometric authentication

<div align="center"><figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-a8c1f493cd413b78a73586fe6dee6550631d631b%2FIMG_8077.jpg?alt=media" alt="Screenshot of Kastle FaceID Set Up Page" width="375"><figcaption></figcaption></figure></div>

5. Choose the method to import the wallet with

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-7fd789049d742293c0df58a5c91c1661f25870e7%2FIMG_74E4FFFA9D94-1.jpeg?alt=media" alt="Screenshot of Kastle Import Method Page" width="375"><figcaption></figcaption></figure>

6. Type or paste the secret recovery phrase or private key

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-295fc87fb1fef96832d2e8703466aa0359b25911%2FIMG_702183315320-1.jpeg?alt=media" alt="Screenshot of Kastle Import Recovery Phrase Page" width="375"><figcaption></figcaption></figure>

7. And that’s it — your wallet is ready to use!

<div data-full-width="false"><figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-7f71a22dd24b56f0e8efc457c316da83d9244c52%2FIMG_D09C200AD912-1.jpeg?alt=media" alt="Screenshot of Kastle Wallet Imported Successful Page" width="375"><figcaption></figcaption></figure></div>


# Navigate the Kastle Interface

This dashboard is designed to make managing your crypto assets as easy and secure as possible — all while keeping your data private and organized.

#### Top Bar

* **Wallet Selector ("My Wallet")**: Tap this to manage your wallets and wallets addresses. Inside the 'Wallets' page you can:
  * Rename your wallet category and your wallet address;
  * Switch between wallets and wallets addresses;
  * Create or import wallets.
* **Copy Button:** Use this button to instantly copy your wallet's address;
* **Settings (⚙️ icon)**: Access your wallet preferences, security options, and account settings.

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-dbecf1c6690f8adc715813c70d781b3db2edb68a%2FIMG_8082.jpg?alt=media" alt="Screenshot of Kastle Dashboard Page" width="375"><figcaption></figcaption></figure>

#### Balance Overview

* **Eye Icon (👁)**: Tap to show or hide your total wallet balance for privacy.
* **Masked Balance + % Change**: Your overall token balance is hidden by default. Next to it, you'll see the 24h percentage change in portfolio value.

#### Quick Action Buttons

* **Send**: Transfer KAS, KRC20 or ERC20 tokens to another address.
* **Receive**: Get your wallet address and QR code to receive funds.
* **Scan**: Use your camera to scan a QR code for faster sending.

#### Banner Section

* **Banner messages**: This section provides Kastle updates, messages, sponsored content from partners.

#### Navigation Tabs

* **Assets**: View and manage your KAS, KRC20, ERC20 tokens.
* **NFT**: A dedicated space for any supported NFTs in your wallet.
* **KNS**: See your registered Kaspa Name Service domains.
* **Text**: Browse or manage on-chain text inscriptions you own.

#### Token List

Each token entry shows:

* **Token Name and Logo**
* **Market Price (in your preferred currency equivalent)**
* **Masked Balance**: Your token holdings are hidden by default.
* **Approximate Value**: An estimated FIAT equivalent for your token balance.

Tap any token to view more details, including transaction history.


# Connect a Ledger Hardware Wallet

[Kastle’s browser extension](https://chromewebstore.google.com/detail/kastle/oambclflhjfppdmkghokjmpppmaebego) fully supports **Ledger hardware wallets**, allowing you to manage your **Kaspa Wallet** securely without ever exposing your private keys.

To connect your Ledger, make sure your device has the **Kaspa app installed via Ledger Live**.

***

#### Step-by-Step Guide

**Prepare Your Ledger**

* Connect your **Ledger device** to your computer.
* Make sure it’s **unlocked** and the **Kaspa app** is **open** on the device.

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-aae551c04cf6c7d05639fd59e27125e703baa83c%2FIMG_8931.HEIC?alt=media" alt="Ledger device with Kaspa app open picture" width="563"><figcaption></figcaption></figure>

**Open Kastle**

* In the **Kastle browser extension**, go to the **Account Management** page (top-left corner).
* Click the **“+”** button.
* Select **“Import with Ledger.”**

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-c6ad9661586e643ed716b83b666dc057f43092d6%2FScreenshot%202025-10-14%20at%2011.46.06%E2%80%AFAM.png?alt=media" alt="Screenshot of Kastle import wallet Page"><figcaption></figcaption></figure>

**Connect and Import**

* Click **“Connect”** in Kastle.

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-6b60ac5fb81480c63a23ea10f8f08022736dcf85%2FScreenshot%202025-10-13%20at%205.49.58%E2%80%AFPM.png?alt=media" alt="Screenshot of Kastle Connect Ledger Page"><figcaption></figcaption></figure>

* On your Ledger, confirm that the Kaspa app is open, then click **“I’ve opened the app.”**

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-0de1e30f4f38ba87c4b3760cdc8fb92f7783b61a%2FScreenshot%202025-10-14%20at%2011.39.34%E2%80%AFAM.png?alt=media" alt="Screenshot of Kastle Connected Ledger Page"><figcaption></figcaption></figure>

* Select the Ledger accounts you want to import then click **“Import Wallet.”**

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-5750fa2712ebfea70aeb7c535f944aed3106f453%2FScreenshot%202025-10-14%20at%2011.40.14%E2%80%AFAM.png?alt=media" alt="Screenshot of Kastle accounts list Page"><figcaption></figcaption></figure>

**Finish Setup**

* Once the import is complete, you’ll see a success message.
* Click **“Go Back to Extension.”**
* Your **Ledger accounts** will now show up in your wallet and are ready to use.

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-7c63b7397ee577af20ff0934ba6c65f10817b76e%2FScreenshot%202025-10-14%20at%2011.40.21%E2%80%AFAM.png?alt=media" alt="Screenshot of Kastle accounts imported page"><figcaption></figcaption></figure>

***

#### 💡 Tips

* Keep your Ledger **firmware** and the **Kaspa app** up to date for smooth operation.
* Your private keys **never leave** the Ledger device — Kastle only reads public account information to display balances and sign transactions securely.

***

Perfect — here’s the **Troubleshooting Ledger Connection Issues** section written to follow directly under your Ledger guide.\
It matches the tone and structure of the rest of your Support Center content:

***

### 🧩 Troubleshooting Ledger Connection Issues

If you’re having trouble connecting your Ledger device to Kastle, try these fixes:

#### ⚠️ 1. Device Not Detected

* Ensure your **Ledger is unlocked** and the **Kaspa app** is open.
* Use a **different USB cable or port** — some only supply power, not data.
* If prompted, allow your **browser to grant USB access** to the Ledger.

#### 🧱 2. Browser Permissions

* Kastle works best in **Google Chrome** or **Brave**.
* Close **Ledger Live** before connecting, as it can block access.
* On macOS, you may need to **reconnect** your device after granting permissions.

#### 🔄 3. Outdated Kaspa App or Firmware

* Open **Ledger Live** and update your **firmware** and **Kaspa app** to the latest version.
* Reconnect your Ledger and reopen the Kaspa app before trying again.

#### 🧹 4. Reset the Connection

If issues persist:

1. Disconnect your Ledger and close Kastle.
2. Reopen your browser.
3. Reconnect your Ledger, open the Kaspa app, and retry **“Import with Ledger.”**

***

#### Still Having Issues?

If none of the above works, reach out on our [**Telegram Support Channel**](https://t.me/kastlewallet) and include:

* Your operating system and browser version
* Ledger model (Nano S, Nano X, etc.)
* Whether the Kaspa app is open and up to date

Our team will help you troubleshoot further.


# Wallet Operations

Your guide to day-to-day use of the wallet for managing tokens, transactions, and DApps.

* [**Send & Receive Tokens**](/kastle-wallet-help-center/wallet-operations/send-and-receive-tokens)
  * Learn how to send cryptocurrency (Kaspa or KRC20 tokens) to others and receive funds in your Kastle wallet, with tips to ensure transactions are fast and secure.
* [**Manage Your Token Portfolio**](/kastle-wallet-help-center/wallet-operations/manage-your-token-portfolio)
  * How to view your token balances and track your transactions and history all within Kastle.
* [**Manage KRC20 Tokens**](/kastle-wallet-help-center/wallet-operations/manage-krc20-tokens)
  * Understand what KRC20 tokens are and how Kastle helps you manage them. This article explains viewing KRC20 token details, managing token settings, and the similarities to ERC20 tokens on other blockchains for context.


# Send & Receive Tokens

### **Send tokens**

1. After you tap on the "Send" button in the dashboard you will be redirected to the first step where to select the asset you want to send

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-4f2225d41b73a2f81576190cd9cb06501557beac%2FIMG_EB4F44AD77AC-1.jpeg?alt=media" alt="Screenshot of Kastle select token Page" width="375"><figcaption></figcaption></figure>

2. After you tap on the "Send" button in the dashboard you will be redirected to the first step where to input the receiver's address

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-9fbdfb4e5b016e076e313e7231dfc038f676ee75%2FIMG_ED663CC70433-1.jpeg?alt=media" alt="Screenshot of Kastle select receiver Page" width="375"><figcaption></figcaption></figure>

2. After adding the receiver's address, tap on "**Next**"

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-e2b370be14251805731f62ea6ecf4c356797a0e8%2FIMG_AD1739385D32-1.jpeg?alt=media" alt="Screenshot of Kastle receiver address Page" width="375"><figcaption></figcaption></figure>

3. Now select the amount you want to send by using the app's keyboard and then tap on "Next"

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-d03426a182116cc66ab4810e0622dd1c81ac3d96%2FIMG_F2AEB63B93AD-1.jpeg?alt=media" alt="Screenshot of Kastle set amount Page" width="375"><figcaption></figcaption></figure>

4. Confirm the transaction by swiping

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-f75ea46e833deb329add2376ac1dbff2b9633b5d%2FIMG_8629.jpg?alt=media" alt="Screenshot of Kastle send confirmation Page" width="375"><figcaption></figcaption></figure>

5. After the confirmation you should see the "Success" screen if everything went through correctly

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-7f71a22dd24b56f0e8efc457c316da83d9244c52%2FIMG_D09C200AD912-1.jpeg?alt=media" alt="Screenshot of Kastle send success Page" width="375"><figcaption></figcaption></figure>

### **Receive Tokens**

1. To receive tokens just:
   1. Tap on the "Receive" button and select the network you want to copy the address for between Kaspa L1, Kasplex L2 and Igra L2

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-7a843dd6eb6ac5d36b952430b4a1f58dd5668686%2FIMG_8633.jpg?alt=media" alt="Screenshot of Kastle select receiving wallet Page" width="375"><figcaption></figcaption></figure>

2. Tap on "Copy" or "Share" and deliver the address to the sender.

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-70829f40d48dd90fbf93f1134680659576e32802%2FIMG_8635.jpg?alt=media" alt="Screenshot of Kastle receiving wallet QR Page" width="375"><figcaption></figcaption></figure>


# Manage Your Token Portfolio

1. Each asset in your portfolio can be managed by the related category you can access from the dashboard.
2. **There are 4 navigation tabs you can explore:**
   * **Assets**: View and manage your KAS and KRC20 tokens.
   * **NFT**: A dedicated space for any supported NFTs in your wallet.
   * **KNS**: See your registered Kaspa Name Service domains.
   * **Text**: Browse or manage on-chain text inscriptions you own.

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-45c87e80c714f73be08c9d1c34923d87881ae04c%2Fimage.png?alt=media" alt="Screenshot of Kastle Dashboard Page" width="375"><figcaption></figcaption></figure>

### Assets

In the assets category, each token entry shows:

* **Token Name and Logo**
* **Market Price (in your preferred currency equivalent)**
* **Masked Balance**: Your token holdings are hidden by default.
* **Approximate Value**: An estimated FIAT equivalent for your token balance.

Tap any token to view more details, including transaction history.

#### Token Details

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-7b4968acc9aa6b8edfdd0728389c09b4649d20fb%2FIMG_F83E285C4EAB-1.jpeg?alt=media" alt="Screenshot of Kastle token details Page" width="375"><figcaption></figcaption></figure>

#### 🔎 Understanding Token Info

When you tap on a token in your portfolio (like “NACHO”), you can access its **Token Info** tab — a detailed breakdown of that token's metadata, supply, and others. Here's what each field means:

* **Mode**\
  Indicates the token's type. For example, `Mint` means the token was created with a minting mechanism, where new tokens can be issued up to a defined max supply.
* **Max Supply**\
  The total number of tokens that can ever exist. In this example, 287 billion NACHO tokens were defined as the maximum possible supply.
* **Total Minted**\
  Shows how many tokens have already been minted versus the max supply. If it displays 100%, it means the total supply has been fully minted.
* **Holder Count**\
  The number of unique addresses that currently hold this token. This helps you gauge how widely the token is distributed.
* **Mint Count**\
  How many times the minting action has been performed across the token’s lifetime.
* **Transfer Count**\
  The total number of times the token has been transferred between wallets.
* **Preallocation Amount**\
  The number of tokens reserved at creation but not distributed through minting. A value of 0 means no tokens were preallocated.
* **Default Mint Amount**\
  The standard quantity minted per mint action unless otherwise specified. In this case, every mint action typically produced 28.7 tokens.
* **Decimal**\
  Defines the number of decimal places the token can be divided into. For example, 8 decimals means the token can be split into 0.00000001 units — just like Bitcoin.

At the bottom, you'll also find a **Send \[TOKEN]** button that lets you transfer the token directly from this view.

#### History

**$KAS**

Here on the history page you can access to the Kaspa block explorer to check your transaction. Tapping on the "See your activity" button will automatically redirect to the explorer page showing your wallet's activities.

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-6ed17e183d71a144d8e78973ca3ae199258f558f%2FIMG_5278E7FC3E62-1.jpeg?alt=media" alt="Screenshot of Kastle token history Page" width="375"><figcaption></figcaption></figure>

**KRC20**

Here on the history page you can see all the recent activities for a specific KRC20. Nacho in the example below.

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-38d4544fa6643d06bfa8ffc6ae15b441d27483f2%2FIMG_2E3A149D78DB-1.jpeg?alt=media" alt="Screenshot of Kastle KRC20 History Page" width="375"><figcaption></figcaption></figure>


# Manage KRC20 Tokens

### What are KRC20?

**KRC-20** is the **token standard used on the Kaspa network**, introduced through the **Kasplex Protocol**.

It defines the rules and structure for creating **fungible tokens** — digital assets that are interchangeable, like traditional crypto (e.g., $KAS or $ETH).

With KRC-20, developers can build and deploy their own tokens directly on Kaspa’s Layer 1, using Kasplex’s efficient and scalable data insertion protocol. These tokens can represent anything from community coins and utility tokens to governance assets within decentralized applications.

[Kastle](https://kastle.cc/) fully supports **KRC-20 tokens**, allowing users to view, send, receive within the wallet.

### Access KRC20

You can access your KRC20 tokens from the wallet dashboard by scrolling the 'Assets' category to view those you hold.

<div align="center"><figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-6875b58c33ceada1d6444df7d2a90e4b42f87649%2FIMG_8888.jpg?alt=media" alt="Screenshot of Kastle Assets Page" width="375"><figcaption></figcaption></figure></div>

### Explore KRC20 Details

The **Token info** section in each KRC20 page lets you view detailed information about any of them.

This page provides transparent, real-time data about token activity, supply, and distribution so you can verify details before sending, receiving, or interacting with the token.

***

#### **Token Information Overview**

Each KRC-20 token page includes:

* **Network** – Indicates the blockchain the token runs on (e.g., *Kaspa*).
* **Mode** – Defines how the token was created, such as *Mint* or *Deploy*.
* **Max Supply** – The total number of tokens that can ever exist.
* **Total Minted** – Shows how much of the total supply has already been created.
* **Holder Count** – The number of unique wallet addresses currently holding the token.
* **Mint Count** – The total number of mint transactions that have occurred.
* **Transfer Count** – The total number of token transfers on the network.
* **Preallocation Amount** – Tokens reserved or pre-distributed during the initial creation.
* **Default Mint Amount** – The standard quantity of tokens minted in each transaction.

You’ll also see the token’s name, symbol, icon, and real-time value in the **Assets** section.

***

**Actions Available**

At the bottom of the page, you can quickly **send the token** using the *Send \[Token Name]* button — for example, *Send NACHO* — to transfer it to another Kaspa address.

<div align="center"><figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-f348aa29ab112f9510fc96abc907ece12462e404%2FIMG_8889.jpg?alt=media" alt="Screenshot of Kastle KRC20 token details Page" width="375"><figcaption></figcaption></figure></div>


# Advanced Features

Deep dive into Kastle’s capabilities and how to make the most of them.

* [**How to Deploy and Mint KRC20 Token**](/kastle-wallet-help-center/advanced-features/how-to-deploy-and-mint-krc-20-token)
  * A more detailed look at creating your own tokens. Explains the process of deploying a new KRC20 token via Kastle, including setting token parameters and minting tokens.
* [**Kaspa Network Integration**](/kastle-wallet-help-center/advanced-features/kaspa-networks-integration)
  * Understand the differences between Kaspa L1, Kasplex, and Igra L2s — and how to switch between mainnet and testnets directly within Kastle.


# How to Deploy and Mint KRC-20 Token

With **Kastle Browser Extension**, you can easily **deploy** (create) your own KRC-20 token and later **mint** additional tokens as needed. This guide walks you through both processes from start to finish.

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-99f1331d008e3d40c739f736b9531ccc2c30d845%2FScreenshot%202025-10-13%20at%204.40.02%E2%80%AFPM.png?alt=media" alt="Screenshot of Kastle extension dashboard Page"><figcaption></figcaption></figure>

### Deploy

1. After clicking **“Deploy”**, the KRC-20 deployment interface will open. Here you’ll fill in the required fields to define your token’s key parameters.

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-269579bdfb62d10da031ba1c5a830a532cc0ab0e%2FScreenshot%202025-10-13%20at%204.50.35%E2%80%AFPM.png?alt=media" alt="Screenshot of Kastle deploy krc20 Page" width="349"><figcaption></figcaption></figure>

#### Fields Overview

| Field                   | Description                                                                                         |
| ----------------------- | --------------------------------------------------------------------------------------------------- |
| **Ticker**              | A short, unique abbreviation for your token — e.g. **BTC** for Bitcoin or **KAS** for Kaspa.        |
| **Maximum Supply**      | The total number of tokens that will ever exist. This value cannot be changed after deployment.     |
| **Default Mint Amount** | The number of tokens created each time you mint.                                                    |
| **Preallocation**       | The amount of tokens automatically created and assigned to your wallet (the deployer) at launch.    |
| **Decimal**             | Defines how divisible your token is (e.g. 8 decimals means one token can be split into 0.00000001). |

2. Once all fields are filled, review your details carefully, then **confirm** the transaction to deploy your token on the Kaspa network.

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-463d0bab2cab26165e500472f813c0dc2a29b6b8%2FScreenshot%202025-10-13%20at%205.01.36%E2%80%AFPM.png?alt=media" alt="Screenshot of Kastle extension deploy confirmation Page" width="346"><figcaption></figcaption></figure>

3. If deployment succeeds, you’ll see a **confirmation screen** and your new token will appear in the **Assets** section of your wallet.

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-7d57fe2a9dd0022d8e48d5b8222cff5313d65b56%2FScreenshot%202025-10-13%20at%205.01.47%E2%80%AFPM.png?alt=media" alt="Screenshot of Kastle extension deploy success Page" width="349"><figcaption></figcaption></figure>

### Mint

You can mint **any KRC-20 token** that has been deployed on the Kaspa network, as long as it hasn’t yet reached its **maximum supply**. You don’t need to be the original deployer to mint — only the token’s configuration determines if additional minting is allowed.

To mint new tokens:

1. Open the **Mint** feature in your wallet.
2. Enter the **token ticker** you want to mint.
3. Select the **number of times** you wish to mint, based on the token’s predefined *default mint amount* and remaining supply.
4. Click **“Mint Token.”**

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-28723c8a24cda407af91f56633144b936cce86ae%2FScreenshot%202025-10-13%20at%205.02.03%E2%80%AFPM.png?alt=media" alt="Screenshot of Kastle extension mint Page" width="347"><figcaption></figcaption></figure>

Once the transaction is confirmed, wait for the process to complete. If the mint succeeds, a **confirmation screen** will appear, and the newly minted tokens will show up in your **Assets** section.

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-116bfafe84c9ad50792510a1466f0decd8289af8%2FScreenshot%202025-10-13%20at%205.20.42%E2%80%AFPM.png?alt=media" alt="Screenshot of Kastle extension mint success Page" width="350"><figcaption></figcaption></figure>


# Kaspa Networks Integration

### 🌐 Kaspa Network Integration

#### Overview

[Kastle](https://kastle.cc/) supports multiple networks within the **Kaspa ecosystem**, including both **Layer 1** and **Layer 2**.

This allows users to interact with a variety of assets — from native $KAS, KRC tokens to EVM-based assets (ERC20, ERC721) — all within one wallet.

This section provides an overview of the networks currently supported in Kastle and explains how to switch between mainnet and testnet environments.

***

#### 🧱 Kaspa Layer 1

The **Kaspa Layer 1 (L1)** network is the core blockchain that powers all native transactions and on-chain data.

* **Mainnet:** The live network where $KAS, **KRC-20**, **KRC-721**, and **KNS** assets exist.
* **TN10 Testnet:** A public test network where users and developers can experiment with Kaspa transactions, token minting, and name services without using real $KAS.

> KRC-based assets are built on Kasplex’s **data insertion protocol** and indexed by third-party APIs that Kastle monitors for display.

***

#### ⚙️ Kasplex Layer 2 (EVM-Based)

**Kasplex L2** extends the Kaspa ecosystem with **EVM compatibility**, supporting assets and dApps built using Ethereum standards.\
Kastle currently supports:

* **Kasplex L2 Mainnet** – For real EVM-based tokens and smart contract interactions (ERC-20, ERC-721).
* **Kasplex L2 Testnet** – For developers to test EVM-based integrations before deploying to mainnet.

This means you can interact with familiar **EVM-style dApps and tokens** directly from your Kastle wallet while benefiting from Kaspa’s high-speed, PoW-secured foundation.

***

#### 🔧 Igra Layer 2 (EVM-Based)

**Igra** is an experimental **Layer-2 protocol** being developed on top of Kaspa. Its objective is to combine **Bitcoin-grade Proof-of-Work security** with the **programmability of modern virtual machines**.

The project explores how Kaspa’s BlockDAG architecture can be used to support **EVM-based smart contracts** with **high throughput** and **low latency**, while maintaining strong decentralization and MEV resistance.

Kastle currently supports the **Igra Testnet**, **Caravel**, allowing developers to experiment with its early implementation and test EVM-compatible transactions before mainnet release.

***

#### 🔁 Switching Between Networks

Switching between supported networks in Kastle is simple:

1. Open your **Kastle wallet**.
2. Tap on the ⚙️ icon.
3. Tap or click the **Network** selector.
4. Choose your desired network (mainnet or testnet).

<div align="center"><figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-98bcfffb071bc5699754516bf1cf1e362db236bd%2FScreenshot%202025-10-13%20at%2016.21.40.png?alt=media" alt="Screenshot of Kastle switch network setting Page" width="375"><figcaption></figcaption></figure></div>

**Kastle automatically handles all the different mainnet and testnet**, you won't need to deal with switching between L1 and L2 and so on.

If you connect to a dApp that operates on a different network, Kastle will automatically prompt you to switch.

***

#### 🧠 Tip

When using any **testnet**, remember that tokens there have **no real value** — they’re for experimentation and development purposes only.

***

#### ✅ Summary of Supported Networks

| Layer  | Network     | Supported Environments | Supported Assets           |
| ------ | ----------- | ---------------------- | -------------------------- |
| **L1** | **Kaspa**   | Mainnet + TN10 Testnet | $KAS, KRC-20, KRC-721, KNS |
| **L2** | **Kasplex** | Mainnet + Testnet      | ERC-20, ERC-721            |
| **L2** | **Igra**    | Testnet                | ERC-20, ERC-721            |

***

As the Kaspa ecosystem continues to evolve, Kastle will expand support for additional networks and Layer-2 integrations, ensuring a seamless experience across all Kaspa environments.


# Security

Keep your assets safe and learn how to recover your wallet if needed.

* [**Security Essentials**](/kastle-wallet-help-center/security/security-essentials)
  * Essential tips for protecting your wallet. Learn about safeguarding your Secret Recovery Phrase, keeping your private keys secure, and avoiding common scams or phishing attempts to ensure your funds stay safe.
* [**Backup Your Secrets**](/kastle-wallet-help-center/security/backup-your-secrets)
  * Steps to back up your Kastle wallet and recovery phrase, and detailed instructions to restore your wallet on a new device or app installation. This ensures you can regain access to your funds if you ever lose your phone or computer.
* [**MFA Settings & Autolock**](/kastle-wallet-help-center/security/mfa-settings-and-autolock)
  * Learn how to enable biometrics (fingerprint or Face ID) and auto-lock to keep your wallet secure and ensure only you can access or approve transactions.


# Security Essentials

[Kastle](https://kastle.cc/) gives you **full control over your Kaspa assets** — and with that comes full responsibility.\
Follow these best practices to keep your **Kaspa Wallet** and funds safe from loss or compromise.

***

### TL;DR – Quick Security Checklist

1. **Recovery/Seed phrase = everything** → Write it offline, never share, never store online.
2. **Set a strong PIN + enable biometrics** for double protection.
3. **Turn on Auto-Lock** so your wallet locks itself when idle.
4. **Back up your recovery phrase immediately** after creating your wallet.
5. **Always update** Kastle, your browser, and your phone OS.
6. **Connect only to official dApps** (via verified X/website) and read what you sign.
7. **Use safe networks/devices** → avoid public Wi-Fi and untrusted extensions.
8. **Separate funds** → small balance for daily use, hardware/cold storage for savings.

***

### Know What Matters Most

* Your **seed phrase (recovery phrase)** is the ultimate key to your wallet.
* Anyone with it can take your funds — keep it **safe, offline, and private**.

***

### Back Up Your Recovery Phrase Immediately

After creating a new wallet, **back it up right away** following the steps in our guide [here](/kastle-wallet-help-center/security/backup-your-secrets).\
Write it down or store it securely offline — never take a screenshot or save it to the cloud.

***

### Protect Access with PIN, Biometrics & Auto-Lock

* Set a **strong PIN** and never share it.
* Enable **biometric authentication** (fingerprint or face ID) for extra protection.
* Keep **Auto-Lock** on to automatically lock the wallet after inactivity.

These features prevent unauthorized access if your device is lost or left unattended.

***

### Be Careful When Connecting to dApps

* Use only **official project links** — ideally through verified X profiles or websites.
* Double-check URLs to avoid clones or phishing sites.
* When signing contracts on L2s, **always review what you’re approving** before confirming.

***

### Keep Software Updated

* Always use the latest version of Kastle. Updates often include important security fixes.
* Keep your phone, browser, and OS updated too.

***

### Avoid Risky Networks & Devices

* Avoid managing funds on **public Wi-Fi**. If necessary, use a trusted VPN.
* Only install Kastle from official sources: **Chrome Web Store**, **App Store**, or **Google Play**.
* Do not use **rooted or jailbroken** devices for storing crypto.

***

### Separate Daily & Long-Term Funds

* Use a **small balance** in Kastle for regular transactions and dApps.
* Keep larger holdings in a **hardware wallet or cold storage** for maximum safety.

***

### Watch Out for Phishing & Scams

* Kastle support will **never** ask for your seed phrase or PIN.
* Ignore DMs, pop-ups, or emails claiming to be official.
* Always verify links before connecting your wallet.

***

### If You Suspect Compromise

* Move your funds immediately to a **new wallet**.
* Reset your **PIN and biometrics**.
* Revoke **suspicious dApp approvals** through Kastle or a trusted explorer.

***

### Important Final Reminder

Kastle is a **non-custodial Kaspa Wallet**.\
This means **we cannot recover your wallet, seed phrase, or lost funds** if you lose access.\
Always back up your recovery phrase and follow these best practices — **your security is in your hands.**


# Backup Your Secrets

### Back Up Your Recovery Phrase (or private key) Immediately

After creating a new wallet, back it up right away:

1. If it's your first time opening the wallet, just click on the "**Back up now**" button of the banner

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-c385977c5499d492653574d470b972d6101d544a%2FScreenshot%202025-10-14%20at%2014.45.48.png?alt=media" alt="Screenshot of Kastle dashboard backup secret banner Page" width="375"><figcaption></figcaption></figure>

1. Open **Account Management** from the **top left of the dashboard**.

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-7625e0cd80fc807e1f155616551b94b4d9bcb278%2FIMG_8636.jpg?alt=media" alt="Screenshot of Kastle dashboard Page" width="375"><figcaption></figcaption></figure>

2. Tap the **three dots** button on the right.
3. Select **“Backup recovery phrase.”/"Backup Private Key"**

<div data-full-width="false"><figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-e3c020d0bcc4a4339bf015b541dec410b1bd130d%2FIMG_8E8D23C471CF-1.jpeg?alt=media" alt="Screenshot of Kastle account management Page" width="375"><figcaption></figcaption></figure></div>

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-6e37d5a4f00e4a75018e7d01e0381932ed3f4d4a%2FIMG_8637.jpg?alt=media" alt="Screenshot of Kastle account management Page" width="375"><figcaption></figcaption></figure>

4. Copy or write down your recovery phrase.

⚠️ For your security:

* The phrase will **only stay in your clipboard for 60 seconds**.
* You **won't be able to screenshot** the recovery phrase.
* The recovery phrase display window is **hidden by default** — you’ll need to tap to reveal it.

**👉 Store the phrase offline on paper or metal, never online.**


# MFA Settings & Autolock

Kastle includes built-in security features to help keep your funds safe at all times. These settings include:

* **Auto-Lock** – Automatically locks your wallet after a short period of inactivity.\
  👉 For maximum protection, we recommend setting Auto-Lock to **no more than 1 minute**.
* **Biometric Authentication** – Use your fingerprint or face ID for quick and secure access.
* **Fallback PIN Code** – A backup method to unlock your wallet if biometrics are unavailable.

You can manage all these options from the **⚙️ gear icon in the top-right corner** of the dashboard.

<figure><img src="https://964770553-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FyO6DQPyrOXH1GlIXlmhm%2Fuploads%2Fgit-blob-2349953326ce5af563981c6b1796a4a5e5c628c6%2FIMG_B58B277C5E5F-1.jpeg?alt=media" alt="Screenshot of Kastle settings Page" width="375"><figcaption></figcaption></figure>

***

⚠️ **Security Tip**\
Do not rely on the **PIN code alone**. The PIN is only a fallback — enabling **both Auto-Lock and Biometrics** gives you the strongest protection against unauthorized access.


# Troubleshooting

Solutions to common issues and answers to frequently asked questions.

* [**Tokens Not Showing Up**](/kastle-wallet-help-center/troubleshooting/tokens-not-showing-up)
  * Learn what to do if your tokens, NFTs, or KNS domains don’t appear in Kastle.\
    This guide explains how Kastle fetches data from third-party APIs for both Kaspa L1 and L2 networks, how to check service status, and what steps to take if your assets aren’t showing.
* [**Cannot Connect to a DApp**](/kastle-wallet-help-center/troubleshooting/cannot-connect-to-a-dapp)
  * Learn how to fix common connection issues caused by network mismatches or unsupported networks, and find out how to report problems with dApps that should be compatible with Kastle.


# Tokens Not Showing Up

### ⚠️ Quick Note

If your tokens or NFTs aren’t appearing in **Kastle**, don’t worry — your assets are safe.\
Kastle displays token data through **third-party APIs**, and temporary outages or sync delays can affect visibility.

👉 Always start by checking our [**Status Page**](https://status.kastle.cc/) or contact us on [**Telegram**](https://t.me/kastlewallet) if the issue persists.

### **Kaspa Layer 1 (KRC-20, KRC-721, and KNS)**

Your **KRC-20 tokens**, **KRC-721 NFTs**, and **KNS domains** are automatically fetched from third-party APIs connected to the Kaspa network.

* Kastle **does not manage these APIs** directly but continuously **monitors their uptime and performance**.
* You can view real-time service status on the [**Kastle Status Page**](https://status.kastle.cc/).
* If one or more APIs experience downtime, tokens may **temporarily disappear** from your wallet interface.
* Once the service is restored, the tokens will reappear automatically.

If the status page shows everything operational but your tokens are still missing, reach out on our [**Telegram Support Channel**](https://t.me/kastlewallet) and our team will assist.

***

### **Kaspa Layer 2 (L2s)**

For **Layer-2 networks** such as **Kasplex** or **Igra**, token data is also provided by each network’s APIs.

* You can check their availability on our [**Status Page**](https://status.kastle.cc/).
* If a token isn’t visible, try manually adding it via integrated dApps like **Zealous DEX** — search for the token and select **“Add Token.”**

***

**✅ Before Reaching Out**

* Check the [**Status Page**](https://status.kastle.cc/) for any reported outages.
* Wait a few minutes to allow services to refresh.
* If everything looks normal and tokens still don’t appear, contact us on [**Telegram**](https://t.me/kastlewallet) for support.

***

🪙 **Note:** Your funds are always safe on the blockchain — display issues in Kastle Wallet never affect your actual token balances or ownership.


# Cannot Connect to a DApp

If you’re having trouble connecting [Kastle](https://kastle.cc/) to a decentralized application (dApp), here are a few things to check before reaching out:

***

### **Network Mismatch**

If the dApp is on a different network than the one currently selected in your wallet, Kastle will automatically prompt you to **switch networks** (in the extension).

* Approve the pop-up to switch to the correct network.
* If you don’t see the prompt, refresh the dApp page and try connecting again.

***

### Unsupported Network

Some dApps may run on networks not yet supported by Kastle.

* In this case, please let us know via our [**Telegram Feedback Channel**](https://t.me/kastlewallet) so we can review and consider adding support for that specific network in a future update.

***

### Known-Compatible dApp Fails to Connect

If you’re trying to connect to a **dApp that already supports Kastle** (or is officially listed as compatible with Kastle Mobile) but still encounter errors:

1. Take note of the steps that lead to the connection issue.
2. Contact us through our [**Telegram Feedback Channel**](https://t.me/kastlewallet) and share those details.

Our team will review your case and guide you through the troubleshooting process.

***

🪙 **Tip:** Make sure your Kaspa wallet is unlocked and you’re using the latest version of Kastle before attempting to connect again.


# Common Error Messages


# Ask For Help

Need help or want to connect? We're here for you.

### **Contact Kastle Support**

If you run into issues or have technical questions, the fastest way to get help is through our community channels or GitHub. Our team and community members are active and ready to assist.

* **Telegram Support Group**: [t.me/kastlewallet](https://t.me/kastlewallet/10) — Join our public chat to ask questions, report bugs, or get guidance from other Kastlers and the team.
* **GitHub Issues**: [github.com/forbole/kastle/issues](https://github.com/forbole/kastle/issues) — For bug reports and feature requests, please open a GitHub issue so our dev team can track and address it.
* **X (formerly Twitter)**: [@KastleWallet](https://x.com/KastleWallet) — Follow us for announcements, tips, and support DMs.
* **Email us**: Reach out to our team through [email](mailto:support@kastle.cc) or in-app chat. We explain what info to include so we can help you faster.

We currently do not offer email or ticket-based support, but the channels above are monitored and responsive.

**How to Get Faster Help**\
When asking for help, please include:

* Your device and OS (e.g. iPhone 14, iOS 17.5)
* Kastle version number (e.g. 1.0.5 from App Store)
* Screenshots or error messages (if any)
* A brief description of what you were doing before the issue occurred

**Feedback and Suggestions**\
We value your ideas! To suggest features or improvements, feel free to message us on Telegram or open a GitHub discussion. We regularly review community input to help shape future updates.


# FAQs

Below you’ll find answers to the most common questions about Kastle across mobile and browser extension. If you need support, reach out through our official channels on X, Telegram, or Discord.

## 🧭 [**General**](#general)

***

### **Why does my Kastle wallet show a 0 balance even though the explorer shows my funds?**

This is usually caused by temporary RPC congestion.\
Your funds are safe — if the Kaspa explorer shows the transaction as “received”, the wallet will sync once the RPC reconnects properly.

***

### **Why do transactions feel slow sometimes?**

Transaction speed depends on network load and RPC responsiveness.\
Kastle broadcasts your transaction immediately, but confirmation time varies with network conditions.

***

### **Does Kastle have a public roadmap?**

Yes. Major updates are shared in our docs, release notes, and on X. We typically release updates every two weeks.

***

### **Will Kastle support multiple languages (e.g., Chinese)?**

Yes — full localization support (including Chinese) is planned and on the roadmap.

***

## 🔐 [**Wallet Setup & Security**](#wallet-setup-and-security)

***

### **Why can’t I create a 24-word seed phrase in Kastle?**

Kastle currently supports **12-word recovery phrases** only.\
Support for additional mnemonic formats may be added later.

***

### **Can I export private keys from a wallet created from a seed phrase?**

Not yet.\
Kastle only allows exporting private keys for wallets imported **via private key**.\
For seed-based wallets, private key export is disabled for security reasons.

***

### **Is Kastle open source?**

* **Browser extension:** Yes, available on GitHub.
* **Mobile app:** Will be progressively open-sourced as internal components mature.

***

## 🧩 [**Addresses & Migration**](#addresses-and-migration)

***

### **How can I check if I am using a Legacy EVM address and migrate safely?**

Go to **Settings → Legacy EVM Address**:

* If the toggle is **off** → you're using the correct address.
* If the toggle is **on** →
  1. Turn it off to reveal your standard EVM address
  2. Transfer assets to this standard address
  3. Keep Legacy mode off once funds are moved

***

## 💳 [**Hardware Wallets**](#hardware-wallets)

***

### **Does Kastle support Ledger or Tangem on mobile?**

* **Ledger:** Mobile support is coming soon
* **Tangem:** Also planned as part of upcoming hardware integrations
* **Extension:** Ledger is already supported for Kaspa L1

***

### **Can I use Ledger with EVM / Kasplex / L2 networks?**

Not yet.\
Ledger currently supports **Kaspa L1 only**.\
L2/EVM Ledger support requires a different implementation.

***

## 🔄 [**L1 / L2 Bridges**](#l1-l2-bridges)

***

### Is there a way to bridge **from L1 KAS to L2 KAS** within the wallet?

It's not available now, but it's in development and it's coming soon with the next update on mobile.

### **How do I transfer KAS from L1 to L2?**

Use the official **Kurve Bridge (Kaspa Foundation):**\
👉 <https://kasbridge-evm.kaspafoundation.org/>

### **How do I bridge KRC20 or KRC721 tokens?**

Use the **KAT Bridge**, which is specifically designed for KRC-standard assets.

***

## 💰 [**Tokens (KAS, KRC20 & L2)**](#tokens-kas-krc20-and-l2)

***

### **Does Kastle support KRC20 tokens? Can I hold them?**

Yes — Kastle supports holding and viewing **KRC20 tokens** in both extension and mobile.

***

### **Which API does Kastle use to fetch KRC20 token prices?**

Kastle uses **Kasplex APIs** for all KRC20 price and valuation data.

***

### **Are KRC20 swaps supported in Kastle?**

No.\
Due to how KRC20 tokens are implemented (chunk-based buying/selling), **swaps are not technically possible**.

***

### **Will Kastle support swaps?**

Yes — but **only for L2 assets**.\
Swaps for L2 tokens will be available soon through integrated DEX providers.

***

## 🎨 [**NFTs (ERC-721 & KRC721)**](#nfts-erc-721-and-krc721)

***

### **Can Kastle hold ERC-721 NFTs?**

Yes.\
Kastle fully supports **ERC-721 NFTs** on L2 networks — including viewing, receiving, and transferring — on both mobile and extension.

***

### **Does Kastle support KRC721 NFTs?**

Partially.\
Viewing is supported, full **KRC721 transfer support** is coming soon.

***

### **Can I buy or sell NFTs inside Kastle?**

Not natively yet.\
Kastle supports **transfers** for ERC-721 NFTs, but buying/selling will become available through the **in-app browser**, which will let you access external marketplaces.

***

### **Why couldn’t I send NFTs previously on mobile?**

This has now been updated:

* **ERC-721 transfers:** Supported on both mobile & extension
* **KRC721 transfers:** Coming soon

***

## 🧱 [**DApps, WalletConnect & Browser Features**](#dapps-walletconnect-and-browser-features)

***

### **Is WalletConnect supported?**

* **Extension:** Already works with RainbowKit
* **Mobile:** Not yet, integration is in progress\
  Developer documentation will be published once support is live.

***

### **Will Kastle have an in-app browser?**

Yes — this feature is coming soon and will enable:

* NFT marketplace interactions
* Token discovery
* DEX integrations
* KNS marketplace support

***

### **Can I expand the browser extension into a full-page view?**

This feature is on the UX improvement list and being tracked.

***

### **Can the wallet be used to sign and interact with smart contracts?**

At the moment no but the wallet already supports Kaspa L2s (Kasplex and Igra) and you can send and receive L2 tokens in those.

## 📜 [**Activity & History**](#activity-and-history)

***

### **Is there a transaction history inside Kastle?**

Yes — Kastle now includes **full KAS transaction history**, available on both:

* **Mobile app**
* **Browser extension**

More detailed token histories will be added progressively.

***

## 🧪 [**Testnet**](#testnet)

***

### **How can I get test KAS or test tokens?**

Use the official faucet:\
👉 <https://faucet-tn10.kaspanet.io/>

***

## 🛠️ [**Troubleshooting**](#troubleshooting)

***

### **Why doesn’t the wallet work on my PC or iPhone? Are my funds safe?**

Yes — your funds are always safe on-chain.\
Issues usually stem from temporary RPC outages. Once resolved, the wallet will resume normal behavior.

***

### **Why does my Kastle wallet show a 0 balance?**

This is due to RPC congestion. The wallet will sync as soon as the connection stabilizes, and your funds remain safe.

***