# Delegated Accounts
Source: https://docs.glam.systems/v1/access-control/delegated-accounts



Delegated accounts (also known as delegates) start with no permissions and must be explicitly granted access. Permissions are granular, allowing vault owners to build precise guardrails by adding specific capabilities to each delegate.

* Low-privileged delegates are ideal for performing routine tasks such as staking and farming.
* High-privileged delegates can be used for more sensitive operations like trading and transfers.

This approach enhances security by ensuring that delegates can only perform intended actions within the defined boundaries:

* It reduces the risk of unauthorized operations and accidental mistakes.
* Even if a delegate is compromised, the impact is limited to the permissions granted to them.

## Permissions

Permissions are protocol-specific capabilities defined by each [integration program](/v1/platform/integrations). They represent the smallest units of access that can be granted to delegates, allowing for fine-grained control over what actions each delegate can perform.

Permission bitflags are stored as `u64` integers, allowing for a maximum of 64 permissions per protocol.

Follow the links in the table to view the permission definitions in program IDLs.

| Protocol                                                                                                                                 | Permission Name | Permission Bitflag   | Description                                 |
| ---------------------------------------------------------------------------------------------------------------------------------------- | --------------- | -------------------- | ------------------------------------------- |
| [System](https://github.com/glamsystems/glam-sdk/blob/6d03d99af6650b3f211de84c8e5f152eebef78f3/idl/glam_protocol.json#L3103-L3112)       | WSOL            | `0b0000000000000001` | Wrap SOL to wSOL                            |
|                                                                                                                                          | Transfer        | `0b0000000000000010` | Transfer vault SOL an allowlisted address   |
| [Jupiter Swap](https://github.com/glamsystems/glam-sdk/blob/6d03d99af6650b3f211de84c8e5f152eebef78f3/idl/glam_protocol.json#L3068-L3082) | SwapAny         | `0b0000000000000001` | Swap any token to any other token           |
|                                                                                                                                          | SwapLST         | `0b0000000000000010` | Swap among SOL and LSTs                     |
|                                                                                                                                          | SwapAllowlisted | `0b0000000000000100` | Swap tokens that are explicitly allowlisted |
| [SPL](https://github.com/glamsystems/glam-sdk/blob/6d03d99af6650b3f211de84c8e5f152eebef78f3/idl/ext_spl.json#L1259-L1263)                | Transfer        | `0b0000000000000001` | Transfer vault token an allowlisted address |
| [Kamino Lending](https://github.com/glamsystems/glam-sdk/blob/6d03d99af6650b3f211de84c8e5f152eebef78f3/idl/ext_kamino.json#L2841-L2865)  | Init            | `0b0000000000000001` | Initialize Kamino lending account           |
|                                                                                                                                          | Deposit         | `0b0000000000000010` | Deposit tokens into Kamino lending          |
|                                                                                                                                          | Withdraw        | `0b0000000000000100` | Withdraw tokens from Kamino lending         |
|                                                                                                                                          | Borrow          | `0b0000000000001000` | Borrow tokens on Kamino lending             |
|                                                                                                                                          | Repay           | `0b0000000000010000` | Repay borrowed tokens                       |
| [Kamino Vaults](https://github.com/glamsystems/glam-sdk/blob/6d03d99af6650b3f211de84c8e5f152eebef78f3/idl/ext_kamino.json#L2871-L2880)   | Deposit         | `0b0000000000000001` | Deposit into Kamino vaults                  |
|                                                                                                                                          | Withdraw        | `0b0000000000000010` | Withdraw from Kamino vaults                 |
| [Kamino Farms](https://github.com/glamsystems/glam-sdk/blob/6d03d99af6650b3f211de84c8e5f152eebef78f3/idl/ext_kamino.json#L2821-L2835)    | Stake           | `0b0000000000000001` | Stake tokens in Kamino farms                |
|                                                                                                                                          | Unstake         | `0b0000000000000010` | Unstake tokens from Kamino farms            |
|                                                                                                                                          | HarvestReward   | `0b0000000000000100` | Harvest farming rewards                     |
| [CCTP](https://github.com/glamsystems/glam-sdk/blob/6d03d99af6650b3f211de84c8e5f152eebef78f3/idl/ext_cctp.json#L1253-L1257)              | Transfer        | `0b0000000000000001` | Bridge asset to another chain               |

### Pending Audit

This table lists permissions defined by integration programs that are pending audit.

| Protocol                                                                                                                                  | Permission Name | Permission Bitflag   | Description                        |
| ----------------------------------------------------------------------------------------------------------------------------------------- | --------------- | -------------------- | ---------------------------------- |
| [Stake Program](https://github.com/glamsystems/glam-sdk/blob/6d03d99af6650b3f211de84c8e5f152eebef78f3/idl/glam_protocol.json#L3088-L3097) | Stake           | `0b0000000000000001` | Stake SOL to a validator           |
|                                                                                                                                           | Unstake         | `0b0000000000000010` | Unstake from a validator           |
| [Stake Pool](https://github.com/glamsystems/glam-sdk/blob/6d03d99af6650b3f211de84c8e5f152eebef78f3/idl/ext_stake_pool.json#L1577-L1596)   | DepositSol      | `0b0000000000000001` | Deposit SOL to a pool              |
|                                                                                                                                           | DepositStake    | `0b0000000000000010` | Deposit stake account to a pool    |
|                                                                                                                                           | DepositSolAny   | `0b0000000000000100` | Deposit SOL to any pool            |
|                                                                                                                                           | DepositStakeAny | `0b0000000000001000` | Deposit stake account to any pool  |
|                                                                                                                                           | WithdrawSol     | `0b0000000000010000` | Withdraw SOL from a pool           |
|                                                                                                                                           | WithdrawStake   | `0b0000000000100000` | Withdraw stake account from a pool |
| [Sanctum](https://github.com/glamsystems/glam-sdk/blob/6d03d99af6650b3f211de84c8e5f152eebef78f3/idl/ext_stake_pool.json#L1557-L1576)      | DepositSol      | `0b0000000000000001` | Deposit SOL to a pool              |
|                                                                                                                                           | DepositStake    | `0b0000000000000010` | Deposit stake account to a pool    |
|                                                                                                                                           | DepositSolAny   | `0b0000000000000100` | Deposit SOL to any pool            |
|                                                                                                                                           | DepositStakeAny | `0b0000000000001000` | Deposit stake account to any pool  |
|                                                                                                                                           | WithdrawSol     | `0b0000000000010000` | Withdraw SOL from a pool           |
|                                                                                                                                           | WithdrawStake   | `0b0000000000100000` | Withdraw stake account from a pool |
| [Marinade](https://github.com/glamsystems/glam-sdk/blob/6d03d99af6650b3f211de84c8e5f152eebef78f3/idl/ext_marinade.json#L1577-L1586)       | Stake           | `0b0000000000000001` | Stake SOL to get mSOL              |
|                                                                                                                                           | Unstake         | `0b0000000000000010` | Unstake mSOL to get SOL            |


# Framework
Source: https://docs.glam.systems/v1/access-control/framework



The GLAM access control framework fully operates onchain. It plays a crucial role in protecting Vaults and Mints from unauthorized access and malicious activities. Program invocations are thoroughly examined at three different levels.

<CardGroup>
  <Card title="Vault-level" icon="vault">
    The vault-level access control ensures that rules are applied uniformly to all signers, regardless of their roles or permissions.

    *Benefits: This strengthens security by providing an overarching control layer for critical vault operations.*
  </Card>

  <Card title="Instruction-level" icon="wrench">
    The instruction-level access control is enforced on individual instructions, ensuring that only authorized instruction(s) can be executed by a delegate.

    *Benefits: It ensures that delegates can only perform specific actions permitted by the vault owner, enhancing operational flexibility without compromising security.*
  </Card>

  <Card title="Parameter-level" icon="puzzle-piece-simple">
    The parameter-level access control represents a highly granular mechanism that restricts and defines access based not only on instructions but also on specific parameters within those actions.

    *Benefits: This level of control ensures that even when a delegate is permitted to execute certain instructions, the scope of those instructions is limited to predefined parameters.*
  </Card>
</CardGroup>

***

<Tip>
  Learn how GLAM's onchain access control can help mitigate supply chain attacks targeting crypto projects in our blog post [here](https://www.glam.systems/blog/mitigating-supply-chain-attacks-with-onchain-access-control-and-timelocks).
</Tip>


# Use Cases
Source: https://docs.glam.systems/v1/access-control/use-cases



<Note>
  GLAM access control framework provides a flexible and secure way to manage delegated accounts and their permissions. Some common use cases are listed below.
</Note>

<Tabs>
  <Tab title="Treasury Management">
    <Frame>
      <img />

      <img />

      <video />

      <video />
    </Frame>

    The vault owner designates a treasury delegate with specific permissions to manage protocol interactions. While this delegate can lend into and withdraw from authorized protocols, they cannot initiate unauthorized actions like transfers. This enables specialized treasury management while maintaining strict security controls.
  </Tab>

  <Tab title="Stake Management">
    <Frame>
      <img />

      <img />

      <video />

      <video />
    </Frame>

    The vault owner grants a staking manager delegate permission to optimize staking positions across validators. While the delegate can execute stake and unstake instructions within defined parameters, they cannot perform unauthorized actions like swaps. This enables specialized stake management with robust security controls.
  </Tab>

  <Tab title="AI Yield Optimization">
    <Frame>
      <img />

      <img />

      <video />

      <video />
    </Frame>

    The vault owner grants an AI optimizer delegate permission to automatically rebalance positions across lending protocols. While the delegate can move assets between integrated protocols to maximize returns, they cannot perform unauthorized actions like swaps. This enables automated yield optimization with strong security controls.
  </Tab>

  <Tab title="Governance Automation">
    <Frame>
      <img />

      <img />

      <video />

      <video />
    </Frame>

    The vault owner grants a governance delegate permission to participate in protocol governance. While the delegate can cast votes on behalf of the vault's token holdings, they cannot perform unauthorized actions like trades. This enables automated governance with rigorous security controls.
  </Tab>
</Tabs>


# Address Lookup Tables
Source: https://docs.glam.systems/v1/cli/alt



Address Lookup Tables (ALTs) reduce transaction size by allowing addresses to be referenced by index rather than including full 32-byte public keys. This is especially useful for complex vault operations like pricing with many assets or DeFi positions.

<Info>
  For assistance with address lookup tables, please contact us at [dev@glam.systems](mailto:dev@glam.systems).
</Info>

## When to Use ALTs

ALTs are recommended when:

* The vault holds many assets that need pricing in a single transaction
* DeFi integrations (e.g., Kamino) add many accounts to transactions
* Transactions exceed the Solana transaction size limit (1232 bytes)

Pricing transactions are the most common case where ALTs are needed, as they reference oracle accounts, token accounts, and market accounts for each asset in the vault.


# Cross-Chain Transfer (CCTP)
Source: https://docs.glam.systems/v1/cli/cctp

Bridge USDC across chains using Circle's CCTP

Commands for bridging USDC across chains using Circle's Cross-Chain Transfer Protocol (CCTP).

<Note>
  The `CCTP` integration must be enabled before using these commands:

  ```bash theme={null}
  glam-cli integration enable CCTP
  ```
</Note>

## Bridge USDC

Bridge USDC from Solana to an EVM chain.

* `amount`: Amount of USDC to bridge
* `domain`: Destination domain ID (see table below)
* `destination_address`: Recipient address on the destination chain
* `--destination-caller`, `-d`: Optional destination caller address
* `--max-fee-bps`, `-m`: Maximum fee in basis points (default: 1)
* `--base58`, `-b`: Address is in base58 format (default: EVM hex format)
* `--fast`, `-f`: Use fast transfer mode (lower finality threshold)

```bash theme={null}
glam-cli cctp bridge-usdc <amount> <domain> <destination_address> [options] [--yes]
```

**Example:** Bridge 100 USDC to Ethereum:

```bash theme={null}
glam-cli cctp bridge-usdc 100 0 0x1234567890abcdef1234567890abcdef12345678
```

**Example:** Fast bridge to Arbitrum:

```bash theme={null}
glam-cli cctp bridge-usdc 100 3 0x1234567890abcdef1234567890abcdef12345678 --fast
```

### Domain IDs

| Domain ID | Chain     |
| --------- | --------- |
| 0         | Ethereum  |
| 1         | Avalanche |
| 2         | Optimism  |
| 3         | Arbitrum  |
| 6         | Base      |
| 7         | Polygon   |

## Receive USDC

Receive USDC bridged from an EVM chain to Solana.

* `source_domain`: Source chain domain ID
* `--txHash`, `-t`: Transaction hash from the source chain (hex string starting with 0x)
* `--nonce`, `-n`: Nonce from the source transaction (hex string starting with 0x)

```bash theme={null}
glam-cli cctp receive <source_domain> [--txHash <hash>] [--nonce <nonce>]
```

## List Bridge Events

List CCTP events for incoming and outgoing bridge transfers.

* `--since-slot`, `-s`: Fetch events since this slot
* `--batch-size`, `-b`: Batch size for RPC requests
* `--commitment`, `-c`: Commitment level (default: confirmed)

```bash theme={null}
glam-cli cctp list [--since-slot <slot>] [--batch-size <size>] [--commitment <level>]
```

***

## Policy Management

CCTP policies allow you to restrict which destination addresses can receive bridged USDC.

### View Policy

View the current CCTP policy.

```bash theme={null}
glam-cli cctp view-policy
```

### Allowlist Destination

Add a destination address to the CCTP allowlist.

* `domain`: Destination domain ID
* `destination_address`: Address on the destination chain
* `--base58`: Address is in base58 format

```bash theme={null}
glam-cli cctp allowlist-destination <domain> <destination_address> [--base58] [--yes]
```

**Example:** Allowlist an Ethereum address:

```bash theme={null}
glam-cli cctp allowlist-destination 0 0x1234567890abcdef1234567890abcdef12345678
```

### Remove Destination

Remove a destination address from the CCTP allowlist.

```bash theme={null}
glam-cli cctp remove-destination <domain> <destination_address> [--base58] [--yes]
```


# Delegate Commands
Source: https://docs.glam.systems/v1/cli/delegate



Manage delegate permissions for your vault. Only the vault owner can grant or revoke delegate permissions.

For more information on the access control framework, see [Access Control](/v1/access-control/framework).

## List Delegates

List all delegates and their permissions for the active vault.

```bash theme={null}
glam-cli delegate list
```

## Grant Permissions

Grant delegate permissions for a specific protocol.

* `pubkey`: Public key of the delegate
* `permissions...`: Space-separated list of permission names
* `--protocol`: Protocol name (required). Examples: `KaminoLend`, `SplToken`, `JupiterSwap`

```bash theme={null}
glam-cli delegate grant <pubkey> <permissions...> --protocol <protocol_name> [--yes]
```

**Example:** Grant a delegate permission to deposit and withdraw on Kamino Lending:

```bash theme={null}
glam-cli delegate grant Delegate111111111111111111111111 Deposit Withdraw --protocol KaminoLend
```

<Tip>
  Run `glam-cli delegate grant -h` to see the full list of available permissions for each protocol.
</Tip>

## Revoke Permissions

Revoke specific delegate permissions for a protocol.

* `pubkey`: Public key of the delegate
* `permissions...`: Space-separated list of permission names to revoke
* `--protocol`: Protocol name (required)

```bash theme={null}
glam-cli delegate revoke <pubkey> <permissions...> --protocol <protocol_name> [--yes]
```

**Example:** Revoke deposit permission from a delegate:

```bash theme={null}
glam-cli delegate revoke Delegate111111111111111111111111 Deposit --protocol KaminoLend
```

## Revoke All Permissions

Completely remove a delegate's access to the vault.

```bash theme={null}
glam-cli delegate revoke-all <pubkey> [--yes]
```


# CLI Examples
Source: https://docs.glam.systems/v1/cli/examples



## Install & Configure CLI

The GLAM CLI is built using the GLAM SDK. The [source code is available on Github](https://github.com/glamsystems/glam-cli).

For reference, here's a sample configuration:

```json theme={null}
{
  "cluster": "mainnet-beta",
  "json_rpc_url": "https://mainnet.helius-rpc.com/?api-key=[ redacted ]",
  "tx_rpc_url": "https://staked.helius-rpc.com/?api-key=[ redacted ]",
  "keypair_path": "/path/to/keypair.json",
  "jupiter_api_key": "[ redacted ]",
  "priority_fee": {
    "level": "Min",
    "helius_api_key": "[ redacted ]"
  }
}
```

<Info>
  If you don't have a dedicated RPC for landing transactions, it's highly recommended to set priority fee level to High.
</Info>

***

## Create a Vault

Prepare a vault.json file with basic vault configurations:

```json theme={null}
{
  "accountType": "vault",
  "name": "GLAM Vault Demo",
  "enabled": true,
  "assets": [
    "So11111111111111111111111111111111111111112",
    "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
  ]
}
```

Create the vault:

```bash theme={null}
glam-cli vault create vault.json
```

Output:

```text theme={null}
txSig: 58QhaZWjVqdBr1Ap9eitp8p4LL2NyzT2c5fxhVtb7qgo2Y8DDhrY6yeAobcTqz1fW3AYcjknbtXqbSNkcg7ePkrW
GLAM state created: 6K1wuNhcFX6yDJZaGYwQMnnf4rGuCNBTvngx5dQNNfcN
Vault: 5zJKfPVQLEBiVqoXRtG9tYRXHS166d5JiZbyQtiopqgh
```

***

## Enable Integrations

Integrations are disabled by default. Enable them before use:

```bash theme={null}
glam-cli integration enable KaminoLend JupiterSwap
```

Verify enabled integrations:

```bash theme={null}
glam-cli integration list
```

Output:

```text theme={null}
GLAM Vault Quickstart (6K1wuNhcFX6yDJZaGYwQMnnf4rGuCNBTvngx5dQNNfcN) has 2 integration programs enabled:
[0] GLAMpk...111111, protocols (0b001): KaminoLend
[1] GLAMpk...111111, protocols (0b010): JupiterSwap
```

***

## Deposit

SOL and tokens can be transferred to the vault directly.

### Get Vault Address

```bash theme={null}
glam-cli env
```

In the output, the pubkey after `Active vault:` is the vault address that can receive tokens.

<Warning>
  Double check you have the right address before transferring. Sending tokens to the wrong address might lead to unrecoverable loss of your funds!
</Warning>

```text theme={null}
Wallet connected: gLJHKPrZLGBiBZ33hFgZh6YnsEhTVxuRT17UCqNp6ff
RPC endpoint: https://mainnet.helius-rpc.com/?api-key=[ redacted ]
Priority fee: { level: 'Min', helius_api_key: '...' }
GLAM state: 6K1wuNhcFX6yDJZaGYwQMnnf4rGuCNBTvngx5dQNNfcN
✅ Active vault: 5zJKfPVQLEBiVqoXRtG9tYRXHS166d5JiZbyQtiopqgh
```

### Check Vault Holdings

```bash theme={null}
glam-cli vault token-balances
```

Output:

```text theme={null}
Token    Mint    Amount          Value (USD)
SOL      N/A     0.5             70.4668035
```

***

## Kamino Lending

### Initialize Kamino User

```bash theme={null}
glam-cli kamino-lend init
```

### Deposit to Main Market

The pubkey of Kamino main market is `7u3HeHxYDLhnCoErrtycNokbQYbWGzLs6JSDqGAv5PfF`.

Deposit 0.1 SOL:

```bash theme={null}
glam-cli kamino-lend deposit 7u3HeHxYDLhnCoErrtycNokbQYbWGzLs6JSDqGAv5PfF So11111111111111111111111111111111111111112 0.1
```

To verify the deposit, visit the vault's Kamino account at:

```text theme={null}
https://app.kamino.finance/?DEBUG_WALLET=[ YourVaultAddress ]
```

### Borrow

Borrow cbBTC using deposited SOL as collateral:

```bash theme={null}
glam-cli kamino-lend borrow 7u3HeHxYDLhnCoErrtycNokbQYbWGzLs6JSDqGAv5PfF cbbtcf3aa214zXHbiAZQwf4122FBYbraNdFqgw4iMij 0.000001
```

### Withdraw

```bash theme={null}
glam-cli kamino-lend withdraw 7u3HeHxYDLhnCoErrtycNokbQYbWGzLs6JSDqGAv5PfF So11111111111111111111111111111111111111112 0.05
```

### Repay

```bash theme={null}
glam-cli kamino-lend repay 7u3HeHxYDLhnCoErrtycNokbQYbWGzLs6JSDqGAv5PfF cbbtcf3aa214zXHbiAZQwf4122FBYbraNdFqgw4iMij 0.000001
```

***

## Jupiter Swap

Swap 0.01 SOL to USDC:

```bash theme={null}
glam-cli jupiter swap SOL USDC 0.01
```

***

## Access Control & Delegation

### Grant Permissions

```bash theme={null}
glam-cli delegate grant <delegate_pubkey> Deposit --protocol KaminoLend
```

### List Delegates

```bash theme={null}
glam-cli delegate list
```

### Revoke Permissions

```bash theme={null}
glam-cli delegate revoke <delegate_pubkey> Deposit --protocol KaminoLend
```

### Revoke All Access

```bash theme={null}
glam-cli delegate revoke-all <delegate_pubkey>
```

***

## Debugging Tips

### Simulation

If a transaction fails during simulation, copy the base64 encoded transaction data and simulate it on [https://explorer.solana.com/tx/inspector](https://explorer.solana.com/tx/inspector) for better error messages.

### Inspecting Onchain Data

Due to active development, new IDLs are shipped frequently. If a transaction isn't parsed on solscan.io, try [https://explorer.solana.com/](https://explorer.solana.com/) instead.


# General Commands
Source: https://docs.glam.systems/v1/cli/general



## Environment

### View Environment Setup

Display the current CLI configuration including connected wallet, RPC endpoint, and active vault.

```bash theme={null}
glam-cli env
```

***

## Vault Management

### List Vaults

List GLAM vaults accessible to the connected wallet.

* `--owner-only`, `-o`: Only show vaults owned by the connected wallet
* `--all`, `-a`: Show all GLAM vaults
* `--type`, `-t`: Filter by type (`vault` or `tokenizedVault`)

```bash theme={null}
glam-cli vault list [--owner-only] [--all] [--type <type>]
```

### Set Active Vault

Set the active GLAM vault for subsequent CLI operations. Saves the vault state to the config file.

```bash theme={null}
glam-cli vault set <state>
```

### View Vault Details

View a GLAM vault by its state pubkey.

* `--compact`, `-c`: Output as compact JSON
* `state`: If not provided, the current active vault is used

```bash theme={null}
glam-cli vault view [--compact] [state]
```

### Create a Vault

Create a new GLAM vault from a JSON template file.

* See the [templates directory](https://github.com/glamsystems/glam/tree/main/cli/templates) for available templates

```bash theme={null}
glam-cli vault create <path-to-template.json>
```

### Close a Vault

Close a GLAM vault. Only the owner can close a vault. Tokenized vaults cannot be closed if mint supply is greater than 0.

* `state`: If not provided, the current active vault is used
* `--yes`, `-y`: Skip confirmation prompt

```bash theme={null}
glam-cli vault close [state] [--yes]
```

### Update Owner

Transfer vault ownership to a new owner.

* `--name`, `-n`: Optionally set a new portfolio manager name
* `--yes`, `-y`: Skip confirmation prompt

```bash theme={null}
glam-cli vault update-owner <new-owner> [--name <name>] [--yes]
```

### Enable/Disable Vault

Enable a GLAM vault.

```bash theme={null}
glam-cli vault enable [--yes]
```

Disable a GLAM vault.

```bash theme={null}
glam-cli vault disable [--yes]
```

### Extend State Account

Extend the GLAM state account by additional bytes. Useful when the state account needs more space.

```bash theme={null}
glam-cli vault extend <bytes> [--yes]
```

***

## Asset Management

### View Balances

Get token balances for the vault.

* `--all`, `-a`: Show all assets including token accounts with 0 balance

```bash theme={null}
glam-cli vault token-balances [--all]
```

### View Holdings

Get all vault holdings including token balances and positions across integrated protocols.

```bash theme={null}
glam-cli vault holdings
```

### Close Token Accounts

Close vault token accounts by specifying mint addresses, or use `--empty` to close all zero-balance token accounts.

* `mints`: One or more mint addresses of token accounts to close

```bash theme={null}
glam-cli vault close-token-accounts <mints...> [--yes]
glam-cli vault close-token-accounts --empty [--yes]
```

<Info>
  Token programs prevent closing token accounts with non-zero balances.
</Info>

### List Asset Allowlist

List the vault's asset allowlist and corresponding token accounts.

```bash theme={null}
glam-cli vault list-assets
```

### Add Asset to Allowlist

Add an asset to the vault's allowlist.

```bash theme={null}
glam-cli vault allowlist-asset <asset> [--yes]
```

### Remove Asset from Allowlist

Remove an asset from the vault's allowlist.

```bash theme={null}
glam-cli vault remove-asset <asset> [--yes]
```

***

## SOL Wrapping

### Wrap SOL

Wrap SOL into wSOL.

```bash theme={null}
glam-cli vault wrap <amount> [--yes]
```

### Unwrap wSOL

Unwrap all wSOL back to SOL.

```bash theme={null}
glam-cli vault unwrap [--yes]
```

***

## Vault Templates

When creating a vault with `glam-cli vault create <template>`, the template is a JSON file that defines the vault configuration. Templates are available in the [CLI templates directory](https://github.com/glamsystems/glam/tree/main/cli/templates).

### Template Structure

A vault template has two top-level sections:

```json theme={null}
{
  "state": { /* StateModel fields */ },
  "mint": { /* MintModel fields (tokenized vaults only) */ }
}
```

### StateModel Fields

<table>
  <thead>
    <tr>
      <th>Field</th>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td>`accountType`</td>
      <td>`"vault"` | `"tokenizedVault"` | `"singleAssetVault"`</td>
      <td>Vault type</td>
    </tr>

    <tr>
      <td>`name`</td>
      <td>`string`</td>
      <td>Vault display name</td>
    </tr>

    <tr>
      <td>`enabled`</td>
      <td>`boolean`</td>
      <td>Whether the vault is active</td>
    </tr>

    <tr>
      <td>`baseAssetMint`</td>
      <td>`string`</td>
      <td>Base asset mint address</td>
    </tr>

    <tr>
      <td>`assets`</td>
      <td>`string[]`</td>
      <td>Allowlisted asset mint addresses</td>
    </tr>

    <tr>
      <td>`uri`</td>
      <td>`string`</td>
      <td>Vault metadata URI</td>
    </tr>

    <tr>
      <td>`portfolioManagerName`</td>
      <td>`string`</td>
      <td>Display name of the portfolio manager</td>
    </tr>

    <tr>
      <td>`borrowable`</td>
      <td>`string[]`</td>
      <td>Assets allowed for borrowing</td>
    </tr>

    <tr>
      <td>`reduceOnly`</td>
      <td>`boolean`</td>
      <td>If true, vault can only reduce positions</td>
    </tr>

    <tr>
      <td>`anyLst`</td>
      <td>`boolean`</td>
      <td>If true, any LST is accepted for staking</td>
    </tr>

    <tr>
      <td>`timelockDuration`</td>
      <td>`number`</td>
      <td>Timelock duration in seconds</td>
    </tr>
  </tbody>
</table>

### MintModel Fields (Tokenized Vaults)

<table>
  <thead>
    <tr>
      <th>Field</th>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td>`name`</td>
      <td>`string`</td>
      <td>Token metadata name</td>
    </tr>

    <tr>
      <td>`symbol`</td>
      <td>`string`</td>
      <td>Token metadata symbol (max 32 chars)</td>
    </tr>

    <tr>
      <td>`baseAssetMint`</td>
      <td>`string`</td>
      <td>Base asset mint address</td>
    </tr>

    <tr>
      <td>`maxCap`</td>
      <td>`number`</td>
      <td>Maximum vault capacity in base units</td>
    </tr>

    <tr>
      <td>`minSubscription`</td>
      <td>`number`</td>
      <td>Minimum subscription amount in base units</td>
    </tr>

    <tr>
      <td>`minRedemption`</td>
      <td>`number`</td>
      <td>Minimum redemption amount in base units</td>
    </tr>

    <tr>
      <td>`lockupPeriod`</td>
      <td>`number`</td>
      <td>Lockup period for new shares in seconds</td>
    </tr>

    <tr>
      <td>`defaultAccountStateFrozen`</td>
      <td>`boolean`</td>
      <td>If true, new token accounts are frozen by default</td>
    </tr>

    <tr>
      <td>`feeStructure`</td>
      <td>`object`</td>
      <td>Fee configuration (see below)</td>
    </tr>

    <tr>
      <td>`notifyAndSettle`</td>
      <td>`object`</td>
      <td>Notice and settlement periods</td>
    </tr>

    <tr>
      <td>`allowlist`</td>
      <td>`string[]`</td>
      <td>Allowlisted subscriber addresses</td>
    </tr>

    <tr>
      <td>`blocklist`</td>
      <td>`string[]`</td>
      <td>Blocklisted subscriber addresses</td>
    </tr>
  </tbody>
</table>

### Example: Vault

```json theme={null}
{
  "state": {
    "accountType": "vault",
    "name": "My Treasury",
    "enabled": true,
    "baseAssetMint": "So11111111111111111111111111111111111111112",
    "assets": ["So11111111111111111111111111111111111111112"]
  }
}
```

### Example: Single Asset Vault

```json theme={null}
{
  "state": {
    "accountType": "singleAssetVault",
    "name": "USDC Vault",
    "enabled": true,
    "baseAssetMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    "assets": ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"]
  }
}
```


# Integrations
Source: https://docs.glam.systems/v1/cli/integrations



Manage protocol integrations for your vault. Integrations must be enabled before using protocol-specific commands.

For more information on available integrations, see [Integrations](/v1/platform/integrations).

## List Enabled Integrations

List all enabled integration programs and protocols for the active vault.

```bash theme={null}
glam-cli integration list
```

## Enable Protocols

Enable one or more protocols by name.

* `protocols...`: Space-separated list of protocol names

Available protocols include:

* `SplToken` - SPL token transfers
* `JupiterSwap` - Jupiter swap
* `KaminoLend` - Kamino lending
* `KaminoVaults` - Kamino vaults
* `KaminoFarms` - Kamino farms
* `CCTP` - Cross-chain token bridge

```bash theme={null}
glam-cli integration enable <protocols...> [--yes]
```

**Example:** Enable Jupiter swap and Kamino lending:

```bash theme={null}
glam-cli integration enable JupiterSwap KaminoLend
```

## Disable Protocols

Disable one or more protocols by name.

```bash theme={null}
glam-cli integration disable <protocols...> [--yes]
```

## Disable All Protocols

Disable all protocols from a specific integration program.

* `integration_program`: The integration program ID

```bash theme={null}
glam-cli integration disable-all <integration_program> [--yes]
```


# GLAM CLI
Source: https://docs.glam.systems/v1/cli/introduction

Operate with the GLAM Command Line Interface

The GLAM CLI provides a powerful command-line interface for interacting with the GLAM Protocol.

## Getting Started

<Steps>
  <Step title="Install">
    ```bash theme={null}
    npm install -g @glamsystems/glam-cli
    ```

    This installs the CLI and makes it available in the shell as `glam-cli`.
  </Step>

  <Step title="Configure">
    The GLAM CLI by default expects a configuration file at the following path:

    * **macOS / Linux**: `~/.config/glam/config.json`
    * **Windows**: `%USERPROFILE%\.config\glam\config.json`

    You can also specify a different path to the configuration using the `-C` or `--config` flag:

    ```bash theme={null}
    glam-cli -C /path/to/config.json [options] [command]
    ```

    At minimum, you need to provide `cluster`, `json_rpc_url`, and `keypair_path` in the configuration file (full list of options can be found [here](#configuration-options)):

    ```json theme={null}
    {
      "cluster": "mainnet-beta",
      "json_rpc_url": "https://api.mainnet-beta.solana.com",
      "keypair_path": "/path/to/your/keypair.json"
    }
    ```
  </Step>

  <Step title="Run">
    Check the version of the CLI:

    ```
    glam-cli -V
    ```

    Show help:

    ```
    glam-cli -h
    ```
  </Step>
</Steps>

## Commands Overview

| Command         | Description                            |
| --------------- | -------------------------------------- |
| `env`           | Display current environment setup      |
| `vault`         | Create, close, manage vaults           |
| `invest`        | Investor operations (subscribe/redeem) |
| `manage`        | Manager operations (fulfill, fees)     |
| `delegate`      | Manage vault delegates and permissions |
| `integration`   | Manage integration programs            |
| `jupiter`       | Jupiter swap                           |
| `kamino-lend`   | Kamino lending integration             |
| `kamino-vaults` | Kamino vaults integration              |
| `kamino-farms`  | Kamino farms integration               |
| `cctp`          | Cross-chain token bridge               |

## Configuration Options

* `cluster`: Value must be one of `mainnet-beta`, `devnet`, or `localnet`.
* `json_rpc_url`: The URL of your preferred Solana JSON RPC endpoint.
* `keypair_path`: Path to your keypair JSON file.
* `tx_rpc_url`: Optional. If not set it defaults to `json_rpc_url`. Use this to specify a separate RPC endpoint for landing transactions.
* `jupiter_api_key`: Required if Jupiter swap is used. Obtain an API key from the [Jupiter Developer Portal](https://portal.jup.ag/).
* `websocket_disabled`: Optional. If set to `true` the CLI will not attempt to use WebSocket methods. This can be useful if you are using a RPC provider that does not support WebSocket.
* `priority_fee`:
  * `micro_lamports`: Optional. If provided, `level` and `helius_api_key` will be ignored.
  * `level`: Optional (defaults to `Min`). Only applied if cluster is `mainnet-beta`. Other options are `Min`, `Low`, `Medium`, `High`, `VeryHigh`, `UnsafeMax`, `Default` (more info can be found [here](https://docs.helius.dev/solana-apis/priority-fee-api)).
  * `helius_api_key`: Optional. Only applied if cluster is `mainnet-beta`. If not provided `level` will be ignored. The API key is needed to call Helius priority fee endpoint.
* `glam_staging`: Optional. If set to `true` the CLI will use GLAM mainnet staging programs.
* `glam_state`: Optional. Sets the default active vault state. You can also set this later using the `set` command.

### Dynamic Priority Fee

Use this template if you have a Helius API key and want to use dynamic priority fee:

```json theme={null}
{
  "cluster": "mainnet-beta",
  "json_rpc_url": "https://your-preferred-rpc-provider.com",
  "keypair_path": "/path/to/your/keypair.json",
  "priority_fee": {
    "level": "High",
    "helius_api_key": "YOUR_HELIUS_API_KEY"
  },
}
```

The SDK will call Helius [Priority Fee API](https://www.helius.dev/docs/priority-fee-api) to get priority fee estimate in micro-lamports. The actual priority fee of a transaction is calculated as `micro_lamports * CU_consumed`.

### Static Priority Fee

If a fixed priority fee amount is preferred:

```json theme={null}
{
  "cluster": "mainnet-beta",
  "json_rpc_url": "https://your-preferred-rpc-provider.com",
  "keypair_path": "/path/to/your/keypair.json",
  "priority_fee": {
    "micro_lamports": 500000
  },
}
```

* `micro_lamports`: Specifies a fixed priority fee per CU in micro-lamports (1,000,000 micro-lamports = 1 lamport). Actual priority fee is calculated as `micro_lamports * CU_consumed`.
* Use this method when dynamic fee adjustment is unnecessary or unavailable.


# Investor Operations
Source: https://docs.glam.systems/v1/cli/invest



Commands for investors to subscribe to and redeem from tokenized vaults.

## Subscribe

Subscribe to a tokenized vault by depositing the vault's deposit asset.

* `amount`: Amount to subscribe (in deposit asset units)
* `state`: Optional vault state pubkey (uses active vault if not provided)
* `--queued`, `-q`: Subscribe in queued mode (requires manager fulfillment)

```bash theme={null}
glam-cli invest subscribe <amount> [state] [--queued] [--yes]
```

**Example:** Subscribe 100 USDC to a tokenized vault:

```bash theme={null}
glam-cli invest subscribe 100
```

**Example:** Subscribe in queued mode:

```bash theme={null}
glam-cli invest subscribe 100 --queued
```

## Claim Subscription

Claim share tokens after a queued subscription has been fulfilled by the manager.

```bash theme={null}
glam-cli invest claim-subscription
```

## Redeem

Request to redeem share tokens from a tokenized vault.

* `amount`: Amount of share tokens to redeem

```bash theme={null}
glam-cli invest redeem <amount> [--yes]
```

## Claim Redemption

Claim the deposit asset after a redemption request has been fulfilled.

```bash theme={null}
glam-cli invest claim-redemption
```

## Cancel Request

Cancel a pending queued subscription or redemption request.

```bash theme={null}
glam-cli invest cancel-request [--yes]
```


# Jupiter Swap
Source: https://docs.glam.systems/v1/cli/jupiter

Execute token swaps through Jupiter aggregator

Commands for swapping tokens using Jupiter aggregator.

<Note>
  The `JupiterSwap` integration must be enabled before using these commands:

  ```bash theme={null}
  glam-cli integration enable JupiterSwap
  ```
</Note>

## Swap

Swap tokens held in the vault using Jupiter.

* `from`: Source token (mint address or symbol like `SOL`, `USDC`)
* `to`: Destination token (mint address or symbol)
* `amount`: Amount to swap (in source token units)
* `--slippage-bps`, `-s`: Slippage tolerance in basis points (default: 5, which is 0.05%)
* `--max-accounts`, `-m`: Maximum accounts allowed in the swap route
* `--only-direct-routes`, `-d`: Only use direct swap routes
* `--use-v2`: Use Jupiter v2 instruction

```bash theme={null}
glam-cli jupiter swap <from> <to> <amount> [options] [--yes]
```

**Example:** Swap 1 SOL to USDC:

```bash theme={null}
glam-cli jupiter swap SOL USDC 1
```

**Example:** Swap with custom slippage:

```bash theme={null}
glam-cli jupiter swap SOL USDC 1 --slippage-bps 50
```

***

## Policy Management

Jupiter swap policies allow you to restrict which tokens can be swapped and set maximum slippage limits.

### View Policy

View the current Jupiter swap policy for the vault.

```bash theme={null}
glam-cli jupiter view-policy
```

### Set Maximum Slippage

Set the maximum allowed slippage for swaps in basis points.

* `slippage_bps`: Maximum slippage in basis points (e.g., 100 = 1%)

```bash theme={null}
glam-cli jupiter set-max-slippage <slippage_bps> [--yes]
```

### Allowlist Token

Add a token to the swap allowlist. When tokens are allowlisted, swaps are restricted to only those tokens.

```bash theme={null}
glam-cli jupiter allowlist-token <token_mint> [--yes]
```

### Remove Token from Allowlist

Remove a token from the swap allowlist.

```bash theme={null}
glam-cli jupiter remove-token <token_mint> [--yes]
```

### Clear Allowlist

Clear the swap allowlist to allow swapping any token.

```bash theme={null}
glam-cli jupiter clear-allowlist [--yes]
```


# Kamino
Source: https://docs.glam.systems/v1/cli/kamino

Interact with Kamino Lending, Vaults, and Farms

Commands for interacting with Kamino Lending, Vaults, and Farms.

<Note>
  The `Kamino` integration must be enabled before using these commands:

  ```bash theme={null}
  glam-cli integration enable KaminoLend KaminoVaults KaminoFarms
  ```
</Note>

***

## Kamino Lending

### Initialize User

Initialize a Kamino lending user account for the vault.

```bash theme={null}
glam-cli kamino-lend init
```

### List Positions

List Kamino lending deposits and borrows.

* `market`: Optional market public key to filter by

```bash theme={null}
glam-cli kamino-lend list [market]
```

### Deposit

Deposit an asset to a Kamino lending market.

* `market`: Market public key
* `asset`: Asset mint public key
* `amount`: Amount to deposit

```bash theme={null}
glam-cli kamino-lend deposit <market> <asset> <amount> [--yes]
```

**Example:** Deposit 1 SOL to the main market:

```bash theme={null}
glam-cli kamino-lend deposit 7u3HeHxYDLhnCoErrtycNokbQYbWGzLs6JSDqGAv5PfF So11111111111111111111111111111111111111112 1
```

### Withdraw

Withdraw an asset from a Kamino lending market.

```bash theme={null}
glam-cli kamino-lend withdraw <market> <asset> <amount> [--yes]
```

### Borrow

Borrow an asset from a Kamino lending market.

```bash theme={null}
glam-cli kamino-lend borrow <market> <asset> <amount> [--yes]
```

### Repay

Repay a borrowed asset to a Kamino lending market.

```bash theme={null}
glam-cli kamino-lend repay <market> <asset> <amount> [--yes]
```

### Policy Management

#### View Policy

```bash theme={null}
glam-cli kamino-lend view-policy
```

#### Allowlist Market

```bash theme={null}
glam-cli kamino-lend allowlist-market <market> [--yes]
```

#### Remove Market

```bash theme={null}
glam-cli kamino-lend remove-market <market> [--yes]
```

#### Allowlist Borrowable Asset

```bash theme={null}
glam-cli kamino-lend allowlist-borrowable-asset <asset> [--yes]
```

#### Remove Borrowable Asset

```bash theme={null}
glam-cli kamino-lend remove-borrowable-asset <asset> [--yes]
```

***

## Kamino Vaults

### Deposit

Deposit to a Kamino vault.

* `vault`: Kamino vault public key
* `amount`: Amount to deposit

```bash theme={null}
glam-cli kamino-vaults deposit <vault> <amount> [--yes]
```

### Withdraw

Withdraw from a Kamino vault.

* `amount`: Number of vault shares to withdraw

```bash theme={null}
glam-cli kamino-vaults withdraw <vault> <amount> [--yes]
```

### Policy Management

#### View Policy

```bash theme={null}
glam-cli kamino-vaults view-policy
```

#### Allowlist Vault

```bash theme={null}
glam-cli kamino-vaults allowlist-vault <vault> [--yes]
```

#### Remove Vault

```bash theme={null}
glam-cli kamino-vaults remove-vault <vault> [--yes]
```

***

## Kamino Farms

### List Farms

List Kamino farms where the GLAM vault has unclaimed rewards.

```bash theme={null}
glam-cli kamino-farms list
```

### Harvest Rewards

Harvest rewards from Kamino farms.

* `farm_states...`: Space-separated farm state public keys

```bash theme={null}
glam-cli kamino-farms harvest <farm_states...> [--yes]
```

### Stake

Stake tokens to a delegated farm.

```bash theme={null}
glam-cli kamino-farms stake <farm_state> <amount> [--yes]
```

### Unstake

Unstake tokens from a delegated farm.

```bash theme={null}
glam-cli kamino-farms unstake <farm_state> <amount> [--yes]
```


# Manager Operations
Source: https://docs.glam.systems/v1/cli/manage



Commands for vault managers to operate tokenized vaults, including pricing, fulfillment, and fee management.

## Price Vault

Update the pricing for vault assets. This is for debugging purpose only and you don't need to call it manually before performing fulfillment of subscriptions and redemptions (relevant instructions are automatically included in those transactions).

```bash theme={null}
glam-cli manage price
```

## Fulfill Requests

Fulfill queued subscription and redemption requests from investors.

```bash theme={null}
glam-cli manage fulfill
```

## Claim Fees

Claim management and performance fees collected by the tokenized vault.

```bash theme={null}
glam-cli manage claim-fees
```

## List Requests

List pending subscription and redemption requests in the queue. Displays each request's user, type, amounts, status, and creation date.

```bash theme={null}
glam-cli manage list-requests
```

## Cancel for User

Cancel a queued subscription or redemption request on behalf of a user.

* `pubkey`: Public key of the user whose request to cancel

```bash theme={null}
glam-cli manage cancel-for-user <pubkey> [--yes]
```

## Claim for User

Claim a fulfilled subscription or redemption request on behalf of a user.

* `pubkey`: Public key of the user to claim for

```bash theme={null}
glam-cli manage claim-for-user <pubkey> [--yes]
```

## Update Minimums

### Update Minimum Subscription

Set the minimum subscription amount for the vault.

```bash theme={null}
glam-cli manage update-min-subscription <amount> [--yes]
```

### Update Minimum Redemption

Set the minimum redemption amount for the vault.

```bash theme={null}
glam-cli manage update-min-redemption <amount> [--yes]
```

## Pause/Unpause Operations

### Pause

Pause subscription or redemption operations.

* `action`: Either `subscription` or `redemption`

```bash theme={null}
glam-cli manage pause <subscription|redemption> [--yes]
```

### Unpause

Resume subscription or redemption operations.

```bash theme={null}
glam-cli manage unpause <subscription|redemption> [--yes]
```


# Staking
Source: https://docs.glam.systems/v1/cli/staking

Stake SOL via native staking, LST pools, or Marinade

<Warning>
  Staking integrations (Native Stake, LST Stake Pools, and Marinade) are only supported in staging programs. Code is pending audit. Use the `--bypass-warning` flag to acknowledge and proceed.
</Warning>

## Native Staking

Manage native Solana stake accounts through the vault.

### List Stake Accounts

List all stake accounts owned by the vault:

```bash theme={null}
glam-cli stake list
```

Displays each stake account's address, lamport balance, and state (e.g., `active`, `deactivating`, `inactive`).

### Deactivate Stake Accounts

Deactivate one or more stake accounts:

```bash theme={null}
glam-cli stake deactivate <accounts...> [--yes]
```

* `<accounts...>`: Space-separated public keys of stake accounts to deactivate

### Withdraw from Stake Accounts

Withdraw SOL from deactivated stake accounts back to the vault:

```bash theme={null}
glam-cli stake withdraw <accounts...> [--yes]
```

* `<accounts...>`: Space-separated public keys of stake accounts to withdraw from

## LST Stake Pools

Stake SOL into liquid staking token (LST) pools or unstake LSTs back to SOL.

### Stake SOL

Stake SOL into a stake pool and receive LST tokens:

```bash theme={null}
glam-cli lst stake <stakepool> <amount> [--yes]
```

* `<stakepool>`: The stake pool address
* `<amount>`: Amount of SOL to stake

### Unstake LST

Unstake LST tokens and receive SOL in a stake account:

```bash theme={null}
glam-cli lst unstake <asset> <amount> [--deactivate] [--yes]
```

* `<asset>`: The LST mint address
* `<amount>`: Amount of LST to unstake
* `--deactivate`, `-d`: Automatically deactivate the resulting stake account

## Marinade

Stake and unstake SOL through Marinade Finance.

### Stake SOL (mSOL)

Stake SOL and receive mSOL:

```bash theme={null}
glam-cli marinade stake <amount> [--yes]
```

### Stake SOL (Native)

Stake SOL through Marinade Native (no mSOL token, direct stake account):

```bash theme={null}
glam-cli marinade stake-native <amount> [--yes]
```

### Withdraw Stake

Withdraw mSOL into a stake account:

```bash theme={null}
glam-cli marinade withdraw-stake <amount> [--deactivate] [--yes]
```

* `<amount>`: Amount of mSOL to withdraw
* `--deactivate`, `-d`: Automatically deactivate the resulting stake account


# Timelock
Source: https://docs.glam.systems/v1/cli/timelock



Commands for managing vault timelock settings. Timelocks add a delay before certain vault changes take effect, providing additional security.

For more information on timelocks, see [Timelock](/v1/operations/timelock).

## View Timelock

View the current timelock configuration and any pending changes.

```bash theme={null}
glam-cli timelock view
```

## Set Timelock Duration

Set the timelock duration in seconds. Changes to the vault will require this delay before taking effect.

* `duration`: Duration in seconds

```bash theme={null}
glam-cli timelock set <duration> [--yes]
```

**Example:** Set a 24-hour timelock:

```bash theme={null}
glam-cli timelock set 86400
```

## Apply Timelocked Changes

Apply pending timelocked changes after the timelock period has passed.

```bash theme={null}
glam-cli timelock apply [--yes]
```

## Cancel Pending Changes

Cancel any pending timelocked changes.

```bash theme={null}
glam-cli timelock cancel [--yes]
```


# Token Transfers
Source: https://docs.glam.systems/v1/cli/transfer

Send SPL tokens out of the vault and manage destination allowlists

Commands for transferring tokens out of the vault.

<Note>
  The `SplToken` integration must be enabled before using these commands:

  ```bash theme={null}
  glam-cli integration enable SplToken
  ```
</Note>

## Transfer Tokens

Transfer SPL tokens from the vault to a destination address.

* `amount`: Amount to transfer
* `to`: Destination public key
* `--token`, `-t`: Token mint address (defaults to wSOL)

```bash theme={null}
glam-cli transfer <amount> <to> [--token <mint>] [--yes]
```

**Example:** Transfer 10 USDC:

```bash theme={null}
glam-cli transfer 10 Recipient111111111111111111111111 --token EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v
```

***

## Policy Management

Token transfer policies allow you to restrict which addresses can receive transfers from the vault.

### View Policy

View the current token transfer policy.

```bash theme={null}
glam-cli transfer view-policy
```

### Allowlist Destination

Add a destination address to the transfer allowlist. When destinations are allowlisted, transfers are restricted to only those addresses.

```bash theme={null}
glam-cli transfer allowlist-destination <pubkey> [--yes]
```

### Remove Destination

Remove a destination address from the transfer allowlist.

```bash theme={null}
glam-cli transfer remove-destination <pubkey> [--yes]
```


# Disclaimer
Source: https://docs.glam.systems/v1/disclaimer



<Warning>
  GLAM is under active development with potential breaking changes. Use at own risk – no warranties given. We assume no liability. Content is for informational purposes only.
</Warning>

### 1. Introduction[](#id-1.-introduction)

We welcome you to **GLAM's unaudited, experimental beta version, comprising GLAM Protocol, GLAM API, GLAM SDK, GLAM GUI, and any other related components (collectively "GLAM")**. By accessing or using any component of GLAM, you acknowledge that you have read, understood, and agree to be bound by this disclaimer. If you do not agree, please refrain from using any GLAM components.

### 2. Active Development Notice[](#id-2.-active-development-notice)

GLAM is currently under **active development**. Features may change without notice, and **breaking changes** could occur. The software may not function as intended.

### 3. Use at Your Own Risk[](#id-3.-use-at-your-own-risk)

* GLAM is provided on an "**as is**" and "**as available**" basis **without warranties of any kind**, either express or implied.

* **You assume all risks** associated with using GLAM.

* We **strongly recommend** not storing significant amounts of cryptoassets on the platform during the beta phase.

### 4. Risk Acknowledgment[](#id-4.-risk-acknowledgment)

* **Security Risks:** The software may contain bugs, errors, or security vulnerabilities that could lead to unauthorized access, data breaches, or other security incidents.

* **Financial Risks:** There is a potential for **partial or total loss of cryptoassets** due to software issues or security breaches.

* **Operational Risks:** GLAM may experience interruptions, delays, or errors.

### 5. Limitation of Liability[](#id-5.-limitation-of-liability)

GLAM **shall not be liable** for any direct, indirect, incidental, consequential, or exemplary damages arising from the use or inability to use GLAM. This includes, but is not limited to, loss of cryptoassets, data loss, or security breaches.

### 6. No Warranties[](#id-6.-no-warranties)

GLAM makes **no warranties or representations** about the accuracy or completeness of GLAM's content or the content of any services linked to any GLAM component. We do not warrant that:

* GLAM will meet your requirements.

* GLAM will be uninterrupted, timely, secure, or error-free.

* Any errors or defects will be corrected.

### 7. User Responsibility[](#id-7.-user-responsibility)

* **Security Measures:** You are responsible for safeguarding your private keys, passwords, and any other security credentials. GLAM does not have access to your private keys or passwords.

* **Due Diligence:** Exercise caution and conduct your own due diligence before making any decisions based on the information provided by GLAM.

### 8. Legal Jurisdiction[](#id-8.-legal-jurisdiction)

This disclaimer is governed by and construed in accordance with the laws of **Switzerland**. Any disputes arising out of or in connection with this disclaimer shall be subject to the exclusive jurisdiction of the courts of Switzerland.

### 9. Contact Information[](#id-9.-contact-information)

For inquiries or to report issues, please contact us at:

* **Email:** [hello@glam.systems](mailto:hello@glam.systems)

### 10. Privacy Notice[](#id-10.-privacy-notice)

GLAM may collect certain non-personal usage data to improve our services, perform bug fixes, and enhance user experience. This may include information such as:

* **Device Information:** Type of device, operating system, browser type, and version.

* **Usage Data:** Pages visited, features used, time and date of access, and other diagnostic data.

* **Error Reports:** Crash reports and performance data to help us identify and fix issues.

We may utilize third-party analytics services such as Google Analytics, Umami, Mixpanel, or PostHog to collect and analyze this data.

* **Third-Party Services:** These services may use cookies or similar tracking technologies to collect and analyze information about your use of GLAM. The data collected is generally aggregated and anonymized.

**Personal Data:**

* **No Collection of Personal Identifiable Information (PII):** We do not collect or store any personal data that can be used to identify you without your explicit consent.

A formal **Privacy Policy** detailing our data collection, use, and storage practices will be provided in future updates. By using GLAM, you consent to the collection and use of information as outlined above.

### 11. Updates to This Disclaimer[](#id-11.-updates-to-this-disclaimer)

We may update this disclaimer from time to time. **Continued use** of GLAM constitutes your acceptance of any changes. Please review this disclaimer periodically for updates.

### 12. Nature of Information[](#id-12.-nature-of-information)

All content available through GLAM is general in nature and not tailored to any particular person

Information is provided for informational purposes only

Content should not be considered investment advice or a recommendation to transact in any cryptoassets

### 13. Informational Purposes

While GLAM provides information about cryptoassets and related technologies, users should not rely solely on this information for making investment decisions. We encourage users to conduct their own research and seek professional advice when necessary.

### 14. Performance Information

Any performance information or historical data presented through GLAM must be considered in conjunction with applicable disclosures. Past performance is not indicative of future results. The cryptoasset market is highly volatile and unpredictable.

### 15. Third-Party Content

GLAM may include content from third-party sources. While we strive to provide accurate and up-to-date information, we do not endorse or guarantee the accuracy, completeness, or reliability of any third-party content. Users should exercise caution and critical thinking when interpreting such information.

### 16. Regulatory Compliance

Users are responsible for ensuring their use of GLAM complies with all applicable laws and regulations in their jurisdiction. Cryptoasset regulations vary by country and are subject to change. GLAM does not guarantee the legality of its services in all jurisdictions.

### 17. Professional Advice

Given the complex nature of cryptoassets and the potential risks involved, we strongly recommend that users consult with qualified professionals, including legal and tax advisors, before making any decisions based on the information provided by GLAM.


# Fees
Source: https://docs.glam.systems/v1/operations/fees



Tokenized Vaults can be configured with flexible fees based on manager preferences and underlying strategies. All fees are charged in the form of vault shares.

## Overview

| Category                       | Fee Type         | Description                                                                                               |
| :----------------------------- | :--------------- | :-------------------------------------------------------------------------------------------------------- |
| [**Vault**](#vault-fees)       | **Subscription** | Charged on deposits as a percentage of issued shares. Burned to retain value in the vault.                |
|                                | **Redemption**   | Charged on withdrawals as a percentage of redeemed shares. Burned to retain value in the vault.           |
| [**Manager**](#manager-fees)   | **Subscription** | Charged on deposits as a percentage of issued shares. Claimable by the manager.                           |
|                                | **Redemption**   | Charged on withdrawals as a percentage of redeemed shares. Claimable by the manager.                      |
|                                | **Management**   | Charged over time based on AUM. Paid in newly issued shares claimable by the manager.                     |
|                                | **Performance**  | Charged on profits above high water mark or hurdle. Paid in newly issued shares claimable by the manager. |
| [**Protocol**](#protocol-fees) | **Base**         | Charged over time based on AUM. Paid in newly issued shares claimable by the protocol.                    |
|                                | **Flow**         | Charged as a percentage of manager fees. Paid in shares claimable by the protocol.                        |

## Vault Fees

Vault fees serve to protect both investors and the long term integrity of the vault. Instead of leaving the system or going to external parties, the fees are burned. This reduces overall supply and effectively reinvests value back into the vault without requiring any token flows.

<Info>
  For efficiency, these fees may be implicitly burned by never being minted, achieving the same supply-reduction effect as a traditional mint-and-burn mechanism.
</Info>

### Subscription

The subscription fee is applied when a user deposits funds into a vault. It is calculated as a percentage of the shares that would otherwise be issued based on the vault’s Net Asset Value (NAV). The fee is burned, reducing the number of shares issued and preserving value for existing holders.

For example, if a user deposits 1,000 USDC into a vault with a NAV of 1 and a subscription fee of 0.1 percent:

* $\text{Gross Shares} = \frac{1{,}000}{1} = 1{,}000$
* $\text{Net Shares Subscribed} = 1{,}000 \times (1 - 0.001) = 999$

The user receives 999 shares. One share is burned as the subscription fee.

### Redemption

The redemption fee is applied when a user withdraws from a vault by redeeming shares. It is calculated as a percentage of the shares being redeemed. The fee is burned, reducing total share supply and preserving value for remaining holders.

For example, if a user redeems 1,000 shares from a vault with a 0.1 percent redemption fee:

* $\text{Fee} = 1{,}000 \times 0.001 = 1$
* $\text{Net Shares Redeemed} = 1{,}000 - 1 = 999$

The user receives assets based on 999 shares. One share is burned as the redemption fee.

## Manager Fees

Manager fees are charged to compensate the vault manager for operating and maintaining the strategy. Unlike vault fees, these shares are **claimable by the manager** and represent a source of revenue rather than being burned.

### Subscription

The manager subscription fee is applied when a user deposits funds into a vault. It is calculated as a percentage of the shares issued for the deposit. These shares are allocated to the manager.

For example, if a user deposits 1,000 USDC into a vault with a NAV of 1 and a manager subscription fee of 0.1 percent:

* $\text{Gross Shares} = \frac{1{,}000}{1} = 1{,}000$
* $\text{Net Shares Subscribed} = 1{,}000 \times (1 - 0.001) = 999$

The user receives 999 shares. One share is issued to the manager as the fee.

### Redemption

The manager redemption fee is applied when a user withdraws by redeeming shares. It is calculated as a percentage of the redemption amount. The fee is claimable by the manager.

For example, if a user redeems 1,000 shares from a vault with a manager redemption fee of 0.1 percent:

* $\text{Fee} = 1{,}000 \times 0.001 = 1$
* $\text{Net Shares Redeemed} = 1{,}000 - 1 = 999$

The user receives assets based on 999 shares. One share is allocated to the manager as the fee.

### Management

The management fee is a time-based fee charged as a percentage of AUM (assets under management), regardless of vault performance.

Considering an annual management fee, at any time $t_1$, the fee is calculated as:

* $\text{Management Fee} = AUM_{t_1} \times \frac{t_1 - t_0}{\text{time\_units}} \times \text{fee\_pct}$

Where:

* $AUM_{t_1}$ = assets under management at $t_1$
* $t_0$ = the time the management fee was last crystallized
* $\text{time\_units}$ = number of time units in one year (GLAM supports `Second` and `Slot`)
* $\text{fee\_pct}$ = annual management fee

The management fee is distributed by issuing new shares that can be claimed by the manager.

### Performance

The performance fee is charged on profits and is typically based on a high water mark (HWM) and an optional hurdle rate. It is claimable by the manager and paid in newly issued shares.

#### High Water Mark (HWM)

The HWM represents the highest Net Asset Value (NAV) per share a vault has reached after a performance fee was last crystallized. Performance fees are only charged on profits above this threshold.

If:

* $NAV_{\text{current}} > HWM$

Then:

* $\text{Performance Fee} = (\text{NAV}_{\text{current}} - HWM) \times \text{Shares} \times \text{fee\_pct}$

This ensures managers cannot charge fees for recovering prior losses.

#### Hurdle Rate

The hurdle rate is a minimum return threshold that must be exceeded before performance fees can be charged. GLAM supports fixed hurdle rates.

Two modes are supported:

* **Soft Hurdle**: If the vault return exceeds the hurdle, performance fees apply to all profits.
* **Hard Hurdle**: Performance fees apply only to profits above the hurdle.

**Example (Hard Hurdle):**\
If the hurdle rate is 5 percent and the vault return is 8 percent, the performance fee only applies to the 3 percent excess.

HWM and hurdle logic are evaluated at the time of fee crystallization, and fees are distributed as claimable shares to the manager.

## Protocol Fees

Protocol fees compensate the GLAM protocol for maintaining and securing the infrastructure. These fees are charged at the vault level and are claimable by the protocol.

<Info>
  Please note that the current protocol fee model reflects early-adopter pricing. We will maintain this structure through June 30, 2026, while continuing to evaluate and refine our long-term fee model.
</Info>

### Base

The base fee is a time-based fee, charged as a percentage of AUM, similar to the manager's management fee. It is paid by issuing new shares to the protocol.

The base fee is fixed at **0.2 percent** (20 basis point) annually for all tokenized vaults.

If:

* $AUM_{t_1}$ = assets under management at time $t_1$
* $t_0$ = the time the base fee was last crystallized
* $\text{time\_units}$ = number of time units in one year (GLAM supports `Second` and `Slot`)
* $\text{base\_rate}$ = base fee rate (default 0.002)

Then:

* $\text{Base Fee} = AUM_{t_1} \times \frac{t_1 - t_0}{\text{time\_units}} \times \text{base\_rate}$

<Info>
  If your strategy requires custom pricing, please contact us at [hello@glam.systems](mailto:hello@glam.systems).
</Info>


# Flows
Source: https://docs.glam.systems/v1/operations/flows



Shares of tokenized vaults are tokenized. When a user subscribes, the amount of vault shares to issue is calculated based on the current AUM of the vault. When a user redeems their shares, the shares get burned and withdrawal assets can be claimed.

## Subscriptions

GLAM tokenized vaults support two types of subscriptions: **instant** subscription and **queued** subscription.

<Frame>
  <img />

  <img />
</Frame>

### Instant Subscriptions

Vault shares are issued in the same transaction where the user makes the deposit. Instant subscription is preferred if vault AUM can be immediately calculated and the amount of shares can be determined instantly.

### Queued Subscriptions

In case vault AUM can only be calculated with a delay, queued subscription should be used. The diagram below shows the subscription flow:

## Redemptions

GLAM tokenized vaults support both **instant** and **queued** redemptions, depending on the strategy and configuration of the vault.

<Frame>
  <img />

  <img />
</Frame>

### Instant Redemptions

Instant redemption allows users to redeem shares and receive withdrawal assets in a single transaction. This mode is enabled when the vault’s **notice period** and **settlement period** are both set to **0**.

Instant redemption is only possible if the vault has sufficient liquidity to fulfill the request at the time of redemption.

This mode is recommended for tokenized vaults with simple, highly liquid strategies (e.g., token baskets).

### Queued Redemptions

If the vault is configured with a non-zero notice period or settlement period, redemptions are queued and expected to be fulfilled asynchronously.

When a user submits a redemption request, it is timestamped and placed in a queue. Once the request becomes eligible (based on the notice period and settlement period), it can be fulfilled. After fulfillment, the user must initiate a claim transaction to complete the redemption.

Queued redemption is recommended for strategies that require liquidity management, batching, or time to unwind positions.

## Execution Window

<Frame>
  <img />

  <img />
</Frame>

### Notice Period

The **notice period** is the configured lead time for a queued subscription or redemption request. It is measured in seconds or slots. How it affects fulfillment eligibility depends on the notice period type.

GLAM supports two notice period types:

* **Hard**: Requests become eligible only after the notice period has fully elapsed.
* **Soft**: Requests are eligible immediately if liquidity is available; the notice period is advisory and does not block early fulfillment.

For both types, the configured notice period is still used when calculating cancellation and execution-window boundaries.

**Choosing a type:**

* Use **Hard** when the manager genuinely needs lead time, or when fulfillment must align to a known cutoff:
  * Strategy-bound assets that take time to unwind: lending positions (Kamino, Drift), LP positions, perps, native validator unstaking that is gated by epoch boundaries.
  * Periodic-NAV or batched funds, where a hard notice aligns requests to a known valuation cutoff and prevents acting on stale or pre-rebalance NAV.
  * Fairness and anti-timing: forces a minimum gap between request and execution, so users cannot front-run a NAV update, fee crystallization, or a large rebalance.
* Use **Soft** for stable, mostly-cash or DEX-liquid vaults where the manager can net requests instantly against on-hand liquidity. Liquid staking vaults that hold tradeable LSTs (e.g. JitoSOL, mSOL) typically fit here; vaults that perform native validator unstaking should use Hard.

### Settlement Period

The **settlement period** defines the maximum duration after the notice period during which a request can be fulfilled. It ensures that requests are processed in a timely manner and provides a bounded execution window for managers or external actors.

### Cancellation Window

The **cancellation window** defines the duration after submitting a request during which it can be cancelled. This must be less than or equal to the notice period.

A request is cancellable under two conditions:

1. **Within the cancellation window**: The request was recently created and is still within the cancellation window (`created_at + cancellation_window > now`). This gives users a grace period to cancel immediately after submitting a request.
2. **After the execution window has expired**: The request has passed both the notice period and settlement period (`created_at + notice_period + settlement_period < now`). This protects investors by allowing them to reclaim their assets if the manager fails to fulfill the request within the promised timeframe.

Between these two windows — after the cancellation window closes but before the execution window expires — the request is locked and cannot be cancelled.

Queued requests can be cancelled by:

* The user who submitted the request.
* The vault owner.
* An active delegate with the Mint `CancelRequest` permission.

When a request is cancelled, the escrowed deposit assets or vault shares are returned to the request user's associated token account.

### Permissionless Fulfillment

If **permissionless fulfillment** is enabled, any actor including users and bots can fulfill eligible requests once they enter the settlement window. If it is disabled, only the vault manager is authorized to trigger fulfillment.

### Fulfillment Order

Fulfillment scans the request queue in **FIFO** insertion order. Requests are appended when submitted, and the fulfillment routine walks the queue oldest-first. It processes eligible, unfulfilled requests in that scan order; requests that are not yet eligible (for hard notice periods) or already fulfilled are skipped without stopping the scan.

Within a single fulfillment call, subscriptions and redemptions **net out** against each other. It aggregates the share and base-asset deltas across the processed eligible requests and settles only the net difference. Shares are minted or burned once for the net delta, and base asset moves between the vault and escrow only by the net amount. Incoming subscription deposits processed earlier in the same batch therefore count as available liquidity for redemptions processed later in the queue.

If a redemption cannot be paid out because the vault and earlier in-batch subscription deposits still lack sufficient base asset liquidity, fulfillment **stops** at that request. The redemption stays unfulfilled at its existing queue position and will be retried on a later fulfillment call once liquidity is available.


# Pricing
Source: https://docs.glam.systems/v1/operations/pricing



Tokenized Vaults and Single Asset Vaults require accurate pricing to function correctly. Subscription and redemption flow require a precise calculation of Assets Under Management (AUM) in order to issue or burn vault shares. To determine AUM, GLAM prices each individual asset (token or DeFi position) held by the vault and sums them up:

<br />

$$
\text{AUM} = \sum_{t \in \text{Tokens}} v_t + \sum_{j \in \text{KaminoLending}} v_j + \cdots
$$

Where:

* $v_t$ is the value of each individual token held by the vault
* $v_j$ is the value of each individual position in Kamino Lending

Vaults are priced in their base asset. Tokenized Vaults depend on a curated set of oracles to be priced. Single Asset Vaults do not need any external oracle as they only hold one asset (i.e., the base asset), so AUM is derived directly from the balance of that asset.

## How Pricing Works Onchain

<Frame>
  <img />

  <img />
</Frame>

For integrated protocols like Kamino, we implement the protocol's native calculation, including underlying fees.

The pricing process involves the following steps:

* Any transaction that requires AUM must include price instructions for all enabled protocols. These instructions save per-protocol price data to the GLAM State Account's `PricedProtocols` field.
* AUM is calculated by summing the valuations in `PricedProtocols`. Validations ensure all vault assets and positions use fresh oracle data.
* NAV (Net Asset Value) is calculated as AUM divided by the total share supply.
  * For subscriptions, the number of shares to issue is calculated from NAV and the subscription amount, subject to applicable fees.
  * For redemptions, the payout amount is calculated from NAV and the number of shares being redeemed, subject to applicable fees.

### Consuming Pricing Data

The `PricedProtocols` field provides the source of truth for current AUM. To get a fresh valuation onchain, a transaction must include the `price` instructions to cover all enabled protocols, optionally followed by the `validate_aum` instruction that validates the correctness.

Do not use `FeeParams` as the source of truth for current AUM or NAV. `FeeParams`'s `last_aum`, `pa_last_nav`, and high-water-mark fields are fee-accounting checkpoints from fee crystallization, not live valuation fields.

## Functional Pricing for LSTs

For liquid staking tokens (LSTs), GLAM uses functional pricing whenever possible. Each LST (like mSOL, jitoSOL, bSOL, etc.) represents a claim on staked SOL plus staking rewards, therefore they have an intrinsic value backed by SOL in the pool. The conversion rate is derived onchain from the LST's pool state account:

$$
\text{ConversionRate} = \frac{\text{Stake Pool SOL Balance}}{\text{LST Token Supply}}
$$

With the conversion rate, GLAM derives the functional price of the LST as:

$$
\text{FuncPrice} = \text{SOL Price (USD)} \times \text{ConversionRate}
$$

### Benefits of Functional Pricing

* **Depeg Protection**: Protects users from temporary market depegging events where LST spot prices may trade below their intrinsic value
* **Accurate Valuation**: Reflects the true underlying value based on staked SOL and accrued rewards, not market sentiment
* **Reduced Manipulation Risk**: Eliminates the risk of oracle manipulation or flash loan attacks on LST spot prices
* **Consistent Pricing**: Provides stable, predictable pricing that follows the actual staking yield mechanics
* **Fair Entry/Exit**: Ensures users receive fair value when subscribing to or redeeming from vaults holding LSTs


# Rent
Source: https://docs.glam.systems/v1/operations/rent



On Solana, every account must maintain a minimum balance of SOL as "rent", which ensures the network can sustainably store its data and prevents inactive or unused accounts from occupying onchain space indefinitely.

In GLAM, account creation costs are always covered by the operator, technically referred to as the `fee payer` when constructing a transaction (such as the vault owner or delegate). When an account is closed, the recovered SOL is returned to the current operator.

This design ensures that operational funds remain separate from the vault’s asset valuation and prevents commingling of funds.

<Warning>
  Some accounts cannot be closed due to underlying protocol limitations, making the rent paid by the operator unrecoverable.
</Warning>


# Timelock
Source: https://docs.glam.systems/v1/operations/timelock



A timelock introduces a delay between when a change is proposed and when it can take effect. This delay helps safeguard users and vaults by making critical actions visible in advance and giving time to respond before execution.

GLAM vaults support configurable timelocks on sensitive actions such as policy updates, fee changes, integration settings, and access control modifications. Timelocks can be set by the manager during deployment or while the vault is active, depending on its permissions.

Proposed changes can only be applied once all pending redemptions are fulfilled. This ensures users are not subject to modified vault parameters after submitting a redemption request.

Timelocks enhance both security and transparency:

<CardGroup>
  <Card title="Security" icon="shield-check">
    Timelocks prevent sudden or unauthorized changes.

    ***

    *Example*: If a vault manager’s private key is compromised, an attacker might attempt to whitelist a malicious token and swap vault assets into it. With a two-day timelock enabled, the change cannot be executed immediately. This gives managers and users a two-day window to detect the action and take steps to intervene before it is applied.
  </Card>

  <Card title="Transparency" icon="eye">
    Timelocks make proposed changes visible before execution.

    ***

    *Example*: A manager proposes increasing the annual performance fee from 20 percent to 25 percent. With a seven-day timelock enabled, the change cannot be executed immediately. This gives users a seven-day window to review the proposal and decide whether to remain in the vault or redeem before the change is applied.
  </Card>
</CardGroup>

Timelock settings and pending changes are fully visible onchain and through the GLAM interface, ensuring auditability and informed participation. By introducing a mandatory delay, timelocks strengthen safety guarantees while preserving user choice.

<Warning>
  The protocol does not enforce that the timelock duration must exceed the vault’s redemption period. Managers are responsible for setting appropriate configurations to ensure users have enough time to react before changes take effect.
</Warning>


# Concepts
Source: https://docs.glam.systems/v1/platform/concepts

Concepts and terminology for understanding GLAM

## GLAM State

Each GLAM vault, whether tokenized or non-tokenized, has a unique state account that stores metadata, states, configurations, and policies.

## Vault

A Vault is a system account with a PDA derived from the GLAM Protocol program:

* It holds all assets (SOL, tokens) and DeFi positions (e.g., Kamino vault shares).
* It provides programmable management of onchain assets with embedded risk controls.
* Access is strictly gated by access control rules.

## Mint

A Mint is a [Token-2022 Program](https://spl.solana.com/token-2022) account that uniquely identifies a token. Every GLAM tokenized vault has an associated mint:

* The mint address is a PDA derived from the GLAM Mint program
* Token-2022 extensions are enabled, including metadata, transfer hook, and default account state
* Mint tokens represent vault shares—new tokens are issued during subscriptions, and tokens are burned during redemptions

## Subscriber

A subscriber is a user who deposits assets into a tokenized vault and receives vault shares in return. Depending on the vault configuration, subscribers may or may not be required to complete KYC verification.

## Owner

The terms "owner" and "manager" are used interchangeably, both referring to the owner of a vault.

* Vault owner has admin access to the vault. They are exempt from delegate access control policies, however, they are still subject to vault policies and timelocks.
* Vault owner can propose changes if timelock is enforced and transfer ownership to another address.
* It is recommended to use hardware wallets or multisig for enhanced security, while granting delegate permissions for routine operations.

## Delegate

A delegate is a public key that is granted specific vault permissions by the owner.

* Multiple delegates can be added to a vault, each with a different set of permissions.
* Only vault owner can grant delegate permissions.

## Integration

An integration is a program that bridges GLAM vaults and external DeFi protocols. No integrations are enabled by default, and vault owners should only enable those required for their investment strategy to minimize attack surface and operational risks. For example, if a vault strategy does not require Kamino protocols, the Kamino integration should remain disabled.

## Access Control List (ACL)

An ACL is a list of rules that specify which users or entities are granted or denied access and what operations they can perform. GLAM allows vault owners to set up ACLs for both integrations and delegates:

* Integration ACLs define which integrations are enabled for a vault
* Delegate ACLs define which delegates are granted specific permissions to access a vault

## Policies

GLAM enforces risk management and compliance through configurable policies at various levels.

* Vault policies control parameters like the asset allowlist, timelock duration, and transfer restrictions.
* Mint policies include max capacity, min subscription size, lockup period.
* Policies can be configured for individual integrations. For example, a Kamino Lending policy that defines which lending pools are allowed for a vault.

## Automations

Automations are services that streamline and manage onchain operations without manual intervention, handling tasks such as rebalancing and risk management. They can be self-hosted or developed by third parties, enhancing efficiency while respecting defined access controls.

## Escrow

An Escrow is a temporary system account used during subscription and redemption flows for tokenized vaults:

* The escrow PDA is derived from the GLAM Mint program using the vault state pubkey
* During queued subscriptions, the subscriber's deposit is held in escrow until fulfillment
* During queued redemptions, the vault's withdrawal assets are placed in escrow until the subscriber claims them


# Integrations
Source: https://docs.glam.systems/v1/platform/integrations



<Frame>
  <img />

  <img />
</Frame>

GLAM Vaults has integrated with a collection of DeFi protocols. By default a newly created vault has zero integrations enabled. Vault owners must turn on individual integrations explicitly.

The table below shows a list of integration programs being audited and the protocols they support. The protocol bitflags are stored as `u16` integers, allowing for a maximum of 16 protocols per integration program.

| Integration Program | Supported Protocol            | Protocol Bitflag |
| ------------------- | ----------------------------- | ---------------- |
| Native\*            | System Program                | `0b00000001`     |
|                     | Jupiter Swap                  | `0b00000100`     |
| SPL                 | Token Program                 | `0b00000001`     |
|                     | Token 2022 Program            | `0b00000001`     |
| Kamino              | Kamino Lending                | `0b00000001`     |
|                     | Kamino Vaults                 | `0b00000010`     |
|                     | Kamino Farms                  | `0b00000100`     |
| CCTP                | Cross-Chain Transfer Protocol | `0b00000001`     |

*\*Native integration is part of the GLAM Protocol program. It does not use a separate integration program.*

## Pending Audit

Some integrations and protocols are supported but pending audit. We will provide a timeline as soon as an audit is scheduled.

| Integration Program | Supported Protocol | Protocol Bitflag |
| ------------------- | ------------------ | ---------------- |
| Native              | Stake Program      | `0b00000010`     |
| Stake Pools         | SPL Stake Pool     | `0b00000001`     |
|                     | Sanctum Single     | `0b00000010`     |
|                     | Sanctum Multi      | `0b00000100`     |
| Marinade            | Marinade Staking   | `0b00000001`     |

<Info>
  We are currently migrating the Meteora integration to our new architecture. If you'd like to request a specific integration, please reach out to us at [<u>hello@glam.systems</u>](mailto:hello@glam.systems).
</Info>


# Mints
Source: https://docs.glam.systems/v1/platform/mints



GLAM Mints provide the tokenization infrastructure that powers subscription and redemption flows using Token-2022 features. They enable controlled issuance and burning of vault share tokens, with built-in administrative controls and secure custody mechanisms.

## Token Extensions

Token Extensions expand the core Solana token standard with advanced capabilities. They retain minting, transferring, and freezing, while adding support for custom logic, extended metadata, and confidential transfers.

GLAM builds on this extended interface using the [Token-2022 program](https://spl.solana.com/token-2022), a superset of the [legacy Token program](https://spl.solana.com/token).

To learn more about Token Extensions visit the official documentation [here](https://solana.com/developers/guides/token-extensions/getting-started).

### Permanent Delegate

The Permanent Delegate extension designates an authority that can transfer or burn share tokens from any holder's account; holders cannot revoke that authority from their token accounts. It is disabled by default and should only be enabled for documented use cases (e.g., regulatory force-redemption). Pointing it at a single externally-owned wallet effectively gives that key custody over every depositor's shares.

See [Mint Management → Permanent Delegate](/v1/sdk/mint-management#permanent-delegate) for configuration guidance.

<Warning>
  Token Extensions (Token 2022) are still evolving, and certain features or configurations may introduce limitations across the ecosystem. While some integrations support standard extensions like Metadata and Transfer Fee, broader compatibility is still being explored.
</Warning>

| Extension                 | Supported | Enabled by Default |
| ------------------------- | --------- | ------------------ |
| Mint Close Authority      | ✅         | ✅                  |
| Transfer Fees             | ⏹️        | ⏹️                 |
| Non-Transferable          | ⏹️        | ⏹️                 |
| Interest-Bearing          | ⏹️        | ⏹️                 |
| Permanent Delegate        | ✅         | ⏹️                 |
| Transfer Hook             | ✅         | ✅                  |
| Metadata                  | ✅         | ✅                  |
| Metadata Pointer          | ✅         | ✅                  |
| Confidential Transfers    | ⏹️        | ⏹️                 |
| Pausable Config           | ⏹️        | ⏹️                 |
| Immutable Owner           | ⏹️        | ⏹️                 |
| Required Memo on Transfer | ⏹️        | ⏹️                 |
| CPI Guard                 | ⏹️        | ⏹️                 |
| Default Account State     | ✅         | ✅                  |
| Pausable Account          | ⏹️        | ⏹️                 |

<Info>
  If you need support for additional Token Extensions, please contact us at [mint@glam.systems](mailto:mint@glam.systems).
</Info>

## Token Metadata

When users subscribe to a tokenized vault, they receive share tokens. Wallets (Phantom, Solflare) and aggregators (Jupiter) rely on token metadata to display a human-readable name, symbol, and logo.

GLAM mints use the Token-2022 Metadata and Metadata Pointer extensions, which are enabled by default. The mint stores `name`, `symbol`, and a `uri` onchain. The `uri` points to an offchain JSON document that wallets fetch to resolve the token's description and image.

### Metadata JSON Schema

For broad wallet and indexer compatibility, use a metadata JSON document at `uri` with these recommended fields:

| Field         | Type     | Description                                                                   |
| ------------- | -------- | ----------------------------------------------------------------------------- |
| `name`        | `string` | Full name of the share token (should match the onchain mint name)             |
| `symbol`      | `string` | Short ticker, typically 2–6 characters (should match the onchain mint symbol) |
| `description` | `string` | Summary of the vault's purpose and strategy                                   |
| `image`       | `string` | HTTPS URL to the token logo (PNG or SVG, square, at least 512×512 px)         |

Example:

```json theme={null}
{
  "name": "GLAM SOL",
  "symbol": "gmSOL",
  "description": "Liquid SOL strategy vault on GLAM. Share token represents a pro-rata claim on vault assets.",
  "image": "https://your-domain.com/gmsol-logo.png"
}
```

### Hosting Options

For broad wallet support, use a publicly accessible HTTPS URL that returns the JSON document with `Content-Type: application/json`. Three common approaches:

<CardGroup>
  <Card title="GitHub">
    Free, version-controlled, and reliable. Host the JSON and logo in a public repo and link to the raw file URL. Updates are trivial, and history is auditable.
  </Card>

  <Card title="Arweave / IPFS">
    Permanent, decentralized hosting. Best when immutability is a feature rather than a limitation. Updates require publishing a new URI and updating the mint.
  </Card>

  <Card title="Self-hosted">
    Full control over caching, updates, and analytics. Requires your own infrastructure and uptime guarantees.
  </Card>
</CardGroup>

<Warning>
  Wallets and indexers cache metadata aggressively. Prefer a stable URL and update the JSON in place rather than rotating URIs. If you do change the `uri` onchain, expect delays before clients refresh.
</Warning>

### Setting the URI

The metadata URI is part of the mint configuration and is typically set at vault creation time. Set the `uri` field via:

* **CLI**: the `mint.uri` field in the vault template. See [CLI General Usage](/v1/cli/general) for the template reference.
* **SDK**: the `uri` parameter passed to `mint.initialize`. See [Mint Management](/v1/sdk/mint-management) for initialization and lifecycle operations.

### Checklist

Before announcing your vault, verify:

* The URI returns valid JSON with the recommended wallet/indexer-compatible fields.
* `name` and `symbol` in the JSON match the onchain mint name and symbol.
* The `image` URL resolves to a square logo at least 512×512 px.
* The share token displays correctly in a wallet after a test subscription.


# Overview
Source: https://docs.glam.systems/v1/platform/overview



As the illustration below shows, GLAM Vaults infrastructure provides the foundation for onchain asset management. GLAM Mints infrastructure tokenizes the underlying vaults and allows users to subscribe and redeem vault shares.

<Frame>
  <img />

  <img />
</Frame>

## Key Components

* **Vault**: Programmable account that manages assets, with embedded risk management and compliance

* **Mint**: Tokenized representation of vault shares, governed by configurable policies

* **Escrow**: System account that securely holds assets during subscription and redemption flows

* **Access Control**: Granular permissions framework for integrations and delegates

* **Policies**: Onchain, programmatically enforced compliance and risk parameters

* **Integrations**: Composability layer that connects vaults to DeFi protocols


# Policies
Source: https://docs.glam.systems/v1/platform/policies



Policies can be attached to vaults, mints, and enabled integrations. They can be modified over time to adapt to changing conditions.

<CardGroup>
  <Card title="Vault Policies" icon="vault">
    Vault policies define rules that apply to the entire vault. These policies are always enforced regardless of user role or permissions.

    *Examples: asset allowlists, borrowable assets, timelock.*
  </Card>

  <Card title="Tokenization Policies" icon="binary">
    Tokenization policies govern tokenized vault shares and investor interactions. They control subscription, redemption, and fulfillment rules.

    *Examples: maximum capacity, minimum subscription size, lockup periods, investor allowlists.*
  </Card>

  <Card title="Integration Policies" icon="puzzle-piece-simple">
    Integration policies define rules specific to individual DeFi protocol connections. Each enabled integration can have its own policy constraints.

    *Examples: market allowlists, slippage limits.*
  </Card>
</CardGroup>

## Vault Policies

### Asset Allowlist

Asset allowlist defines which tokens a vault can interact with. It is also used as source of truth for pricing vault tokens.

### Borrowable Assets

This list defines which assets the vault can borrow from DeFi protocols. Tokens held by the vault but not among the asset allowlist or borrowable assets are not included in the vault's AUM.

### Transfer Allowlist

By default, delegates can deploy vault capital into DeFi protocols and withdraw it back into the vault, but they **cannot transfer assets to arbitrary addresses or personal wallets**.

The Transfer Allowlist enables vault owners to define approved destinations for vault assets, such as other vaults under the same control. This adds flexibility for internal capital management while preventing unauthorized or unintended transfers.

## Tokenization Policies

### Maximum Capacity

Defines the maximum total value the vault can accept.

### Minimum Subscription

Defines the minimum amount required for a subscription.

### Minimum Redemption

Defines the minimum number of shares required for a redemption.

### Permissioned Fulfillment

By default, only managers can fulfill subscription and redemption requests.

If permissionless fulfillment is enabled, anyone, including users and bots, can fulfill eligible requests once they become executable.

### Investor Allowlists

GLAM Mints support allowlists to further restrict who can subscribe or redeem beyond the default account state. Only pre-approved wallet addresses can receive or interact with minted tokens. This enables jurisdictional compliance, institutional onboarding, and controlled distribution.

### Investor Blocklists

Blocklists act as an additional enforcement layer by denying specific addresses the ability to receive, hold, or transfer mint tokens. Used to manage sanctions, compromised wallets, or internal policies, blocklisted actions are automatically rejected by the token program.

### Lockup Periods

Lockup periods impose time-based restrictions on both redemptions and transfers of minted tokens. When enabled, every recipient is subject to a lockup window starting from the moment of mint or token receipt. During this period, transfers and burns (used for redemptions) are blocked at the protocol level. These constraints are enforced via Transfer Hook metadata and GLAM’s Policies program, offering strong, onchain guarantees against premature liquidity events. Lockups help align redemptions with fund terms, prevent early exits, and protect portfolio stability.

## Integration Policies

### Market Allowlists

Market allowlists define which specific markets a vault can access within each supported DeFi protocol. The overall market access for a vault is the combination of all integration-specific market allowlists.

For example:

* For Kamino Lending, vault owner can specify a list of **selected lending pools**.
* The **Jupiter Swap Allowlist** controls which tokens can be swapped into using Jupiter.

### Borrow Allowlists

In addition to vault-level borrowable assets, each integration of lending protocol can have its own borrow allowlist, allowing vault owners to further restrict which assets can be borrowed.

### Max Slippage Limits

Max slippage limits protect vaults from harmful execution conditions, whether due to delegate error or manipulation.

By capping the slippage a delegate can specify, vaults mitigate risks like sandwich attacks and prevent transactions with excessive price impact from being executed.


# Vaults
Source: https://docs.glam.systems/v1/platform/vaults



GLAM Vaults provide core infrastructure for managing onchain portfolios with automated risk controls and fine grained, configurable permissions. Modular components and streamlined workflows reduce operational complexity, enforce policy with precision, and support strategy execution while maintaining strong security guarantees and transparent onchain operations.

<CardGroup>
  <Card title="Vaults" icon="vault">
    Manage your own assets with fine-grained access controls and seamless integrations.

    Deploy treasury funds, automate DeFi strategies, or manage portfolios with fine-grained access controls and risk management. Delegate specific permissions while maintaining control and enforce compliance rules at the protocol level.

    *Designed for: DAOs, family offices, treasury teams, sophisticated investors*
  </Card>

  <Card title="Tokenized Vaults" icon="binary">
    Create transparent investment products that external investors can access.

    Launch funds, structured products, or managed strategies with embedded compliance and automated investor operations. Maintain operational control while automating flows, fee collection, and policy enforcement.

    *Designed for: Asset managers, institutions, protocol teams, investment advisors*
  </Card>
</CardGroup>

<CardGroup>
  <Card title="Single Asset Vaults" icon="coin">
    Streamlined vaults for strategies that hold only one asset.

    Simplify pricing and operations by removing multi-asset valuation logic. Derive AUM directly from a single token account balance with reduced transaction size.

    *Designed for: Single-token yield strategies, staking vaults*
  </Card>
</CardGroup>

## Vaults

Vaults can be created without tokenization and such "private" vaults can be used to run internal strategies, manage treasury assets, or automate portfolio operations. These vaults do not issue investor-facing tokens and are often used by DAOs, family offices, or power users looking for fine-grained control.

Permissions, integrations, and policies can be configured to enforce execution boundaries without requiring tokenization.

**Use Cases:** DAO treasuries, proprietary strategies, delegated execution environments

**Key Features:**

* No tokenized share issuance
* Configurable access control for delegate accounts
* Onchain enforcement of risk and compliance policies
* Integration with DeFi protocols

## Tokenized Vaults

Tokenized Vaults issue shares to external investors and are designed for launching onchain investment products. These vaults include automated mechanisms for subscription, redemption, fee accrual, and policy enforcement. Vault shares are tokenized using GLAM Mints and distributed according to configured terms.

This structure allows managers to scale compliant, transparent strategies while maintaining control over permissions, pricing, and risk boundaries.

**Use Cases:** Onchain funds, structured products, actively managed portfolios

**Key Features:**

* Investor-facing share issuance
* Automated fee logic (subscription, redemption, performance)
* Enforcement of compliance, access, and liquidity policies
* Support for notice and settlement periods
* Full auditability of flows and valuation
* Plus all the Vaults features

## Single Asset Vaults

Single Asset Vaults are a streamlined vault type designed for strategies that hold only one asset. They simplify pricing and operations by removing the need for multi-asset valuation logic.

Single Asset Vaults use a dedicated `priceSingleAssetVault` pricing instruction that derives the vault's AUM directly from the single token account balance, eliminating the complexity of oracle-based pricing for multi-asset portfolios.

**Use Cases:** Single-token yield strategies, stablecoin vaults, wrapped asset management

**Key Features:**

* Simplified pricing via single asset balance
* Reduced transaction size for pricing operations
* All standard vault features (access control, policies, integrations)
* Can be tokenized like other vault types


# Programs
Source: https://docs.glam.systems/v1/programs



GLAM adopts a [modular design](platform/overview) that allows for extensibility and customization. Core functionalities are implemented in GLAM Protocol and GLAM Mint, while several other programs provide DeFi integrations and auxiliary functionalities.

## Core Programs

### GLAM Protocol

This is the main program that controls the vault PDA (Program Derived Address), manages on-chain states, configurations, and policies.

<CodeGroup>
  ```Production Production theme={null}
  GLAMpaME8wdTEzxtiYEAa5yD8fZbxZiz2hNtV58RZiEz
  ```

  ```Staging Staging theme={null}
  gstgptmbgJVi5f8ZmSRVZjZkDQwqKa3xWuUtD5WmJHz
  ```

  ```Devnet Devnet theme={null}
  GLAMpaME8wdTEzxtiYEAa5yD8fZbxZiz2hNtV58RZiEz
  ```
</CodeGroup>

### GLAM Mint

The Mint program handles tokenization and pricing. It implements investor flows (i.e., subscription and redemption) and manager flows (fulfillment, claiming & crystallizing fees).

<CodeGroup>
  ```Production Production theme={null}
  GM1NtvvnSXUptTrMCqbogAdZJydZSNv98DoU5AZVLmGh
  ```

  ```Staging Staging theme={null}
  gstgm1M39mhgnvgyScGUDRwNn5kNVSd97hTtyow1Et5
  ```

  ```Devnet Devnet theme={null}
  GM1NtvvnSXUptTrMCqbogAdZJydZSNv98DoU5AZVLmGh
  ```
</CodeGroup>

## Integration Programs

An integration program implements the integration with one or more DeFi protocols. They are like adapters that connect GLAM vaults with other protocols.

Vault owners have the flexibility to choose which integration programs to enable on their vaults. In addition to the following integrations GLAM provides, advanced users can also implement their own integration programs.

### CCTP Integration

This program implements the integration with Circle’s Cross-Chain Transfer Protocol (CCTP).

<CodeGroup>
  ```Production Production theme={null}
  G1NTcMDYgNLpDwgnrpSZvoSKQuR9NXG7S3DmtNQCDmrK
  ```

  ```Devnet Devnet theme={null}
  G1NTcMDYgNLpDwgnrpSZvoSKQuR9NXG7S3DmtNQCDmrK
  ```
</CodeGroup>

### Kamino Integration

This program implements the integration with Kamino programs, including Kamino Lending, Kamino Vaults, and Kamino Farms.

<CodeGroup>
  ```Production Production theme={null}
  G1NTkDEUR3pkEqGCKZtmtmVzCUEdYa86pezHkwYbLyde
  ```

  ```Staging Staging theme={null}
  gstgKa2Gq9wf5hM3DFWx1TvUrGYzDYszyFGq3XBY9Uq
  ```

  ```Devnet Devnet theme={null}
  G1NTkDEUR3pkEqGCKZtmtmVzCUEdYa86pezHkwYbLyde
  ```
</CodeGroup>

### SPL Integration

This program implements the integration with Token program and Token 2022 program.

<CodeGroup>
  ```Production Production theme={null}
  G1NTsQ36mjPe89HtPYqxKsjY5HmYsDR6CbD2gd2U2pta
  ```

  ```Staging Staging theme={null}
  gstgs9nJgX8PmRHWAAEP9H7xT3ZkaPWSGPYbj3mXdTa
  ```

  ```Devnet Devnet theme={null}
  G1NTsQ36mjPe89HtPYqxKsjY5HmYsDR6CbD2gd2U2pta
  ```
</CodeGroup>

## Auxiliary Programs

### GLAM Config

The config program manages global configurations (e.g., protocol fees and authority, oracle mapping) that apply to all GLAM instances.

<CodeGroup>
  ```Production Production theme={null}
  gConFzxKL9USmwTdJoeQJvfKmqhJ2CyUaXTyQ8v9TGX
  ```

  ```Devnet Devnet theme={null}
  gConFzxKL9USmwTdJoeQJvfKmqhJ2CyUaXTyQ8v9TGX
  ```
</CodeGroup>

### GLAM Policies

The policies program implements the Token 2022 transfer hook and enforces lock-up policies.

<CodeGroup>
  ```Production Production theme={null}
  po1iCYakK3gHCLbuju4wGzFowTMpAJxkqK1iwUqMonY
  ```

  ```Devnet Devnet theme={null}
  po1iCYakK3gHCLbuju4wGzFowTMpAJxkqK1iwUqMonY
  ```
</CodeGroup>


# AI
Source: https://docs.glam.systems/v1/quickstart/ai



You can manage GLAM vaults through AI coding agents using the [glam-skill](https://skills.sh/glamsystems/glam-skill/glam). Instead of running CLI commands or clicking through the GUI, describe what you want in natural language and the agent handles the rest.

The skill gives your agent a decision tree for vault operations, error handling, integration awareness, and knowledge of the GLAM CLI and SDK.

### Supported platforms

The glam-skill works with any [skills.sh](https://skills.sh)-compatible platform:

* Claude Code
* Gemini CLI
* Codex
* OpenCode

### Installation

For skills.sh-compatible platforms:

```bash theme={null}
npx skills add https://github.com/glamsystems/glam-skill --skill glam
```

<Info>
  In Claude Code, you can also install with `/skill` or add the skill manually to your project configuration.
</Info>

### Configuration

Before your agent can manage vaults, you need the GLAM CLI installed and configured.

Install the CLI:

```bash theme={null}
npm install -g @glamsystems/glam-cli
```

Create your CLI config at `~/.config/glam/config.json`:

```json config.json theme={null}
{
  "keypair_path": "~/.config/solana/id.json",
  "json_rpc_url": "https://api.mainnet-beta.solana.com",
  "priority_fee": { "micro_lamports": 5000 },
  "jupiter_api_key": "<jupiter-api-key>"
}
```

<Info>
  Need an RPC endpoint? AI agents can create a [Helius](https://www.helius.dev/docs/agents/overview) account and get an API key automatically. Your `json_rpc_url` would then be `https://mainnet.helius-rpc.com/?api-key=<helius-api-key>`.
</Info>

<Info>
  The `jupiter_api_key` is optional but recommended. It's required for commands that fetch token prices (e.g., `vault token-balances`). Get one for free on [Jupiter Developer Platform](https://portal.jup.ag/pricing).
</Info>

The agent uses this config automatically when running CLI commands. If you have multiple keypairs (e.g., owner, delegate, user), you can either update the config or tell the agent to use a specific config file with the `-C` flag.

### Example walkthrough

Here's what managing a GLAM vault looks like through an AI agent. The following prompts mirror the [CLI quickstart](/v1/quickstart/cli) flow.

<Steps>
  <Step title="Create a vault">
    Prompt your agent:

    ```
    Create a tokenized GLAM vault called "AI Quickstart USDC" with USDC as
    the base asset. Set max cap to 1000 USDC, min subscription to 1 USDC,
    and zero fees.
    ```

    The agent will generate the vault configuration JSON and run the appropriate `glam-cli vault create` command.
  </Step>

  <Step title="Enable integrations">
    ```
    Enable Kamino Vaults integration on my vault.
    ```

    The agent knows which integrations are available and runs:

    ```bash theme={null}
    glam-cli integration enable KaminoVaults
    ```
  </Step>

  <Step title="Grant delegate permissions">
    ```
    Grant my delegate ndcXmT...ids4QnG permissions to fulfill mint requests
    and deposit/withdraw from Kamino Vaults.
    ```

    The agent translates this into the correct `delegate grant` commands with the right protocol and permission names.
  </Step>

  <Step title="Manage portfolio">
    ```
    Deposit 5 USDC into Kamino lending (main market).
    ```

    The skill knows the main Kamino market address, so this works out of the box. If you want to use a different market or vault, just paste the address in your prompt.
  </Step>

  <Step title="Handle investor flows">
    ```
    Fulfill all pending redemption requests.
    ```

    The agent runs `glam-cli manage fulfill` to process queued redemptions.
  </Step>
</Steps>

### What the skill provides

* **Decision tree** for vault operations -- the agent knows which commands to run and in what order
* **Error handling** -- the agent interprets CLI errors and suggests fixes
* **Integration awareness** -- the agent understands which integrations need to be enabled before use and what permissions delegates need
* **CLI and SDK coverage** -- the agent can use either the CLI or the TypeScript SDK depending on your context

### Learn more

See the full skill reference at [skills.sh/glamsystems/glam-skill/glam](https://skills.sh/glamsystems/glam-skill/glam).


# CLI
Source: https://docs.glam.systems/v1/quickstart/cli



Follow the steps in the [CLI introduction](https://docs.glam.systems/v1/cli/introduction) to install the GLAM CLI.

<Info>
  All transactions mentioned on this page were executed on mainnet using GLAM CLI v1.0.2. There might be some differences in the most recent versions. Check help messages first if you encounter any issues.
</Info>

### Preparation

Before starting, ensure you have:

* **Solana keypairs** for each persona. Create new keypairs with `solana-keygen new -o keypair.json`. See [Solana CLI docs](https://solana.com/docs/intro/installation) for more details.
* **SOL** in each account for transaction fees.
* **USDC** for the user account to subscribe to the vault.
* **Jupiter API key** (optional but recommended). Required for commands that fetch token prices (e.g., `vault token-balances`). Get one for free on [Jupiter Developer Platform](https://portal.jup.ag/pricing).

### Setup

In this quickstart, there are three personas:

* **Vault owner**: creates a vault, configures it, and grants the delegate proper permissions for operations.
  * `HQsXBSrJait1Gt8FJSNhf87p8cddRAy4WEbGzQvdeC3M`
  * Funded with 0.1 SOL
* **Delegate**: allocates fund, and fulfills user requests.
  * `ndcXmTFuMPkJ5mE4sYNnZdSo99Ajzny88xnrids4QnG`
  * Funded with 0.01 SOL
* **User**: subscribes to the vault, then redeems shares.
  * `gpoPk9Aa7yZoFsfkAUiaH85UsdDvoFz8gZrTGbjtAX8`
  * Funded with 0.01 SOL plus 5 USDC

Prepare CLI configs for each persona:

```json owner-config.json lines theme={null}
{
  "cluster": "mainnet-beta",
  "json_rpc_url": "https://mainnet.helius-rpc.com/?api-key=<api-key>",
  "keypair_path": "/path/to/owner-keypair.json",
  "priority_fee": { "micro_lamports": 5000 },
  "jupiter_api_key": "<jupiter-api-key>"
}
```

```json manager-config.json lines theme={null}
{
  "cluster": "mainnet-beta",
  "json_rpc_url": "https://mainnet.helius-rpc.com/?api-key=<api-key>",
  "keypair_path": "/path/to/delegate-keypair.json",
  "priority_fee": { "micro_lamports": 5000 },
  "jupiter_api_key": "<jupiter-api-key>"
}
```

```json user-config.json lines theme={null}
{
  "cluster": "mainnet-beta",
  "json_rpc_url": "https://mainnet.helius-rpc.com/?api-key=<api-key>",
  "keypair_path": "/path/to/user-keypair.json",
  "priority_fee": { "micro_lamports": 5000 },
  "jupiter_api_key": "<jupiter-api-key>"
}
```

For convenience, place all user config files, as well as vault setup `tokenized.json` (see below) in the same directory. All commands, unless specified otherwise, are run from this directory.

### Create a Tokenized Vault

```bash theme={null}
glam-cli -C ./owner-config.json vault create ./tokenized.json
```

* [Transaction](https://solscan.io/tx/47ebP75gwYWNiKgYtjxHC1y2T9SfeAcueh3kDq2sKVD46MFUHi5rS3TFRWCC1rNfmXgr6p245SXD6HTQZAZLGAEC)
* Vault State: [3ciXL6K3kxF754sjqP5acHYHjhZWNK6rj6svjrYouNpY](https://solscan.io/account/3ciXL6K3kxF754sjqP5acHYHjhZWNK6rj6svjrYouNpY)
* Vault PDA: [9hcpVEWDe55hHDHkk4SbN4AVnqqWYXUE7EW3cjai4JAE](https://solscan.io/account/9hcpVEWDe55hHDHkk4SbN4AVnqqWYXUE7EW3cjai4JAE)
* Mint PDA: [J6wov8kN6tw48u57JBKszD4Vn4hmx32bHxHK82ZvrXDe](https://solscan.io/account/J6wov8kN6tw48u57JBKszD4Vn4hmx32bHxHK82ZvrXDe)

Vault setup:

```json tokenized.json expandable lines theme={null}
{
  "state": {
    "accountType": "tokenizedVault"
  },
  "mint": {
    "name": "GLAM Quickstart USDC",
    "symbol": "gqUSD",
    "uri": "",
    "baseAssetMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    "maxCap": 1000000000,
    "minSubscription": 1000000,
    "minRedemption": 100000,
    "lockupPeriod": 0,
    "feeStructure": {
      "vault": {
        "subscriptionFeeBps": 0,
        "redemptionFeeBps": 0
      },
      "manager": {
        "subscriptionFeeBps": 0,
        "redemptionFeeBps": 0
      },
      "management": {
        "feeBps": 0
      },
      "performance": {
        "feeBps": 0,
        "hurdleRateBps": 0,
        "hurdleType": "hard"
      }
    },
    "notifyAndSettle": {
      "model": "continuous",
      "permissionlessFulfillment": false,
      "subscribeNoticePeriodType": "hard",
      "subscribeNoticePeriod": 0,
      "subscribeSettlementPeriod": 0,
      "subscribeCancellationWindow": 0,
      "redeemNoticePeriodType": "hard",
      "redeemNoticePeriod": 0,
      "redeemSettlementPeriod": 0,
      "redeemCancellationWindow": 0,
      "timeUnit": "second"
    }
  }
}
```

<Info>
  The vault setup format may change between CLI versions. See the [templates](https://github.com/glamsystems/glam-cli/tree/main/templates) directory for the most up-to-date examples.
</Info>

### Enable Kamino Vaults

Kamino Vaults needs to be enabled before it can be used.

```bash theme={null}
glam-cli -C ./owner-config.json integration enable KaminoVaults
```

* [Transaction](https://solscan.io/tx/2vxwLr96jRd3bHBFRiakTR1GudsRGiDnsFdiz8HmaKHMMaj2gTUT1XGT3wJGuP4vpUJPqcX3XKRMjFB6cgYApkGA)

### Grant Delegate Permissions

<Info>
  Refer to [Integrations](https://docs.glam.systems/v1/platform/integrations) and [Delegated Accounts](https://docs.glam.systems/v1/access-control/delegated-accounts) for more details on protocols and permissions.
</Info>

Vault owner grants the delegate the following permissions:

* `Fulfill` permission from `GlamMint` so it can fulfill user requests.
* `Deposit` and `Withdraw` permissions from `KaminoVaults` so it can deploy GLAM vault assets to Kamino vaults.

```bash theme={null}
glam-cli -C ./owner-config.json delegate grant --protocol GlamMint \
  ndcXmTFuMPkJ5mE4sYNnZdSo99Ajzny88xnrids4QnG Fulfill
```

```bash theme={null}
glam-cli -C ./owner-config.json delegate grant --protocol KaminoVaults \
  ndcXmTFuMPkJ5mE4sYNnZdSo99Ajzny88xnrids4QnG Deposit Withdraw
```

* [Transaction granting Fulfill permission](https://solscan.io/tx/49KGiCUvqAZQEC9mKhGbozgqYRTcL5GgK4qRJY7g9K4JiaFnXrCvcqQEiNWhqeCxgffryznFWJnyVhXoXcjEmyeF)
* [Transaction granting Deposit and Withdraw permissions](https://solscan.io/tx/4wHrovpvFS98EFY7uaLiamosfTifkict23XJHqdZbvUnevaY2CjtKmUf86LDimMJReBZq9QFKSSr63H76a6tyVQQ)

### Subscribe to GLAM Vault

Set the active GLAM vault to user's CLI config:

```bash theme={null}
glam-cli -C ./user-config.json vault set 3ciXL6K3kxF754sjqP5acHYHjhZWNK6rj6svjrYouNpY
```

User subscribes to GLAM vault with 5 USDC:

```bash theme={null}
glam-cli -C ./user-config.json invest subscribe 5
```

* [Transaction](https://solscan.io/tx/5EJje4PQR6P2CaiiZienZ4yLJ7JJ2uBxsqHZRkm8Z9qXX6XR8BK1MoKLSHKuCmVDsEzjsTb1Zcm87n2wgBBPNnk8)

We've configured the vault with 0 fees, so user receives 5 shares (initial share price is 1 USDC).

### Allocate Idle Capital

User deposited 5 USDC has arrived in the GLAM vault, held by vault PDA. Now the delegate can allocate idle capital to a Kamino vault to start generating yield.

Set the active GLAM vault to delegate's CLI config:

```bash theme={null}
glam-cli -C ./delegate-config.json vault set 3ciXL6K3kxF754sjqP5acHYHjhZWNK6rj6svjrYouNpY
```

Display vault token balances:

```bash theme={null}
glam-cli -C ./delegate-config.json vault token-balances
```

Output:

```bash theme={null}
Token        Mint                                          Amount          Value (USD)
SOL          N/A                                           0.000000000     0.000000
USDC         EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v  5               4.999002
```

Deposit to Kamino vault [USDC Prime](https://kamino.com/lend/HDsayqAsDWy3QvANGqh2yNraqcD8Fnjgh73Mhb3WRS5E):

```bash theme={null}
glam-cli -C ./delegate-config.json kamino-vaults \
  deposit HDsayqAsDWy3QvANGqh2yNraqcD8Fnjgh73Mhb3WRS5E 5
```

* [Transaction depositing 5 USDC](https://solscan.io/tx/5B654xatXaTR1TveRqW83AzgfHRHjDVwvo1Lv5sRFYX5tfimn3kKX44maMAwX8udHSGaBFfsRfoLucFQR4AvPG8q)

Withdraw from Kamino vault [USDC Prime](https://kamino.com/lend/HDsayqAsDWy3QvANGqh2yNraqcD8Fnjgh73Mhb3WRS5E):

```bash theme={null}
glam-cli -C ./delegate-config.json kamino-vaults \
  withdraw HDsayqAsDWy3QvANGqh2yNraqcD8Fnjgh73Mhb3WRS5E 3
```

* [Transaction withdrawing from USDC Prime](https://solscan.io/tx/3VyhR9xMAcQHJhzL8XQnLCbE4kxttHeErRTsZELmqSxFvLEL8hvsnH9dufPrYNijFFMMEztfGNnrUGdzuBjc7ydc)

### Redeem GLAM Vault Shares

User holds 5 GLAM vault shares, and redeems 2 shares to get back USDC. Redemption request is queued, and withdrawal amount can be claimed after the request is fulfilled.

```bash theme={null}
glam-cli -C ./user-config.json invest redeem 2
```

* [Transaction](https://solscan.io/tx/KLPSgtwgmXnCYM7VKJe7uF9eHNhQB3jrHvu1bZJ2Mzupx7hoXG5PhaTuY4t7648WHKvbqjKC7vQj7s6tGe3B9yd)

### Fulfill Redemption

The delegate has been granted `Fulfill` permission from `GlamMint`, so it can fulfill user requests.

```bash theme={null}
glam-cli -C ./delegate-config.json manage fulfill
```

* [Transaction](https://solscan.io/tx/HcCvwWKDgzKPQn3igDYZyBMVcJ9rAeLETUgv8gPfH87m2fgm5ZseokhvUUQCPrqs9164eGyBM1QTsEPoiaz9aCv)

### Claim from Redemption

User claims USDC from fulfilled redemption.

```bash theme={null}
glam-cli -C ./user-config.json invest claim-redemption
```

* [Transaction](https://solscan.io/tx/4rSw2WH6o2KWsEyXU4LBc2Wc3YtCRg5bC4B8JxYH5bYdwGsqXyYqjAFgGDda7CpUKzDiVsNw8uHCMxwrASBqDkY)


# GUI
Source: https://docs.glam.systems/v1/quickstart/gui



## Create Vault

<Steps>
  <Step title="Access Platform">
    Navigate to the <Tooltip>[GLAM GUI](https://gui.glam.systems/)</Tooltip> and select *Vault*.
  </Step>

  <Step title="Vault Configuration">
    On the <Tooltip>[Create Vault](https://gui.glam.systems/vault/create)</Tooltip> page:

    1. Connect your Solana wallet if you haven't already

    2. Choose a name for your vault (public)

    3. Select the integrations you would like to enable

    4. Review the settings and click *Create*

    5. Sign the transaction in your wallet

    <Note>
      For optimal security and efficiency only enable integrations required for your use case.
    </Note>

    <Note>
      Creating a vault requires a refundable deposit of 0.016 SOL to cover rent costs. This amount will be returned when you close the vault.
    </Note>
  </Step>

  <Step title="Initial Deposit">
    After creation, you'll be directed to the Holdings page where you can:

    * View your vault details

    * Find your vault's address under *Vault Details* to make the initial deposit

    * Begin making your first deposit by transferring assets to the vault address
  </Step>
</Steps>

<Frame>
  <video />

  <video />
</Frame>

***

## Delegate Access

Delegate access allows you to grant specific permissions to other wallets while maintaining control of your vault.

<Steps>
  <Step title="Access Delegation Controls">
    Navigate to the [<Tooltip>Access</Tooltip>](https://gui.glam.systems/vault/access) page.
  </Step>

  <Step title="Add New Delegate">
    Click the *Add Key* button and provide:

    * Label (optional) to identify the delegate

    * Delegate's public key

    * Specific permissions you want to grant
  </Step>

  <Step title="Review and Confirm">
    * Verify the selected permissions

    * Sign the transaction to activate the delegation

    Learn more about fine-grained access control and delegation in  Access Control documentation.
  </Step>
</Steps>

<Frame>
  <video />

  <video />
</Frame>

***

## Manage Portfolio

Your GLAM vault supports various DeFi operations to help you manage your portfolio effectively:

<Steps>
  <Step title="Token Swaps">
    * Execute trades through Jupiter's aggregator

    * Access optimal routes across Solana's DEXs

    * Get best available prices with minimal slippage
  </Step>

  <Step title="Staking Operations">
    * Stake SOL directly with validators (native staking)

    * Use liquid staking protocols for staking derivatives

    * Earn staking rewards while maintaining liquidity
  </Step>

  <Step title="Asset Transfers">
    * Deploy capital across different DeFi protocols

    * Manage positions across multiple venues
  </Step>
</Steps>

<Note>
  Remember to enable the required integrations before performing any of these operations.
</Note>

<Frame>
  <video />

  <video />
</Frame>

***

## Close Vault

Important safety considerations when closing your vault:

<Steps>
  <Step title="Prepare for Closure">
    * Ensure all assets have been withdrawn from the vault

    * Only the vault owner can perform this operation
  </Step>

  <Step title="Close the Vault">
    Navigate to the [<Tooltip><u>Holdings</u></Tooltip>](https://gui.glam.systems/vault/holdings) page:

    * Click *Details* to open the Vault Details sheet

    * Locate the *Close Vault* button at the bottom

    * Sign the closing transaction, which will automatically refund your rent deposit
  </Step>
</Steps>

<Warning>
  Any remaining assets will be automatically transferred to the owner during closure
</Warning>

<Warning>
  The closing transaction may fail if the vault holds too many assets. If this happens, manually transfer assets and/or close empty token accounts first.
</Warning>

<Warning>
  **DO NOT** send any assets to the vault during the closing process. Assets sent during closure may be permanently lost.
</Warning>

<Frame>
  <video />

  <video />
</Frame>


# Access Control
Source: https://docs.glam.systems/v1/sdk/access-control



The `access` sub-client provides methods for managing vault permissions, enabling integrations, and configuring delegate access. This guide covers how to use the SDK to implement granular access control for your vault.

## When to Use Access Control

Access control is essential when you need to:

* **Delegate operations** - Allow bots, managers, or multisig members to perform specific actions
* **Enable protocol integrations** - Activate DeFi protocols (Jupiter, Kamino) for your vault
* **Enforce guardrails** - Set allowlists/blocklists for transfers and swaps
* **Emergency management** - Quickly revoke compromised delegate access

## Permission Hierarchy

```mermaid theme={null}
graph TB
    V[Vault]

    V --> IA[Integration ACLs]
    V --> DA[Delegate ACLs]

    IA --> PB[Protocol Bitmask]
    PB --> PP[Protocol Policies]

    DA --> IP[Integration Permissions]
    IP --> PRM[Protocol Permissions]

    IA -.- IA_DESC["Which programs can interact"]
    PB -.- PB_DESC["Which protocols within<br/>program are enabled"]
    PP -.- PP_DESC["Custom rules like allowlists"]

    DA -.- DA_DESC["Who can act on<br/>behalf of owner"]
    IP -.- IP_DESC["Per-integration access"]
    PRM -.- PRM_DESC["Bitmask of allowed actions"]

    style V fill:#010101,stroke:#fefefe,color:#fefefe,stroke-width:3px
    style IA fill:#333,stroke:#fefefe,color:#fefefe
    style DA fill:#333,stroke:#fefefe,color:#fefefe
    style PB fill:#444,stroke:#fefefe,color:#fefefe
    style PP fill:#555,stroke:#fefefe,color:#fefefe
    style IP fill:#444,stroke:#fefefe,color:#fefefe
    style PRM fill:#555,stroke:#fefefe,color:#fefefe
    style IA_DESC fill:none,stroke:none,color:#888
    style PB_DESC fill:none,stroke:none,color:#888
    style PP_DESC fill:none,stroke:none,color:#888
    style DA_DESC fill:none,stroke:none,color:#888
    style IP_DESC fill:none,stroke:none,color:#888
    style PRM_DESC fill:none,stroke:none,color:#888
```

* **Integration ACLs** define which external programs (Jupiter, Kamino) can interact with your vault and what protocol-specific policies apply.
* **Delegate ACLs** control which external accounts can act on behalf of the vault owner, with permissions scoped per integration and protocol.

## Enabling Protocols for Integrations

Before a vault can interact with DeFi protocols, you must enable them at the integration level.

### Enable Protocols

```typescript theme={null}
import { GlamClient, getProgramAndBitflagByProtocolName } from "@glamsystems/glam-sdk";
import { PublicKey } from "@solana/web3.js";

const glamClient = new GlamClient({ statePda: vaultStatePubkey });

// Get protocol info by name
const permissionsMap = getProgramAndBitflagByProtocolName(glamClient.staging);
const [integrationProgram, protocolBitflag] = permissionsMap["JupiterSwap"];

// Enable Jupiter Swap for the vault
const txSig = await glamClient.access.enableProtocols(
  new PublicKey(integrationProgram),
  parseInt(protocolBitflag, 2)
);
```

### Disable Protocols

```typescript theme={null}
// Disable Jupiter Swap
const txSig = await glamClient.access.disableProtocols(
  new PublicKey(integrationProgram),
  parseInt(protocolBitflag, 2)
);
```

## Managing Delegate Permissions

Delegates start with no permissions and must be explicitly granted access.

### Grant Permissions

```typescript theme={null}
import { GlamClient, getProgramAndBitflagByProtocolName } from "@glamsystems/glam-sdk";
import { PublicKey } from "@solana/web3.js";
import { BN } from "@coral-xyz/anchor";

const glamClient = new GlamClient({ statePda: vaultStatePubkey });

// Grant delegate permission to swap tokens via Jupiter
const delegatePubkey = new PublicKey("De1egate111111111111111111111111111111111111");
const permissionsMap = getProgramAndBitflagByProtocolName(glamClient.staging);
const [integrationProgram, protocolBitflag] = permissionsMap["JupiterSwap"];

// Permission bits: SwapAny=0b001, SwapLST=0b010, SwapAllowlisted=0b100
const permissions = new BN(0b001); // SwapAny permission

const txSig = await glamClient.access.grantDelegatePermissions(
  delegatePubkey,
  new PublicKey(integrationProgram),
  parseInt(protocolBitflag, 2),
  permissions
);
```

### Revoke Permissions

```typescript theme={null}
// Revoke specific permissions from delegate
const txSig = await glamClient.access.revokeDelegatePermissions(
  delegatePubkey,
  new PublicKey(integrationProgram),
  parseInt(protocolBitflag, 2),
  permissions // permissions to revoke
);
```

## Protocol Policies

Policies add parameter-level access control through allowlists and blocklists.

### Set Transfer Allowlist

```typescript theme={null}
import { GlamClient, getProgramAndBitflagByProtocolName, TransferPolicy } from "@glamsystems/glam-sdk";
import { PublicKey } from "@solana/web3.js";

const glamClient = new GlamClient({ statePda: vaultStatePubkey });
const permissionsMap = getProgramAndBitflagByProtocolName(glamClient.staging);

// Create policy with allowed destination addresses
const destinationAddress1 = new PublicKey("Dest1nation11111111111111111111111111111111");
const destinationAddress2 = new PublicKey("Dest2nation11111111111111111111111111111111");

const policy = new TransferPolicy([]);
policy.allowlist.push(destinationAddress1);
policy.allowlist.push(destinationAddress2);

// Get SPL Token protocol info
const [splProgram, tokenBitflag] = permissionsMap["SplToken"];

const txSig = await glamClient.access.setProtocolPolicy(
  new PublicKey(splProgram),
  parseInt(tokenBitflag, 2),
  policy.encode()
);
```

### Set Swap Policy

```typescript theme={null}
import { GlamClient, getProgramAndBitflagByProtocolName, SwapPolicy } from "@glamsystems/glam-sdk";
import { PublicKey } from "@solana/web3.js";

const glamClient = new GlamClient({ statePda: vaultStatePubkey });
const permissionsMap = getProgramAndBitflagByProtocolName(glamClient.staging);

// Create policy with allowed tokens for swapping
const allowedTokenMint1 = new PublicKey("Token1Mint1111111111111111111111111111111111");
const allowedTokenMint2 = new PublicKey("Token2Mint1111111111111111111111111111111111");

const policy = new SwapPolicy([]);
policy.allowlist.push(allowedTokenMint1);
policy.allowlist.push(allowedTokenMint2);

const [jupiterProgram, swapBitflag] = permissionsMap["JupiterSwap"];

const txSig = await glamClient.access.setProtocolPolicy(
  new PublicKey(jupiterProgram),
  parseInt(swapBitflag, 2),
  policy.encode()
);
```

## Emergency Access

Emergency updates bypass timelock for critical security situations.

```typescript theme={null}
import { GlamClient } from "@glamsystems/glam-sdk";
import { PublicKey } from "@solana/web3.js";

const glamClient = new GlamClient({ statePda: vaultStatePubkey });

// Emergency disable a compromised delegate
const compromisedDelegatePubkey = new PublicKey("Compromised11111111111111111111111111111111");

const txSig = await glamClient.access.emergencyAccessUpdate({
  disabledIntegrations: [],
  disabledDelegates: [compromisedDelegatePubkey],
  stateEnabled: true // keep vault enabled, just disable delegate
});
```

<Warning>
  Emergency access updates bypass the timelock and should only be used when immediate action is required.
</Warning>

## Common Patterns

### Trading Bot Setup

```typescript theme={null}
import { GlamClient, getProgramAndBitflagByProtocolName } from "@glamsystems/glam-sdk";
import { PublicKey } from "@solana/web3.js";
import { BN } from "@coral-xyz/anchor";

const glamClient = new GlamClient({ statePda: vaultStatePubkey });
const permissionsMap = getProgramAndBitflagByProtocolName(glamClient.staging);

// 1. Enable Jupiter Swap for the vault
const [jupiterProgram, jupiterBitflag] = permissionsMap["JupiterSwap"];
await glamClient.access.enableProtocols(
  new PublicKey(jupiterProgram),
  parseInt(jupiterBitflag, 2)
);

// 2. Grant bot delegate swap permissions
const botWallet = new PublicKey("TradingBot11111111111111111111111111111111");
await glamClient.access.grantDelegatePermissions(
  botWallet,
  new PublicKey(jupiterProgram),
  parseInt(jupiterBitflag, 2),
  new BN(0b001) // SwapAny permission
);
```

### Multisig Manager Setup

```typescript theme={null}
import { GlamClient, getProgramAndBitflagByProtocolName } from "@glamsystems/glam-sdk";
import { PublicKey } from "@solana/web3.js";
import { BN } from "@coral-xyz/anchor";

const glamClient = new GlamClient({ statePda: vaultStatePubkey });
const permissionsMap = getProgramAndBitflagByProtocolName(glamClient.staging);

// Different managers with different responsibilities
const treasuryManager = new PublicKey("Treasury111111111111111111111111111111111");
const lendingManager = new PublicKey("LendingMgr11111111111111111111111111111111");

// Enable Kamino Lending for the vault
const [kaminoLendingProgram, lendingBitflag] = permissionsMap["KaminoLend"];
await glamClient.access.enableProtocols(
  new PublicKey(kaminoLendingProgram),
  parseInt(lendingBitflag, 2)
);

// Treasury manager: deposit/withdraw only
await glamClient.access.grantDelegatePermissions(
  treasuryManager,
  new PublicKey(kaminoLendingProgram),
  parseInt(lendingBitflag, 2),
  new BN(0b00110) // Deposit + Withdraw
);

// Lending manager: full lending operations
await glamClient.access.grantDelegatePermissions(
  lendingManager,
  new PublicKey(kaminoLendingProgram),
  parseInt(lendingBitflag, 2),
  new BN(0b11110) // Deposit + Withdraw + Borrow + Repay
);
```

### AI Yield Optimizer

```typescript theme={null}
import { GlamClient, getProgramAndBitflagByProtocolName } from "@glamsystems/glam-sdk";
import { PublicKey } from "@solana/web3.js";
import { BN } from "@coral-xyz/anchor";

const glamClient = new GlamClient({ statePda: vaultStatePubkey });
const permissionsMap = getProgramAndBitflagByProtocolName(glamClient.staging);

// Enable Kamino lending and vaults
const [kaminoLendingProgram, lendingBitflag] = permissionsMap["KaminoLend"];
const [kaminoVaultsProgram, vaultsBitflag] = permissionsMap["KaminoVaults"];

await glamClient.access.enableProtocols(
  new PublicKey(kaminoLendingProgram),
  parseInt(lendingBitflag, 2)
);

await glamClient.access.enableProtocols(
  new PublicKey(kaminoVaultsProgram),
  parseInt(vaultsBitflag, 2)
);

// Grant AI agent permission to deposit/withdraw across protocols
const aiAgent = new PublicKey("AiAgent1111111111111111111111111111111111111");

await glamClient.access.grantDelegatePermissions(
  aiAgent,
  new PublicKey(kaminoLendingProgram),
  parseInt(lendingBitflag, 2),
  new BN(0b00110) // Deposit + Withdraw
);

await glamClient.access.grantDelegatePermissions(
  aiAgent,
  new PublicKey(kaminoVaultsProgram),
  parseInt(vaultsBitflag, 2),
  new BN(0b11) // Deposit + Withdraw
);
```

## References

* [Permissions](/v1/access-control/delegated-accounts#permissions) - Permission definitions
* [Access Control Framework](/v1/access-control/framework) - Conceptual overview
* [Delegated Accounts](/v1/access-control/delegated-accounts) - Permission definitions
* [Use Cases](/v1/access-control/use-cases) - Real-world scenarios


# Cross-Chain Transfer (CCTP)
Source: https://docs.glam.systems/v1/sdk/cctp

Bridge USDC across chains using Circle's CCTP

The `cctp` sub-client enables cross-chain USDC transfers using Circle's Cross-Chain Transfer Protocol (CCTP). This allows GLAM vaults to bridge USDC between Solana and EVM chains.

## Bridge USDC (Outgoing)

Send USDC from the vault on Solana to a destination on another chain:

```typescript theme={null}
import { GlamClient } from "@glamsystems/glam-sdk";
import { PublicKey } from "@solana/web3.js";
import { BN } from "@coral-xyz/anchor";

const glamClient = new GlamClient();

const txSig = await glamClient.cctp.bridgeUsdc(
  new BN(1_000_000), // 1 USDC (6 decimals)
  0, // destination domain (0 = Ethereum)
  new PublicKey("EvmAddr1111111111111111111111111"), // destination address as PublicKey
  {
    maxFee: new BN(500_000), // max fee in USDC units
    minFinalityThreshold: 1000,
  },
);
```

### CCTP Domain IDs

| Domain ID | Chain     |
| --------- | --------- |
| 0         | Ethereum  |
| 1         | Avalanche |
| 2         | Optimism  |
| 3         | Arbitrum  |
| 5         | Solana    |
| 6         | Base      |
| 7         | Polygon   |

## Receive USDC (Incoming)

Receive USDC from another chain into the vault. You need either the source transaction hash or nonce:

```typescript theme={null}
// Receive using transaction hash
const txSig = await glamClient.cctp.receiveUsdc(
  0, // source domain (Ethereum)
  { txHash: "0xabc123..." },
);

// Receive using nonce
const txSig = await glamClient.cctp.receiveUsdc(
  0,
  { nonce: "0x..." },
);
```

## Query Bridge Events

### Outgoing Events

Get all Solana-to-EVM bridge events for the vault:

```typescript theme={null}
const events = await glamClient.cctp.getOutgoingBridgeEvents({
  commitment: "confirmed",
});

for (const event of events) {
  console.log(event.amount.toString(), event.destinationDomain, event.status);
}
```

### Incoming Events

Get all EVM-to-Solana bridge events for the vault:

```typescript theme={null}
const events = await glamClient.cctp.getIncomingBridgeEvents({
  commitment: "confirmed",
});
```


# Create a Vault
Source: https://docs.glam.systems/v1/sdk/create-vault



GLAM provides a rich set of options to customize a vault. This page explains how to create and configure a vault using the GLAM SDK.

## Vault

To create a vault, we use the `state` sub-client's `create` method:

```typescript lines create-vault.ts theme={null}
import {
  GlamClient,
  WSOL,
  nameToChars,
  StateAccountType
} from "@glamsystems/glam-sdk";

// Initialize the GLAM client
const glamClient = new GlamClient();

// Build a vault state model
const stateModel = {
    accountType: StateAccountType.VAULT,
    name: nameToChars("GLAM Vault Demo"),
    enabled: true,
    assets: [WSOL],
};

// Create the vault
const txSig = await glamClient.state.create(
    stateModel,
    WSOL, // base asset
    { simulate: true },
);
```

The code above is equivalent to creating the vault with `glam-cli` using the following template:

```json lines vault.json theme={null}
{
  "state": {
    "accountType": "vault",
    "name": "GLAM Vault Demo",
    "enabled": true,
    "baseAssetMint": "So11111111111111111111111111111111111111112",
    "assets": ["So11111111111111111111111111111111111111112"]
  }
}
```

## Tokenized Vault

We need to use the `mint` sub-client's `initialize` method to create a tokenized vault. The vault state will be automatically created by the underlying `initialize_mint` instruction through CPI.

```typescript lines create-tokenized-vault.ts theme={null}
import {
  GlamClient,
  WSOL,
  nameToChars,
  StateAccountType
} from "@glamsystems/glam-sdk";

// Initialize the GLAM client
const glamClient = new GlamClient();

// Build a mint model
const mintModel = {
  name: nameToChars("GLAM Tokenized Vault Demo"),
  symbol: "gtvdSOL",
  baseAssetMint: WSOL,
  maxCap: new BN(1000_000_000_000), // 1000 SOL max cap
  minSubscription: new BN(1_000_000_000), // 1 SOL min subscription
  minRedemption: new BN(100_000_000), // 0.1 share min redemption
  lockupPeriod: new BN(0), // no lockup period on new shares
  feeStructure: {
    vault: {
      subscriptionFeeBps: 10,
      redemptionFeeBps: 20,
    },
    manager: {
      subscriptionFeeBps: 10,
      redemptionFeeBps: 20,
    },
    management: {
      feeBps: 10,
    },
    performance: {
      feeBps: 2000,
      hurdleRateBps: 500,
      hurdleType: { hard: {} },
    },
    protocol: {
      baseFeeBps: 0, // will be overwritten in program with 1
      flowFeeBps: 0, // will be overwritten in program with 2000
    },
  },
  notifyAndSettle: {
    model: { continuous: {} },
    permissionlessFulfillment: false, // only manager can fulfill
    subscribeNoticePeriodType: { hard: {} },
    subscribeNoticePeriod: new BN(0), // not needed for a vault that allows instant subscription
    subscribeSettlementPeriod: new BN(0), // not needed for a vault that allows instant subscription
    subscribeCancellationWindow: new BN(0), // not needed for a vault that allows instant subscription
    redeemNoticePeriodType: { hard: {} },
    redeemNoticePeriod: new BN(0), // not set
    redeemSettlementPeriod: new BN(0), // not set
    redeemCancellationWindow: new BN(0), // not set
    timeUnit: { slot: {} },
    padding: [0, 0, 0],
  }
}

// Create the tokenized vault
const txSig = await glamClient.mint.initialize(
    mintModel,
    StateAccountType.TOKENIZED_VAULT,
    { simulate: true },
);
```

The code above is equivalent to creating the vault with `glam-cli` using the following template:

```json lines tokenized-vault.json theme={null}
{
  "state": {
    "accountType": "tokenizedVault",
    "enabled": true
  },
  "mint": {
    "name": "GLAM Tokenized Vault Demo",
    "symbol": "gtvdSOL",
    "baseAssetMint": "So11111111111111111111111111111111111111112",
    "maxCap": 1000000000000,
    "minSubscription": 1000000000,
    "minRedemption": 100000000,
    "lockupPeriod": 0,
    "feeStructure": {
      "vault": {
        "subscriptionFeeBps": 10,
        "redemptionFeeBps": 10
      },
      "manager": {
        "subscriptionFeeBps": 0,
        "redemptionFeeBps": 0
      },
      "management": {
        "feeBps": 0
      },
      "performance": {
        "feeBps": 2000,
        "hurdleRateBps": 5,
        "hurdleType": "hard"
      }
    },
    "notifyAndSettle": {
      "model": "continuous",
      "permissionlessFulfillment": false,
      "subscribeNoticePeriodType": "hard",
      "subscribeNoticePeriod": 0,
      "subscribeSettlementPeriod": 0,
      "subscribeCancellationWindow": 0,
      "redeemNoticePeriodType": "hard",
      "redeemNoticePeriod": 0,
      "redeemSettlementPeriod": 0,
      "redeemCancellationWindow": 0,
      "timeUnit": "slot"
    }
  }
}
```


# Custom Wallet
Source: https://docs.glam.systems/v1/sdk/custom-wallet



## Default Initialization

Initialize `GlamClient` by setting the `ANCHOR_PROVIDER_URL` and `ANCHOR_WALLET` environment variables:

```typescript theme={null}
import { GlamClient, ClusterNetwork } from '@glamsystems/glam-sdk';

const glamClient = new GlamClient();
```

## Keypair Wallet

Alternatively, initialize `GlamClient` with an RPC URL and wallet keypair:

```typescript theme={null}
import NodeWallet from "@coral-xyz/anchor/dist/cjs/nodewallet";
import { AnchorProvider } from "@coral-xyz/anchor";
import { Connection, Keypair } from "@solana/web3.js";
import { GlamClient, ClusterNetwork } from "@glamsystems/glam-sdk";

const connection = new Connection("https://api.mainnet-beta.solana.com");
const keypairPath = "/path/to/wallet/keypair.json";

const loadWallet = (path: string) => {
  let keypair = Keypair.fromSecretKey(
    Buffer.from(
      JSON.parse(require("fs").readFileSync(path, { encoding: "utf-8" })),
    ),
  );
  return new NodeWallet(keypair);
};

const glamClient = new GlamClient({
  provider: new AnchorProvider(connection, loadWallet(keypairPath)),
  cluster: ClusterNetwork.Mainnet,
});
```

## Custom Wallet Implementation

Any custom wallet that implements the `Wallet` interface can be used with `GlamClient`.

### Read-Only Wallet

A read-only wallet allows querying vault data without signing transactions:

```typescript theme={null}
import { Wallet } from "@coral-xyz/anchor/dist/cjs/provider";
import { Connection, PublicKey, Transaction, VersionedTransaction } from "@solana/web3.js";
import { GlamClient, ClusterNetwork } from "@glamsystems/glam-sdk";

class ReadOnlyWallet implements Wallet {
  constructor(readonly pubkey: PublicKey) {}
  signTransaction<T extends Transaction | VersionedTransaction>(tx: T): Promise<T> {
    throw new Error("Method not implemented.");
  }
  signAllTransactions<T extends Transaction | VersionedTransaction>(txs: T[]): Promise<T[]> {
    throw new Error("Method not implemented.");
  }
  get publicKey(): PublicKey {
    return this.pubkey;
  }
}

const connection = new Connection("https://api.mainnet-beta.solana.com");
const wallet = new ReadOnlyWallet(new PublicKey("<ReadOnlyWalletPubkey>"));

const glamClient = new GlamClient({
  provider: new AnchorProvider(connection, wallet),
  cluster: ClusterNetwork.Mainnet,
  statePda: new PublicKey("<GlamStatePda>"),
});
```


# Fee Management
Source: https://docs.glam.systems/v1/sdk/fees

Crystallize, claim, and configure fees for tokenized vaults

The `fees` sub-client manages fee operations for tokenized vaults, including crystallization, claiming, and protocol fee configuration.

For an overview of the fee structure, see [Fees](/v1/operations/fees).

## Fee Lifecycle

Fees in GLAM tokenized vaults follow a three-step lifecycle:

1. **Accrue** — Fees accumulate based on the vault's fee structure (management, performance, subscription, redemption)
2. **Crystallize** — Accrued fees are calculated and recorded onchain
3. **Claim** — Crystallized fees are transferred to the manager and protocol

## Crystallize Fees

Crystallize accrued management and performance fees. This must be called before claiming:

```typescript theme={null}
import { GlamClient } from "@glamsystems/glam-sdk";

const glamClient = new GlamClient();

const txSig = await glamClient.fees.crystallizeFees();
```

<Info>
  Crystallization triggers vault pricing internally. The vault must have up-to-date price data for accurate fee calculation.
</Info>

## Claim Fees

Claim crystallized fees. Fees are distributed to the vault manager and the protocol:

```typescript theme={null}
const txSig = await glamClient.fees.claimFees();
```

## Query Fees

### Get Claimable Fees

View fees that have been crystallized and are ready to claim:

```typescript theme={null}
const claimable = await glamClient.fees.getClaimableFees();
```

### Get Claimed Fees

View the history of fees that have already been claimed:

```typescript theme={null}
const claimed = await glamClient.fees.getClaimedFees();
```

## Set Protocol Fees

Configure protocol-level fee rates (requires protocol authority):

```typescript theme={null}
await glamClient.fees.setProtocolFees(
  1,    // baseFeeBps (basis points)
  2000, // flowFeeBps (basis points)
);
```


# GLAM SDK
Source: https://docs.glam.systems/v1/sdk/introduction

Integrate with the GLAM TypeScript SDK

The GLAM TypeScript SDK provides a comprehensive interface for building decentralized applications on top of the GLAM protocol.

## Installation

Visit the [npm registry](https://www.npmjs.com/package/@glamsystems/glam-sdk?updated=true) to view all available versions. To install the latest version, run:

```bash theme={null}
npm i @glamsystems/glam-sdk
```

## Examples

The [GLAM CLI](https://github.com/glamsystems/glam-cli) is built on top of the SDK and serves as a comprehensive reference implementation.

Additional example apps are available in the [SDK repository](https://github.com/glamsystems/glam-sdk/tree/main/examples).


# Investment Flows
Source: https://docs.glam.systems/v1/sdk/invest

Subscribe to and redeem from tokenized vaults

The `invest` sub-client handles subscription and redemption flows for tokenized vaults. It supports both instant and queued modes depending on the vault's configuration.

For conceptual details on subscription and redemption flows, see [Flows](/v1/operations/flows).

## Subscribe

Subscribe to a tokenized vault by depositing the base asset and receiving vault shares.

### Instant Subscription

When the vault supports instant subscriptions, shares are issued in the same transaction:

```typescript theme={null}
import { GlamClient } from "@glamsystems/glam-sdk";
import { BN } from "@coral-xyz/anchor";

const glamClient = new GlamClient();

// Subscribe with 10 SOL (instant mode)
const txSig = await glamClient.invest.subscribe(
  new BN(10_000_000_000), // amount in base asset units
  false, // queued = false for instant
);
```

### Queued Subscription

When the vault requires pricing delays or notice periods, use queued subscription:

```typescript theme={null}
// Subscribe with 10 SOL (queued mode)
const txSig = await glamClient.invest.subscribe(
  new BN(10_000_000_000),
  true, // queued = true
);
```

## Redeem

### Queued Redemption

Submit a redemption request to burn vault shares and receive the base asset:

```typescript theme={null}
// Redeem 5 shares
const txSig = await glamClient.invest.queuedRedeem(
  new BN(5_000_000_000),
);
```

## Fulfill Requests

The vault manager (or any actor, if permissionless fulfillment is enabled) can fulfill pending subscription and redemption requests:

```typescript theme={null}
// Fulfill up to 10 pending requests
const txSig = await glamClient.invest.fulfill(10);

// Fulfill all pending requests
const txSig = await glamClient.invest.fulfill(null);
```

<Info>
  Before fulfilling requests, the vault must be priced. See [Pricing](/v1/sdk/pricing) for details on generating pricing instructions.
</Info>

## Claim

After a request is fulfilled, the subscriber must claim to complete the flow:

```typescript theme={null}
// Claim for the connected wallet
const txSig = await glamClient.invest.claim();

// Claim for a specific user (manager only)
const txSig = await glamClient.invest.claimForUser(
  new PublicKey("User1111111111111111111111111111"),
);
```

## Cancel

Cancel a pending request before it is fulfilled:

```typescript theme={null}
// Cancel the connected wallet's pending request
const txSig = await glamClient.invest.cancel();

// Cancel a specific user's request (manager only)
const txSig = await glamClient.invest.cancelForUser(
  new PublicKey("User1111111111111111111111111111"),
);
```

## Query Pending Requests

Fetch the pending subscription or redemption request for a user:

```typescript theme={null}
// Fetch pending request for connected wallet
const request = await glamClient.invest.fetchPendingRequest();

// Fetch pending request for a specific user
const request = await glamClient.invest.fetchPendingRequest(
  new PublicKey("User1111111111111111111111111111"),
);
```

## End-to-End Example

A complete queued subscription flow:

```typescript theme={null}
import { GlamClient } from "@glamsystems/glam-sdk";
import { BN } from "@coral-xyz/anchor";

const glamClient = new GlamClient();

// 1. Subscriber submits a queued subscription
await glamClient.invest.subscribe(new BN(10_000_000_000), true);

// 2. Manager prices the vault
const pricingIxs = await glamClient.price.priceVaultIxs();
// ... send pricing transaction

// 3. Manager fulfills pending requests
await glamClient.invest.fulfill(null);

// 4. Subscriber claims their shares
await glamClient.invest.claim();
```


# Jupiter
Source: https://docs.glam.systems/v1/sdk/jupiter

Execute token swaps through Jupiter aggregator

The `jupiterSwap` sub-client enables token swaps through the Jupiter aggregator for GLAM vaults.

<Info>
  Jupiter integration requires a Jupiter API key. Configure it when initializing the client:

  ```typescript theme={null}
  const glamClient = new GlamClient({ jupiterApiKey: "YOUR_JUPITER_API_KEY" });
  ```
</Info>

## Swap

Execute a token swap through Jupiter. The `swap` method accepts Jupiter quote parameters, a quote response, or pre-built swap instructions:

```typescript theme={null}
import { GlamClient, WSOL } from "@glamsystems/glam-sdk";
import { PublicKey } from "@solana/web3.js";

const glamClient = new GlamClient({ jupiterApiKey: "YOUR_API_KEY" });

const USDC = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");

// Swap 1 SOL to USDC using quote parameters
const txSig = await glamClient.jupiterSwap.swap({
  quoteParams: {
    inputMint: WSOL.toBase58(),
    outputMint: USDC.toBase58(),
    amount: 1_000_000_000, // 1 SOL
    slippageBps: 50, // 0.5% slippage
  },
});
```

### Swap with Quote Response

If you have already fetched a Jupiter quote, pass it directly:

```typescript theme={null}
// Fetch quote externally
const quoteResponse = await fetchJupiterQuote(/* ... */);

// Swap using the pre-fetched quote
const txSig = await glamClient.jupiterSwap.swap({ quoteResponse });
```

### Swap with Pre-built Instructions

For full control, pass pre-built swap instructions:

```typescript theme={null}
const txSig = await glamClient.jupiterSwap.swap({
  swapInstructions: {
    // Jupiter swap instructions object
  },
});
```

## Transaction Options

Pass `TxOptions` to customize the swap transaction:

```typescript theme={null}
const txSig = await glamClient.jupiterSwap.swap(
  {
    quoteParams: {
      inputMint: WSOL.toBase58(),
      outputMint: USDC.toBase58(),
      amount: 1_000_000_000,
      slippageBps: 50,
    },
  },
  {
    simulate: true,
    maxFeeLamports: 100_000,
  },
);
```


# Kamino
Source: https://docs.glam.systems/v1/sdk/kamino

Interact with Kamino Lending, Vaults, and Farms

GLAM integrates with Kamino for lending, vault deposits, and yield farming. The SDK provides three sub-clients:

* `kaminoLending` — Kamino Lending (collateral, borrowing)
* `kaminoVaults` — Kamino Vaults (yield vaults)
* `kaminoFarm` — Kamino Farms (staking and rewards)

## Kamino Lending

### Initialize

Initialize user metadata for Kamino Lending:

```typescript theme={null}
import { GlamClient } from "@glamsystems/glam-sdk";
import { BN } from "@coral-xyz/anchor";
import { PublicKey } from "@solana/web3.js";

const glamClient = new GlamClient();

const txSig = await glamClient.kaminoLending.initUserMetadata();
```

### Deposit Collateral

Deposit collateral into a Kamino lending market:

```typescript theme={null}
const market = new PublicKey("KaminoMk111111111111111111111111");
const USDC = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");

const txSig = await glamClient.kaminoLending.deposit(
  market,
  USDC,
  new BN(1_000_000_000), // amount in base units
);
```

### Withdraw Collateral

Withdraw collateral from a Kamino lending market:

```typescript theme={null}
const txSig = await glamClient.kaminoLending.withdraw(
  market,
  USDC,
  new BN(500_000_000),
);
```

### Borrow

Borrow assets from a Kamino lending market:

```typescript theme={null}
const txSig = await glamClient.kaminoLending.borrow(
  market,
  USDC,
  new BN(200_000_000),
);
```

### Repay

Repay borrowed assets:

```typescript theme={null}
const txSig = await glamClient.kaminoLending.repay(
  market,
  USDC,
  new BN(200_000_000),
);
```

## Kamino Vaults

### Deposit

Deposit into a Kamino yield vault:

```typescript theme={null}
const kaminoVault = new PublicKey("KaminoVt111111111111111111111111");

const txSig = await glamClient.kaminoVaults.deposit(
  kaminoVault,
  new BN(1_000_000_000),
);
```

### Withdraw

Withdraw from a Kamino yield vault:

```typescript theme={null}
const txSig = await glamClient.kaminoVaults.withdraw(
  kaminoVault,
  new BN(500_000_000),
);
```

## Kamino Farms

### Stake

Stake tokens into a Kamino farm:

```typescript theme={null}
const farmState = new PublicKey("KaminoFm111111111111111111111111");

const txSig = await glamClient.kaminoFarm.stake(
  new BN(1_000_000_000),
  farmState,
);
```

### Unstake

Unstake tokens from a Kamino farm:

```typescript theme={null}
const txSig = await glamClient.kaminoFarm.unstake(
  new BN(500_000_000),
  farmState,
);
```

### Harvest Rewards

Claim farming rewards from one or more farms:

```typescript theme={null}
const txSig = await glamClient.kaminoFarm.harvest([farmState]);
```


# Mint Management
Source: https://docs.glam.systems/v1/sdk/mint-management

Initialize, configure, and manage tokenized vault mints

The `mint` sub-client manages the lifecycle of tokenized vault mints, including initialization, configuration updates, subscription/redemption pausing, and token account management.

For creating a tokenized vault with a mint, see [Create a Vault](/v1/sdk/create-vault).

## Initialize Mint

Create a new tokenized vault by initializing a mint. The vault state is automatically created by the underlying `initialize_mint` instruction. The `uri` should point to a publicly hosted JSON document, see [Token Metadata](/v1/platform/mints#token-metadata) for the schema and hosting guidance.

```typescript theme={null}
import {
  GlamClient,
  WSOL,
  nameToChars,
  StateAccountType,
} from "@glamsystems/glam-sdk";
import { BN } from "@coral-xyz/anchor";

const glamClient = new GlamClient();

const txSig = await glamClient.mint.initialize({
  accountType: StateAccountType.TOKENIZED_VAULT,
  name: nameToChars("My Fund"),
  symbol: "gFUND",
  uri: "https://raw.githubusercontent.com/your-org/token-metadata/main/gfund.json",
  baseAssetMint: WSOL,
  maxCap: new BN(1_000_000_000_000),
  minSubscription: new BN(1_000_000_000),
  minRedemption: new BN(100_000_000),
  lockupPeriod: new BN(0),
});
```

### Permanent Delegate

The `permanentDelegate` field on `mint.initialize` controls the Token-2022 [Permanent Delegate](https://www.solana-program.com/docs/token-2022/extensions#permanent-delegate) extension. It accepts three meaningfully different values:

| Value             | Behavior                                                                                                                    |
| ----------------- | --------------------------------------------------------------------------------------------------------------------------- |
| `null` (default)  | Extension not enabled. No party can force-transfer or burn investor shares.                                                 |
| System Program ID | Sentinel. The mint PDA itself is set as the permanent delegate, meaning the GLAM Mint Program retains programmatic control. |
| Any other key     | The provided key holds the permanent-delegate authority directly and unconditionally.                                       |

```typescript theme={null}
import { SystemProgram } from "@solana/web3.js";

await glamClient.mint.initialize({
  // ...other fields
  permanentDelegate: SystemProgram.programId, // recommended when the extension is required
});
```

* **Why the sentinel matters:** When the delegate is set to `SystemProgram.programId`, `initialize_mint` substitutes the mint PDA as the on-chain authority. Any forced transfer or burn must therefore be invoked through a GLAM Mint Program instruction signed by the program via PDA seeds, gated by GLAM access control rather than a single keypair.
* **Rotation rules:** `mint.update` can rotate the permanent delegate **only if the current delegate is the mint itself**. Once a non-mint key has been set, that key must rotate the authority directly (`spl-token authorize <mint> permanent-delegate <new>`); the vault manager cannot reclaim it through GLAM.

#### Best practices

* Default to `null` unless you have a documented compliance reason to enable the extension.
* Prefer the `SystemProgram.programId` sentinel over an external key. It keeps the authority programmatic and rotatable through GLAM.
* Never use a single EOA as the delegate. If you must point it at an external account, use a multisig (e.g., Squads).
* Disclose the configuration. If the extension is enabled, document who holds the authority and under what conditions it will be exercised.
* Plan for the lifetime of the key. Once a non-mint delegate is set, your operational procedures (custody, multisig membership, recovery) become load-bearing for the vault.

## Update Mint

Update mint configuration parameters:

```typescript theme={null}
await glamClient.mint.update({
  maxCap: new BN(5_000_000_000_000), // increase max cap
  minSubscription: new BN(500_000_000), // lower minimum
});
```

## Pause and Unpause

Temporarily halt subscriptions or redemptions:

```typescript theme={null}
// Pause subscriptions
await glamClient.mint.pauseSubscription();

// Resume subscriptions
await glamClient.mint.unpauseSubscription();

// Pause redemptions
await glamClient.mint.pauseRedemption();

// Resume redemptions
await glamClient.mint.unpauseRedemption();
```

## Token Account Management

### Create Token Account

Create a token account for a user to hold vault shares:

```typescript theme={null}
await glamClient.mint.createTokenAccount(
  new PublicKey("User1111111111111111111111111111"),
  true, // frozen by default
);
```

### Freeze and Unfreeze Accounts

Control the transferability of vault shares by freezing or unfreezing token accounts:

```typescript theme={null}
// Freeze token accounts
await glamClient.mint.setTokenAccountsStates(
  [new PublicKey("TokenAcc111111111111111111111111")],
  true, // frozen
);

// Unfreeze token accounts
await glamClient.mint.setTokenAccountsStates(
  [new PublicKey("TokenAcc111111111111111111111111")],
  false, // unfrozen
);
```

## Fetch Token Holders

Retrieve all token holders for the vault mint:

```typescript theme={null}
// Get holders with non-zero balances
const holders = await glamClient.mint.fetchTokenHolders();

// Include zero-balance holders
const allHolders = await glamClient.mint.fetchTokenHolders(true);
```

## Close Mint

Close the mint account. The vault must have zero outstanding shares:

```typescript theme={null}
await glamClient.mint.close();
```


# GlamClient
Source: https://docs.glam.systems/v1/sdk/overview



The `GlamClient` class is the main entry point for the GLAM SDK. It uses lazy initialization to load sub-clients only when needed, optimizing performance and resource usage.

```mermaid theme={null}
graph TB
    GC[GlamClient]
    BC[BaseClient]

    GC -->|extends| BC

    CORE[Sub-clients: Core Operations]
    PROTO[Sub-clients: Protocol Integrations]

    GC -.->|lazy load| CORE
    GC -.->|lazy load| PROTO

    MODELS[Data Models<br/><i>StateModel, MintModel</i>]
    GC --> MODELS

    PROGRAMS[GLAM Programs<br/><i>protocol, mint, etc</i>]
    BC -->|RPC| PROGRAMS

    style GC fill:#010101,stroke:#fefefe,color:#fefefe,stroke-width:3px
    style BC fill:#333,stroke:#fefefe,color:#fefefe
    style CORE fill:#444,stroke:#fefefe,color:#fefefe
    style PROTO fill:#444,stroke:#fefefe,color:#fefefe
    style MODELS fill:#555,stroke:#fefefe,color:#fefefe
    style PROGRAMS fill:#666,stroke:#fefefe,color:#fefefe
```

`GlamClient` extends `BaseClient`, which provides:

* **Connection Management**: Handles Solana RPC connections
* **Transaction Processing**: Sign, send, and confirm transactions
* **Program Integration**: Interfaces with GLAM Protocol programs

## Initialization

Initialize `GlamClient` with the default Anchor provider and wallet:

```typescript theme={null}
import { GlamClient, ClusterNetwork } from '@glamsystems/glam-sdk';

// ANCHOR_PROVIDER_URL and ANCHOR_WALLET env variables must be set
const glamClient = new GlamClient();
```

The client can be customized by providing a `GlamClientConfig` object:

```typescript theme={null}
export type GlamClientConfig = {
  provider?: Provider;
  wallet?: Wallet;
  cluster?: ClusterNetwork;
  statePda?: PublicKey;
  jupiterApiKey?: string;
};
```

For example, if Jupiter functionality is used, the Jupiter API key should be configured as follows:

```typescript theme={null}
const glamClient = new GlamClient({ jupiterApiKey: "YOUR_JUPITER_API_KEY" });
```

Refer to [Custom Wallet](./custom-wallet) for more information on how to use a custom wallet.

### Sub-clients

Sub-clients are lazily loaded on first access. For a comprehensive list, see [client.ts](https://github.com/glamsystems/glam-sdk-ts/blob/main/src/client.ts).

| Sub-client      | Category             | Description                                         |
| --------------- | -------------------- | --------------------------------------------------- |
| `jupiterSwap`   | Protocol Integration | Jupiter swap integration                            |
| `kaminoLending` | Protocol Integration | Kamino lending integration                          |
| `kaminoFarm`    | Protocol Integration | Kamino farming integration                          |
| `kaminoVaults`  | Protocol Integration | Kamino vaults integration                           |
| `cctp`          | Protocol Integration | Cross-Chain Transfer Protocol                       |
| `vault`         | Core Operations      | Vault management                                    |
| `access`        | Core Operations      | ACL management                                      |
| `timelock`      | Core Operations      | Time lock management                                |
| `invest`        | Core Operations      | Investment flows (for tokenized vaults)             |
| `fees`          | Core Operations      | Fee management (for tokenized vaults)               |
| `price`         | Core Operations      | Pricing tokens and positions (for tokenized vaults) |
| `state`         | Utilities            | Vault state queries                                 |

## Transaction Builder

Each sub-client provides a `TxBuilder` instance for constructing instructions and transactions.

### Building Instructions

To build an instruction that enables Jupiter Swap on a vault:

```typescript theme={null}
const permissionsMap = getProgramAndBitflagByProtocolName(glamClient.staging);
const [integrationProgram, protocolBitflag] = permissionsMap["JupiterSwap"];

const ix = await glamClient.access.txBuilder.enableDisableProtocolsIx(
  new PublicKey(integrationProgram),
  parseInt(protocolBitflag, 2),
  true,
  signer
);
```

### Building Transactions

To build a complete transaction:

```typescript theme={null}
const tx = await glamClient.access.txBuilder.enableDisableProtocolsTx(
  new PublicKey(integrationProgram),
  parseInt(protocolBitflag, 2),
  true,
  txOptions
);
```

## Sending Transactions

Convert a legacy transaction to a versioned transaction and send it:

```typescript theme={null}
const vTx = await glamClient.intoVersionedTransaction(tx, txOptions); 
const txSig = await glamClient.sendAndConfirm(vTx); 
```

## Transaction Options

Most client methods accept an optional `TxOptions` parameter:

```typescript theme={null}
const txOptions: TxOptions = {
  simulate: true,
  maxFeeLamports: 100_000, // 0.0001 SOL
  useMaxFee: true
}

await glamClient.invest.subscribe(amount, false, txOptions);
```

The `TxOptions` type provides additional configuration for transactions:

```typescript theme={null}
export type TxOptions = {
  signer?: PublicKey;
  computeUnitLimit?: number;
  getPriorityFeeMicroLamports?: (tx: VersionedTransaction) => Promise<number>;
  maxFeeLamports?: number;
  useMaxFee?: boolean;
  preInstructions?: TransactionInstruction[];
  lookupTables?: PublicKey[] | AddressLookupTableAccount[];
  simulate?: boolean;
};
```

**Available options:**

* `signer`: Override the default signer
* `computeUnitLimit`: Set the compute unit limit
* `getPriorityFeeMicroLamports`: Callback function to calculate dynamic priority fees
* `maxFeeLamports`: Set the maximum priority fee
* `useMaxFee`: Use the maximum priority fee
* `preInstructions`: Add instructions before the main instruction
* `lookupTables`: Include address lookup tables
* `simulate`: Simulate the transaction before sending

## State Model

The SDK abstracts on-chain vault state using the `StateModel` class, which defines the vault's configuration at creation time.

```typescript lines state-model.ts theme={null}
export class StateIdlModel implements StateModelType {
  accountType: StateAccountType; // vault or tokenizedVault
  name: number[];                // vault name encoded as char array
  uri: string | null;            // vault URI
  enabled: boolean | null;       // enabled flag
  assets: PublicKey[] | null;    // allowed assets
  created: CreatedModel | null;  // creation seeds, pubkey, and timestamp
  owner: PublicKey | null;       // vault owner
  portfolioManagerName: number[] | null;    // portfolio manager name encoded as char array
  borrowable: PublicKey[] | null;           // borrowable assets
  timelockDuration: number | null;          // timelock duration in seconds
  integrationAcls: IntegrationAcl[] | null; // integration ACLs
  delegateAcls: DelegateAcl[] | null;       // delegate ACLs
  ...
}
```

### Fetching Vault State

Fetch the state of the active vault:

```typescript theme={null}
const stateModel = await glamClient.fetchStateModel();
```

Or fetch the state of a specific vault by passing its state account public key:

```typescript theme={null}
const stateModel = await glamClient.fetchStateModel(vaultStatePubkey);
```

## Mint Model

The SDK represents on-chain mint data using the `MintModel` class, which defines the tokenized vault's configuration at creation time.

```typescript lines mint-model.ts theme={null}
export class MintIdlModel implements MintModelType {
  symbol: string;  // token metadata symbol
  name: number[];  // token metadata name
  uri: string;     // token metadata URI
  yearInSeconds: number | null;         // number of seconds in a year
  permanentDelegate: PublicKey | null;  // permanent delegate
  defaultAccountStateFrozen: boolean | null; // default account state is frozen if true, otherwise active
  feeStructure: FeeStructure | null;    // fee configurations
  notifyAndSettle: NotifyAndSettle | null;// notification and settlement periods 
  lockupPeriod: number | null;            // lockup period in seconds
  maxCap: BN | null;                      // maximum vault capacity
  minSubscription: BN | null;             // minimum subscription amount
  minRedemption: BN | null;               // minimum redemption amount
  allowlist: PublicKey[] | null;          // allowlist of users    
  blocklist: PublicKey[] | null;          // blocklist of users
  ...
}
```

### Accessing Mint Model

Access the `MintModel` of a tokenized vault via its `stateModel`:

```typescript theme={null}
const mintModel = stateModel.mintModel;
```

## Use Staging Programs

<Warning>
  GLAM mainnet staging programs are available for testing and development purposes. They contain unaudited code and features that are not yet ready for production.
</Warning>

To use staging programs, make sure env variable `NEXT_PUBLIC_GLAM_STAGING` or `GLAM_STAGING`, is set to `true`.


# Pricing & Valuation
Source: https://docs.glam.systems/v1/sdk/pricing

Price vault assets and validate AUM for tokenized vaults

The `price` sub-client handles vault asset pricing, which is required before fulfilling subscription/redemption requests or crystallizing fees.

For an overview of pricing concepts, see [Pricing](/v1/operations/pricing).

<Warning>
  Do not read `FeeParams` from the GLAM State Account to display current AUM or NAV. Those fields are fee-accounting checkpoints. Use pricing instructions, AUM validation, or vault holdings for current valuation data.
</Warning>

## Pricing Instructions

Generate all necessary pricing instructions for a vault. The method automatically detects which integrations are enabled and builds the appropriate set of instructions:

```typescript theme={null}
import { GlamClient } from "@glamsystems/glam-sdk";

const glamClient = new GlamClient();

// Get all pricing instructions for the vault
const pricingIxs = await glamClient.price.priceVaultIxs();
```

The returned instructions cover:

* **Vault tokens** — Prices all token balances in the vault
* **Kamino obligations** — Prices Kamino Lending collateral and debt positions
* **Kamino vault shares** — Prices Kamino Vault share holdings
* **Stake accounts** — Prices native stake account balances

### SingleAssetVault

For `SingleAssetVault` types, pricing is simplified since the vault holds only one asset:

```typescript theme={null}
// priceVaultIxs() automatically detects the vault type
// and returns a single priceSingleAssetVault instruction
const pricingIxs = await glamClient.price.priceVaultIxs();
```

For `SingleAssetVault` vaults, current priced AUM is based on the current balance of the vault's base-asset token account. `FeeParams.last_aum` may differ after subscriptions because it records the AUM checkpoint used during the last fee crystallization.

## Validate AUM

After pricing, validate the computed AUM:

```typescript theme={null}
const validateIx = await glamClient.price.validateAumIx();
```

## Vault Holdings

Fetch all vault holdings with current prices for display or analysis:

```typescript theme={null}
const holdings = await glamClient.price.getVaultHoldings("confirmed");

// Access individual holdings
for (const holding of holdings) {
  console.log(holding.mintAddress, holding.uiAmount, holding.price);
}
```

## Pricing Workflow

A typical pricing workflow before fulfilling requests:

```typescript theme={null}
// 1. Build pricing instructions
const pricingIxs = await glamClient.price.priceVaultIxs();

// 2. Build validate AUM instruction
const validateIx = await glamClient.price.validateAumIx();

// 3. Send pricing + validation as a transaction
const tx = new Transaction().add(...pricingIxs, validateIx);
const vTx = await glamClient.intoVersionedTransaction(tx);
await glamClient.sendAndConfirm(vTx);

// 4. Now fulfill pending requests
await glamClient.invest.fulfill(null);
```

<Warning>
  Pricing transactions can be large when a vault has many assets or DeFi positions. Use [address lookup tables](/v1/cli/alt) to reduce transaction size.
</Warning>


# Squads Multisig
Source: https://docs.glam.systems/v1/sdk/squads-multisig



When a GLAM vault is owned by a Squads multisig, all vault operations must go through the Squads approval process. This guide shows how to create Squads proposals for GLAM vault operations using the SDK.

## Prerequisites

* A GLAM vault where the manager is set to a Squads vault PDA
* A wallet with Squads Proposer permission
* The `@sqds/multisig` package installed alongside the GLAM SDK

## How It Works

1. Build a GLAM instruction using the SDK's `txBuilder` methods
2. Wrap the instruction in a Squads vault transaction
3. Create a Squads proposal for multisig members to vote on
4. Once approved, the transaction executes through Squads

## Creating a Proposal

The following example creates a proposal to enable the JupiterSwap protocol on a vault:

```typescript theme={null}
import { PublicKey, Transaction, TransactionMessage } from "@solana/web3.js";
import { GlamClient, getProgramAndBitflagByProtocolName } from "@glamsystems/glam-sdk";
import * as multisig from "@sqds/multisig";

// Initialize clients
const glamClient = new GlamClient({
  statePda: new PublicKey("GlamState111111111111111111111111111111111"),
});
const multisigPda = new PublicKey("SquadsMultisig111111111111111111111111111");

// Derive the Squads vault PDA (index 0 is the default vault)
const [squadsVaultPda] = multisig.getVaultPda({
  multisigPda,
  index: 0,
});

// 1. Build the GLAM instruction
const permissionsMap = getProgramAndBitflagByProtocolName(glamClient.staging);
const [integrationProgram, protocolBitflag] = permissionsMap["JupiterSwap"];

const ix = await glamClient.access.txBuilder.enableDisableProtocolsIx(
  new PublicKey(integrationProgram),
  parseInt(protocolBitflag, 2),
  true, // enable
  squadsVaultPda // signer is the Squads vault
);

// 2. Wrap into a transaction message
const blockhash = (await glamClient.blockhashWithCache.get()).blockhash;
const txMessage = new TransactionMessage({
  payerKey: squadsVaultPda,
  recentBlockhash: blockhash,
  instructions: [ix],
});

// 3. Get the next transaction index
const multisigInfo = await multisig.accounts.Multisig.fromAccountAddress(
  glamClient.connection,
  multisigPda
);
const newTransactionIndex = BigInt(Number(multisigInfo.transactionIndex) + 1);

// 4. Create Squads vault transaction instruction
const ixCreateSquadsTx = multisig.instructions.vaultTransactionCreate({
  multisigPda,
  transactionIndex: newTransactionIndex,
  creator: glamClient.signer,
  vaultIndex: 0,
  ephemeralSigners: 0,
  transactionMessage: txMessage,
});

// 5. Create Squads proposal instruction
const ixCreateSquadsProposal = multisig.instructions.proposalCreate({
  multisigPda,
  creator: glamClient.signer,
  transactionIndex: newTransactionIndex,
});

// 6. Send the transaction
const tx = new Transaction().add(ixCreateSquadsTx, ixCreateSquadsProposal);
const vTx = await glamClient.intoVersionedTransaction(tx);
const txSig = await glamClient.sendAndConfirm(vTx);

// 7. Get the proposal URL
const [transactionPda] = multisig.getTransactionPda({
  multisigPda,
  index: newTransactionIndex,
});
console.log(
  "View proposal:",
  `https://app.squads.so/squads/${squadsVaultPda}/transactions/${transactionPda}`
);
```

## Finding Your Squads Multisig Address

The multisig PDA is different from the Squads vault address. To find it:

1. Go to `https://app.squads.so/squads/<your-squads>/settings`
2. Look for the "Multisig Account" address

## Other Vault Operations

You can create proposals for any GLAM vault operation by using the appropriate `txBuilder` method:

```typescript theme={null}
// Grant delegate permissions
const ix = await glamClient.access.txBuilder.grantDelegatePermissionsIx(
  delegatePubkey,
  new PublicKey(integrationProgram),
  parseInt(protocolBitflag, 2),
  permissions,
  squadsVaultPda
);

// Set protocol policy
const ix = await glamClient.access.txBuilder.setProtocolPolicyIx(
  new PublicKey(integrationProgram),
  parseInt(protocolBitflag, 2),
  policy.encode(),
  squadsVaultPda
);
```

The pattern is the same: build the instruction with `squadsVaultPda` as the signer, wrap it in a Squads transaction, and create a proposal.

## After Creating a Proposal

Once the proposal is created:

1. Share the proposal URL with other multisig members
2. Members vote on the proposal through the Squads UI
3. When the threshold is reached, any member can execute the transaction
4. The GLAM vault operation takes effect

## References

* [Access Control](/v1/sdk/access-control) - Managing vault permissions
* [Squads Protocol](https://docs.squads.so/) - Official Squads documentation


# Timelock
Source: https://docs.glam.systems/v1/sdk/timelock

Configure and manage vault update timelocks

The `timelock` sub-client manages timelock configuration for vaults. Timelocks add a mandatory delay between proposing and applying vault configuration changes, providing protection against unauthorized or hasty modifications.

For conceptual details, see [Timelock](/v1/operations/timelock).

## Set Timelock Duration

Configure the timelock duration in seconds. Once set, any subsequent vault state or mint updates will require waiting for this duration before they can be applied:

```typescript theme={null}
import { GlamClient } from "@glamsystems/glam-sdk";

const glamClient = new GlamClient();

// Set a 24-hour timelock (86400 seconds)
const txSig = await glamClient.timelock.set(86400);
```

## Apply Timelock

After the timelock duration has elapsed, apply the pending changes:

```typescript theme={null}
const txSig = await glamClient.timelock.apply();
```

The `apply` method automatically detects the vault type:

* For **Vault** types, it applies state timelock changes
* For **TokenizedVault** types, it applies mint timelock changes

## Cancel Timelock

Cancel pending timelock changes before they are applied:

```typescript theme={null}
const txSig = await glamClient.timelock.cancel();
```


# Vault Operations
Source: https://docs.glam.systems/v1/sdk/vault-operations

Manage vault assets: deposits, transfers, SOL wrapping, and token account management

The `vault` sub-client provides methods for managing vault assets, including depositing tokens, transferring assets, wrapping/unwrapping SOL, and managing token accounts.

## Depositing Assets

### Deposit Tokens

Deposit tokens from the signer's wallet into the vault:

```typescript theme={null}
import { GlamClient, WSOL } from "@glamsystems/glam-sdk";

const glamClient = new GlamClient();

// Deposit 100 USDC (6 decimals) into the vault
const txSig = await glamClient.vault.deposit(
  new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"), // USDC mint
  100_000_000, // 100 USDC in base units
);
```

### Deposit SOL

Deposit SOL directly into the vault. Optionally wrap it to wSOL:

```typescript theme={null}
// Deposit 1 SOL and wrap it to wSOL
const txSig = await glamClient.vault.depositSol(
  1_000_000_000, // 1 SOL in lamports
  true, // wrap to wSOL
);

// Deposit 1 SOL without wrapping
const txSig = await glamClient.vault.depositSol(
  1_000_000_000,
  false,
);
```

## SOL Wrapping

### Wrap SOL

Wrap vault SOL into wSOL:

```typescript theme={null}
import { BN } from "@coral-xyz/anchor";

// Wrap 5 SOL to wSOL
const txSig = await glamClient.vault.wrap(new BN(5_000_000_000));
```

### Unwrap wSOL

Unwrap all vault wSOL back to SOL:

```typescript theme={null}
const txSig = await glamClient.vault.unwrap();
```

## Transfers

### Transfer SOL

Transfer SOL from the vault to another account:

```typescript theme={null}
const txSig = await glamClient.vault.systemTransfer(
  1_000_000_000, // 1 SOL
  new PublicKey("Recipient111111111111111111111111"),
);
```

### Transfer Tokens

Transfer tokens from the vault to another account:

```typescript theme={null}
const txSig = await glamClient.vault.tokenTransfer(
  new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"), // USDC mint
  50_000_000, // 50 USDC
  new PublicKey("Recipient111111111111111111111111"),
);
```

## Token Account Management

### Close Token Accounts

Close vault token accounts to reclaim rent. Pass an array of token account public keys:

```typescript theme={null}
const txSig = await glamClient.vault.closeTokenAccounts([
  new PublicKey("TokenAcc111111111111111111111111"),
  new PublicKey("TokenAcc211111111111111111111111"),
]);
```


# Security
Source: https://docs.glam.systems/v1/security



## Security Audits

| **Name**                                                                                                                                                        | **Firm**                                   | **Date**          | **Notes**                                                                                                                                  |
| :-------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------- | :---------------- | :----------------------------------------------------------------------------------------------------------------------------------------- |
| [GLAM Protocol Audit](https://github.com/AdevarLabs/audit-reports/blob/main/reports/2025-11-07_GLAM_audit_report.pdf)                                           | [Adevar Labs](https://www.adevarlabs.com/) | November 7, 2025  | The security audit focused on GLAM core programs and external integrations.                                                                |
| [Protocol Integration Patches Audit Report](https://github.com/AdevarLabs/audit-reports/blob/main/reports/2025-12-15_GLAM_integration_patches_audit_report.pdf) | [Adevar Labs](https://www.adevarlabs.com/) | December 15, 2025 | The audit covered Jupiter swap v2 with slippage checks, Kamino upstream breaking change fix, and automatic wSOL synchronization.           |
| [SingleAssetVault Audit Report](https://github.com/AdevarLabs/audit-reports/blob/main/reports/2026-02-07_GLAM_SingleAssetVault_audit_report.pdf)                | [Adevar Labs](https://www.adevarlabs.com/) | February 07, 2026 | This audit reviews a single commit. That commit adds the SingleAssetVault type, a tokenized vault that is priced solely by its base asset. |
| [Security Enhancements Audit Report](https://github.com/AdevarLabs/audit-reports/blob/main/reports/2026-04-07_GLAM_Security_Enhancements_audit_report.pdf)      | [Adevar Labs](https://www.adevarlabs.com/) | April 08, 2026    | This review focused on changes around swap execution, trusted external price feeds, Kamino integrations, and shared permission refactors.  |

## Program Framework

GLAM programs are built with [Anchor 0.31.1](https://www.anchor-lang.com/docs/updates/release-notes/0-31-1), a framework for building secure Solana programs.

## Development Status

The repository is currently private during active development. When major versions are released, they will be made public under the Business Source License (BSL). According to the BSL terms, the code will eventually transition to open source (Apache 2.0).

## Source Code Access

During the private development phase, if you would like access to the source code, please contact us at [help@glam.systems](mailto:help@glam.systems). We are happy to provide access upon request.


# Welcome to GLAM
Source: https://docs.glam.systems/v1/welcome

Onchain infrastructure for institutional asset management and tokenization.

<img />

GLAM is a protocol for programmable investment infrastructure on Solana. It provides composable primitives like vaults, mints, integrations, policies, and permissions to launch tokenized products and onchain strategies with precision and control.

Whether you manage a treasury, run an investment strategy, or create products for others to invest in, GLAM handles the operational complexity so you can focus on what matters.

## Use Cases

<CardGroup>
  <Card title="Tokenized Vaults" icon="binary">
    Create transparent investment products that external investors can access.

    Launch funds, structured products, or managed strategies with embedded compliance and automated investor operations. Maintain operational control while automating flows, fee collection, and policy enforcement.

    *Designed for: Asset managers, institutions, protocol teams, investment advisors*
  </Card>

  <Card title="Vaults" icon="vault">
    Manage your own assets with fine-grained access controls and seamless integrations.

    Deploy treasury funds, automate DeFi strategies, or manage portfolios with fine-grained access controls and risk management. Delegate specific permissions while maintaining control and enforce compliance rules at the protocol level.

    *Designed for: DAOs, family offices, treasury teams, sophisticated investors*
  </Card>
</CardGroup>

## Architecture

GLAM separates asset management into programmable components that work together:

<CardGroup>
  <Card title="Vaults" icon="diamonds-4">
    Vaults manage assets with embedded risk controls and automated operations. Define who can act, what they can do, and which protocols they can access. Rules are recorded and enforced onchain at the protocol level.
  </Card>

  <Card title="Mints" icon="grid-round-2">
    Mints turn vaults into investable products. Add investor access, compliance rules, and token distribution while keeping operational control. Handle subscriptions, redemptions, and regulatory requirements automatically.
  </Card>
</CardGroup>

## Capabilities

<Card title="Native Protocol Integrations">
  Connect to leading Solana protocols for trading, lending, staking, and liquidity provision with built-in safeguards and policy enforcement. Each integration includes risk controls and operational boundaries designed for institutional use.
</Card>

<CardGroup>
  <Card title="Onchain Access Control">
    Delegate specific permissions to team members, automated systems, or external managers without giving up control. Assign trading rights or protocol access on a per-wallet basis with granular permissions.
  </Card>

  <Card title="Programmable Policies">
    Enforce rules automatically at the protocol level. Define asset allowlists, protocol restrictions, delegation boundaries, and compliance requirements that execute without human oversight or intervention.
  </Card>
</CardGroup>

<Card title="Automated Pricing and Operations">
  Calculate NAV across DeFi positions and automate subscription and redemption flows with transparent pricing. Handle complex fee structures including management fees, performance fees, hurdle rates, and high-water marks.
</Card>

## Start Using GLAM

New to GLAM? Start here to learn how to manage assets and create tokenized products.

<CardGroup>
  <Card title="Create Your First Vault" href="/v1/quickstart">
    Deploy a vault and start managing assets onchain today.
  </Card>

  <Card title="Discover the Platform" href="/v1/platform/overview">
    Explore the full capabilities of GLAM's infrastructure and integrations.
  </Card>
</CardGroup>

## Developer Tools

We provide a suite of developer tools to accelerate builders:

<CardGroup>
  <Card title="SDK" icon="network-wired" href="/v1/sdk/introduction">
    TypeScript library
  </Card>

  <Card title="CLI" icon="square-terminal" href="/v1/cli/introduction">
    Command-line interface
  </Card>

  <Card title="API (coming soon)" icon="webhook">
    REST API & WebSockets
  </Card>
</CardGroup>