# Solana Actions

### Overview

Solana vault interactions use the same pattern as EVM:

1. Use `sdk.getVault()` to query vault data
2. Use `sdk.solana.vaultDeposit()` to deposit
3. Use `sdk.solana.vaultRedeem()` to withdraw

The SDK handles all Solana-specific complexities (PDAs, token accounts, etc.) automatically.

### Setup

#### Basic Initialization

Include Solana RPC endpoint when initializing the SDK:

```typescript
import { AugustSDK } from '@augustdigital/sdk';

const sdk = new AugustSDK({
  providers: {
    -1: 'https://api.mainnet-beta.solana.com', // Solana Mainnet
  },
});

// Access Solana adapter
const solana = sdk.solana;
```

#### Custom RPC Endpoint

```typescript
const sdk = new AugustSDK({
  providers: {
    -1: 'https://solana-mainnet.g.alchemy.com/v2/YOUR_KEY',
  },
});
```

#### For Write Operations

To execute transactions, you need to set a wallet provider:

```typescript
import { useWallet } from '@solana/wallet-adapter-react';

// In your React component
const { publicKey, signTransaction } = useWallet();

// Set wallet for signing transactions
if (publicKey && signTransaction) {
  sdk.solana.setWalletProvider(publicKey, signTransaction);
}
```

### Adapter API

#### Methods

**setWalletProvider()**

Set the wallet provider for write operations.

```typescript
sdk.solana.setWalletProvider(
  publicKey: PublicKey | string,
  signTransaction: (tx: Transaction) => Promise<Transaction>
): void
```

**Parameters:**

* `publicKey`: User's Solana public key
* `signTransaction`: Function to sign transactions (from wallet adapter)

**Example:**

```typescript
import { useWallet } from '@solana/wallet-adapter-react';

function MyComponent() {
  const { publicKey, signTransaction } = useWallet();

  useEffect(() => {
    if (publicKey && signTransaction) {
      sdk.solana.setWalletProvider(publicKey, signTransaction);
    }
  }, [publicKey, signTransaction]);
}
```

### Get Vault Data

Query Solana vault information using the same `sdk.getVault()` method as EVM vaults.

```typescript
sdk.getVault({
  vault: string;  // Solana program ID
  chainId?: number;  // -1 for mainnet
  options?: {
    solanaWallet?: string;  // For user position data
  };
}): Promise<IVault>
```

#### Parameters

| Parameter              | Type     | Required | Description                                |
| ---------------------- | -------- | -------- | ------------------------------------------ |
| `vault`                | `string` | Yes      | Solana vault program ID                    |
| `options.solanaWallet` | `string` | No       | User's Solana public key for position data |

#### Example

```typescript
// Get vault details
const vault = await sdk.getVault({
  vault: 'VaultProgramId...',
  chainId: -1, // Solana mainnet
});

console.log('Name:', vault.name);
console.log('Version:', vault.version); // "sol-0"
console.log('Total Assets:', vault.totalAssets.normalized);
console.log('APY:', vault.apy.apy);
console.log('Deposit Token:', vault.depositAssets[0].symbol);

// Get vault with user position
const vaultWithPosition = await sdk.getVault({
  vault: 'VaultProgramId...',
  chainId: -1,
  options: {
    solanaWallet: 'UserPublicKey...',
  },
});

if (vaultWithPosition.position) {
  console.log(
    'Your balance:',
    vaultWithPosition.position.walletBalance.normalized,
  );
}
```

#### Get All Solana Vaults

```typescript
const solanaVaults = await sdk.getVaults({
  chainIds: [-1], // Filter to Solana mainnet only
  solanaWallet: 'UserPublicKey...', // Optional: include positions
});

solanaVaults.forEach((vault) => {
  console.log(`${vault.name}: ${vault.totalAssets.normalized} TVL`);
});
```

#### Get User Positions

```typescript
const positions = await sdk.getVaultPositions({
  solanaWallet: 'UserPublicKey...',
  chainId: -1,
});

positions.forEach((position) => {
  console.log(`Vault: ${position.vault}`);
  console.log(`Balance: ${position.walletBalance.normalized}`);
});
```

### Vault Deposit

Deposit tokens into a Solana vault. The SDK automatically handles token accounts, PDAs, and Anchor program interactions.

```typescript
sdk.solana.vaultDeposit({
  vault: string;
  amount: string | number | bigint;
  wallet: string;
  wait?: boolean;
}): Promise<string>
```

#### Parameters

| Parameter | Type                         | Required | Description                            |
| --------- | ---------------------------- | -------- | -------------------------------------- |
| `vault`   | `string`                     | Yes      | Solana vault program ID                |
| `amount`  | `string \| number \| bigint` | Yes      | Amount to deposit                      |
| `wallet`  | `string`                     | Yes      | User's Solana public key               |
| `wait`    | `boolean`                    | No       | Wait for confirmation (default: false) |

#### Returns

Transaction signature as `string`

#### Example

