Adventure Layer Slither

import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
import { isHex, Hex } from "viem";

export const BurnerCacheKey = 'mud:burnerWallet';

function assertPrivateKey(privateKey: string, cacheKey: string): asserts privateKey is Hex {
  if (!isHex(privateKey)) {
    console.error("Private key found in cache is not valid hex", { privateKey, cacheKey });
    throw new Error(`Private key found in cache (${cacheKey}) is not valid hex`);
  }
  // Ensure the address can be extracted from the private key
  privateKeyToAccount(privateKey);
}

export function setBurnerPrivateKey(privateKey: string, cacheKey = "mud:burnerWallet"): Hex {
  localStorage.setItem(cacheKey, privateKey);
  
  if (privateKey === null) {
    console.error("Private key found in cache is not valid hex", { privateKey, cacheKey });
    throw new Error(`Private key found in cache (${cacheKey}) is not valid hex`);
  }

  assertPrivateKey(privateKey, cacheKey);
  console.log("Old burner wallet updated:", privateKeyToAccount(privateKey));
  
  return privateKey;
}

tables: {
  Users: {
    schema: {
      player: "address",
      gameCode: "uint32",
      score: "uint32",
      username: "string",
    },
    key: ["player"],
  },
  GameCodeToGameState: {
    schema: {
      gameCode: "uint32",
      players: "address[]",
    },
    key: ["gameCode"],
  },
  UserToOthersPositions: {
    schema: {
      gameCode: "uint32",
      snakes: "bytes32[]",
    },
    key: ["gameCode"]
  },
  UserToOwnPositions: {
    schema: {
      player: "address",
      snake: "bytes32[]",
    },
    key: ["player"],
  },
  UserToSnakeDeque: {
    schema: {
      player: "address",
      snakeBody: "bytes32[]",
    },
    key: ["player"],
  },
  Balance: {
    schema: {
      player: "address",
      value: "uint256",
    },
    key: ["player"],
  },
  UserAccountMapping: {
    schema: {
      player: "address",
      account: "string",
    },
    key: ["player"],
  },
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.24;

/* Autogenerated file. Do not edit manually. */

import { IBaseWorld } from "@latticexyz/world/src/codegen/interfaces/IBaseWorld.sol";
import { IBalanceSystem } from "./IBalanceSystem.sol";
import { IGameStateSystem } from "./IGameStateSystem.sol";
import { IUserAccountSystem } from "./IUserAccountSystem.sol";
import { IUsersSystem } from "./IUsersSystem.sol";

/**
 * @title IWorld
 * @author MUD (https://mud.dev) by Lattice (https://lattice.xyz)
 * @notice This interface integrates all systems and associated function selectors
 * that are dynamically registered in the World during deployment.
 * @dev This is an autogenerated file; do not edit manually.
 */
interface IWorld is IBaseWorld, IBalanceSystem, IGameStateSystem, IUserAccountSystem, IUsersSystem {}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import { System } from "@latticexyz/world/src/System.sol";
import { Balance } from "../codegen/index.sol";

contract BalanceSystem is System {
    address public owner;
    uint256 public gameFee = 0.01 ether; // Define game fee

    event GameStartedRecharge(address indexed player);
    event GamePlayedDeduct(address indexed player);

    constructor() {
        owner = msg.sender;
    }

    // Player pays and starts game
    function startGame() public payable {
        require(msg.value >= gameFee, "Insufficient funds to start the game");
        payable(owner).transfer(gameFee);
        rechargeBalance(msg.sender, gameFee);
        emit GameStartedRecharge(msg.sender);
    }

    // Query contract balance
    function getContractBalance() public view returns (uint256) {
        return address(this).balance;
    }

    // Query player contract balance
    function getPlayerBalance(address player) public view returns (uint256) {
        return Balance.get(player);
    }

    // Query current sender balance
    function getCurrentBalance() public view returns (uint256) {
        return Balance.get(msg.sender);
    }

    // Set game fee
    function setGameFee(uint256 newFee) public {
        require(msg.sender == owner, "Only owner can set game fee");
        gameFee = newFee;
    }

    // Deduct balance
    function deductBalance(address player, uint256 amount) public {
        uint256 currentBalance = Balance.get(player);
        require(currentBalance >= amount, "Insufficient balance");
        Balance.set(player, currentBalance - amount);
    }

    // Recharge balance
    function rechargeBalance(address player, uint256 amount) public {
        uint256 currentBalance = Balance.get(player);
        Balance.set(player, currentBalance + amount);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.24;

import { Users, UsersData, GameCodeToGameState } from "../codegen/index.sol";
import { System } from "@latticexyz/world/src/System.sol";

contract UsersSystem is System {
    function getData() public view returns (UsersData memory) {
        return Users.get(msg.sender);
    }

    function startGame(string memory name) public {
        uint32 gameCode = uint32(generateRandom() % 10000);
        Users.setGameCode(msg.sender, gameCode);
        Users.setUsername(msg.sender, name);
        addUser(gameCode);
    }

    function addUser(uint32 gameCode) public {
        if (gameStateExistsAndRemove(gameCode, false)) {
            GameCodeToGameState.pushPlayers(gameCode, msg.sender);
        }
    }

    function gameStateExistsAndRemove(uint32 gameCode, bool remove) public returns (bool) {
        address[] memory players = GameCodeToGameState.getPlayers(gameCode);
        for (uint256 i = 0; i < players.length; i++) {
            if (players[i] == msg.sender) {
                if (remove) {
                    GameCodeToGameState.updatePlayers(gameCode, uint256(i), GameCodeToGameState.getItemPlayers(gameCode, 0));
                    GameCodeToGameState.popPlayers(gameCode);
                }
                return false;
            }
        }
        return true;
    }

    function generateRandom() public view returns (uint256) {
        return uint256(keccak256(abi.encodePacked(block.timestamp, block.prevrandao, msg.sender)));
    }
}