Symmetry Protocol

https://docs.symmetry.fi/
Admin
Symmetry is an on-chain asset management protocol that allows users to create, manage, and trade...
Tokens:22,273
Snippets:93
Trust Score:7.6
Update:10 months ago
Show doc for...
Tokens:
Raw
### Get Oracle Prices using Symmetry SDK

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

Fetches current prices from the oracle. This function returns an array of numbers representing the prices.

```javascript
let txs: number[] = await basketsSdk.getOraclePrices();
```

--------------------------------

### Baskets SDK Initialization and Basic Operations

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

This section covers initializing the Baskets SDK, loading supported tokens, retrieving token IDs, and setting the wallet.

```APIDOC
## Baskets SDK Initialization and Basic Operations

### Description
Initialize the Baskets SDK and perform basic operations like loading tokens and setting the wallet.

### Method
Initialization involves calling static methods.

### Endpoint
N/A (SDK methods)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```javascript
import { BasketsSDK } from "@symmetry-hq/baskets-sdk";
import { Connection, Wallet } from "@solana/web3.js";

// Initialize SDK
let basketsSdk = await BasketsSDK.init(
    // rpc connection
    connection: Connection,
    // wallet (optional, can be provided later, using setWallet())
    wallet: Wallet
);

// Load list of supported tokens
let tokens = basketsSdk.getTokenListData();

// Get tokenId from mint address
let tokenId = basketsSdk.tokenIdFromMint(
  "So11111111111111111111111111111111111111112"
);

// Set wallet
basketsSdk.setWallet(wallet: Wallet);
```

### Response
#### Success Response (200)
- **tokens** (TokenSettings[]) - An array of supported token configurations.
- **tokenId** (string) - The token identifier for Symmetry.

#### Response Example
```json
// Example for getTokenListData()
[
  {
    "mint": "EPjFWdd5AufqSSVr5fPEzPjU6Wvcj9f11KqfFfSgU7Z",
    "tokenId": "USDC",
    "decimals": 6,
    "logoURI": "..."
  }
]

// Example for tokenIdFromMint()
"USDC"
```
```

--------------------------------

### Create Basket with Rules using Symmetry.fi Baskets SDK (JavaScript)

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

This snippet demonstrates how to initialize the Baskets SDK and create a new basket with specified parameters. It includes settings for management fees, mutability, asset pool composition, automated refiltering, reweighting, rebalancing intervals and thresholds, slippage limits, liquidity provision, and complex rules for asset selection and weighting. Dependencies include the `@symmetry-hq/baskets-sdk` library.

```javascript
import {
  BasketsSDK,
  Basket,
  BuyState,
  FilterType,
  FilterTime,
  SortBy,
  WeightType,
  WeightTime
} from "@symmetry-hq/baskets-sdk";

/*  init baskets sdk */
let basketsSdk: BasketsSDK = await BasketsSDK.init(
   connection,
   wallet
);

/*  Create a basket (CreateBasket + SetRules + Refilter&Reweight) */
let basket: Basket = await basketsSdk.createBasket({
  name: "Solana Bitcoin Ethereum",
  symbol: "SOLBTCETH",
  uri: "",
  hostPlatform: wallet.publicKey,     // platform hosting UI 
  hostPlatformFee: 0,                 // fees on deposits for host 
  manager: wallet.publicKey,          // basket manager
  managerFee: 10,                     // deposit fee in bps: 10 = 0.1%
  activelyManaged: 1,                 // actively managed
  assetPool: [0, 1, 2, 3],            // USDC, SOL, BTC, ETH
  refilterInterval: 7 * 24 * 3600,    // 1 week
  reweightInterval: 24 * 3600,        // 1 day
  rebalanceInterval: 2 * 3600,        // 2 hours
  rebalanceThreshold: 500,            // 5%
  rebalanceSlippage: 300,             // 3%
  lpOffsetThreshold: 5000,            // 50% of rebalance threshold
  disableRebalance: 0,                // Auto Rebalance is on
  disableLp: 0,                       // Liquidity provision is on
  rules: [{
    filterBy: FilterType.MarketCap,   // filter assets by marketcap
    filterDays: FilterTime.Week,      // by 1 week average of marketcap
    sortBy: SortBy.DescendingOrder,   // select top coins by marketcap
    totalWeight: 100,                 // total weight of this rule
    fixedAsset: 0,                    // (provide if filterBy is Fixed)
    numAssets: 3,                     // select 3 assets
    weightBy: WeightType.Performance, // weight by performance
    weightDays: WeightTime.Day,       // 1 day performance
    weightExpo: 0.5,                  // square root of performance
    excludeAssets: [0],               // Exclude USDC when filtering
   }],
});
```

--------------------------------

### Initialize Baskets SDK

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

Initializes the Baskets SDK with a provided RPC connection and an optional wallet. It allows fetching supported token data and retrieving token IDs from mint addresses. The wallet can also be set separately after initialization.