```typescript
import { useWallet } from '@solana/wallet-adapter-react';

// In your React component
const { publicKey, signTransaction } = useWallet();

// Set wallet provider (once per session)
if (publicKey && signTransaction) {
  sdk.solana.setWalletProvider(publicKey, signTransaction);
}

// Get vault info
const vault = await sdk.getVault({
  vault: 'VaultProgramId...',
  chainId: -1,
});

// Deposit
const signature = await sdk.solana.vaultDeposit({
  vault: vault.address,
  amount: '100', // 100 tokens
  wallet: publicKey.toString(),
  wait: true,
});

console.log('Deposit successful:', signature);
```

#### Behavior

The SDK automatically:

1. Fetches vault state and PDAs
2. Gets or creates associated token accounts
3. Handles token approvals if needed
4. Converts amount to proper decimals
5. Submits transaction via wallet adapter
6. Optionally waits for confirmation

### Vault Withdraw

Request withdrawal from a Solana vault.

```typescript
sdk.solana.vaultRedeem({
  vault: string;
  amount: string | number | bigint;
  wallet: string;
  wait?: boolean;
}): Promise<string>
```

#### Parameters

| Parameter | Type                         | Required | Description                |
| --------- | ---------------------------- | -------- | -------------------------- |
| `vault`   | `string`                     | Yes      | Solana vault program ID    |
| `amount`  | `string \| number \| bigint` | Yes      | Amount of shares to redeem |
| `wallet`  | `string`                     | Yes      | User's Solana public key   |
| `wait`    | `boolean`                    | No       | Wait for confirmation      |

#### Returns

Transaction signature as `string`

#### Example

```typescript
// Get user's vault balance
const position = await sdk.getVaultPositions({
  solanaWallet: publicKey.toString(),
  chainId: -1,
});

if (position[0].walletBalance.raw === '0') {
  throw new Error('No balance to withdraw');
}

// Request redemption
const signature = await sdk.solana.vaultRedeem({
  vault: 'VaultProgramId...',
  amount: '50', // Redeem 50 shares
  wallet: publicKey.toString(),
  wait: true,
});

console.log('Redemption requested:', signature);
```

### Examples

#### Complete Deposit Flow

```typescript
import { AugustSDK } from '@augustdigital/sdk';
import { useWallet } from '@solana/wallet-adapter-react';
import { PublicKey } from '@solana/web3.js';

function SolanaVaultDeposit() {
  const { publicKey, signTransaction } = useWallet();
  const [loading, setLoading] = useState(false);

  const sdk = new AugustSDK({
    providers: {
      -1: 'https://api.mainnet-beta.solana.com',
    },
  });

  const deposit = async (vaultId: string, amount: string) => {
    if (!publicKey || !signTransaction) {
      throw new Error('Wallet not connected');
    }

    setLoading(true);
    try {
      // 1. Set wallet provider
      sdk.solana.setWalletProvider(publicKey, signTransaction);

      // 2. Get vault details
      const vault = await sdk.getVault({
        vault: vaultId,
        chainId: -1,
      });

      console.log(`Depositing to ${vault.name}`);

      // 3. Execute deposit (SDK handles everything)
      const signature = await sdk.solana.vaultDeposit({
        vault: vaultId,
        amount,
        wallet: publicKey.toString(),
        wait: true,
      });

      console.log('Deposit successful:', signature);
      return signature;
    } catch (error) {
      console.error('Deposit failed:', error);
      throw error;
    } finally {
      setLoading(false);
    }
  };

  return (
    <button
      onClick={() => deposit('VaultProgramId...', '100')}
      disabled={loading || !publicKey}
    >
      {loading ? 'Depositing...' : 'Deposit 100 Tokens'}
    </button>
  );
}
```

#### Complete Withdrawal Flow

```typescript
function SolanaVaultWithdraw() {
  const { publicKey, signTransaction } = useWallet();

  const sdk = new AugustSDK({
    providers: {
      -1: 'https://api.mainnet-beta.solana.com',
    },
  });

  const withdraw = async (vaultId: string) => {
    if (!publicKey || !signTransaction) {
      throw new Error('Wallet not connected');
    }

    try {
      // 1. Set wallet provider
      sdk.solana.setWalletProvider(publicKey, signTransaction);

      // 2. Check user's position
      const position = await sdk.getVaultPositions({
        solanaWallet: publicKey.toString(),
        chainId: -1,
      });

      if (!position[0] || position[0].walletBalance.raw === '0') {
        throw new Error('No balance to withdraw');
      }

      const balance = position[0].walletBalance.normalized;
      console.log(`Withdrawing ${balance} shares`);

      // 3. Execute redemption
      const signature = await sdk.solana.vaultRedeem({
        vault: vaultId,
        amount: balance, // Withdraw all
        wallet: publicKey.toString(),
        wait: true,
      });

      console.log('Withdrawal successful:', signature);
      return signature;
    } catch (error) {
      console.error('Withdrawal failed:', error);
      throw error;
    }
  };

  return (
    <button onClick={() => withdraw('VaultProgramId...')}>
      Withdraw All
    </button>
  );
}
```

