@peeramid-labs/sdk 3.7.4 → 3.8.0

package/lib.commonjs/rankify/GameMaster.js

@@ -26,6 +26,7 @@ class GameMaster {
     walletClient;
     publicClient;
     chainId;
+    maxSlotSizeForProofs = 15;
     /**
      * Creates a new GameMaster instance
   
@@ -74,39 +75,50 @@ class GameMaster {
      * @param proposer - Optional proposer address to filter proposals
      * @returns Array of decrypted proposals with proposer addresses
      */
-    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({
+    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
@@ -117,11 +129,10 @@ class GameMaster {
      * @returns The generated permutation, secret, and commitment
      */
     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
@@ -132,7 +143,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 };
@@ -157,7 +168,7 @@ class GameMaster {
         const commitment = BigInt(poseidon.F.toObject(poseidon([PoseidonThird, turnSalt])));
         return {
             permutation,
-            secret: turnSalt,
+            turnSalt,
             commitment,
         };
     };
@@ -226,61 +237,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;
     };
-    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
@@ -288,31 +249,17 @@ class GameMaster {
      * @returns Index of the player's proposal, -1 if not found
      */
     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);
     };
     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" };
             }
@@ -340,6 +287,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)({
@@ -403,19 +354,12 @@ class GameMaster {
      * @returns Transaction hash
      */
     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,
@@ -430,6 +374,84 @@ 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
+     */
+    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;
+        }
+    };
+    hasVoted({ vote }) {
+        return vote?.reduce((a, b) => a + b, 0n) !== 0n;
+    }
+    ;
+    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: "" };
+    };
+    getGameState({ gameId, instanceAddress }) {
+        const baseInstance = new InstanceBase_1.default({
+            instanceAddress,
+            publicClient: this.publicClient,
+            chainId: this.chainId,
+        });
+        return baseInstance.getGameStateDetails(gameId);
+    }
+    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
      */
@@ -572,8 +594,6 @@ class GameMaster {
      * @returns Transaction hash
      */
     submitProposal = async ({ instanceAddress, submissionParams, proposerSignature, }) => {
-        // let proposalData: GetAbiItemParameters<typeof RankifyDiamondInstanceAbi, "submitProposal">["args"];
-        // proposalData[0].
         const txParams = [
             {
                 ...submissionParams,
@@ -600,21 +620,23 @@ class GameMaster {
      * @param turn - Turn number
      * @returns Array of decrypted votes with player addresses
      */
-    decryptTurnVotes = async ({ instanceAddress, gameId, turn, }) => {
+    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)
@@ -631,26 +653,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
-     */
-    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
@@ -658,12 +667,24 @@ class GameMaster {
      * @returns Boolean indicating if turn can be ended
      */
     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
@@ -709,60 +730,22 @@ class GameMaster {
     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");
-            }
-            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: "",
-                    });
-                }
+            if (!(await this.canEndTurn({ instanceAddress, gameId }))) {
+                throw new Error("Cannot end turn");
             }
-            (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({
@@ -770,16 +753,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);
         }
@@ -807,6 +788,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 }),
@@ -839,7 +822,12 @@ class GameMaster {
      */
     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,
@@ -932,7 +920,7 @@ class GameMaster {
      */
     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,
@@ -964,7 +952,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/"),
@@ -987,8 +978,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,
@@ -1002,7 +993,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,
@@ -1018,9 +1009,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,
         };
     }
     /**
@@ -1030,20 +1021,19 @@ class GameMaster {
      */
     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];