@peeramid-labs/sdk 3.4.0 → 3.6.0

package/lib.esm/rankify/GameMaster.js

@@ -1,7 +1,16 @@
-import { keccak256, encodePacked } from "viem";
+import { keccak256, encodePacked, stringToHex, zeroHash, } from "viem";
 import { RankifyDiamondInstanceAbi } from "../abis";
 import InstanceBase from "./InstanceBase";
+import { gameStatusEnum } from "../types";
 import { handleRPCError } from "../utils";
+import { publicKeyToAddress } from "viem/accounts";
+import { logger } from "../utils/log";
+import { buildPoseidon } from "circomlibjs";
+import aes from "crypto-js/aes";
+import cryptoJs from "crypto-js";
+import { CircuitZKit, Groth16Implementer } from "@solarity/zkit";
+import path from "path";
+import { permuteArray, reversePermutation } from "../utils/permutations";
 /**
  * GameMaster class for managing game state and cryptographic operations in Rankify
  * Extends InstanceBase to provide game master specific functionality
@@ -10,10 +19,6 @@ import { handleRPCError } from "../utils";
 export class GameMaster {
     walletClient;
     publicClient;
-    encryptionCallback;
-    decryptionCallback;
-    randomnessCallback;
-    turnSaltCallback;
     chainId;
     /**
      * Creates a new GameMaster instance
@@ -21,20 +26,41 @@ export class GameMaster {
      * @param walletClient - Viem wallet client for transactions
      * @param publicClient - Viem public client for reading state
      * @param chainId - Chain ID of the network
-     * @param encryptionCallback - Callback function for encrypting data
-     * @param decryptionCallback - Callback function for decrypting data
-     * @param randomnessCallback - Callback function for generating random numbers
-     * @param turnSaltCallback - Callback function for generating turn salts
      */