#### Query Vault Before Depositing

```typescript
// 1. Get vault info
const vault = await sdk.getVault({
  vault: 'VaultProgramId...',
  chainId: -1,
});

// 2. Check if deposits are enabled
if (vault.isDepositPaused) {
  throw new Error('Vault deposits are paused');
}

// 3. Show user the vault details
console.log(`Vault: ${vault.name}`);
console.log(`APY: ${vault.apy.apy}%`);
console.log(`TVL: ${vault.totalAssets.normalized}`);
console.log(`Deposit token: ${vault.depositAssets[0].symbol}`);

// 4. Deposit
await sdk.solana.vaultDeposit({
  vault: vault.address,
  amount: '100',
  wallet: publicKey.toString(),
  wait: true,
});
```

### Advanced Operations

For advanced use cases, the Solana adapter exposes low-level methods and utilities.

#### Direct Program Access

Access Solana connection and provider for custom operations:

```typescript
// Get connection
const connection = sdk.solana.connection;
const balance = await connection.getBalance(publicKey);

// Get Anchor provider
const provider = sdk.solana.provider;

// Get program instance
import { vaultIdl } from '@augustdigital/sdk';
const program = sdk.solana.getProgram(vaultIdl);

// Query vault account directly
const vaultState = await program.account.vault.fetch(vaultPda);
```

#### Utility Functions

```typescript
import { Solana } from '@augustdigital/sdk';
```

**deriveShareMintPda()**

Derive the share mint PDA for a vault.

```typescript
const shareMintPda = Solana.utils.deriveShareMintPda('VaultProgramId...');

console.log('Share Mint PDA:', shareMintPda.toString());
```

**getToken()**

Get token metadata from mint address.

```typescript
const token = await Solana.utils.getToken({
  mintAddress: 'MintPublicKey...',
  endpoint: 'https://api.mainnet-beta.solana.com',
  connection: sdk.solana.connection,
});

console.log('Symbol:', token.symbol);
console.log('Decimals:', token.decimals);
console.log('Supply:', token.supply);
```

#### getVaultStateReadOnly()

Get vault state without a wallet provider.

```typescript
const vaultState = await Solana.utils.getVaultStateReadOnly({
  vaultProgramId: 'VaultProgramId...',
  idl: vaultIdl,
  endpoint: 'https://api.mainnet-beta.solana.com',
  connection: sdk.solana.connection,
});
```

#### getProvider()

Create an Anchor provider with wallet.

```typescript
import { PublicKey } from '@solana/web3.js';

const provider = Solana.utils.getProvider({
  network: 'mainnet-beta',
  connection: sdk.solana.connection,
  publicKey: new PublicKey('UserPublicKey...'),
  signTransaction: signTransactionFunction,
});
```

#### getReadOnlyProvider()

Create a read-only Anchor provider.

```typescript
const provider = Solana.utils.getReadOnlyProvider({
  network: 'mainnet-beta',
  connection: sdk.solana.connection,
});
```

#### getProgram()

Create an Anchor program instance.

```typescript
const program = Solana.utils.getProgram({
  network: 'mainnet-beta',
  provider: anchorProvider,
  idl: programIdl,
});
```

### Constants

The Solana adapter provides useful constants:

```typescript
import { Solana } from '@augustdigital/sdk';
```

#### Vault IDL

```typescript
const vaultIdl = Solana.constants.vaultIdl;
```

#### Program IDs

```typescript
const programIds = Solana.constants.programIds;

console.log('Vault Program:', programIds.vaultProgram);
```

#### Fallback Values

```typescript
const fallbackDecimals = Solana.constants.fallbackDecimals; // 9
const fallbackNetwork = Solana.utils.fallbackNetwork; // 'mainnet-beta'
```

### Error Handling

#### Connection Errors

```typescript
try {
  const vaultState = await sdk.solana.getVaultState('VaultId...', vaultIdl);
} catch (error) {
  if (error.message.includes('404')) {
    console.error('Vault program not found');
  } else if (error.message.includes('Network request failed')) {
    console.error('RPC connection failed');
  } else {
    console.error('Unknown error:', error);
  }
}
```

#### Transaction Errors

```typescript
try {
  await handleSolanaDeposit({
    connection: sdk.solana.connection,
    provider: sdk.solana.provider,
    vaultProgramId: 'VaultId...',
    amount: 1000000000,
    userTokenAccount: 'TokenAccount...',
    idl: vaultIdl,
  });
} catch (error) {
  if (error.message.includes('User rejected')) {
    console.error('Transaction cancelled by user');
  } else if (error.message.includes('insufficient funds')) {
    console.error('Not enough SOL for transaction');
  } else {
    console.error('Transaction failed:', error);
  }
}
```


---

# Agent Instructions: Querying This Documentation

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

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

```
GET https://docs.augustdigital.io/developers/typescript-sdk/code-examples/solana-actions.md?ask=<question>
```

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

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