dubs-server 1.0.0

package/services/arcadeMatchService.js

@@ -0,0 +1,763 @@
+/**
+ * 🎮 Arcade Match Service
+ * 
+ * Handles head-to-head arcade game matches with the following features:
+ * - Create matches with stakes
+ * - Join existing matches
+ * - Submit scores
+ * - Resolve matches with operator fees
+ * - Cancel unmatched games
+ */
+
+const { Connection, Keypair, PublicKey, SystemProgram, Transaction, TransactionInstruction } = require('@solana/web3.js');
+const crypto = require('crypto');
+const { v4: uuidv4 } = require('uuid');
+const fs = require('fs');
+const path = require('path');
+
+// 🎮 Arcade Program Configuration
+const ARCADE_PROGRAM_ID = new PublicKey('EiNzW28xL1a92m1i9T3MyRZqEEszMcVBtrYB3NkphwRq');
+
+// 🔐 HARDCODED OPERATOR WALLET - Must match the contract!
+const OPERATOR_WALLET = new PublicKey('BVZXwZpfgyzTBdRFHohkHZppPHnAyqyctRsKy3vWfQib');
+
+// Instruction discriminators (first 8 bytes of SHA256 hash of "global:instruction_name")
+const DISCRIMINATORS = {
+  CREATE_MATCH: Buffer.from([107, 2, 184, 145, 70, 142, 17, 165]),      // create_match
+  JOIN_MATCH: Buffer.from([244, 8, 47, 130, 192, 59, 179, 44]),         // join_match
+  SUBMIT_SCORE: Buffer.from([130, 100, 1, 137, 70, 252, 96, 3]),        // submit_match_score
+  RESOLVE_MATCH: Buffer.from([73, 0, 15, 197, 178, 47, 21, 193]),       // resolve_match
+  CANCEL_MATCH: Buffer.from([142, 136, 247, 45, 92, 112, 180, 83]),     // cancel_match
+};
+
+// Game types
+const GAME_TYPES = {
+  ASTEROIDS: { asteroids: {} },
+  SNAKE: { snake: {} },
+};
+
+// Match types
+const MATCH_TYPES = {
+  BEST_OF_1: { bestOf1: {} },
+  BEST_OF_3: { bestOf3: {} },
+};
+
+// Match status
+const MATCH_STATUS = {
+  WAITING_FOR_OPPONENT: 0,
+  ACTIVE: 1,
+  RESOLVED: 2,
+  CANCELLED: 3,
+};
+
+class ArcadeMatchService {
+  constructor(config) {
+    this.connection = new Connection(config.rpcUrl || 'http://127.0.0.1:8899', 'confirmed');
+    this.programId = ARCADE_PROGRAM_ID;
+    this.operatorWallet = OPERATOR_WALLET;
+    this.walletsDir = config.walletsDir || path.join(__dirname, '..', 'wallets');
+    
+    // Ensure wallets directory exists
+    if (!fs.existsSync(this.walletsDir)) {
+      fs.mkdirSync(this.walletsDir, { recursive: true });
+    }
+    
+    console.log('🎮 Arcade Match Service initialized');
+    console.log('   Program ID:', this.programId.toString());
+    console.log('   Operator:', this.operatorWallet.toString());
+  }
+
+  /**
+   * Get match PDA from match ID
+   */
+  getMatchPDA(matchId) {
+    const matchIdNum = typeof matchId === 'string' ? this.uuidToU64(matchId) : BigInt(matchId);
+    const matchIdBuf = Buffer.alloc(8);
+    matchIdBuf.writeBigUInt64LE(matchIdNum);
+    return PublicKey.findProgramAddressSync(
+      [Buffer.from('match'), matchIdBuf],
+      this.programId
+    );
+  }
+
+  /**
+   * Convert UUID to u64 for use as match ID
+   */
+  uuidToU64(uuid) {
+    const hash = crypto.createHash('sha256').update(uuid).digest();
+    return hash.readBigUInt64LE(0);
+  }
+
+  /**
+   * Get or create a wallet for a player
+   */
+  getWallet(playerName) {
+    const walletPath = path.join(this.walletsDir, `arcade_${playerName}.json`);
+    
+    if (fs.existsSync(walletPath)) {
+      const secretKey = JSON.parse(fs.readFileSync(walletPath, 'utf-8'));
+      return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+    }
+    
+    const newWallet = Keypair.generate();
+    fs.writeFileSync(walletPath, JSON.stringify(Array.from(newWallet.secretKey)));
+    console.log(`✅ Created arcade wallet for ${playerName}`);
+    return newWallet;
+  }
+
+  /**
+   * Fetch match data from chain
+   */
+  async getMatchData(matchId) {
+    try {
+      const [matchPDA] = this.getMatchPDA(matchId);
+      const accountInfo = await this.connection.getAccountInfo(matchPDA);
+      
+      if (!accountInfo) {
+        return null;
+      }
+
+      // Parse match account data (simplified - you may want to use Anchor's IDL parser)
+      const data = accountInfo.data;
+      
+      // Basic structure (you'll need to adjust based on actual layout)
+      return {
+        matchId: matchId,
+        pda: matchPDA.toString(),
+        exists: true,
+        lamports: accountInfo.lamports,
+        // Add more parsing as needed
+      };
+    } catch (error) {
+      console.error('Error fetching match data:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Build UNSIGNED transaction for creating a match
+   * Returns base64 encoded transaction for user to sign
+   */
+  async buildCreateMatchTransaction(params) {
+    const {
+      creatorAddress,
+      stake,
+      gameType = 'asteroids',
+      matchType = 'bestOf1',
+      deadlineMinutes = 60,
+    } = params;
+
+    try {
+      // Generate UUID for Firebase and human-readable sharing
+      const matchUuid = uuidv4();
+      // Convert to u64 for on-chain storage
+      const matchId = this.uuidToU64(matchUuid);
+      const [matchPDA] = this.getMatchPDA(matchId);
+      
+      // Calculate deadline
+      const currentTime = Math.floor(Date.now() / 1000);
+      const deadline = currentTime + (deadlineMinutes * 60);
+      
+      // Build instruction data
+      const matchIdBuf = Buffer.alloc(8);
+      matchIdBuf.writeBigUInt64LE(matchId);
+      
+      const stakeBuf = Buffer.alloc(8);
+      stakeBuf.writeBigUInt64LE(BigInt(stake));
+      
+      const gameTypeBuf = Buffer.from([gameType === 'asteroids' ? 0 : 1]);
+      const matchTypeBuf = Buffer.from([matchType === 'bestOf1' ? 0 : 1]);
+      
+      const deadlineBuf = Buffer.alloc(8);
+      deadlineBuf.writeBigInt64LE(BigInt(deadline));
+      
+      const instructionData = Buffer.concat([
+        DISCRIMINATORS.CREATE_MATCH,
+        matchIdBuf,
+        stakeBuf,
+        gameTypeBuf,
+        matchTypeBuf,
+        deadlineBuf,
+      ]);
+      
+      const creatorPubkey = new PublicKey(creatorAddress);
+      
+      const instruction = new TransactionInstruction({
+        programId: this.programId,
+        keys: [
+          { pubkey: matchPDA, isSigner: false, isWritable: true },
+          { pubkey: creatorPubkey, isSigner: true, isWritable: true },
+          { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+        data: instructionData,
+      });
+      
+      // Build unsigned transaction
+      const transaction = new Transaction().add(instruction);
+      
+      // Get recent blockhash
+      const { blockhash } = await this.connection.getLatestBlockhash('confirmed');
+      transaction.recentBlockhash = blockhash;
+      transaction.feePayer = creatorPubkey;
+      
+      // Serialize to base64
+      const serialized = transaction.serialize({
+        requireAllSignatures: false,
+        verifySignatures: false,
+      });
+      
+      console.log(`✅ Built create match transaction`);
+      console.log(`   Match UUID: ${matchUuid}`);
+      console.log(`   Match PDA: ${matchPDA.toString()}`);
+      
+      return {
+        success: true,
+        matchId: matchId.toString(),  // u64 for on-chain
+        matchUuid: matchUuid,  // UUID for Firebase/sharing
+        matchPDA: matchPDA.toString(),
+        transaction: serialized.toString('base64'),
+        stake,
+        gameType,
+        matchType,
+      };
+    } catch (error) {
+      console.error('Error building create match transaction:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Create a new arcade match (LEGACY - for testing with test wallets)
+   */
+  async createMatch(params) {
+    const {
+      matchId,
+      creatorName,
+      stake,
+      gameType = 'asteroids',
+      matchType = 'bestOf1',
+      deadlineMinutes = 60,
+    } = params;
+
+    try {
+      const creator = this.getWallet(creatorName);
+      const [matchPDA] = this.getMatchPDA(matchId);
+      
+      // Calculate deadline
+      const currentTime = Math.floor(Date.now() / 1000);
+      const deadline = currentTime + (deadlineMinutes * 60);
+      
+      // Build instruction data with proper Borsh encoding
+      const matchIdNum = typeof matchId === 'string' ? this.uuidToU64(matchId) : BigInt(matchId);
+      const matchIdBuf = Buffer.alloc(8);
+      matchIdBuf.writeBigUInt64LE(matchIdNum);
+      
+      const stakeBuf = Buffer.alloc(8);
+      stakeBuf.writeBigUInt64LE(BigInt(stake));
+      
+      // Borsh enum encoding: variant index (u8) only (no data for these simple enums)
+      const gameTypeBuf = Buffer.from([gameType === 'asteroids' ? 0 : 1]);
+      const matchTypeBuf = Buffer.from([matchType === 'bestOf1' ? 0 : 1]);
+      
+      const deadlineBuf = Buffer.alloc(8);
+      deadlineBuf.writeBigInt64LE(BigInt(deadline));
+      
+      const instructionData = Buffer.concat([
+        DISCRIMINATORS.CREATE_MATCH,
+        matchIdBuf,
+        stakeBuf,
+        gameTypeBuf,
+        matchTypeBuf,
+        deadlineBuf,
+      ]);
+      
+      const instruction = new TransactionInstruction({
+        programId: this.programId,
+        keys: [
+          { pubkey: matchPDA, isSigner: false, isWritable: true },
+          { pubkey: creator.publicKey, isSigner: true, isWritable: true },
+          { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+        data: instructionData,
+      });
+      
+      const transaction = new Transaction().add(instruction);
+      const signature = await this.connection.sendTransaction(transaction, [creator]);
+      await this.connection.confirmTransaction(signature);
+      
+      console.log(`✅ Match created: ${matchId}`);
+      console.log(`   Signature: ${signature}`);
+      
+      return {
+        success: true,
+        matchId,
+        signature,
+        matchPDA: matchPDA.toString(),
+        creator: creator.publicKey.toString(),
+        stake,
+        gameType,
+        matchType,
+        deadline: new Date(deadline * 1000).toISOString(),
+      };
+    } catch (error) {
+      console.error('Error creating match:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Build UNSIGNED transaction for joining a match
+   */
+  async buildJoinMatchTransaction(params) {
+    const { matchId, opponentAddress } = params;
+
+    try {
+      const matchIdNum = typeof matchId === 'string' ? BigInt(matchId) : BigInt(matchId);
+      const [matchPDA] = this.getMatchPDA(matchIdNum);
+      
+      // Build instruction data
+      const matchIdBuf = Buffer.alloc(8);
+      matchIdBuf.writeBigUInt64LE(matchIdNum);
+      
+      const instructionData = Buffer.concat([
+        DISCRIMINATORS.JOIN_MATCH,
+        matchIdBuf,
+      ]);
+      
+      const opponentPubkey = new PublicKey(opponentAddress);
+      
+      const instruction = new TransactionInstruction({
+        programId: this.programId,
+        keys: [
+          { pubkey: matchPDA, isSigner: false, isWritable: true },
+          { pubkey: opponentPubkey, isSigner: true, isWritable: true },
+          { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+        data: instructionData,
+      });
+      
+      // Build unsigned transaction
+      const transaction = new Transaction().add(instruction);
+      
+      // Get recent blockhash
+      const { blockhash } = await this.connection.getLatestBlockhash('confirmed');
+      transaction.recentBlockhash = blockhash;
+      transaction.feePayer = opponentPubkey;
+      
+      // Serialize to base64
+      const serialized = transaction.serialize({
+        requireAllSignatures: false,
+        verifySignatures: false,
+      });
+      
+      console.log(`✅ Built join match transaction`);
+      console.log(`   Match PDA: ${matchPDA.toString()}`);
+      
+      return {
+        success: true,
+        matchId: matchId.toString(),
+        transaction: serialized.toString('base64'),
+      };
+    } catch (error) {
+      console.error('Error building join match transaction:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Build UNSIGNED transaction for submitting a score
+   */
+  async buildSubmitScoreTransaction(params) {
+    const { matchId, playerAddress, score, gameRound = 1 } = params;
+
+    console.log('🎮 [Backend] Building submit score transaction:');
+    console.log('   matchId:', matchId);
+    console.log('   playerAddress:', playerAddress);
+    console.log('   score:', score);
+    console.log('   gameRound:', gameRound, 'Type:', typeof gameRound);
+
+    try {
+      const matchIdNum = typeof matchId === 'string' ? BigInt(matchId) : BigInt(matchId);
+      const [matchPDA] = this.getMatchPDA(matchIdNum);
+      
+      // Build instruction data
+      const matchIdBuf = Buffer.alloc(8);
+      matchIdBuf.writeBigUInt64LE(matchIdNum);
+      
+      const scoreBuf = Buffer.alloc(8);
+      scoreBuf.writeBigUInt64LE(BigInt(score));
+      
+      const roundBuf = Buffer.from([gameRound]);
+      
+      const instructionData = Buffer.concat([
+        DISCRIMINATORS.SUBMIT_SCORE,
+        matchIdBuf,
+        scoreBuf,
+        roundBuf,
+      ]);
+      
+      const playerPubkey = new PublicKey(playerAddress);
+      
+      const instruction = new TransactionInstruction({
+        programId: this.programId,
+        keys: [
+          { pubkey: matchPDA, isSigner: false, isWritable: true },
+          { pubkey: playerPubkey, isSigner: true, isWritable: false },
+        ],
+        data: instructionData,
+      });
+      
+      // Build unsigned transaction
+      const transaction = new Transaction().add(instruction);
+      
+      // Get recent blockhash
+      const { blockhash } = await this.connection.getLatestBlockhash('confirmed');
+      transaction.recentBlockhash = blockhash;
+      transaction.feePayer = playerPubkey;
+      
+      // Serialize to base64
+      const serialized = transaction.serialize({
+        requireAllSignatures: false,
+        verifySignatures: false,
+      });
+      
+      console.log(`✅ Built submit score transaction`);
+      console.log(`   Match PDA: ${matchPDA.toString()}`);
+      console.log(`   Score: ${score}, Round: ${gameRound}`);
+      
+      return {
+        success: true,
+        matchId: matchId.toString(),
+        transaction: serialized.toString('base64'),
+      };
+    } catch (error) {
+      console.error('Error building submit score transaction:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Join an existing match (LEGACY - for testing with test wallets)
+   */
+  async joinMatch(params) {
+    const { matchId, opponentName } = params;
+
+    try {
+      const opponent = this.getWallet(opponentName);
+      const [matchPDA] = this.getMatchPDA(matchId);
+      
+      // Build instruction data
+      const matchIdNum = typeof matchId === 'string' ? this.uuidToU64(matchId) : BigInt(matchId);
+      const matchIdBuf = Buffer.alloc(8);
+      matchIdBuf.writeBigUInt64LE(matchIdNum);
+      
+      const instructionData = Buffer.concat([
+        DISCRIMINATORS.JOIN_MATCH,
+        matchIdBuf,
+      ]);
+      
+      const instruction = new TransactionInstruction({
+        programId: this.programId,
+        keys: [
+          { pubkey: matchPDA, isSigner: false, isWritable: true },
+          { pubkey: opponent.publicKey, isSigner: true, isWritable: true },
+          { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+        data: instructionData,
+      });
+      
+      const transaction = new Transaction().add(instruction);
+      const signature = await this.connection.sendTransaction(transaction, [opponent]);
+      await this.connection.confirmTransaction(signature);
+      
+      console.log(`✅ Player joined match: ${matchId}`);
+      console.log(`   Signature: ${signature}`);
+      
+      return {
+        success: true,
+        matchId,
+        signature,
+        opponent: opponent.publicKey.toString(),
+      };
+    } catch (error) {
+      console.error('Error joining match:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Submit a score for a match
+   */
+  async submitScore(params) {
+    const { matchId, playerName, score, gameRound = 1 } = params;
+
+    try {
+      const player = this.getWallet(playerName);
+      const [matchPDA] = this.getMatchPDA(matchId);
+      
+      // Build instruction data
+      const matchIdNum = typeof matchId === 'string' ? this.uuidToU64(matchId) : BigInt(matchId);
+      const matchIdBuf = Buffer.alloc(8);
+      matchIdBuf.writeBigUInt64LE(matchIdNum);
+      
+      const scoreBuf = Buffer.alloc(8);
+      scoreBuf.writeBigUInt64LE(BigInt(score));
+      
+      const roundBuf = Buffer.alloc(1);
+      roundBuf.writeUInt8(gameRound);
+      
+      const instructionData = Buffer.concat([
+        DISCRIMINATORS.SUBMIT_SCORE,
+        matchIdBuf,
+        scoreBuf,
+        roundBuf,
+      ]);
+      
+      const instruction = new TransactionInstruction({
+        programId: this.programId,
+        keys: [
+          { pubkey: matchPDA, isSigner: false, isWritable: true },
+          { pubkey: player.publicKey, isSigner: true, isWritable: false },
+        ],
+        data: instructionData,
+      });
+      
+      const transaction = new Transaction().add(instruction);
+      const signature = await this.connection.sendTransaction(transaction, [player]);
+      await this.connection.confirmTransaction(signature);
+      
+      console.log(`✅ Score submitted: ${playerName} scored ${score} in round ${gameRound}`);
+      console.log(`   Signature: ${signature}`);
+      
+      return {
+        success: true,
+        matchId,
+        signature,
+        player: player.publicKey.toString(),
+        score,
+        gameRound,
+      };
+    } catch (error) {
+      console.error('Error submitting score:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Build UNSIGNED transaction for resolving a match
+   */
+  async buildResolveMatchTransaction(params) {
+    const { matchId, callerAddress, creatorAddress, opponentAddress } = params;
+
+    try {
+      const matchIdNum = typeof matchId === 'string' ? BigInt(matchId) : BigInt(matchId);
+      const [matchPDA] = this.getMatchPDA(matchIdNum);
+      
+      // Build instruction data
+      const matchIdBuf = Buffer.alloc(8);
+      matchIdBuf.writeBigUInt64LE(matchIdNum);
+      
+      const instructionData = Buffer.concat([
+        DISCRIMINATORS.RESOLVE_MATCH,
+        matchIdBuf,
+      ]);
+      
+      const callerPubkey = new PublicKey(callerAddress);
+      const creatorPubkey = new PublicKey(creatorAddress);
+      const opponentPubkey = new PublicKey(opponentAddress);
+      
+      const instruction = new TransactionInstruction({
+        programId: this.programId,
+        keys: [
+          { pubkey: matchPDA, isSigner: false, isWritable: true },
+          { pubkey: callerPubkey, isSigner: true, isWritable: false },  // Caller (anyone - pays gas)
+          // Remaining accounts for payouts: [0]=Operator, [1]=Creator, [2]=Opponent
+          { pubkey: this.operatorWallet, isSigner: false, isWritable: true },
+          { pubkey: creatorPubkey, isSigner: false, isWritable: true },
+          { pubkey: opponentPubkey, isSigner: false, isWritable: true },
+        ],
+        data: instructionData,
+      });
+      
+      // Build unsigned transaction
+      const transaction = new Transaction().add(instruction);
+      
+      // Get recent blockhash
+      const { blockhash } = await this.connection.getLatestBlockhash('confirmed');
+      transaction.recentBlockhash = blockhash;
+      transaction.feePayer = callerPubkey;  // Caller pays gas
+      
+      // Serialize to base64
+      const serialized = transaction.serialize({
+        requireAllSignatures: false,
+        verifySignatures: false,
+      });
+      
+      console.log(`✅ Built resolve match transaction`);
+      console.log(`   Match PDA: ${matchPDA.toString()}`);
+      
+      return {
+        success: true,
+        matchId: matchId.toString(),
+        transaction: serialized.toString('base64'),
+      };
+    } catch (error) {
+      console.error('Error building resolve match transaction:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Resolve a match and distribute winnings (LEGACY)
+   */
+  async resolveMatch(params) {
+    const { matchId, callerName } = params;
+
+    try {
+      const caller = this.getWallet(callerName);
+      const [matchPDA] = this.getMatchPDA(matchId);
+      
+      // Fetch match data to determine winner and opponent
+      const matchData = await this.getMatchData(matchId);
+      if (!matchData) {
+        throw new Error('Match not found');
+      }
+      
+      // Build instruction data
+      const matchIdNum = typeof matchId === 'string' ? this.uuidToU64(matchId) : BigInt(matchId);
+      const matchIdBuf = Buffer.alloc(8);
+      matchIdBuf.writeBigUInt64LE(matchIdNum);
+      
+      const instructionData = Buffer.concat([
+        DISCRIMINATORS.RESOLVE_MATCH,
+        matchIdBuf,
+      ]);
+      
+      // Build accounts - need to include operator and opponent in remaining_accounts
+      const instruction = new TransactionInstruction({
+        programId: this.programId,
+        keys: [
+          { pubkey: matchPDA, isSigner: false, isWritable: true },
+          { pubkey: caller.publicKey, isSigner: true, isWritable: true },
+          // Remaining accounts (operator + opponent)
+          { pubkey: this.operatorWallet, isSigner: false, isWritable: true },
+          // Note: You'll need to fetch opponent pubkey from match data
+          // { pubkey: opponentPubkey, isSigner: false, isWritable: true },
+        ],
+        data: instructionData,
+      });
+      
+      const transaction = new Transaction().add(instruction);
+      const signature = await this.connection.sendTransaction(transaction, [caller]);
+      await this.connection.confirmTransaction(signature);
+      
+      console.log(`✅ Match resolved: ${matchId}`);
+      console.log(`   Signature: ${signature}`);
+      
+      return {
+        success: true,
+        matchId,
+        signature,
+      };
+    } catch (error) {
+      console.error('Error resolving match:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Cancel a match (if no opponent joined)
+   */
+  async cancelMatch(params) {
+    const { matchId, creatorName } = params;
+
+    try {
+      const creator = this.getWallet(creatorName);
+      const [matchPDA] = this.getMatchPDA(matchId);
+      
+      // Build instruction data
+      const matchIdNum = typeof matchId === 'string' ? this.uuidToU64(matchId) : BigInt(matchId);
+      const matchIdBuf = Buffer.alloc(8);
+      matchIdBuf.writeBigUInt64LE(matchIdNum);
+      
+      const instructionData = Buffer.concat([
+        DISCRIMINATORS.CANCEL_MATCH,
+        matchIdBuf,
+      ]);
+      
+      const instruction = new TransactionInstruction({
+        programId: this.programId,
+        keys: [
+          { pubkey: matchPDA, isSigner: false, isWritable: true },
+          { pubkey: creator.publicKey, isSigner: true, isWritable: true },
+        ],
+        data: instructionData,
+      });
+      
+      const transaction = new Transaction().add(instruction);
+      const signature = await this.connection.sendTransaction(transaction, [creator]);
+      await this.connection.confirmTransaction(signature);
+      
+      console.log(`✅ Match cancelled: ${matchId}`);
+      console.log(`   Signature: ${signature}`);
+      
+      return {
+        success: true,
+        matchId,
+        signature,
+      };
+    } catch (error) {
+      console.error('Error cancelling match:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Airdrop SOL to a wallet (for testing)
+   */
+  async airdrop(playerName, amount = 1) {
+    try {
+      const wallet = this.getWallet(playerName);
+      const signature = await this.connection.requestAirdrop(
+        wallet.publicKey,
+        amount * 1_000_000_000
+      );
+      await this.connection.confirmTransaction(signature);
+      
+      console.log(`✅ Airdropped ${amount} SOL to ${playerName}`);
+      return {
+        success: true,
+        player: playerName,
+        pubkey: wallet.publicKey.toString(),
+        amount,
+        signature,
+      };
+    } catch (error) {
+      console.error('Error airdropping:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get wallet balance
+   */
+  async getBalance(playerName) {
+    try {
+      const wallet = this.getWallet(playerName);
+      const balance = await this.connection.getBalance(wallet.publicKey);
+      
+      return {
+        player: playerName,
+        pubkey: wallet.publicKey.toString(),
+        balance: balance / 1_000_000_000,
+        lamports: balance,
+      };
+    } catch (error) {
+      console.error('Error getting balance:', error);
+      throw error;
+    }
+  }
+}
+
+module.exports = ArcadeMatchService;
+