Integrate with Bolt’s zero slippage execution layer on Sui using TypeScript.
The Bolt TypeScript SDK provides a comprehensive, type-safe interface for integrating with Bolt’s zero slippage execution layer on Sui. Query oracle prices, inspect pools, simulate swaps off-chain, and execute trades programmatically.
Before using the SDK, make sure you have:☑️ Node.js 18+ installed☑️ A Sui-compatible wallet (Sui Wallet, Suiet, etc.) for signing transactions☑️ Access to SUI RPC endpoints: The client uses https://fullnode.mainnet.sui.io:443 for mainnet and https://fullnode.testnet.sui.io:443 for testnet by default
2
Installation
NPM
YARN
PNPM
npm install @bolt-liquidity-hq/sui-client
yarn add @bolt-liquidity-hq/sui-client
pnpm install @bolt-liquidity-hq/sui-client
3
Initialize the Bolt client
The SDK supports different environments:
type Environment = 'mainnet' | 'testnet';
Mainnet
Testnet
import { BoltSuiClient } from '@bolt-liquidity-hq/sui-client';const client = new BoltSuiClient();
import { BoltSuiClient } from '@bolt-liquidity-hq/sui-client';const client = new BoltSuiClient({ environment: 'testnet',});
4
Query all assets
// Get all supported assetsconst assets = await client.getAssets();assets.forEach((asset) => { console.log(`${asset.symbol} (${asset.name}): ${asset.denom}`); console.log(` Decimals: ${asset.decimals}`);});// Find a specific assetconst suiAsset = assets.find((a) => a.symbol === 'SUI');console.log(`SUI type: ${suiAsset?.denom}`); // "0x2::sui::SUI"
5
Execute a swap
// Get signer from wallet (implementation depends on wallet)const signer: Signer = await getSuiWalletSigner();// Execute a swap: exactly 1 SUI for USDCconst result = await client.swap({ assetIn: '0x2::sui::SUI', amountIn: '1000000000', // 1 SUI (9 decimals) assetOut: '0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC', minimumAmountOut: '1900000', // Minimum 1.9 USDC (6 decimals)}, signer);console.log(`Swapped 1 SUI for ${result.amountOut} USDC`);console.log(`Transaction digest: ${result.txHash}`);console.log(`Gas cost: ${result.txOutput.effects.gasUsed.computationCost}`);console.log(`Status: ${result.txOutput.effects.status.status}`);
import { BoltSuiClient } from '@bolt-liquidity-hq/sui-client';// Initialise clientconst client = new BoltSuiClient({ environment: 'mainnet', // 'testnet' | 'mainnet' customOverride: { chainConfig: { rpcEndpoint: 'https://my-custom-rpc-endpoint...', // Remove this if you want to use the default public RPC endpoint } }});
Custom asset configurations indexed by denomination
type Asset = { symbol: string; // Asset symbol (e.g., 'SUI', 'USDC') name: string; // Full asset name (e.g., 'Sui', 'Circle USDC') chainId: string; // Chain identifier denom: string; // Asset denomination/address decimals: number; // Number of decimal places logo?: string; // Optional logo URL coingeckoId?: string; // Optional CoinGecko identifier};
Override SUI client
Parameter
Type
Description
suiClient
SuiClient
Pre-existing SuiClient instance for blockchain interactions
import { SuiClient } from '@mysten/sui/client';// Create custom Sui client with specific configurationconst customSuiClient = new SuiClient({ url: 'https://custom-rpc.example.com',});const client = new BoltSuiClient({ suiClient: customSuiClient});
getOracleConfig()Retrieves the current configuration settings from the Bolt Oracle smart contract on Sui. This configuration governs how price feeds are managed, including update thresholds, expiration times, and administrative settings.
Method Signature
Returns
async getOracleConfig(): Promise<OracleConfig>
type OracleConfig = { admin: Address; // Sui address authorised to update oracle settings and prices priceThresholdRatio: string; // Minimum price change ratio required for updates (decimal string) priceExpireTime: Duration | null; // Time duration before prices become stale};type Duration = { secs: number; // Seconds component nanos: number; // Nanoseconds component (always 0 in current implementation)};
getAssets() Retrieves all unique assets available in the Bolt execution layer by querying oracle asset pairs and enriching them with additional metadata from the client’s asset configuration.
Method Signature
Returns
async getAssets(): Promise<Asset[]>
type Asset = { symbol: string; // Trading symbol (e.g., "SUI", "USDC") name: string; // Full asset name (e.g., "Sui", "USD Coin") chainId: string; // Blockchain network identifier denom: string; // Chain-specific denomination decimals: number; // Number of decimal places logo?: string; // Optional logo URL coingeckoId?: string; // Optional CoinGecko identifier};
Usage example
import { BoltSuiClient } from '@bolt-liquidity-hq/sui-client';const client = new BoltSuiClient();const assets = await client.getAssets();console.log('Available assets:', assets.length);assets.forEach(asset => { console.log(`${asset.symbol}: ${asset.name} (${asset.decimals} decimals)`);});// Find a specific assetconst suiAsset = assets.find((a) => a.symbol === 'SUI');console.log(`SUI type: ${suiAsset?.denom}`); // "0x2::sui::SUI"
getAllOracleAssetPairs()Queries the oracle smart contract to retrieve all supported asset pairs with automatic pagination. Each asset pair represents a base/quote relationship that can be used for price queries and swaps.
type OracleAssetPair = { base: OracleAsset; // Base asset information quote: OracleAsset; // Quote asset information};type OracleAsset = { name: string; // Asset name (currently same as symbol) symbol: string; // Trading symbol (e.g., "SUI", "ETH") precision: number; // Number of decimal places};
getAllPrices() Queries the oracle smart contract to retrieve all available price feeds with automatic pagination. More efficient than making multiple individual price queries when you need prices for multiple pairs.
Method Signature
Returns
async getAllPrices(): Promise<Price[]>
type Price = { assetPair: string; // Currently empty string due to contract limitations price: string; // Current price as decimal string expiryTime: string; // Unix timestamp in nanoseconds when price expires};
getPrice() Queries the oracle smart contract to retrieve the current price for a specific asset pair. Fetches the latest price feed that is updated by authorised price feeders and validated against configured thresholds.
type InvertiblePrice = { assetPair: string; // Trading pair in format "baseDenom:quoteDenom" price: string; // Current price as decimal string expiryTime: string; // Unix timestamp in nanoseconds when price expires isInverse: boolean; // Always false in current implementation};
getPoolBaseLiquidity() Queries the router smart contract to retrieve the total base asset liquidity for a specific pool. Fetches current liquidity levels for the base asset in the specified pool.
type BaseLiquidityDetails = { baseLiquidity: Coin; // Base asset liquidity information totalShares: string; // Total liquidity shares};type Coin = { amount: string; // Quantity of base asset liquidity denom: string; // Type of the base asset};
getAllBaseAssetsLiquidity() Queries the router smart contract to retrieve the base asset liquidity across all pools. Fetches current liquidity levels for all the base assets in their respective pools.
type BaseLiquidityDetails = { baseLiquidity: Coin; // Base asset liquidity information totalShares: string; // Total liquidity shares};type Coin = { amount: string; // Quantity of base asset liquidity denom: string; // Type of the base asset};
getAllPools() Queries the router smart contract to retrieve information about all deployed pools with automatic pagination. Fetches a comprehensive list of all pools in the Bolt execution layer.
Method Signature
Returns
async getAllPools(): Promise<Pool[]>
type Pool = { poolAddress: string; // Contract address or Sui object ID of the pool baseDenom: string; // Type of the base asset quoteDenoms: string[]; // Array of available quote asset types};
Usage example
const allPools = await client.getAllPools();console.log(`Total pools available: ${allPools.length}`);// Display all pools and their trading pairsallPools.forEach((pool, index) => { console.log(`\nPool ${index + 1}: ${pool.poolAddress}`); console.log(` Base asset: ${pool.baseDenom}`); console.log(` Quote assets: ${pool.quoteDenoms.length}`); pool.quoteDenoms.forEach(quote => { console.log(` - ${quote}`); });});// Find pools for specific base assetconst suiPools = allPools.filter(pool => pool.baseDenom === "0x2::sui::SUI");console.log(`SUI pools found: ${suiPools.length}`);
getPoolConfig() Retrieves the configuration settings of a liquidity pool contract. Queries the contract to fetch its current configuration parameters, including fees, LP settings, and oracle integration.
type PoolConfig = { priceOracleContract: string; // Object ID of price oracle used by this pool protocolFeeRecipient: string; // Sui address that receives protocol fees protocolFee: string; // Protocol fee percentage (e.g., "0.003" = 0.3%) lpFee: string; // LP fee percentage (e.g., "0.002" = 0.2%) allowanceMode: string; // Allowance mode for pool operations lps: string[]; // Array of authorised LP Sui addresses minBaseOut: string; // Minimum base asset output amount for trades};
getPoolByDenom() Queries the router smart contract to retrieve pool information for a specific base/quote asset pair on Sui. Fetches pool details for the pool matching the provided asset denominations.
type Pool = { poolAddress: string; // Contract address or Sui object ID of the pool baseDenom: string; // Type of the base asset quoteDenoms: string[]; // Array of available quote asset types};
Usage example
// Get pool for SUI/USDC pair on the Bolt Sui Outpostconst pool = await client.getPoolByDenom( '0x2::sui::SUI', '0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC');console.log('Pool Address:', pool.poolAddress);console.log('Base Asset:', pool.baseDenom);console.log('Quote Assets:', pool.quoteDenoms.length);pool.quoteDenoms.forEach(quote => { console.log(` - ${quote}`);});
getPoolConfigByDenom() Retrieves pool configuration by base/quote asset pair. This is a convenience function that combines pool lookup and configuration retrieval.
type PoolConfig = { priceOracleContract: string; // Object ID of price oracle used by this pool protocolFeeRecipient: string; // Sui address that receives protocol fees protocolFee: string; // Protocol fee percentage (e.g., "0.003" = 0.3%) lpFee: string; // LP fee percentage (e.g., "0.002" = 0.2%) allowanceMode: string; // Allowance mode for pool operations lps: string[]; // Array of authorised LP Sui addresses minBaseOut: string; // Minimum base asset output amount for trades};
Usage example
// Get pool configuration for SUI/USDC pair on the Bolt Sui Outpostconst config = await client.getPoolConfigByDenom( '0x2::sui::SUI', '0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC');console.log('Price Oracle:', config.priceOracleContract);console.log('Protocol Fee Recipient:', config.protocolFeeRecipient);console.log('Protocol Fee:', config.protocolFee);console.log('LP Fee:', config.lpFee);console.log('Allowance Mode:', config.allowanceMode);console.log('Authorised LPs:', config.lps.length);console.log('Min Base Out:', config.minBaseOut);
simulateSwap() Simulates a swap operation to calculate the expected output amount without executing the transaction. Performs a dry run taking into account current pool conditions, oracle prices, and fees. Use this for accurate estimates before executing.
type SimulateSwapResult = { poolAddress: string; // Contract address or Sui object ID of the pool amountOut: string; // Amount expected to be received after the swap assetOut: string; // Denom of the asset that will be received protocolFee: string; // Protocol fee amount that would be charged lpFee: string; // LP fee amount that would be charged dynamicFeePercentage?: string; // Percentage going to dynamic fees on the Sui Outpost totalFees: string; // Sum of protocolFee and lpFee (dynamic fee distributed between both)};
swap() Executes a token swap transaction on the Bolt execution layer through the router contract. It performs a “swap exact in” operation where you specify exactly how much of the input asset to swap, and receive a variable amount of the output asset based on current pool conditions.
Method Signature
Returns
async swap(params: SwapParams, signer: Signer): Promise<SwapResult<SuiTransactionBlockResponse>>type SwapParams = { assetIn: string; // Denomination of the asset being sold amountIn: string; // Exact amount of input asset to swap (in minimal units) assetOut: string; // Denomination of the asset being bought minimumAmountOut?: string; // Optional minimum acceptable amount of output asset receiver?: Address; // Optional recipient address for swapped assets swapType?: 'buy' | 'sell'; // Optional swap type to execute on the pool, defaults to 'buy'};
type SwapResult<SuiTransactionBlockResponse> = { txOutput: SuiTransactionBlockResponse; // Complete transaction response amountOut: string; // Actual amount of output asset received assetOut: string; // Output asset denomination txHash: string; // Transaction hash for tracking};