Quick Start Guide

Get started with the Whisky Gaming Protocol in minutes

Quick Start Guide

Welcome to the Whisky Gaming Protocol! This guide will help you get up and running quickly, whether you’re a developer building games, a player wanting to participate, or a liquidity provider looking to earn fees.

Prerequisites

Before you begin, make sure you have:

• Solana Wallet: Phantom, Solflare, or any Solana wallet
• SOL: Some SOL for transaction fees
• Node.js: Version 16.0.0 or higher (for developers)
• Basic Knowledge: Understanding of Solana and blockchain concepts

For Players

1. Connect Your Wallet

First, connect your Solana wallet to a Whisky-powered platform:

// Example wallet connection
import { useWallet } from '@solana/wallet-adapter-react';

const { connect, connected, wallet } = useWallet();

if (!connected) {
  return <button onClick={connect}>Connect Wallet</button>;
}

2. Choose a Game

Browse available games on platforms like:

• Whisky Explorer
• Community-built gaming platforms
• Direct integrations

3. Place Your First Bet

// Example game interaction
import { useWhisky } from '@whisky-gaming/ui';

const { play, isPlaying } = useWhisky();

const handlePlay = async () => {
  await play({
    wager: 1000000, // 1 USDC (in base units)
    bet: [50, 50], // 50/50 chance
    creator: 'GAME_CREATOR_ADDRESS',
    clientSeed: 'my_random_seed_123'
  });
};

4. Wait for Settlement

Games are settled automatically by the RNG provider:

// Wait for game settlement
const { game, result } = useWhisky();

if (game && result) {
  console.log(`Game result: ${result.won ? 'Won!' : 'Lost'}`);
  console.log(`Payout: ${result.payout}`);
}

For Developers

1. Install Dependencies

# Install Core SDK
npm install @whisky-gaming/core

# Install React SDK (for frontend)
npm install @whisky-gaming/ui

# Install Solana dependencies
npm install @solana/web3.js @solana/wallet-adapter-react

2. Initialize SDK

import { WhiskySDK } from '@whisky-gaming/core';
import { Connection, Keypair } from '@solana/web3.js';

const sdk = new WhiskySDK({
  connection: new Connection('https://api.mainnet-beta.solana.com'),
  wallet: yourWallet,
  programId: WHISKY_PROGRAM_ID
});

3. Create Your First Pool

// Create a USDC gaming pool
const poolAddress = await sdk.createPool({
  tokenMint: USDC_MINT_ADDRESS,
  minimumWager: 1_000_000, // 1 USDC
  maximumWager: 100_000_000, // 100 USDC
  poolAuthority: poolAuthorityKeypair,
  feeBps: 100 // 1% fee
});

console.log('Pool created:', poolAddress.toString());

4. Build a Simple Game

// Simple coinflip game
function CoinflipGame() {
  const { play, isPlaying, game } = useWhisky();
  const [wager, setWager] = useState(1000000); // 1 USDC

  const handlePlay = async () => {
    try {
      await play({
        poolAddress: poolAddress,
        wager: wager,
        bet: [50, 50], // Equal probability
        clientSeed: `flip_${Date.now()}`,
        creatorFee: 100, // 1%
        jackpotFee: 50,  // 0.5%
        metadata: 'Coinflip Game'
      });
    } catch (error) {
      console.error('Game failed:', error);
    }
  };

  return (
    <div>
      <input
        type="number"
        value={wager}
        onChange={(e) => setWager(Number(e.target.value))}
        placeholder="Wager amount (in base units)"
      />
      <button onClick={handlePlay} disabled={isPlaying}>
        {isPlaying ? 'Playing...' : 'Flip Coin'}
      </button>
      {game && (
        <div>
          <h3>Game Result</h3>
          <p>Status: {game.status}</p>
          {game.result && (
            <p>Outcome: {game.result === 0 ? 'Heads' : 'Tails'}</p>
          )}
        </div>
      )}
    </div>
  );
}

For Liquidity Providers

1. Find a Pool

Browse available pools on the Whisky Explorer:

// Get pool information
const poolInfo = await sdk.getPoolInfo(poolAddress);
console.log('Pool liquidity:', poolInfo.totalLiquidity);
console.log('Pool volume:', poolInfo.totalVolume);

