@peeramid-labs/sdk 3.7.3 → 3.8.0

package/cli/rankify/GameMaster.js

@@ -0,0 +1,1066 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GameMaster = void 0;
+const viem_1 = require("viem");
+const abis_1 = require("../abis");
+const InstanceBase_1 = __importDefault(require("./InstanceBase"));
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+const accounts_1 = require("viem/accounts");
+const log_1 = require("../utils/log");
+const circomlibjs_1 = require("circomlibjs");
+const aes_1 = __importDefault(require("crypto-js/aes"));
+const crypto_js_1 = __importDefault(require("crypto-js"));
+const zkit_1 = require("@solarity/zkit");
+const path_1 = __importDefault(require("path"));
+const permutations_1 = require("../utils/permutations");
+/**
+ * GameMaster class for managing game state and cryptographic operations in Rankify
+ * Extends InstanceBase to provide game master specific functionality
+ * @public
+ */
+class GameMaster {
+    /**
+     * Creates a new GameMaster instance
+  
+     * @param walletClient - Viem wallet client for transactions
+     * @param publicClient - Viem public client for reading state
+     * @param chainId - Chain ID of the network
+     */
+    constructor({ walletClient, chainId, publicClient, }) {
+        this.maxSlotSizeForProofs = 15;
+        /**
+         * Decrypts a proposal for a specific game turn
+         * @param proposal - The encrypted proposal
+         * @param turn - The turn number
+         * @param instanceAddress - The address of the instance
+         * @param gameId - The ID of the game
+         * @param proposer - The address of the proposer
+         * @returns The decrypted proposal
+         */
+        this.decryptProposal = async ({ proposal, turn, instanceAddress, gameId, proposer, instance, }) => {
+            const _instance = instance ?? new InstanceBase_1.default({ instanceAddress, publicClient: this.publicClient, chainId: this.chainId });
+            const proposerPubKey = await _instance.getPlayerPubKey({
+                instanceAddress,
+                gameId,
+                player: proposer,
+            });
+            const sharedKey = _instance.sharedSigner({
+                publicKey: proposerPubKey,
+                privateKey: await this.gameKey({ gameId, contractAddress: instanceAddress }),
+                gameId,
+                turn,
+                contractAddress: instanceAddress,
+                chainId: this.chainId,
+            });
+            (0, log_1.logger)(`Decrypting proposal ${proposal} with shared key (hashed value: ${(0, viem_1.keccak256)(sharedKey)})`);
+            const decryptedProposal = aes_1.default.decrypt(proposal, sharedKey).toString(crypto_js_1.default.enc.Utf8);
+            (0, log_1.logger)(`Decrypted proposal ${decryptedProposal}`);
+            return decryptedProposal;
+        };
+        /**
+         * Decrypts proposals for a specific game turn
+         * @param gameId - ID of the game
+         * @param turn - Turn number
+         * @param proposer - Optional proposer address to filter proposals
+         * @returns Array of decrypted proposals with proposer addresses
+         */
+        this.decryptProposals = async ({ instanceAddress, gameId, turn, players, padToMaxSize = false, permute = false, }) => {
+            (0, log_1.logger)(`Getting proposals for instance ${instanceAddress}, game ${gameId}, turn ${turn.toString()}`);
+            const ProposalSubmittedEvents = await this.publicClient.getContractEvents({
+                abi: abis_1.RankifyDiamondInstanceAbi,
+                address: instanceAddress,
+                eventName: "ProposalSubmitted",
+                args: { gameId: gameId, turn: turn },
+                fromBlock: 0n,
+            });
+            (0, log_1.logger)(`Found ${ProposalSubmittedEvents.length} proposals`);
+            const instance = new InstanceBase_1.default({ instanceAddress, publicClient: this.publicClient, chainId: this.chainId });
+            (0, log_1.logger)(`Decrypting ${ProposalSubmittedEvents.length} proposals`);
+            const proposalsForPlayers = await Promise.all((players)?.map(async (player) => {
+                const log = ProposalSubmittedEvents.find((log) => log.args.proposer === player);
+                if (!log) {
+                    return {
+                        proposer: player,
+                        proposal: "",
+                    };
+                }
+                else {
+                    (0, log_1.logger)(`Decrypting proposal ${log.args.proposer}`);
+                    if (!log.args.proposer)
+                        throw new Error("No proposer");
+                    if (!log.args.encryptedProposal)
+                        throw new Error("No proposalEncryptedByGM");
+                    return {
+                        proposer: log.args.proposer,
+                        proposal: await this.decryptProposal({
+                            proposal: log.args.encryptedProposal,
+                            turn: turn,
+                            instanceAddress: instanceAddress,
+                            gameId: gameId,
+                            proposer: log.args.proposer,
+                            instance,
+                        }),
+                    };
+                }
+            }));
+            if (permute) {
+                const proposalsPermuted = await this.permuteArray({ array: proposalsForPlayers, gameId, turn, verifierAddress: instanceAddress });
+                return padToMaxSize ? this.padProposalsArrayWithZeroAddress(proposalsPermuted) : proposalsPermuted;
+            }
+            return padToMaxSize ? this.padProposalsArrayWithZeroAddress(proposalsForPlayers) : proposalsForPlayers;
+        };
+        /**
+         * Generates a deterministic permutation for a specific game turn
+         * @param gameId - ID of the game
+         * @param turn - Turn number
+         * @param size - Size of the permutation
+         * @param verifierAddress - Address of the verifier
+         * @returns The generated permutation, secret, and commitment
+         */
+        this.getPermutation = async ({ gameId, turn, size, verifierAddress, }) => {
+            const turnSalt = await this.getTurnSalt({ gameId, turn, verifierAddress });
+            // Create deterministic seed from game parameters and GM's signature
+            // Use the seed to generate permutation
+            const permutation = Array.from({ length: this.maxSlotSizeForProofs }, (_, i) => i);
+            // Fisher-Yates shuffle with deterministic randomness
+            for (let i = size - 1; i >= 0; i--) {
+                // Generate deterministic random number for this position
+                const randHash = (0, viem_1.keccak256)((0, viem_1.encodePacked)(["uint256", "uint256"], [turnSalt, BigInt(i)]));
+                const rand = BigInt(randHash);
+                const j = Number(rand % BigInt(i + 1));
+                // Swap elements
+                [permutation[i], permutation[j]] = [permutation[j], permutation[i]];
+            }
+            // Ensure inactive slots map to themselves
+            for (let i = size; i < this.maxSlotSizeForProofs; i++) {
+                permutation[i] = i;
+            }
+            return { permutation, turnSalt };
+        };
+        /**
+         * Generates a deterministic permutation for a specific game turn
+         * @param gameId - ID of the game
+         * @param turn - Turn number
+         * @param size - Size of the permutation
+         * @param verifierAddress - Address of the verifier
+         * @returns The generated permutation, secret, and commitment
+         */
+        this.generateDeterministicPermutation = async ({ gameId, turn, size = 15, verifierAddress, }) => {
+            // This is kept secret to generate witness
+            // Create deterministic seed from game parameters and GM's signature
+            const { permutation, turnSalt } = await this.getPermutation({ gameId, turn, size, verifierAddress });
+            // Generate commitment
+            const poseidon = await (0, circomlibjs_1.buildPoseidon)();
+            const PoseidonFirst = BigInt(poseidon.F.toObject(poseidon([permutation[0], permutation[1], permutation[2], permutation[3], permutation[4]])));
+            const PoseidonSecond = BigInt(poseidon.F.toObject(poseidon([PoseidonFirst, permutation[5], permutation[6], permutation[7], permutation[8], permutation[9]])));
+            const PoseidonThird = BigInt(poseidon.F.toObject(poseidon([PoseidonSecond, permutation[10], permutation[11], permutation[12], permutation[13], permutation[14]])));
+            const commitment = BigInt(poseidon.F.toObject(poseidon([PoseidonThird, turnSalt])));
+            return {
+                permutation,
+                turnSalt,
+                commitment,
+            };
+        };
+        /**
+         * Permutes an array based on a deterministic permutation
+         * @param array - Array to permute
+         * @param gameId - ID of the game
+         * @param turn - Turn number
+         * @param verifierAddress - Address of the verifier
+         * @returns The permuted array
+         */
+        this.permuteArray = async ({ array, gameId, turn, verifierAddress, }) => {
+            const { permutation } = await this.getPermutation({ gameId, turn, size: array.length, verifierAddress });
+            return (0, permutations_1.permuteArray)({ array, permutation });
+        };
+        /**
+         * Reverses a permutation of an array
+         * @param permutedArray - Array to reverse
+         * @param gameId - ID of the game
+         * @param turn - Turn number
+         * @param verifierAddress - Address of the verifier
+         * @returns The original array
+         */
+        this.reversePermutation = async ({ permutedArray, gameId, turn, verifierAddress, }) => {
+            const { permutation } = await this.getPermutation({ gameId, turn, size: permutedArray.length, verifierAddress });
+            return (0, permutations_1.reversePermutation)({ array: permutedArray, permutation });
+        };
+        /**
+         * Generates a salt for a specific game turn
+         * @param gameId - ID of the game
+         * @param turn - Turn number
+         * @param verifierAddress - Address of the verifier
+         * @returns Generated salt as Hex
+         */
+        this.getTurnSalt = async ({ gameId, turn, verifierAddress, }) => {
+            const gameKey = await this.gameKey({ gameId, contractAddress: verifierAddress });
+            const instance = new InstanceBase_1.default({
+                instanceAddress: verifierAddress,
+                publicClient: this.publicClient,
+                chainId: this.chainId,
+            });
+            const seed = instance.pkdf({
+                privateKey: gameKey,
+                turn,
+                gameId,
+                contractAddress: verifierAddress,
+                chainId: this.chainId,
+                scope: "turnSalt",
+            });
+            return BigInt(seed);
+        };
+        /**
+         * Generates a salt for a specific player in a game turn
+         * @param gameId - ID of the game
+         * @param turn - Turn number
+         * @param player - Address of the player
+         * @param verifierAddress - Address of the verifier
+         * @param size - Size of the permutation
+         * @returns Generated salt as Hex
+         */
+        this.getTurnPlayersSalt = async ({ gameId, turn, player, verifierAddress, size, }) => {
+            (0, log_1.logger)(`Generating vote salt for player ${player} in game ${gameId}, turn ${turn}`);
+            const result = await this.generateDeterministicPermutation({
+                gameId,
+                turn: turn - 1n,
+                verifierAddress,
+                size,
+            }).then((perm) => {
+                return (0, viem_1.keccak256)((0, viem_1.encodePacked)(["address", "uint256"], [player, perm.turnSalt]));
+            });
+            (0, log_1.logger)(`Generated vote salt for player ${player}`);
+            return result;
+        };
+        /**
+         * Finds the index of a player's ongoing proposal
+         * @param gameId - ID of the game
+         * @param player - Address of the player
+         * @returns Index of the player's proposal, -1 if not found
+         */
+        this.findPlayerOngoingProposalIndex = async ({ instanceAddress, gameId, player, turn, }) => {
+            if (!turn) {
+                turn = await this.currentTurn({ instanceAddress, gameId });
+            }
+            const players = await this.getPlayers({ instanceAddress, gameId });
+            const decryptedProposalsPermuted = await this.decryptProposals({ instanceAddress, gameId, turn: turn - 1n, players: [...players], permute: true });
+            return decryptedProposalsPermuted.findIndex((p) => p?.proposer === player);
+        };
+        this.validateJoinGame = async (props) => {
+            const { gameId, participant, instanceAddress } = props;
+            try {
+                const gameState = await this.getGameState({ gameId, instanceAddress });
+                if (gameState.gamePhase !== types_1.gameStatusEnum.open) {
+                    return { result: false, errorMessage: "Game is not open for registration" };
+                }
+                if (gameState.players.length === Number(gameState.maxPlayerCnt)) {
+                    return { result: false, errorMessage: "Game is already full" };
+                }
+                if (gameState.players.indexOf(participant) !== -1) {
+                    return { result: false, errorMessage: "Player already registered" };
+                }
+                return { result: true, errorMessage: "" };
+            }
+            catch (e) {
+                throw await (0, utils_1.handleRPCError)(e);
+            }
+        };
+        /**
+         * Signs a joining game event
+         * @param gameId - ID of the game
+         * @param participant - Address of the participant
+         * @param instanceAddress - Address of the game instance
+         * @returns Signature and gmCommitment
+         */
+        this.signJoiningGame = async (props, timeToJoin = 60 * 10) => {
+            if (!this.walletClient.account)
+                throw new Error("No account");
+            (0, log_1.logger)(`Signing joining game..`);
+            const { gameId, participant, instanceAddress, participantPubKeyHash } = props;
+            const { result: isValid, errorMessage } = await this.validateJoinGame({ gameId, participant, instanceAddress });
+            if (!isValid) {
+                throw new Error(errorMessage);
+            }
+            const baseInstance = new InstanceBase_1.default({ instanceAddress, publicClient: this.publicClient, chainId: this.chainId });
+            const eip712 = await baseInstance.getEIP712Domain();
+            (0, log_1.logger)({
+                gameId: props.gameId,
+                participant: props.participant,
+                instanceAddress: props.instanceAddress,
+                chainId: this.chainId,
+                name: eip712.name,
+                version: eip712.version,
+                gameMaster: this.walletClient.account?.address,
+                participantPubKeyHash,
+            }, 2);
+            const deadline = BigInt(Math.floor(Date.now() / 1000) + timeToJoin);
+            //ToDo This is placeholder for now, we will need it later in staking
+            const gmCommitment = (0, viem_1.stringToHex)("0x123131231311", { size: 32 });
+            console.log({
+                name: eip712.name,
+                version: eip712.version,
+                chainId: this.chainId,
+                verifyingContract: instanceAddress,
+            }, {
+                participant,
+                gameId,
+                gmCommitment,
+                deadline,
+                participantPubKeyHash,
+            });
+            const signature = await this.walletClient.signTypedData({
+                domain: {
+                    name: eip712.name,
+                    version: eip712.version,
+                    chainId: this.chainId,
+                    verifyingContract: instanceAddress,
+                },
+                types: {
+                    AttestJoiningGame: [
+                        { type: "address", name: "participant" },
+                        { type: "uint256", name: "gameId" },
+                        { type: "bytes32", name: "gmCommitment" },
+                        { type: "uint256", name: "deadline" },
+                        { type: "bytes32", name: "participantPubKeyHash" },
+                    ],
+                },
+                message: {
+                    participant,
+                    gameId,
+                    gmCommitment,
+                    deadline,
+                    participantPubKeyHash,
+                },
+                primaryType: "AttestJoiningGame",
+                account: this.walletClient.account,
+            });
+            return { signature, gmCommitment, deadline };
+        };
+        /**
+         * Submits a vote for proposals
+         * @param gameId - ID of the game
+         * @param vote - Array of vote values
+         * @param voter - Address of the voter
+         * @returns Transaction hash
+         */
+        this.submitVote = async ({ instanceAddress, gameId, vote, voter, voterSignature, ballotHash, ballotId, }) => {
+            const players = await this.getPlayers({ instanceAddress, gameId });
+            const turn = await this.currentTurn({ instanceAddress, gameId });
+            const validationResult = await this.validateVote({ gameId, turn, voter, vote, instanceAddress, players: [...players] });
+            if (!validationResult.result) {
+                throw new Error('Vote validation failed: ' + validationResult.reason);
+            }
+            try {
+                const { request } = await this.publicClient.simulateContract({
+                    account: this.walletClient.account,
+                    address: instanceAddress,
+                    abi: abis_1.RankifyDiamondInstanceAbi,
+                    functionName: "submitVote",
+                    args: [gameId, ballotId, voter, viem_1.zeroHash, voterSignature, ballotHash],
+                });
+                return this.walletClient.writeContract(request);
+            }
+            catch (e) {
+                throw await (0, utils_1.handleRPCError)(e);
+            }
+        };
+        /**
+         * Gets the current turn progress in percent value
+         * @param instanceAddress - Address of the instance
+         * @param gameState - Current game state
+         * @param gameId - ID of the game
+         * @returns Current turn progress
+         */
+        this.getTurnProgress = async ({ instanceAddress, gameState, gameId }) => {
+            const prevTurnProposals = await this.decryptProposals({ instanceAddress, gameId, turn: gameState.currentTurn - 1n, players: [...gameState.players] });
+            const proposalCountInPrevTurn = prevTurnProposals.filter(p => p.proposal !== "").length;
+            const proposalsMadeInCurrentTurn = await this.decryptProposals({ instanceAddress, gameId, turn: gameState.currentTurn, players: [...gameState.players] });
+            const proposalCountInCurrentTurn = proposalsMadeInCurrentTurn.filter(p => p.proposal !== "").length;
+            if (proposalCountInPrevTurn === 0) {
+                return (proposalCountInCurrentTurn / gameState.players.length) * 100;
+            }
+            else {
+                const votesMadeInCurrentTurn = await this.decryptTurnVotes({ instanceAddress, gameId, turn: gameState.currentTurn, players: [...gameState.players] });
+                const votesCount = votesMadeInCurrentTurn.filter(v => this.hasVoted({ vote: v })).length;
+                return ((votesCount + proposalCountInCurrentTurn) / (gameState.players.length * 2)) * 100;
+            }
+        };
+        this.validateVote = async ({ gameId, turn, voter, vote, instanceAddress, players }) => {
+            const decryptedProposals = await this.decryptProposals({ instanceAddress, gameId, turn: turn - 1n, players, permute: true });
+            //Invalid vote length
+            if (vote.length !== decryptedProposals.length) {
+                return { result: false, reason: "Invalid vote length" };
+            }
+            // Check if points used are correct (Quadratic voting system)
+            let pointsUsed = 0n;
+            for (let i = 0; i < vote.length; i++) {
+                if (vote[i] > 0n) {
+                    pointsUsed += 1n ** vote[i];
+                }
+            }
+            const gameState = await this.getGameState({ gameId, instanceAddress });
+            if (pointsUsed > gameState.voteCredits) {
+                return { result: false, reason: "Too many points used" };
+            }
+            if (pointsUsed < gameState.voteCredits) {
+                return { result: false, reason: "Not all points used" };
+            }
+            // Check if voter voted for a non-proposed player or their own proposal
+            for (let i = 0; i < vote.length; i++) {
+                if (vote[i] === 0n)
+                    continue;
+                if (decryptedProposals[i].proposal === "" || decryptedProposals[i].proposer === viem_1.zeroAddress) {
+                    return { result: false, reason: "Vote for non existing proposal" };
+                }
+                if (decryptedProposals[i].proposer === voter) {
+                    return { result: false, reason: "Voter cannot vote for their own proposal" };
+                }
+            }
+            // Valid vote
+            return { result: true, reason: "" };
+        };
+        this.padProposalsArrayWithZeroAddress = (proposals) => {
+            if (proposals.length < this.maxSlotSizeForProofs) {
+                for (let i = proposals.length; i < this.maxSlotSizeForProofs; i++) {
+                    proposals.push({
+                        proposer: viem_1.zeroAddress,
+                        proposal: "",
+                    });
+                }
+            }
+            return proposals;
+        };
+        /**
+         * Types for proposal submission
+         */
+        this.proposalTypes = {
+            SubmitProposal: [
+                { type: "uint256", name: "gameId" },
+                { type: "address", name: "proposer" },
+                { type: "string", name: "encryptedProposal" },
+                { type: "uint256", name: "commitment" },
+            ],
+        };
+        this.signProposal = async ({ verifierAddress, proposer, gameId, encryptedProposal, commitment, eip712, }) => {
+            // Generate typed data hash matching Solidity's keccak256(abi.encode(...))
+            if (!this.walletClient.account)
+                throw new Error("No account");
+            return this.walletClient.signTypedData({
+                domain: {
+                    name: eip712.name,
+                    version: eip712.version,
+                    chainId: this.chainId,
+                    verifyingContract: verifierAddress,
+                },
+                types: this.proposalTypes,
+                message: {
+                    gameId,
+                    proposer,
+                    encryptedProposal,
+                    commitment,
+                },
+                primaryType: "SubmitProposal",
+                account: this.walletClient.account,
+            });
+        };
+        this.proposalValues = async ({ instanceAddress, gameId, proposal, proposer, turn, }) => {
+            const instance = new InstanceBase_1.default({ instanceAddress, publicClient: this.publicClient, chainId: this.chainId });
+            const proposerPubKey = await instance.getPlayerPubKey({
+                instanceAddress,
+                gameId,
+                player: proposer,
+            });
+            const sharedKey = instance.sharedSigner({
+                publicKey: proposerPubKey,
+                privateKey: await this.gameKey({ gameId, contractAddress: instanceAddress }),
+                gameId,
+                turn,
+                contractAddress: instanceAddress,
+                chainId: this.chainId,
+            });
+            // const poseidon = await buildPoseidon();
+            const proposalValue = BigInt((0, viem_1.keccak256)((0, viem_1.encodePacked)(["string"], [proposal])));
+            const randomnessValue = BigInt((0, viem_1.keccak256)((0, viem_1.encodePacked)(["string"], [sharedKey])));
+            // Calculate commitment using poseidon
+            return {
+                proposalValue,
+                randomnessValue,
+                proposal,
+            };
+        };
+        /**
+         * Encrypts a proposal
+         * @param proposal - Proposal to encrypt
+         * @param turn - Turn number
+         * @param instanceAddress - Address of the game instance
+         * @param gameId - ID of the game
+         * @param proposerPubKey - Public key of the proposer
+         * @returns Encrypted proposal and shared key
+         */
+        this.encryptProposal = async ({ proposal, turn, instanceAddress, gameId, proposerPubKey, }) => {
+            const instance = new InstanceBase_1.default({ instanceAddress, publicClient: this.publicClient, chainId: this.chainId });
+            const sharedKey = instance.sharedSigner({
+                publicKey: proposerPubKey,
+                privateKey: await this.gameKey({ gameId, contractAddress: instanceAddress }),
+                gameId,
+                turn,
+                contractAddress: instanceAddress,
+                chainId: this.chainId,
+            });
+            (0, log_1.logger)(`Encrypting proposal ${proposal} with shared key (hashed value: ${(0, viem_1.keccak256)(sharedKey)})`);
+            const encryptedProposal = aes_1.default.encrypt(proposal, sharedKey).toString();
+            (0, log_1.logger)(`Encrypted proposal ${encryptedProposal}`);
+            return { encryptedProposal, sharedKey };
+        };
+        /**
+         * Attests a proposal
+         * @param instanceAddress - Address of the game instance
+         * @param gameId - ID of the game
+         * @param proposal - Proposal to attest
+         * @param proposerPubKey - Public key of the proposer
+         * @param turn - Turn number
+         * @returns The attested proposal
+         */
+        this.attestProposal = async ({ instanceAddress, gameId, proposal, proposerPubKey, turn, }) => {
+            const proposerAddress = (0, accounts_1.publicKeyToAddress)(proposerPubKey);
+            (0, log_1.logger)(`Creating proposal secrets for player ${proposerAddress} in game ${gameId}`);
+            const poseidon = await (0, circomlibjs_1.buildPoseidon)();
+            const instance = new InstanceBase_1.default({ instanceAddress, publicClient: this.publicClient, chainId: this.chainId });
+            const { encryptedProposal, sharedKey } = await this.encryptProposal({
+                proposal,
+                turn,
+                instanceAddress,
+                gameId,
+                proposerPubKey,
+            });
+            const proposalValue = BigInt((0, viem_1.keccak256)((0, viem_1.encodePacked)(["string"], [proposal])));
+            const randomnessValue = BigInt((0, viem_1.keccak256)((0, viem_1.encodePacked)(["string"], [sharedKey])));
+            // Calculate commitment using poseidon
+            const hash = poseidon([proposalValue, randomnessValue]);
+            const poseidonCommitment = BigInt(poseidon.F.toObject(hash));
+            const eip712 = await instance.getEIP712Domain();
+            const signature = await this.signProposal({
+                verifierAddress: instanceAddress,
+                proposer: proposerAddress,
+                gameId,
+                encryptedProposal,
+                commitment: poseidonCommitment,
+                eip712,
+            });
+            const params = {
+                gameId,
+                encryptedProposal,
+                commitment: poseidonCommitment,
+                proposer: proposerAddress,
+                gmSignature: signature,
+            };
+            (0, log_1.logger)(`Generated proposal secrets with commitment ${poseidonCommitment}`);
+            return {
+                submissionParams: params,
+                proposal,
+                proposerAddress,
+                proposalValue,
+                randomnessValue,
+            };
+        };
+        /**
+         * Submits a proposal to the game
+         * @param gameId - ID of the game
+         * @param commitmentHash - Hash of the proposal commitment
+         * @param encryptedProposal - Encrypted proposal data
+         * @param proposer - Address of the proposer
+         * @returns Transaction hash
+         */
+        this.submitProposal = async ({ instanceAddress, submissionParams, proposerSignature, }) => {
+            const txParams = [
+                {
+                    ...submissionParams,
+                    proposerSignature,
+                },
+            ];
+            try {
+                const { request } = await this.publicClient.simulateContract({
+                    account: this.walletClient.account,
+                    address: instanceAddress,
+                    abi: abis_1.RankifyDiamondInstanceAbi,
+                    functionName: "submitProposal",
+                    args: txParams,
+                });
+                return this.walletClient.writeContract(request);
+            }
+            catch (e) {
+                throw await (0, utils_1.handleRPCError)(e);
+            }
+        };
+        /**
+         * Decrypts votes for a specific game turn
+         * @param gameId - ID of the game
+         * @param turn - Turn number
+         * @returns Array of decrypted votes with player addresses
+         */
+        this.decryptTurnVotes = async ({ instanceAddress, gameId, turn, players = [], }) => {
+            (0, log_1.logger)(`Decrypting votes for game ${BigInt(gameId)} turn ${turn} at address ${instanceAddress} at ${await this.publicClient.getBlockNumber()} block`);
+            const VoteSubmittedEvents = await this.publicClient.getContractEvents({
+                address: instanceAddress,
+                abi: abis_1.RankifyDiamondInstanceAbi,
+                eventName: "VoteSubmitted",
+                fromBlock: 0n,
+                args: { turn, gameId },
+            });
+            (0, log_1.logger)(`Found ${VoteSubmittedEvents.length} events`);
+            if (VoteSubmittedEvents.length === 0)
+                return [];
+            //Decrypting votes from events
+            const votes = [];
+            console.log("Events:", VoteSubmittedEvents);
+            for (const event of VoteSubmittedEvents) {
+                console.log("Event:", event);
+                if (!event.args.player)
+                    throw new Error("No player in event");
+                if (!event.args.sealedBallotId)
+                    throw new Error("No sealedBallotId in event");
+                const turnKey = await this.calculateSharedTurnKey({
+                    instanceAddress,
+                    gameId,
+                    turn,
+                    player: event.args.player,
+                });
+                const decryptedVotes = await this.decryptVote(event.args.sealedBallotId, turnKey);
+                votes.push({
+                    player: event.args.player,
+                    votes: decryptedVotes,
+                });
+            }
+            const votesForEachPlayer = await Promise.all(players.map(async (player) => {
+                const vote = votes.find((v) => v.player === player);
+                if (!vote?.votes)
+                    return players.map(() => 0n);
+                return vote.votes;
+            }));
+            return votesForEachPlayer;
+        };
+        /**
+         * Checks if the current turn can be ended
+         * @param gameId - ID of the game
+         * @returns Boolean indicating if turn can be ended
+         */
+        this.canEndTurn = async ({ instanceAddress, gameId }) => {
+            const canEndTurn = await this.publicClient.readContract({
+                address: instanceAddress,
+                abi: abis_1.RankifyDiamondInstanceAbi,
+                functionName: "canEndTurn",
+                args: [gameId],
+            });
+            if (!canEndTurn)
+                return false;
+            //Extra check to not allow to end turn if current phase timeout is not passed and progress is less than 100% (probably must be fixed in contracts!)
+            // TODO: if fixed in contracts, remove this check
+            const gameState = await this.getGameState({ instanceAddress, gameId });
+            const lastBlock = await this.publicClient.getBlock({ blockNumber: BigInt(await this.publicClient.getBlockNumber()) });
+            if (gameState.currentPhaseTimeoutAt > lastBlock.timestamp) {
+                const turnProgress = await this.getTurnProgress({ instanceAddress, gameState, gameId });
+                if (turnProgress <= 100)
+                    return false;
+            }
+            return true;
+        };
+        /**
+         * Gets the current turn number
+         * @param gameId - ID of the game
+         * @returns Current turn number
+         */
+        this.currentTurn = async ({ instanceAddress, gameId }) => {
+            try {
+                return this.publicClient.readContract({
+                    address: instanceAddress,
+                    abi: abis_1.RankifyDiamondInstanceAbi,
+                    functionName: "getTurn",
+                    args: [gameId],
+                });
+            }
+            catch (e) {
+                throw await (0, utils_1.handleRPCError)(e);
+            }
+        };
+        /**
+         * Gets the list of players in the game
+         * @param gameId - ID of the game
+         * @returns Array of player addresses
+         */
+        this.getPlayers = async ({ instanceAddress, gameId }) => {
+            try {
+                return this.publicClient.readContract({
+                    address: instanceAddress,
+                    abi: abis_1.RankifyDiamondInstanceAbi,
+                    functionName: "getPlayers",
+                    args: [gameId],
+                });
+            }
+            catch (e) {
+                throw await (0, utils_1.handleRPCError)(e);
+            }
+        };
+        /**
+         * Ends the current turn and processes votes
+         * @param gameId - ID of the game
+         * @returns Transaction hash
+         */
+        this.endTurn = async ({ instanceAddress, gameId }) => {
+            (0, log_1.logger)(`Ending turn for game ${gameId}`, 2);
+            try {
+                if (!(await this.canEndTurn({ instanceAddress, gameId }))) {
+                    throw new Error("Cannot end turn");
+                }
+                const turn = await this.currentTurn({ instanceAddress, gameId });
+                const players = await this.getPlayers({ instanceAddress, gameId });
+                (0, log_1.logger)(`Current turn: ${turn}, Players count: ${players.length}`, 2);
+                const newPaddedDecryptedProposals = await this.decryptProposals({ instanceAddress, gameId, turn, players: [...players], padToMaxSize: true });
+                (0, log_1.logger)(`newPaddedDecryptedProposals:`);
+                (0, log_1.logger)(newPaddedDecryptedProposals);
+                const votesDecrypted = await this.decryptTurnVotes({ instanceAddress, gameId, turn, players: [...players] });
+                (0, log_1.logger)(`votesDecrypted:`);
+                (0, log_1.logger)(votesDecrypted);
+                const tableData = players.map((player, idx) => ({
+                    player,
+                    voted: this.hasVoted({ vote: votesDecrypted[idx] }),
+                    proposal: newPaddedDecryptedProposals[idx]?.proposal.substring(0, 50) || "not-proposed",
+                }));
+                console.table(tableData);
+                const attested = await this.getProposalsIntegrity({
+                    gameId,
+                    turn,
+                    verifierAddress: instanceAddress,
+                    size: players.length,
+                    proposals: newPaddedDecryptedProposals,
+                });
+                const { request } = await this.publicClient.simulateContract({
+                    abi: abis_1.RankifyDiamondInstanceAbi,
+                    account: this.walletClient.account,
+                    address: instanceAddress,
+                    functionName: "endTurn",
+                    args: [gameId, votesDecrypted, attested.newProposals, attested.prevTurnPermutation, attested.prevTurnSalt],
+                });
+                return this.walletClient.writeContract(request);
+            }
+            catch (e) {
+                throw await (0, utils_1.handleRPCError)(e);
+            }
+        };
+        this.gameKey = async ({ gameId, contractAddress }) => {
+            (0, log_1.logger)(`Signing game key for game ${gameId} at address ${contractAddress}`);
+            const message = (0, viem_1.encodePacked)(["uint256", "address", "string"], [gameId, contractAddress, "gameKey"]);
+            (0, log_1.logger)(`Signing message: ${message}`, 2);
+            if (!this.walletClient.account)
+                throw new Error("No account");
+            const gameKey = await this.walletClient
+                .signMessage({
+                message,
+                account: this.walletClient.account,
+            })
+                .then((sig) => (0, viem_1.keccak256)(sig));
+            (0, log_1.logger)(`Game key: ${gameKey}`, 2);
+            return gameKey;
+        };
+        this.calculateSharedTurnKey = async ({ instanceAddress, gameId, turn, player, }) => {
+            (0, log_1.logger)(`Calculating shared turn key for player ${player} in game ${gameId} at address ${instanceAddress}`);
+            const instance = new InstanceBase_1.default({ instanceAddress, publicClient: this.publicClient, chainId: this.chainId });
+            const playerPubKey = await instance.getPlayerPubKey({ instanceAddress, gameId, player });
+            (0, log_1.logger)(`Player public key: ${playerPubKey}`, 2);
+            console.log("Player public key:", playerPubKey);
+            console.log("Game key:", await this.gameKey({ gameId, contractAddress: instanceAddress }));
+            return instance.sharedSigner({
+                publicKey: playerPubKey,
+                privateKey: await this.gameKey({ gameId, contractAddress: instanceAddress }),
+                gameId,
+                turn,
+                contractAddress: instanceAddress,
+                chainId: this.chainId,
+            });
+        };
+        this.decryptVote = async (vote, privateKey) => {
+            const decrypted = aes_1.default.decrypt(vote, privateKey).toString(crypto_js_1.default.enc.Utf8);
+            if (!decrypted) {
+                throw new Error("Failed to decrypt vote");
+            }
+            try {
+                const parsed = JSON.parse(decrypted);
+                (0, log_1.logger)(`Decrypted vote:`, 2);
+                (0, log_1.logger)(parsed, 2);
+                return parsed.map((v) => BigInt(v));
+                // eslint-disable-next-line
+            }
+            catch (e) {
+                throw new Error("Unexpected token");
+            }
+        };
+        /**
+         * Creates and signs a vote for testing purposes
+         * @param params - Parameters including voter, game info, and vote configuration
+         * @returns A complete mock vote with signatures
+         */
+        this.attestVote = async ({ voter, gameId, turn, vote, verifierAddress, }) => {
+            (0, log_1.logger)(`Attesting vote for player ${voter} in game ${gameId}, turn ${turn}`);
+            const players = await this.getPlayers({ instanceAddress: verifierAddress, gameId });
+            const validationResult = await this.validateVote({ gameId, turn, voter, vote, instanceAddress: verifierAddress, players: [...players] });
+            if (!validationResult.result) {
+                throw new Error('Vote validation failed: ' + validationResult.reason);
+            }
+            const gameSize = players.length;
+            const instance = new InstanceBase_1.default({
+                instanceAddress: verifierAddress,
+                publicClient: this.publicClient,
+                chainId: this.chainId,
+            });
+            const eip712 = await instance.getEIP712Domain();
+            const playerSalt = await this.getTurnPlayersSalt({
+                gameId,
+                turn,
+                player: voter,
+                verifierAddress,
+                size: gameSize,
+            });
+            const ballot = {
+                vote: vote,
+                salt: playerSalt,
+            };
+            const ballotHash = (0, viem_1.keccak256)((0, viem_1.encodePacked)(["uint256[]", "bytes32"], [vote, playerSalt]));
+            const turnKey = await this.calculateSharedTurnKey({
+                instanceAddress: verifierAddress,
+                gameId,
+                turn,
+                player: voter,
+            });
+            const ballotId = aes_1.default.encrypt(JSON.stringify(ballot.vote.map((v) => v.toString())), turnKey).toString();
+            const gmSignature = await this.signVote({
+                verifierAddress,
+                voter,
+                gameId,
+                sealedBallotId: ballotId,
+                ballotHash,
+                name: eip712.name,
+                version: eip712.version,
+            });
+            (0, log_1.logger)(`Vote attested for player ${voter} by ${this.walletClient.account?.address}`);
+            (0, log_1.logger)({
+                gameId,
+                turn,
+                vote,
+                verifierAddress,
+                gameSize,
+                name: eip712.name,
+                version: eip712.version,
+                chainId: this.chainId,
+            }, 2);
+            return { vote, ballotHash, ballot, ballotId, gmSignature };
+        };
+        /**
+         * Signs a vote
+         * @param params - Parameters including voter, game info, and vote configuration
+         * @returns The signed vote
+         */
+        this.signVote = async (params) => {
+            const { voter, gameId, verifierAddress, sealedBallotId, ballotHash, name, version } = params;
+            (0, log_1.logger)(`Signing vote for player ${voter} in game ${gameId}`);
+            const types = {
+                SubmitVote: [
+                    { name: "gameId", type: "uint256" },
+                    { name: "voter", type: "address" },
+                    { name: "sealedBallotId", type: "string" },
+                    { name: "ballotHash", type: "bytes32" },
+                ],
+            };
+            if (!this.walletClient.account)
+                throw new Error("No account");
+            const signature = await this.walletClient.signTypedData({
+                domain: {
+                    name,
+                    version,
+                    chainId: this.chainId,
+                    verifyingContract: verifierAddress,
+                },
+                types,
+                primaryType: "SubmitVote",
+                message: {
+                    gameId,
+                    voter,
+                    sealedBallotId,
+                    ballotHash,
+                },
+                account: this.walletClient.account,
+            });
+            (0, log_1.logger)(`Vote signed for player ${voter}`);
+            return signature;
+        };
+        /**
+         * Generates integrity data for the end of a game turn
+         * @param params - Parameters including game info, turn, and proposal data
+         * @returns Integrity data including permutation, secret, and proof
+         */
+        this.generateEndTurnIntegrity = async ({ gameId, turn, verifierAddress, size = 15, proposals, }) => {
+            let _proposals = [...proposals];
+            const { permutation: prevTurnPermutation, turnSalt: prevTurnSalt } = await this.generateDeterministicPermutation({
+                gameId,
+                turn: turn - 1n,
+                verifierAddress,
+                size,
+            });
+            const values = await Promise.all(_proposals.map((p) => p.proposal === ""
+                ? {
+                    proposalValue: 0n,
+                    randomnessValue: 0n,
+                    proposer: p.proposer,
+                }
+                : this.proposalValues({
+                    instanceAddress: verifierAddress,
+                    gameId,
+                    proposal: p.proposal,
+                    turn,
+                    proposer: p.proposer,
+                })));
+            (0, log_1.logger)("proposals with added empty proposals:", 3);
+            (0, log_1.logger)(_proposals, 3);
+            const inputs = await this.createInputs({
+                numActive: size,
+                proposals: values.map((v) => v.proposalValue),
+                commitmentRandomnesses: values.map((v) => v.randomnessValue),
+                gameId,
+                turn,
+                verifierAddress,
+            });
+            (0, log_1.logger)("inputs:", 3);
+            (0, log_1.logger)(inputs, 3);
+            // Apply permutation to proposals array
+            console.log("permutation used on new proposals:", inputs.permutation);
+            console.log("revealed permutation for prevTurn proposals:", prevTurnPermutation);
+            const permutedProposals = (0, permutations_1.permuteArray)({ array: _proposals, permutation: inputs.permutation });
+            console.log("permutedProposals:", permutedProposals);
+            const config = {
+                circuitName: "ProposalsIntegrity15",
+                circuitArtifactsPath: path_1.default.join(__dirname, "../../zk_artifacts/circuits/proposals_integrity_15.circom/"),
+                verifierDirPath: path_1.default.join(__dirname, "../../zk_artifacts/verifiers"),
+            };
+            const implementer = new zkit_1.Groth16Implementer();
+            const circuit = new zkit_1.CircuitZKit(config, implementer);
+            const proof = await circuit.generateProof(inputs);
+            (0, log_1.logger)("proof:", 3);
+            (0, log_1.logger)(proof, 3);
+            const callData = await circuit.generateCalldata(proof);
+            (0, log_1.logger)("callData:", 3);
+            (0, log_1.logger)(callData, 3);
+            if (!proof) {
+                throw new Error("Proof not found");
+            }
+            // const callData = await circuit.generateCalldata(proof);
+            const a = callData[0].map((a) => BigInt(a));
+            const b = callData[1].map((b) => b.map((b) => BigInt(b)));
+            const c = callData[2].map((c) => BigInt(c));
+            return {
+                commitment: inputs.permutationCommitment,
+                prevTurnSalt,
+                prevTurnPermutation,
+                permutedProposals: permutedProposals.map((proposal) => proposal.proposal),
+                a,
+                b,
+                c,
+            };
+        };
+        /**
+         * Creates inputs for the proposal integrity circuit
+         * @param params - Parameters including number of active proposals, proposals, commitment random numbers, game ID, turn, and verifier address
+         * @returns The inputs for the proposal integrity circuit
+         */
+        this.createInputs = async ({ numActive, proposals, commitmentRandomnesses, gameId, turn, verifierAddress, }) => {
+            const poseidon = await (0, circomlibjs_1.buildPoseidon)();
+            // Initialize arrays with zeros
+            const commitments = Array(this.maxSlotSizeForProofs).fill(0n);
+            const randomnesses = Array(this.maxSlotSizeForProofs).fill(0n);
+            const permutedProposals = Array(this.maxSlotSizeForProofs).fill(0n);
+            // Generate deterministic permutation
+            const { permutation, turnSalt: secret, commitment } = await this.generateDeterministicPermutation({
+                gameId,
+                turn,
+                verifierAddress,
+                size: numActive,
+            });
+            // Fill arrays with values
+            for (let i = 0; i < this.maxSlotSizeForProofs; i++) {
+                if (i < numActive) {
+                    // Active slots
+                    const proposal = proposals[i];
+                    const randomness = commitmentRandomnesses[i];
+                    const hash = poseidon([proposal, randomness]);
+                    commitments[i] = BigInt(poseidon.F.toObject(hash));
+                    randomnesses[i] = randomness;
+                    // Store proposal in permuted position
+                    permutedProposals[permutation[i]] = proposal;
+                }
+                else {
+                    (0, log_1.logger)(`Inactive slot ${i}`, 3);
+                    // Inactive slots
+                    const hash = poseidon([0n, 0n]);
+                    commitments[i] = BigInt(poseidon.F.toObject(hash));
+                    randomnesses[i] = 0n;
+                    // permutedProposals already 0n
+                }
+            }
+            return {
+                numActive: BigInt(numActive),
+                commitments,
+                permutedProposals,
+                permutationCommitment: commitment,
+                permutation: permutation.map((p) => BigInt(p)),
+                randomnesses,
+                permutationRandomness: secret,
+            };
+        };
+        this.chainId = chainId;
+        this.publicClient = publicClient;
+        this.walletClient = walletClient;
+    }
+    hasVoted({ vote }) {
+        return vote?.reduce((a, b) => a + b, 0n) !== 0n;
+    }
+    ;
+    getGameState({ gameId, instanceAddress }) {
+        const baseInstance = new InstanceBase_1.default({
+            instanceAddress,
+            publicClient: this.publicClient,
+            chainId: this.chainId,
+        });
+        return baseInstance.getGameStateDetails(gameId);
+    }
+    /**
+     * Gets proposal integrity data for testing
+     * @param params - Parameters including game info and proposal data
+     * @returns Proposal integrity information including permutations and proofs
+     */
+    async getProposalsIntegrity({ size, gameId, turn, proposals, verifierAddress, }) {
+        (0, log_1.logger)(`Generating proposals integrity for game ${gameId}, turn ${turn} with ${size} players.`);
+        const { commitment, prevTurnSalt, prevTurnPermutation, permutedProposals, a, b, c } = await this.generateEndTurnIntegrity({
+            gameId,
+            turn,
+            verifierAddress,
+            size,
+            proposals,
+        });
+        (0, log_1.logger)(`Generated proposals integrity with commitment ${commitment}`);
+        return {
+            newProposals: {
+                a,
+                b,
+                c,
+                proposals: permutedProposals,
+                permutationCommitment: commitment,
+            },
+            prevTurnPermutation: prevTurnPermutation.map((p) => BigInt(p)),
+            proposalsNotPermuted: proposals.map((proposal) => proposal.proposal),
+            prevTurnSalt,
+        };
+    }
+}
+exports.GameMaster = GameMaster;
+exports.default = GameMaster;
+//# sourceMappingURL=GameMaster.js.map