-    constructor({ walletClient, chainId, publicClient, encryptionCallback, decryptionCallback, randomnessCallback, turnSaltCallback, }) {
+    constructor({ walletClient, chainId, publicClient, }) {
         this.chainId = chainId;
         this.publicClient = publicClient;
         this.walletClient = walletClient;
-        this.encryptionCallback = encryptionCallback;
-        this.decryptionCallback = decryptionCallback;
-        this.randomnessCallback = randomnessCallback;
-        this.turnSaltCallback = turnSaltCallback;
     }
+    /**
+     * 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
+     */
+    decryptProposal = async ({ proposal, turn, instanceAddress, gameId, proposer, instance, }) => {
+        const _instance = instance ?? new InstanceBase({ 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,
+        });
+        logger(`Decrypting proposal ${proposal} with shared key (hashed value: ${keccak256(sharedKey)})`);
+        const decryptedProposal = aes.decrypt(proposal, sharedKey).toString(cryptoJs.enc.Utf8);
+        logger(`Decrypted proposal ${decryptedProposal}`);
+        return decryptedProposal;
+    };
     /**
      * Decrypts proposals for a specific game turn
      * @param gameId - ID of the game
@@ -48,55 +74,201 @@ export class GameMaster {
             address: instanceAddress,
             eventName: "ProposalSubmitted",
             args: { gameId: gameId, turn: turn, proposer: proposer },
+            fromBlock: 0n,
         });
+        const instance = new InstanceBase({ instanceAddress, publicClient: this.publicClient, chainId: this.chainId });
         if (evts.length == 0)
             return [];
+        logger(`Decrypting ${evts.length} proposals`);
         const proposals = await Promise.all(evts.map(async (log) => {
-            if (!log.args.proposalEncryptedByGM)
+            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.decryptionCallback(log.args.proposalEncryptedByGM),
+                proposal: await this.decryptProposal({
+                    proposal: log.args.encryptedProposal,
+                    turn: turn,
+                    instanceAddress: instanceAddress,
+                    gameId: gameId,
+                    proposer: log.args.proposer,
+                    instance,
+                }),
             };
         }));
         return proposals;
     };
     /**
-     * Shuffles an array using cryptographically secure randomness
-     * @param array - Array to shuffle
-     * @returns Shuffled array
+     * 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
      */
-    shuffle = async (array) => {
-        const randomness = await this.randomnessCallback();
-        let currentIndex = array.length, randomIndex;
-        // While there remain elements to shuffle.
-        while (currentIndex > 0) {
-            // Pick a remaining element.
-            randomIndex = Math.floor(randomness * currentIndex);
-            currentIndex--;
-            // And swap it with the current element.
-            [array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
+    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);
+        // Fisher-Yates shuffle with deterministic randomness
+        for (let i = size - 1; i >= 0; i--) {
+            // Generate deterministic random number for this position
+            const randHash = keccak256(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 < maxSize; i++) {
+            permutation[i] = i;
         }
-        return array;
+        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
+     */
+    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 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,
+            secret: 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
+     */
+    permuteArray = async ({ array, gameId, turn, verifierAddress, }) => {
+        const { permutation } = await this.getPermutation({ gameId, turn, size: array.length, verifierAddress });
+        return 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
+     */
+    reversePermutation = async ({ permutedArray, gameId, turn, verifierAddress, }) => {
+        const { permutation } = await this.getPermutation({ gameId, turn, size: permutedArray.length, verifierAddress });
+        return 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
      */
-    getTurnSalt = async ({ gameId, turn }) => {
-        return this.turnSaltCallback({ gameId, turn }).then((salt) => keccak256(encodePacked(["bytes32", "uint256", "uint256"], [salt, gameId, turn])));
+    getTurnSalt = async ({ gameId, turn, verifierAddress, }) => {
+        const gameKey = await this.gameKey({ gameId, contractAddress: verifierAddress });
+        const instance = new InstanceBase({
+            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 proposer - Address of the proposer
+     * @param player - Address of the player
+     * @param verifierAddress - Address of the verifier
+     * @param size - Size of the permutation
      * @returns Generated salt as Hex
      */
-    getTurnPlayersSalt = async ({ gameId, turn, proposer }) => {
-        return this.getTurnSalt({ gameId, turn }).then((salt) => keccak256(encodePacked(["address", "bytes32"], [proposer, salt])));
+    getTurnPlayersSalt = async ({ gameId, turn, player, verifierAddress, size, }) => {
+        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 keccak256(encodePacked(["address", "uint256"], [player, perm.secret]));
+        });
+        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) {
+            const endedEvents = await this.publicClient.getContractEvents({
+                address: instanceAddress,
+                abi: RankifyDiamondInstanceAbi,
+                eventName: "TurnEnded",
+                args: { gameId, turn: turn - 1n },
+                fromBlock: 0n,
+            });
+            const evt = endedEvents[0];
+            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: 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
@@ -104,16 +276,113 @@ export class GameMaster {
      * @param player - Address of the player
      * @returns Index of the player's proposal, -1 if not found
      */
-    findPlayerOngoingProposalIndex = async ({ instanceAddress, gameId, player, }) => {
+    findPlayerOngoingProposalIndex = async ({ instanceAddress, gameId, player, turn, }) => {
         const baseInstance = new InstanceBase({ instanceAddress, publicClient: this.publicClient, chainId: this.chainId });
-        const { currentTurn, proposals } = await baseInstance.getOngoingProposals(gameId);
-        if (currentTurn == 0n) {
-            console.error("No proposals in turn 0");
-            return -1;
+        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;
         }
-        const turn = currentTurn - 1n;
-        const playersProposal = await this.decryptProposals({ instanceAddress, gameId, turn, proposer: player }).then((ps) => (ps.length > 0 ? ps[0].proposal : undefined));
-        return playersProposal ? proposals.findIndex((p) => p === playersProposal) : -1;
+        const proposalsVotedUpon = await this.getProposalsVotedUpon({ instanceAddress, gameId, turn: currentTurn });
+        return proposalsVotedUpon.findIndex((p) => p.proposer === player);
+    };
+    validateJoinGame = async (props) => {
+        const { gameId, participant, instanceAddress } = props;
+        try {
+            const baseInstance = new InstanceBase({
+                instanceAddress,
+                publicClient: this.publicClient,
+                chainId: this.chainId,
+            });
+            const gameState = await baseInstance.getGameStateDetails(gameId);
+            if (gameState.gamePhase !== 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 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
+     */
+    signJoiningGame = async (props, timeToJoin = 60 * 10) => {
+        if (!this.walletClient.account)
+            throw new Error("No account");
+        logger(`Signing joining game..`);
+        const { gameId, participant, instanceAddress, participantPubKeyHash } = props;
+        const baseInstance = new InstanceBase({ instanceAddress, publicClient: this.publicClient, chainId: this.chainId });
+        const eip712 = await baseInstance.getEIP712Domain();
+        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 = 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
@@ -122,7 +391,7 @@ export class GameMaster {
      * @param voter - Address of the voter
      * @returns Transaction hash
      */
-    submitVote = async ({ instanceAddress, gameId, vote, voter, }) => {
+    submitVote = async ({ instanceAddress, gameId, vote, voter, voterSignature, ballotHash, ballotId, }) => {
         if (!gameId)
             throw new Error("No gameId");
         if (!vote)
@@ -130,9 +399,10 @@ export class GameMaster {
         if (!voter)
             throw new Error("No voter");
         const proposerIdx = await this.findPlayerOngoingProposalIndex({ instanceAddress, gameId, player: voter });
-        if (proposerIdx != -1 && vote[proposerIdx] !== 0n)
+        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");
-        const votesHidden = await this.encryptionCallback(JSON.stringify(vote.map((vi) => vi.toString())));
         if (!this.walletClient?.account?.address)
             throw new Error("No account address found");
         try {
@@ -141,7 +411,7 @@ export class GameMaster {
                 address: instanceAddress,
                 abi: RankifyDiamondInstanceAbi,
                 functionName: "submitVote",
-                args: [gameId, votesHidden, voter],
+                args: [gameId, ballotId, voter, zeroHash, voterSignature, ballotHash],
             });
             return this.walletClient.writeContract(request);
         }
@@ -150,14 +420,137 @@ export class GameMaster {
         }
     };
     /**
-     * Gets the hidden proposer hash for a specific game turn
+     * Types for proposal submission
+     */
+    proposalTypes = {
+        SubmitProposal: [
+            { type: "uint256", name: "gameId" },
+            { type: "address", name: "proposer" },
+            { type: "string", name: "encryptedProposal" },
+            { type: "uint256", name: "commitment" },
+        ],
+    };
+    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,
+        });
+    };
+    proposalValues = async ({ instanceAddress, gameId, proposal, proposer, turn, }) => {
+        const instance = new InstanceBase({ 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(keccak256(encodePacked(["string"], [proposal])));
+        const randomnessValue = BigInt(keccak256(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
+     */
+    encryptProposal = async ({ proposal, turn, instanceAddress, gameId, proposerPubKey, }) => {
+        const instance = new InstanceBase({ 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,
+        });
+        logger(`Encrypting proposal ${proposal} with shared key (hashed value: ${keccak256(sharedKey)})`);
+        const encryptedProposal = aes.encrypt(proposal, sharedKey).toString();
+        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
-     * @param proposer - Address of the proposer
-     * @returns Hidden proposer hash
+     * @returns The attested proposal
      */
-    proposerHidden = ({ gameId, turn, proposer }) => {
-        return this.getTurnPlayersSalt({ gameId, turn, proposer }).then((salt) => keccak256(encodePacked(["address", "bytes32"], [proposer, salt])));
+    attestProposal = async ({ instanceAddress, gameId, proposal, proposerPubKey, turn, }) => {
+        const proposerAddress = publicKeyToAddress(proposerPubKey);
+        logger(`Creating proposal secrets for player ${proposerAddress} in game ${gameId}`);
+        const poseidon = await buildPoseidon();
+        const instance = new InstanceBase({ instanceAddress, publicClient: this.publicClient, chainId: this.chainId });
+        const { encryptedProposal, sharedKey } = await this.encryptProposal({
+            proposal,
+            turn,
+            instanceAddress,
+            gameId,
+            proposerPubKey,
+        });
+        const proposalValue = BigInt(keccak256(encodePacked(["string"], [proposal])));
+        const randomnessValue = BigInt(keccak256(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,
+        };
+        logger(`Generated proposal secrets with commitment ${poseidonCommitment}`);
+        return {
+            submissionParams: params,
+            proposal,
+            proposerAddress,
+            proposalValue,
+            randomnessValue,
+        };
     };
     /**
      * Submits a proposal to the game
@@ -167,18 +560,22 @@ export class GameMaster {
      * @param proposer - Address of the proposer
      * @returns Transaction hash
      */
-    submitProposal = async ({ instanceAddress, gameId, commitmentHash, proposal, proposer, }) => {
+    submitProposal = async ({ instanceAddress, submissionParams, proposerSignature, }) => {
         // let proposalData: GetAbiItemParameters<typeof RankifyDiamondInstanceAbi, "submitProposal">["args"];
         // proposalData[0].
-        const encryptedProposal = await this.encryptionCallback(proposal);
-        console.log("submitting proposal tx..", gameId, commitmentHash, proposal, proposer);
+        const txParams = [
+            {
+                ...submissionParams,
+                proposerSignature,
+            },
+        ];
         try {
             const { request } = await this.publicClient.simulateContract({
                 account: this.walletClient.account,
                 address: instanceAddress,
                 abi: RankifyDiamondInstanceAbi,
                 functionName: "submitProposal",
-                args: [{ gameId, commitmentHash, encryptedProposal, proposer }],
+                args: txParams,
             });
             return this.walletClient.writeContract(request);
         }
@@ -199,18 +596,28 @@ export class GameMaster {
             eventName: "VoteSubmitted",
             args: { gameId, turn },
         });
-        const votes = await Promise.all(evts.map(async (event) => {
+        logger(`Found ${evts.length} events`);
+        if (evts.length === 0)
+            return [];
+        // Process events one by one to allow errors to propagate
+        const votes = [];
+        for (const event of evts) {
             if (!event.args.player)
-                throw new Error("No player found in event data, that is unexpected");
-            if (!event.args.votesHidden)
-                throw new Error("No votesHidden found in event data, that is unexpected");
-            const decryptedVote = await this.decryptionCallback(event.args.votesHidden);
-            const parsedVotes = JSON.parse(decryptedVote);
-            return {
+                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,
-                votes: parsedVotes.map((v) => BigInt(v)),
-            };
-        }));
+            });
+            const decryptedVotes = await this.decryptVote(event.args.sealedBallotId, turnKey);
+            votes.push({
+                player: event.args.player,
+                votes: decryptedVotes,
+            });
+        }
         return votes;
     };
     /**
@@ -303,81 +710,50 @@ export class GameMaster {
             if (!Array.isArray(players)) {
                 throw new Error("Expected players to be an array");
             }
-            const oldProposals = [];
             const proposerIndices = [];
-            let votes = [];
-            //Proposals sequence is directly corresponding to proposers sequence
-            if (turn != 1n) {
-                const endedEvents = await this.publicClient.getContractEvents({
-                    address: instanceAddress,
-                    abi: RankifyDiamondInstanceAbi,
-                    eventName: "TurnEnded",
-                    args: { gameId, turn: turn - 1n },
-                });
-                const evt = endedEvents[0];
-                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.forEach((proposal, idx) => {
-                        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 {
-                    // Boundary case if no-one proposed a thing
-                    players.forEach((p, idx) => {
-                        oldProposals[idx] = {
-                            proposer: p,
-                            proposal: "",
-                        };
-                    });
-                }
-                votes = await this.decryptTurnVotes({ instanceAddress, gameId, turn }).then((voteSubmissions) => {
-                    const orderedVotes = players.map((player) => ({
-                        player,
-                        votes: new Array(players.length).fill(0n),
-                    }));
-                    players.forEach((player, playerIdx) => {
-                        const vote = voteSubmissions.find((v) => v.player === player);
-                        if (vote)
-                            orderedVotes[playerIdx] = vote;
-                        else
-                            orderedVotes[playerIdx] = {
-                                player,
-                                votes: new Array(players.length).fill(0n),
-                            };
-                    });
-                    return orderedVotes;
-                });
-            }
-            const newProposals = await this.decryptProposals({ instanceAddress, gameId, turn });
+            const oldProposals = await this.getProposalsVotedUpon({ instanceAddress, gameId, turn });
+            const decryptedProposals = await this.decryptProposals({ instanceAddress, gameId, turn });
+            const proposals = players.map((player) => {
+                const proposal = decryptedProposals.find((p) => p.proposer === player)?.proposal ?? "";
+                return {
+                    proposer: player,
+                    proposal,
+                };
+            });
             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 tableData = players.map((player, idx) => ({
                 player,
                 proposerIndex: proposerIndices[idx],
                 proposer: oldProposals[Number(proposerIndices[idx])].proposer,
             }));
             console.table(tableData);
-            const shuffled = await this.shuffle(newProposals.map((x) => x.proposal));
-            console.log(votes.map((v) => v.votes));
+            const attested = await this.getProposalsIntegrity({
+                gameId,
+                turn,
+                verifierAddress: instanceAddress,
+                size: players.length,
+                proposals,
+            });
+            logger(`votes:`);
+            logger(votes);
             const { request } = await this.publicClient.simulateContract({
                 abi: RankifyDiamondInstanceAbi,
                 account: this.walletClient.account,
                 address: instanceAddress,
                 functionName: "endTurn",
-                args: [gameId, votes.map((v) => v.votes), shuffled, proposerIndices],
+                args: [gameId, votes, attested.newProposals, attested.permutation, attested.nullifier],
             });
             return this.walletClient.writeContract(request);
         }
@@ -385,5 +761,301 @@ export class GameMaster {
             throw await handleRPCError(e);
         }
     };
+    gameKey = async ({ gameId, contractAddress }) => {
+        logger(`Signing game key for game ${gameId} at address ${contractAddress}`);
+        const message = encodePacked(["uint256", "address", "string"], [gameId, contractAddress, "gameKey"]);
+        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) => keccak256(sig));
+        logger(`Game key: ${gameKey}`, 2);
+        return gameKey;
+    };
+    calculateSharedTurnKey = async ({ instanceAddress, gameId, turn, player, }) => {
+        logger(`Calculating shared turn key for player ${player} in game ${gameId} at address ${instanceAddress}`);
+        const instance = new InstanceBase({ instanceAddress, publicClient: this.publicClient, chainId: this.chainId });
+        const playerPubKey = await instance.getPlayerPubKey({ instanceAddress, gameId, player });
+        logger(`Player public key: ${playerPubKey}`, 2);
+        return instance.sharedSigner({
+            publicKey: playerPubKey,
+            privateKey: await this.gameKey({ gameId, contractAddress: instanceAddress }),
+            gameId,
+            turn,
+            contractAddress: instanceAddress,
+            chainId: this.chainId,
+        });
+    };
+    decryptVote = async (vote, privateKey) => {
+        const decrypted = aes.decrypt(vote, privateKey).toString(cryptoJs.enc.Utf8);
+        if (!decrypted) {
+            throw new Error("Failed to decrypt vote");
+        }
+        try {
+            const parsed = JSON.parse(decrypted);
+            logger(`Decrypted vote:`, 2);
+            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
+     */
+    attestVote = async ({ voter, gameId, turn, vote, verifierAddress, }) => {
+        logger(`Attesting vote for player ${voter} in game ${gameId}, turn ${turn}`);
+        const gameSize = (await this.getPlayers({ instanceAddress: verifierAddress, gameId })).length;
+        const instance = new InstanceBase({
+            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 = keccak256(encodePacked(["uint256[]", "bytes32"], [vote, playerSalt]));
+        const turnKey = await this.calculateSharedTurnKey({
+            instanceAddress: verifierAddress,
+            gameId,
+            turn,
+            player: voter,
+        });
+        const ballotId = aes.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,
+        });
+        logger(`Vote attested for player ${voter} by ${this.walletClient.account?.address}`);
+        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
+     */
+    signVote = async (params) => {
+        const { voter, gameId, verifierAddress, sealedBallotId, ballotHash, name, version } = params;
+        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,
+        });
+        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
+     */
+    generateEndTurnIntegrity = async ({ gameId, turn, verifierAddress, size = 15, proposals, }) => {
+        const maxSize = 15;
+        const { permutation, secret: nullifier } = 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,
+            })));
+        const inputs = await this.createInputs({
+            numActive: size,
+            proposals: values.map((v) => v.proposalValue),
+            commitmentRandomnesses: values.map((v) => v.randomnessValue),
+            gameId,
+            turn,
+            verifierAddress,
+        });
+        logger(inputs, 2);
+        // Apply permutation to proposals array
+        const permutedProposals = [...proposals];
+        for (let i = 0; i < maxSize; i++) {
+            if (i < size) {
+                permutedProposals[Number(inputs.permutation[i])] = proposals[i];
+            }
+        }
+        const config = {
+            circuitName: "ProposalsIntegrity15",
+            // node_modules/rankify-contracts/zk_artifacts
+            circuitArtifactsPath: path.join(__dirname, "../../node_modules/rankify-contracts/zk_artifacts/circuits/proposals_integrity_15.circom/"),
+            verifierDirPath: path.join(__dirname, "../../node_modules/rankify-contracts/src/verifiers"),
+        };
+        const implementer = new Groth16Implementer();
+        const circuit = new CircuitZKit(config, implementer);
+        const proof = await circuit.generateProof(inputs);
+        const callData = await circuit.generateCalldata(proof);
+        // const circuit = await hre.zkit.getCircuit("ProposalsIntegrity15");
+        // const inputsKey = ethers.utils.solidityKeccak256(["string"], [JSON.stringify(inputs) + "groth16"]);
+        // let cached = loadFromCache(inputsKey);
+        // if (cached) {
+        // log(`Loaded proof from cache for inputsKey ${inputsKey}`, 2);
+        // } else {
+        // log(`Generating proof for inputsKey ${inputsKey}`, 2);
+        // const proof = await circuit.generateProof(inputs);
+        // saveToCache(inputsKey, proof);
+        // cached = proof;
+        // }
+        // const proof = "0x00";
+        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,
+            nullifier,
+            permutation: permutation.slice(0, size),
+            permutedProposals: permutedProposals.map((proposal) => proposal.proposal),
+            a,
+            b,
+            c,
+        };
+    };
+    /**
+     * 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, }) {
+        logger(`Generating proposals integrity for game ${gameId}, turn ${turn} with ${size} players.`);
+        const { commitment, nullifier, permutation, permutedProposals, a, b, c } = await this.generateEndTurnIntegrity({
+            gameId,
+            turn,
+            verifierAddress,
+            size,
+            proposals,
+        });
+        logger(`Generated proposals integrity with commitment ${commitment}`);
+        return {
+            newProposals: {
+                a,
+                b,
+                c,
+                proposals: permutedProposals,
+                permutationCommitment: commitment,
+            },
+            permutation: permutation.map((p) => BigInt(p)),
+            proposalsNotPermuted: proposals.map((proposal) => proposal.proposal),
+            nullifier,
+        };
+    }
+    /**
+     * 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
+     */
+    createInputs = async ({ numActive, proposals, commitmentRandomnesses, gameId, turn, verifierAddress, }) => {
+        const poseidon = await 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);
+        // Generate deterministic permutation
+        const { permutation, secret, commitment } = await this.generateDeterministicPermutation({
+            gameId,
+            turn,
+            verifierAddress,
+            size: numActive,
+        });
+        // Fill arrays with values
+        for (let i = 0; i < maxSize; 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 {
+                // 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,
+        };
+    };
 }
 //# sourceMappingURL=GameMaster.js.map