DarkSightDeveloper Docs

import { DarkSightSDK } from '@darksight/sdk';
import { Connection, Wallet } from '@solana/web3.js';

const connection = new Connection('https://api.mainnet-beta.solana.com');
const wallet = new Wallet(/* your wallet */);

const sdk = new DarkSightSDK({
  connection,
  wallet,
  network: 'mainnet-beta'
});

// Initialize the SDK
await sdk.initialize();

// Proof generation is handled automatically in our current design:
const sdk = new DarkSightSDK({
  connection,
  wallet,
  proofConfig: {
    wasmPath: '/path/to/prover.wasm',
    timeout: 10000, // 10 seconds
    useWorker: true // Use web worker for non-blocking proof generation
  }
});

const market = await sdk.createMarket({
  question: 'Will Bitcoin reach $100K by end of 2025?',
  outcomes: ['Yes', 'No'],
  resolutionDate: new Date('2025-12-31'),
  initialLiquidity: 10000, // SOL
  description: 'Optional market description',
  category: 'crypto'
});

console.log('Market created:', market.id);

// First, deposit funds into the shielded pool
const depositResult = await sdk.deposit(1000); // 1000 SOL

// Create a private position
const position = await sdk.createPosition({
  marketId: market.id,
  outcome: 'Yes',
  amount: 500 // SOL
});

// Position is completely private - only you know the details
console.log('Position commitment:', position.commitment);

// Get all active markets
const markets = await sdk.getMarkets({
  status: 'active',
  limit: 50,
  offset: 0
});

// Find specific market by ID
const market = markets.find(m => m.id === marketId);

// Current odds are public
console.log('Yes odds:', market?.currentOdds['Yes']);
console.log('No odds:', market?.currentOdds['No']);
console.log('24h volume:', market?.volume24h);

// Get your positions for a market
const positions = await sdk.getPositions({
  marketId: market.id,
  outcome: 'Yes'
});

// Withdraw funds (zero-knowledge proof verifies ownership)
const withdrawResult = await sdk.withdraw({
  amount: winningsAmount,
  recipient: wallet.publicKey
});

console.log('Withdrawal signature:', withdrawResult.signature);
console.log('Nullifier:', withdrawResult.nullifier);

import { DarkSightSDK } from '@darksight/sdk';
import { Connection, Keypair } from '@solana/web3.js';

async function tradeExample() {
  // Initialize SDK
  const connection = new Connection('https://api.mainnet-beta.solana.com');
  const wallet = Keypair.generate(); // In production, use actual wallet
  
  const sdk = new DarkSightSDK({
    connection,
    wallet,
    network: 'mainnet-beta'
  });
  
  await sdk.initialize();
  
  // 1. Deposit funds
  const deposit = await sdk.deposit(1000);
  console.log('Deposited:', deposit.amount);
  
  // 2. Find a market
  const markets = await sdk.getMarkets({ status: 'active' });
  const market = markets[0];
  
  // 3. Create private position
  const position = await sdk.createPosition({
    marketId: market.id,
    outcome: 'Yes',
    amount: 500
  });
  
  console.log('Position created:', position.id);
  console.log('Current odds:', market.currentOdds);
  
  // 4. Wait for market resolution...
  // (In production, you'd listen for resolution events)
  
  // 5. Withdraw winnings
  const withdraw = await sdk.withdraw({
    amount: 750, // Your winnings
    recipient: wallet.publicKey
  });
  
  console.log('Withdrawn:', withdraw.amount);
}

tradeExample().catch(console.error);

import { useEffect, useState } from 'react';
import { useWallet } from '@solana/wallet-adapter-react';
import { DarkSightSDK } from '@darksight/sdk';

export function useDarkSight() {
  const { publicKey, signTransaction } = useWallet();
  const [sdk, setSdk] = useState<DarkSightSDK | null>(null);
  
  useEffect(() => {
    if (!publicKey) return;
    
    const connection = new Connection('https://api.mainnet-beta.solana.com');
    const sdkInstance = new DarkSightSDK({
      connection,
      wallet: { publicKey, signTransaction },
      network: 'mainnet-beta'
    });
    
    sdkInstance.initialize().then(() => setSdk(sdkInstance));
    
    return () => {
      sdkInstance?.disconnect();
    };
  }, [publicKey, signTransaction]);
  
  return sdk;
}

// Usage in component
function TradingComponent() {
  const sdk = useDarkSight();
  const [markets, setMarkets] = useState([]);
  
  useEffect(() => {
    if (!sdk) return;
    sdk.getMarkets().then(setMarkets);
  }, [sdk]);
  
  // ... rest of component
}

import { 
  DarkSightError,
  InsufficientBalanceError,
  MarketNotFoundError,
  ProofGenerationError,
  NetworkError
} from '@darksight/sdk';

try {
  await sdk.createPosition({ marketId, outcome, amount });
} catch (error) {
  if (error instanceof InsufficientBalanceError) {
    console.error('Not enough balance in shielded pool');
  } else if (error instanceof ProofGenerationError) {
    console.error('Failed to generate ZK proof:', error.message);
  } else if (error instanceof NetworkError) {
    console.error('Network error:', error.message);
  }
}

// Subscribe to market updates
sdk.onMarketUpdate(marketId, (update) => {
  console.log('Odds updated:', update.currentOdds);
  console.log('New volume:', update.volume24h);
});

// Subscribe to position updates
sdk.onPositionUpdate((position) => {
  console.log('Position updated:', position.id);
});

// Cleanup
sdk.removeAllListeners();