# Token

Token Contract Address: [inj1v3a4zznudwpukpr8y987pu5gnh4xuf7v36jhva](https://injscan.com/contract/inj1v3a4zznudwpukpr8y987pu5gnh4xuf7v36jhva)

The **Token Contract** is a core component of the Neptune Protocol, responsible for managing the NEPT token. It handles token minting, bonding, unbonding, and various queries related to token state and user interactions.

## Query Messages

The Token Contract supports several queries to retrieve information about the token state, user stakes, and unlock schedules.

### 1. Get Params

**Query:** `get_params`

**Purpose:** Returns the current state of the token contract variables

**Query Input:**

```json
{
  "get_params": {}
}
```

**Query Response:**

```json
{
  "emission_rate": "50000000000",
  "bond_duration_settings": [
    [
      604800000000000,
      {
        "reward_weight": "1",
        "gov_weight": "1",
        "health_weight": "0",
        "flash_loan_weight": "0"
      }
    ],
    [
      2592000000000000,
      {
        "reward_weight": "2",
        "gov_weight": "2",
        "health_weight": "1",
        "flash_loan_weight": "0"
      }
    ],
    [
      7776000000000000,
      {
        "reward_weight": "3",
        "gov_weight": "3",
        "health_weight": "1",
        "flash_loan_weight": "1"
      }
    ]
  ],
  "tokens_per_weight": 1000
}
```

| Parameters                     | Type                  | Description                                                                 |
| ------------------------------ | --------------------- | --------------------------------------------------------------------------- |
| `emission_rate`                | `string (uint256)`    | The rate at which tokens are emitted and allocated to staking rewards       |
| `bond_duration_settings`       | `array`               | Array contain staking pool parameters                                       |
| `bond_duration_settings.[].[]` | `integer (uint64)`    | The duration of the staking pool bonding period in nanoseconds              |
| `reward_weight`                | `string (decimal256)` | The weight assigned to rewards for the given bond duration                  |
| `gov_weight`                   | `string (decimal256)` | The weight assigned to governance power for the given bond duration         |
| `health_weight`                | `string (decimal256)` | The weight assigned to health calculations for the given bond duration      |
| `flash_loan_weight`            | `string (decimal256)` | The weight assigned to flashloan calculations for the given bond duration   |
| `tokens_per_weight`            | `integer (uint64)`    | The number of tokens assigned per weight unit, used in staking calculations |

This table provides a structured overview of the parameters found in the JSON, including their types and descriptions.

### 2. Get State

**Query:** `get_state`

**Purpose:** Returns the current state of the token contract variables

**Query Input:**

```json
{
  "get_state": {}
}
```

**Query Response:**

```json
{
  "bonded": [
    [
      604800000000000,
      "31290473171"
    ],
    [
      2592000000000000,
      "44644356919"
    ],
    [
      7776000000000000,
      "298450211419"
    ]
  ],
  "stake_acc": "0.220433595000408612",
  "time_last_distributed": "1740513832459201021",
  "total_issued": "19008699867843",
  "total_claimed": "19004686162561",
  "total_locked": "5737867114162",
  "total_supply": "20000000000000"
}
```

| Parameters              | Type                  | Description                                               |
| ----------------------- | --------------------- | --------------------------------------------------------- |
| `bonded`                | `array`               | Array of the available staking pools                      |
| `bonded.[].[0]`         | `integer (uint64)`    | Duration of bond for the staking pool in nanoseconds      |
| `bonded.[].[1]`         | `string (uint256)`    | Amount of NEPT tokens staked to pool                      |
| `stake_acc`             | `string (decimal256)` | The accumulated stake value                               |
| `time_last_distributed` | `string (uint64)`     | The timestamp of the last emissions distribution event    |
| `total_issued`          | `string (uint256)`    | The total number of NEPT tokens that have been issued     |
| `total_claimed`         | `string (uint256)`    | The total number of tokens that have been claimed         |
| `total_locked`          | `string (uint256)`    | The total number of NEPT tokens that are currently locked |
| `total_supply`          | `string (uint256)`    | The total supply of NEPT tokens                           |

### 3. Get User Token Unlocks

**Query:** `get_user_token_unlocks`

**Purpose:** Retrieves token unlock schedules and their claimable amounts for a user, if any apply.

**Query Input:**

```json
{
  "get_user_token_unlocks": {
    "account_addr": "inj142aemh62w2fpqjws0yre5936ts9x9e93fj8322"
  }
}
```

**Query Response:**

```json
{
  "token_unlocks": [
    {
      "amount": "66340451",
      "start": "1736971200000000000",
      "last_claim": "1736971240955753058",
      "expiration": "1744747200000000000",
      "schedule": "lump_sum",
      "admin": {
        "addr": "inj196lzdc3cak5q4fqgtvmqs8vc42dym00frmwpsw",
        "reclaimed": false
      }
    }
  ],
  "claimable_unlocks": "0"
}
```

| Parameters          | Type               | Description                                                                 |
| ------------------- | ------------------ | --------------------------------------------------------------------------- |
| `token_unlocks`     | `array`            | An array of objects, each representing a token unlock schedule with details |
| `amount`            | `string (uint256)` | The amount of tokens scheduled to be unlocked                               |
| `start`             | `string (uint64)`  | The start time of the unlock schedule, unix epoch in nanoseconds            |
| `last_claim`        | `string (uint64)`  | The timestamp of the last claim made, unix epoch in nanoseconds             |
| `expiration`        | `string (uint64)`  | The expiration time of the unlock schedule, unix epoch in nanoseconds       |
| `schedule`          | `UnlockSchedule`   | Either "lump\_sum" or {"linear": {"duration": uint64}}                      |
| `admin`             | `object`           | An object containing administrative details related to the unlock schedule  |
| `admin.addr`        | `string`           | The address of the admin responsible for the unlock schedule                |
| `admin.reclaimed`   | `boolean`          | A flag indicating whether the unlock schedule has been reclaimed            |
| `claimable_unlocks` | `string (uint256)` | The amount of tokens that are currently claimable from the unlock schedule  |

### 4. Get User Staked

**Query:** `get_user_staked`

**Purpose:** Retrieves staking data for a user, including bonded tokens, unbonding tokens, unclaimed rewards, and claimable rewards.

**Query Input:**

```json
{
  "get_user_staked": {
    "account_addr": "inj1exampleaddress"
  }
}
```

**Query Response:**

```json
{
  "bonded": [
    {
      "account_index": 0,
      "duration": 604800000000000,
      "bonded": []
    },
    {
      "account_index": 0,
      "duration": 7776000000000000,
      "bonded": [
        {
          "cooldown": null,
          "cascade": false,
          "last_stake_acc": "0.219795491591127008",
          "amount": "69922202"
        }
      ]
    },
    {
      "account_index": 2,
      "duration": 604800000000000,
      "bonded": []
    },
    {
      "account_index": 2,
      "duration": 7776000000000000,
      "bonded": []
    }
  ],
  "unbonding": [],
  "unclaimed": "1349271",
  "claimable_rewards": "1487805",
  "claimable_unbonding": "0"
}
```

| Parameters                                                                                                      | Type                | Description                                                                                                 |
| --------------------------------------------------------------------------------------------------------------- | ------------------- | ----------------------------------------------------------------------------------------------------------- |
| `bonded`                                                                                                        | `array`             | An array of objects, each representing a bond with details about account index, duration, and bonded tokens |
| <p><code>bonded.\[].</code></p><p><strong><code>account\_index</code></strong></p>                              | `u64`               | The index of a users margin account associated with the token bond                                          |
| <p><code>bonded.\[].</code></p><p><strong><code>duration</code></strong></p>                                    | `u64 (nanoseconds)` | The duration of the staking pool bond in nanoseconds                                                        |
| <p><code>bonded.\[].</code></p><p><strong><code>bonded</code></strong></p>                                      | `array`             | An array of objects representing individual bond details                                                    |
| <p><code>bonded.\[].</code></p><p><code>bonded.</code></p><p><strong><code>cooldown</code></strong></p>         | `null` or `string`  | The cooldown (unlock) period for the bond, null if not applicable                                           |
| <p><code>bonded.\[].</code></p><p><code>bonded.</code></p><p><strong><code>cascade</code></strong></p>          | `boolean`           | A flag indicating whether the cooldown is part of a cascade operation                                       |
| <p><code>bonded.\[].</code></p><p><code>bonded.</code></p><p><strong><code>last\_stake\_acc</code></strong></p> | `string (u64)`      | The last recorded stake accumulator value for the bond.                                                     |
| <p><code>bonded.\[].</code></p><p><code>bonded.</code></p><p><strong><code>amount</code></strong></p>           | `string (u64)`      | The amount of tokens bonded.                                                                                |
| `unbonding`                                                                                                     | `array`             | An array representing tokens that are in the process of unbonding.                                          |
| `unclaimed`                                                                                                     | `string (u64)`      | The amount of staking rewards that have been accumulated but not yet claimed                                |
| `claimable_rewards`                                                                                             | `string (u64)`      | The amount of staking rewards that are currently claimable                                                  |
| `claimable_unbonding`                                                                                           | `string (u64)`      | The amount of unbonding tokens that are currently claimable                                                 |

### 5. Get Health Weighted Stake

**Query:** `get_health_weighted_stake`

**Purpose:** Calculates the health-weighted stake for a specific staking position, used by the market contract for account health calculations.

**Query Input:**

```json
{
  "get_health_weighted_stake": {
    "account_addr": "inj1exampleaddress",
    "account_index": 0
  }
}
```

**Query Response:**

```json
"69922202"
```

| Parameters | Type               | Description                                                           |
| ---------- | ------------------ | --------------------------------------------------------------------- |
| `response` | `string (uint256)` | The health-weighted stake for the specified account address and index |

### 5. Get Gov Weighted Stake

**Query:** `get_gov_weighted_stake`

**Purpose:** Calculates the governance-weighted stake for a user, determining voting power in protocol governance.

**Query Input:**

```json
{
  "get_gov_weighted_stake": {
    "account_addr": "inj1exampleaddress"
  }
}
```

**Query Response:**

```
"209766606"
```

| Parameters | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `response` | `string (uint256)` | The governance weight for a given address |

### 6. Get Flash Loan Weighted Stake

**Query:** `get_flash_loan_weighted_stake`

**Purpose:** Calculates the flashloan-weighted stake for a user, used in flashloan operations to determine the amount of assets a user can borrow in a flashloan.

**Query Input:**

```json
{
  "get_flash_loan_weighted_stake": {
    "account_addr": "inj1exampleaddress"
  }
}
```

**Query Response:**

```
"209766606"
```

| Parameters | Type               | Description                                                                                   |
| ---------- | ------------------ | --------------------------------------------------------------------------------------------- |
| `response` | `string (uint256)` | The flashloan weight staked used to calculate the amount a user can flashloan from the market |

### 7. Get Health Weighted Stake Range

**Query:** `get_health_weighted_stake_range`

**Purpose:** Retrieves the health-weighted stake for a range of account positions.

**Query Input:**

```json
{
  "get_health_weighted_stake_range": {
    "from": ["inj1exampleaddress", 0],
    "to": ["inj1exampleaddress", 1]
  }
}
```

**Query Response:**

```json
[
  [
    ["inj1exampleaddress", 0],
    "1000000"
  ],
  [
    ["inj1exampleaddress", 1],
    "2000000"
  ]
]
```

| Parameters  | Type               | Description                                               |
| ----------- | ------------------ | --------------------------------------------------------- |
| `[]`        | `array`            | Array of account indexes and their health weighted stakes |
| `[].[].[1]` | `string (uint256)` | Health weighted stake value                               |

### 8. Get Cascade

**Query:** `get_cascade`

**Purpose:** Checks if there are any pending cascade operations. Cascading is used to transition bonds from one duration phase to another.

**Query Input:**

```json
{
  "get_cascade": {}
}
```

**Query Response:**

```
true
```

| Parameters | Type      | Description                                                            |
| ---------- | --------- | ---------------------------------------------------------------------- |
| `response` | `boolean` | Returns `true` if at least one cascade entry exists, `false` otherwise |

## Execute Messages

The Token Contract supports several execute messages for managing token bonding, unbonding, rewards, and token unlocks.

### 1. Bond

**Execute:** `bond`

**Purpose:** Bonds (stakes) NEPT tokens to a specified staking pool for a specified duration, enabling participation in protocol governance and earning staking rewards.

**Execute Input:**

```json
{
  "bond": {
    "account_index": 0,
    "duration": 604800000000000
  }
}
```

| Parameters      | Type               | Description                                                                                  |
| --------------- | ------------------ | -------------------------------------------------------------------------------------------- |
| `account_index` | `integer (uint8)`  | The index of the margin account to associate with the bond                                   |
| `duration`      | `integer (uint64)` | The duration to bond tokens for, must match one of the durations in bond\_duration\_settings |

**Note:** This message must be sent with exactly one non-zero amount of NEPT tokens to bond.

### 2. Unbond

**Execute:** `unbond`

**Purpose:** Initiates the unbonding of staked NEPT tokens, starting the cooldown period before tokens can be claimed.

**Execute Input:**

```json
{
  "unbond": {
    "account_index": 0,
    "amount": "1000000",
    "duration": 604800000000000
  }
}
```

| Parameters      | Type               | Description                                    |
| --------------- | ------------------ | ---------------------------------------------- |
| `account_index` | `integer (uint8)`  | The index of the margin account to unbond from |
| `amount`        | `string (uint256)` | The amount of NEPT tokens to unbond            |
| `duration`      | `integer (uint64)` | The duration pool to unbond from               |

### 3. Rebond

**Execute:** `rebond`

**Purpose:** Rebonds tokens that are currently unbonding back into a staking position, optionally enabling cascading.

**Execute Input:**

```json
{
  "rebond": {
    "account_index": 0,
    "amount": "1000000",
    "duration": 604800000000000,
    "cascade": true
  }
}
```

| Parameters      | Type               | Description                                  |
| --------------- | ------------------ | -------------------------------------------- |
| `account_index` | `integer (uint8)`  | The index of the margin account to rebond to |
| `amount`        | `string (uint256)` | The amount of NEPT tokens to rebond          |
| `duration`      | `integer (uint64)` | The duration to rebond for                   |
| `cascade`       | `boolean`          | Whether to enable cascading for this bond    |

### 4. Claim Unbonded

**Execute:** `claim_unbonded`

**Purpose:** Claims NEPT tokens that have completed their unbonding period.

**Execute Input:**

```json
{
  "claim_unbonded": {}
}
```

### 5. Claim Rewards

**Execute:** `claim_rewards`

**Purpose:** Claims accumulated staking rewards from all bonded positions.

**Execute Input:**

```json
{
  "claim_rewards": {}
}
```

### 6. Claim Token Unlock

**Execute:** `claim_token_unlock`

**Purpose:** Claims tokens that have been unlocked according to the unlock schedule.

**Execute Input:**

```json
{
  "claim_token_unlock": {}
}
```

### 7. Reclaim Token Unlock

**Execute:** `reclaim_token_unlock`

**Purpose:** Allows an admin to reclaim tokens from an unlock schedule they control.

**Execute Input:**

```json
{
  "reclaim_token_unlock": {
    "addr": "inj1...",
    "index": 0,
    "recipient": "inj1..."
  }
}
```

| Parameters  | Type               | Description                                         |
| ----------- | ------------------ | --------------------------------------------------- |
| `addr`      | `string`           | The address that owns the unlock schedule           |
| `index`     | `integer (uint64)` | The index of the unlock schedule to reclaim         |
| `recipient` | `string`           | Optional recipient address for the reclaimed tokens |

### 8. Cascade

**Execute:** `cascade`

**Purpose:** Processes bonds that are ready to cascade to lower duration pools.

**Execute Input:**

```json
{
  "cascade": {
    "limit": 10
  }
}
```

| Parameters | Type               | Description                                  |
| ---------- | ------------------ | -------------------------------------------- |
| `limit`    | `integer (uint16)` | Maximum number of cascade entries to process |

### 9. Create Token Unlock

**Execute:** `create_token_unlock`

**Purpose:** Creates a new token unlock schedule for gradual or lump-sum token distribution.

**Execute Input:**

```json
{
  "create_token_unlock": {
    "addr": "inj1...",
    "start": "1736971200000000000",
    "expiration": "1744747200000000000",
    "schedule": {
      "linear": {
        "duration": 7776000000000000
      }
    },
    "admin": "inj1..."
  }
}
```

| Parameters   | Type              | Description                                            |
| ------------ | ----------------- | ------------------------------------------------------ |
| `addr`       | `string`          | The address that will receive the unlocked tokens      |
| `start`      | `string (uint64)` | The timestamp when the unlock schedule begins          |
| `expiration` | `string (uint64)` | Optional timestamp when the unlock schedule expires    |
| `schedule`   | `UnlockSchedule`  | Either "lump\_sum" or {"linear": {"duration": uint64}} |
| `admin`      | `string`          | Optional admin address that can reclaim tokens         |

**Note:** This message must be sent with the NEPT tokens to be unlocked.

### 10. Set Params

**Execute:** `set_params`

**Purpose:** Updates the contract parameters, including emission rate and bond duration settings.

**Execute Input:**

```json
{
  "set_params": {
    "params": {
      "emission_rate": "50000000000",
      "bond_duration_settings": [
        [
          604800000000000,
          {
            "reward_weight": "1",
            "gov_weight": "1",
            "health_weight": "0",
            "flash_loan_weight": "0"
          }
        ]
      ]
    }
  }
}
```

| Parameters               | Type               | Description                                   |
| ------------------------ | ------------------ | --------------------------------------------- |
| `emission_rate`          | `string (uint256)` | The new emission rate of NEPT tokens per year |
| `bond_duration_settings` | `array`            | Array of duration and weight settings         |

**Note:** Cannot modify governance or reward weights for existing durations.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.nept.finance/develop/contracts/token.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.