```javascript
import { BasketsSDK } from "@symmetry-hq/baskets-sdk";

let basketsSdk: BasketsSDK = await BasketsSDK.init(
    // rpc connection
    connection: Connection,
    // wallet (optional, can be provided later, using setWallet() 
    wallet: Wallet,
);

// load list of supported tokens(returns TokenSettings array)
let tokens: TokenSettings[] = basketsSdk.getTokenListData();

// get tokenId(tokenId in symmetry supported tokens) from mint
let tokenId = basketsSdk.tokenIdFromMint(
  "So11111111111111111111111111111111111111112"
);

// set wallet
basketsSdk.setWallet(wallet: Wallet);
```

--------------------------------

### Loading Basket Data

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

This section explains how to load individual baskets by their public key or find multiple baskets based on filters.

```APIDOC
## Loading Basket Data

### Description
Retrieve basket information, either a single basket by its public key or a list of baskets based on specific filters.

### Method
SDK methods for loading basket data.

### Endpoint
N/A (SDK methods)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```javascript
// Load a specific basket by its public key
let basket = await basketsSdk.loadFromPubkey(pubkey: PublicKey);

// Find baskets based on filters
let baskets = await basketsSdk.findBaskets(filters: FilterOption[]);
let baskets = await basketsSdk.findBaskets([
  {
    filterType: "manager" | "host",
    filterPubkey: PublicKey
  }
]);

// Get current compositions and parsed data for loaded baskets
let currentCompositions = await basketsSdk.getCurrentCompositions(baskets: Basket[]);
```

### Response
#### Success Response (200)
- **loadFromPubkey**: Returns a `Basket` object.
- **findBaskets**: Returns an array of `Basket` objects.
- **getCurrentCompositions**: Returns an array of `CurrentComposition` objects.

#### Response Example
```json
// Example for loadFromPubkey() or findBaskets()
{
  "address": "BasketPublicKey",
  "name": "Example Basket",
  // ... other basket properties
}

// Example for getCurrentCompositions()
[
  {
    "basket": "BasketPublicKey",
    "composition": [
      { "token": "TokenMintAddress", "amount": 1000000, "decimals": 6 }
    ],
    "basketWorth": 1500000,
    "rawPrice": 1.5
  }
]
```
```

--------------------------------

### Buying Basket Tokens

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

This section outlines the different methods available for purchasing basket tokens using the Baskets SDK.

```APIDOC
## Buying Basket Tokens

### Description
Purchase basket tokens through various methods provided by the SDK, including buying with a single token or contributing all tokens from a basket's composition.

### Method
SDK methods for buying basket tokens.

### Endpoint
N/A (SDK methods)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
Parameters specific to the buying method (e.g., token public key, amounts).

### Request Example
```javascript
// Option 1: Buy with a single token
let expectedAmountSingle = await basketsSdk.computeMintAmountWithSingleToken(
  basket: Basket,
  token: PublicKey,
  amount: number
);
let txSingle = await basketsSdk.buyWithSingleToken(
  basket: Basket,
  token: PublicKey,
  amount: number
);

// Option 2: Contribute all tokens from basket's composition
let expectedAmountAll = await basketsSdk.computeMintAmount(
  basket: Basket,
  amounts: number[]
);
let txAll = await basketsSdk.buyBasketInstant(
  basket: Basket,
  amounts: number[]
);
```

### Response
#### Success Response (200)
- **computeMintAmountWithSingleToken/computeMintAmount**: Returns the expected amount of basket tokens to be minted.
- **buyWithSingleToken/buyBasketInstant**: Returns a transaction signature for the purchase.

#### Response Example
```json
// Example for computeMintAmountWithSingleToken() or computeMintAmount()
150.75

// Example for buyWithSingleToken() or buyBasketInstant()
"txSignatureHere"
```
```

--------------------------------

### Generate Basket Instructions using Symmetry SDK

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

Provides utility functions to generate TransactionInstruction objects for various basket operations. This includes instructions for closing baskets, refiltering, reweighting, buying with a single token, and instant burns, among others.

```javascript
import { BasketInstructions } from "@symmetry-hq/baskets-sdk";
let ix: TransactionInstruction = await BasketInstructions.closeBasketIx(...);
let ix: TransactionInstruction = await BasketInstructions.refilterBasketIx(...);
let ix: TransactionInstruction = await BasketInstructions.reweightBasketIx(...);
let ix: TransactionInstruction = await BasketInstructions.buyBasketWithSingleTokenIx(...);
let ix: TransactionInstruction = await BasketInstructions.instantBurnIx(...);
```

--------------------------------

### Load Baskets by Public Key or Filters

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

Enables loading specific basket details using its public key or finding multiple baskets based on provided filters, such as manager or host platform public keys. It can also fetch current compositions and parsed data like TVL and price.

```javascript
let basket: Basket = await basketsSdk.loadFromPubkey(pubkey: PublicKey);

let baskets: Basket[] = await basketsSdk.findBaskets(filters: FilterOption[]);
let baskets: Basket[] = await basketsSdk.findBaskets([
  {
    filterType: "manager"|"host",
    filterPubkey: PublicKey
  }
]);

let currentCompositions: CurrentComposition[] =
  await basketsSdk.getCurrentCompositions(baskets: Basket[]);

```

--------------------------------

### POST /baskets/create

