Integration Guide

TYPESCRIPT
import { SuiClient, getFullnodeUrl } from '@mysten/sui/client';
 
const client = new SuiClient({
  url: getFullnodeUrl('mainnet'), // or 'testnet', 'devnet'
});
 
// Contract package ID
const PROPHYT_PACKAGE_ID = '0x...';

TYPESCRIPT
import { TransactionBlock } from '@mysten/sui/transactions';
 
async function createMarket(
  question: string,
  description: string,
  duration: number // seconds
) {
  const txb = new TransactionBlock();
  
  txb.moveCall({
    target: `${PROPHYT_PACKAGE_ID}::prediction_market::create_market`,
    typeArguments: ['0x2::sui::SUI'],
    arguments: [
      txb.object(STATE_OBJECT_ID),
      txb.pure(question),
      txb.pure(description),
      txb.pure(duration),
      txb.object(CLOCK_OBJECT_ID),
    ],
  });
  
  const result = await signAndExecuteTransactionBlock({
    transactionBlock: txb,
    signer: keypair,
  });
  
  return result;
}

TYPESCRIPT
async function placeBet(
  marketId: number,
  position: boolean, // true for Yes, false for No
  amount: number
) {
  const txb = new TransactionBlock();
  
  // Split coin for bet
  const [betCoin] = txb.splitCoins(txb.gas, [amount]);
  
  txb.moveCall({
    target: `${PROPHYT_PACKAGE_ID}::prediction_market::place_bet`,
    typeArguments: ['0x2::sui::SUI'],
    arguments: [
      txb.object(STATE_OBJECT_ID),
      txb.object(REGISTRY_OBJECT_ID),
      txb.object(SUILEND_STATE_ID),
      txb.object(HAEDAL_STATE_ID),
      txb.object(VOLO_STATE_ID),
      txb.pure(marketId),
      txb.pure(position),
      betCoin,
      txb.pure(blobAddress),
      txb.pure(imageUrl),
      txb.pure(imageBlobId),
      txb.object(CLOCK_OBJECT_ID),
    ],
  });
  
  return await signAndExecuteTransactionBlock({
    transactionBlock: txb,
    signer: keypair,
  });
}

TYPESCRIPT
const API_BASE_URL = 'http://localhost:8000/api';
 
async function fetchMarkets(filters?: {
  status?: string;
  protocolId?: string;
  limit?: number;
  offset?: number;
}) {
  const params = new URLSearchParams();
  if (filters?.status) params.append('status', filters.status);
  if (filters?.protocolId) params.append('protocolId', filters.protocolId);
  if (filters?.limit) params.append('limit', filters.limit.toString());
  if (filters?.offset) params.append('offset', filters.offset.toString());
  
  const response = await fetch(`${API_BASE_URL}/markets?${params}`);
  return await response.json();
}

TYPESCRIPT
// Get all active markets
const markets = await fetchMarkets({ status: 'active', limit: 20 });
 
// Get market details
async function getMarket(marketId: string) {
  const response = await fetch(`${API_BASE_URL}/markets/${marketId}`);
  return await response.json();
}

TYPESCRIPT
async function getUserBets(userAddress: string) {
  const response = await fetch(`${API_BASE_URL}/bets/user/${userAddress}`);
  return await response.json();
}
 
async function getUserStats(userAddress: string) {
  const response = await fetch(`${API_BASE_URL}/users/${userAddress}/stats`);
  return await response.json();
}

TYPESCRIPT
const NAUTILUS_URL = 'http://localhost:8080';
 
async function requestResolution(
  marketId: number,
  marketQuestion: string,
  marketEndTime: number,
  dataSourceUrl?: string,
  imageUrl?: string
) {
  const response = await fetch(`${NAUTILUS_URL}/resolve`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      market_id: marketId,
      market_question: marketQuestion,
      market_end_time: marketEndTime,
      data_source_url: dataSourceUrl,
      image_url: imageUrl,
    }),
  });
  
  return await response.json();
}

TYPESCRIPT
import { useState, useEffect } from 'react';
 
function useMarkets(filters?: MarketFilters) {
  const [markets, setMarkets] = useState([]);
  const [loading, setLoading] = useState(true);
  
  useEffect(() => {
    async function fetchData() {
      setLoading(true);
      const data = await fetchMarkets(filters);
      setMarkets(data.data.markets);
      setLoading(false);
    }
    
    fetchData();
    const interval = setInterval(fetchData, 5000);
    return () => clearInterval(interval);
  }, [filters]);
  
  return { markets, loading };
}

TYPESCRIPT
import { useWallet } from '@suiet/wallet-kit';
 
function BettingComponent({ marketId }: { marketId: string }) {
  const { address, signAndExecuteTransactionBlock } = useWallet();
  
  const handleBet = async (position: boolean, amount: number) => {
    if (!address) {
      alert('Please connect wallet');
      return;
    }
    
    try {
      const result = await placeBet(marketId, position, amount);
      console.log('Bet placed:', result);
    } catch (error) {
      console.error('Bet failed:', error);
    }
  };
  
  return (
    <div>
      <button onClick={() => handleBet(true, 1000000)}>
        Bet Yes
      </button>
      <button onClick={() => handleBet(false, 1000000)}>
        Bet No
      </button>
    </div>
  );
}