kill-switch-mcp 1.0.1 → 1.1.2

package/src/wallet/index.ts

@@ -0,0 +1,369 @@
+/**
+ * Kill Switch Game Wallet
+ *
+ * Manages a local access key for interacting with tournament contracts.
+ * The access key is a scoped sub-key of the player's Tempo passkey account.
+ *
+ * Flow:
+ *   1. Player creates Tempo account via `tempo wallet login`
+ *   2. setup_game_wallet generates a local keypair and guides the player
+ *      through authorizing it as an access key on their Tempo account
+ *   3. The access key is stored locally in ~/.killswitch/
+ *   4. join_tournament uses the access key to sign approve + deposit txs
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import {
+  createPublicClient,
+  createWalletClient,
+  http,
+  parseUnits,
+  formatUnits,
+  defineChain,
+  encodeFunctionData,
+  stringToHex,
+  pad,
+  type Hex,
+} from 'viem';
+import { privateKeyToAccount, generatePrivateKey } from 'viem/accounts';
+
+// ── Config ──
+
+const WALLET_DIR = join(homedir(), '.killswitch');
+const WALLET_FILE = join(WALLET_DIR, 'access-key.json');
+
+// Tempo chain config — defaults to testnet, override via env
+const TEMPO_RPC = process.env.TEMPO_RPC_URL || 'https://rpc.moderato.tempo.xyz';
+const TEMPO_CHAIN_ID = parseInt(process.env.TEMPO_CHAIN_ID || '42431');
+
+const tempoChain = defineChain({
+  id: TEMPO_CHAIN_ID,
+  name: TEMPO_CHAIN_ID === 4217 ? 'Tempo' : 'Tempo Testnet',
+  nativeCurrency: { name: 'USD', symbol: 'USD', decimals: 18 },
+  rpcUrls: {
+    default: { http: [TEMPO_RPC] },
+  },
+});
+
+// USDC on Tempo testnet (pathUSD)
+const USDC_ADDRESS = (process.env.USDC_ADDRESS || '0x20c0000000000000000000000000000000000000') as Hex;
+
+// Factory address — set after deployment
+const FACTORY_ADDRESS = process.env.FACTORY_ADDRESS as Hex | undefined;
+
+// Game server URL for API calls
+const SERVER_URL = (() => {
+  const idx = process.argv.indexOf('--server');
+  if (idx !== -1 && process.argv[idx + 1]) return process.argv[idx + 1];
+  return process.env.KILL_SWITCH_SERVER || 'localhost';
+})();
+
+function getWebBase(): string {
+  const isLocal = SERVER_URL === 'localhost' || SERVER_URL === '127.0.0.1';
+  return isLocal ? 'http://localhost:8888' : `https://${SERVER_URL}`;
+}
+
+// ── ABIs (minimal, just what we need) ──
+
+const ERC20_ABI = [
+  {
+    name: 'approve',
+    type: 'function',
+    inputs: [
+      { name: 'spender', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+    ],
+    outputs: [{ name: '', type: 'bool' }],
+    stateMutability: 'nonpayable',
+  },
+  {
+    name: 'balanceOf',
+    type: 'function',
+    inputs: [{ name: 'account', type: 'address' }],
+    outputs: [{ name: '', type: 'uint256' }],
+    stateMutability: 'view',
+  },
+  {
+    name: 'decimals',
+    type: 'function',
+    inputs: [],
+    outputs: [{ name: '', type: 'uint8' }],
+    stateMutability: 'view',
+  },
+] as const;
+
+const TOURNAMENT_ABI = [
+  {
+    name: 'deposit',
+    type: 'function',
+    inputs: [{ name: 'username', type: 'bytes32' }],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+  {
+    name: 'buyIn',
+    type: 'function',
+    inputs: [],
+    outputs: [{ name: '', type: 'uint256' }],
+    stateMutability: 'view',
+  },
+  {
+    name: 'state',
+    type: 'function',
+    inputs: [],
+    outputs: [{ name: '', type: 'uint8' }],
+    stateMutability: 'view',
+  },
+  {
+    name: 'getDepositorCount',
+    type: 'function',
+    inputs: [],
+    outputs: [{ name: '', type: 'uint256' }],
+    stateMutability: 'view',
+  },
+  {
+    name: 'maxPlayers',
+    type: 'function',
+    inputs: [],
+    outputs: [{ name: '', type: 'uint8' }],
+    stateMutability: 'view',
+  },
+  {
+    name: 'startTime',
+    type: 'function',
+    inputs: [],
+    outputs: [{ name: '', type: 'uint256' }],
+    stateMutability: 'view',
+  },
+  {
+    name: 'hasDeposited',
+    type: 'function',
+    inputs: [{ name: '', type: 'address' }],
+    outputs: [{ name: '', type: 'bool' }],
+    stateMutability: 'view',
+  },
+] as const;
+
+// ── Wallet Storage ──
+
+interface StoredWallet {
+  accessKeyPrivate: string;  // hex private key
+  accountAddress: string;    // the player's Tempo account address
+  createdAt: string;
+}
+
+function loadWallet(): StoredWallet | null {
+  try {
+    if (existsSync(WALLET_FILE)) {
+      return JSON.parse(readFileSync(WALLET_FILE, 'utf-8'));
+    }
+  } catch (e) {
+    console.error('[Wallet] Failed to load wallet:', e);
+  }
+  return null;
+}
+
+function saveWallet(wallet: StoredWallet): void {
+  mkdirSync(WALLET_DIR, { recursive: true });
+  writeFileSync(WALLET_FILE, JSON.stringify(wallet, null, 2), { mode: 0o600 });
+}
+
+// ── Client Factories ──
+
+function getPublicClient() {
+  return createPublicClient({
+    chain: tempoChain,
+    transport: http(),
+  });
+}
+
+function getWalletClient(privateKey: Hex) {
+  const account = privateKeyToAccount(privateKey);
+  return createWalletClient({
+    account,
+    chain: tempoChain,
+    transport: http(),
+  });
+}
+
+// ── Public API (used by MCP tools) ──
+
+/**
+ * Check if a game wallet exists locally.
+ */
+export function hasGameWallet(): boolean {
+  return existsSync(WALLET_FILE);
+}
+
+/**
+ * Get wallet info — address and USDC balance.
+ */
+export async function getWalletInfo(): Promise<{
+  address: string;
+  balance: string;
+  balanceRaw: bigint;
+}> {
+  const wallet = loadWallet();
+  if (!wallet) {
+    throw new Error('No game wallet found. Run setup_game_wallet first.');
+  }
+
+  const pub = getPublicClient();
+
+  const balanceRaw = await pub.readContract({
+    address: USDC_ADDRESS,
+    abi: ERC20_ABI,
+    functionName: 'balanceOf',
+    args: [wallet.accountAddress as Hex],
+  });
+
+  const balance = formatUnits(balanceRaw, 6);
+
+  return {
+    address: wallet.accountAddress,
+    balance,
+    balanceRaw,
+  };
+}
+
+/**
+ * Generate a new access key and return setup instructions.
+ * Does NOT authorize it — the player must do that with their passkey.
+ */
+export function generateAccessKey(): {
+  accessKeyAddress: string;
+  privateKey: string;
+  instructions: string;
+} {
+  const privateKey = generatePrivateKey();
+  const account = privateKeyToAccount(privateKey);
+
+  const instructions = [
+    'A new game access key has been generated.',
+    '',
+    `Access Key Address: ${account.address}`,
+    '',
+    'To authorize this key on your Tempo account, you need to call the',
+    'Account Keychain precompile. This requires your passkey (biometric).',
+    '',
+    'You can do this via the Tempo wallet web interface or by running:',
+    '',
+    `  cast send 0xAAAAAAAA00000000000000000000000000000000 \\`,
+    `    "authorizeKey(address,uint8,uint64,bool,(address,uint256)[])" \\`,
+    `    ${account.address} 0 ${Math.floor(Date.now() / 1000) + 90 * 86400} true \\`,
+    `    "[(${USDC_ADDRESS},1000000000)]" \\`,
+    `    --rpc-url ${TEMPO_RPC}`,
+    '',
+    'This authorizes the key to spend up to 1000 USDC on game transactions,',
+    'expiring in 90 days. You can revoke it anytime from your Tempo account.',
+    '',
+    'Learn more about Tempo access keys:',
+    'https://docs.tempo.xyz/protocol/tips/tip-1011',
+  ].join('\n');
+
+  return { accessKeyAddress: account.address, privateKey, instructions };
+}
+
+/**
+ * Save the access key after the player has authorized it.
+ */
+export function saveAccessKey(privateKey: string, accountAddress: string): void {
+  saveWallet({
+    accessKeyPrivate: privateKey,
+    accountAddress,
+    createdAt: new Date().toISOString(),
+  });
+}
+
+/**
+ * Get upcoming paid tournament schedule from the game server.
+ */
+export async function getTournamentSchedule(): Promise<any[]> {
+  const res = await fetch(`${getWebBase()}/api/paid-schedule`);
+  const data = await res.json() as any;
+
+  if (data.error) {
+    throw new Error(data.error);
+  }
+
+  return data.slots || [];
+}
+
+/**
+ * Join a paid tournament by depositing the buy-in.
+ * Signs approve() + deposit() using the local access key.
+ */
+export async function joinTournament(
+  tournamentAddress: string,
+  username: string,
+): Promise<{ txHash: string; amount: string }> {
+  const wallet = loadWallet();
+  if (!wallet) {
+    throw new Error('No game wallet found. Run setup_game_wallet first.');
+  }
+
+  const pub = getPublicClient();
+  const walletClient = getWalletClient(wallet.accessKeyPrivate as Hex);
+
+  // Read buy-in amount from the contract
+  const buyIn = await pub.readContract({
+    address: tournamentAddress as Hex,
+    abi: TOURNAMENT_ABI,
+    functionName: 'buyIn',
+  });
+
+  // Check balance
+  const balance = await pub.readContract({
+    address: USDC_ADDRESS,
+    abi: ERC20_ABI,
+    functionName: 'balanceOf',
+    args: [wallet.accountAddress as Hex],
+  });
+
+  if (balance < buyIn) {
+    const needed = formatUnits(buyIn, 6);
+    const have = formatUnits(balance, 6);
+    throw new Error(`Insufficient balance. Need $${needed} USDC, have $${have}.`);
+  }
+
+  // Check if already deposited
+  const alreadyDeposited = await pub.readContract({
+    address: tournamentAddress as Hex,
+    abi: TOURNAMENT_ABI,
+    functionName: 'hasDeposited',
+    args: [wallet.accountAddress as Hex],
+  });
+
+  if (alreadyDeposited) {
+    throw new Error('You have already deposited in this tournament.');
+  }
+
+  // Step 1: Approve USDC spend
+  const approveHash = await walletClient.writeContract({
+    address: USDC_ADDRESS,
+    abi: ERC20_ABI,
+    functionName: 'approve',
+    args: [tournamentAddress as Hex, buyIn],
+  });
+
+  await pub.waitForTransactionReceipt({ hash: approveHash });
+
+  // Step 2: Deposit with username
+  const usernameBytes = pad(stringToHex(username), { size: 32 });
+
+  const depositHash = await walletClient.writeContract({
+    address: tournamentAddress as Hex,
+    abi: TOURNAMENT_ABI,
+    functionName: 'deposit',
+    args: [usernameBytes],
+  });
+
+  await pub.waitForTransactionReceipt({ hash: depositHash });
+
+  return {
+    txHash: depositHash,
+    amount: formatUnits(buyIn, 6),
+  };
+}