Source: https://docs.symmetry.fi/infrastructure/symmetry-apis

Creates a new basket on the Symmetry.fi platform. This endpoint allows users to define the parameters of a new basket, including its symbol, name, composition, and various settings related to rebalancing and fees.

```APIDOC
## POST /baskets/create

### Description
Creates a new basket with specified parameters.

### Method
POST

### Endpoint
https://api.symmetry.fi/baskets/create

### Parameters
#### Request Body
- **symbol** (string) - Required - Basket Symbol/Ticker (3-10 characters).
- **name** (string) - Required - Basket name (3-60 characters).
- **uri** (string) - Optional - URI containing desired metadata in JSON format (Max 300 characters).
- **hostPlatform** (string) - Optional - A project integrating Symmetry may receive hostPlatformFees.
- **hostPlatformFees** (number) - Optional - Fee in bps (0.1% = 10) for host platform wallet.
- **creator** (string) - Required - Wallet PublicKey of a user creating a basket.
- **depositFee** (number) - Optional - Fee charged on deposits for creator (in bps).
- **type** (number) - Optional - Basket type: 0 = Immutable, 1 = Mutable, 2 = Permissioned.
- **rebalanceInterval** (number) - Optional - Frequency of rebalance checks in seconds.
- **rebalanceThreshold** (number) - Optional - Allowed deviation from target weights before rebalancing, in bps.
- **slippage** (number) - Optional - Maximum allowed slippage for rebalance transactions, in bps.
- **lpOffsetThreshold** (number) - Optional - EXPERIMENTAL: Defines liquidity pool behavior for rebalancing. 0 disables this feature.
- **disableRebalance** (number) - Optional - Controls automatic rebalancing: 0 = enabled, 1 = disabled.
- **disableLp** (number) - Optional - Controls liquidity pool functionality: 0 = enabled, 1 = disabled.
- **composition** (array) - Required - Array of desired basket composition. Each object should have:
  - **token** (string) - Required - Token address.
  - **weight** (number) - Required - Token weight in the basket.

### Request Example
```json
{
  "symbol": "FAVTOKENS",
  "name": "My Portfolio Basket",
  "uri": "",
  "hostPlatform": "4Vry5hGDmbwGwhjgegHmoitjMHniSotpjBFkRuDYHcDG",
  "hostPlatformFee": 10,
  "creator": "userPublicKey",
  "depositFee": 50,
  "type": 1,
  "rebalanceInterval": 3600,
  "rebalanceThreshold": 300,
  "slippage": 100,
  "lpOffsetThreshold": 0,
  "disableRebalance": 0,
  "disableLp": 1,
  "composition": [
    { "token": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "weight": 40 },
    { "token": "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263", "weight": 60 }
  ]
}
```

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the operation was successful.
- **createTransaction** (string) - Base64 encoded transaction for basket creation.
- **compositionTransaction** (string) - Base64 encoded transaction for setting basket composition.
- **restructureTransaction** (string) - Base64 encoded transaction for restructuring the basket.

#### Response Example
```json
{
  "success": true,
  "createTransaction": "base64EncodedCreateTx",
  "compositionTransaction": "base64EncodedCompositionTx",
  "restructureTransaction": "base64EncodedRestructureTx"
}
```
```

--------------------------------

### Buy Basket Tokens with Rebalancing using Symmetry.fi Baskets SDK (JavaScript)

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

This code demonstrates purchasing basket tokens funded with USDC. It first buys the basket with a specified amount and then rebalances the underlying assets to match the basket's target allocation. Finally, it mints the basket tokens representing the user's share. The `rebalanceBuyState` function is crucial for ensuring the purchased assets align with the basket's strategy.

```javascript
/*  1. buy a basket with 50 USDC
    2. rebalance buyState (buy underlying assets)
    3. mint basket tokens */
let buyState1: BuyState = await basketsSdk.buyBasket(basket, 50);
let txsRebalanceBuyState1 = await basketsSdk.rebalanceBuyState(buyState1);
let txMintBasket1 = await basketsSdk.mintBasket(buyState1);
```

--------------------------------

### Create Basket

Source: https://docs.symmetry.fi/infrastructure/symmetry-apis

Allows users to create a new basket on the Symmetry platform. Requires specific parameters to define the basket's properties.

```APIDOC
## POST /websites/symmetry_fi/baskets/XXXX

### Description
Creates a new basket with specified parameters.

### Method
POST

### Endpoint
https://api.symmetry.fi/baskets/XXXX

### Parameters
#### Path Parameters
- **XXXX** (string) - Required - Identifier for the basket operation.

#### Query Parameters
None

#### Request Body
- **command** (string) - Required - The command to execute, e.g., 'create_basket'.
- **parameters** (object) - Required - An object containing parameters specific to basket creation.
  - **name** (string) - Required - The name of the basket.
  - **description** (string) - Optional - A description for the basket.
  - **underlying_assets** (array) - Required - A list of underlying assets and their proportions in the basket.

### Request Example
```json
{
  "command": "create_basket",
  "parameters": {
    "name": "My New Basket",
    "description": "A basket for diversified assets",
    "underlying_assets": [
      {"asset": "USDC", "amount": 1000},
      {"asset": "ETH", "amount": 10}
    ]
  }
}
```

### Response
#### Success Response (200)
- **basket_id** (string) - The unique identifier of the newly created basket.
- **status** (string) - The status of the basket creation operation.

#### Response Example
```json
{
  "basket_id": "basket_12345",
  "status": "success"
}
```
```

