Asset Configuration

pub struct AssetConfig {
    pub mint_address: Pubkey,               // Token mint address
    pub nav_data: Vec<NavData>,             // Up to 5 NAV pricing sources
    pub price_difference_bps: u16,          // Maximum price divergence tolerance
    pub paused: bool,                       // Asset-level pause flag
    pub version: u8,                        // Configuration version
    pub asset_type: AssetType,              // Rwa or Stable
    pub used_in_pairs_count: u16,           // Number of pairs using this asset
    pub bump: u8,                           // PDA bump seed
}

pub enum AssetType {
    Rwa,     // Real World Asset token
    Stable,  // Stablecoin token
}

pub fn init_asset_config_account(
    ctx: Context<InitAssetConfigAccount>,
    nav_data: Vec<NavData>,
    price_difference_bps: u16,
    asset_type: AssetType,
) -> Result<()>

#[derive(Accounts)]
pub struct InitAssetConfigAccount<'info> {
    #[account(
        init,
        payer = admin,
        space = 8 + AssetConfig::INIT_SPACE,
        seeds = [ASSET_CONFIG_PREFIX, mint_address.key().as_ref()],
        bump,
    )]
    pub asset_config: Account<'info, AssetConfig>,

    pub mint_address: InterfaceAccount<'info, Mint>,

    #[account(mut)]
    pub admin: Signer<'info>,

    // Fee vault ATA owned by the global program authority
    #[account(
        init_if_needed,
        payer = admin,
        associated_token::mint = mint_address,
        associated_token::authority = program_authority,
        associated_token::token_program = token_program,
    )]
    pub fee_vault_token_account: InterfaceAccount<'info, TokenAccount>,

    /// CHECK: Global PDA used as the protocol fee-vault authority
    #[account(
        seeds = [PROGRAM_AUTHORITY_PREFIX],
        bump,
    )]
    pub program_authority: UncheckedAccount<'info>,

    #[account(
        seeds = [GLOBAL_CONFIG_PREFIX],
        bump = global_config.bump,
        has_one = admin
    )]
    pub global_config: Account<'info, GlobalConfig>,

    pub system_program: Program<'info, System>,
    pub token_program: Interface<'info, TokenInterface>,
    pub associated_token_program: Program<'info, AssociatedToken>,
}

import { BN } from "@coral-xyz/anchor";

// NAV source: Read price from a fixed account address
const navData = [{
  u64FixedAddress: {
    navAccountAddress: priceOracleAccount,
    navPriceOffset: 0,
    priceDecimals: 6,
  }
}];

await program.methods
  .initAssetConfigAccount(
    navData,
    100,  // 1% max price divergence
    { rwa: {} }  // Asset type
  )
  .accounts({
    assetConfig,
    mintAddress: rwaMint,
    admin: adminWallet.publicKey,
    feeVaultTokenAccount,
    programAuthority,
    globalConfig,
    systemProgram: SystemProgram.programId,
    tokenProgram: TOKEN_PROGRAM_ID,
    associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
  })
  .rpc();

pub fn update_asset_config_account(
    ctx: Context<UpdateAssetConfigAccount>,
    nav_data: Vec<NavData>,
    price_difference_bps: u16,
    asset_type: AssetType,
) -> Result<()>

#[derive(Accounts)]
pub struct UpdateAssetConfigAccount<'info> {
    #[account(
        mut,
        seeds = [ASSET_CONFIG_PREFIX, mint_address.key().as_ref()],
        bump = asset_config.bump,
    )]
    pub asset_config: Account<'info, AssetConfig>,

    pub mint_address: InterfaceAccount<'info, Mint>,

    pub admin: Signer<'info>,

    #[account(
        seeds = [GLOBAL_CONFIG_PREFIX],
        bump = global_config.bump,
        has_one = admin
    )]
    pub global_config: Account<'info, GlobalConfig>,
}

// Add a second NAV source (Pyth oracle)
const updatedNavData = [
  {
    u64FixedAddress: {
      navAccountAddress: primaryOracle,
      navPriceOffset: 0,
      priceDecimals: 6,
    }
  },
  {
    pythPush: {
      pythPushAccountAddress: pythAccount,
      feedId: Array.from(Buffer.from("40ac3329933a6b5b65cf31496018c5764ac0567316146f7d0de00095886b480d", "hex")),
      maxAgeSecs: new BN(86_400),
      maxConfBps: 100,
    }
  }
];

await program.methods
  .updateAssetConfigAccount(
    updatedNavData,
    50,  // 0.5% max divergence
    { rwa: {} }  // Asset type
  )
  .accounts({
    assetConfig,
    admin: adminWallet.publicKey,
    mintAddress: rwaMint,
    globalConfig,
  })
  .rpc();

pub fn set_paused_for_asset(
    ctx: Context<SetPausedForAsset>,
    paused: bool,
) -> Result<()>

#[derive(Accounts)]
pub struct SetPausedForAsset<'info> {
    #[account(
        seeds = [GLOBAL_CONFIG_PREFIX],
        bump = global_config.bump,
        has_one = admin,
    )]
    pub global_config: Account<'info, GlobalConfig>,

    #[account(
        mut,
        seeds = [ASSET_CONFIG_PREFIX, mint_address.key().as_ref()],
        bump = asset_config.bump,
    )]
    pub asset_config: Account<'info, AssetConfig>,

    pub mint_address: UncheckedAccount<'info>,

    #[account(mut)]
    pub admin: Signer<'info>,
}

// Pause an asset
await program.methods
  .setPausedForAsset(true)
  .accounts({
    globalConfig,
    assetConfig,
    mintAddress: rwaMint,
    admin: adminWallet.publicKey,
  })
  .rpc();

NavData::U64FixedAddress {
    nav_account_address: Pubkey,  // Account containing price data
    nav_price_offset: u16,        // Byte offset to read price
    price_decimals: u8,           // Decimal places (0-9)
}

NavData::Hardcoded {
    hardcoded_price: u64,   // Fixed price value
    price_decimals: u8,     // Decimal places (0-9)
}

NavData::PythPush {
    pyth_push_account_address: Pubkey,  // Pyth receiver price update account
    feed_id: [u8; 32],                  // Expected Pyth feed id
    max_age_secs: u64,                  // Maximum accepted price age
    max_conf_bps: u16,                  // Maximum accepted confidence ratio
}