Add in-browser delegation demo to Mina template

mina/cli/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@game/cli",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "build/src/index.js",
+  "types": "build/src/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prestart": "npm run build",
+    "start": "node --enable-source-maps build/run.js"
+  },
+  "dependencies": {
+    "o1js": "^1.6.0",
+    "viem": "^2.12.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3"
+  }
+}

mina/contracts/mina/src/run.ts → mina/cli/src/run.ts

@@ -9,33 +9,115 @@
  * Build the project: `$ npm run build`
  * Run with node:     `$ node build/src/run.js`.
  */
-import { Sudoku, SudokuZkApp } from './sudoku.js';
-import { cloneSudoku, generateSudoku, solveSudoku } from './sudoku-lib.js';
-import { AccountUpdate, Lightnet, Mina, PrivateKey, PublicKey, fetchAccount } from 'o1js';
+import { delegateEvmToMina, Ecdsa, Secp256k1, Sudoku, SudokuSolution, SudokuSolutionProof, SudokuZkApp, cloneSudoku, generateSudoku, solveSudoku } from '@game/mina-contracts';
+import paimaL2Abi from '@paima/evm-contracts/abi/PaimaL2Contract.json' with { type: 'json' };
+import assert from 'assert';
+import { AccountUpdate, Lightnet, Mina, PrivateKey, PublicKey, fetchAccount, verify } from 'o1js';
+import { createWalletClient, getContract, http, toHex } from 'viem';
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+import { anvil } from 'viem/chains';
 
-console.log('Event names:', Object.keys(SudokuZkApp.events));
-console.log('Compiling SudokuZkApp...');
-await SudokuZkApp.compile();
+const { DelegationCommand, DelegationCommandProgram, DelegationCommandProof } = delegateEvmToMina('Test: ');
 
 /** Scaling factor from human-friendly MINA amount to raw integer fee amount. */
 const MINA_TO_RAW_FEE = 1_000_000_000;
 
 // ----------------------------------------------------------------------------
 // Connect to Lightnet
 const lightnetAccountManagerEndpoint = 'http://localhost:8181';