--------------------------------

### Buy Basket Tokens Instantly with Multiple Tokens

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

Allows for the instant purchase of basket tokens by contributing all required tokens based on the basket's composition. This method is suitable for baskets with up to 5 tokens and requires amounts to be provided in the correct order.

```javascript
// Fetch expected amount of Basket tokens after contribution
let expectedAmount: number = await basketsSdk.computeMintAmount(
  basket: Basket,
  amounts: number[]
);

// Contribute tokens and mint Basket tokens
let tx: TransactionSignature = await basketsSdk.buyBasketInstant(
  basket: Basket,
  amounts: number[]
);
```

--------------------------------

### Contribute USDC and Create BuyState

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

Initiates the process of contributing USDC to a basket and creates a temporary 'BuyState' account to hold the contribution details. This is the first step in advanced basket token acquisition.

```javascript
let buyState: BuyState = await basketsSdk.buyBasket(
  basket: Basket,
  amountUsdc: number
);
```

--------------------------------

### Find and Fetch BuyState Accounts

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

Provides helper functions to retrieve active 'BuyState' accounts for a user or fetch a specific 'BuyState' using its public key. This is useful for monitoring ongoing or past contribution processes.

```javascript
// Find active BuyStates for user that have been created after Step 1
let buyStates: BuyState[] = await basketsSdk
  .findActiveBuyStates(user: PublicKey);

// Fetch specific BuyState using its PublicKey
let buyState: BuyState[] = await basketsSdk
  .fetchBuyStateFromPubkey(pubkey: PublicKey);
```

--------------------------------

### Manage Baskets: Create, Edit, Close

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

Provides functions to manage Symmetry Baskets. This includes creating a new basket with specified parameters, editing existing mutable or permissioned baskets using simple or advanced methods, and closing a basket when its TVL is zero and no active BuyStates exist.

```javascript
let basket: Basket = await basketsSdk.createBasket(params: CreateBasketParams);

// Option 1 - (Simple) Directly set desired composition
await basketsSdk
  .simpleEditBasket(basket: Basket, params: SimpleEditParams);

// Option 2 - (Advanced) Provide full settings with rules
await basketsSdk
  .editBasket(basket: Basket, params: CreateBasketParams);

await basketsSdk.closeBasket(basket: Basket);
```

--------------------------------

### Create New Basket with TypeScript

Source: https://docs.symmetry.fi/infrastructure/symmetry-apis

This snippet demonstrates how to create a new basket on Symmetry.fi using their API. It defines basket parameters, sends a POST request to the create endpoint, and then processes the returned transactions to be signed and sent to the Solana blockchain. Dependencies include `@solana/wallet-adapter-react` and `@solana/web3.js`.

```jsx
import { useConnection, useWallet } from "@solana/wallet-adapter-react";
import { Transaction } from "@solana/web3.js";

const wallet = useWallet();
const { connection } = useConnection();
/*
    By using this publickey as host platform, your basket will
    be available for public @ https://app.symmetry.fi/explore/
    Host platforms can set any address they want to collect fees at
*/
const symmetryHost = "4Vry5hGDmbwGwhjgegHmoitjMHniSotpjBFkRuDYHcDG";
const creator = wallet.publicKey.toBase58();
const basketParameters = {
    symbol: "FAVTOKENS", // 3-10 ['a'-'z','A'-'Z','0'-'9'] characters
    name: "My Portfolio Basket", // 3-60 characters
    uri: "", // can be left as empty and configured later.
    hostPlatform: symmetryHost, // publicKey - string.
    hostPlatformFee: 10, // Fee in basis points (bps). 10 bps = 0.1%
    creator: creator, // wallet publickey of creator (string) .
    depositFee: 50, // Fee on deposits, paid to the basket creator - 0.5% .
    type: 1, // 1 = Mutable, Creator has authority to edit basket.
    rebalanceInterval: 3600, // Rebalance checks are done every hour.
    rebalanceThreshold: 300, // Rebalance will be triggered when asset weights deviate from their target weights by 3% .
    slippage: 100, // Maximum allowed slippage for rebalance transactions, in bps 100 = 1%.
    lpOffsetThreshold: 0, // EXPERIMENTAL: Defines liquidity pool behavior for rebalancing. 0 disables this feature.
    disableRebalance: 0, // 0 - Automatic rebalances are enabled.
    disableLp: 1, // 1 - Liquidity pool functionality is disabled.
    composition: [
    { token: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", weight: 40 }, // USDC
    { token: "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263", weight: 60 }, // BONK
    ],
};
let request = await fetch('https://api.symmetry.fi/baskets/create', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(basketParameters),
});
let response = await request.json();

if (response.success) {
    const {
        createTransaction,
        compositionTransaction,
        restructureTransaction
    } = response;

    // Decode the base64 encoded transactions provided by the API.
    const createTx = Transaction.from(Buffer.from(createTransaction, 'base64'));
    const compositionTx = Transaction.from(Buffer.from(compositionTransaction, 'base64'));
    const restructureTx = Transaction.from(Buffer.from(restructureTransaction, 'base64'));

    // Sign and send each transaction to the Solana blockchain.
    let signedCreate = await wallet.signTransaction(createTx);
    let createTxid = await connection.sendRawTransaction(signedCreate.serialize(), { skipPreflight: true });
    console.log('createTxid', createTxid);

    // Transactions need to be executed in the correct order, so make sure each transaction is confirmed before sending the next one.
    // Repeat the process for composition and restructure transactions.
    let signedComposition = await wallet.signTransaction(compositionTx);
    let compositionTxid = await connection.sendRawTransaction(signedComposition.serialize(), { skipPreflight: true });
    console.log('compositionTxid', compositionTxid);

    let signedRestructure = await wallet.signTransaction(restructureTx);
    let restructureTxid = await connection.sendRawTransaction(signedRestructure.serialize(), { skipPreflight: true });
    console.log('restructureTxid', restructureTxid);

    console.log('Basket created successfully');
} else {
    console.error('Something went wrong', response);
}

```