2. Deposit Liquidity

// Deposit 1000 USDC to earn fees
const signature = await sdk.depositLiquidity(
  poolAddress,
  1000_000_000 // 1000 USDC in base units
);

console.log('Deposit successful:', signature);

3. Monitor Earnings

// Check LP token balance
const lpBalance = await sdk.getLPTokenBalance(poolAddress, walletAddress);
console.log('LP tokens owned:', lpBalance);

// Calculate earnings
const earnings = await sdk.calculateLPFees(poolAddress, lpBalance);
console.log('Total fees earned:', earnings);

4. Withdraw Liquidity

// Withdraw liquidity
const withdrawSignature = await sdk.withdrawLiquidity(
  poolAddress,
  lpBalance // Withdraw all LP tokens
);

console.log('Withdrawal successful:', withdrawSignature);

Advanced Examples

Multi-Outcome Game

// Six-sided dice game
const diceGame = await sdk.playGame({
  poolAddress: solPool,
  wager: 5_000_000_000, // 5 SOL
  bet: [16, 16, 16, 16, 16, 20], // Slightly favor outcome 6
  clientSeed: 'dice_roll_789',
  creatorFee: 300, // 3% house edge
  jackpotFee: 100, // 1% progressive jackpot
  metadata: 'Lucky Dice Roll'
});

Prediction Market

// Binary prediction market
const predictionGame = await sdk.playGame({
  poolAddress: usdcPool,
  wager: 50_000_000, // 50 USDC
  bet: [60, 40], // 60% probability for "Yes"
  clientSeed: 'prediction_12345',
  creatorFee: 200, // 2% to market creator
  jackpotFee: 0,   // No jackpot for predictions
  metadata: 'Election Outcome Prediction'
});

Slot Machine

// Complex probability distribution
const slotGame = await sdk.playGame({
  poolAddress: bonkPool,
  wager: 1_000_000_000, // 1B BONK tokens
  bet: [
    500, // 50% - No win
    300, // 30% - Small win (2x)
    150, // 15% - Medium win (5x)
    40,  // 4% - Large win (20x)
    9,   // 0.9% - Huge win (100x)
    1    // 0.1% - Jackpot (1000x)
  ],
  clientSeed: 'slot_machine_456',
  creatorFee: 500, // 5% house edge
  jackpotFee: 200, // 2% progressive jackpot
  metadata: 'Triple 7s Slot Machine'
});

Testing

Local Development

# Set Solana to devnet
solana config set --url devnet

# Request test SOL
solana airdrop 2

# Run tests
npm test

Test Game Flow

describe('Game Flow', () => {
  test('should complete full game cycle', async () => {
    // Create pool
    const poolAddress = await sdk.createPool(poolParams);
    
    // Add liquidity
    await sdk.depositLiquidity(poolAddress, 1000000000);
    
    // Play game
    const gameResult = await sdk.playGame(gameParams);
    
    // Wait for settlement
    const settlement = await sdk.waitForSettlement(gameResult.gameAddress);
    
    // Claim winnings if won
    if (settlement.won) {
      await sdk.claimWinnings(gameResult.gameAddress);
    }
    
    expect(settlement).toBeDefined();
  });
});

Best Practices

Security

1. Validate Inputs: Always validate user inputs before sending transactions
2. Handle Errors: Implement proper error handling for all operations
3. Test Thoroughly: Test your games extensively before deployment
4. Monitor Transactions: Track transaction success and failure rates

Performance

1. Batch Operations: Group multiple operations when possible
2. Cache Data: Cache frequently accessed data
3. Optimize Queries: Use efficient database queries
4. Monitor Costs: Track transaction costs and optimize

User Experience

1. Clear Feedback: Provide clear feedback for all user actions
2. Loading States: Show loading states during transactions
3. Error Messages: Display helpful error messages
4. Mobile Support: Ensure your app works on mobile devices

Next Steps

Now that you’re familiar with the basics, explore:

• API Reference: Detailed API documentation
• Core SDK: Advanced SDK features
• React SDK: UI components and hooks
• Explorer: Monitor protocol activity
• Community: Join the Discord community

Support

Need help? Get support from:

• Documentation: Browse this documentation
• Community: Discord Server
• Issues: GitHub Issues
• Email: [e-mail]

Happy building! 🎮