-Mina.setActiveInstance(Mina.Network({
-  mina: 'http://localhost:8080/graphql',
-  lightnetAccountManager: lightnetAccountManagerEndpoint,
-}));
+Mina.setActiveInstance(
+  Mina.Network({
+    mina: 'http://localhost:8080/graphql',
+    lightnetAccountManager: lightnetAccountManagerEndpoint,
+  })
+);
+
+// ----------------------------------------------------------------------------
+// Compile
+console.log('Event names:', Object.keys(SudokuZkApp.events));
+console.log('Compiling ...');
+console.time('compile');
+//await SudokuSolution.compile();
+//await SudokuZkApp.compile();
+const { verificationKey } = await DelegationCommandProgram.compile();
+console.timeEnd('compile');
 
 let lightnetAccount;
 try {
+  // ----------------------------------------------------------------------------
+  // Connect to localhost Lightnet
   lightnetAccount = await Lightnet.acquireKeyPair({ lightnetAccountManagerEndpoint });
   const { publicKey: sender, privateKey: senderKey } = lightnetAccount;
 
   await Mina.waitForFunding(sender.toBase58());
   console.log('Sender balance:', Mina.activeInstance.getAccount(sender).balance.toBigInt());
 
+  // ----------------------------------------------------------------------------
+  const viemAccount = privateKeyToAccount(generatePrivateKey());
+  const delegationOrder = new DelegationCommand({
+    target: sender,
+    signer: Secp256k1.fromHex(viemAccount.publicKey),
+  });
+
+  const delegationSignature = Ecdsa.fromHex(await viemAccount.signMessage({ message: { raw: DelegationCommand.bytesToSign(delegationOrder) } }));
+
+  console.time('DelegationCommandProgram.sign');
+  const delegateProof = await DelegationCommandProgram.sign(
+    delegationOrder,
+    delegationSignature,
+  );
+  console.timeEnd('DelegationCommandProgram.sign');
+
+  console.time('DelegationCommandProgram.verify');
+  console.log(await DelegationCommandProgram.verify(delegateProof));
+  //console.log(await verify(delegateProof, verificationKey));
+  //console.log(await verify(delegateProof.toJSON(), verificationKey));
+  console.timeEnd('DelegationCommandProgram.verify');
+
+  // ----------------------------------------------------------------------------
+  const sudoku = generateSudoku(0.5);
+  const solution = solveSudoku(sudoku);
+  if (solution === undefined) throw Error('Failed to solve randomly generated puzzle');
+
+  // --------------------------------------------------------------------------
+  // Use a ZkProgram to prove the solution
+  console.log('Proving Sudoku solution...');
+  // ZkPrograms make recursion possible, and also allow proofs to be created
+  // and verified outside of the actual Mina blockchain transaction. We could
+  // serialize `JSON.stringify(proof.toJSON())` and send that wherever and the
+  // recipient could check it independently.
+  const proof = await SudokuSolution.solve(Sudoku.from(sudoku), Sudoku.from(solution));
+  const serializedProof = JSON.stringify(proof.toJSON());
+
+  console.log('serializedProof.length =', serializedProof.length);
+
+  console.log('Verifying deserialized proof...');
+  const deserializedProof = await SudokuSolutionProof.fromJSON(JSON.parse(serializedProof));
+  assert(await SudokuSolution.verify(deserializedProof));
+
+  // --------------------------------------------------------------------------
+  console.log('Posting proof to PaimaL2Contract');
+  {
+    const publicClient = createWalletClient({
+      // This is one of Hardhat's well-known test private keys.
+      account: privateKeyToAccount('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80'),
+      chain: anvil,
+      transport: http(),
+    });
+
+    const paimaL2 = getContract({
+      abi: paimaL2Abi,
+      address: '0x5FbDB2315678afecb367f032d93F642f64180aa3',  // Good for localhost only
+      client: publicClient,
+    });
+
+    const hash = await paimaL2.write.paimaSubmitGameInput([toHex(`sp|${serializedProof}`)], {
+      value: 1n,
+      gas: 1000000n,
+    });
+    console.log('Submitted hash:', hash);
+  }
+
   // ----------------------------------------------------------------------------
   // Initialize our SudokuZkApp instance pointing to the preordained address.
   // In a real project, DON'T hardcode keys.
@@ -102,15 +184,17 @@ try {
   // --------------------------------------------------------------------------
   // Reset the puzzle
 
-  const sudoku = generateSudoku(0.5);
   {
     console.log('Resetting puzzle: preparing...');
-    const tx = await Mina.transaction({
-      sender,
-      fee: 0.01 * MINA_TO_RAW_FEE,
-    }, async () => {
-      await zkApp.update(Sudoku.from(sudoku));
-    });
+    const tx = await Mina.transaction(
+      {
+        sender,
+        fee: 0.01 * MINA_TO_RAW_FEE,
+      },
+      async () => {
+        await zkApp.update(Sudoku.from(sudoku));
+      }
+    );
     console.log('Resetting puzzle: proving...');
     await tx.prove();
     console.log('Resetting puzzle: signing and sending...');
@@ -122,26 +206,41 @@ try {
   await fetchAccount({ publicKey: zkApp.address });
   console.log('Is the sudoku solved?', zkApp.isSolved.get().toBoolean());
 
-  let solution = solveSudoku(sudoku);
-  if (solution === undefined) throw Error('Failed to solve randomly generated puzzle');
-
   // --------------------------------------------------------------------------
   // Submit a wrong solution
-  let noSolution = cloneSudoku(solution);
+  const noSolution = cloneSudoku(solution);
   noSolution[0][0] = (noSolution[0][0] % 9) + 1;
 
-  console.log('Submitting wrong solution...');
+  // Skip attempting to generate a SudokuSolution.solve proof for this solution
+  // because it breaks `zkApp.isSolved.get().toBoolean()` below... somehow
+  /*
+  console.log('Attempting to prove wrong solution...');
+  assert.rejects(async () => {
+    await SudokuSolution.solve(Sudoku.from(sudoku), Sudoku.from(noSolution));
+  });
+  */
+
+  console.log('Attempting to submit invalid proof...');
+  const incorrectProof = new SudokuSolutionProof({
+    ...proof,
+    // Make the correct proof invalid by attempting to repurpose it for a
+    // different Sudoku puzzle.
+    publicInput: Sudoku.from(generateSudoku(0.5)),
+  });
   try {
-    let tx = await Mina.transaction({
-      sender,
-      fee: 0.01 * MINA_TO_RAW_FEE,
-    }, async () => {
-      await zkApp.submitSolution(Sudoku.from(sudoku), Sudoku.from(noSolution));
-    });
+    let tx = await Mina.transaction(
+      {
+        sender,
+        fee: 0.01 * MINA_TO_RAW_FEE,
+      },
+      async () => {
+        await zkApp.submitSolutionProof(incorrectProof);
+      }
+    );
     await tx.prove();
     await tx.sign([senderKey]).send();
   } catch (err) {
-    console.log('There was an error submitting the solution, as expected', err);
+    console.log('There was an error submitting the solution, as expected');
   }
 
   await fetchAccount({ publicKey: zkApp.address });
@@ -151,12 +250,17 @@ try {
   // Submit the actual solution
   {
     console.log('Submitting solution: preparing...');
-    const tx = await Mina.transaction({
-      sender,
-      fee: 0.01 * MINA_TO_RAW_FEE,
-    }, async () => {
-      await zkApp.submitSolution(Sudoku.from(sudoku), Sudoku.from(solution!));
-    });
+    const tx = await Mina.transaction(
+      {
+        sender,
+        fee: 0.01 * MINA_TO_RAW_FEE,
+      },
+      async () => {
+        // The proof object bundles the public input (puzzle to be solved) so we
+        // don't need to pass it again.
+        await zkApp.submitSolutionProof(proof);
+      }
+    );
     console.log('Submitting solution: proving...');
     await tx.prove();
     console.log('Submitting solution: signing and sending...');

mina/cli/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "build",
+
+    "target": "es2020",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+  },
+  "include": ["src/**/*"],
+  "references": [
+    { "path": "../utils" },
+    { "path": "../game-logic" },
+    { "path": "../api" },
+    { "path": "../db" },
+    { "path": "../contracts/mina" }
+  ]
+}

mina/contracts/mina/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "sudoku",
+  "name": "@game/mina-contracts",
   "version": "0.1.0",
   "description": "",
   "author": "",
@@ -24,6 +24,10 @@
     "lint:fix": "npm run lint -- --fix",
     "start": "node build/src/run.js"
   },
+  "dependencies": {
+    "@paima/mina-delegation": "^3.1.0",
+    "o1js": "^1.6.0"
+  },
   "devDependencies": {
     "@types/jest": "^29.5.11",
     "@typescript-eslint/eslint-plugin": "^7.10.0",
@@ -35,9 +39,6 @@
     "ts-jest": "^29.1.1",
     "typescript": "^5.3.3"
   },
-  "peerDependencies": {
-    "o1js": "^1.3.0"
-  },
   "engines": {
     "node": ">=18.14.0"
   }

mina/contracts/mina/src/index.ts

@@ -1,3 +1,4 @@
-import { SudokuZkApp } from './sudoku.js';
-
-export { SudokuZkApp };
+export { Sudoku, SudokuSolution, SudokuSolutionProof, SudokuZkApp } from './sudoku.js';
+export { cloneSudoku, generateSudoku, solveSudoku } from './sudoku-lib.js';
+export * from '@paima/mina-delegation';
+export type * from '@paima/mina-delegation';

mina/contracts/mina/src/sudoku.test.ts

@@ -1,5 +1,5 @@
-import { Sudoku, SudokuZkApp } from './sudoku';
-import { cloneSudoku, generateSudoku, solveSudoku } from './sudoku-lib';
+import { Sudoku, SudokuSolution, SudokuZkApp } from './sudoku.js';
+import { cloneSudoku, generateSudoku, solveSudoku } from './sudoku-lib.js';
 import { PrivateKey, PublicKey, Mina, AccountUpdate } from 'o1js';
 
 describe('sudoku', () => {
@@ -10,6 +10,11 @@ describe('sudoku', () => {
     sender: Mina.TestPublicKey,
     senderKey: PrivateKey;
 
+  it('compiles', async () => {
+    await SudokuSolution.compile();
+    await SudokuZkApp.compile();
+  });
+
   beforeEach(async () => {
     let Local = await Mina.LocalBlockchain({ proofsEnabled: false });
     Mina.setActiveInstance(Local);
@@ -31,7 +36,8 @@ describe('sudoku', () => {
     if (solution === undefined) throw Error('cannot happen');
     let tx = await Mina.transaction(sender, async () => {
       let zkApp = new SudokuZkApp(zkAppAddress);
-      await zkApp.submitSolution(Sudoku.from(sudoku), Sudoku.from(solution!));
+      let proof = await SudokuSolution.solve(Sudoku.from(sudoku), Sudoku.from(solution));
+      await zkApp.submitSolutionProof(proof);
     });
     await tx.prove();
     await tx.sign([senderKey]).send();
@@ -52,10 +58,7 @@ describe('sudoku', () => {
     await expect(async () => {
       let tx = await Mina.transaction(sender, async () => {
         let zkApp = new SudokuZkApp(zkAppAddress);
-        await zkApp.submitSolution(
-          Sudoku.from(sudoku),
-          Sudoku.from(noSolution)
-        );
+        await zkApp.submitSolution(Sudoku.from(sudoku), Sudoku.from(noSolution));
       });
       await tx.prove();
       await tx.sign([senderKey]).send();