--------------------------------

### Basket Creation and Editing Parameters

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

Defines types for creating and editing basket configurations. This includes parameters for manager fees, rebalancing intervals and thresholds, liquidity provisioning offsets, and composition rules. It also includes enums for defining filtering, sorting, and weighting strategies.

```typescript
type SimpleEditParams = {
    managerFee: number,         // manager fee in bps 100 = 1%
    rebalanceInterval: number,  // rebalance interval in seconds
    rebalanceThreshold: number, // rebalance threshold in bps 100 = 1%
    rebalanceSlippage: number,  // rebalance slippage in bps 100 = 1%
    lpOffsetThreshold: number,  // liquidity provsion ... in bps
    disableRebalance: boolean,  // true for turning of automation
    disableLp: boolean,         // true for turining of lp
    composition: {token: PublicKey, weight: number}[],
}
type CreateBasketParams = {
    name: string,
    symbol: string,
    uri: string,                // metadata URI which stores name, symbol, logo.
    hostPlatform: PublicKey,    // platofrm hosting symmetry UI
    hostPlatformFee: number,    // deposit fee for host platform in bps
    manager: PublicKey,         // basket manager
    managerFee: number,         // deposit fee for manager in bps 
    activelyManaged: number,    // 0 - Immutable, 1 - Mutable, 2 - Permissioned
    assetPool: number[],        // Asset pool with tokenIds (check getTokenListData())
    refilterInterval: number,   // refilter interval in seconds
    reweightInterval: number,   // reweight interval in seconds
    rebalanceInterval: number,  // rebalance interval in seconds
    rebalanceThreshold: number, // rebalance threshold in bps 
    rebalanceSlippage: number,  // rebalance slippage in bps
    lpOffsetThreshold: number,  // liquidity provision .. in bps
    disableRebalance: boolean,  // true for disabling automaion
    disableLp: boolean,         // true for disabling liquidity provision
    rules: Rule[],
}

type Rule = {
  totalWeight: number,
  filterBy: FilterType,
  filterDays: FilterTime,
  sortBy: SortBy,
  fixedAsset: number,
  numAssets: number,
  weightBy: WeightType,
  weightDays: WeightTime,
  weightExpo: number,
  excludeAssets: number[],
}

export enum FilterType {
    Fixed,
    MarketCap,
    Volume,
    Performance,
}
export enum WeightType {
    Fixed,
    MarketCap,
    Volume,
    Performance,
}
export enum FilterTime {
    Day,
    Week,
    Month,
    Quarter,
    HalfYear,
    Year,
}
export enum WeightTime {
    Day,
    Week,
    Month,
    Quarter,
    HalfYear,
    Year,
}
export enum SortBy {
    DescendingOrder,
    AscendingOrder,
}
```

--------------------------------

### Deposit into Basket API Request and Transaction Handling (TypeScript)

Source: https://docs.symmetry.fi/infrastructure/symmetry-apis

Illustrates how to deposit USDC into a basket using the Symmetry.fi API and manage the subsequent transaction. This code snippet requires wallet and connection objects from `@solana/wallet-adapter-react` and utilizes `web3.js` for transaction operations. It sends a POST request to the `/baskets/deposit` endpoint and handles the response to sign and send the deposit transaction.

```jsx
import { useConnection, useWallet } from "@solana/wallet-adapter-react";
import { Transaction } from "@solana/web3.js";

const wallet = useWallet();
const { connection } = useConnection();

const depositParameters = {
    user: wallet.publicKey.toBase58(), // string
    basket: "4RofqKG4d6jfUD2HjtWb2F9UkLJvJ7P3kFmyuhX7H88d", // ySOL Basket
    amount: 100 // 100 USDC
};
let request = await fetch('https://api.symmetry.fi/baskets/deposit', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(depositParameters),
});
let response = await request.json();

if (response.success) {
    const { transaction } = response;

    // Decode the base64 encoded transactions provided by the API.
    const depositTx = Transaction.from(Buffer.from(transaction, 'base64'));

    // Sign and send transaction to the Solana blockchain.
    let signedDeposit = await wallet.signTransaction(depositTx);
    let dopositTxId = await connection.sendRawTransaction(signedDeposit.serialize(), { skipPreflight: true });
    console.log('depositTxId', dopositTxId);

    console.log('Deposited successfully');
} else {
    console.error('Something went wrong', response);
}
```

