Documentation

npm install @Nidus-FI/sdk

import { NubisClient } from '@Nidus-FI/sdk';

// Initialize client
const client = new NubisClient({
  rpcUrl: 'https://api.mainnet.solana.com',
  walletProvider: wallet
});

// Execute a trade
const trade = await client.executeSwap({
  fromToken: 'SOL',
  toToken: 'USDC',
  amount: new BN(1000000000), // 1 SOL
  slippageTolerance: 0.005, // 0.5%
  useOptimalRouting: true
});

console.log('Trade executed:', trade.signature);

npm install @Nidus-FI/sdk

pip install Nidus-FI

cargo add Nidus-FI

go get github.com/Nidus-FI/sdk-go

// Example API request with API key
const response = await fetch('https://api.Nidus-FI.com/v1/pools', {
  headers: {
    'X-API-Key': 'your-api-key-here'
  }
});

// Example JWT authentication
const response = await fetch('https://api.Nidus-FI.com/v1/user/positions', {
  headers: {
    'Authorization': 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'
  }
});

// Example wallet authentication
// 1. Request challenge
const challenge = await fetch('https://api.Nidus-FI.com/v1/auth/challenge?wallet=user_wallet_address');
const { message } = await challenge.json();

// 2. Sign message with wallet
const signature = await wallet.signMessage(new TextEncoder().encode(message));

// 3. Verify signature and get auth token
const auth = await fetch('https://api.Nidus-FI.com/v1/auth/verify', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ wallet: wallet.publicKey.toString(), signature })
});
const { token } = await auth.json();

{
  "error": {
    "code": "invalid_parameter",
    "message": "The provided token address is invalid",
    "details": {
      "parameter": "fromToken",
      "value": "NOT_A_VALID_TOKEN",
      "reason": "Token not found"
    }
  }
}

https://api.Nidus-FI.com/v1

// Example API request header
{
  "X-API-Key": "your-api-key-here"
}

// Core Module Interface
// Program ID: NUB1Sfi45cQsz4NCjNQQkBJxCUGQnfZAkVCrSZ8Vcq4

// Primary Interfaces
pub trait CoreModule {
    // Pool Management
    fn create_pool(context: Context<CreatePool>, params: CreatePoolParams) -> Result<()>;
    fn add_liquidity(context: Context<AddLiquidity>, params: AddLiquidityParams) -> Result<()>;
    fn remove_liquidity(context: Context<RemoveLiquidity>, params: RemoveLiquidityParams) -> Result<()>;
    
    // Trading
    fn swap(context: Context<Swap>, params: SwapParams) -> Result<()>;
    fn create_limit_order(context: Context<CreateOrder>, params: OrderParams) -> Result<()>;
    fn cancel_order(context: Context<CancelOrder>, order_id: u64) -> Result<()>;
    
    // Analytics and Data
    fn get_pool_data(pool_id: Pubkey) -> Result<PoolData>;
    fn get_position_info(position_id: Pubkey) -> Result<PositionInfo>;
    fn get_fee_tier_info(fee_tier_id: Pubkey) -> Result<FeeTierInfo>;
}

// Key Structs and Types
pub struct CreatePoolParams {
    pub token_a_mint: Pubkey,
    pub token_b_mint: Pubkey,
    pub fee_tier: u16, // Basis points (e.g., 30 = 0.3%)
    pub initial_price_sqrt: u128,
    pub price_range: PriceRange,
}

pub struct AddLiquidityParams {
    pub pool_id: Pubkey,
    pub amount_a_desired: u64,
    pub amount_b_desired: u64,
    pub amount_a_min: u64,
    pub amount_b_min: u64,
    pub price_range: PriceRange,
    pub deadline: i64,
}

pub struct SwapParams {
    pub pool_id: Pubkey,
    pub amount_in: u64,
    pub minimum_amount_out: u64,
    pub swap_direction: SwapDirection, // TokenA -> TokenB or TokenB -> TokenA
    pub deadline: i64,
}

// Price Range for Concentrated Liquidity
pub struct PriceRange {
    pub lower_tick: i32,
    pub upper_tick: i32,
}

// Swap Direction Enum
pub enum SwapDirection {
    AtoB,
    BtoA,
}

// npm
npm install @Nidus-FI/sdk

// yarn
yarn add @Nidus-FI/sdk

import { NubisClient } from '@Nidus-FI/sdk';

// Initialize with default mainnet configuration
const client = new NubisClient({
  rpcUrl: 'https://api.mainnet.solana.com',  // Optional, defaults to mainnet
  walletProvider: wallet,                     // Your wallet instance
  apiKey: 'your-api-key',                     // Optional, for higher rate limits
  network: 'mainnet'                          // Optional: 'mainnet', 'testnet', or 'devnet'
});

// 1. Get a quote first (optional but recommended)
const quote = await client.getQuote({
  fromToken: 'SOL',
  toToken: 'USDC',
  amount: '1000000000', // 1 SOL (in lamports)
  slippageTolerance: 0.005 // 0.5%
});

console.log(`Expected to receive: ${quote.toAmount} USDC`);
console.log(`Price impact: ${quote.priceImpact * 100}%`);

// 2. Execute the swap
const swap = await client.executeSwap({
  fromToken: 'SOL',
  toToken: 'USDC',
  amount: '1000000000',
  slippageTolerance: 0.005,
  useOptimalRouting: true // Use AI-powered routing for best execution
});

console.log(`Swap executed with transaction ID: ${swap.transactionId}`);
console.log(`Received: ${swap.toAmount} USDC`);

// 1. Find available pools
const pools = await client.getPools({
  tokenA: 'SOL',
  tokenB: 'USDC'
});

// 2. Add liquidity to a pool
const addLiquidity = await client.addLiquidity({
  poolId: pools[0].id,
  amountA: '10000000000', // 10 SOL
  amountB: '1000000000',  // 1000 USDC
  priceRange: {
    min: 95.0,  // Min price: 95 USDC per SOL
    max: 105.0  // Max price: 105 USDC per SOL
  },
  useRecommendedRange: false // Set to true to use AI-recommended price range
});

console.log(`Added liquidity with position ID: ${addLiquidity.positionId}`);

npm install @Nidus-FI/sdk @solana/web3.js