@peeramid-labs/sdk 3.7.4 → 3.9.0

package/cli/rankify/GameMaster.js

@@ -31,6 +31,7 @@ class GameMaster {
      * @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
@@ -67,39 +68,50 @@ class GameMaster {
          * @param proposer - Optional proposer address to filter proposals
          * @returns Array of decrypted proposals with proposer addresses
          */
-        this.decryptProposals = async ({ instanceAddress, gameId, turn, proposer, }) => {
-            (0, log_1.logger)(`Getting proposals for instance ${instanceAddress}, game ${gameId}, turn ${turn.toString()}, proposer ${proposer}`);
-            const evts = await this.publicClient.getContractEvents({
+        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, proposer: proposer },
+                args: { gameId: gameId, turn: turn },
                 fromBlock: 0n,
             });
-            (0, log_1.logger)(`Found ${evts.length} proposals`);
+            (0, log_1.logger)(`Found ${ProposalSubmittedEvents.length} proposals`);
             const instance = new InstanceBase_1.default({ instanceAddress, publicClient: this.publicClient, chainId: this.chainId });
-            if (evts.length == 0)
-                return [];
-            (0, log_1.logger)(`Decrypting ${evts.length} proposals`);
-            const proposals = await Promise.all(evts.map(async (log) => {
-                (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,
+            (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,
-                        instance,
-                    }),
-                };
+                        proposal: await this.decryptProposal({
+                            proposal: log.args.encryptedProposal,
+                            turn: turn,
+                            instanceAddress: instanceAddress,
+                            gameId: gameId,
+                            proposer: log.args.proposer,
+                            instance,
+                        }),
+                    };
+                }
             }));
-            return proposals;
+            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
@@ -110,11 +122,10 @@ class GameMaster {
          * @returns The generated permutation, secret, and commitment
          */
         this.getPermutation = async ({ gameId, turn, size, verifierAddress, }) => {
-            const maxSize = 15;
             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: maxSize }, (_, i) => i);
+            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
@@ -125,7 +136,7 @@ class GameMaster {
                 [permutation[i], permutation[j]] = [permutation[j], permutation[i]];
             }
             // Ensure inactive slots map to themselves