--------------------------------

### Buy Basket Tokens with Single Token

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

Facilitates buying basket tokens by contributing a single, specified token that is part of the basket's composition. It first computes the expected amount of basket tokens and then executes the contribution and minting process.

```javascript
// Fetch expected amount of Basket tokens after contribution
let expectedAmount = await basketsSdk.computeMintAmountWithSingleToken(
  basket: Basket, 
  token: PublicKey, 
  amount: number
);

// Contribute single token and mint Basket tokens
let tx: TransactionSignature = await basketsSdk.buyWithSingleToken(
  basket: Basket, 
  token: PublicKey, 
  amount: number
);
```

--------------------------------

### Compute Output Amount for Selling Basket Tokens

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

Calculates the expected amount of a specific underlying token a user will receive when selling a certain amount of basket tokens using the instant burn method.

```javascript
// Fetch expected amount of received tokens.
let amount: number = await basketsSdk.computeOutputAmountWithInstantBurn(
  basket: Basket,
  amount: number,
  withdrawToken: PublicKey
);
```

--------------------------------

### Rebalance BuyState to Acquire Underlying Assets

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

Uses the contributed USDC in the 'BuyState' to purchase the underlying assets of the basket according to their target weights. This process can be user-initiated or automatically handled by the Symmetry Engine within 3 minutes.

```javascript
let txs: TransactionSignature[] = await basketsSdk
  .rebalanceBuyState(buyState: BuyState);
```

--------------------------------

### Instant Sell Basket Tokens

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

Allows users to directly sell their basket tokens for a specified underlying token. The basket tokens are burned, and the user receives the corresponding amount of the chosen token.

```javascript
// Burn/Sell Basket tokens.
let tx: TransactionSignature = await basketsSdk.instantBurn(
  basket: Basket,
  amount: number,
  withdrawToken: PublicKey
);
```

--------------------------------

### Sell Basket Tokens with Rebalancing using Symmetry.fi Baskets SDK (JavaScript)

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

This code shows how to sell basket tokens. The process involves selling a specified amount of basket tokens, rebalancing the underlying assets back into USDC, and then claiming the resulting USDC and any remaining tokens. The `true` parameter in `sellBasket` indicates that rebalancing should occur. This ensures that users receive the most accurate value in USDC after selling.

```javascript
/*  1. sell a basket
    2. rebalance basket (to USDC)
    3. claim tokens (USDC + tokens for which rebalance failed) */
let sellState1: Basket = await basketsSdk.sellBasket(basket, 0.4, true);
let txsRebalanceSellState = await basketsSdk.rebalanceBasket(sellState1);
let txsClaimTokens1 = await basketsSdk.claimTokens(sellState);
```

--------------------------------

### Create SellState for Advanced Basket Token Sale

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

Initiates the advanced process for selling basket tokens by burning them and creating a temporary 'SellState' account. This account holds the basket's composition corresponding to the user's holdings and can optionally be rebalanced to USDC.

```javascript
let sellState: Basket = await basketsSdk
  .sellBasket(basket: Basket, amount: number, rebalance: boolean);
```

--------------------------------

### Basket Management Operations

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

This section details the operations for creating, editing, and closing baskets using the Baskets SDK.

```APIDOC
## Basket Management Operations

### Description
Manage baskets by creating new ones, editing existing ones, or closing them.

### Method
SDK methods for basket management.

### Endpoint
N/A (SDK methods)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
Parameters vary based on the operation (create, edit, set metadata).

### Request Example
```javascript
// Create Basket
let basket = await basketsSdk.createBasket(params: CreateBasketParams);

// Edit Basket (Simple)
await basketsSdk.simpleEditBasket(basket: Basket, params: SimpleEditParams);

// Edit Basket (Advanced)
await basketsSdk.editBasket(basket: Basket, params: CreateBasketParams);

// Close Basket
await basketsSdk.closeBasket(basket: Basket);

// Set Metadata
let tx = await basketsSdk.setMetadata(
  basket: Basket,
  symbol: string,
  name: string,
  uri: string
);
```

### Response
#### Success Response (200)
- **createBasket**: Returns the created `Basket` object.
- **simpleEditBasket/editBasket**: Returns a transaction signature.
- **closeBasket**: Returns a transaction signature.
- **setMetadata**: Returns an array of transaction signatures.

#### Response Example
```json
// Example for createBasket()
{
  "address": "BasketPublicKey",
  // ... other basket properties
}

// Example for setMetadata()
["txSignature1", "txSignature2"]
```
```

--------------------------------

### Deposit USDC to Buy/Mint Basket Tokens

Source: https://docs.symmetry.fi/infrastructure/symmetry-apis

Allows users to deposit USDC to purchase or mint basket tokens. This facilitates adding liquidity to the basket.

```APIDOC
## POST /websites/symmetry_fi/baskets/XXXX

### Description
Deposits USDC to buy or mint basket tokens, effectively adding to the basket's liquidity.

### Method
POST

### Endpoint
https://api.symmetry.fi/baskets/XXXX

### Parameters
#### Path Parameters
- **XXXX** (string) - Required - Identifier for the basket operation.

#### Query Parameters
None

#### Request Body
- **command** (string) - Required - The command to execute, e.g., 'deposit_usdc_to_mint'.
- **parameters** (object) - Required - An object containing parameters for the deposit.
  - **basket_id** (string) - Required - The ID of the basket to deposit into.
  - **amount** (number) - Required - The amount of USDC to deposit.
  - **recipient** (string) - Required - The address that will receive the minted basket tokens.

### Request Example
```json
{
  "command": "deposit_usdc_to_mint",
  "parameters": {
    "basket_id": "basket_12345",
    "amount": 500,
    "recipient": "0xYourEthereumAddress"
  }
}
```

### Response
#### Success Response (200)
- **transaction_hash** (string) - The hash of the transaction that executed the deposit.
- **minted_tokens** (number) - The amount of basket tokens minted.
- **status** (string) - The status of the deposit operation.

#### Response Example
```json
{
  "transaction_hash": "0xabc123...",
  "minted_tokens": 450,
  "status": "success"
}
```
```

--------------------------------

### Claim Tokens from Halted BuyState

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

Allows users to reclaim contributed tokens from a 'BuyState' if the minting process has been unsuccessful for over 30 minutes due to reasons like lack of liquidity or chain congestion.

```javascript
// Claim Tokens from halted BuyState
// In a case where BuyState has been created more than 30 minutes ago,
// and mint was unsuccessful for some reason
// (no liquidity for token / oracle feed not live / chain congestion)
// contributed token(s) can be claimed back by user.
let tx = await basketsSdk.claimTokensFromBuyState(pubkey: PublicKey)
```

--------------------------------

### Edit Basket API Request and Transaction Handling (TypeScript)

Source: https://docs.symmetry.fi/infrastructure/symmetry-apis

Demonstrates how to edit a basket's parameters via the Symmetry.fi API and subsequently handle the returned transaction. It requires wallet and connection objects from `@solana/wallet-adapter-react` and uses `web3.js` for transaction manipulation. The function sends a POST request to the `/baskets/edit` endpoint and processes the response to sign and send the transaction.

```jsx
import { useConnection, useWallet } from "@solana/wallet-adapter-react";
import { Transaction } from "@solana/web3.js";

const wallet = useWallet();
const { connection } = useConnection();

const editParameters = {
    creator: wallet.publicKey.toBase58(), // string
    basket: "4RofqKG4d6jfUD2HjtWb2F9UkLJvJ7P3kFmyuhX7H88d", // Publickey of the basket
    depositFee: 40, // Fee on deposits, paid to the basket creator - 0.4% .
    rebalanceInterval: 7200, // Rebalance checks are done every 2 hours.
    rebalanceThreshold: 500, // Rebalance will be triggered when asset weights deviate from their target weights by 5% .
    slippage: 100, // Maximum allowed slippage for rebalance transactions, in bps 100 = 1%.
    lpOffsetThreshold: 0, // EXPERIMENTAL: Defines liquidity pool behavior for rebalancing. 0 disables this feature.
    disableRebalance: 0, // 0 - Automatic rebalances are enabled.
    disableLp: 1, // 1 - Liquidity pool functionality is disabled.
    composition: [
    { token: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", weight: 20 }, // USDC
    { token: "So11111111111111111111111111111111111111112", weight: 50 }, // SOL
    { token: "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263", weight: 30 }, // BONK
    ],
};
let request = await fetch('https://api.symmetry.fi/baskets/edit', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(editParameters),
});
let response = await request.json();

if (response.success) {
    const { editTransaction } = response;

    // Decode the base64 encoded transactions provided by the API.
    const editTx = Transaction.from(Buffer.from(editTransaction, 'base64'));

    // Sign and send transaction to the Solana blockchain.
    let signedEdit = await wallet.signTransaction(editTx);
    let editTxid = await connection.sendRawTransaction(signedEdit.serialize(), { skipPreflight: true });
    console.log('createTxid', editTxid);

    console.log('Basket edited successfully');
} else {
    console.error('Something went wrong', response);
}
```

--------------------------------

### Buy State Chain Data Structure (Solana)

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

Defines the on-chain data structure for buy states, representing a user's contribution to a fund. It tracks fund details, buyer information, contributed amounts, and tokens involved in the transaction. Uses BN.js for large number handling.

```typescript
type BuyStateChainData = {
  fund: PublicKey,
  buyer: PublicKey,
  fundManager: PublicKey,
  hostPlatform: PublicKey,
  buyerFundTokenAccount: PublicKey,
  usdcContributed: BN,
  usdcLeft: BN,
  token: BN[],
  amountToSpend: BN[],
  amountBought: BN[],
  creationTimestamp: BN,
  contributedValue: BN
};
```