-            for (let i = size; i < maxSize; i++) {
+            for (let i = size; i < this.maxSlotSizeForProofs; i++) {
                 permutation[i] = i;
             }
             return { permutation, turnSalt };
@@ -150,7 +161,7 @@ class GameMaster {
             const commitment = BigInt(poseidon.F.toObject(poseidon([PoseidonThird, turnSalt])));
             return {
                 permutation,
-                secret: turnSalt,
+                turnSalt,
                 commitment,
             };
         };
@@ -219,61 +230,11 @@ class GameMaster {
                 verifierAddress,
                 size,
             }).then((perm) => {
-                return (0, viem_1.keccak256)((0, viem_1.encodePacked)(["address", "uint256"], [player, perm.secret]));
+                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;
         };
-        this.getProposalsVotedUpon = async ({ instanceAddress, gameId, turn, }) => {
-            const oldProposals = [];
-            //Proposals sequence is directly corresponding to proposers sequence
-            if (turn != 1n) {
-                (0, log_1.logger)(`Getting proposals voted upon for game ${gameId.toString()}, turn ${(turn - 1n).toString()}`, 3);
-                const endedEvents = await this.publicClient.getContractEvents({
-                    address: instanceAddress,
-                    abi: abis_1.RankifyDiamondInstanceAbi,
-                    eventName: "TurnEnded",
-                    args: { gameId, turn: turn - 1n },
-                    fromBlock: 0n,
-                });
-                const evt = endedEvents[0];
-                (0, log_1.logger)("evt:", 3);
-                (0, log_1.logger)(evt, 3);
-                if (endedEvents.length > 1)
-                    throw new Error("Multiple turns ended");
-                const args = evt.args;
-                const decryptedProposals = await this.decryptProposals({ instanceAddress, gameId, turn: turn - 1n });
-                if (args.newProposals) {
-                    args.newProposals.slice(0, args?.players?.length).forEach((proposal, idx) => {
-                        if (proposal !== "") {
-                            const proposer = decryptedProposals.find((p) => p.proposal === proposal)?.proposer;
-                            if (!proposer)
-                                throw new Error("No proposer found for proposal");
-                            oldProposals[idx] = {
-                                proposer,
-                                proposal: proposal,
-                            };
-                        }
-                    });
-                }
-                else {
-                    const _players = await this.publicClient.readContract({
-                        address: instanceAddress,
-                        abi: abis_1.RankifyDiamondInstanceAbi,
-                        functionName: "getPlayers",
-                        args: [gameId],
-                    });
-                    // Boundary case if no-one proposed a thing
-                    _players.forEach((p, idx) => {
-                        oldProposals[idx] = {
-                            proposer: p,
-                            proposal: "",
-                        };
-                    });
-                }
-            }
-            return oldProposals;
-        };
         /**
          * Finds the index of a player's ongoing proposal
          * @param gameId - ID of the game
@@ -281,31 +242,17 @@ class GameMaster {
          * @returns Index of the player's proposal, -1 if not found
          */
         this.findPlayerOngoingProposalIndex = async ({ instanceAddress, gameId, player, turn, }) => {
-            const baseInstance = new InstanceBase_1.default({ instanceAddress, publicClient: this.publicClient, chainId: this.chainId });
-            let currentTurn = 0n;
             if (!turn) {
-                const r = await baseInstance.getOngoingProposals(gameId);
-                currentTurn = r.currentTurn;
-                if (currentTurn == 0n) {
-                    console.error("No proposals in turn 0");
-                    return -1;
-                }
-            }
-            else {
-                currentTurn = turn;
+                turn = await this.currentTurn({ instanceAddress, gameId });
             }
-            const proposalsVotedUpon = await this.getProposalsVotedUpon({ instanceAddress, gameId, turn: currentTurn });
-            return proposalsVotedUpon.findIndex((p) => p.proposer === player);
+            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 baseInstance = new InstanceBase_1.default({
-                    instanceAddress,
-                    publicClient: this.publicClient,
-                    chainId: this.chainId,
-                });
-                const gameState = await baseInstance.getGameStateDetails(gameId);
+                const gameState = await this.getGameState({ gameId, instanceAddress });
                 if (gameState.gamePhase !== types_1.gameStatusEnum.open) {
                     return { result: false, errorMessage: "Game is not open for registration" };
                 }
@@ -333,6 +280,10 @@ class GameMaster {
                 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)({
@@ -396,19 +347,12 @@ class GameMaster {
          * @returns Transaction hash
          */
         this.submitVote = async ({ instanceAddress, gameId, vote, voter, voterSignature, ballotHash, ballotId, }) => {
-            if (!gameId)
-                throw new Error("No gameId");
-            if (!vote)
-                throw new Error("No votesHidden");
-            if (!voter)
-                throw new Error("No voter");
-            const proposerIdx = await this.findPlayerOngoingProposalIndex({ instanceAddress, gameId, player: voter });
-            if (proposerIdx == -1)
-                throw new Error("You are not a proposer in this game");
-            if (vote[proposerIdx] !== 0n)
-                throw new Error("You cannot vote for your own proposal");
-            if (!this.walletClient?.account?.address)
-                throw new Error("No account address found");
+            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,
@@ -423,6 +367,72 @@ class GameMaster {
                 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
          */
@@ -565,8 +575,6 @@ class GameMaster {
          * @returns Transaction hash
          */
         this.submitProposal = async ({ instanceAddress, submissionParams, proposerSignature, }) => {
-            // let proposalData: GetAbiItemParameters<typeof RankifyDiamondInstanceAbi, "submitProposal">["args"];
-            // proposalData[0].
             const txParams = [
                 {
                     ...submissionParams,
@@ -593,21 +601,23 @@ class GameMaster {
          * @param turn - Turn number
          * @returns Array of decrypted votes with player addresses
          */
-        this.decryptTurnVotes = async ({ instanceAddress, gameId, turn, }) => {
+        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 evts = await this.publicClient.getContractEvents({
+            const VoteSubmittedEvents = await this.publicClient.getContractEvents({
                 address: instanceAddress,
                 abi: abis_1.RankifyDiamondInstanceAbi,
                 eventName: "VoteSubmitted",
                 fromBlock: 0n,
                 args: { turn, gameId },
             });
-            (0, log_1.logger)(`Found ${evts.length} events`);
-            if (evts.length === 0)
+            (0, log_1.logger)(`Found ${VoteSubmittedEvents.length} events`);
+            if (VoteSubmittedEvents.length === 0)
                 return [];
-            // Process events one by one to allow errors to propagate
+            //Decrypting votes from events
             const votes = [];
-            for (const event of evts) {
+            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)
@@ -624,26 +634,13 @@ class GameMaster {
                     votes: decryptedVotes,
                 });
             }
-            return votes;
-        };
-        /**
-         * Decrypts all votes for the current game turn
-         * @param gameId - ID of the game
-         * @returns Array of decrypted votes with player addresses
-         */
-        this.decryptVotes = async ({ instanceAddress, gameId }) => {
-            const currentTurn = await this.publicClient.readContract({
-                address: instanceAddress,
-                abi: abis_1.RankifyDiamondInstanceAbi,
-                functionName: "getTurn",
-                args: [gameId],
-            });
-            if (currentTurn === 0n) {
-                console.error("No proposals in turn 0");
-                return -1;
-            }
-            const votes = await this.decryptTurnVotes({ instanceAddress, gameId, turn: currentTurn });
-            return votes.length === 0 ? -1 : votes;
+            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
@@ -651,12 +648,24 @@ class GameMaster {
          * @returns Boolean indicating if turn can be ended
          */
         this.canEndTurn = async ({ instanceAddress, gameId }) => {
-            return this.publicClient.readContract({
+            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
@@ -702,60 +711,22 @@ class GameMaster {
         this.endTurn = async ({ instanceAddress, gameId }) => {
             (0, log_1.logger)(`Ending turn for game ${gameId}`, 2);
             try {
-                const turn = await this.publicClient.readContract({
-                    address: instanceAddress,
-                    abi: abis_1.RankifyDiamondInstanceAbi,
-                    functionName: "getTurn",
-                    args: [gameId],
-                });
-                const players = (await this.publicClient.readContract({
-                    address: instanceAddress,
-                    abi: abis_1.RankifyDiamondInstanceAbi,
-                    functionName: "getPlayers",
-                    args: [gameId],
-                }));
-                (0, log_1.logger)(`Current turn: ${turn}, Players count: ${players.length}`, 2);
-                if (!Array.isArray(players)) {
-                    throw new Error("Expected players to be an array");
+                if (!(await this.canEndTurn({ instanceAddress, gameId }))) {
+                    throw new Error("Cannot end turn");
                 }
-                const proposerIndices = [];
-                const oldProposals = await this.getProposalsVotedUpon({ instanceAddress, gameId, turn });
-                const decryptedProposals = await this.decryptProposals({ instanceAddress, gameId, turn });
-                (0, log_1.logger)(decryptedProposals);
-                const proposals = players.map((player) => {
-                    const proposal = decryptedProposals.find((p) => p.proposer === player)?.proposal ?? "";
-                    return {
-                        proposer: player,
-                        proposal,
-                    };
-                });
-                const maxSize = 15;
-                if (proposals.length < maxSize) {
-                    for (let i = proposals.length; i < maxSize; i++) {
-                        proposals.push({
-                            proposer: viem_1.zeroAddress,
-                            proposal: "",
-                        });
-                    }
-                }
-                (0, log_1.logger)(proposals);
-                players.forEach((player) => {
-                    let proposerIdx = oldProposals.findIndex((p) => player === p.proposer);
-                    if (proposerIdx === -1)
-                        proposerIdx = players.length; //Did not propose
-                    proposerIndices.push(BigInt(proposerIdx));
-                });
-                const voteDecrypted = await this.decryptTurnVotes({ instanceAddress, gameId, turn });
-                const votes = await Promise.all(players.map(async (player) => {
-                    const vote = voteDecrypted.find((v) => v.player === player);
-                    if (!vote?.votes)
-                        return players.map(() => 0n);
-                    return vote.votes;
-                }));
+                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,
-                    proposerIndex: proposerIndices[idx],
-                    proposer: oldProposals[Number(proposerIndices[idx])]?.proposer || "not-proposed",
+                    voted: this.hasVoted({ vote: votesDecrypted[idx] }),
+                    proposal: newPaddedDecryptedProposals[idx]?.proposal.substring(0, 50) || "not-proposed",
                 }));
                 console.table(tableData);
                 const attested = await this.getProposalsIntegrity({
@@ -763,16 +734,14 @@ class GameMaster {
                     turn,
                     verifierAddress: instanceAddress,
                     size: players.length,
-                    proposals,
+                    proposals: newPaddedDecryptedProposals,
                 });
-                (0, log_1.logger)(`votes:`);
-                (0, log_1.logger)(votes);
                 const { request } = await this.publicClient.simulateContract({
                     abi: abis_1.RankifyDiamondInstanceAbi,
                     account: this.walletClient.account,
                     address: instanceAddress,
                     functionName: "endTurn",
-                    args: [gameId, votes, attested.newProposals, attested.permutation, attested.nullifier],
+                    args: [gameId, votesDecrypted, attested.newProposals, attested.prevTurnPermutation, attested.prevTurnSalt],
                 });
                 return this.walletClient.writeContract(request);
             }
@@ -800,6 +769,8 @@ class GameMaster {
             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 }),
@@ -832,7 +803,12 @@ class GameMaster {
          */
         this.attestVote = async ({ voter, gameId, turn, vote, verifierAddress, }) => {
             (0, log_1.logger)(`Attesting vote for player ${voter} in game ${gameId}, turn ${turn}`);
-            const gameSize = (await this.getPlayers({ instanceAddress: verifierAddress, gameId })).length;
+            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,
@@ -925,7 +901,7 @@ class GameMaster {
          */
         this.generateEndTurnIntegrity = async ({ gameId, turn, verifierAddress, size = 15, proposals, }) => {
             let _proposals = [...proposals];
-            const { permutation, secret: nullifier } = await this.generateDeterministicPermutation({
+            const { permutation: prevTurnPermutation, turnSalt: prevTurnSalt } = await this.generateDeterministicPermutation({
                 gameId,
                 turn: turn - 1n,
                 verifierAddress,
@@ -957,7 +933,10 @@ class GameMaster {
             (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/"),
@@ -980,8 +959,8 @@ class GameMaster {
             const c = callData[2].map((c) => BigInt(c));
             return {
                 commitment: inputs.permutationCommitment,
-                nullifier,
-                permutation: permutation,
+                prevTurnSalt,
+                prevTurnPermutation,
                 permutedProposals: permutedProposals.map((proposal) => proposal.proposal),
                 a,
                 b,
@@ -995,20 +974,19 @@ class GameMaster {
          */
         this.createInputs = async ({ numActive, proposals, commitmentRandomnesses, gameId, turn, verifierAddress, }) => {
             const poseidon = await (0, circomlibjs_1.buildPoseidon)();
-            const maxSize = 15;
             // Initialize arrays with zeros
-            const commitments = Array(maxSize).fill(0n);
-            const randomnesses = Array(maxSize).fill(0n);
-            const permutedProposals = Array(maxSize).fill(0n);
+            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, secret, commitment } = await this.generateDeterministicPermutation({
+            const { permutation, turnSalt: secret, commitment } = await this.generateDeterministicPermutation({
                 gameId,
                 turn,
                 verifierAddress,
                 size: numActive,
             });
             // Fill arrays with values
-            for (let i = 0; i < maxSize; i++) {
+            for (let i = 0; i < this.maxSlotSizeForProofs; i++) {
                 if (i < numActive) {
                     // Active slots
                     const proposal = proposals[i];
@@ -1042,6 +1020,18 @@ class GameMaster {
         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
@@ -1049,7 +1039,7 @@ class GameMaster {
      */
     async getProposalsIntegrity({ size, gameId, turn, proposals, verifierAddress, }) {
         (0, log_1.logger)(`Generating proposals integrity for game ${gameId}, turn ${turn} with ${size} players.`);
-        const { commitment, nullifier, permutation, permutedProposals, a, b, c } = await this.generateEndTurnIntegrity({
+        const { commitment, prevTurnSalt, prevTurnPermutation, permutedProposals, a, b, c } = await this.generateEndTurnIntegrity({
             gameId,
             turn,
             verifierAddress,
@@ -1065,9 +1055,9 @@ class GameMaster {
                 proposals: permutedProposals,
                 permutationCommitment: commitment,
             },
-            permutation: permutation.map((p) => BigInt(p)),
+            prevTurnPermutation: prevTurnPermutation.map((p) => BigInt(p)),
             proposalsNotPermuted: proposals.map((proposal) => proposal.proposal),
-            nullifier,
+            prevTurnSalt,
         };
     }
 }