--------------------------------

### Buy/Mint Basket Tokens with an Arbitrary Asset

Source: https://docs.symmetry.fi/infrastructure/symmetry-apis

Allows users to buy or mint basket tokens using an asset other than USDC. This provides flexibility in acquiring basket tokens.

```APIDOC
## POST /websites/symmetry_fi/baskets/XXXX

### Description
Buys or mints basket tokens using an arbitrary asset as payment, offering flexibility in acquiring basket tokens.

### Method
POST

### Endpoint
https://api.symmetry.fi/baskets/XXXX

### Parameters
#### Path Parameters
- **XXXX** (string) - Required - Identifier for the basket operation.

#### Query Parameters
None

#### Request Body
- **command** (string) - Required - The command to execute, e.g., 'deposit_arbitrary_asset_to_mint'.
- **parameters** (object) - Required - An object containing parameters for the deposit.
  - **basket_id** (string) - Required - The ID of the basket to mint tokens for.
  - **asset_address** (string) - Required - The contract address of the arbitrary asset being used for payment.
  - **amount** (number) - Required - The amount of the arbitrary asset to deposit.
  - **recipient** (string) - Required - The address that will receive the minted basket tokens.

### Request Example
```json
{
  "command": "deposit_arbitrary_asset_to_mint",
  "parameters": {
    "basket_id": "basket_12345",
    "asset_address": "0xArbitraryAssetAddress",
    "amount": 25,
    "recipient": "0xYourEthereumAddress"
  }
}
```

### Response
#### Success Response (200)
- **transaction_hash** (string) - The hash of the transaction that executed the deposit.
- **minted_tokens** (number) - The amount of basket tokens minted.
- **status** (string) - The status of the deposit operation.

#### Response Example
```json
{
  "transaction_hash": "0xghi789...",
  "minted_tokens": 90,
  "status": "success"
}
```
```

--------------------------------

### POST /baskets/edit

Source: https://docs.symmetry.fi/infrastructure/symmetry-apis

Edits an existing basket's configuration. This includes settings for fees, rebalancing, slippage, and composition.

```APIDOC
## POST /baskets/edit

### Description
Edits a basket's configuration, including deposit fees, rebalance intervals and thresholds, slippage, and composition.

### Method
POST

### Endpoint
https://api.symmetry.fi/baskets/edit

### Parameters
#### Request Body
- **basket** (string) - Required - PublicKey of the basket to be edited.
- **creator** (string) - Required - Wallet PublicKey of the basket creator.
- **depositFee** (number) - Optional - Fee charged on deposits for creator (in bps).
- **rebalanceInterval** (number) - Optional - Frequency of rebalance checks in seconds.
- **rebalanceThreshold** (number) - Optional - Allowed deviation from target weights before rebalancing.
- **slippage** (number) - Optional - Maximum allowed slippage for rebalance transactions, in bps.
- **lpOffsetThreshold** (number) - Optional - EXPERIMENTAL: Defines liquidity pool behavior for rebalancing. 0 disables this feature.
- **disableRebalance** (number) - Optional - Controls automatic rebalancing: 0 = enabled, 1 = disabled.
- **disableLp** (number) - Optional - Controls liquidity pool functionality: 0 = enabled, 1 = disabled.
- **composition** (array) - Optional - Array of desired basket composition, each object containing `token` (string) and `weight` (number).

### Request Example
```json
{
  "creator": "user_public_key",
  "basket": "4RofqKG4d6jfUD2HjtWb2F9UkLJvJ7P3kFmyuhX7H88d",
  "depositFee": 40,
  "rebalanceInterval": 7200,
  "rebalanceThreshold": 500,
  "slippage": 100,
  "lpOffsetThreshold": 0,
  "disableRebalance": 0,
  "disableLp": 1,
  "composition": [
    { "token": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "weight": 20 },
    { "token": "So11111111111111111111111111111111111111112", "weight": 50 },
    { "token": "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263", "weight": 30 }
  ]
}
```

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the operation was successful.
- **editTransaction** (string) - Base64 encoded transaction data for editing the basket.

#### Response Example
```json
{
  "success": true,
  "editTransaction": "base64_encoded_transaction_data"
}
```
```

--------------------------------

### Token Settings Type Definition

Source: https://docs.symmetry.fi/infrastructure/symmetry-sdks

Defines the structure for token settings, including identification, metadata, oracle configurations, and liquidity pool status. This type is crucial for managing individual tokens within the Symmetry.fi ecosystem.

```typescript
type TokenSettings = {
    id: number,
    symbol: string,
    name: string,
    tokenMint: string,
    decimals: number,
    coingeckoId: string,
    pdaTokenAccount: string,
    oracleType: string,
    oracleAccount: string,
    oracleIndex: number,
    oracleConfidencePct: number,
    fixedConfidenceBps: number,
    tokenSwapFeeBeforeTwBps: number,
    tokenSwapFeeAfterTwBps: number,
    isLive: boolean,
    lpOn: boolean,
    useCurveData: boolean,
    additionalData: number[],
}
```
Tokens:
Raw