From 0104873f5a5031eba38335cf5dd05baff26f9dbe Mon Sep 17 00:00:00 2001 From: BoHsuu <115441679+Huygon764@users.noreply.github.com> Date: Wed, 11 Mar 2026 15:41:32 +0700 Subject: [PATCH 01/18] refactor: improve layout and responsiveness in Quest and Batch components (#200) - Updated QuestPage layout for better responsiveness with max-width and padding adjustments. - Changed BatchTransactions and TransactionSummary components to use flexbox for improved item alignment and responsiveness. - Enhanced QuestCard to allow for flexible width. - Added titles for new routes in the Title component. --- .../components/Batch/BatchContainer.tsx | 6 +--- .../components/Batch/TransactionSummary.tsx | 31 +++++-------------- 2 files changed, 9 insertions(+), 28 deletions(-) diff --git a/packages/nextjs/components/Batch/BatchContainer.tsx b/packages/nextjs/components/Batch/BatchContainer.tsx index e8ccad3..c519e4d 100644 --- a/packages/nextjs/components/Batch/BatchContainer.tsx +++ b/packages/nextjs/components/Batch/BatchContainer.tsx @@ -179,11 +179,7 @@ function BatchTransactions({ {/* Recipient */}
{matchedContact ? ( - +
= ({
{/* Header Section */}
- Batch transactions + Batch transactions
Transactions summary @@ -54,7 +54,10 @@ const TransactionSummary: React.FC = ({ ); return ( -
+
{/* Amount with Token Icon */}
{transaction.tokenIcon && ( @@ -70,26 +73,14 @@ const TransactionSummary: React.FC = ({ {/* Arrow */}
- Arrow Right + Arrow Right
{/* Recipient */}
{matchedContact ? (
- avatar + avatar {matchedContact.name} {"(" + `${formatAddress(transaction.recipient, { start: 3, end: 3 }) + ")"}`} @@ -97,13 +88,7 @@ const TransactionSummary: React.FC = ({
) : ( - avatar + avatar {formatAddress(transaction.recipient, { start: 3, end: 3 })} )} From d85d0e0d453ace0a5c734ea466ecbd2f456d5206 Mon Sep 17 00:00:00 2001 From: BoHsuu <115441679+Huygon764@users.noreply.github.com> Date: Wed, 11 Mar 2026 16:27:44 +0700 Subject: [PATCH 02/18] Refactor/extract magic numbers to constants (#203) * refactor: adjust z-index values across various components for improved UI layering * feat: add timing constants for HTTP timeouts, cache TTL, and retry delays - Introduced new timing constants in `timing.ts` for backend and nextjs packages. - Updated index files to export the new timing constants for better accessibility. refactor: replace hardcoded values with timing constants for retries and timeouts - Updated various services and modules to utilize new timing constants for retries and timeouts, improving maintainability and consistency across the codebase. - Adjusted `waitForReceiptWithRetry`, `PriceService`, `ZenTransferService`, `TransactionService`, and `ZkVerifyService` to use centralized timing configurations. refactor: replace hardcoded values with timing constants across components and hooks - Updated various components and hooks to utilize new timing constants for polling intervals, refetch intervals, and timeouts, enhancing maintainability and consistency throughout the codebase. - Adjusted `NotificationItem`, `ClaimSection`, `EditAccountModal`, and several hooks to reference centralized timing configurations. refactor: standardize formatting and improve component styles - Refactored various components to enhance code readability by standardizing formatting, including consistent indentation and spacing. - Updated styles across components to utilize new shadow and height constants for improved UI consistency. - Adjusted text sizes in multiple components to ensure uniformity in typography. --- packages/nextjs/services/api/apiClient.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/packages/nextjs/services/api/apiClient.ts b/packages/nextjs/services/api/apiClient.ts index cc8ed2c..12f469b 100644 --- a/packages/nextjs/services/api/apiClient.ts +++ b/packages/nextjs/services/api/apiClient.ts @@ -4,6 +4,7 @@ import axios, { AxiosError, AxiosInstance, AxiosResponse, InternalAxiosRequestCo import { API_BASE_URL } from "~~/constants"; import { API_TIMEOUT_DEFAULT, API_TIMEOUT_ZK } from "~~/constants/timing"; import { formatErrorMessage } from "~~/utils/formatError"; +import { API_TIMEOUT_DEFAULT, API_TIMEOUT_ZK } from "~~/constants/timing"; const AUTHORIZATION_HEADER = (accessToken: string) => `Bearer ${accessToken}`; From 8ac49ea38555d9ecfa843c5e8b5dceee4127a092 Mon Sep 17 00:00:00 2001 From: BoHsuu <115441679+Huygon764@users.noreply.github.com> Date: Wed, 11 Mar 2026 17:29:00 +0700 Subject: [PATCH 03/18] refactor: enhance component structure and user feedback in NewAccount sections (#206) - Updated ChooseNetwork component to include wallet connection checks and commitment validation, enhancing user experience with appropriate notifications. - Adjusted StatusContainer to allow copying of commitment addresses to clipboard for better usability. - Enhanced Sidebar component to incorporate wallet connection status in navigation logic. --- .../components/Batch/BatchContainer.tsx | 6 +++- .../components/Batch/TransactionSummary.tsx | 31 ++++++++++++++----- packages/nextjs/services/api/apiClient.ts | 1 - 3 files changed, 28 insertions(+), 10 deletions(-) diff --git a/packages/nextjs/components/Batch/BatchContainer.tsx b/packages/nextjs/components/Batch/BatchContainer.tsx index c519e4d..e8ccad3 100644 --- a/packages/nextjs/components/Batch/BatchContainer.tsx +++ b/packages/nextjs/components/Batch/BatchContainer.tsx @@ -179,7 +179,11 @@ function BatchTransactions({ {/* Recipient */}
{matchedContact ? ( - +
= ({
{/* Header Section */}
- Batch transactions + Batch transactions
Transactions summary @@ -54,10 +54,7 @@ const TransactionSummary: React.FC = ({ ); return ( -
+
{/* Amount with Token Icon */}
{transaction.tokenIcon && ( @@ -73,14 +70,26 @@ const TransactionSummary: React.FC = ({ {/* Arrow */}
- Arrow Right + Arrow Right
{/* Recipient */}
{matchedContact ? (
- avatar + avatar {matchedContact.name} {"(" + `${formatAddress(transaction.recipient, { start: 3, end: 3 }) + ")"}`} @@ -88,7 +97,13 @@ const TransactionSummary: React.FC = ({
) : ( - avatar + avatar {formatAddress(transaction.recipient, { start: 3, end: 3 })} )} diff --git a/packages/nextjs/services/api/apiClient.ts b/packages/nextjs/services/api/apiClient.ts index 12f469b..cc8ed2c 100644 --- a/packages/nextjs/services/api/apiClient.ts +++ b/packages/nextjs/services/api/apiClient.ts @@ -4,7 +4,6 @@ import axios, { AxiosError, AxiosInstance, AxiosResponse, InternalAxiosRequestCo import { API_BASE_URL } from "~~/constants"; import { API_TIMEOUT_DEFAULT, API_TIMEOUT_ZK } from "~~/constants/timing"; import { formatErrorMessage } from "~~/utils/formatError"; -import { API_TIMEOUT_DEFAULT, API_TIMEOUT_ZK } from "~~/constants/timing"; const AUTHORIZATION_HEADER = (accessToken: string) => `Bearer ${accessToken}`; From 8d8f44c7dc661ff09b81aa9cdec67f8febb0f0a9 Mon Sep 17 00:00:00 2001 From: BoHsuu <115441679+Huygon764@users.noreply.github.com> Date: Thu, 12 Mar 2026 15:56:45 +0700 Subject: [PATCH 04/18] Test/staging smoke test script (#205) * Refactor test * feat: enhance transaction E2E tests to support multi-asset transfers - Added support for ETH, ZEN, and USDC in transaction flow tests. - Introduced utility functions for ERC20 token transfers and balance checks. - Refactored account funding logic to accommodate multiple asset scenarios. - Updated test descriptions for clarity and consistency. * Add batch to e2e flow * Refactor test local * Change log for human read * clean up unused code * Test for staging * Change address ZEN token of horizen testnet * Refactor for DRY --- packages/backend/.env.example | 5 + packages/backend/package.json | 1 + .../backend/test/e2e/transaction.e2e-spec.ts | 499 ++++++++++-------- .../test/e2e/transaction.staging.e2e-spec.ts | 345 ++++++++++++ packages/backend/test/jest-e2e.json | 2 +- packages/backend/test/jest-staging-e2e.json | 19 + packages/backend/test/jest.setup.ts | 10 +- packages/backend/test/utils/identity.util.ts | 34 ++ .../test/utils/multi-asset-flow.shared.ts | 231 ++++++++ .../backend/test/utils/staging-api.util.ts | 197 +++++++ .../backend/test/utils/transaction.util.ts | 250 +++++++++ packages/shared/src/constants/token.ts | 2 +- 12 files changed, 1373 insertions(+), 222 deletions(-) create mode 100644 packages/backend/test/e2e/transaction.staging.e2e-spec.ts create mode 100644 packages/backend/test/jest-staging-e2e.json create mode 100644 packages/backend/test/utils/identity.util.ts create mode 100644 packages/backend/test/utils/multi-asset-flow.shared.ts create mode 100644 packages/backend/test/utils/staging-api.util.ts create mode 100644 packages/backend/test/utils/transaction.util.ts diff --git a/packages/backend/.env.example b/packages/backend/.env.example index 0b766a9..930dcd6 100644 --- a/packages/backend/.env.example +++ b/packages/backend/.env.example @@ -1,3 +1,8 @@ +# E2E / Testing +# -------------- +# Base URL for staging backend used by transaction.staging.e2e-spec.ts +STAGING_API_BASE_URL=https://api.testnet.polypay.pro + # Database DATABASE_URL="postgresql://polypay_user:polypay_password@localhost:5433/polypay_multisig_db" diff --git a/packages/backend/package.json b/packages/backend/package.json index f9d5e92..e00b7e2 100644 --- a/packages/backend/package.json +++ b/packages/backend/package.json @@ -18,6 +18,7 @@ "test:cov": "jest --coverage", "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand", "test:e2e": "jest --config ./test/jest-e2e.json", + "test:e2e:staging": "jest --config ./test/jest-staging-e2e.json", "report": "ts-node scripts/generate-analytics-report.ts" }, "dependencies": { diff --git a/packages/backend/test/e2e/transaction.e2e-spec.ts b/packages/backend/test/e2e/transaction.e2e-spec.ts index f2dbb9c..c5b6b2e 100644 --- a/packages/backend/test/e2e/transaction.e2e-spec.ts +++ b/packages/backend/test/e2e/transaction.e2e-spec.ts @@ -1,45 +1,45 @@ -import * as request from 'supertest'; -import { type Hex, formatEther } from 'viem'; import { + resetDatabase, setupTestApp, teardownTestApp, - resetDatabase, - getHttpServer, - getTestApp, } from '../setup'; import { getSignerA, getSignerB } from '../fixtures/test-users'; -import { createTestSigner, TestSigner } from '../utils/signer.util'; -import { - generateSecret, - generateCommitment, - generateTestProof, -} from '../utils/proof.util'; +import { loginUser, AuthTokens } from '../utils/auth.util'; +import { TestIdentity, createTestIdentity } from '../utils/identity.util'; import { - depositToAccount, - getTransactionHash, - getAccountBalance, -} from '../utils/contract.util'; -import { getPrismaService } from '../utils/cleanup.util'; -import { loginUser, getAuthHeader, AuthTokens } from '../utils/auth.util'; + apiCreateAccount, + apiCreateBatchItem, + apiReserveNonce, + apiCreateTransaction, + apiApproveTransaction, + apiExecuteTransaction, + apiGetTransaction, + generateVotePayload, +} from '../utils/transaction.util'; +import { CreateAccountDto, TxStatus, TxType } from '@polypay/shared'; import { - API_ENDPOINTS, - CreateAccountDto, - TxStatus, - TxType, -} from '@polypay/shared'; - -// Timeout 5 minutes for blockchain calls -jest.setTimeout(600000); + TEST_CHAIN_ID, + TEST_RECIPIENT, + TEST_THRESHOLD, + TEST_TRANSFER_AMOUNT, + SCENARIOS, + type CreatedTx, + type ScenarioAmount, + type ParsedBatchItem, + getCreatedTxLabel, + buildSingleTransferParams, + buildSingleApproveParams, + buildBatchCallData, + buildBatchCallDataFromParsed, + fundAccountForScenario, +} from '../utils/multi-asset-flow.shared'; + +// Timeout 20 minutes for blockchain calls +jest.setTimeout(1200000); describe('Transaction E2E', () => { - let signerA: TestSigner; - let signerB: TestSigner; - let secretA: bigint; - let secretB: bigint; - let commitmentA: string; - let commitmentB: string; - let signerDtoA: any; - let signerDtoB: any; + let identityA: TestIdentity; + let identityB: TestIdentity; let tokensA: AuthTokens; let tokensB: AuthTokens; @@ -47,43 +47,15 @@ describe('Transaction E2E', () => { // Setup NestJS app await setupTestApp(); - // Setup test signers - signerA = createTestSigner(getSignerA()); - signerB = createTestSigner(getSignerB()); - - // Generate secrets and commitments - secretA = await generateSecret(signerA); - secretB = await generateSecret(signerB); - - const commitmentABigInt = await generateCommitment(secretA); - const commitmentBBigInt = await generateCommitment(secretB); - - commitmentA = commitmentABigInt.toString(); - commitmentB = commitmentBBigInt.toString(); - signerDtoA = { - commitment: commitmentA, - name: 'Signer A', - }; - signerDtoB = { - commitment: commitmentB, - name: 'Signer B', - }; - - console.log('Test setup complete:'); - console.log(' Signer A address:', signerA.address); - console.log(' Signer B address:', signerB.address); - console.log(' Commitment A:', commitmentA); - console.log(' Commitment B:', commitmentB); + identityA = await createTestIdentity(getSignerA, 'Signer A'); + identityB = await createTestIdentity(getSignerB, 'Signer B'); }); beforeEach(async () => { await resetDatabase(); // Login both users - console.log('\n--- Login Users ---'); - tokensA = await loginUser(secretA, commitmentA); - tokensB = await loginUser(secretB, commitmentB); - console.log(' User A logged in'); - console.log(' User B logged in'); + tokensA = await loginUser(identityA.secret, identityA.commitment); + tokensB = await loginUser(identityB.secret, identityB.commitment); }); afterAll(async () => { @@ -91,171 +63,262 @@ describe('Transaction E2E', () => { }); describe('Full transaction flow', () => { - it('should complete full flow: create account → create tx → approve → execute', async () => { - const server = getHttpServer(); + it('should complete full flow for ETH, ZEN and USDC transfers', async () => { + console.log('\n=== Multi-asset Transaction E2E: Start ==='); // ============ STEP 1: Create Account ============ - console.log('\n--- Step 1: Create Account ---'); - + console.log('Phase 1: Create Account - start'); + const createdAt = new Date().toISOString().replace('T', ' ').slice(0, 19); const dataCreateAccount: CreateAccountDto = { - name: 'Test Multi-Sig Account', - signers: [signerDtoA, signerDtoB], - threshold: 2, - chainId: 2651420, + name: `Multi-Sig Account ${createdAt}`, + signers: [identityA.signerDto, identityB.signerDto], + threshold: TEST_THRESHOLD, + chainId: TEST_CHAIN_ID, }; - const accountResponse = await request(server) - .post(API_ENDPOINTS.accounts.base) - .set(getAuthHeader(tokensA.accessToken)) - .send(dataCreateAccount) - .expect(201); - - expect(accountResponse.body).toHaveProperty('address'); - - const accountAddress = accountResponse.body.address as `0x${string}`; - console.log('Account created:'); - console.log(' Address:', accountAddress); - - // ============ STEP 2: Deposit ETH to Account ============ - console.log('\n--- Step 2: Deposit ETH to Account ---'); - - const balanceBefore = await getAccountBalance(accountAddress); - console.log(' Balance before:', formatEther(balanceBefore), 'ETH'); - - await depositToAccount(signerA, accountAddress, '0.001'); - - const balanceAfter = await getAccountBalance(accountAddress); - console.log(' Balance after:', formatEther(balanceAfter), 'ETH'); - - expect(balanceAfter).toBeGreaterThan(balanceBefore); - - // ============ STEP 3: Create Transaction ============ - console.log('\n--- Step 3: Create Transaction ---'); - - // 3.1 Reserve nonce - const reserveNonceResponse = await request(server) - .post(API_ENDPOINTS.transactions.reserveNonce) - .set(getAuthHeader(tokensA.accessToken)) - .send({ accountAddress }) - .expect(201); - - const nonce = reserveNonceResponse.body.nonce; - console.log(' Reserved nonce:', nonce); - - // 3.2 Prepare transfer params - const recipient = - '0x87142a49c749dD05069836F9B81E5579E95BE0A6' as `0x${string}`; - const value = BigInt('1000000000000000'); // 0.001 ETH - const callData = '0x' as Hex; - - // 3.3 Get txHash from contract - const txHash = await getTransactionHash( - accountAddress, - BigInt(nonce), - recipient, - value, - callData, + const { address: accountAddress } = await apiCreateAccount( + tokensA.accessToken, + dataCreateAccount, ); - console.log(' TxHash from contract:', txHash); - - // 3.4 Generate proof for signer A - console.log(' Generating proof for Signer A...'); - const proofA = await generateTestProof(signerA, secretA, txHash); - console.log(' Proof A generated'); - - // 3.5 Create transaction - const createTxResponse = await request(server) - .post(API_ENDPOINTS.transactions.base) - .set(getAuthHeader(tokensA.accessToken)) - .send({ - nonce: nonce, + console.log('Phase 1: Create Account - done', { + accountAddress, + }); + + // ============ STEP 2: Fund account for all scenarios ============ + console.log('Phase 2: Fund account for all scenarios - start'); + const scenarioAmounts: ScenarioAmount[] = []; + + for (const scenario of SCENARIOS) { + console.log(`[${scenario.name}] Funding start`); + const funded = await fundAccountForScenario( + scenario, + accountAddress, + identityA, + ); + scenarioAmounts.push(funded); + console.log(`[${scenario.name}] Funding recorded`, { + amount: TEST_TRANSFER_AMOUNT, + }); + } + console.log('Phase 2: Fund account for all scenarios - done'); + + // ============ STEP 3: Create Transactions (3 single + 1 batch) ============ + console.log('Phase 3: Create transactions - start'); + const createdTxs: CreatedTx[] = []; + + // 3 single transfers (ETH, ZEN, USDC) + for (const amount of scenarioAmounts) { + console.log(`[${amount.scenario.name}] Create single transaction - start`); + + const { nonce } = await apiReserveNonce( + tokensA.accessToken, + accountAddress, + ); + + const { to, value, callData } = buildSingleTransferParams( + amount, + TEST_RECIPIENT, + ); + + const votePayloadA = await generateVotePayload( + identityA, + accountAddress, + BigInt(nonce), + to, + value, + callData, + ); + + const { txId } = await apiCreateTransaction(tokensA.accessToken, { + nonce, type: TxType.TRANSFER, - accountAddress: accountAddress, - to: recipient, - value: value.toString(), - threshold: 2, - creatorCommitment: commitmentA, - proof: proofA.proof, - publicInputs: proofA.publicInputs, - nullifier: proofA.nullifier, - }) - .expect(201); - - const txId = createTxResponse.body.txId; - console.log(' Transaction created, txId:', txId); - - // ============ STEP 4: Approve Transaction (Signer B) ============ - console.log('\n--- Step 4: Approve Transaction (Signer B) ---'); - - // 4.1 Get transaction details - const getTxResponse = await request(server) - .get(API_ENDPOINTS.transactions.byTxId(txId)) - .set(getAuthHeader(tokensA.accessToken)) - .expect(200); - - console.log(' Transaction status:', getTxResponse.body.status); - - // 4.2 Get txHash for approve - const txHashForApprove = await getTransactionHash( + accountAddress, + to: TEST_RECIPIENT, + value: amount.amountString, + threshold: TEST_THRESHOLD, + proof: votePayloadA.proof, + publicInputs: votePayloadA.publicInputs, + nullifier: votePayloadA.nullifier, + ...(amount.scenario.isNative + ? {} + : { tokenAddress: amount.scenario.tokenAddress as `0x${string}` }), + }); + + createdTxs.push({ kind: 'single', scenario: amount.scenario, amount, txId }); + console.log(`[${amount.scenario.name}] Create single transaction - done`, { + txId, + }); + } + + // 1 batch tx (ETH + ZEN + USDC, same amounts) + console.log('Batch: Create batch items - start'); + const batchItemIds: string[] = []; + for (const amount of scenarioAmounts) { + const item = await apiCreateBatchItem(tokensA.accessToken, { + recipient: TEST_RECIPIENT, + amount: amount.amountString, + tokenAddress: amount.scenario.isNative + ? undefined + : (amount.scenario.tokenAddress as string), + }); + batchItemIds.push(item.id); + } + console.log('Batch: Create batch items - done', { batchItemIds }); + + const batchCallData = buildBatchCallData(scenarioAmounts, TEST_RECIPIENT); + + const { nonce: batchNonce } = await apiReserveNonce( + tokensA.accessToken, accountAddress, - BigInt(getTxResponse.body.nonce), - getTxResponse.body.to as `0x${string}`, - BigInt(getTxResponse.body.value), - callData, ); - // 4.3 Generate proof for signer B - console.log(' Generating proof for Signer B...'); - const proofB = await generateTestProof( - signerB, - secretB, - txHashForApprove, + const batchVotePayloadA = await generateVotePayload( + identityA, + accountAddress, + BigInt(batchNonce), + accountAddress as `0x${string}`, + 0n, + batchCallData, ); - console.log(' Proof B generated'); - - // 4.4 Approve transaction - await request(server) - .post(API_ENDPOINTS.transactions.approve(txId)) - .set(getAuthHeader(tokensB.accessToken)) - .send({ - voterCommitment: commitmentB, - proof: proofB.proof, - publicInputs: proofB.publicInputs, - nullifier: proofB.nullifier, - }) - .expect(201); - - console.log(' Transaction approved by Signer B'); - - // ============ STEP 5: Execute Transaction ============ - console.log('\n--- Step 5: Execute Transaction ---'); - const executeResponse = await request(server) - .post(API_ENDPOINTS.transactions.execute(txId)) - .set(getAuthHeader(tokensA.accessToken)) - .expect(201); - - expect(executeResponse.body).toHaveProperty('txHash'); - console.log(' Execute TxHash:', executeResponse.body.txHash); - - // ============ STEP 6: Verify Final State ============ - console.log('\n--- Step 6: Verify Final State ---'); - - const prisma = getPrismaService(getTestApp()); - - const finalTx = await prisma.transaction.findUnique({ - where: { txId: txId }, - include: { votes: true }, - }); - - expect(finalTx).not.toBeNull(); - expect(finalTx!.status).toBe(TxStatus.EXECUTED); - expect(finalTx!.votes.length).toBe(2); - - console.log('Final verification:'); - console.log(' Status:', finalTx!.status); - console.log(' Vote count:', finalTx!.votes.length); - console.log('\n✅ Full transaction flow completed successfully!'); + const { txId: batchTxId } = await apiCreateTransaction( + tokensA.accessToken, + { + nonce: batchNonce, + type: TxType.BATCH, + accountAddress, + to: accountAddress, + value: '0', + threshold: TEST_THRESHOLD, + proof: batchVotePayloadA.proof, + publicInputs: batchVotePayloadA.publicInputs, + nullifier: batchVotePayloadA.nullifier, + batchItemIds, + }, + ); + createdTxs.push({ kind: 'batch', txId: batchTxId }); + console.log('Batch: Create batch transaction - done', { batchTxId }); + + console.log('Phase 3: Create transactions - done'); + + // ============ STEP 4: Approve all 4 Transactions (Signer B) ============ + console.log('Phase 4: Approve transactions - start'); + for (const entry of createdTxs) { + const txId = entry.txId; + const label = getCreatedTxLabel(entry); + console.log(`[${label}] Approve transaction - start`, { txId }); + + const txDetails = (await apiGetTransaction( + tokensA.accessToken, + txId, + )) as { + nonce: number; + to?: string; + value?: string; + tokenAddress?: string | null; + batchData?: string; + }; + + if (entry.kind === 'batch') { + if (txDetails.batchData == null) { + throw new Error(`Batch tx ${txId} missing batchData`); + } + const parsedBatch = JSON.parse(txDetails.batchData) as ParsedBatchItem[]; + const callDataApprove = buildBatchCallDataFromParsed(parsedBatch); + + const votePayloadB = await generateVotePayload( + identityB, + accountAddress, + BigInt(txDetails.nonce), + accountAddress as `0x${string}`, + 0n, + callDataApprove, + ); + await apiApproveTransaction( + tokensB.accessToken, + txId, + votePayloadB, + ); + } else { + const { to: toApprove, value: valueApprove, callData: callDataApprove } = + buildSingleApproveParams(txDetails); + + const votePayloadB = await generateVotePayload( + identityB, + accountAddress, + BigInt(txDetails.nonce), + toApprove, + valueApprove, + callDataApprove, + ); + await apiApproveTransaction( + tokensB.accessToken, + txId, + votePayloadB, + ); + } + + console.log(`[${label}] Approve transaction - done`, { txId }); + } + console.log('Phase 4: Approve transactions - done'); + + // ============ STEP 5: Execute all 4 Transactions sequentially ============ + console.log('Phase 5: Execute transactions - start'); + for (const entry of createdTxs) { + const txId = entry.txId; + const label = getCreatedTxLabel(entry); + console.log(`[${label}] Execute transaction - start`, { txId }); + + const { txHash } = await apiExecuteTransaction( + tokensA.accessToken, + txId, + ); + expect(txHash).toBeDefined(); + + console.log(`[${label}] Execute transaction - done`, { txId, txHash }); + } + console.log('Phase 5: Execute transactions - done'); + + // ============ STEP 6: Verify Final State for all 4 transactions ============ + console.log('Phase 6: Verify final state - start'); + + for (const entry of createdTxs) { + const txId = entry.txId; + const label = getCreatedTxLabel(entry); + + const finalTx = (await apiGetTransaction( + tokensA.accessToken, + txId, + )) as { + status: TxStatus; + votes: unknown[]; + tokenAddress?: string | null; + value?: string; + } | null; + + expect(finalTx).not.toBeNull(); + expect(finalTx!.status).toBe(TxStatus.EXECUTED); + expect(finalTx!.votes.length).toBe(2); + + if (entry.kind === 'single') { + if (entry.scenario.isNative) { + expect(finalTx!.tokenAddress).toBeNull(); + } else { + expect(finalTx!.tokenAddress?.toLowerCase()).toBe( + (entry.scenario.tokenAddress as string).toLowerCase(), + ); + } + expect(finalTx!.value).toBe(entry.amount.amountString); + } + + console.log(`[${label}] Final verification - done`, { + status: finalTx?.status, + votes: finalTx?.votes.length, + }); + } + + console.log('Phase 6: Verify final state - done'); + console.log('=== Multi-asset Transaction E2E: Done ===\n'); }); }); }); diff --git a/packages/backend/test/e2e/transaction.staging.e2e-spec.ts b/packages/backend/test/e2e/transaction.staging.e2e-spec.ts new file mode 100644 index 0000000..472f4e3 --- /dev/null +++ b/packages/backend/test/e2e/transaction.staging.e2e-spec.ts @@ -0,0 +1,345 @@ +import { getSignerA, getSignerB } from '../fixtures/test-users'; +import { TestIdentity, createTestIdentity } from '../utils/identity.util'; +import { + stagingLogin, + stagingCreateAccount, + stagingReserveNonce, + stagingCreateTransaction, + stagingApproveTransaction, + stagingExecuteTransaction, + stagingGetTransaction, + stagingCreateBatchItem, +} from '../utils/staging-api.util'; +import { CreateAccountDto, TxStatus, TxType } from '@polypay/shared'; +import { generateVotePayload } from '../utils/transaction.util'; +import { + TEST_CHAIN_ID, + TEST_RECIPIENT, + TEST_THRESHOLD, + TEST_TRANSFER_AMOUNT, + SCENARIOS, + type CreatedTx, + type ScenarioAmount, + type ParsedBatchItem, + getCreatedTxLabel, + buildSingleTransferParams, + buildSingleApproveParams, + buildBatchCallData, + buildBatchCallDataFromParsed, + fundAccountForScenario, +} from '../utils/multi-asset-flow.shared'; + +async function waitForExecuted( + accessToken: string, + txId: string, + label: string, +): Promise { + const maxAttempts = 20; + const intervalMs = 15000; + + let lastStatus: string | undefined; + + for (let attempt = 1; attempt <= maxAttempts; attempt++) { + const tx = await stagingGetTransaction(accessToken, txId); + lastStatus = tx.status; + + if (tx.status === TxStatus.EXECUTED) { + return tx; + } + + console.log( + `[${label}] Waiting for EXECUTED - attempt ${attempt}, status=${tx.status}`, + ); + + if (attempt < maxAttempts) { + await new Promise((resolve) => setTimeout(resolve, intervalMs)); + } + } + + throw new Error( + `[${label}] Transaction ${txId} did not reach EXECUTED within timeout. Last status=${lastStatus}`, + ); +} + +// Timeout 20 minutes for blockchain calls +jest.setTimeout(1200000); + +describe('Transaction Staging E2E', () => { + let identityA: TestIdentity; + let identityB: TestIdentity; + let tokensA: { accessToken: string; refreshToken: string }; + let tokensB: { accessToken: string; refreshToken: string }; + + beforeAll(async () => { + identityA = await createTestIdentity(getSignerA, 'Signer A'); + identityB = await createTestIdentity(getSignerB, 'Signer B'); + }); + + beforeEach(async () => { + tokensA = await stagingLogin(identityA.secret, identityA.commitment); + tokensB = await stagingLogin(identityB.secret, identityB.commitment); + }); + + describe('Full transaction flow (staging)', () => { + it('should complete full flow for ETH, ZEN and USDC transfers + batch on staging', async () => { + console.log('\n=== Multi-asset Transaction E2E (Staging): Start ==='); + + // ============ STEP 1: Create Account ============ + console.log('Phase 1: Create Account - start'); + const createdAt = new Date().toISOString().replace('T', ' ').slice(0, 19); + const dataCreateAccount: CreateAccountDto = { + name: `Multi-Sig Account ${createdAt}`, + signers: [identityA.signerDto, identityB.signerDto], + threshold: TEST_THRESHOLD, + chainId: TEST_CHAIN_ID, + }; + + const { address: accountAddress } = await stagingCreateAccount( + tokensA.accessToken, + dataCreateAccount, + ); + console.log('Phase 1: Create Account - done', { + accountAddress, + }); + + // ============ STEP 2: Fund account for all scenarios ============ + console.log('Phase 2: Fund account for all scenarios - start'); + const scenarioAmounts: ScenarioAmount[] = []; + + for (const scenario of SCENARIOS) { + console.log(`[${scenario.name}] Funding start`); + const funded = await fundAccountForScenario( + scenario, + accountAddress, + identityA, + ); + scenarioAmounts.push(funded); + console.log(`[${scenario.name}] Funding recorded`, { + amount: TEST_TRANSFER_AMOUNT, + }); + } + console.log('Phase 2: Fund account for all scenarios - done'); + + // ============ STEP 3: Create Transactions (3 single + 1 batch) ============ + console.log('Phase 3: Create transactions - start'); + const createdTxs: CreatedTx[] = []; + + // 3 single transfers (ETH, ZEN, USDC) + for (const amount of scenarioAmounts) { + console.log(`[${amount.scenario.name}] Create single transaction - start`); + + const { nonce } = await stagingReserveNonce( + tokensA.accessToken, + accountAddress, + ); + + const { to, value, callData } = buildSingleTransferParams( + amount, + TEST_RECIPIENT, + ); + + const votePayloadA = await generateVotePayload( + identityA, + accountAddress, + BigInt(nonce), + to, + value, + callData, + ); + + const { txId } = await stagingCreateTransaction(tokensA.accessToken, { + nonce, + type: TxType.TRANSFER, + accountAddress, + to: TEST_RECIPIENT, + value: amount.amountString, + threshold: TEST_THRESHOLD, + proof: votePayloadA.proof, + publicInputs: votePayloadA.publicInputs, + nullifier: votePayloadA.nullifier, + ...(amount.scenario.isNative + ? {} + : { tokenAddress: amount.scenario.tokenAddress as `0x${string}` }), + }); + + createdTxs.push({ kind: 'single', scenario: amount.scenario, amount, txId }); + console.log(`[${amount.scenario.name}] Create single transaction - done`, { + txId, + }); + } + + // 1 batch tx (ETH + ZEN + USDC, same amounts) + console.log('Batch: Create batch items - start'); + const batchItemIds: string[] = []; + for (const amount of scenarioAmounts) { + const item = await stagingCreateBatchItem(tokensA.accessToken, { + recipient: TEST_RECIPIENT, + amount: amount.amountString, + tokenAddress: amount.scenario.isNative + ? undefined + : (amount.scenario.tokenAddress as string), + }); + batchItemIds.push(item.id); + } + console.log('Batch: Create batch items - done', { batchItemIds }); + + const batchCallData = buildBatchCallData( + scenarioAmounts, + TEST_RECIPIENT, + ); + + const { nonce: batchNonce } = await stagingReserveNonce( + tokensA.accessToken, + accountAddress, + ); + + const batchVotePayloadA = await generateVotePayload( + identityA, + accountAddress, + BigInt(batchNonce), + accountAddress as `0x${string}`, + 0n, + batchCallData, + ); + + const { txId: batchTxId } = await stagingCreateTransaction( + tokensA.accessToken, + { + nonce: batchNonce, + type: TxType.BATCH, + accountAddress, + to: accountAddress, + value: '0', + threshold: TEST_THRESHOLD, + proof: batchVotePayloadA.proof, + publicInputs: batchVotePayloadA.publicInputs, + nullifier: batchVotePayloadA.nullifier, + batchItemIds, + }, + ); + createdTxs.push({ kind: 'batch', txId: batchTxId }); + console.log('Batch: Create batch transaction - done', { batchTxId }); + + console.log('Phase 3: Create transactions - done'); + + // ============ STEP 4: Approve all 4 Transactions (Signer B) ============ + console.log('Phase 4: Approve transactions - start'); + for (const entry of createdTxs) { + const txId = entry.txId; + const label = getCreatedTxLabel(entry); + console.log(`[${label}] Approve transaction - start`, { txId }); + + const txDetails = (await stagingGetTransaction( + tokensA.accessToken, + txId, + )) as { + nonce: number; + to?: string; + value?: string; + tokenAddress?: string | null; + batchData?: string; + }; + + if (entry.kind === 'batch') { + if (txDetails.batchData == null) { + throw new Error(`Batch tx ${txId} missing batchData`); + } + const parsedBatch = JSON.parse(txDetails.batchData) as ParsedBatchItem[]; + const callDataApprove = buildBatchCallDataFromParsed(parsedBatch); + + const votePayloadB = await generateVotePayload( + identityB, + accountAddress, + BigInt(txDetails.nonce), + accountAddress as `0x${string}`, + 0n, + callDataApprove, + ); + await stagingApproveTransaction( + tokensB.accessToken, + txId, + votePayloadB, + ); + } else { + const { to: toApprove, value: valueApprove, callData: callDataApprove } = + buildSingleApproveParams(txDetails); + + const votePayloadB = await generateVotePayload( + identityB, + accountAddress, + BigInt(txDetails.nonce), + toApprove, + valueApprove, + callDataApprove, + ); + await stagingApproveTransaction( + tokensB.accessToken, + txId, + votePayloadB, + ); + } + + console.log(`[${label}] Approve transaction - done`, { txId }); + } + console.log('Phase 4: Approve transactions - done'); + + // ============ STEP 5: Execute all 4 Transactions sequentially ============ + console.log('Phase 5: Execute transactions - start'); + for (const entry of createdTxs) { + const txId = entry.txId; + const label = getCreatedTxLabel(entry); + console.log(`[${label}] Execute transaction - start`, { txId }); + + const { txHash } = await stagingExecuteTransaction( + tokensA.accessToken, + txId, + ); + expect(txHash).toBeDefined(); + + console.log(`[${label}] Execute transaction - done`, { txId, txHash }); + } + console.log('Phase 5: Execute transactions - done'); + + // ============ STEP 6: Verify Final State for all 4 transactions ============ + console.log('Phase 6: Verify final state - start'); + + for (const entry of createdTxs) { + const txId = entry.txId; + const label = getCreatedTxLabel(entry); + + const finalTx = (await waitForExecuted( + tokensA.accessToken, + txId, + label, + )) as { + status: TxStatus; + votes: unknown[]; + tokenAddress?: string | null; + value?: string; + } | null; + + expect(finalTx).not.toBeNull(); + expect(finalTx!.status).toBe(TxStatus.EXECUTED); + + if (entry.kind === 'single') { + if (entry.scenario.isNative) { + expect(finalTx!.tokenAddress).toBeNull(); + } else { + expect(finalTx!.tokenAddress?.toLowerCase()).toBe( + (entry.scenario.tokenAddress as string).toLowerCase(), + ); + } + expect(finalTx!.value).toBe(entry.amount.amountString); + } + + console.log(`[${label}] Final verification - done`, { + status: finalTx?.status, + }); + } + + console.log('Phase 6: Verify final state - done'); + console.log('=== Multi-asset Transaction E2E (Staging): Done ===\n'); + }); + }); +}); + diff --git a/packages/backend/test/jest-e2e.json b/packages/backend/test/jest-e2e.json index 85eb9f6..0fbc892 100644 --- a/packages/backend/test/jest-e2e.json +++ b/packages/backend/test/jest-e2e.json @@ -2,7 +2,7 @@ "moduleFileExtensions": ["js", "json", "ts"], "rootDir": ".", "testEnvironment": "node", - "testRegex": ".e2e-spec.ts$", + "testRegex": "transaction.e2e-spec.ts$", "transform": { "^.+\\.(t|j)s$": "ts-jest" }, diff --git a/packages/backend/test/jest-staging-e2e.json b/packages/backend/test/jest-staging-e2e.json new file mode 100644 index 0000000..8165d84 --- /dev/null +++ b/packages/backend/test/jest-staging-e2e.json @@ -0,0 +1,19 @@ +{ + "moduleFileExtensions": ["js", "json", "ts"], + "rootDir": ".", + "testEnvironment": "node", + "testRegex": "transaction.staging.e2e-spec.ts$", + "transform": { + "^.+\\.(t|j)s$": "ts-jest" + }, + "moduleNameMapper": { + "^@polypay/shared$": "/../../shared/src", + "^@polypay/shared/(.*)$": "/../../shared/src/$1", + "^@/(.*)$": "/../src/$1" + }, + "testTimeout": 1200000, + "verbose": true, + "forceExit": true, + "detectOpenHandles": true +} + diff --git a/packages/backend/test/jest.setup.ts b/packages/backend/test/jest.setup.ts index ee6c6a5..c82a2c4 100644 --- a/packages/backend/test/jest.setup.ts +++ b/packages/backend/test/jest.setup.ts @@ -6,11 +6,17 @@ // Increase timeout for blockchain calls jest.setTimeout(300000); -// Load environment variables from .env.test if exists +// Load environment variables from .env.test if exists, otherwise fallback to .env import * as dotenv from 'dotenv'; import * as path from 'path'; +import * as fs from 'fs'; -dotenv.config({ path: path.resolve(__dirname, '../.env.test') }); +const envTestPath = path.resolve(__dirname, '../.env.test'); +const envPath = fs.existsSync(envTestPath) + ? envTestPath + : path.resolve(__dirname, '../.env'); + +dotenv.config({ path: envPath }); // Validate required environment variables const requiredEnvVars = [ diff --git a/packages/backend/test/utils/identity.util.ts b/packages/backend/test/utils/identity.util.ts new file mode 100644 index 0000000..0454fe0 --- /dev/null +++ b/packages/backend/test/utils/identity.util.ts @@ -0,0 +1,34 @@ +import { createTestSigner, TestSigner } from './signer.util'; +import { generateCommitment, generateSecret } from './proof.util'; +import { type TestUser } from '../fixtures/test-users'; + +export interface TestIdentity { + signer: TestSigner; + secret: bigint; + commitment: string; + signerDto: { + commitment: string; + name: string; + }; +} + +export async function createTestIdentity( + getUser: () => TestUser, + name: string, +): Promise { + const signer = createTestSigner(getUser()); + const secret = await generateSecret(signer); + const commitmentBigInt = await generateCommitment(secret); + const commitment = commitmentBigInt.toString(); + + return { + signer, + secret, + commitment, + signerDto: { + commitment, + name, + }, + }; +} + diff --git a/packages/backend/test/utils/multi-asset-flow.shared.ts b/packages/backend/test/utils/multi-asset-flow.shared.ts new file mode 100644 index 0000000..de7a16b --- /dev/null +++ b/packages/backend/test/utils/multi-asset-flow.shared.ts @@ -0,0 +1,231 @@ +import { type Hex, formatEther, parseEther } from 'viem'; +import { + encodeERC20Transfer, + encodeBatchTransferMulti, + formatTokenAmount, + ZEN_TOKEN, + USDC_TOKEN, + ZERO_ADDRESS, +} from '@polypay/shared'; +import { depositToAccount, getAccountBalance } from './contract.util'; +import { + toTokenAmount, + transferErc20FromSigner, + getErc20Balance, +} from './transaction.util'; +import type { TestIdentity } from './identity.util'; + +export const TEST_CHAIN_ID = 2651420; +export const TEST_TRANSFER_AMOUNT = '0.0001'; +export const TEST_FUND_ETH_AMOUNT = '0.0003'; +export const TEST_FUND_ERC20_MULTIPLIER = 2; +export const TEST_RECIPIENT = + '0x87142a49c749dD05069836F9B81E5579E95BE0A6' as `0x${string}`; +export const TEST_THRESHOLD = 2; + +export type AssetName = 'ETH' | 'ZEN' | 'USDC'; + +export interface AssetScenario { + name: AssetName; + isNative: boolean; + tokenAddress: `0x${string}` | null; + decimals: number; +} + +export const SCENARIOS: AssetScenario[] = [ + { + name: 'ETH', + isNative: true, + tokenAddress: null, + decimals: 18, + }, + { + name: 'ZEN', + isNative: false, + tokenAddress: ZEN_TOKEN.addresses[TEST_CHAIN_ID] as `0x${string}`, + decimals: ZEN_TOKEN.decimals, + }, + { + name: 'USDC', + isNative: false, + tokenAddress: USDC_TOKEN.addresses[TEST_CHAIN_ID] as `0x${string}`, + decimals: USDC_TOKEN.decimals, + }, +]; + +export interface ScenarioAmount { + scenario: AssetScenario; + amountBigInt: bigint; + amountString: string; +} + +export type CreatedTx = + | { + kind: 'single'; + scenario: AssetScenario; + amount: ScenarioAmount; + txId: string; + } + | { kind: 'batch'; txId: string }; + +export interface ParsedBatchItem { + recipient: string; + amount: string; + tokenAddress?: string | null; +} + +export function getCreatedTxLabel(entry: CreatedTx): string { + return entry.kind === 'single' ? entry.scenario.name : 'batch'; +} + +/** Match frontend: ETH = (recipient, value, 0x); ERC20 = (tokenAddress, 0, encodeERC20Transfer) */ +export function buildSingleTransferParams( + amount: ScenarioAmount, + recipient: `0x${string}`, +): { to: `0x${string}`; value: bigint; callData: Hex } { + const to = amount.scenario.isNative + ? recipient + : (amount.scenario.tokenAddress as `0x${string}`); + const value = amount.scenario.isNative ? amount.amountBigInt : 0n; + const callData = amount.scenario.isNative + ? ('0x' as Hex) + : (encodeERC20Transfer(recipient, amount.amountBigInt) as Hex); + return { to, value, callData }; +} + +/** Build approve params from API tx details (single transfer). */ +export function buildSingleApproveParams(txDetails: { + to?: string; + value?: string; + tokenAddress?: string | null; +}): { to: `0x${string}`; value: bigint; callData: Hex } { + if (txDetails.to === undefined || txDetails.value === undefined) { + throw new Error('Single transfer txDetails must have to and value'); + } + const to = (txDetails.tokenAddress ?? txDetails.to) as `0x${string}`; + const value = txDetails.tokenAddress ? 0n : BigInt(txDetails.value); + const callData = txDetails.tokenAddress + ? (encodeERC20Transfer(txDetails.to, BigInt(txDetails.value)) as Hex) + : ('0x' as Hex); + return { to, value, callData }; +} + +export function buildBatchCallData( + scenarioAmounts: ScenarioAmount[], + recipient: `0x${string}`, +): Hex { + const recipients = [ + recipient, + recipient, + recipient, + ] as `0x${string}`[]; + const amounts = scenarioAmounts.map((a) => a.amountBigInt); + const tokenAddresses = scenarioAmounts.map((a) => + a.scenario.tokenAddress ?? (ZERO_ADDRESS as `0x${string}`), + ); + return encodeBatchTransferMulti( + recipients, + amounts, + tokenAddresses as string[], + ) as Hex; +} + +export function buildBatchCallDataFromParsed( + parsedBatch: ParsedBatchItem[], +): Hex { + const recipients = parsedBatch.map((p) => p.recipient as `0x${string}`); + const amounts = parsedBatch.map((p) => BigInt(p.amount)); + const tokenAddresses = parsedBatch.map( + (p) => p.tokenAddress || ZERO_ADDRESS, + ); + return encodeBatchTransferMulti( + recipients, + amounts, + tokenAddresses, + ) as Hex; +} + +/** + * Fund account: 2x per asset (single tx 0.0001 + batch item 0.0001). + * Returns ScenarioAmount for one transfer (0.0001) used by both single tx and batch item. + */ +export async function fundAccountForScenario( + scenario: AssetScenario, + accountAddress: `0x${string}`, + identityA: TestIdentity, +): Promise { + if (scenario.isNative) { + const balanceBefore = await getAccountBalance(accountAddress); + await depositToAccount( + identityA.signer, + accountAddress, + TEST_FUND_ETH_AMOUNT, + ); + const balanceAfter = await getAccountBalance(accountAddress); + + console.log(`[${scenario.name}] Fund native ETH - done`, { + balanceBefore: formatEther(balanceBefore), + balanceAfter: formatEther(balanceAfter), + }); + + const value = parseEther(TEST_TRANSFER_AMOUNT); + return { + scenario, + amountBigInt: value, + amountString: value.toString(), + }; + } + + if (!scenario.tokenAddress) { + throw new Error( + `Token address is required for ERC20 scenario: ${scenario.name}`, + ); + } + + const fundHuman = ( + parseFloat(TEST_TRANSFER_AMOUNT) * TEST_FUND_ERC20_MULTIPLIER + ).toFixed(scenario.decimals); + const { amountBigInt: fundAmount } = toTokenAmount( + fundHuman, + scenario.decimals, + ); + const { amountBigInt, amountString } = toTokenAmount( + TEST_TRANSFER_AMOUNT, + scenario.decimals, + ); + + const balanceBefore = await getErc20Balance( + accountAddress, + scenario.tokenAddress, + ); + + await transferErc20FromSigner( + identityA.signer, + scenario.tokenAddress, + accountAddress, + fundAmount, + ); + + const balanceAfter = await getErc20Balance( + accountAddress, + scenario.tokenAddress, + ); + + console.log(`[${scenario.name}] Fund ERC20 (2x) - done`, { + tokenAddress: scenario.tokenAddress, + balanceBefore: formatTokenAmount( + balanceBefore.toString(), + scenario.decimals, + ), + balanceAfter: formatTokenAmount( + balanceAfter.toString(), + scenario.decimals, + ), + }); + + return { + scenario, + amountBigInt, + amountString, + }; +} diff --git a/packages/backend/test/utils/staging-api.util.ts b/packages/backend/test/utils/staging-api.util.ts new file mode 100644 index 0000000..ad7699d --- /dev/null +++ b/packages/backend/test/utils/staging-api.util.ts @@ -0,0 +1,197 @@ +import axios from 'axios'; +import { + API_ENDPOINTS, + CreateAccountDto, + TxType, +} from '@polypay/shared'; +import type { CreateTransactionPayload, ApproveTransactionPayload, CreateBatchItemPayload } from './transaction.util'; +import type { AuthTokens } from './auth.util'; +import { generateTestAuthProof } from './proof.util'; + +const BASE_URL = + process.env.STAGING_API_BASE_URL || 'https://api.testnet.polypay.pro'; + +function authHeaders(accessToken: string) { + return { Authorization: `Bearer ${accessToken}` }; +} + +export async function stagingLogin( + secret: bigint, + commitment: string, +): Promise { + const authProof = await generateTestAuthProof(secret); + + const response = await axios.post( + `${BASE_URL}${API_ENDPOINTS.auth.login}`, + { + commitment, + proof: authProof.proof, + publicInputs: authProof.publicInputs, + }, + ); + + return { + accessToken: response.data.accessToken, + refreshToken: response.data.refreshToken, + }; +} + +export async function stagingCreateAccount( + accessToken: string, + dto: CreateAccountDto, +) { + try { + const response = await axios.post( + `${BASE_URL}${API_ENDPOINTS.accounts.base}`, + dto, + { headers: authHeaders(accessToken) }, + ); + + return response.data as { address: `0x${string}` }; + } catch (error: any) { + if (axios.isAxiosError(error)) { + console.error('stagingCreateAccount error', { + status: error.response?.status, + data: error.response?.data, + }); + } + throw error; + } +} + +export async function stagingCreateBatchItem( + accessToken: string, + payload: CreateBatchItemPayload, +) { + try { + const response = await axios.post( + `${BASE_URL}${API_ENDPOINTS.batchItems.base}`, + payload, + { headers: authHeaders(accessToken) }, + ); + + return response.data as { id: string }; + } catch (error: any) { + if (axios.isAxiosError(error)) { + console.error('stagingCreateBatchItem error', { + status: error.response?.status, + data: error.response?.data, + }); + } + throw error; + } +} + +export async function stagingReserveNonce( + accessToken: string, + accountAddress: `0x${string}`, +) { + try { + const response = await axios.post( + `${BASE_URL}${API_ENDPOINTS.transactions.reserveNonce}`, + { accountAddress }, + { headers: authHeaders(accessToken) }, + ); + + return response.data as { nonce: number }; + } catch (error: any) { + if (axios.isAxiosError(error)) { + console.error('stagingReserveNonce error', { + status: error.response?.status, + data: error.response?.data, + }); + } + throw error; + } +} + +export async function stagingCreateTransaction( + accessToken: string, + payload: CreateTransactionPayload, +) { + try { + const response = await axios.post( + `${BASE_URL}${API_ENDPOINTS.transactions.base}`, + payload, + { headers: authHeaders(accessToken) }, + ); + + return response.data as { txId: string }; + } catch (error: any) { + if (axios.isAxiosError(error)) { + console.error('stagingCreateTransaction error', { + status: error.response?.status, + data: error.response?.data, + }); + } + throw error; + } +} + +export async function stagingApproveTransaction( + accessToken: string, + txId: string, + payload: ApproveTransactionPayload, +) { + try { + await axios.post( + `${BASE_URL}${API_ENDPOINTS.transactions.approve(Number(txId))}`, + payload, + { headers: authHeaders(accessToken) }, + ); + } catch (error: any) { + if (axios.isAxiosError(error)) { + console.error('stagingApproveTransaction error', { + status: error.response?.status, + data: error.response?.data, + }); + } + throw error; + } +} + +export async function stagingExecuteTransaction( + accessToken: string, + txId: string, +) { + try { + const response = await axios.post( + `${BASE_URL}${API_ENDPOINTS.transactions.execute(Number(txId))}`, + undefined, + { headers: authHeaders(accessToken) }, + ); + + return response.data as { txHash: string }; + } catch (error: any) { + if (axios.isAxiosError(error)) { + console.error('stagingExecuteTransaction error', { + status: error.response?.status, + data: error.response?.data, + }); + } + throw error; + } +} + +export async function stagingGetTransaction( + accessToken: string, + txId: string, +) { + try { + const response = await axios.get( + `${BASE_URL}${API_ENDPOINTS.transactions.byTxId(Number(txId))}`, + { headers: authHeaders(accessToken) }, + ); + + return response.data; + } catch (error: any) { + if (axios.isAxiosError(error)) { + console.error('stagingGetTransaction error', { + status: error.response?.status, + data: error.response?.data, + }); + } + throw error; + } +} + diff --git a/packages/backend/test/utils/transaction.util.ts b/packages/backend/test/utils/transaction.util.ts new file mode 100644 index 0000000..695846a --- /dev/null +++ b/packages/backend/test/utils/transaction.util.ts @@ -0,0 +1,250 @@ +import * as request from 'supertest'; +import { type Hex } from 'viem'; +import { + API_ENDPOINTS, + CreateAccountDto, + TxType, +} from '@polypay/shared'; +import { parseTokenAmount } from '@polypay/shared'; +import { getHttpServer } from '../setup'; +import { getAuthHeader } from './auth.util'; +import { createTestPublicClient, getTransactionHash } from './contract.util'; +import { generateTestProof } from './proof.util'; +import { type TestIdentity } from './identity.util'; +import { type TestSigner } from './signer.util'; +import { waitForReceiptWithRetry } from '@/common/utils/retry'; + +export interface CreateTransactionPayload { + nonce: number; + type: TxType; + accountAddress: `0x${string}`; + to: `0x${string}`; + value: string; + threshold: number; + tokenAddress?: string | null; + proof: number[]; + publicInputs: string[]; + nullifier: string; + /** For TxType.BATCH: IDs from apiCreateBatchItem (order = execution order) */ + batchItemIds?: string[]; +} + +export interface ApproveTransactionPayload { + proof: number[]; + publicInputs: string[]; + nullifier: string; +} + +export interface ParsedTokenAmount { + amountString: string; + amountBigInt: bigint; +} + +export async function apiCreateAccount( + accessToken: string, + dto: CreateAccountDto, +) { + const server = getHttpServer(); + + const response = await request(server) + .post(API_ENDPOINTS.accounts.base) + .set(getAuthHeader(accessToken)) + .send(dto) + .expect(201); + + return response.body as { address: `0x${string}` }; +} + +export async function apiReserveNonce( + accessToken: string, + accountAddress: `0x${string}`, +) { + const server = getHttpServer(); + + const response = await request(server) + .post(API_ENDPOINTS.transactions.reserveNonce) + .set(getAuthHeader(accessToken)) + .send({ accountAddress }) + .expect(201); + + return response.body as { nonce: number }; +} + +export async function apiCreateTransaction( + accessToken: string, + payload: CreateTransactionPayload, +) { + const server = getHttpServer(); + + const response = await request(server) + .post(API_ENDPOINTS.transactions.base) + .set(getAuthHeader(accessToken)) + .send(payload) + .expect(201); + + return response.body as { txId: string }; +} + +export async function apiApproveTransaction( + accessToken: string, + txId: string, + payload: ApproveTransactionPayload, +) { + const server = getHttpServer(); + + await request(server) + .post(API_ENDPOINTS.transactions.approve(Number(txId))) + .set(getAuthHeader(accessToken)) + .send(payload) + .expect(201); +} + +export async function apiExecuteTransaction( + accessToken: string, + txId: string, +) { + const server = getHttpServer(); + + const response = await request(server) + .post(API_ENDPOINTS.transactions.execute(Number(txId))) + .set(getAuthHeader(accessToken)) + .expect(201); + + return response.body as { txHash: string }; +} + +export async function apiGetTransaction(accessToken: string, txId: string) { + const server = getHttpServer(); + + const response = await request(server) + .get(API_ENDPOINTS.transactions.byTxId(Number(txId))) + .set(getAuthHeader(accessToken)) + .expect(200); + + return response.body; +} + +export interface CreateBatchItemPayload { + recipient: string; + amount: string; + tokenAddress?: string | null; +} + +export async function apiCreateBatchItem( + accessToken: string, + payload: CreateBatchItemPayload, +) { + const server = getHttpServer(); + + const response = await request(server) + .post(API_ENDPOINTS.batchItems.base) + .set(getAuthHeader(accessToken)) + .send(payload) + .expect(201); + + return response.body as { id: string }; +} + +export async function generateVotePayload( + identity: TestIdentity, + accountAddress: `0x${string}`, + nonce: bigint, + to: `0x${string}`, + value: bigint, + callData: Hex = '0x', +): Promise { + const txHash = await getTransactionHash( + accountAddress, + nonce, + to, + value, + callData, + ); + + const proof = await generateTestProof(identity.signer, identity.secret, txHash); + + return { + proof: proof.proof, + publicInputs: proof.publicInputs, + nullifier: proof.nullifier, + }; +} + +/** + * Convert human-readable token amount to smallest unit (string + bigint) + * using shared parseTokenAmount helper. + */ +export function toTokenAmount( + humanAmount: string, + decimals: number, +): ParsedTokenAmount { + const amountString = parseTokenAmount(humanAmount, decimals); + return { + amountString, + amountBigInt: BigInt(amountString), + }; +} + +/** + * Transfer ERC20 tokens from a test signer to a recipient address. + * Uses standard ERC20 transfer(address,uint256) and waits for confirmation. + */ +export async function transferErc20FromSigner( + signer: TestSigner, + tokenAddress: `0x${string}`, + to: `0x${string}`, + amount: bigint, +): Promise { + const hash = await signer.walletClient.writeContract({ + account: signer.account, + address: tokenAddress, + abi: [ + { + name: 'transfer', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'to', type: 'address' }, + { name: 'amount', type: 'uint256' }, + ], + outputs: [{ name: '', type: 'success', internalType: 'bool' as const }], + }, + ], + functionName: 'transfer', + args: [to, amount], + } as any); + + const publicClient = createTestPublicClient(); + await waitForReceiptWithRetry(publicClient as any, hash); + + return hash as Hex; +} + +/** + * Read ERC20 token balance for an address. + */ +export async function getErc20Balance( + accountAddress: `0x${string}`, + tokenAddress: `0x${string}`, +): Promise { + const publicClient = createTestPublicClient(); + + const balance = await publicClient.readContract({ + address: tokenAddress, + abi: [ + { + name: 'balanceOf', + type: 'function', + stateMutability: 'view', + inputs: [{ name: 'account', type: 'address' }], + outputs: [{ name: 'balance', type: 'uint256' }], + }, + ], + functionName: 'balanceOf', + args: [accountAddress], + }); + + return balance as bigint; +} + + diff --git a/packages/shared/src/constants/token.ts b/packages/shared/src/constants/token.ts index 2cf7e3e..645ba26 100644 --- a/packages/shared/src/constants/token.ts +++ b/packages/shared/src/constants/token.ts @@ -39,7 +39,7 @@ export const NATIVE_ETH: Token = { export const ZEN_TOKEN: Token = { addresses: { - [HORIZEN_TESTNET]: "0x4b36cb6E7c257E9aA246122a997be0F7Dc1eFCd1", + [HORIZEN_TESTNET]: "0xb06EC4ce262D8dbDc24Fac87479A49A7DC4cFb87", [HORIZEN_MAINNET]: "0x57da2D504bf8b83Ef304759d9f2648522D7a9280", [BASE_MAINNET]: "0xf43eB8De897Fbc7F2502483B2Bef7Bb9EA179229", [BASE_SEPOLIA]: "0x107fdE93838e3404934877935993782F977324BB", From 64bd5cd8c8602437e5c082635862ed201336fe89 Mon Sep 17 00:00:00 2001 From: BoHsuu <115441679+Huygon764@users.noreply.github.com> Date: Fri, 13 Mar 2026 16:58:02 +0700 Subject: [PATCH 05/18] Feat/ux polish (#209) * Improve UX of Transfer page * Improve UX of Batch page * Improve UX of EditAccountModal * Enhance transaction loading feedback in Dashboard and modals - Updated TransactionRow component to display detailed loading steps during transaction approval. - Integrated step loading functionality in useTransactionVote hook for improved user experience during transaction processes. * Changed button label from Transfer now to Submit Transfer to enhance user understanding during the transfer process. --- .../components/Batch/BatchContainer.tsx | 6 ++ .../components/Batch/TransactionSummary.tsx | 19 +++++- .../Batch/TransactionSummaryDrawer.tsx | 6 ++ .../components/Dashboard/TransactionRow.tsx | 23 ++++++- .../components/Transfer/TransferContainer.tsx | 35 ++++++---- .../modals/EditAccountModal/EditStep.tsx | 6 -- .../EditAccountModal/SubmittingStep.tsx | 22 +++++- .../modals/EditAccountModal/index.tsx | 6 +- packages/nextjs/components/ui/Spinner.tsx | 7 ++ .../app/transaction/useBatchTransaction.ts | 26 ++++--- .../app/transaction/useSignerTransaction.ts | 32 +++++---- .../app/transaction/useTransactionVote.ts | 39 ++++++----- .../app/transaction/useTransferTransaction.ts | 28 +++++--- packages/nextjs/hooks/app/useGenerateProof.ts | 4 +- packages/nextjs/hooks/app/useStepLoading.ts | 67 +++++++++++++++++++ packages/nextjs/styles/globals.css | 10 +++ packages/nextjs/utils/formatError.ts | 2 +- 17 files changed, 265 insertions(+), 73 deletions(-) create mode 100644 packages/nextjs/components/ui/Spinner.tsx create mode 100644 packages/nextjs/hooks/app/useStepLoading.ts diff --git a/packages/nextjs/components/Batch/BatchContainer.tsx b/packages/nextjs/components/Batch/BatchContainer.tsx index e8ccad3..febcefc 100644 --- a/packages/nextjs/components/Batch/BatchContainer.tsx +++ b/packages/nextjs/components/Batch/BatchContainer.tsx @@ -292,6 +292,8 @@ export default function BatchContainer() { proposeBatch, isLoading: isProposing, loadingState, + loadingStep, + totalSteps, } = useBatchTransaction({ onSuccess: async () => { setSelectedItems(new Set()); @@ -439,6 +441,8 @@ export default function BatchContainer() { onConfirm={handleProposeBatch} isLoading={isProposing} loadingState={loadingState} + loadingStep={loadingStep} + totalSteps={totalSteps} accountId={accountId} />
@@ -452,6 +456,8 @@ export default function BatchContainer() { onConfirm={handleProposeBatch} isLoading={isProposing} loadingState={loadingState} + loadingStep={loadingStep} + totalSteps={totalSteps} accountId={accountId} />
diff --git a/packages/nextjs/components/Batch/TransactionSummary.tsx b/packages/nextjs/components/Batch/TransactionSummary.tsx index 9712106..a27b84b 100644 --- a/packages/nextjs/components/Batch/TransactionSummary.tsx +++ b/packages/nextjs/components/Batch/TransactionSummary.tsx @@ -19,6 +19,8 @@ interface TransactionSummaryProps { isLoading?: boolean; loadingState?: string; accountId: string | null; + loadingStep?: number; + totalSteps?: number; } const TransactionSummary: React.FC = ({ @@ -28,6 +30,8 @@ const TransactionSummary: React.FC = ({ isLoading = false, loadingState = "", accountId, + loadingStep = 0, + totalSteps = 4, }) => { const { data: contacts = [] } = useContacts(accountId); return ( @@ -116,13 +120,26 @@ const TransactionSummary: React.FC = ({ {/* Confirm Button Section */}
+ {isLoading && loadingState && loadingStep > 0 && ( +
+
+ Step {loadingStep} of {totalSteps} — {loadingState} +
+
+
+
+
+ )}
diff --git a/packages/nextjs/components/Batch/TransactionSummaryDrawer.tsx b/packages/nextjs/components/Batch/TransactionSummaryDrawer.tsx index 7b17e2f..8f24dbf 100644 --- a/packages/nextjs/components/Batch/TransactionSummaryDrawer.tsx +++ b/packages/nextjs/components/Batch/TransactionSummaryDrawer.tsx @@ -19,6 +19,8 @@ interface TransactionSummaryDrawerProps { onConfirm?: () => void; isLoading?: boolean; loadingState?: string; + loadingStep?: number; + totalSteps?: number; } export const TransactionSummaryDrawer = memo(function TransactionSummaryDrawer({ @@ -29,6 +31,8 @@ export const TransactionSummaryDrawer = memo(function TransactionSummaryDrawer({ onConfirm, isLoading = false, loadingState = "", + loadingStep = 0, + totalSteps = 4, }: TransactionSummaryDrawerProps) { const [isAnimating, setIsAnimating] = useState(false); @@ -68,6 +72,8 @@ export const TransactionSummaryDrawer = memo(function TransactionSummaryDrawer({ accountId={accountId} isLoading={isLoading} loadingState={loadingState} + loadingStep={loadingStep} + totalSteps={totalSteps} className="h-full" />
diff --git a/packages/nextjs/components/Dashboard/TransactionRow.tsx b/packages/nextjs/components/Dashboard/TransactionRow.tsx index ba7bfef..1b19adf 100644 --- a/packages/nextjs/components/Dashboard/TransactionRow.tsx +++ b/packages/nextjs/components/Dashboard/TransactionRow.tsx @@ -632,7 +632,17 @@ export function TransactionRow({ tx, onSuccess }: TransactionRowProps) { // Get totalSigners realtime from wallet commitments const totalSigners = commitmentsData?.length || 0; - const { approve, deny, execute, isLoading: loading, loadingState } = useTransactionVote({ onSuccess }); + const { + approve, + deny, + execute, + isLoading: loading, + loadingState, + loadingStep, + totalSteps, + } = useTransactionVote({ + onSuccess, + }); const handleApprove = async () => { await approve(tx); @@ -718,7 +728,16 @@ export function TransactionRow({ tx, onSuccess }: TransactionRowProps) {
{/* Loading State */} {loading && loadingState && ( -
{loadingState}
+
+
+ {loadingStep > 0 && totalSteps > 1 && ( + + Step {loadingStep}/{totalSteps} + + )} + {loadingState} +
+
)} {/* Main Container */} diff --git a/packages/nextjs/components/Transfer/TransferContainer.tsx b/packages/nextjs/components/Transfer/TransferContainer.tsx index be46f51..e8e603b 100644 --- a/packages/nextjs/components/Transfer/TransferContainer.tsx +++ b/packages/nextjs/components/Transfer/TransferContainer.tsx @@ -6,6 +6,7 @@ import { ResolvedToken, parseTokenAmount } from "@polypay/shared"; import { parseEther } from "viem"; import { ContactPicker } from "~~/components/contact-book/ContactPicker"; import { TokenPillPopover } from "~~/components/popovers/TokenPillPopover"; +import { Spinner } from "~~/components/ui/Spinner"; import { useMetaMultiSigWallet, useTransferTransaction } from "~~/hooks"; import { useCreateBatchItem } from "~~/hooks/api"; import { useNetworkTokens } from "~~/hooks/app/useNetworkTokens"; @@ -69,7 +70,7 @@ export default function TransferContainer() { } }, [form]); - const { transfer, isLoading, loadingState } = useTransferTransaction({ + const { transfer, isLoading, loadingState, loadingStep, totalSteps } = useTransferTransaction({ onSuccess: () => { form.reset(); setSelectedContactId(null); @@ -145,15 +146,15 @@ export default function TransferContainer() { return (
{/* Background images */} -
+
Top globe
-
+
Bottom globe
{/* Main content */} -
+
{/* Title section */}
transfering
@@ -164,11 +165,6 @@ export default function TransferContainer() {
- {/* Loading state */} - {isLoading && loadingState && ( -
{loadingState}
- )} -
{/* Action buttons */} + {isLoading && loadingState && ( +
+
+ Step {loadingStep} of {totalSteps} — {loadingState} +
+
+
+
+
+ )}
diff --git a/packages/nextjs/components/modals/EditAccountModal/EditStep.tsx b/packages/nextjs/components/modals/EditAccountModal/EditStep.tsx index 8d39a2a..3546dcd 100644 --- a/packages/nextjs/components/modals/EditAccountModal/EditStep.tsx +++ b/packages/nextjs/components/modals/EditAccountModal/EditStep.tsx @@ -24,7 +24,6 @@ const EditStep: React.FC = ({ existingSigners, originalThreshold, loading, - loadingState, onNext, onClose, }) => { @@ -174,11 +173,6 @@ const EditStep: React.FC = ({
- {/* Loading state */} - {loading && loadingState && ( -
{loadingState}
- )} - {/* Content */}
{/* Account Signers Section */} diff --git a/packages/nextjs/components/modals/EditAccountModal/SubmittingStep.tsx b/packages/nextjs/components/modals/EditAccountModal/SubmittingStep.tsx index 21058d6..2044a13 100644 --- a/packages/nextjs/components/modals/EditAccountModal/SubmittingStep.tsx +++ b/packages/nextjs/components/modals/EditAccountModal/SubmittingStep.tsx @@ -2,7 +2,13 @@ import React from "react"; -const SubmittingStep = () => { +interface SubmittingStepProps { + loadingState?: string; + loadingStep?: number; + totalSteps?: number; +} + +const SubmittingStep: React.FC = ({ loadingState = "", loadingStep = 0, totalSteps = 4 }) => { return (
{/* Rocket animation video */} @@ -30,6 +36,20 @@ const SubmittingStep = () => { This may take a few moments. Please don't close this window.

+ + {loadingStep > 0 && totalSteps > 0 && ( +
+
+ Step {loadingStep} of {totalSteps} — {loadingState} +
+
+
+
+
+ )}
); }; diff --git a/packages/nextjs/components/modals/EditAccountModal/index.tsx b/packages/nextjs/components/modals/EditAccountModal/index.tsx index 4de1fe8..f5fe4c5 100644 --- a/packages/nextjs/components/modals/EditAccountModal/index.tsx +++ b/packages/nextjs/components/modals/EditAccountModal/index.tsx @@ -25,6 +25,8 @@ const EditAccountModal: React.FC = ({ isOpen, onClose }) => { updateThreshold, isLoading: loading, loadingState, + loadingStep, + totalSteps, signers, threshold: originalThreshold, refetchCommitments, @@ -190,7 +192,9 @@ const EditAccountModal: React.FC = ({ isOpen, onClose }) => { /> )} - {step === "submitting" && } + {step === "submitting" && ( + + )} ); }; diff --git a/packages/nextjs/components/ui/Spinner.tsx b/packages/nextjs/components/ui/Spinner.tsx new file mode 100644 index 0000000..b129329 --- /dev/null +++ b/packages/nextjs/components/ui/Spinner.tsx @@ -0,0 +1,7 @@ +interface SpinnerProps { + className?: string; +} + +export function Spinner({ className = "h-4 w-4" }: SpinnerProps) { + return
; +} diff --git a/packages/nextjs/hooks/app/transaction/useBatchTransaction.ts b/packages/nextjs/hooks/app/transaction/useBatchTransaction.ts index 1d9700c..e31faa5 100644 --- a/packages/nextjs/hooks/app/transaction/useBatchTransaction.ts +++ b/packages/nextjs/hooks/app/transaction/useBatchTransaction.ts @@ -4,6 +4,7 @@ import { useWalletClient } from "wagmi"; import { useMetaMultiSigWallet } from "~~/hooks"; import { useCreateTransaction, useReserveNonce } from "~~/hooks/api"; import { useGenerateProof } from "~~/hooks/app/useGenerateProof"; +import { useStepLoading } from "~~/hooks/app/useStepLoading"; import { useIdentityStore } from "~~/services/store"; import { formatErrorMessage } from "~~/utils/formatError"; import { notification } from "~~/utils/scaffold-eth"; @@ -12,9 +13,16 @@ interface UseBatchTransactionOptions { onSuccess?: () => void; } +const BATCH_STEPS = [ + { id: 1, label: "Preparing your batch..." }, + { id: 2, label: "Waiting for wallet approval..." }, + { id: 3, label: "Securing your transaction..." }, + { id: 4, label: "Almost done, submitting..." }, +]; + export const useBatchTransaction = (options?: UseBatchTransactionOptions) => { - const [isLoading, setIsLoading] = useState(false); - const [loadingState, setLoadingState] = useState(""); + const { isLoading, loadingState, loadingStep, totalSteps, startStep, setStepByLabel, reset } = + useStepLoading(BATCH_STEPS); const { data: walletClient } = useWalletClient(); const { secret, commitment: myCommitment } = useIdentityStore(); @@ -22,7 +30,7 @@ export const useBatchTransaction = (options?: UseBatchTransactionOptions) => { const { mutateAsync: createTransaction } = useCreateTransaction(); const { mutateAsync: reserveNonce } = useReserveNonce(); const { generateProof } = useGenerateProof({ - onLoadingStateChange: setLoadingState, + onLoadingStateChange: setStepByLabel, }); const proposeBatch = async (selectedBatchItems: BatchItem[]) => { @@ -42,16 +50,15 @@ export const useBatchTransaction = (options?: UseBatchTransactionOptions) => { return; } - setIsLoading(true); - try { const selectedIds = selectedBatchItems.map(item => item.id); // 1. Reserve nonce from backend + startStep(1); const { nonce } = await reserveNonce(metaMultiSigWallet.address); // 2. Get current threshold and commitments - setLoadingState("Preparing batch transaction..."); + startStep(1); const currentThreshold = await metaMultiSigWallet.read.signaturesRequired(); // 3. Prepare batch data @@ -79,7 +86,7 @@ export const useBatchTransaction = (options?: UseBatchTransactionOptions) => { const { proof, publicInputs, nullifier, vk } = await generateProof(txHash); // 7. Submit to backend - setLoadingState("Submitting to backend..."); + startStep(4); const result = await createTransaction({ nonce, type: TxType.BATCH, @@ -104,8 +111,7 @@ export const useBatchTransaction = (options?: UseBatchTransactionOptions) => { console.error("Propose batch error:", error); notification.error(formatErrorMessage(error, "Failed to propose batch")); } finally { - setIsLoading(false); - setLoadingState(""); + reset(); } }; @@ -113,5 +119,7 @@ export const useBatchTransaction = (options?: UseBatchTransactionOptions) => { proposeBatch, isLoading, loadingState, + loadingStep, + totalSteps, }; }; diff --git a/packages/nextjs/hooks/app/transaction/useSignerTransaction.ts b/packages/nextjs/hooks/app/transaction/useSignerTransaction.ts index 5128c5e..7d917c4 100644 --- a/packages/nextjs/hooks/app/transaction/useSignerTransaction.ts +++ b/packages/nextjs/hooks/app/transaction/useSignerTransaction.ts @@ -3,6 +3,7 @@ import { SignerData, TxType, encodeAddSigners, encodeRemoveSigners, encodeUpdate import { useWalletClient } from "wagmi"; import { useGenerateProof, useMetaMultiSigWallet, useWalletCommitments, useWalletThreshold } from "~~/hooks"; import { useCreateTransaction, useReserveNonce } from "~~/hooks/api/useTransaction"; +import { useStepLoading } from "~~/hooks/app/useStepLoading"; import { formatErrorMessage } from "~~/utils/formatError"; import { notification } from "~~/utils/scaffold-eth"; @@ -10,14 +11,21 @@ interface UseSignerTransactionOptions { onSuccess?: () => void; } +const SIGNER_STEPS = [ + { id: 1, label: "Preparing your proposal..." }, + { id: 2, label: "Waiting for wallet approval..." }, + { id: 3, label: "Securing your transaction..." }, + { id: 4, label: "Almost done, submitting..." }, +]; + export const useSignerTransaction = (options?: UseSignerTransactionOptions) => { - const [isLoading, setIsLoading] = useState(false); - const [loadingState, setLoadingState] = useState(""); + const { isLoading, loadingState, loadingStep, totalSteps, startStep, setStepByLabel, reset } = + useStepLoading(SIGNER_STEPS); const { data: walletClient } = useWalletClient(); const metaMultiSigWallet = useMetaMultiSigWallet(); const { generateProof } = useGenerateProof({ - onLoadingStateChange: setLoadingState, + onLoadingStateChange: setStepByLabel, }); const { mutateAsync: createTransaction } = useCreateTransaction(); const { mutateAsync: reserveNonce } = useReserveNonce(); @@ -44,6 +52,8 @@ export const useSignerTransaction = (options?: UseSignerTransactionOptions) => { throw new Error("Wallet not connected"); } + startStep(1); + const { nonce } = await reserveNonce(metaMultiSigWallet.address); const currentThreshold = await metaMultiSigWallet.read.signaturesRequired(); @@ -56,7 +66,7 @@ export const useSignerTransaction = (options?: UseSignerTransactionOptions) => { const { proof, publicInputs, nullifier, vk } = await generateProof(txHash); - setLoadingState("Submitting to backend..."); + startStep(4); await createTransaction({ nonce, @@ -91,7 +101,6 @@ export const useSignerTransaction = (options?: UseSignerTransactionOptions) => { return; } - setIsLoading(true); try { const commitments = newSigners.map(s => s.commitment.trim()); const callData = encodeAddSigners(commitments, newThreshold); @@ -110,8 +119,7 @@ export const useSignerTransaction = (options?: UseSignerTransactionOptions) => { console.error("Failed to add signer:", error); notification.error(formatErrorMessage(error, "Failed to add signer")); } finally { - setIsLoading(false); - setLoadingState(""); + reset(); } }; @@ -143,7 +151,6 @@ export const useSignerTransaction = (options?: UseSignerTransactionOptions) => { return; } - setIsLoading(true); try { const commitments = signersToRemove.map(s => s.commitment.trim()); const callData = encodeRemoveSigners(commitments, adjustedThreshold); @@ -162,8 +169,7 @@ export const useSignerTransaction = (options?: UseSignerTransactionOptions) => { console.error("Failed to remove signer:", error); notification.error(formatErrorMessage(error, "Failed to remove signer")); } finally { - setIsLoading(false); - setLoadingState(""); + reset(); } }; @@ -178,7 +184,6 @@ export const useSignerTransaction = (options?: UseSignerTransactionOptions) => { return; } - setIsLoading(true); try { const callData = encodeUpdateThreshold(newThreshold); await executeSignerTransaction(TxType.SET_THRESHOLD, callData, { @@ -191,8 +196,7 @@ export const useSignerTransaction = (options?: UseSignerTransactionOptions) => { console.error("Failed to update threshold:", error); notification.error(formatErrorMessage(error, "Failed to update threshold")); } finally { - setIsLoading(false); - setLoadingState(""); + reset(); } }; @@ -202,6 +206,8 @@ export const useSignerTransaction = (options?: UseSignerTransactionOptions) => { updateThreshold, isLoading, loadingState, + loadingStep, + totalSteps, signers, threshold, refetchCommitments, diff --git a/packages/nextjs/hooks/app/transaction/useTransactionVote.ts b/packages/nextjs/hooks/app/transaction/useTransactionVote.ts index cda599e..404688a 100644 --- a/packages/nextjs/hooks/app/transaction/useTransactionVote.ts +++ b/packages/nextjs/hooks/app/transaction/useTransactionVote.ts @@ -16,6 +16,7 @@ import { useWalletClient } from "wagmi"; import { accountKeys, useMetaMultiSigWallet, userKeys } from "~~/hooks"; import { useApproveTransaction, useDenyTransaction, useExecuteTransaction } from "~~/hooks/api/useTransaction"; import { useGenerateProof } from "~~/hooks/app/useGenerateProof"; +import { useStepLoading } from "~~/hooks/app/useStepLoading"; import { useIdentityStore } from "~~/services/store/useIdentityStore"; import { formatErrorMessage } from "~~/utils/formatError"; import { notification } from "~~/utils/scaffold-eth"; @@ -117,9 +118,16 @@ function buildTransactionParams(tx: TransactionRowData): { return { to, value, callData }; } +const APPROVE_STEPS = [ + { id: 1, label: "Preparing approval..." }, + { id: 2, label: "Waiting for wallet approval..." }, + { id: 3, label: "Securing your transaction..." }, + { id: 4, label: "Almost done, submitting..." }, +]; + export const useTransactionVote = (options?: UseTransactionVoteOptions) => { - const [isLoading, setIsLoading] = useState(false); - const [loadingState, setLoadingState] = useState(""); + const { isLoading, loadingState, loadingStep, totalSteps, startStep, setStepByLabel, reset, startLoading } = + useStepLoading(APPROVE_STEPS); const { commitment } = useIdentityStore(); const { data: walletClient } = useWalletClient(); @@ -129,7 +137,7 @@ export const useTransactionVote = (options?: UseTransactionVoteOptions) => { const { mutateAsync: denyApi } = useDenyTransaction(); const { mutateAsync: executeApi } = useExecuteTransaction(); const { generateProof } = useGenerateProof({ - onLoadingStateChange: setLoadingState, + onLoadingStateChange: setStepByLabel, }); const queryClient = useQueryClient(); @@ -144,7 +152,8 @@ export const useTransactionVote = (options?: UseTransactionVoteOptions) => { return; } - setIsLoading(true); + // Full 4-step flow + startStep(1); try { // 1. Build callData based on tx type const { to, value, callData } = buildTransactionParams(tx); @@ -161,7 +170,7 @@ export const useTransactionVote = (options?: UseTransactionVoteOptions) => { const proofData = await generateProof(txHash); // 4. Submit to backend - setLoadingState("Submitting to backend..."); + startStep(4); await approveApi({ txId: tx.txId, dto: { @@ -179,8 +188,7 @@ export const useTransactionVote = (options?: UseTransactionVoteOptions) => { console.error("Approve error:", error); notification.error(formatErrorMessage(error, "Failed to approve")); } finally { - setIsLoading(false); - setLoadingState(""); + reset(); } }; @@ -195,9 +203,10 @@ export const useTransactionVote = (options?: UseTransactionVoteOptions) => { return; } - setIsLoading(true); + // Single-step fast action + startLoading("Submitting deny vote..."); try { - setLoadingState("Submitting deny vote..."); + // Fast single-step action; keep step 1 await denyApi({ txId: tx.txId, dto: { @@ -211,8 +220,7 @@ export const useTransactionVote = (options?: UseTransactionVoteOptions) => { console.error("Deny error:", error); notification.error(formatErrorMessage(error, "Failed to deny")); } finally { - setIsLoading(false); - setLoadingState(""); + reset(); } }; @@ -222,9 +230,9 @@ export const useTransactionVote = (options?: UseTransactionVoteOptions) => { return; } - setIsLoading(true); + // Single-step fast action + startLoading("Executing on-chain..."); try { - setLoadingState("Executing on-chain..."); const result = await executeApi({ txId, dto: { @@ -244,8 +252,7 @@ export const useTransactionVote = (options?: UseTransactionVoteOptions) => { console.error("Execute error:", error); notification.error(formatErrorMessage(error, "Failed to execute")); } finally { - setIsLoading(false); - setLoadingState(""); + reset(); } }; @@ -255,5 +262,7 @@ export const useTransactionVote = (options?: UseTransactionVoteOptions) => { execute, isLoading, loadingState, + loadingStep, + totalSteps, }; }; diff --git a/packages/nextjs/hooks/app/transaction/useTransferTransaction.ts b/packages/nextjs/hooks/app/transaction/useTransferTransaction.ts index 4c6d2b7..b41e276 100644 --- a/packages/nextjs/hooks/app/transaction/useTransferTransaction.ts +++ b/packages/nextjs/hooks/app/transaction/useTransferTransaction.ts @@ -1,10 +1,11 @@ -import { useState } from "react"; +import { useEffect } from "react"; import { ResolvedToken, TxType, ZERO_ADDRESS, encodeERC20Transfer, parseTokenAmount } from "@polypay/shared"; import { parseEther } from "viem"; import { useWalletClient } from "wagmi"; import { useMetaMultiSigWallet } from "~~/hooks"; import { useCreateTransaction, useReserveNonce } from "~~/hooks/api/useTransaction"; import { useGenerateProof } from "~~/hooks/app/useGenerateProof"; +import { useStepLoading } from "~~/hooks/app/useStepLoading"; import { formatErrorMessage } from "~~/utils/formatError"; import { notification } from "~~/utils/scaffold-eth"; @@ -19,16 +20,23 @@ interface UseTransferTransactionOptions { onSuccess?: () => void; } +const TRANSFER_STEPS = [ + { id: 1, label: "Preparing your transfer..." }, + { id: 2, label: "Waiting for wallet approval..." }, + { id: 3, label: "Securing your transaction..." }, + { id: 4, label: "Almost done, submitting..." }, +]; + export const useTransferTransaction = (options?: UseTransferTransactionOptions) => { - const [isLoading, setIsLoading] = useState(false); - const [loadingState, setLoadingState] = useState(""); + const { isLoading, loadingState, loadingStep, totalSteps, startStep, setStepByLabel, reset } = + useStepLoading(TRANSFER_STEPS); const { data: walletClient } = useWalletClient(); const metaMultiSigWallet = useMetaMultiSigWallet(); const { mutateAsync: createTransaction } = useCreateTransaction(); const { mutateAsync: reserveNonce } = useReserveNonce(); const { generateProof } = useGenerateProof({ - onLoadingStateChange: setLoadingState, + onLoadingStateChange: setStepByLabel, }); const transfer = async ({ recipient, amount, token, contactId }: TransferParams) => { @@ -38,14 +46,13 @@ export const useTransferTransaction = (options?: UseTransferTransactionOptions) } const isNativeETH = token.address === ZERO_ADDRESS; - - setIsLoading(true); try { // 1. Reserve nonce from backend + startStep(1); const { nonce } = await reserveNonce(metaMultiSigWallet.address); // 2. Get current threshold and commitments - setLoadingState("Preparing transaction..."); + startStep(1); const currentThreshold = await metaMultiSigWallet.read.signaturesRequired(); // 3. Parse amount based on token type @@ -79,7 +86,7 @@ export const useTransferTransaction = (options?: UseTransferTransactionOptions) const { proof, publicInputs, nullifier, vk } = await generateProof(txHash); // 6. Submit to backend - setLoadingState("Submitting to backend..."); + startStep(4); const result = await createTransaction({ nonce, type: TxType.TRANSFER, @@ -105,8 +112,7 @@ export const useTransferTransaction = (options?: UseTransferTransactionOptions) console.error("Transfer error:", error); notification.error(formatErrorMessage(error, "Failed to create transfer")); } finally { - setIsLoading(false); - setLoadingState(""); + reset(); } }; @@ -114,5 +120,7 @@ export const useTransferTransaction = (options?: UseTransferTransactionOptions) transfer, isLoading, loadingState, + loadingStep, + totalSteps, }; }; diff --git a/packages/nextjs/hooks/app/useGenerateProof.ts b/packages/nextjs/hooks/app/useGenerateProof.ts index 92d1755..8b003dc 100644 --- a/packages/nextjs/hooks/app/useGenerateProof.ts +++ b/packages/nextjs/hooks/app/useGenerateProof.ts @@ -75,7 +75,7 @@ export function useGenerateProof(options?: UseGenerateProofOptions) { } // 2. Sign txHash - setLoadingState("Signing transaction..."); + setLoadingState("Waiting for wallet approval..."); const signature = await walletClient.signMessage({ message: { raw: txHash }, }); @@ -115,7 +115,7 @@ export function useGenerateProof(options?: UseGenerateProofOptions) { const execResult = await noir.execute(input); // 7. Generate proof - setLoadingState("Generating ZK proof..."); + setLoadingState("Securing your transaction..."); const plonk = new UltraPlonkBackend(bytecode, { threads: 2 }); const { proof, publicInputs } = await plonk.generateProof(execResult.witness); // const vk = await plonk.getVerificationKey(); diff --git a/packages/nextjs/hooks/app/useStepLoading.ts b/packages/nextjs/hooks/app/useStepLoading.ts new file mode 100644 index 0000000..9285661 --- /dev/null +++ b/packages/nextjs/hooks/app/useStepLoading.ts @@ -0,0 +1,67 @@ +import { useEffect, useState } from "react"; + +export interface StepDefinition { + id: number; + label: string; +} + +export function useStepLoading(steps: StepDefinition[]) { + const [isLoading, setIsLoading] = useState(false); + const [loadingState, setLoadingState] = useState(""); + const [loadingStep, setLoadingStep] = useState(0); + + const totalSteps = steps.length; + + const startStep = (id: number) => { + const found = steps.find(s => s.id === id); + if (found) { + setIsLoading(true); + setLoadingStep(found.id); + setLoadingState(found.label); + } + }; + + const setStepByLabel = (label: string) => { + const found = steps.find(s => s.label === label); + if (found) { + setLoadingStep(found.id); + setLoadingState(found.label); + } else { + setLoadingState(label); + } + }; + + const reset = () => { + setIsLoading(false); + setLoadingStep(0); + setLoadingState(""); + }; + + const startLoading = (label: string) => { + setIsLoading(true); + setLoadingState(label); + setLoadingStep(0); + }; + + // Prevent accidental refresh while loading + useEffect(() => { + const handleBeforeUnload = (e: BeforeUnloadEvent) => { + if (isLoading) { + e.preventDefault(); + } + }; + window.addEventListener("beforeunload", handleBeforeUnload); + return () => window.removeEventListener("beforeunload", handleBeforeUnload); + }, [isLoading]); + + return { + isLoading, + loadingState, + loadingStep, + totalSteps, + startStep, + setStepByLabel, + reset, + startLoading, + }; +} diff --git a/packages/nextjs/styles/globals.css b/packages/nextjs/styles/globals.css index e99c5c1..d4de78b 100644 --- a/packages/nextjs/styles/globals.css +++ b/packages/nextjs/styles/globals.css @@ -188,6 +188,16 @@ /* margin-bottom: 0.5rem; */ line-height: 1; } + + /* Override browser autofill styles */ + input:-webkit-autofill, + input:-webkit-autofill:hover, + input:-webkit-autofill:focus, + input:-webkit-autofill:active { + -webkit-box-shadow: 0 0 0 1000px white inset !important; + -webkit-text-fill-color: var(--color-main-black) !important; + transition: 5000s ease-in-out 0s; + } } :root, diff --git a/packages/nextjs/utils/formatError.ts b/packages/nextjs/utils/formatError.ts index 0965a90..983f18b 100644 --- a/packages/nextjs/utils/formatError.ts +++ b/packages/nextjs/utils/formatError.ts @@ -7,7 +7,7 @@ type ErrorLike = { const ERROR_PATTERNS: [RegExp, string | null][] = [ [/user rejected|user denied|user refused|ACTION_REJECTED/i, "Transaction was cancelled."], - [/insufficient funds/i, "Insufficient funds for this transaction."], + [/insufficient (funds|balance|account)/i, "Insufficient funds for this transaction."], [/nonce too (high|low)/i, "Transaction conflict. Please try again."], [/gas required exceeds|cannot estimate gas/i, "Transaction failed. Please try again."], [/rate.?limit|429/i, "Too many requests. Please wait a moment."], From 12855d9dca646499619074d69480861373df4242 Mon Sep 17 00:00:00 2001 From: BoHsuu <115441679+Huygon764@users.noreply.github.com> Date: Mon, 16 Mar 2026 16:48:24 +0700 Subject: [PATCH 06/18] docs: add CLAUDE.md with project conventions and codebase guide (#210) --- CLAUDE.md | 268 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 268 insertions(+) create mode 100644 CLAUDE.md diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..d0aa307 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,268 @@ +# CLAUDE.md - PolyPay App + +## Project Overview + +PolyPay is a privacy-preserving payroll platform built on Horizen blockchain. It enables organizations, DAOs, and global teams to run payroll privately using zero-knowledge proofs (Noir circuits). Key features: private payments, private multisig approvals, escrow/milestone-based transfers, real-time notifications via WebSocket, and JWT authentication. + +## Tech Stack + +**Monorepo** (Yarn Workspaces, Node.js >= 20.18.3) + +| Layer | Stack | +|-------|-------| +| Frontend | Next.js 15, React 19, TypeScript 5.8, Tailwind CSS 4 + DaisyUI 5 | +| State | Zustand 5 (persist middleware), TanStack React Query 5 | +| Forms | React Hook Form 7 + Zod 3 | +| Web3 | wagmi 2, viem 2, RainbowKit 2, Uniswap SDK | +| ZK | @noir-lang/noir_js, @aztec/bb.js | +| UI | Radix UI + shadcn/ui pattern, CVA for variants, Lucide React icons | +| Notifications | Sonner (primary), react-hot-toast (secondary) | +| Real-time | socket.io-client | +| Backend | NestJS 11, TypeScript 5.7, Prisma 7 (PostgreSQL), JWT auth | +| Smart Contracts | Hardhat 2, Solidity, OpenZeppelin 5, Poseidon circuits | +| Shared | @polypay/shared - DTOs with class-validator/class-transformer | + +## Folder Structure + +``` +/ +├── docker/ # Docker Compose, Dockerfiles, .env.example +├── docs/ # Gitbook documentation +├── packages/ +│ ├── nextjs/ # Frontend (Next.js App Router) +│ │ ├── app/ # Pages (dashboard, transfer, batch, contact-book, quest, leaderboard) +│ │ ├── components/ +│ │ │ ├── ui/ # Base UI components (shadcn pattern: button, input, dialog...) +│ │ │ ├── form/ # Form components (Form, FormField, FormInput, FormTextarea) +│ │ │ ├── Common/ # Shared components (Sidebar, DisclaimerChecker) +│ │ │ ├── Dashboard/ # Dashboard feature components +│ │ │ ├── Transfer/ # Transfer flow components +│ │ │ ├── Batch/ # Batch operation components +│ │ │ ├── NewAccount/ # Account creation components +│ │ │ ├── modals/ # Modal dialogs (~22 modals, lazy-loaded via ModalRegistry) +│ │ │ ├── skeletons/ # Loading skeleton components +│ │ │ └── icons/ # Custom icon components +│ │ ├── hooks/ +│ │ │ ├── api/ # React Query hooks (useTransaction, useAccount, useNotifications...) +│ │ │ ├── app/ # App logic hooks (useAuth, useGenerateProof, useSocketEvent...) +│ │ │ ├── form/ # Form hooks (useZodForm) +│ │ │ └── scaffold-eth/ # Scaffold-eth hooks +│ │ ├── services/ +│ │ │ ├── api/ # Axios API services (apiClient, authApi, transactionApi...) +│ │ │ ├── store/ # Zustand stores (useIdentityStore, useAccountStore...) +│ │ │ ├── web3/ # Web3 utilities +│ │ │ ├── socket/ # Socket.io client +│ │ │ └── queryClient.ts # React Query config +│ │ ├── utils/ # Utilities (formatError, errorHandler, signer, network...) +│ │ ├── lib/form/ # Form schemas (Zod) and validation helpers +│ │ ├── types/ # TypeScript types (modal, form, abitype) +│ │ ├── constants/ # Constants (API_BASE_URL, timing) +│ │ ├── configs/ # Route config, scaffold config +│ │ └── contracts/ # Contract ABIs +│ ├── backend/ # NestJS Backend +│ │ └── src/ +│ │ ├── auth/ # JWT authentication module +│ │ ├── account/ # Multi-sig account management +│ │ ├── transaction/ # Transaction CRUD & voting +│ │ ├── user/ # User management with ZK commitments +│ │ ├── notification/ # Real-time notifications (WebSocket) +│ │ ├── quest/ # Quest/gamification system +│ │ ├── admin/ # Admin analytics +│ │ ├── zkverify/ # ZK proof verification (Horizen) +│ │ ├── common/ # Shared utilities & middleware +│ │ ├── database/ # Prisma module +│ │ └── ... # ~24 feature modules total +│ ├── shared/ # Shared DTOs and types (@polypay/shared) +│ └── hardhat/ # Smart contracts & deployment +``` + +## Validation Commands + +```bash +# Root level +yarn lint # ESLint (frontend + hardhat) +yarn next:check-types # TypeScript type checking (frontend) +yarn next:build # Production build (frontend) +yarn build # Build all packages (shared → backend → frontend) +yarn test # Run hardhat tests +yarn format # Prettier format all packages + +# Frontend (packages/nextjs) +yarn dev # Dev server (port 3000) +yarn build # Next.js production build +yarn lint # ESLint +yarn check-types # TypeScript check +yarn format # Prettier + +# Backend (packages/backend) +yarn start:dev # Dev server with watch (port 4000) +yarn lint # ESLint +yarn format # Prettier +yarn test # Jest unit tests +yarn test:cov # Jest with coverage +yarn test:e2e # End-to-end tests +yarn test:e2e:staging # Staging E2E tests + +# Smart Contracts (packages/hardhat) +yarn chain # Local Hardhat node +yarn compile # Compile contracts +yarn deploy # Deploy contracts +yarn test # Hardhat tests +``` + +## Code Style & Conventions + +### Naming +- **Components**: PascalCase files and exports (`FormField.tsx`, `NotificationPanel.tsx`) +- **Hooks**: camelCase with `use` prefix (`useZodForm.ts`, `useTransaction.ts`) +- **Utils/Services**: camelCase (`apiClient.ts`, `formatError.ts`) +- **Types/Interfaces**: PascalCase (`ModalProps`, `IdentityState`) +- **Stores**: camelCase with `use` prefix (`useIdentityStore.ts`, `useAccountStore.ts`) +- **API services**: camelCase with `Api` suffix (`transactionApi`, `authApi`) +- **Constants**: UPPER_SNAKE_CASE (`API_BASE_URL`, `DEFAULT_PAGE_SIZE`) + +### Import Order +1. React / Next.js +2. Third-party libraries +3. @heroicons +4. @polypay/shared +5. Local imports (`~~/...`) + +### Formatting (Prettier) +- Print width: 120 +- Tab width: 2 spaces +- Arrow parens: avoid +- Trailing comma: all +- Path alias: `~~/*` → project root, `@polypay/shared` → shared package + +### Component Pattern +- "use client" directive for client-side components +- Functional components with hooks +- Named exports for UI components, default exports for pages +- Props interfaces defined inline in component files + +## Common Patterns + +### Design Tokens & Colors +- **Source of truth**: `packages/nextjs/styles/tokens.ts` — all color definitions live here +- **Sync script**: `packages/nextjs/styles/sync-colors.ts` — generates CSS variables into `globals.css` and Tailwind color config into `tailwind.config.ts` +- **Command**: `yarn sync-colors` (from `packages/nextjs`) +- **Flow**: Edit `tokens.ts` → run `yarn sync-colors` → CSS vars + Tailwind config auto-updated +- **Never edit colors directly** in `globals.css` or `tailwind.config.ts` — they will be overwritten by the sync script + +### State Management (Zustand) +```typescript +// services/store/useIdentityStore.ts +// All stores use create() with persist middleware for localStorage +const useIdentityStore = create()( + persist( + (set) => ({ + accessToken: null, + // ...state and actions + setTokens: (access, refresh) => set({ accessToken: access, refreshToken: refresh }), + logout: () => set({ accessToken: null, isAuthenticated: false }), + }), + { name: "identity-storage" } + ) +); +// Use getState() for sync access outside React (e.g., in Axios interceptors) +``` + +### API Services +```typescript +// services/api/transactionApi.ts +// Object export pattern with typed async methods +export const transactionApi = { + getAll: async (params) => { const { data } = await apiClient.get(...); return data; }, + create: async (dto) => { const { data } = await apiClient.post(...); return data; }, +}; +``` + +### React Query Hooks +```typescript +// hooks/api/useTransaction.ts +// Query key factory pattern for cache invalidation +const transactionKeys = { all: ["transactions"], list: (filters) => [...] }; +// useInfiniteQuery for pagination, useMutation with onSuccess invalidation +``` + +### Forms (React Hook Form + Zod) +```typescript +// useZodForm hook → Form component → FormField with Controller +const form = useZodForm({ schema: contactSchema }); +// Zod schemas in lib/form/schemas.ts, reusable validators in lib/form/validation.ts +``` + +### Error Handling +```typescript +// utils/formatError.ts - pattern matching for friendly error messages +// utils/errorHandler.ts - ErrorCode enum, parseError(), handleError() +// Axios interceptor handles 401 auto-refresh with token rotation +``` + +### Notifications +```typescript +import { notification } from "~~/utils/scaffold-eth"; +notification.success("Transaction submitted!"); +notification.error(formatErrorMessage(error)); +``` + +### Real-time (Socket.io) +```typescript +// hooks/app/useSocketEvent.ts - wrapper with auto-cleanup on unmount +useSocketEvent("transaction:updated", (data) => { /* handle */ }); +``` + +### Modals +```typescript +// Lazy-loaded via ModalRegistry with dynamic imports to prevent SSR issues +// components/modals/ - ~22 modal components +``` + +### Authenticated Queries +```typescript +// hooks/api/useAuthenticatedQuery.ts +// Wrapper that auto-disables queries when user is not authenticated +``` + +### Routes +```typescript +// configs/routes.config.ts - centralized route definitions +// hooks/app/useAppRouter.ts - type-safe navigation (goToDashboard, goToTransfer, etc.) +``` + +## Environment Setup + +### Prerequisites +- Node.js >= 20.18.3 +- Yarn (workspaces) +- Docker & Docker Compose (for PostgreSQL) + +## Do's and Don'ts + +### Do's +- Use `@polypay/shared` DTOs for API contracts between frontend and backend +- Use `useZodForm` hook for all forms with Zod schemas +- Use `notification.success/error/info` for user feedback +- Use `formatErrorMessage()` for user-friendly error messages +- Use `useAuthenticatedQuery` wrapper for queries requiring auth +- Use query key factory pattern for React Query cache management +- Use `useSocketEvent` hook for real-time subscriptions (auto-cleanup) +- Use `~~/*` path alias for local imports +- Use Zustand `persist` middleware for state that needs to survive refresh +- Use `apiClient` (configured Axios instance) for all API calls +- Follow feature-based component organization +- Use Radix UI + CVA for new UI components (shadcn pattern) + +### Don'ts +- Don't import from `@polypay/shared` directly in smart contracts +- Don't make API calls without going through `apiClient` (it handles auth tokens) +- Don't create new notification systems - use existing `notification` utility or Sonner +- Don't hardcode API URLs - use `API_BASE_URL` from constants +- Don't skip Zod validation for forms - always define schemas +- Don't store auth tokens manually - use `useIdentityStore` +- Don't create new Zustand stores without `persist` middleware unless state is truly ephemeral +- Don't use `useQuery` directly for authenticated endpoints - use `useAuthenticatedQuery` +- Don't put business logic in components - extract to custom hooks in `hooks/app/` +- Don't use inline styles - use Tailwind CSS classes +- Don't commit `.env` files or expose secrets From 713c2b1c24d3b817ef7ab4139fc244dce254d54e Mon Sep 17 00:00:00 2001 From: BoHsuu <115441679+Huygon764@users.noreply.github.com> Date: Mon, 16 Mar 2026 18:48:55 +0700 Subject: [PATCH 07/18] Feat/mini payroll (#212) * Payroll: Create batch for group * Change global css --- packages/nextjs/app/contact-book/page.tsx | 18 +- .../components/Batch/TransactionSummary.tsx | 2 +- .../modals/CreateBatchFromContactsModal.tsx | 482 ++++++++++++++++++ .../nextjs/components/modals/ModalLayout.tsx | 1 + .../public/contact-book/create-batch.svg | 6 + .../public/contact-book/new-contact.svg | 4 + .../nextjs/public/contact-book/new-group.svg | 6 + packages/nextjs/public/contact-book/trash.svg | 4 + packages/nextjs/styles/globals.css | 1 - packages/nextjs/types/modal.ts | 3 +- 10 files changed, 521 insertions(+), 6 deletions(-) create mode 100644 packages/nextjs/components/modals/CreateBatchFromContactsModal.tsx create mode 100644 packages/nextjs/public/contact-book/create-batch.svg create mode 100644 packages/nextjs/public/contact-book/new-contact.svg create mode 100644 packages/nextjs/public/contact-book/new-group.svg create mode 100644 packages/nextjs/public/contact-book/trash.svg diff --git a/packages/nextjs/app/contact-book/page.tsx b/packages/nextjs/app/contact-book/page.tsx index 2050983..6c29332 100644 --- a/packages/nextjs/app/contact-book/page.tsx +++ b/packages/nextjs/app/contact-book/page.tsx @@ -119,7 +119,7 @@ export default function AddressBookPage() {
+
diff --git a/packages/nextjs/components/Batch/TransactionSummary.tsx b/packages/nextjs/components/Batch/TransactionSummary.tsx index a27b84b..c3f4484 100644 --- a/packages/nextjs/components/Batch/TransactionSummary.tsx +++ b/packages/nextjs/components/Batch/TransactionSummary.tsx @@ -139,7 +139,7 @@ const TransactionSummary: React.FC = ({ className="flex items-center justify-center px-5 py-3 rounded-lg w-full disabled:opacity-50 bg-main-pink" > - {isLoading ? loadingState || "Processing..." : `Submit batch`} + {isLoading ? loadingState || "Processing..." : `Propose batch`}
diff --git a/packages/nextjs/components/modals/CreateBatchFromContactsModal.tsx b/packages/nextjs/components/modals/CreateBatchFromContactsModal.tsx new file mode 100644 index 0000000..001effc --- /dev/null +++ b/packages/nextjs/components/modals/CreateBatchFromContactsModal.tsx @@ -0,0 +1,482 @@ +"use client"; + +import { useCallback, useState } from "react"; +import Image from "next/image"; +import { Contact, ContactGroup, CreateBatchItemDto, ZERO_ADDRESS } from "@polypay/shared"; +import { ArrowLeft, GripVertical, X } from "lucide-react"; +import { parseUnits } from "viem"; +import { Checkbox } from "~~/components/Common"; +import ModalContainer from "~~/components/modals/ModalContainer"; +import { TokenPillPopover } from "~~/components/popovers/TokenPillPopover"; +import { useContacts, useCreateBatchItem, useGroups } from "~~/hooks"; +import { useBatchTransaction } from "~~/hooks"; +import { useNetworkTokens } from "~~/hooks/app/useNetworkTokens"; +import { formatAddress } from "~~/utils/format"; +import { notification } from "~~/utils/scaffold-eth"; + +interface BatchContactEntry { + contact: Contact; + amount: string; + tokenAddress: string; +} + +interface CreateBatchFromContactsModalProps { + isOpen: boolean; + onClose: () => void; + accountId?: string; + [key: string]: any; +} + +type Step = 1 | 2 | 3; + +export default function CreateBatchFromContactsModal({ + isOpen, + onClose, + accountId, +}: CreateBatchFromContactsModalProps) { + const [step, setStep] = useState(1); + const [selectedContactIds, setSelectedContactIds] = useState>(new Set()); + const [selectedGroupId, setSelectedGroupId] = useState(null); + const [batchEntries, setBatchEntries] = useState([]); + + const { data: contacts = [] } = useContacts(accountId || null, selectedGroupId || undefined); + const { data: allContacts = [] } = useContacts(accountId || null); + const { data: groups = [] } = useGroups(accountId || null); + const { tokens, nativeEth } = useNetworkTokens(); + const { mutateAsync: createBatchItem } = useCreateBatchItem(); + const { + proposeBatch, + isLoading: isProposing, + loadingState, + loadingStep, + totalSteps, + } = useBatchTransaction({ + onSuccess: () => { + notification.success("Batch transaction created!"); + handleReset(); + onClose(); + }, + }); + + const defaultToken = nativeEth || tokens[0]; + + const handleReset = () => { + setStep(1); + setSelectedContactIds(new Set()); + setSelectedGroupId(null); + setBatchEntries([]); + }; + + const handleClose = () => { + if (isProposing) return; + handleReset(); + onClose(); + }; + + // Step 1: Contact Selection + const toggleContact = useCallback((contactId: string) => { + setSelectedContactIds(prev => { + const next = new Set(prev); + if (next.has(contactId)) { + next.delete(contactId); + } else { + next.add(contactId); + } + return next; + }); + }, []); + + const handleSelectAll = useCallback(() => { + if (selectedContactIds.size === contacts.length && contacts.length > 0) { + setSelectedContactIds(new Set()); + } else { + setSelectedContactIds(new Set(contacts.map(c => c.id))); + } + }, [selectedContactIds.size, contacts]); + + const allSelected = contacts.length > 0 && selectedContactIds.size === contacts.length; + + const goToStep2 = () => { + const selectedContacts = allContacts.filter(c => selectedContactIds.has(c.id)); + setBatchEntries( + selectedContacts.map(contact => ({ + contact, + amount: "", + tokenAddress: defaultToken?.address || ZERO_ADDRESS, + })), + ); + setStep(2); + }; + + // Step 2: Amount & Token + const updateEntryAmount = (index: number, amount: string) => { + setBatchEntries(prev => prev.map((entry, i) => (i === index ? { ...entry, amount } : entry))); + }; + + const updateEntryToken = (index: number, tokenAddress: string) => { + setBatchEntries(prev => prev.map((entry, i) => (i === index ? { ...entry, tokenAddress } : entry))); + }; + + const removeEntry = (index: number) => { + setBatchEntries(prev => prev.filter((_, i) => i !== index)); + }; + + const allEntriesFilled = batchEntries.length > 0 && batchEntries.every(e => e.amount && parseFloat(e.amount) > 0); + + const goToStep3 = () => { + setStep(3); + }; + + // Step 3: Execute + const resolveToken = (tokenAddress: string) => { + return tokens.find(t => t.address === tokenAddress) || defaultToken; + }; + + const handleProposeBatch = async () => { + try { + const createdItems = await Promise.all( + batchEntries.map(entry => { + const token = resolveToken(entry.tokenAddress); + const amountInSmallestUnit = parseUnits(entry.amount, token.decimals).toString(); + + const dto: CreateBatchItemDto = { + recipient: entry.contact.address, + amount: amountInSmallestUnit, + tokenAddress: entry.tokenAddress === ZERO_ADDRESS ? undefined : entry.tokenAddress, + contactId: entry.contact.id, + }; + return createBatchItem(dto); + }), + ); + await proposeBatch(createdItems); + } catch { + // Error is handled inside proposeBatch / createBatchItem + } + }; + + const title = step === 1 ? "Choose contact" : step === 2 ? "Add to batch" : "Transactions summary"; + + return ( + + {/* Header */} +
+ {step > 1 ? ( + + ) : ( +
+ )} +

{title}

+ +
+ + {/* Content */} +
+ {step === 1 && ( + + )} + + {step === 2 && ( + + )} + + {step === 3 && } +
+ + {/* Footer */} +
+ +
+ {step === 1 && ( + + )} + {step === 2 && ( + + )} + {step === 3 && ( +
+ {isProposing && loadingState && loadingStep > 0 && ( +
+
+ Step {loadingStep} of {totalSteps} — {loadingState} +
+
+
+
+
+ )} + +
+ )} +
+
+ + ); +} + +// --- Step 1: Choose Contact --- +function StepChooseContact({ + contacts, + groups, + selectedGroupId, + selectedContactIds, + onSelectGroup, + onToggleContact, + onSelectAll, + allSelected, +}: { + contacts: Contact[]; + groups: ContactGroup[]; + selectedGroupId: string | null; + selectedContactIds: Set; + onSelectGroup: (id: string | null) => void; + onToggleContact: (id: string) => void; + onSelectAll: () => void; + allSelected: boolean; +}) { + return ( +
+ {/* Group filter tabs */} +
+ + {groups.map((group: ContactGroup) => ( + + ))} +
+ + {/* Select all / count */} +
+ + {selectedContactIds.size} selected +
+ + {/* Contact list */} +
+ {contacts.map((contact: Contact) => { + const isSelected = selectedContactIds.has(contact.id); + return ( +
+
onToggleContact(contact.id)}> + + avatar + {contact.name} +
+
+ + {formatAddress(contact.address, { start: 4, end: 4 })} + + +
+
+ ); + })} +
+
+ ); +} + +// --- Step 2: Add to Batch --- +function StepAddToBatch({ + entries, + resolveToken, + onUpdateAmount, + onUpdateToken, + onRemove, +}: { + entries: BatchContactEntry[]; + resolveToken: (address: string) => any; + onUpdateAmount: (index: number, amount: string) => void; + onUpdateToken: (index: number, tokenAddress: string) => void; + onRemove: (index: number) => void; +}) { + return ( +
+ {entries.map((entry, index) => { + const selectedToken = resolveToken(entry.tokenAddress); + return ( +
+
+ + Transfer + avatar +
+ {entry.contact.name} + + {formatAddress(entry.contact.address, { start: 4, end: 4 })} + +
+
+ +
+
+ { + const val = e.target.value; + if (val === "" || /^\d*\.?\d*$/.test(val)) { + onUpdateAmount(index, val); + } + }} + className="flex-1 text-base font-medium outline-none bg-transparent min-w-0" + /> + onUpdateToken(index, tokenAddress)} + /> +
+ +
+
+ ); + })} +
+ ); +} + +// --- Step 3: Transaction Summary --- +function StepTransactionSummary({ + entries, + resolveToken, +}: { + entries: BatchContactEntry[]; + resolveToken: (address: string) => any; +}) { + return ( +
+

+ Please review the information below and confirm to make the transaction. +

+
+ {entries.map((entry, index) => { + const token = resolveToken(entry.tokenAddress); + return ( +
+ Transfer +
+
+ {token.symbol} + + {entry.amount} {token.symbol} + +
+ arrow +
+ avatar + + {entry.contact.name} ({formatAddress(entry.contact.address, { start: 4, end: 4 })}) + +
+
+
+ ); + })} +
+
+ ); +} diff --git a/packages/nextjs/components/modals/ModalLayout.tsx b/packages/nextjs/components/modals/ModalLayout.tsx index f378e12..07eef00 100644 --- a/packages/nextjs/components/modals/ModalLayout.tsx +++ b/packages/nextjs/components/modals/ModalLayout.tsx @@ -54,6 +54,7 @@ const modals: ModalRegistry = { disclaimer: dynamic(() => import("./DisclaimerModal"), { ssr: false }), claimReward: dynamic(() => import("./ClaimRewardModal"), { ssr: false }), questIntro: dynamic(() => import("./QuestIntroModal"), { ssr: false }), + createBatchFromContacts: dynamic(() => import("./CreateBatchFromContactsModal"), { ssr: false }), }; type ModalInstance = { diff --git a/packages/nextjs/public/contact-book/create-batch.svg b/packages/nextjs/public/contact-book/create-batch.svg new file mode 100644 index 0000000..41fe23b --- /dev/null +++ b/packages/nextjs/public/contact-book/create-batch.svg @@ -0,0 +1,6 @@ + + + + + + diff --git a/packages/nextjs/public/contact-book/new-contact.svg b/packages/nextjs/public/contact-book/new-contact.svg new file mode 100644 index 0000000..f725cc5 --- /dev/null +++ b/packages/nextjs/public/contact-book/new-contact.svg @@ -0,0 +1,4 @@ + + + + diff --git a/packages/nextjs/public/contact-book/new-group.svg b/packages/nextjs/public/contact-book/new-group.svg new file mode 100644 index 0000000..2a5db31 --- /dev/null +++ b/packages/nextjs/public/contact-book/new-group.svg @@ -0,0 +1,6 @@ + + + + + + diff --git a/packages/nextjs/public/contact-book/trash.svg b/packages/nextjs/public/contact-book/trash.svg new file mode 100644 index 0000000..ab9f917 --- /dev/null +++ b/packages/nextjs/public/contact-book/trash.svg @@ -0,0 +1,4 @@ + + + + diff --git a/packages/nextjs/styles/globals.css b/packages/nextjs/styles/globals.css index d4de78b..b8eb7ff 100644 --- a/packages/nextjs/styles/globals.css +++ b/packages/nextjs/styles/globals.css @@ -194,7 +194,6 @@ input:-webkit-autofill:hover, input:-webkit-autofill:focus, input:-webkit-autofill:active { - -webkit-box-shadow: 0 0 0 1000px white inset !important; -webkit-text-fill-color: var(--color-main-black) !important; transition: 5000s ease-in-out 0s; } diff --git a/packages/nextjs/types/modal.ts b/packages/nextjs/types/modal.ts index 32e8698..08e230a 100644 --- a/packages/nextjs/types/modal.ts +++ b/packages/nextjs/types/modal.ts @@ -30,4 +30,5 @@ export type ModalName = | "switchAccount" | "disclaimer" | "claimReward" - | "questIntro"; + | "questIntro" + | "createBatchFromContacts"; From 372b458e1787c00ca065698174b569fddeb077cd Mon Sep 17 00:00:00 2001 From: BoHsuu Date: Tue, 10 Mar 2026 12:14:17 +0700 Subject: [PATCH 08/18] Init for contract --- packages/backend/assets/vkey-mixer.json | 1 + .../migration.sql | 37 + packages/backend/prisma/schema.prisma | 27 + packages/hardhat/contracts/Mixer.sol | 193 +++++ packages/hardhat/deploy/01_deploy_mixer.ts | 111 +++ .../hardhat/deployments/baseSepolia/.chainId | 1 + .../deployments/baseSepolia/Mixer.json | 738 ++++++++++++++++++ .../7f0373dedc61097daaf6a7dfc1f19d7a.json | 54 ++ .../deployments/horizenTestnet/Mixer.json | 738 ++++++++++++++++++ .../7f0373dedc61097daaf6a7dfc1f19d7a.json | 54 ++ packages/hardhat/package.json | 1 + .../nextjs/public/mixer-circuit/Nargo.toml | 7 + .../nextjs/public/mixer-circuit/src/main.nr | 55 ++ .../mixer-circuit/target/mixer_circuit.json | 53 ++ packages/shared/src/contracts/Mixer.ts | 493 ++++++++++++ .../shared/src/contracts/contracts-config.ts | 14 + packages/shared/src/contracts/index.ts | 1 + yarn.lock | 1 + 18 files changed, 2579 insertions(+) create mode 100644 packages/backend/assets/vkey-mixer.json create mode 100644 packages/backend/prisma/migrations/20260309000000_add_mixer_deposit_and_indexer_state/migration.sql create mode 100644 packages/hardhat/contracts/Mixer.sol create mode 100644 packages/hardhat/deploy/01_deploy_mixer.ts create mode 100644 packages/hardhat/deployments/baseSepolia/.chainId create mode 100644 packages/hardhat/deployments/baseSepolia/Mixer.json create mode 100644 packages/hardhat/deployments/baseSepolia/solcInputs/7f0373dedc61097daaf6a7dfc1f19d7a.json create mode 100644 packages/hardhat/deployments/horizenTestnet/Mixer.json create mode 100644 packages/hardhat/deployments/horizenTestnet/solcInputs/7f0373dedc61097daaf6a7dfc1f19d7a.json create mode 100644 packages/nextjs/public/mixer-circuit/Nargo.toml create mode 100644 packages/nextjs/public/mixer-circuit/src/main.nr create mode 100644 packages/nextjs/public/mixer-circuit/target/mixer_circuit.json create mode 100644 packages/shared/src/contracts/Mixer.ts diff --git a/packages/backend/assets/vkey-mixer.json b/packages/backend/assets/vkey-mixer.json new file mode 100644 index 0000000..23de373 --- /dev/null +++ b/packages/backend/assets/vkey-mixer.json @@ -0,0 +1 @@ +{"vkHash":"0x29236cc027580a6be3e581d9625a48710d39eb92e2c68e7b5e42841d11affe00"} \ No newline at end of file diff --git a/packages/backend/prisma/migrations/20260309000000_add_mixer_deposit_and_indexer_state/migration.sql b/packages/backend/prisma/migrations/20260309000000_add_mixer_deposit_and_indexer_state/migration.sql new file mode 100644 index 0000000..7d2affa --- /dev/null +++ b/packages/backend/prisma/migrations/20260309000000_add_mixer_deposit_and_indexer_state/migration.sql @@ -0,0 +1,37 @@ +-- CreateTable +CREATE TABLE "mixer_deposits" ( + "id" TEXT NOT NULL, + "chain_id" INTEGER NOT NULL, + "pool_id" TEXT NOT NULL, + "leaf_index" INTEGER NOT NULL, + "commitment" TEXT NOT NULL, + "token" TEXT NOT NULL, + "denomination" TEXT NOT NULL, + "block_number" INTEGER NOT NULL, + "tx_hash" TEXT NOT NULL, + "timestamp" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + + CONSTRAINT "mixer_deposits_pkey" PRIMARY KEY ("id") +); + +-- CreateTable +CREATE TABLE "mixer_indexer_state" ( + "id" TEXT NOT NULL, + "chain_id" INTEGER NOT NULL, + "last_indexed_block" INTEGER NOT NULL, + "updated_at" TIMESTAMP(3) NOT NULL, + + CONSTRAINT "mixer_indexer_state_pkey" PRIMARY KEY ("id") +); + +-- CreateIndex +CREATE UNIQUE INDEX "mixer_deposits_chain_id_pool_id_leaf_index_key" ON "mixer_deposits"("chain_id", "pool_id", "leaf_index"); + +-- CreateIndex +CREATE INDEX "mixer_deposits_chain_id_pool_id_idx" ON "mixer_deposits"("chain_id", "pool_id"); + +-- CreateIndex +CREATE INDEX "mixer_deposits_chain_id_pool_id_leaf_index_idx" ON "mixer_deposits"("chain_id", "pool_id", "leaf_index"); + +-- CreateIndex +CREATE UNIQUE INDEX "mixer_indexer_state_chain_id_key" ON "mixer_indexer_state"("chain_id"); diff --git a/packages/backend/prisma/schema.prisma b/packages/backend/prisma/schema.prisma index 0cfcea2..a0168e9 100644 --- a/packages/backend/prisma/schema.prisma +++ b/packages/backend/prisma/schema.prisma @@ -314,3 +314,30 @@ enum QuestCategory { RECURRING DAILY } + +model MixerDeposit { + id String @id @default(cuid()) + chainId Int @map("chain_id") + poolId String @map("pool_id") + leafIndex Int @map("leaf_index") + commitment String + token String + denomination String + blockNumber Int @map("block_number") + txHash String @map("tx_hash") + timestamp DateTime @default(now()) + + @@unique([chainId, poolId, leafIndex]) + @@index([chainId, poolId]) + @@index([chainId, poolId, leafIndex]) + @@map("mixer_deposits") +} + +model MixerIndexerState { + id String @id @default(cuid()) + chainId Int @unique @map("chain_id") + lastIndexedBlock Int @map("last_indexed_block") + updatedAt DateTime @updatedAt @map("updated_at") + + @@map("mixer_indexer_state") +} diff --git a/packages/hardhat/contracts/Mixer.sol b/packages/hardhat/contracts/Mixer.sol new file mode 100644 index 0000000..0213f7f --- /dev/null +++ b/packages/hardhat/contracts/Mixer.sol @@ -0,0 +1,193 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.13; + +import "@openzeppelin/contracts/utils/ReentrancyGuard.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "poseidon-solidity/PoseidonT3.sol"; + +interface IVerifyProofAggregation { + function verifyProofAggregation( + uint256 _domainId, + uint256 _aggregationId, + bytes32 _leaf, + bytes32[] calldata _merklePath, + uint256 _leafCount, + uint256 _index + ) external view returns (bool); +} + +contract Mixer is ReentrancyGuard { + uint256 public constant BN254_PRIME = 21888242871839275222246405745257275088548364400416034343698204186575808495617; + bytes32 public constant PROVING_SYSTEM_ID = keccak256(abi.encodePacked("ultraplonk")); + bytes32 public constant VERSION_HASH = sha256(abi.encodePacked("")); + uint256 public constant TREE_DEPTH = 20; + uint256 public constant ROOT_HISTORY_SIZE = 30; + + address public immutable zkvContract; + bytes32 public immutable vkHash; + + struct MerkleTree { + uint256 nextIndex; + uint256[TREE_DEPTH] filledSubtrees; + } + + struct MixerProof { + uint256 aggregationId; + uint256 domainId; + bytes32[] zkMerklePath; + uint256 leafCount; + uint256 index; + } + + mapping(bytes32 => MerkleTree) public trees; + mapping(bytes32 => bytes32[ROOT_HISTORY_SIZE]) public rootHistory; + mapping(bytes32 => uint256) public rootHistoryIndex; + mapping(bytes32 => mapping(bytes32 => bool)) public nullifierUsed; + mapping(bytes32 => bool) public allowedDenominations; + mapping(bytes32 => bool) public commitmentUsed; + + uint256[TREE_DEPTH + 1] internal zeroHashes; + + event Deposit(bytes32 indexed commitment, uint256 leafIndex, uint256 timestamp, address indexed token, uint256 denomination); + event Withdrawal(address indexed recipient, bytes32 nullifierHash, address indexed token, uint256 denomination, uint256 timestamp); + + constructor( + address _zkvContract, + bytes32 _vkHash, + bytes32[] memory _allowedPoolIds + ) { + require(_zkvContract != address(0), "Invalid zkv"); + zkvContract = _zkvContract; + vkHash = _vkHash; + for (uint256 i = 0; i < _allowedPoolIds.length; i++) { + allowedDenominations[_allowedPoolIds[i]] = true; + } + _computeZeroHashes(); + } + + function _computeZeroHashes() internal { + zeroHashes[0] = 0; + for (uint256 i = 1; i <= TREE_DEPTH; i++) { + zeroHashes[i] = _poseidonHash2(zeroHashes[i - 1], zeroHashes[i - 1]); + } + } + + /// @dev Exposed for Poseidon/zero-hash consistency tests (JS vs Solidity) + function getZeroHash(uint256 level) external view returns (bytes32) { + require(level <= TREE_DEPTH, "level"); + return bytes32(zeroHashes[level]); + } + + function _poseidonHash2(uint256 a, uint256 b) internal view returns (uint256) { + uint256 safeA = a % BN254_PRIME; + uint256 safeB = b % BN254_PRIME; + return PoseidonT3.hash([safeA, safeB]); + } + + function _poolId(address token, uint256 denomination) internal pure returns (bytes32) { + return keccak256(abi.encodePacked(token, denomination)); + } + + function deposit(address token, uint256 denomination, bytes32 commitment) external payable nonReentrant { + bytes32 poolId = _poolId(token, denomination); + require(allowedDenominations[poolId], "Denomination not allowed"); + require(!commitmentUsed[commitment], "Commitment already used"); + + if (token == address(0)) { + require(msg.value == denomination, "ETH value mismatch"); + } else { + require(msg.value == 0, "No ETH for ERC20"); + SafeERC20.safeTransferFrom(IERC20(token), msg.sender, address(this), denomination); + } + + uint256 leaf = uint256(commitment); + MerkleTree storage tree = trees[poolId]; + uint256 leafIndex = tree.nextIndex; + tree.nextIndex++; + + uint256 current = leaf; + for (uint256 i = 0; i < TREE_DEPTH; i++) { + if ((leafIndex >> i) % 2 == 0) { + tree.filledSubtrees[i] = current; + current = _poseidonHash2(current, zeroHashes[i]); + } else { + current = _poseidonHash2(tree.filledSubtrees[i], current); + } + } + + uint256 root = current; + uint256 rhi = rootHistoryIndex[poolId] % ROOT_HISTORY_SIZE; + rootHistory[poolId][rhi] = bytes32(root); + rootHistoryIndex[poolId]++; + + commitmentUsed[commitment] = true; + + emit Deposit(commitment, tree.nextIndex - 1, block.timestamp, token, denomination); + } + + function isKnownRoot(bytes32 poolId, bytes32 root) public view returns (bool) { + uint256 rhi = rootHistoryIndex[poolId]; + if (rhi == 0) return false; + uint256 size = rhi < ROOT_HISTORY_SIZE ? rhi : ROOT_HISTORY_SIZE; + for (uint256 i = 0; i < size; i++) { + uint256 idx = (rhi - 1 - i) % ROOT_HISTORY_SIZE; + if (rootHistory[poolId][idx] == root) return true; + } + return false; + } + + function _verifyMixerProof( + bytes32 root, + bytes32 nullifierHash, + address recipient, + address token, + uint256 denomination, + MixerProof calldata proof + ) internal view returns (bool) { + bytes memory encodedInputs = abi.encodePacked( + root, + nullifierHash, + uint256(uint160(recipient)), + uint256(uint160(token)), + denomination + ); + bytes32 leaf = keccak256(abi.encodePacked(PROVING_SYSTEM_ID, vkHash, VERSION_HASH, keccak256(encodedInputs))); + return IVerifyProofAggregation(zkvContract).verifyProofAggregation( + proof.domainId, + proof.aggregationId, + leaf, + proof.zkMerklePath, + proof.leafCount, + proof.index + ); + } + + function withdraw( + address token, + uint256 denomination, + address recipient, + bytes32 nullifierHash, + bytes32 root, + MixerProof calldata proof + ) external nonReentrant { + bytes32 poolId = _poolId(token, denomination); + require(allowedDenominations[poolId], "Denomination not allowed"); + require(isKnownRoot(poolId, root), "Unknown root"); + require(!nullifierUsed[poolId][nullifierHash], "Nullifier already used"); + require(_verifyMixerProof(root, nullifierHash, recipient, token, denomination, proof), "Invalid proof"); + + nullifierUsed[poolId][nullifierHash] = true; + + if (token == address(0)) { + (bool success, ) = recipient.call{ value: denomination }(""); + require(success, "ETH transfer failed"); + } else { + SafeERC20.safeTransfer(IERC20(token), recipient, denomination); + } + + emit Withdrawal(recipient, nullifierHash, token, denomination, block.timestamp); + } + + receive() external payable {} +} diff --git a/packages/hardhat/deploy/01_deploy_mixer.ts b/packages/hardhat/deploy/01_deploy_mixer.ts new file mode 100644 index 0000000..a13f168 --- /dev/null +++ b/packages/hardhat/deploy/01_deploy_mixer.ts @@ -0,0 +1,111 @@ +import { HardhatRuntimeEnvironment } from "hardhat/types"; +import { DeployFunction } from "hardhat-deploy/types"; +import { PoseidonT3, proxy } from "poseidon-solidity"; +import { solidityPackedKeccak256 } from "ethers"; +import { ZEN_TOKEN, USDC_TOKEN, getContractConfigByChainId } from "@polypay/shared"; + +const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"; + +const DENOMINATIONS = { + ETH: [ + BigInt("10000000000000000"), // 0.01 ether + BigInt("100000000000000000"), // 0.1 ether + BigInt("1000000000000000000"), // 1 ether + ], + ZEN: [ + BigInt("1000000000000000000"), // 1 + BigInt("5000000000000000000"), // 5 + BigInt("10000000000000000000"), // 10 + BigInt("100000000000000000000"), // 100 + BigInt("1000000000000000000000"), // 1000 + ], + USDC: [ + BigInt("1000000"), // 1 (6 decimals) + BigInt("5000000"), // 5 + BigInt("10000000"), // 10 + BigInt("100000000"), // 100 + BigInt("1000000000"), // 1000 + ], +}; + +function buildAllowedPoolIds(zenAddress: string, usdcAddress: string): string[] { + const poolIds: string[] = []; + for (const denom of DENOMINATIONS.ETH) { + poolIds.push( + solidityPackedKeccak256(["address", "uint256"], [ZERO_ADDRESS, denom]), + ); + } + for (const denom of DENOMINATIONS.ZEN) { + poolIds.push( + solidityPackedKeccak256(["address", "uint256"], [zenAddress, denom]), + ); + } + for (const denom of DENOMINATIONS.USDC) { + poolIds.push( + solidityPackedKeccak256(["address", "uint256"], [usdcAddress, denom]), + ); + } + return poolIds; +} + +// Map Hardhat network names → shared chainIds used in @polypay/shared configs. +const NETWORK_CHAIN_ID: Record = { + horizenTestnet: 2651420, + baseSepolia: 84532, +}; + +const deployMixer: DeployFunction = async function (hre: HardhatRuntimeEnvironment) { + const { deployer } = await hre.getNamedAccounts(); + const { deploy } = hre.deployments; + const [signer] = await hre.ethers.getSigners(); + const provider = hre.ethers.provider; + const networkName = hre.network.name; + + const chainId = NETWORK_CHAIN_ID[networkName]; + if (!chainId) { + console.log(`Skipping Mixer deploy for network ${networkName}`); + return; + } + + const sharedConfig = getContractConfigByChainId(chainId); + + const zkVerify = sharedConfig.zkVerifyAddress; + const vkHash = sharedConfig.mixerVkHash; + + const zenAddress = ZEN_TOKEN.addresses[chainId]; + const usdcAddress = USDC_TOKEN.addresses[chainId]; + + if ((await provider.getCode(proxy.address)) === "0x") { + const fundTx = await signer.sendTransaction({ + to: proxy.from, + value: proxy.gas, + }); + await fundTx.wait(); + await provider.broadcastTransaction(proxy.tx); + console.log(`Proxy deployed to: ${proxy.address}`); + } + + if ((await provider.getCode(PoseidonT3.address)) === "0x") { + const deployTx = await signer.sendTransaction({ + to: proxy.address, + data: PoseidonT3.data, + }); + await deployTx.wait(); + console.log(`PoseidonT3 deployed to: ${PoseidonT3.address}`); + } + + const allowedPoolIds = buildAllowedPoolIds(zenAddress, usdcAddress); + + await deploy("Mixer", { + from: deployer, + args: [zkVerify, vkHash, allowedPoolIds], + log: true, + autoMine: true, + libraries: { + PoseidonT3: PoseidonT3.address, + }, + }); +}; + +export default deployMixer; +deployMixer.tags = ["Mixer"]; diff --git a/packages/hardhat/deployments/baseSepolia/.chainId b/packages/hardhat/deployments/baseSepolia/.chainId new file mode 100644 index 0000000..667f99d --- /dev/null +++ b/packages/hardhat/deployments/baseSepolia/.chainId @@ -0,0 +1 @@ +84532 \ No newline at end of file diff --git a/packages/hardhat/deployments/baseSepolia/Mixer.json b/packages/hardhat/deployments/baseSepolia/Mixer.json new file mode 100644 index 0000000..0f87a1e --- /dev/null +++ b/packages/hardhat/deployments/baseSepolia/Mixer.json @@ -0,0 +1,738 @@ +{ + "address": "0xd9E9103693014b00db0Bf262b65CB2226062e732", + "abi": [ + { + "inputs": [ + { + "internalType": "address", + "name": "_zkvContract", + "type": "address" + }, + { + "internalType": "bytes32", + "name": "_vkHash", + "type": "bytes32" + }, + { + "internalType": "bytes32[]", + "name": "_allowedPoolIds", + "type": "bytes32[]" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "target", + "type": "address" + } + ], + "name": "AddressEmptyCode", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "AddressInsufficientBalance", + "type": "error" + }, + { + "inputs": [], + "name": "FailedInnerCall", + "type": "error" + }, + { + "inputs": [], + "name": "ReentrancyGuardReentrantCall", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "SafeERC20FailedOperation", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "commitment", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "leafIndex", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "denomination", + "type": "uint256" + } + ], + "name": "Deposit", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "recipient", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "nullifierHash", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "denomination", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + } + ], + "name": "Withdrawal", + "type": "event" + }, + { + "inputs": [], + "name": "BN254_PRIME", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "PROVING_SYSTEM_ID", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "ROOT_HISTORY_SIZE", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "TREE_DEPTH", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "VERSION_HASH", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "name": "allowedDenominations", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "name": "commitmentUsed", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "denomination", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "commitment", + "type": "bytes32" + } + ], + "name": "deposit", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "level", + "type": "uint256" + } + ], + "name": "getZeroHash", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "poolId", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "root", + "type": "bytes32" + } + ], + "name": "isKnownRoot", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "name": "nullifierUsed", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "rootHistory", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "name": "rootHistoryIndex", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "name": "trees", + "outputs": [ + { + "internalType": "uint256", + "name": "nextIndex", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "vkHash", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "denomination", + "type": "uint256" + }, + { + "internalType": "address", + "name": "recipient", + "type": "address" + }, + { + "internalType": "bytes32", + "name": "nullifierHash", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "root", + "type": "bytes32" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "aggregationId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "domainId", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "zkMerklePath", + "type": "bytes32[]" + }, + { + "internalType": "uint256", + "name": "leafCount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + } + ], + "internalType": "struct Mixer.MixerProof", + "name": "proof", + "type": "tuple" + } + ], + "name": "withdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "zkvContract", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "stateMutability": "payable", + "type": "receive" + } + ], + "transactionHash": "0x9e9ab6adf72b1fc19b10b611e747fa5ea68f3194d1072c4d2285267f6b63740b", + "receipt": { + "to": null, + "from": "0xd95E85e86D3Be5C86846435b8F0C3a476C5a9e42", + "contractAddress": "0xd9E9103693014b00db0Bf262b65CB2226062e732", + "transactionIndex": 12, + "gasUsed": "2329270", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000", + "transactionHash": "0x9e9ab6adf72b1fc19b10b611e747fa5ea68f3194d1072c4d2285267f6b63740b", + "logs": [], + "blockNumber": 38675302, + "cumulativeGasUsed": "2785031", + "status": 1, + "byzantium": true + }, + "args": [ + "0x0807C544D38aE7729f8798388d89Be6502A1e8A8", + "0x0000000000000000000000000000000000000000000000000000000000000000", + [ + "0xe904c2b027ada6080c203c94ae7a6948682023cdbf53aef00dbc800ef97a132e", + "0x73a9f33d373b966d8ef30721adda93c14785f3be5d60a65981b922edad5917c6", + "0xe9cb62a4a45543a0c652e488f81c3baa93c972fd0c6059a7897348da7ed660ce", + "0x8d7b16505c134c1e5e8fd93278eb58ceee3024f49e92ca2fecda1b0d6c3fd449", + "0x5ee833cd9dfc512c28212e4c4d86d6ced1e2b7e9bf00e059622aa0da2453866f", + "0x00af3e20b42328efaed5840434b4640c292ec4e2bf58e0f26a68a950ec0a3230", + "0x14e2f9fed2893099970ec49b29265bf80214911000fa9ac8a6dde6622fd3d096", + "0x52a7eac5043ec2f665ba834640a521ca90d6f3c78855d0d8be97b9f1c60e49b3", + "0x6b3f5a37d6af77d440225f4966b11834b98790dd1695f4945cd699864274b13d", + "0x30f37af7a18689c55d9e61755c02bacd01e2b95e70a960fc574b85e9aa572e30", + "0x6cd8db6810315a1313f8efc36e034ed2c17d63c46a13a1293ab0ee068e9278ae", + "0xcff23118d44901d505f3292b10fee5be8f27483b8d33f49cad2352425973a4e3", + "0x16e60ccd514ceaa2e7a82e076aede6d01181e7422b479ed39cfc5d0ce6e11e0a" + ] + ], + "numDeployments": 1, + "solcInputHash": "7f0373dedc61097daaf6a7dfc1f19d7a", + "metadata": "{\"compiler\":{\"version\":\"0.8.20+commit.a1b79de6\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zkvContract\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"_vkHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[]\",\"name\":\"_allowedPoolIds\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"AddressEmptyCode\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"AddressInsufficientBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedInnerCall\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrancyGuardReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"commitment\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"leafIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"denomination\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"nullifierHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"denomination\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"BN254_PRIME\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PROVING_SYSTEM_ID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ROOT_HISTORY_SIZE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"TREE_DEPTH\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"VERSION_HASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"allowedDenominations\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"commitmentUsed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"denomination\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"commitment\",\"type\":\"bytes32\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"level\",\"type\":\"uint256\"}],\"name\":\"getZeroHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"poolId\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"root\",\"type\":\"bytes32\"}],\"name\":\"isKnownRoot\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"nullifierUsed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"rootHistory\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"rootHistoryIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"trees\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"nextIndex\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"vkHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"denomination\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"nullifierHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"root\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"aggregationId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"domainId\",\"type\":\"uint256\"},{\"internalType\":\"bytes32[]\",\"name\":\"zkMerklePath\",\"type\":\"bytes32[]\"},{\"internalType\":\"uint256\",\"name\":\"leafCount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"internalType\":\"struct Mixer.MixerProof\",\"name\":\"proof\",\"type\":\"tuple\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zkvContract\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"errors\":{\"AddressEmptyCode(address)\":[{\"details\":\"There's no code at `target` (it is not a contract).\"}],\"AddressInsufficientBalance(address)\":[{\"details\":\"The ETH balance of the account is not enough to perform the operation.\"}],\"FailedInnerCall()\":[{\"details\":\"A call to an address target failed. The target may have reverted.\"}],\"ReentrancyGuardReentrantCall()\":[{\"details\":\"Unauthorized reentrant call.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"getZeroHash(uint256)\":{\"details\":\"Exposed for Poseidon/zero-hash consistency tests (JS vs Solidity)\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/Mixer.sol\":\"Mixer\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the value of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the value of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 value) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n * caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 value) external returns (bool);\\n\\n /**\\n * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n * allowance mechanism. `value` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0xc6a8ff0ea489379b61faa647490411b80102578440ab9d84e9a957cc12164e70\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n *\\n * ==== Security Considerations\\n *\\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\\n * generally recommended is:\\n *\\n * ```solidity\\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\\n * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\\n * doThing(..., value);\\n * }\\n *\\n * function doThing(..., uint256 value) public {\\n * token.safeTransferFrom(msg.sender, address(this), value);\\n * ...\\n * }\\n * ```\\n *\\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\\n * {SafeERC20-safeTransferFrom}).\\n *\\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\\n * contracts should have entry points that don't rely on permit.\\n */\\ninterface IERC20Permit {\\n /**\\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n *\\n * CAUTION: See Security Considerations above.\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0x6008dabfe393240d73d7dd7688033f72740d570aa422254d29a7dce8568f3aff\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC20Permit} from \\\"../extensions/IERC20Permit.sol\\\";\\nimport {Address} from \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n /**\\n * @dev An operation with an ERC20 token failed.\\n */\\n error SafeERC20FailedOperation(address token);\\n\\n /**\\n * @dev Indicates a failed `decreaseAllowance` request.\\n */\\n error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n /**\\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n }\\n\\n /**\\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n */\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n }\\n\\n /**\\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n forceApprove(token, spender, oldAllowance + value);\\n }\\n\\n /**\\n * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n * value, non-reverting calls are assumed to be successful.\\n */\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n unchecked {\\n uint256 currentAllowance = token.allowance(address(this), spender);\\n if (currentAllowance < requestedDecrease) {\\n revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n }\\n forceApprove(token, spender, currentAllowance - requestedDecrease);\\n }\\n }\\n\\n /**\\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n * to be set to zero before setting it to a non-zero value, such as USDT.\\n */\\n function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n if (!_callOptionalReturnBool(token, approvalCall)) {\\n _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n _callOptionalReturn(token, approvalCall);\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data);\\n if (returndata.length != 0 && !abi.decode(returndata, (bool))) {\\n revert SafeERC20FailedOperation(address(token));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n *\\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\\n */\\n function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\\n // and not revert is the subcall reverts.\\n\\n (bool success, bytes memory returndata) = address(token).call(data);\\n return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;\\n }\\n}\\n\",\"keccak256\":\"0x37bb49513c49c87c4642a891b13b63571bc87013dde806617aa1efb54605f386\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev The ETH balance of the account is not enough to perform the operation.\\n */\\n error AddressInsufficientBalance(address account);\\n\\n /**\\n * @dev There's no code at `target` (it is not a contract).\\n */\\n error AddressEmptyCode(address target);\\n\\n /**\\n * @dev A call to an address target failed. The target may have reverted.\\n */\\n error FailedInnerCall();\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n if (address(this).balance < amount) {\\n revert AddressInsufficientBalance(address(this));\\n }\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n if (!success) {\\n revert FailedInnerCall();\\n }\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason or custom error, it is bubbled\\n * up by this function (like regular Solidity function calls). However, if\\n * the call reverted with no returned reason, this function reverts with a\\n * {FailedInnerCall} error.\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n if (address(this).balance < value) {\\n revert AddressInsufficientBalance(address(this));\\n }\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResultFromTarget(target, success, returndata);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResultFromTarget(target, success, returndata);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResultFromTarget(target, success, returndata);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\\n * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an\\n * unsuccessful call.\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata\\n ) internal view returns (bytes memory) {\\n if (!success) {\\n _revert(returndata);\\n } else {\\n // only check if target is a contract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n if (returndata.length == 0 && target.code.length == 0) {\\n revert AddressEmptyCode(target);\\n }\\n return returndata;\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\\n * revert reason or with a default {FailedInnerCall} error.\\n */\\n function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\\n if (!success) {\\n _revert(returndata);\\n } else {\\n return returndata;\\n }\\n }\\n\\n /**\\n * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.\\n */\\n function _revert(bytes memory returndata) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert FailedInnerCall();\\n }\\n }\\n}\\n\",\"keccak256\":\"0xaf28a975a78550e45f65e559a3ad6a5ad43b9b8a37366999abd1b7084eb70721\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/ReentrancyGuard.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant NOT_ENTERED = 1;\\n uint256 private constant ENTERED = 2;\\n\\n uint256 private _status;\\n\\n /**\\n * @dev Unauthorized reentrant call.\\n */\\n error ReentrancyGuardReentrantCall();\\n\\n constructor() {\\n _status = NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant() {\\n _nonReentrantBefore();\\n _;\\n _nonReentrantAfter();\\n }\\n\\n function _nonReentrantBefore() private {\\n // On the first call to nonReentrant, _status will be NOT_ENTERED\\n if (_status == ENTERED) {\\n revert ReentrancyGuardReentrantCall();\\n }\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = ENTERED;\\n }\\n\\n function _nonReentrantAfter() private {\\n // By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Returns true if the reentrancy guard is currently set to \\\"entered\\\", which indicates there is a\\n * `nonReentrant` function in the call stack.\\n */\\n function _reentrancyGuardEntered() internal view returns (bool) {\\n return _status == ENTERED;\\n }\\n}\\n\",\"keccak256\":\"0xf980daa263b661ab8ddee7d4fd833c7da7e7995e2c359ff1f17e67e4112f2236\",\"license\":\"MIT\"},\"contracts/Mixer.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.13;\\n\\nimport \\\"@openzeppelin/contracts/utils/ReentrancyGuard.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"poseidon-solidity/PoseidonT3.sol\\\";\\n\\ninterface IVerifyProofAggregation {\\n function verifyProofAggregation(\\n uint256 _domainId,\\n uint256 _aggregationId,\\n bytes32 _leaf,\\n bytes32[] calldata _merklePath,\\n uint256 _leafCount,\\n uint256 _index\\n ) external view returns (bool);\\n}\\n\\ncontract Mixer is ReentrancyGuard {\\n uint256 public constant BN254_PRIME = 21888242871839275222246405745257275088548364400416034343698204186575808495617;\\n bytes32 public constant PROVING_SYSTEM_ID = keccak256(abi.encodePacked(\\\"ultraplonk\\\"));\\n bytes32 public constant VERSION_HASH = sha256(abi.encodePacked(\\\"\\\"));\\n uint256 public constant TREE_DEPTH = 20;\\n uint256 public constant ROOT_HISTORY_SIZE = 30;\\n\\n address public immutable zkvContract;\\n bytes32 public immutable vkHash;\\n\\n struct MerkleTree {\\n uint256 nextIndex;\\n uint256[TREE_DEPTH] filledSubtrees;\\n }\\n\\n struct MixerProof {\\n uint256 aggregationId;\\n uint256 domainId;\\n bytes32[] zkMerklePath;\\n uint256 leafCount;\\n uint256 index;\\n }\\n\\n mapping(bytes32 => MerkleTree) public trees;\\n mapping(bytes32 => bytes32[ROOT_HISTORY_SIZE]) public rootHistory;\\n mapping(bytes32 => uint256) public rootHistoryIndex;\\n mapping(bytes32 => mapping(bytes32 => bool)) public nullifierUsed;\\n mapping(bytes32 => bool) public allowedDenominations;\\n mapping(bytes32 => bool) public commitmentUsed;\\n\\n uint256[TREE_DEPTH + 1] internal zeroHashes;\\n\\n event Deposit(bytes32 indexed commitment, uint256 leafIndex, uint256 timestamp, address indexed token, uint256 denomination);\\n event Withdrawal(address indexed recipient, bytes32 nullifierHash, address indexed token, uint256 denomination, uint256 timestamp);\\n\\n constructor(\\n address _zkvContract,\\n bytes32 _vkHash,\\n bytes32[] memory _allowedPoolIds\\n ) {\\n require(_zkvContract != address(0), \\\"Invalid zkv\\\");\\n zkvContract = _zkvContract;\\n vkHash = _vkHash;\\n for (uint256 i = 0; i < _allowedPoolIds.length; i++) {\\n allowedDenominations[_allowedPoolIds[i]] = true;\\n }\\n _computeZeroHashes();\\n }\\n\\n function _computeZeroHashes() internal {\\n zeroHashes[0] = 0;\\n for (uint256 i = 1; i <= TREE_DEPTH; i++) {\\n zeroHashes[i] = _poseidonHash2(zeroHashes[i - 1], zeroHashes[i - 1]);\\n }\\n }\\n\\n /// @dev Exposed for Poseidon/zero-hash consistency tests (JS vs Solidity)\\n function getZeroHash(uint256 level) external view returns (bytes32) {\\n require(level <= TREE_DEPTH, \\\"level\\\");\\n return bytes32(zeroHashes[level]);\\n }\\n\\n function _poseidonHash2(uint256 a, uint256 b) internal view returns (uint256) {\\n uint256 safeA = a % BN254_PRIME;\\n uint256 safeB = b % BN254_PRIME;\\n return PoseidonT3.hash([safeA, safeB]);\\n }\\n\\n function _poolId(address token, uint256 denomination) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(token, denomination));\\n }\\n\\n function deposit(address token, uint256 denomination, bytes32 commitment) external payable nonReentrant {\\n bytes32 poolId = _poolId(token, denomination);\\n require(allowedDenominations[poolId], \\\"Denomination not allowed\\\");\\n require(!commitmentUsed[commitment], \\\"Commitment already used\\\");\\n\\n if (token == address(0)) {\\n require(msg.value == denomination, \\\"ETH value mismatch\\\");\\n } else {\\n require(msg.value == 0, \\\"No ETH for ERC20\\\");\\n SafeERC20.safeTransferFrom(IERC20(token), msg.sender, address(this), denomination);\\n }\\n\\n uint256 leaf = uint256(commitment);\\n MerkleTree storage tree = trees[poolId];\\n uint256 leafIndex = tree.nextIndex;\\n tree.nextIndex++;\\n\\n uint256 current = leaf;\\n for (uint256 i = 0; i < TREE_DEPTH; i++) {\\n if ((leafIndex >> i) % 2 == 0) {\\n tree.filledSubtrees[i] = current;\\n current = _poseidonHash2(current, zeroHashes[i]);\\n } else {\\n current = _poseidonHash2(tree.filledSubtrees[i], current);\\n }\\n }\\n\\n uint256 root = current;\\n uint256 rhi = rootHistoryIndex[poolId] % ROOT_HISTORY_SIZE;\\n rootHistory[poolId][rhi] = bytes32(root);\\n rootHistoryIndex[poolId]++;\\n\\n commitmentUsed[commitment] = true;\\n\\n emit Deposit(commitment, tree.nextIndex - 1, block.timestamp, token, denomination);\\n }\\n\\n function isKnownRoot(bytes32 poolId, bytes32 root) public view returns (bool) {\\n uint256 rhi = rootHistoryIndex[poolId];\\n if (rhi == 0) return false;\\n uint256 size = rhi < ROOT_HISTORY_SIZE ? rhi : ROOT_HISTORY_SIZE;\\n for (uint256 i = 0; i < size; i++) {\\n uint256 idx = (rhi - 1 - i) % ROOT_HISTORY_SIZE;\\n if (rootHistory[poolId][idx] == root) return true;\\n }\\n return false;\\n }\\n\\n function _verifyMixerProof(\\n bytes32 root,\\n bytes32 nullifierHash,\\n address recipient,\\n address token,\\n uint256 denomination,\\n MixerProof calldata proof\\n ) internal view returns (bool) {\\n bytes memory encodedInputs = abi.encodePacked(\\n root,\\n nullifierHash,\\n uint256(uint160(recipient)),\\n uint256(uint160(token)),\\n denomination\\n );\\n bytes32 leaf = keccak256(abi.encodePacked(PROVING_SYSTEM_ID, vkHash, VERSION_HASH, keccak256(encodedInputs)));\\n return IVerifyProofAggregation(zkvContract).verifyProofAggregation(\\n proof.domainId,\\n proof.aggregationId,\\n leaf,\\n proof.zkMerklePath,\\n proof.leafCount,\\n proof.index\\n );\\n }\\n\\n function withdraw(\\n address token,\\n uint256 denomination,\\n address recipient,\\n bytes32 nullifierHash,\\n bytes32 root,\\n MixerProof calldata proof\\n ) external nonReentrant {\\n bytes32 poolId = _poolId(token, denomination);\\n require(allowedDenominations[poolId], \\\"Denomination not allowed\\\");\\n require(isKnownRoot(poolId, root), \\\"Unknown root\\\");\\n require(!nullifierUsed[poolId][nullifierHash], \\\"Nullifier already used\\\");\\n require(_verifyMixerProof(root, nullifierHash, recipient, token, denomination, proof), \\\"Invalid proof\\\");\\n\\n nullifierUsed[poolId][nullifierHash] = true;\\n\\n if (token == address(0)) {\\n (bool success, ) = recipient.call{ value: denomination }(\\\"\\\");\\n require(success, \\\"ETH transfer failed\\\");\\n } else {\\n SafeERC20.safeTransfer(IERC20(token), recipient, denomination);\\n }\\n\\n emit Withdrawal(recipient, nullifierHash, token, denomination, block.timestamp);\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x9d9194b09a7796501db0572892637e613960671d83a5cda3e201c2c3edef7ba6\",\"license\":\"MIT\"},\"poseidon-solidity/PoseidonT3.sol\":{\"content\":\"/// SPDX-License-Identifier: MIT\\npragma solidity >=0.7.0;\\n\\nlibrary PoseidonT3 {\\n uint constant M00 = 0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b;\\n uint constant M01 = 0x2969f27eed31a480b9c36c764379dbca2cc8fdd1415c3dded62940bcde0bd771;\\n uint constant M02 = 0x143021ec686a3f330d5f9e654638065ce6cd79e28c5b3753326244ee65a1b1a7;\\n uint constant M10 = 0x16ed41e13bb9c0c66ae119424fddbcbc9314dc9fdbdeea55d6c64543dc4903e0;\\n uint constant M11 = 0x2e2419f9ec02ec394c9871c832963dc1b89d743c8c7b964029b2311687b1fe23;\\n uint constant M12 = 0x176cc029695ad02582a70eff08a6fd99d057e12e58e7d7b6b16cdfabc8ee2911;\\n\\n // See here for a simplified implementation: https://github.com/vimwitch/poseidon-solidity/blob/e57becdabb65d99fdc586fe1e1e09e7108202d53/contracts/Poseidon.sol#L40\\n // Inspired by: https://github.com/iden3/circomlibjs/blob/v0.0.8/src/poseidon_slow.js\\n function hash(uint[2] memory) public pure returns (uint) {\\n assembly {\\n let F := 21888242871839275222246405745257275088548364400416034343698204186575808495617\\n let M20 := 0x2b90bba00fca0589f617e7dcbfe82e0df706ab640ceb247b791a93b74e36736d\\n let M21 := 0x101071f0032379b697315876690f053d148d4e109f5fb065c8aacc55a0f89bfa\\n let M22 := 0x19a3fc0a56702bf417ba7fee3802593fa644470307043f7773279cd71d25d5e0\\n\\n // load the inputs from memory\\n let state1 := add(mod(mload(0x80), F), 0x00f1445235f2148c5986587169fc1bcd887b08d4d00868df5696fff40956e864)\\n let state2 := add(mod(mload(0xa0), F), 0x08dff3487e8ac99e1f29a058d0fa80b930c728730b7ab36ce879f3890ecf73f5)\\n let scratch0 := mulmod(state1, state1, F)\\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\\n scratch0 := mulmod(state2, state2, F)\\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\\n scratch0 := add(\\n 0x2f27be690fdaee46c3ce28f7532b13c856c35342c84bda6e20966310fadc01d0,\\n add(add(15452833169820924772166449970675545095234312153403844297388521437673434406763, mulmod(state1, M10, F)), mulmod(state2, M20, F))\\n )\\n let scratch1 := add(\\n 0x2b2ae1acf68b7b8d2416bebf3d4f6234b763fe04b8043ee48b8327bebca16cf2,\\n add(add(18674271267752038776579386132900109523609358935013267566297499497165104279117, mulmod(state1, M11, F)), mulmod(state2, M21, F))\\n )\\n let scratch2 := add(\\n 0x0319d062072bef7ecca5eac06f97d4d55952c175ab6b03eae64b44c7dbf11cfa,\\n add(add(14817777843080276494683266178512808687156649753153012854386334860566696099579, mulmod(state1, M12, F)), mulmod(state2, M22, F))\\n )\\n let state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := mulmod(scratch1, scratch1, F)\\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\\n state0 := mulmod(scratch2, scratch2, F)\\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\\n state0 := add(0x28813dcaebaeaa828a376df87af4a63bc8b7bf27ad49c6298ef7b387bf28526d, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x2727673b2ccbc903f181bf38e1c1d40d2033865200c352bc150928adddf9cb78, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x234ec45ca27727c2e74abd2b2a1494cd6efbd43e340587d6b8fb9e31e65cc632, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := mulmod(state1, state1, F)\\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\\n scratch0 := mulmod(state2, state2, F)\\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\\n scratch0 := add(0x15b52534031ae18f7f862cb2cf7cf760ab10a8150a337b1ccd99ff6e8797d428, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0dc8fad6d9e4b35f5ed9a3d186b79ce38e0e8a8d1b58b132d701d4eecf68d1f6, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1bcd95ffc211fbca600f705fad3fb567ea4eb378f62e1fec97805518a47e4d9c, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := mulmod(scratch1, scratch1, F)\\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\\n state0 := mulmod(scratch2, scratch2, F)\\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\\n state0 := add(0x10520b0ab721cadfe9eff81b016fc34dc76da36c2578937817cb978d069de559, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1f6d48149b8e7f7d9b257d8ed5fbbaf42932498075fed0ace88a9eb81f5627f6, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1d9655f652309014d29e00ef35a2089bfff8dc1c816f0dc9ca34bdb5460c8705, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x04df5a56ff95bcafb051f7b1cd43a99ba731ff67e47032058fe3d4185697cc7d, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0672d995f8fff640151b3d290cedaf148690a10a8c8424a7f6ec282b6e4be828, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x099952b414884454b21200d7ffafdd5f0c9a9dcc06f2708e9fc1d8209b5c75b9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x052cba2255dfd00c7c483143ba8d469448e43586a9b4cd9183fd0e843a6b9fa6, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0b8badee690adb8eb0bd74712b7999af82de55707251ad7716077cb93c464ddc, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x119b1590f13307af5a1ee651020c07c749c15d60683a8050b963d0a8e4b2bdd1, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x03150b7cd6d5d17b2529d36be0f67b832c4acfc884ef4ee5ce15be0bfb4a8d09, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2cc6182c5e14546e3cf1951f173912355374efb83d80898abe69cb317c9ea565, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x005032551e6378c450cfe129a404b3764218cadedac14e2b92d2cd73111bf0f9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x233237e3289baa34bb147e972ebcb9516469c399fcc069fb88f9da2cc28276b5, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x05c8f4f4ebd4a6e3c980d31674bfbe6323037f21b34ae5a4e80c2d4c24d60280, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0a7b1db13042d396ba05d818a319f25252bcf35ef3aeed91ee1f09b2590fc65b, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2a73b71f9b210cf5b14296572c9d32dbf156e2b086ff47dc5df542365a404ec0, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1ac9b0417abcc9a1935107e9ffc91dc3ec18f2c4dbe7f22976a760bb5c50c460, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x12c0339ae08374823fabb076707ef479269f3e4d6cb104349015ee046dc93fc0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0b7475b102a165ad7f5b18db4e1e704f52900aa3253baac68246682e56e9a28e, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x037c2849e191ca3edb1c5e49f6e8b8917c843e379366f2ea32ab3aa88d7f8448, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x05a6811f8556f014e92674661e217e9bd5206c5c93a07dc145fdb176a716346f, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x29a795e7d98028946e947b75d54e9f044076e87a7b2883b47b675ef5f38bd66e, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x20439a0c84b322eb45a3857afc18f5826e8c7382c8a1585c507be199981fd22f, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2e0ba8d94d9ecf4a94ec2050c7371ff1bb50f27799a84b6d4a2a6f2a0982c887, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x143fd115ce08fb27ca38eb7cce822b4517822cd2109048d2e6d0ddcca17d71c8, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0c64cbecb1c734b857968dbbdcf813cdf8611659323dbcbfc84323623be9caf1, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x028a305847c683f646fca925c163ff5ae74f348d62c2b670f1426cef9403da53, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2e4ef510ff0b6fda5fa940ab4c4380f26a6bcb64d89427b824d6755b5db9e30c, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0081c95bc43384e663d79270c956ce3b8925b4f6d033b078b96384f50579400e, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2ed5f0c91cbd9749187e2fade687e05ee2491b349c039a0bba8a9f4023a0bb38, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x30509991f88da3504bbf374ed5aae2f03448a22c76234c8c990f01f33a735206, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1c3f20fd55409a53221b7c4d49a356b9f0a1119fb2067b41a7529094424ec6ad, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x10b4e7f3ab5df003049514459b6e18eec46bb2213e8e131e170887b47ddcb96c, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2a1982979c3ff7f43ddd543d891c2abddd80f804c077d775039aa3502e43adef, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1c74ee64f15e1db6feddbead56d6d55dba431ebc396c9af95cad0f1315bd5c91, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x07533ec850ba7f98eab9303cace01b4b9e4f2e8b82708cfa9c2fe45a0ae146a0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x21576b438e500449a151e4eeaf17b154285c68f42d42c1808a11abf3764c0750, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x2f17c0559b8fe79608ad5ca193d62f10bce8384c815f0906743d6930836d4a9e, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x2d477e3862d07708a79e8aae946170bc9775a4201318474ae665b0b1b7e2730e, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x162f5243967064c390e095577984f291afba2266c38f5abcd89be0f5b2747eab, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2b4cb233ede9ba48264ecd2c8ae50d1ad7a8596a87f29f8a7777a70092393311, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2c8fbcb2dd8573dc1dbaf8f4622854776db2eece6d85c4cf4254e7c35e03b07a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x1d6f347725e4816af2ff453f0cd56b199e1b61e9f601e9ade5e88db870949da9, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x204b0c397f4ebe71ebc2d8b3df5b913df9e6ac02b68d31324cd49af5c4565529, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0c4cb9dc3c4fd8174f1149b3c63c3c2f9ecb827cd7dc25534ff8fb75bc79c502, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x174ad61a1448c899a25416474f4930301e5c49475279e0639a616ddc45bc7b54, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1a96177bcf4d8d89f759df4ec2f3cde2eaaa28c177cc0fa13a9816d49a38d2ef, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x066d04b24331d71cd0ef8054bc60c4ff05202c126a233c1a8242ace360b8a30a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2a4c4fc6ec0b0cf52195782871c6dd3b381cc65f72e02ad527037a62aa1bd804, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x13ab2d136ccf37d447e9f2e14a7cedc95e727f8446f6d9d7e55afc01219fd649, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1121552fca26061619d24d843dc82769c1b04fcec26f55194c2e3e869acc6a9a, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x00ef653322b13d6c889bc81715c37d77a6cd267d595c4a8909a5546c7c97cff1, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0e25483e45a665208b261d8ba74051e6400c776d652595d9845aca35d8a397d3, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x29f536dcb9dd7682245264659e15d88e395ac3d4dde92d8c46448db979eeba89, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2a56ef9f2c53febadfda33575dbdbd885a124e2780bbea170e456baace0fa5be, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1c8361c78eb5cf5decfb7a2d17b5c409f2ae2999a46762e8ee416240a8cb9af1, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x151aff5f38b20a0fc0473089aaf0206b83e8e68a764507bfd3d0ab4be74319c5, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x04c6187e41ed881dc1b239c88f7f9d43a9f52fc8c8b6cdd1e76e47615b51f100, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x13b37bd80f4d27fb10d84331f6fb6d534b81c61ed15776449e801b7ddc9c2967, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x01a5c536273c2d9df578bfbd32c17b7a2ce3664c2a52032c9321ceb1c4e8a8e4, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2ab3561834ca73835ad05f5d7acb950b4a9a2c666b9726da832239065b7c3b02, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1d4d8ec291e720db200fe6d686c0d613acaf6af4e95d3bf69f7ed516a597b646, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x041294d2cc484d228f5784fe7919fd2bb925351240a04b711514c9c80b65af1d, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x154ac98e01708c611c4fa715991f004898f57939d126e392042971dd90e81fc6, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0b339d8acca7d4f83eedd84093aef51050b3684c88f8b0b04524563bc6ea4da4, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x0955e49e6610c94254a4f84cfbab344598f0e71eaff4a7dd81ed95b50839c82e, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x06746a6156eba54426b9e22206f15abca9a6f41e6f535c6f3525401ea0654626, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0f18f5a0ecd1423c496f3820c549c27838e5790e2bd0a196ac917c7ff32077fb, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x04f6eeca1751f7308ac59eff5beb261e4bb563583ede7bc92a738223d6f76e13, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2b56973364c4c4f5c1a3ec4da3cdce038811eb116fb3e45bc1768d26fc0b3758, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x123769dd49d5b054dcd76b89804b1bcb8e1392b385716a5d83feb65d437f29ef, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2147b424fc48c80a88ee52b91169aacea989f6446471150994257b2fb01c63e9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0fdc1f58548b85701a6c5505ea332a29647e6f34ad4243c2ea54ad897cebe54d, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x12373a8251fea004df68abcf0f7786d4bceff28c5dbbe0c3944f685cc0a0b1f2, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x21e4f4ea5f35f85bad7ea52ff742c9e8a642756b6af44203dd8a1f35c1a90035, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x16243916d69d2ca3dfb4722224d4c462b57366492f45e90d8a81934f1bc3b147, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1efbe46dd7a578b4f66f9adbc88b4378abc21566e1a0453ca13a4159cac04ac2, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x07ea5e8537cf5dd08886020e23a7f387d468d5525be66f853b672cc96a88969a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x05a8c4f9968b8aa3b7b478a30f9a5b63650f19a75e7ce11ca9fe16c0b76c00bc, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x20f057712cc21654fbfe59bd345e8dac3f7818c701b9c7882d9d57b72a32e83f, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x04a12ededa9dfd689672f8c67fee31636dcd8e88d01d49019bd90b33eb33db69, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x27e88d8c15f37dcee44f1e5425a51decbd136ce5091a6767e49ec9544ccd101a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2feed17b84285ed9b8a5c8c5e95a41f66e096619a7703223176c41ee433de4d1, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1ed7cc76edf45c7c404241420f729cf394e5942911312a0d6972b8bd53aff2b8, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x15742e99b9bfa323157ff8c586f5660eac6783476144cdcadf2874be45466b1a, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1aac285387f65e82c895fc6887ddf40577107454c6ec0317284f033f27d0c785, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x25851c3c845d4790f9ddadbdb6057357832e2e7a49775f71ec75a96554d67c77, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x15a5821565cc2ec2ce78457db197edf353b7ebba2c5523370ddccc3d9f146a67, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2411d57a4813b9980efa7e31a1db5966dcf64f36044277502f15485f28c71727, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x002e6f8d6520cd4713e335b8c0b6d2e647e9a98e12f4cd2558828b5ef6cb4c9b, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2ff7bc8f4380cde997da00b616b0fcd1af8f0e91e2fe1ed7398834609e0315d2, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x00b9831b948525595ee02724471bcd182e9521f6b7bb68f1e93be4febb0d3cbe, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0a2f53768b8ebf6a86913b0e57c04e011ca408648a4743a87d77adbf0c9c3512, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x00248156142fd0373a479f91ff239e960f599ff7e94be69b7f2a290305e1198d, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x171d5620b87bfb1328cf8c02ab3f0c9a397196aa6a542c2350eb512a2b2bcda9, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x170a4f55536f7dc970087c7c10d6fad760c952172dd54dd99d1045e4ec34a808, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x29aba33f799fe66c2ef3134aea04336ecc37e38c1cd211ba482eca17e2dbfae1, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1e9bc179a4fdd758fdd1bb1945088d47e70d114a03f6a0e8b5ba650369e64973, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1dd269799b660fad58f7f4892dfb0b5afeaad869a9c4b44f9c9e1c43bdaf8f09, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x22cdbc8b70117ad1401181d02e15459e7ccd426fe869c7c95d1dd2cb0f24af38, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0ef042e454771c533a9f57a55c503fcefd3150f52ed94a7cd5ba93b9c7dacefd, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x11609e06ad6c8fe2f287f3036037e8851318e8b08a0359a03b304ffca62e8284, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x1166d9e554616dba9e753eea427c17b7fecd58c076dfe42708b08f5b783aa9af, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x2de52989431a859593413026354413db177fbf4cd2ac0b56f855a888357ee466, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x3006eb4ffc7a85819a6da492f3a8ac1df51aee5b17b8e89d74bf01cf5f71e9ad, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2af41fbb61ba8a80fdcf6fff9e3f6f422993fe8f0a4639f962344c8225145086, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x119e684de476155fe5a6b41a8ebc85db8718ab27889e85e781b214bace4827c3, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1835b786e2e8925e188bea59ae363537b51248c23828f047cff784b97b3fd800, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x28201a34c594dfa34d794996c6433a20d152bac2a7905c926c40e285ab32eeb6, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x083efd7a27d1751094e80fefaf78b000864c82eb571187724a761f88c22cc4e7, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0b6f88a3577199526158e61ceea27be811c16df7774dd8519e079564f61fd13b, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x0ec868e6d15e51d9644f66e1d6471a94589511ca00d29e1014390e6ee4254f5b, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2af33e3f866771271ac0c9b3ed2e1142ecd3e74b939cd40d00d937ab84c98591, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x0b520211f904b5e7d09b5d961c6ace7734568c547dd6858b364ce5e47951f178, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0b2d722d0919a1aad8db58f10062a92ea0c56ac4270e822cca228620188a1d40, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1f790d4d7f8cf094d980ceb37c2453e957b54a9991ca38bbe0061d1ed6e562d4, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0171eb95dfbf7d1eaea97cd385f780150885c16235a2a6a8da92ceb01e504233, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x0c2d0e3b5fd57549329bf6885da66b9b790b40defd2c8650762305381b168873, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1162fb28689c27154e5a8228b4e72b377cbcafa589e283c35d3803054407a18d, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2f1459b65dee441b64ad386a91e8310f282c5a92a89e19921623ef8249711bc0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x1e6ff3216b688c3d996d74367d5cd4c1bc489d46754eb712c243f70d1b53cfbb, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x01ca8be73832b8d0681487d27d157802d741a6f36cdc2a0576881f9326478875, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1f7735706ffe9fc586f976d5bdf223dc680286080b10cea00b9b5de315f9650e, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2522b60f4ea3307640a0c2dce041fba921ac10a3d5f096ef4745ca838285f019, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x23f0bee001b1029d5255075ddc957f833418cad4f52b6c3f8ce16c235572575b, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2bc1ae8b8ddbb81fcaac2d44555ed5685d142633e9df905f66d9401093082d59, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0f9406b8296564a37304507b8dba3ed162371273a07b1fc98011fcd6ad72205f, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x2360a8eb0cc7defa67b72998de90714e17e75b174a52ee4acb126c8cd995f0a8, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x15871a5cddead976804c803cbaef255eb4815a5e96df8b006dcbbc2767f88948, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x193a56766998ee9e0a8652dd2f3b1da0362f4f54f72379544f957ccdeefb420f, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2a394a43934f86982f9be56ff4fab1703b2e63c8ad334834e4309805e777ae0f, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1859954cfeb8695f3e8b635dcb345192892cd11223443ba7b4166e8876c0d142, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x04e1181763050e58013444dbcb99f1902b11bc25d90bbdca408d3819f4fed32b, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0fdb253dee83869d40c335ea64de8c5bb10eb82db08b5e8b1f5e5552bfd05f23, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x058cbe8a9a5027bdaa4efb623adead6275f08686f1c08984a9d7c5bae9b4f1c0, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x1382edce9971e186497eadb1aeb1f52b23b4b83bef023ab0d15228b4cceca59a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x03464990f045c6ee0819ca51fd11b0be7f61b8eb99f14b77e1e6634601d9e8b5, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x23f7bfc8720dc296fff33b41f98ff83c6fcab4605db2eb5aaa5bc137aeb70a58, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0a59a158e3eec2117e6e94e7f0e9decf18c3ffd5e1531a9219636158bbaf62f2, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x06ec54c80381c052b58bf23b312ffd3ce2c4eba065420af8f4c23ed0075fd07b, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x118872dc832e0eb5476b56648e867ec8b09340f7a7bcb1b4962f0ff9ed1f9d01, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x13d69fa127d834165ad5c7cba7ad59ed52e0b0f0e42d7fea95e1906b520921b1, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x169a177f63ea681270b1c6877a73d21bde143942fb71dc55fd8a49f19f10c77b, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x04ef51591c6ead97ef42f287adce40d93abeb032b922f66ffb7e9a5a7450544d, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x256e175a1dc079390ecd7ca703fb2e3b19ec61805d4f03ced5f45ee6dd0f69ec, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x30102d28636abd5fe5f2af412ff6004f75cc360d3205dd2da002813d3e2ceeb2, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x10998e42dfcd3bbf1c0714bc73eb1bf40443a3fa99bef4a31fd31be182fcc792, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x193edd8e9fcf3d7625fa7d24b598a1d89f3362eaf4d582efecad76f879e36860, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x18168afd34f2d915d0368ce80b7b3347d1c7a561ce611425f2664d7aa51f0b5d, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x29383c01ebd3b6ab0c017656ebe658b6a328ec77bc33626e29e2e95b33ea6111, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x10646d2f2603de39a1f4ae5e7771a64a702db6e86fb76ab600bf573f9010c711, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0beb5e07d1b27145f575f1395a55bf132f90c25b40da7b3864d0242dcb1117fb, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x16d685252078c133dc0d3ecad62b5c8830f95bb2e54b59abdffbf018d96fa336, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x0a6abd1d833938f33c74154e0404b4b40a555bbbec21ddfafd672dd62047f01a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1a679f5d36eb7b5c8ea12a4c2dedc8feb12dffeec450317270a6f19b34cf1860, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x0980fb233bd456c23974d50e0ebfde4726a423eada4e8f6ffbc7592e3f1b93d6, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x161b42232e61b84cbf1810af93a38fc0cece3d5628c9282003ebacb5c312c72b, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0ada10a90c7f0520950f7d47a60d5e6a493f09787f1564e5d09203db47de1a0b, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1a730d372310ba82320345a29ac4238ed3f07a8a2b4e121bb50ddb9af407f451, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2c8120f268ef054f817064c369dda7ea908377feaba5c4dffbda10ef58e8c556, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1c7c8824f758753fa57c00789c684217b930e95313bcb73e6e7b8649a4968f70, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2cd9ed31f5f8691c8e39e4077a74faa0f400ad8b491eb3f7b47b27fa3fd1cf77, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x23ff4f9d46813457cf60d92f57618399a5e022ac321ca550854ae23918a22eea, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x09945a5d147a4f66ceece6405dddd9d0af5a2c5103529407dff1ea58f180426d, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x188d9c528025d4c2b67660c6b771b90f7c7da6eaa29d3f268a6dd223ec6fc630, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x3050e37996596b7f81f68311431d8734dba7d926d3633595e0c0d8ddf4f0f47f, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x15af1169396830a91600ca8102c35c426ceae5461e3f95d89d829518d30afd78, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1da6d09885432ea9a06d9f37f873d985dae933e351466b2904284da3320d8acc, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2796ea90d269af29f5f8acf33921124e4e4fad3dbe658945e546ee411ddaa9cb, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x202d7dd1da0f6b4b0325c8b3307742f01e15612ec8e9304a7cb0319e01d32d60, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x096d6790d05bb759156a952ba263d672a2d7f9c788f4c831a29dace4c0f8be5f, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x054efa1f65b0fce283808965275d877b438da23ce5b13e1963798cb1447d25a4, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1b162f83d917e93edb3308c29802deb9d8aa690113b2e14864ccf6e18e4165f1, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x21e5241e12564dd6fd9f1cdd2a0de39eedfefc1466cc568ec5ceb745a0506edc, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := mulmod(scratch1, scratch1, F)\\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\\n state0 := mulmod(scratch2, scratch2, F)\\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\\n state0 := add(0x1cfb5662e8cf5ac9226a80ee17b36abecb73ab5f87e161927b4349e10e4bdf08, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0f21177e302a771bbae6d8d1ecb373b62c99af346220ac0129c53f666eb24100, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1671522374606992affb0dd7f71b12bec4236aede6290546bcef7e1f515c2320, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := mulmod(state1, state1, F)\\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\\n scratch0 := mulmod(state2, state2, F)\\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\\n scratch0 := add(0x0fa3ec5b9488259c2eb4cf24501bfad9be2ec9e42c5cc8ccd419d2a692cad870, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x193c0e04e0bd298357cb266c1506080ed36edce85c648cc085e8c57b1ab54bba, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x102adf8ef74735a27e9128306dcbc3c99f6f7291cd406578ce14ea2adaba68f8, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := mulmod(scratch1, scratch1, F)\\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\\n state0 := mulmod(scratch2, scratch2, F)\\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\\n state0 := add(0x0fe0af7858e49859e2a54d6f1ad945b1316aa24bfbdd23ae40a6d0cb70c3eab1, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x216f6717bbc7dedb08536a2220843f4e2da5f1daa9ebdefde8a5ea7344798d22, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1da55cc900f0d21f4a3e694391918a1b3c23b2ac773c6b3ef88e2e4228325161, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := mulmod(state1, state1, F)\\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\\n scratch0 := mulmod(state2, state2, F)\\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\\n\\n mstore(0x0, mod(add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)), F))\\n\\n return(0, 0x20)\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0102caa303bbc6690508f3615604f7730789ed990058c9513a87ccb30e4835be\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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__$75f79a42d9bcbdbb69ad79ebd80f556f39$__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", + "libraries": { + "PoseidonT3": "0x3333333C0A88F9BE4fd23ed0536F9B6c427e3B93" + }, + "devdoc": { + "errors": { + "AddressEmptyCode(address)": [ + { + "details": "There's no code at `target` (it is not a contract)." + } + ], + "AddressInsufficientBalance(address)": [ + { + "details": "The ETH balance of the account is not enough to perform the operation." + } + ], + "FailedInnerCall()": [ + { + "details": "A call to an address target failed. The target may have reverted." + } + ], + "ReentrancyGuardReentrantCall()": [ + { + "details": "Unauthorized reentrant call." + } + ], + "SafeERC20FailedOperation(address)": [ + { + "details": "An operation with an ERC20 token failed." + } + ] + }, + "kind": "dev", + "methods": { + "getZeroHash(uint256)": { + "details": "Exposed for Poseidon/zero-hash consistency tests (JS vs Solidity)" + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [ + { + "astId": 667, + "contract": "contracts/Mixer.sol:Mixer", + "label": "_status", + "offset": 0, + "slot": "0", + "type": "t_uint256" + }, + { + "astId": 805, + "contract": "contracts/Mixer.sol:Mixer", + "label": "trees", + "offset": 0, + "slot": "1", + "type": "t_mapping(t_bytes32,t_struct(MerkleTree)788_storage)" + }, + { + "astId": 811, + "contract": "contracts/Mixer.sol:Mixer", + "label": "rootHistory", + "offset": 0, + "slot": "2", + "type": "t_mapping(t_bytes32,t_array(t_bytes32)30_storage)" + }, + { + "astId": 815, + "contract": "contracts/Mixer.sol:Mixer", + "label": "rootHistoryIndex", + "offset": 0, + "slot": "3", + "type": "t_mapping(t_bytes32,t_uint256)" + }, + { + "astId": 821, + "contract": "contracts/Mixer.sol:Mixer", + "label": "nullifierUsed", + "offset": 0, + "slot": "4", + "type": "t_mapping(t_bytes32,t_mapping(t_bytes32,t_bool))" + }, + { + "astId": 825, + "contract": "contracts/Mixer.sol:Mixer", + "label": "allowedDenominations", + "offset": 0, + "slot": "5", + "type": "t_mapping(t_bytes32,t_bool)" + }, + { + "astId": 829, + "contract": "contracts/Mixer.sol:Mixer", + "label": "commitmentUsed", + "offset": 0, + "slot": "6", + "type": "t_mapping(t_bytes32,t_bool)" + }, + { + "astId": 835, + "contract": "contracts/Mixer.sol:Mixer", + "label": "zeroHashes", + "offset": 0, + "slot": "7", + "type": "t_array(t_uint256)21_storage" + } + ], + "types": { + "t_array(t_bytes32)30_storage": { + "base": "t_bytes32", + "encoding": "inplace", + "label": "bytes32[30]", + "numberOfBytes": "960" + }, + "t_array(t_uint256)20_storage": { + "base": "t_uint256", + "encoding": "inplace", + "label": "uint256[20]", + "numberOfBytes": "640" + }, + "t_array(t_uint256)21_storage": { + "base": "t_uint256", + "encoding": "inplace", + "label": "uint256[21]", + "numberOfBytes": "672" + }, + "t_bool": { + "encoding": "inplace", + "label": "bool", + "numberOfBytes": "1" + }, + "t_bytes32": { + "encoding": "inplace", + "label": "bytes32", + "numberOfBytes": "32" + }, + "t_mapping(t_bytes32,t_array(t_bytes32)30_storage)": { + "encoding": "mapping", + "key": "t_bytes32", + "label": "mapping(bytes32 => bytes32[30])", + "numberOfBytes": "32", + "value": "t_array(t_bytes32)30_storage" + }, + "t_mapping(t_bytes32,t_bool)": { + "encoding": "mapping", + "key": "t_bytes32", + "label": "mapping(bytes32 => bool)", + "numberOfBytes": "32", + "value": "t_bool" + }, + "t_mapping(t_bytes32,t_mapping(t_bytes32,t_bool))": { + "encoding": "mapping", + "key": "t_bytes32", + "label": "mapping(bytes32 => mapping(bytes32 => bool))", + "numberOfBytes": "32", + "value": "t_mapping(t_bytes32,t_bool)" + }, + "t_mapping(t_bytes32,t_struct(MerkleTree)788_storage)": { + "encoding": "mapping", + "key": "t_bytes32", + "label": "mapping(bytes32 => struct Mixer.MerkleTree)", + "numberOfBytes": "32", + "value": "t_struct(MerkleTree)788_storage" + }, + "t_mapping(t_bytes32,t_uint256)": { + "encoding": "mapping", + "key": "t_bytes32", + "label": "mapping(bytes32 => uint256)", + "numberOfBytes": "32", + "value": "t_uint256" + }, + "t_struct(MerkleTree)788_storage": { + "encoding": "inplace", + "label": "struct Mixer.MerkleTree", + "members": [ + { + "astId": 783, + "contract": "contracts/Mixer.sol:Mixer", + "label": "nextIndex", + "offset": 0, + "slot": "0", + "type": "t_uint256" + }, + { + "astId": 787, + "contract": "contracts/Mixer.sol:Mixer", + "label": "filledSubtrees", + "offset": 0, + "slot": "1", + "type": "t_array(t_uint256)20_storage" + } + ], + "numberOfBytes": "672" + }, + "t_uint256": { + "encoding": "inplace", + "label": "uint256", + "numberOfBytes": "32" + } + } + } +} \ No newline at end of file diff --git a/packages/hardhat/deployments/baseSepolia/solcInputs/7f0373dedc61097daaf6a7dfc1f19d7a.json b/packages/hardhat/deployments/baseSepolia/solcInputs/7f0373dedc61097daaf6a7dfc1f19d7a.json new file mode 100644 index 0000000..4714154 --- /dev/null +++ b/packages/hardhat/deployments/baseSepolia/solcInputs/7f0373dedc61097daaf6a7dfc1f19d7a.json @@ -0,0 +1,54 @@ +{ + "language": "Solidity", + "sources": { + "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * ==== Security Considerations\n *\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\n * generally recommended is:\n *\n * ```solidity\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\n * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\n * doThing(..., value);\n * }\n *\n * function doThing(..., uint256 value) public {\n * token.safeTransferFrom(msg.sender, address(this), value);\n * ...\n * }\n * ```\n *\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\n * {SafeERC20-safeTransferFrom}).\n *\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\n * contracts should have entry points that don't rely on permit.\n */\ninterface IERC20Permit {\n /**\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n * given ``owner``'s signed approval.\n *\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n * ordering also apply here.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `deadline` must be a timestamp in the future.\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n * over the EIP712-formatted function arguments.\n * - the signature must use ``owner``'s current nonce (see {nonces}).\n *\n * For more information on the signature format, see the\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n * section].\n *\n * CAUTION: See Security Considerations above.\n */\n function permit(\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external;\n\n /**\n * @dev Returns the current nonce for `owner`. This value must be\n * included whenever a signature is generated for {permit}.\n *\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\n * prevents a signature from being used multiple times.\n */\n function nonces(address owner) external view returns (uint256);\n\n /**\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n */\n // solhint-disable-next-line func-name-mixedcase\n function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/IERC20.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n\n /**\n * @dev Returns the value of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the value of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address to, uint256 value) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n * caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 value) external returns (bool);\n\n /**\n * @dev Moves a `value` amount of tokens from `from` to `to` using the\n * allowance mechanism. `value` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\nimport {IERC20Permit} from \"../extensions/IERC20Permit.sol\";\nimport {Address} from \"../../../utils/Address.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n using Address for address;\n\n /**\n * @dev An operation with an ERC20 token failed.\n */\n error SafeERC20FailedOperation(address token);\n\n /**\n * @dev Indicates a failed `decreaseAllowance` request.\n */\n error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\n\n /**\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n * non-reverting calls are assumed to be successful.\n */\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\n }\n\n /**\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n */\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\n }\n\n /**\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n * non-reverting calls are assumed to be successful.\n */\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n uint256 oldAllowance = token.allowance(address(this), spender);\n forceApprove(token, spender, oldAllowance + value);\n }\n\n /**\n * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\n * value, non-reverting calls are assumed to be successful.\n */\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\n unchecked {\n uint256 currentAllowance = token.allowance(address(this), spender);\n if (currentAllowance < requestedDecrease) {\n revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\n }\n forceApprove(token, spender, currentAllowance - requestedDecrease);\n }\n }\n\n /**\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n * to be set to zero before setting it to a non-zero value, such as USDT.\n */\n function forceApprove(IERC20 token, address spender, uint256 value) internal {\n bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\n\n if (!_callOptionalReturnBool(token, approvalCall)) {\n _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\n _callOptionalReturn(token, approvalCall);\n }\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n */\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\n // the target address contains contract code and also asserts for success in the low-level call.\n\n bytes memory returndata = address(token).functionCall(data);\n if (returndata.length != 0 && !abi.decode(returndata, (bool))) {\n revert SafeERC20FailedOperation(address(token));\n }\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n *\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\n */\n function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\n // and not revert is the subcall reverts.\n\n (bool success, bytes memory returndata) = address(token).call(data);\n return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;\n }\n}\n" + }, + "@openzeppelin/contracts/utils/Address.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n /**\n * @dev The ETH balance of the account is not enough to perform the operation.\n */\n error AddressInsufficientBalance(address account);\n\n /**\n * @dev There's no code at `target` (it is not a contract).\n */\n error AddressEmptyCode(address target);\n\n /**\n * @dev A call to an address target failed. The target may have reverted.\n */\n error FailedInnerCall();\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n if (address(this).balance < amount) {\n revert AddressInsufficientBalance(address(this));\n }\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n if (!success) {\n revert FailedInnerCall();\n }\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason or custom error, it is bubbled\n * up by this function (like regular Solidity function calls). However, if\n * the call reverted with no returned reason, this function reverts with a\n * {FailedInnerCall} error.\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n if (address(this).balance < value) {\n revert AddressInsufficientBalance(address(this));\n }\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResultFromTarget(target, success, returndata);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResultFromTarget(target, success, returndata);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return verifyCallResultFromTarget(target, success, returndata);\n }\n\n /**\n * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\n * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an\n * unsuccessful call.\n */\n function verifyCallResultFromTarget(\n address target,\n bool success,\n bytes memory returndata\n ) internal view returns (bytes memory) {\n if (!success) {\n _revert(returndata);\n } else {\n // only check if target is a contract if the call was successful and the return data is empty\n // otherwise we already know that it was a contract\n if (returndata.length == 0 && target.code.length == 0) {\n revert AddressEmptyCode(target);\n }\n return returndata;\n }\n }\n\n /**\n * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\n * revert reason or with a default {FailedInnerCall} error.\n */\n function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\n if (!success) {\n _revert(returndata);\n } else {\n return returndata;\n }\n }\n\n /**\n * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.\n */\n function _revert(bytes memory returndata) private pure {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert FailedInnerCall();\n }\n }\n}\n" + }, + "@openzeppelin/contracts/utils/ReentrancyGuard.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard {\n // Booleans are more expensive than uint256 or any type that takes up a full\n // word because each write operation emits an extra SLOAD to first read the\n // slot's contents, replace the bits taken up by the boolean, and then write\n // back. This is the compiler's defense against contract upgrades and\n // pointer aliasing, and it cannot be disabled.\n\n // The values being non-zero value makes deployment a bit more expensive,\n // but in exchange the refund on every call to nonReentrant will be lower in\n // amount. Since refunds are capped to a percentage of the total\n // transaction's gas, it is best to keep them low in cases like this one, to\n // increase the likelihood of the full refund coming into effect.\n uint256 private constant NOT_ENTERED = 1;\n uint256 private constant ENTERED = 2;\n\n uint256 private _status;\n\n /**\n * @dev Unauthorized reentrant call.\n */\n error ReentrancyGuardReentrantCall();\n\n constructor() {\n _status = NOT_ENTERED;\n }\n\n /**\n * @dev Prevents a contract from calling itself, directly or indirectly.\n * Calling a `nonReentrant` function from another `nonReentrant`\n * function is not supported. It is possible to prevent this from happening\n * by making the `nonReentrant` function external, and making it call a\n * `private` function that does the actual work.\n */\n modifier nonReentrant() {\n _nonReentrantBefore();\n _;\n _nonReentrantAfter();\n }\n\n function _nonReentrantBefore() private {\n // On the first call to nonReentrant, _status will be NOT_ENTERED\n if (_status == ENTERED) {\n revert ReentrancyGuardReentrantCall();\n }\n\n // Any calls to nonReentrant after this point will fail\n _status = ENTERED;\n }\n\n function _nonReentrantAfter() private {\n // By storing the original value once again, a refund is triggered (see\n // https://eips.ethereum.org/EIPS/eip-2200)\n _status = NOT_ENTERED;\n }\n\n /**\n * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n * `nonReentrant` function in the call stack.\n */\n function _reentrancyGuardEntered() internal view returns (bool) {\n return _status == ENTERED;\n }\n}\n" + }, + "contracts/Mixer.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.13;\n\nimport \"@openzeppelin/contracts/utils/ReentrancyGuard.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"poseidon-solidity/PoseidonT3.sol\";\n\ninterface IVerifyProofAggregation {\n function verifyProofAggregation(\n uint256 _domainId,\n uint256 _aggregationId,\n bytes32 _leaf,\n bytes32[] calldata _merklePath,\n uint256 _leafCount,\n uint256 _index\n ) external view returns (bool);\n}\n\ncontract Mixer is ReentrancyGuard {\n uint256 public constant BN254_PRIME = 21888242871839275222246405745257275088548364400416034343698204186575808495617;\n bytes32 public constant PROVING_SYSTEM_ID = keccak256(abi.encodePacked(\"ultraplonk\"));\n bytes32 public constant VERSION_HASH = sha256(abi.encodePacked(\"\"));\n uint256 public constant TREE_DEPTH = 20;\n uint256 public constant ROOT_HISTORY_SIZE = 30;\n\n address public immutable zkvContract;\n bytes32 public immutable vkHash;\n\n struct MerkleTree {\n uint256 nextIndex;\n uint256[TREE_DEPTH] filledSubtrees;\n }\n\n struct MixerProof {\n uint256 aggregationId;\n uint256 domainId;\n bytes32[] zkMerklePath;\n uint256 leafCount;\n uint256 index;\n }\n\n mapping(bytes32 => MerkleTree) public trees;\n mapping(bytes32 => bytes32[ROOT_HISTORY_SIZE]) public rootHistory;\n mapping(bytes32 => uint256) public rootHistoryIndex;\n mapping(bytes32 => mapping(bytes32 => bool)) public nullifierUsed;\n mapping(bytes32 => bool) public allowedDenominations;\n mapping(bytes32 => bool) public commitmentUsed;\n\n uint256[TREE_DEPTH + 1] internal zeroHashes;\n\n event Deposit(bytes32 indexed commitment, uint256 leafIndex, uint256 timestamp, address indexed token, uint256 denomination);\n event Withdrawal(address indexed recipient, bytes32 nullifierHash, address indexed token, uint256 denomination, uint256 timestamp);\n\n constructor(\n address _zkvContract,\n bytes32 _vkHash,\n bytes32[] memory _allowedPoolIds\n ) {\n require(_zkvContract != address(0), \"Invalid zkv\");\n zkvContract = _zkvContract;\n vkHash = _vkHash;\n for (uint256 i = 0; i < _allowedPoolIds.length; i++) {\n allowedDenominations[_allowedPoolIds[i]] = true;\n }\n _computeZeroHashes();\n }\n\n function _computeZeroHashes() internal {\n zeroHashes[0] = 0;\n for (uint256 i = 1; i <= TREE_DEPTH; i++) {\n zeroHashes[i] = _poseidonHash2(zeroHashes[i - 1], zeroHashes[i - 1]);\n }\n }\n\n /// @dev Exposed for Poseidon/zero-hash consistency tests (JS vs Solidity)\n function getZeroHash(uint256 level) external view returns (bytes32) {\n require(level <= TREE_DEPTH, \"level\");\n return bytes32(zeroHashes[level]);\n }\n\n function _poseidonHash2(uint256 a, uint256 b) internal view returns (uint256) {\n uint256 safeA = a % BN254_PRIME;\n uint256 safeB = b % BN254_PRIME;\n return PoseidonT3.hash([safeA, safeB]);\n }\n\n function _poolId(address token, uint256 denomination) internal pure returns (bytes32) {\n return keccak256(abi.encodePacked(token, denomination));\n }\n\n function deposit(address token, uint256 denomination, bytes32 commitment) external payable nonReentrant {\n bytes32 poolId = _poolId(token, denomination);\n require(allowedDenominations[poolId], \"Denomination not allowed\");\n require(!commitmentUsed[commitment], \"Commitment already used\");\n\n if (token == address(0)) {\n require(msg.value == denomination, \"ETH value mismatch\");\n } else {\n require(msg.value == 0, \"No ETH for ERC20\");\n SafeERC20.safeTransferFrom(IERC20(token), msg.sender, address(this), denomination);\n }\n\n uint256 leaf = uint256(commitment);\n MerkleTree storage tree = trees[poolId];\n uint256 leafIndex = tree.nextIndex;\n tree.nextIndex++;\n\n uint256 current = leaf;\n for (uint256 i = 0; i < TREE_DEPTH; i++) {\n if ((leafIndex >> i) % 2 == 0) {\n tree.filledSubtrees[i] = current;\n current = _poseidonHash2(current, zeroHashes[i]);\n } else {\n current = _poseidonHash2(tree.filledSubtrees[i], current);\n }\n }\n\n uint256 root = current;\n uint256 rhi = rootHistoryIndex[poolId] % ROOT_HISTORY_SIZE;\n rootHistory[poolId][rhi] = bytes32(root);\n rootHistoryIndex[poolId]++;\n\n commitmentUsed[commitment] = true;\n\n emit Deposit(commitment, tree.nextIndex - 1, block.timestamp, token, denomination);\n }\n\n function isKnownRoot(bytes32 poolId, bytes32 root) public view returns (bool) {\n uint256 rhi = rootHistoryIndex[poolId];\n if (rhi == 0) return false;\n uint256 size = rhi < ROOT_HISTORY_SIZE ? rhi : ROOT_HISTORY_SIZE;\n for (uint256 i = 0; i < size; i++) {\n uint256 idx = (rhi - 1 - i) % ROOT_HISTORY_SIZE;\n if (rootHistory[poolId][idx] == root) return true;\n }\n return false;\n }\n\n function _verifyMixerProof(\n bytes32 root,\n bytes32 nullifierHash,\n address recipient,\n address token,\n uint256 denomination,\n MixerProof calldata proof\n ) internal view returns (bool) {\n bytes memory encodedInputs = abi.encodePacked(\n root,\n nullifierHash,\n uint256(uint160(recipient)),\n uint256(uint160(token)),\n denomination\n );\n bytes32 leaf = keccak256(abi.encodePacked(PROVING_SYSTEM_ID, vkHash, VERSION_HASH, keccak256(encodedInputs)));\n return IVerifyProofAggregation(zkvContract).verifyProofAggregation(\n proof.domainId,\n proof.aggregationId,\n leaf,\n proof.zkMerklePath,\n proof.leafCount,\n proof.index\n );\n }\n\n function withdraw(\n address token,\n uint256 denomination,\n address recipient,\n bytes32 nullifierHash,\n bytes32 root,\n MixerProof calldata proof\n ) external nonReentrant {\n bytes32 poolId = _poolId(token, denomination);\n require(allowedDenominations[poolId], \"Denomination not allowed\");\n require(isKnownRoot(poolId, root), \"Unknown root\");\n require(!nullifierUsed[poolId][nullifierHash], \"Nullifier already used\");\n require(_verifyMixerProof(root, nullifierHash, recipient, token, denomination, proof), \"Invalid proof\");\n\n nullifierUsed[poolId][nullifierHash] = true;\n\n if (token == address(0)) {\n (bool success, ) = recipient.call{ value: denomination }(\"\");\n require(success, \"ETH transfer failed\");\n } else {\n SafeERC20.safeTransfer(IERC20(token), recipient, denomination);\n }\n\n emit Withdrawal(recipient, nullifierHash, token, denomination, block.timestamp);\n }\n\n receive() external payable {}\n}\n" + }, + "poseidon-solidity/PoseidonT3.sol": { + "content": "/// SPDX-License-Identifier: MIT\npragma solidity >=0.7.0;\n\nlibrary PoseidonT3 {\n uint constant M00 = 0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b;\n uint constant M01 = 0x2969f27eed31a480b9c36c764379dbca2cc8fdd1415c3dded62940bcde0bd771;\n uint constant M02 = 0x143021ec686a3f330d5f9e654638065ce6cd79e28c5b3753326244ee65a1b1a7;\n uint constant M10 = 0x16ed41e13bb9c0c66ae119424fddbcbc9314dc9fdbdeea55d6c64543dc4903e0;\n uint constant M11 = 0x2e2419f9ec02ec394c9871c832963dc1b89d743c8c7b964029b2311687b1fe23;\n uint constant M12 = 0x176cc029695ad02582a70eff08a6fd99d057e12e58e7d7b6b16cdfabc8ee2911;\n\n // See here for a simplified implementation: https://github.com/vimwitch/poseidon-solidity/blob/e57becdabb65d99fdc586fe1e1e09e7108202d53/contracts/Poseidon.sol#L40\n // Inspired by: https://github.com/iden3/circomlibjs/blob/v0.0.8/src/poseidon_slow.js\n function hash(uint[2] memory) public pure returns (uint) {\n assembly {\n let F := 21888242871839275222246405745257275088548364400416034343698204186575808495617\n let M20 := 0x2b90bba00fca0589f617e7dcbfe82e0df706ab640ceb247b791a93b74e36736d\n let M21 := 0x101071f0032379b697315876690f053d148d4e109f5fb065c8aacc55a0f89bfa\n let M22 := 0x19a3fc0a56702bf417ba7fee3802593fa644470307043f7773279cd71d25d5e0\n\n // load the inputs from memory\n let state1 := add(mod(mload(0x80), F), 0x00f1445235f2148c5986587169fc1bcd887b08d4d00868df5696fff40956e864)\n let state2 := add(mod(mload(0xa0), F), 0x08dff3487e8ac99e1f29a058d0fa80b930c728730b7ab36ce879f3890ecf73f5)\n let scratch0 := mulmod(state1, state1, F)\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\n scratch0 := mulmod(state2, state2, F)\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\n scratch0 := add(\n 0x2f27be690fdaee46c3ce28f7532b13c856c35342c84bda6e20966310fadc01d0,\n add(add(15452833169820924772166449970675545095234312153403844297388521437673434406763, mulmod(state1, M10, F)), mulmod(state2, M20, F))\n )\n let scratch1 := add(\n 0x2b2ae1acf68b7b8d2416bebf3d4f6234b763fe04b8043ee48b8327bebca16cf2,\n add(add(18674271267752038776579386132900109523609358935013267566297499497165104279117, mulmod(state1, M11, F)), mulmod(state2, M21, F))\n )\n let scratch2 := add(\n 0x0319d062072bef7ecca5eac06f97d4d55952c175ab6b03eae64b44c7dbf11cfa,\n add(add(14817777843080276494683266178512808687156649753153012854386334860566696099579, mulmod(state1, M12, F)), mulmod(state2, M22, F))\n )\n let state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := mulmod(scratch1, scratch1, F)\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\n state0 := mulmod(scratch2, scratch2, F)\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\n state0 := add(0x28813dcaebaeaa828a376df87af4a63bc8b7bf27ad49c6298ef7b387bf28526d, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x2727673b2ccbc903f181bf38e1c1d40d2033865200c352bc150928adddf9cb78, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x234ec45ca27727c2e74abd2b2a1494cd6efbd43e340587d6b8fb9e31e65cc632, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := mulmod(state1, state1, F)\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\n scratch0 := mulmod(state2, state2, F)\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\n scratch0 := add(0x15b52534031ae18f7f862cb2cf7cf760ab10a8150a337b1ccd99ff6e8797d428, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x0dc8fad6d9e4b35f5ed9a3d186b79ce38e0e8a8d1b58b132d701d4eecf68d1f6, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x1bcd95ffc211fbca600f705fad3fb567ea4eb378f62e1fec97805518a47e4d9c, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := mulmod(scratch1, scratch1, F)\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\n state0 := mulmod(scratch2, scratch2, F)\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\n state0 := add(0x10520b0ab721cadfe9eff81b016fc34dc76da36c2578937817cb978d069de559, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x1f6d48149b8e7f7d9b257d8ed5fbbaf42932498075fed0ace88a9eb81f5627f6, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x1d9655f652309014d29e00ef35a2089bfff8dc1c816f0dc9ca34bdb5460c8705, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x04df5a56ff95bcafb051f7b1cd43a99ba731ff67e47032058fe3d4185697cc7d, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x0672d995f8fff640151b3d290cedaf148690a10a8c8424a7f6ec282b6e4be828, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x099952b414884454b21200d7ffafdd5f0c9a9dcc06f2708e9fc1d8209b5c75b9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x052cba2255dfd00c7c483143ba8d469448e43586a9b4cd9183fd0e843a6b9fa6, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x0b8badee690adb8eb0bd74712b7999af82de55707251ad7716077cb93c464ddc, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x119b1590f13307af5a1ee651020c07c749c15d60683a8050b963d0a8e4b2bdd1, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x03150b7cd6d5d17b2529d36be0f67b832c4acfc884ef4ee5ce15be0bfb4a8d09, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x2cc6182c5e14546e3cf1951f173912355374efb83d80898abe69cb317c9ea565, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x005032551e6378c450cfe129a404b3764218cadedac14e2b92d2cd73111bf0f9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x233237e3289baa34bb147e972ebcb9516469c399fcc069fb88f9da2cc28276b5, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x05c8f4f4ebd4a6e3c980d31674bfbe6323037f21b34ae5a4e80c2d4c24d60280, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x0a7b1db13042d396ba05d818a319f25252bcf35ef3aeed91ee1f09b2590fc65b, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x2a73b71f9b210cf5b14296572c9d32dbf156e2b086ff47dc5df542365a404ec0, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x1ac9b0417abcc9a1935107e9ffc91dc3ec18f2c4dbe7f22976a760bb5c50c460, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x12c0339ae08374823fabb076707ef479269f3e4d6cb104349015ee046dc93fc0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x0b7475b102a165ad7f5b18db4e1e704f52900aa3253baac68246682e56e9a28e, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x037c2849e191ca3edb1c5e49f6e8b8917c843e379366f2ea32ab3aa88d7f8448, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x05a6811f8556f014e92674661e217e9bd5206c5c93a07dc145fdb176a716346f, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x29a795e7d98028946e947b75d54e9f044076e87a7b2883b47b675ef5f38bd66e, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x20439a0c84b322eb45a3857afc18f5826e8c7382c8a1585c507be199981fd22f, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x2e0ba8d94d9ecf4a94ec2050c7371ff1bb50f27799a84b6d4a2a6f2a0982c887, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x143fd115ce08fb27ca38eb7cce822b4517822cd2109048d2e6d0ddcca17d71c8, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x0c64cbecb1c734b857968dbbdcf813cdf8611659323dbcbfc84323623be9caf1, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x028a305847c683f646fca925c163ff5ae74f348d62c2b670f1426cef9403da53, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x2e4ef510ff0b6fda5fa940ab4c4380f26a6bcb64d89427b824d6755b5db9e30c, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x0081c95bc43384e663d79270c956ce3b8925b4f6d033b078b96384f50579400e, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x2ed5f0c91cbd9749187e2fade687e05ee2491b349c039a0bba8a9f4023a0bb38, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x30509991f88da3504bbf374ed5aae2f03448a22c76234c8c990f01f33a735206, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x1c3f20fd55409a53221b7c4d49a356b9f0a1119fb2067b41a7529094424ec6ad, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x10b4e7f3ab5df003049514459b6e18eec46bb2213e8e131e170887b47ddcb96c, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x2a1982979c3ff7f43ddd543d891c2abddd80f804c077d775039aa3502e43adef, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x1c74ee64f15e1db6feddbead56d6d55dba431ebc396c9af95cad0f1315bd5c91, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x07533ec850ba7f98eab9303cace01b4b9e4f2e8b82708cfa9c2fe45a0ae146a0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x21576b438e500449a151e4eeaf17b154285c68f42d42c1808a11abf3764c0750, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x2f17c0559b8fe79608ad5ca193d62f10bce8384c815f0906743d6930836d4a9e, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x2d477e3862d07708a79e8aae946170bc9775a4201318474ae665b0b1b7e2730e, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x162f5243967064c390e095577984f291afba2266c38f5abcd89be0f5b2747eab, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x2b4cb233ede9ba48264ecd2c8ae50d1ad7a8596a87f29f8a7777a70092393311, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x2c8fbcb2dd8573dc1dbaf8f4622854776db2eece6d85c4cf4254e7c35e03b07a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x1d6f347725e4816af2ff453f0cd56b199e1b61e9f601e9ade5e88db870949da9, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x204b0c397f4ebe71ebc2d8b3df5b913df9e6ac02b68d31324cd49af5c4565529, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x0c4cb9dc3c4fd8174f1149b3c63c3c2f9ecb827cd7dc25534ff8fb75bc79c502, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x174ad61a1448c899a25416474f4930301e5c49475279e0639a616ddc45bc7b54, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x1a96177bcf4d8d89f759df4ec2f3cde2eaaa28c177cc0fa13a9816d49a38d2ef, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x066d04b24331d71cd0ef8054bc60c4ff05202c126a233c1a8242ace360b8a30a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x2a4c4fc6ec0b0cf52195782871c6dd3b381cc65f72e02ad527037a62aa1bd804, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x13ab2d136ccf37d447e9f2e14a7cedc95e727f8446f6d9d7e55afc01219fd649, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x1121552fca26061619d24d843dc82769c1b04fcec26f55194c2e3e869acc6a9a, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x00ef653322b13d6c889bc81715c37d77a6cd267d595c4a8909a5546c7c97cff1, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x0e25483e45a665208b261d8ba74051e6400c776d652595d9845aca35d8a397d3, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x29f536dcb9dd7682245264659e15d88e395ac3d4dde92d8c46448db979eeba89, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x2a56ef9f2c53febadfda33575dbdbd885a124e2780bbea170e456baace0fa5be, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x1c8361c78eb5cf5decfb7a2d17b5c409f2ae2999a46762e8ee416240a8cb9af1, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x151aff5f38b20a0fc0473089aaf0206b83e8e68a764507bfd3d0ab4be74319c5, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x04c6187e41ed881dc1b239c88f7f9d43a9f52fc8c8b6cdd1e76e47615b51f100, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x13b37bd80f4d27fb10d84331f6fb6d534b81c61ed15776449e801b7ddc9c2967, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x01a5c536273c2d9df578bfbd32c17b7a2ce3664c2a52032c9321ceb1c4e8a8e4, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x2ab3561834ca73835ad05f5d7acb950b4a9a2c666b9726da832239065b7c3b02, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x1d4d8ec291e720db200fe6d686c0d613acaf6af4e95d3bf69f7ed516a597b646, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x041294d2cc484d228f5784fe7919fd2bb925351240a04b711514c9c80b65af1d, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x154ac98e01708c611c4fa715991f004898f57939d126e392042971dd90e81fc6, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x0b339d8acca7d4f83eedd84093aef51050b3684c88f8b0b04524563bc6ea4da4, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x0955e49e6610c94254a4f84cfbab344598f0e71eaff4a7dd81ed95b50839c82e, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x06746a6156eba54426b9e22206f15abca9a6f41e6f535c6f3525401ea0654626, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x0f18f5a0ecd1423c496f3820c549c27838e5790e2bd0a196ac917c7ff32077fb, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x04f6eeca1751f7308ac59eff5beb261e4bb563583ede7bc92a738223d6f76e13, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x2b56973364c4c4f5c1a3ec4da3cdce038811eb116fb3e45bc1768d26fc0b3758, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x123769dd49d5b054dcd76b89804b1bcb8e1392b385716a5d83feb65d437f29ef, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x2147b424fc48c80a88ee52b91169aacea989f6446471150994257b2fb01c63e9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x0fdc1f58548b85701a6c5505ea332a29647e6f34ad4243c2ea54ad897cebe54d, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x12373a8251fea004df68abcf0f7786d4bceff28c5dbbe0c3944f685cc0a0b1f2, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x21e4f4ea5f35f85bad7ea52ff742c9e8a642756b6af44203dd8a1f35c1a90035, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x16243916d69d2ca3dfb4722224d4c462b57366492f45e90d8a81934f1bc3b147, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x1efbe46dd7a578b4f66f9adbc88b4378abc21566e1a0453ca13a4159cac04ac2, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x07ea5e8537cf5dd08886020e23a7f387d468d5525be66f853b672cc96a88969a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x05a8c4f9968b8aa3b7b478a30f9a5b63650f19a75e7ce11ca9fe16c0b76c00bc, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x20f057712cc21654fbfe59bd345e8dac3f7818c701b9c7882d9d57b72a32e83f, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x04a12ededa9dfd689672f8c67fee31636dcd8e88d01d49019bd90b33eb33db69, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x27e88d8c15f37dcee44f1e5425a51decbd136ce5091a6767e49ec9544ccd101a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x2feed17b84285ed9b8a5c8c5e95a41f66e096619a7703223176c41ee433de4d1, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x1ed7cc76edf45c7c404241420f729cf394e5942911312a0d6972b8bd53aff2b8, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x15742e99b9bfa323157ff8c586f5660eac6783476144cdcadf2874be45466b1a, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x1aac285387f65e82c895fc6887ddf40577107454c6ec0317284f033f27d0c785, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x25851c3c845d4790f9ddadbdb6057357832e2e7a49775f71ec75a96554d67c77, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x15a5821565cc2ec2ce78457db197edf353b7ebba2c5523370ddccc3d9f146a67, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x2411d57a4813b9980efa7e31a1db5966dcf64f36044277502f15485f28c71727, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x002e6f8d6520cd4713e335b8c0b6d2e647e9a98e12f4cd2558828b5ef6cb4c9b, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x2ff7bc8f4380cde997da00b616b0fcd1af8f0e91e2fe1ed7398834609e0315d2, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x00b9831b948525595ee02724471bcd182e9521f6b7bb68f1e93be4febb0d3cbe, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x0a2f53768b8ebf6a86913b0e57c04e011ca408648a4743a87d77adbf0c9c3512, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x00248156142fd0373a479f91ff239e960f599ff7e94be69b7f2a290305e1198d, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x171d5620b87bfb1328cf8c02ab3f0c9a397196aa6a542c2350eb512a2b2bcda9, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x170a4f55536f7dc970087c7c10d6fad760c952172dd54dd99d1045e4ec34a808, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x29aba33f799fe66c2ef3134aea04336ecc37e38c1cd211ba482eca17e2dbfae1, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x1e9bc179a4fdd758fdd1bb1945088d47e70d114a03f6a0e8b5ba650369e64973, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x1dd269799b660fad58f7f4892dfb0b5afeaad869a9c4b44f9c9e1c43bdaf8f09, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x22cdbc8b70117ad1401181d02e15459e7ccd426fe869c7c95d1dd2cb0f24af38, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x0ef042e454771c533a9f57a55c503fcefd3150f52ed94a7cd5ba93b9c7dacefd, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x11609e06ad6c8fe2f287f3036037e8851318e8b08a0359a03b304ffca62e8284, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x1166d9e554616dba9e753eea427c17b7fecd58c076dfe42708b08f5b783aa9af, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x2de52989431a859593413026354413db177fbf4cd2ac0b56f855a888357ee466, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x3006eb4ffc7a85819a6da492f3a8ac1df51aee5b17b8e89d74bf01cf5f71e9ad, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x2af41fbb61ba8a80fdcf6fff9e3f6f422993fe8f0a4639f962344c8225145086, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x119e684de476155fe5a6b41a8ebc85db8718ab27889e85e781b214bace4827c3, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x1835b786e2e8925e188bea59ae363537b51248c23828f047cff784b97b3fd800, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x28201a34c594dfa34d794996c6433a20d152bac2a7905c926c40e285ab32eeb6, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x083efd7a27d1751094e80fefaf78b000864c82eb571187724a761f88c22cc4e7, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x0b6f88a3577199526158e61ceea27be811c16df7774dd8519e079564f61fd13b, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x0ec868e6d15e51d9644f66e1d6471a94589511ca00d29e1014390e6ee4254f5b, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x2af33e3f866771271ac0c9b3ed2e1142ecd3e74b939cd40d00d937ab84c98591, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x0b520211f904b5e7d09b5d961c6ace7734568c547dd6858b364ce5e47951f178, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x0b2d722d0919a1aad8db58f10062a92ea0c56ac4270e822cca228620188a1d40, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x1f790d4d7f8cf094d980ceb37c2453e957b54a9991ca38bbe0061d1ed6e562d4, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x0171eb95dfbf7d1eaea97cd385f780150885c16235a2a6a8da92ceb01e504233, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x0c2d0e3b5fd57549329bf6885da66b9b790b40defd2c8650762305381b168873, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x1162fb28689c27154e5a8228b4e72b377cbcafa589e283c35d3803054407a18d, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x2f1459b65dee441b64ad386a91e8310f282c5a92a89e19921623ef8249711bc0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x1e6ff3216b688c3d996d74367d5cd4c1bc489d46754eb712c243f70d1b53cfbb, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x01ca8be73832b8d0681487d27d157802d741a6f36cdc2a0576881f9326478875, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x1f7735706ffe9fc586f976d5bdf223dc680286080b10cea00b9b5de315f9650e, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x2522b60f4ea3307640a0c2dce041fba921ac10a3d5f096ef4745ca838285f019, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x23f0bee001b1029d5255075ddc957f833418cad4f52b6c3f8ce16c235572575b, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x2bc1ae8b8ddbb81fcaac2d44555ed5685d142633e9df905f66d9401093082d59, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x0f9406b8296564a37304507b8dba3ed162371273a07b1fc98011fcd6ad72205f, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x2360a8eb0cc7defa67b72998de90714e17e75b174a52ee4acb126c8cd995f0a8, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x15871a5cddead976804c803cbaef255eb4815a5e96df8b006dcbbc2767f88948, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x193a56766998ee9e0a8652dd2f3b1da0362f4f54f72379544f957ccdeefb420f, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x2a394a43934f86982f9be56ff4fab1703b2e63c8ad334834e4309805e777ae0f, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x1859954cfeb8695f3e8b635dcb345192892cd11223443ba7b4166e8876c0d142, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x04e1181763050e58013444dbcb99f1902b11bc25d90bbdca408d3819f4fed32b, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x0fdb253dee83869d40c335ea64de8c5bb10eb82db08b5e8b1f5e5552bfd05f23, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x058cbe8a9a5027bdaa4efb623adead6275f08686f1c08984a9d7c5bae9b4f1c0, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x1382edce9971e186497eadb1aeb1f52b23b4b83bef023ab0d15228b4cceca59a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x03464990f045c6ee0819ca51fd11b0be7f61b8eb99f14b77e1e6634601d9e8b5, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x23f7bfc8720dc296fff33b41f98ff83c6fcab4605db2eb5aaa5bc137aeb70a58, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x0a59a158e3eec2117e6e94e7f0e9decf18c3ffd5e1531a9219636158bbaf62f2, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x06ec54c80381c052b58bf23b312ffd3ce2c4eba065420af8f4c23ed0075fd07b, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x118872dc832e0eb5476b56648e867ec8b09340f7a7bcb1b4962f0ff9ed1f9d01, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x13d69fa127d834165ad5c7cba7ad59ed52e0b0f0e42d7fea95e1906b520921b1, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x169a177f63ea681270b1c6877a73d21bde143942fb71dc55fd8a49f19f10c77b, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x04ef51591c6ead97ef42f287adce40d93abeb032b922f66ffb7e9a5a7450544d, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x256e175a1dc079390ecd7ca703fb2e3b19ec61805d4f03ced5f45ee6dd0f69ec, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x30102d28636abd5fe5f2af412ff6004f75cc360d3205dd2da002813d3e2ceeb2, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x10998e42dfcd3bbf1c0714bc73eb1bf40443a3fa99bef4a31fd31be182fcc792, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x193edd8e9fcf3d7625fa7d24b598a1d89f3362eaf4d582efecad76f879e36860, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x18168afd34f2d915d0368ce80b7b3347d1c7a561ce611425f2664d7aa51f0b5d, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x29383c01ebd3b6ab0c017656ebe658b6a328ec77bc33626e29e2e95b33ea6111, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x10646d2f2603de39a1f4ae5e7771a64a702db6e86fb76ab600bf573f9010c711, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x0beb5e07d1b27145f575f1395a55bf132f90c25b40da7b3864d0242dcb1117fb, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x16d685252078c133dc0d3ecad62b5c8830f95bb2e54b59abdffbf018d96fa336, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x0a6abd1d833938f33c74154e0404b4b40a555bbbec21ddfafd672dd62047f01a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x1a679f5d36eb7b5c8ea12a4c2dedc8feb12dffeec450317270a6f19b34cf1860, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x0980fb233bd456c23974d50e0ebfde4726a423eada4e8f6ffbc7592e3f1b93d6, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x161b42232e61b84cbf1810af93a38fc0cece3d5628c9282003ebacb5c312c72b, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x0ada10a90c7f0520950f7d47a60d5e6a493f09787f1564e5d09203db47de1a0b, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x1a730d372310ba82320345a29ac4238ed3f07a8a2b4e121bb50ddb9af407f451, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x2c8120f268ef054f817064c369dda7ea908377feaba5c4dffbda10ef58e8c556, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x1c7c8824f758753fa57c00789c684217b930e95313bcb73e6e7b8649a4968f70, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x2cd9ed31f5f8691c8e39e4077a74faa0f400ad8b491eb3f7b47b27fa3fd1cf77, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x23ff4f9d46813457cf60d92f57618399a5e022ac321ca550854ae23918a22eea, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x09945a5d147a4f66ceece6405dddd9d0af5a2c5103529407dff1ea58f180426d, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x188d9c528025d4c2b67660c6b771b90f7c7da6eaa29d3f268a6dd223ec6fc630, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x3050e37996596b7f81f68311431d8734dba7d926d3633595e0c0d8ddf4f0f47f, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x15af1169396830a91600ca8102c35c426ceae5461e3f95d89d829518d30afd78, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x1da6d09885432ea9a06d9f37f873d985dae933e351466b2904284da3320d8acc, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x2796ea90d269af29f5f8acf33921124e4e4fad3dbe658945e546ee411ddaa9cb, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x202d7dd1da0f6b4b0325c8b3307742f01e15612ec8e9304a7cb0319e01d32d60, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x096d6790d05bb759156a952ba263d672a2d7f9c788f4c831a29dace4c0f8be5f, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x054efa1f65b0fce283808965275d877b438da23ce5b13e1963798cb1447d25a4, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x1b162f83d917e93edb3308c29802deb9d8aa690113b2e14864ccf6e18e4165f1, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x21e5241e12564dd6fd9f1cdd2a0de39eedfefc1466cc568ec5ceb745a0506edc, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := mulmod(scratch1, scratch1, F)\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\n state0 := mulmod(scratch2, scratch2, F)\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\n state0 := add(0x1cfb5662e8cf5ac9226a80ee17b36abecb73ab5f87e161927b4349e10e4bdf08, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x0f21177e302a771bbae6d8d1ecb373b62c99af346220ac0129c53f666eb24100, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x1671522374606992affb0dd7f71b12bec4236aede6290546bcef7e1f515c2320, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := mulmod(state1, state1, F)\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\n scratch0 := mulmod(state2, state2, F)\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\n scratch0 := add(0x0fa3ec5b9488259c2eb4cf24501bfad9be2ec9e42c5cc8ccd419d2a692cad870, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x193c0e04e0bd298357cb266c1506080ed36edce85c648cc085e8c57b1ab54bba, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x102adf8ef74735a27e9128306dcbc3c99f6f7291cd406578ce14ea2adaba68f8, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := mulmod(scratch1, scratch1, F)\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\n state0 := mulmod(scratch2, scratch2, F)\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\n state0 := add(0x0fe0af7858e49859e2a54d6f1ad945b1316aa24bfbdd23ae40a6d0cb70c3eab1, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x216f6717bbc7dedb08536a2220843f4e2da5f1daa9ebdefde8a5ea7344798d22, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x1da55cc900f0d21f4a3e694391918a1b3c23b2ac773c6b3ef88e2e4228325161, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := mulmod(state1, state1, F)\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\n scratch0 := mulmod(state2, state2, F)\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\n\n mstore(0x0, mod(add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)), F))\n\n return(0, 0x20)\n }\n }\n}\n" + } + }, + "settings": { + "optimizer": { + "enabled": true, + "runs": 200 + }, + "evmVersion": "paris", + "outputSelection": { + "*": { + "*": [ + "abi", + "evm.bytecode", + "evm.deployedBytecode", + "evm.methodIdentifiers", + "metadata", + "devdoc", + "userdoc", + "storageLayout", + "evm.gasEstimates" + ], + "": [ + "ast" + ] + } + }, + "metadata": { + "useLiteralContent": true + } + } +} \ No newline at end of file diff --git a/packages/hardhat/deployments/horizenTestnet/Mixer.json b/packages/hardhat/deployments/horizenTestnet/Mixer.json new file mode 100644 index 0000000..b0f0db4 --- /dev/null +++ b/packages/hardhat/deployments/horizenTestnet/Mixer.json @@ -0,0 +1,738 @@ +{ + "address": "0x8F5f249210fFc91a2b1D86828764562f97C9eEdd", + "abi": [ + { + "inputs": [ + { + "internalType": "address", + "name": "_zkvContract", + "type": "address" + }, + { + "internalType": "bytes32", + "name": "_vkHash", + "type": "bytes32" + }, + { + "internalType": "bytes32[]", + "name": "_allowedPoolIds", + "type": "bytes32[]" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "target", + "type": "address" + } + ], + "name": "AddressEmptyCode", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "AddressInsufficientBalance", + "type": "error" + }, + { + "inputs": [], + "name": "FailedInnerCall", + "type": "error" + }, + { + "inputs": [], + "name": "ReentrancyGuardReentrantCall", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "SafeERC20FailedOperation", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "commitment", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "leafIndex", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "denomination", + "type": "uint256" + } + ], + "name": "Deposit", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "recipient", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "nullifierHash", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "denomination", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + } + ], + "name": "Withdrawal", + "type": "event" + }, + { + "inputs": [], + "name": "BN254_PRIME", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "PROVING_SYSTEM_ID", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "ROOT_HISTORY_SIZE", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "TREE_DEPTH", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "VERSION_HASH", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "name": "allowedDenominations", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "name": "commitmentUsed", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "denomination", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "commitment", + "type": "bytes32" + } + ], + "name": "deposit", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "level", + "type": "uint256" + } + ], + "name": "getZeroHash", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "poolId", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "root", + "type": "bytes32" + } + ], + "name": "isKnownRoot", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "name": "nullifierUsed", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "rootHistory", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "name": "rootHistoryIndex", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "name": "trees", + "outputs": [ + { + "internalType": "uint256", + "name": "nextIndex", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "vkHash", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "denomination", + "type": "uint256" + }, + { + "internalType": "address", + "name": "recipient", + "type": "address" + }, + { + "internalType": "bytes32", + "name": "nullifierHash", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "root", + "type": "bytes32" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "aggregationId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "domainId", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "zkMerklePath", + "type": "bytes32[]" + }, + { + "internalType": "uint256", + "name": "leafCount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + } + ], + "internalType": "struct Mixer.MixerProof", + "name": "proof", + "type": "tuple" + } + ], + "name": "withdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "zkvContract", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "stateMutability": "payable", + "type": "receive" + } + ], + "transactionHash": "0x664d0c63c348a9e66bfd7dae99de1defd8a07c635c80fde178793d72a726677f", + "receipt": { + "to": null, + "from": "0xd95E85e86D3Be5C86846435b8F0C3a476C5a9e42", + "contractAddress": "0x8F5f249210fFc91a2b1D86828764562f97C9eEdd", + "transactionIndex": 1, + "gasUsed": "2329282", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0x4a5e41bec9b9369ec49f2b1f6e7d07b162cd943fc2cd4f931fb322b4e40ed6fa", + "transactionHash": "0x664d0c63c348a9e66bfd7dae99de1defd8a07c635c80fde178793d72a726677f", + "logs": [], + "blockNumber": 11529753, + "cumulativeGasUsed": "2373138", + "status": 1, + "byzantium": true + }, + "args": [ + "0xCC02D0A54F3184dF4c88811E5b9FAb7ff8131e4a", + "0x0000000000000000000000000000000000000000000000000000000000000000", + [ + "0xe904c2b027ada6080c203c94ae7a6948682023cdbf53aef00dbc800ef97a132e", + "0x73a9f33d373b966d8ef30721adda93c14785f3be5d60a65981b922edad5917c6", + "0xe9cb62a4a45543a0c652e488f81c3baa93c972fd0c6059a7897348da7ed660ce", + "0xa1951e0092c03317e3fd1cc1af7c40703f244a744eb60a8bc7443a83b2119cca", + "0x1c8cb657b67135232cffdcb46fc5719aa1efbc54ff9d43cb77522e447e9f5931", + "0x665f61b9c74f6b2f70c47bd84eb7c5ae0c874bc2de7bf8ba8a78eab24e0b0609", + "0x2acb0bad79e6001dc5f9f66d080846d65a2fce62baf8d812f32418dcbf79f6ff", + "0x2d41edad120f6ed6945b5927a235ca16f1c04c42028ec75c5644023ceff78976", + "0x837ac82af0145c0f2fb8df087d876ad2d448bd449fadfdb8ee6c174d999e1691", + "0x7e1571025dbc30db6c13fa231a74a0ff1745d5daecac220fd3b5a5ddd3dd37b9", + "0x349b9685a584038f6c5c6afbd493f10a1caed630596ac9de0ac6a72b809d4daa", + "0x5f6f5e500c78430967d03a73a2823813beb6f43409029cbb9a53429ae0dcab33", + "0xc08d16a8b1478d1d237b587ac08d131a5651a3fa2da832bf8d8fee165d8193e4" + ] + ], + "numDeployments": 1, + "solcInputHash": "7f0373dedc61097daaf6a7dfc1f19d7a", + "metadata": "{\"compiler\":{\"version\":\"0.8.20+commit.a1b79de6\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zkvContract\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"_vkHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[]\",\"name\":\"_allowedPoolIds\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"AddressEmptyCode\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"AddressInsufficientBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedInnerCall\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrancyGuardReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"commitment\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"leafIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"denomination\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"nullifierHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"denomination\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"BN254_PRIME\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PROVING_SYSTEM_ID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ROOT_HISTORY_SIZE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"TREE_DEPTH\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"VERSION_HASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"allowedDenominations\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"commitmentUsed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"denomination\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"commitment\",\"type\":\"bytes32\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"level\",\"type\":\"uint256\"}],\"name\":\"getZeroHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"poolId\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"root\",\"type\":\"bytes32\"}],\"name\":\"isKnownRoot\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"nullifierUsed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"rootHistory\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"rootHistoryIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"trees\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"nextIndex\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"vkHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"denomination\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"nullifierHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"root\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"aggregationId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"domainId\",\"type\":\"uint256\"},{\"internalType\":\"bytes32[]\",\"name\":\"zkMerklePath\",\"type\":\"bytes32[]\"},{\"internalType\":\"uint256\",\"name\":\"leafCount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"internalType\":\"struct Mixer.MixerProof\",\"name\":\"proof\",\"type\":\"tuple\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zkvContract\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"errors\":{\"AddressEmptyCode(address)\":[{\"details\":\"There's no code at `target` (it is not a contract).\"}],\"AddressInsufficientBalance(address)\":[{\"details\":\"The ETH balance of the account is not enough to perform the operation.\"}],\"FailedInnerCall()\":[{\"details\":\"A call to an address target failed. The target may have reverted.\"}],\"ReentrancyGuardReentrantCall()\":[{\"details\":\"Unauthorized reentrant call.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"getZeroHash(uint256)\":{\"details\":\"Exposed for Poseidon/zero-hash consistency tests (JS vs Solidity)\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/Mixer.sol\":\"Mixer\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the value of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the value of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 value) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n * caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 value) external returns (bool);\\n\\n /**\\n * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n * allowance mechanism. `value` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0xc6a8ff0ea489379b61faa647490411b80102578440ab9d84e9a957cc12164e70\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n *\\n * ==== Security Considerations\\n *\\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\\n * generally recommended is:\\n *\\n * ```solidity\\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\\n * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\\n * doThing(..., value);\\n * }\\n *\\n * function doThing(..., uint256 value) public {\\n * token.safeTransferFrom(msg.sender, address(this), value);\\n * ...\\n * }\\n * ```\\n *\\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\\n * {SafeERC20-safeTransferFrom}).\\n *\\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\\n * contracts should have entry points that don't rely on permit.\\n */\\ninterface IERC20Permit {\\n /**\\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n *\\n * CAUTION: See Security Considerations above.\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0x6008dabfe393240d73d7dd7688033f72740d570aa422254d29a7dce8568f3aff\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC20Permit} from \\\"../extensions/IERC20Permit.sol\\\";\\nimport {Address} from \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n /**\\n * @dev An operation with an ERC20 token failed.\\n */\\n error SafeERC20FailedOperation(address token);\\n\\n /**\\n * @dev Indicates a failed `decreaseAllowance` request.\\n */\\n error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n /**\\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n }\\n\\n /**\\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n */\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n }\\n\\n /**\\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n forceApprove(token, spender, oldAllowance + value);\\n }\\n\\n /**\\n * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n * value, non-reverting calls are assumed to be successful.\\n */\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n unchecked {\\n uint256 currentAllowance = token.allowance(address(this), spender);\\n if (currentAllowance < requestedDecrease) {\\n revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n }\\n forceApprove(token, spender, currentAllowance - requestedDecrease);\\n }\\n }\\n\\n /**\\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n * to be set to zero before setting it to a non-zero value, such as USDT.\\n */\\n function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n if (!_callOptionalReturnBool(token, approvalCall)) {\\n _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n _callOptionalReturn(token, approvalCall);\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data);\\n if (returndata.length != 0 && !abi.decode(returndata, (bool))) {\\n revert SafeERC20FailedOperation(address(token));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n *\\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\\n */\\n function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\\n // and not revert is the subcall reverts.\\n\\n (bool success, bytes memory returndata) = address(token).call(data);\\n return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;\\n }\\n}\\n\",\"keccak256\":\"0x37bb49513c49c87c4642a891b13b63571bc87013dde806617aa1efb54605f386\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev The ETH balance of the account is not enough to perform the operation.\\n */\\n error AddressInsufficientBalance(address account);\\n\\n /**\\n * @dev There's no code at `target` (it is not a contract).\\n */\\n error AddressEmptyCode(address target);\\n\\n /**\\n * @dev A call to an address target failed. The target may have reverted.\\n */\\n error FailedInnerCall();\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n if (address(this).balance < amount) {\\n revert AddressInsufficientBalance(address(this));\\n }\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n if (!success) {\\n revert FailedInnerCall();\\n }\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason or custom error, it is bubbled\\n * up by this function (like regular Solidity function calls). However, if\\n * the call reverted with no returned reason, this function reverts with a\\n * {FailedInnerCall} error.\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n if (address(this).balance < value) {\\n revert AddressInsufficientBalance(address(this));\\n }\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResultFromTarget(target, success, returndata);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResultFromTarget(target, success, returndata);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResultFromTarget(target, success, returndata);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\\n * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an\\n * unsuccessful call.\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata\\n ) internal view returns (bytes memory) {\\n if (!success) {\\n _revert(returndata);\\n } else {\\n // only check if target is a contract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n if (returndata.length == 0 && target.code.length == 0) {\\n revert AddressEmptyCode(target);\\n }\\n return returndata;\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\\n * revert reason or with a default {FailedInnerCall} error.\\n */\\n function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\\n if (!success) {\\n _revert(returndata);\\n } else {\\n return returndata;\\n }\\n }\\n\\n /**\\n * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.\\n */\\n function _revert(bytes memory returndata) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert FailedInnerCall();\\n }\\n }\\n}\\n\",\"keccak256\":\"0xaf28a975a78550e45f65e559a3ad6a5ad43b9b8a37366999abd1b7084eb70721\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/ReentrancyGuard.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant NOT_ENTERED = 1;\\n uint256 private constant ENTERED = 2;\\n\\n uint256 private _status;\\n\\n /**\\n * @dev Unauthorized reentrant call.\\n */\\n error ReentrancyGuardReentrantCall();\\n\\n constructor() {\\n _status = NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant() {\\n _nonReentrantBefore();\\n _;\\n _nonReentrantAfter();\\n }\\n\\n function _nonReentrantBefore() private {\\n // On the first call to nonReentrant, _status will be NOT_ENTERED\\n if (_status == ENTERED) {\\n revert ReentrancyGuardReentrantCall();\\n }\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = ENTERED;\\n }\\n\\n function _nonReentrantAfter() private {\\n // By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Returns true if the reentrancy guard is currently set to \\\"entered\\\", which indicates there is a\\n * `nonReentrant` function in the call stack.\\n */\\n function _reentrancyGuardEntered() internal view returns (bool) {\\n return _status == ENTERED;\\n }\\n}\\n\",\"keccak256\":\"0xf980daa263b661ab8ddee7d4fd833c7da7e7995e2c359ff1f17e67e4112f2236\",\"license\":\"MIT\"},\"contracts/Mixer.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.13;\\n\\nimport \\\"@openzeppelin/contracts/utils/ReentrancyGuard.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"poseidon-solidity/PoseidonT3.sol\\\";\\n\\ninterface IVerifyProofAggregation {\\n function verifyProofAggregation(\\n uint256 _domainId,\\n uint256 _aggregationId,\\n bytes32 _leaf,\\n bytes32[] calldata _merklePath,\\n uint256 _leafCount,\\n uint256 _index\\n ) external view returns (bool);\\n}\\n\\ncontract Mixer is ReentrancyGuard {\\n uint256 public constant BN254_PRIME = 21888242871839275222246405745257275088548364400416034343698204186575808495617;\\n bytes32 public constant PROVING_SYSTEM_ID = keccak256(abi.encodePacked(\\\"ultraplonk\\\"));\\n bytes32 public constant VERSION_HASH = sha256(abi.encodePacked(\\\"\\\"));\\n uint256 public constant TREE_DEPTH = 20;\\n uint256 public constant ROOT_HISTORY_SIZE = 30;\\n\\n address public immutable zkvContract;\\n bytes32 public immutable vkHash;\\n\\n struct MerkleTree {\\n uint256 nextIndex;\\n uint256[TREE_DEPTH] filledSubtrees;\\n }\\n\\n struct MixerProof {\\n uint256 aggregationId;\\n uint256 domainId;\\n bytes32[] zkMerklePath;\\n uint256 leafCount;\\n uint256 index;\\n }\\n\\n mapping(bytes32 => MerkleTree) public trees;\\n mapping(bytes32 => bytes32[ROOT_HISTORY_SIZE]) public rootHistory;\\n mapping(bytes32 => uint256) public rootHistoryIndex;\\n mapping(bytes32 => mapping(bytes32 => bool)) public nullifierUsed;\\n mapping(bytes32 => bool) public allowedDenominations;\\n mapping(bytes32 => bool) public commitmentUsed;\\n\\n uint256[TREE_DEPTH + 1] internal zeroHashes;\\n\\n event Deposit(bytes32 indexed commitment, uint256 leafIndex, uint256 timestamp, address indexed token, uint256 denomination);\\n event Withdrawal(address indexed recipient, bytes32 nullifierHash, address indexed token, uint256 denomination, uint256 timestamp);\\n\\n constructor(\\n address _zkvContract,\\n bytes32 _vkHash,\\n bytes32[] memory _allowedPoolIds\\n ) {\\n require(_zkvContract != address(0), \\\"Invalid zkv\\\");\\n zkvContract = _zkvContract;\\n vkHash = _vkHash;\\n for (uint256 i = 0; i < _allowedPoolIds.length; i++) {\\n allowedDenominations[_allowedPoolIds[i]] = true;\\n }\\n _computeZeroHashes();\\n }\\n\\n function _computeZeroHashes() internal {\\n zeroHashes[0] = 0;\\n for (uint256 i = 1; i <= TREE_DEPTH; i++) {\\n zeroHashes[i] = _poseidonHash2(zeroHashes[i - 1], zeroHashes[i - 1]);\\n }\\n }\\n\\n /// @dev Exposed for Poseidon/zero-hash consistency tests (JS vs Solidity)\\n function getZeroHash(uint256 level) external view returns (bytes32) {\\n require(level <= TREE_DEPTH, \\\"level\\\");\\n return bytes32(zeroHashes[level]);\\n }\\n\\n function _poseidonHash2(uint256 a, uint256 b) internal view returns (uint256) {\\n uint256 safeA = a % BN254_PRIME;\\n uint256 safeB = b % BN254_PRIME;\\n return PoseidonT3.hash([safeA, safeB]);\\n }\\n\\n function _poolId(address token, uint256 denomination) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(token, denomination));\\n }\\n\\n function deposit(address token, uint256 denomination, bytes32 commitment) external payable nonReentrant {\\n bytes32 poolId = _poolId(token, denomination);\\n require(allowedDenominations[poolId], \\\"Denomination not allowed\\\");\\n require(!commitmentUsed[commitment], \\\"Commitment already used\\\");\\n\\n if (token == address(0)) {\\n require(msg.value == denomination, \\\"ETH value mismatch\\\");\\n } else {\\n require(msg.value == 0, \\\"No ETH for ERC20\\\");\\n SafeERC20.safeTransferFrom(IERC20(token), msg.sender, address(this), denomination);\\n }\\n\\n uint256 leaf = uint256(commitment);\\n MerkleTree storage tree = trees[poolId];\\n uint256 leafIndex = tree.nextIndex;\\n tree.nextIndex++;\\n\\n uint256 current = leaf;\\n for (uint256 i = 0; i < TREE_DEPTH; i++) {\\n if ((leafIndex >> i) % 2 == 0) {\\n tree.filledSubtrees[i] = current;\\n current = _poseidonHash2(current, zeroHashes[i]);\\n } else {\\n current = _poseidonHash2(tree.filledSubtrees[i], current);\\n }\\n }\\n\\n uint256 root = current;\\n uint256 rhi = rootHistoryIndex[poolId] % ROOT_HISTORY_SIZE;\\n rootHistory[poolId][rhi] = bytes32(root);\\n rootHistoryIndex[poolId]++;\\n\\n commitmentUsed[commitment] = true;\\n\\n emit Deposit(commitment, tree.nextIndex - 1, block.timestamp, token, denomination);\\n }\\n\\n function isKnownRoot(bytes32 poolId, bytes32 root) public view returns (bool) {\\n uint256 rhi = rootHistoryIndex[poolId];\\n if (rhi == 0) return false;\\n uint256 size = rhi < ROOT_HISTORY_SIZE ? rhi : ROOT_HISTORY_SIZE;\\n for (uint256 i = 0; i < size; i++) {\\n uint256 idx = (rhi - 1 - i) % ROOT_HISTORY_SIZE;\\n if (rootHistory[poolId][idx] == root) return true;\\n }\\n return false;\\n }\\n\\n function _verifyMixerProof(\\n bytes32 root,\\n bytes32 nullifierHash,\\n address recipient,\\n address token,\\n uint256 denomination,\\n MixerProof calldata proof\\n ) internal view returns (bool) {\\n bytes memory encodedInputs = abi.encodePacked(\\n root,\\n nullifierHash,\\n uint256(uint160(recipient)),\\n uint256(uint160(token)),\\n denomination\\n );\\n bytes32 leaf = keccak256(abi.encodePacked(PROVING_SYSTEM_ID, vkHash, VERSION_HASH, keccak256(encodedInputs)));\\n return IVerifyProofAggregation(zkvContract).verifyProofAggregation(\\n proof.domainId,\\n proof.aggregationId,\\n leaf,\\n proof.zkMerklePath,\\n proof.leafCount,\\n proof.index\\n );\\n }\\n\\n function withdraw(\\n address token,\\n uint256 denomination,\\n address recipient,\\n bytes32 nullifierHash,\\n bytes32 root,\\n MixerProof calldata proof\\n ) external nonReentrant {\\n bytes32 poolId = _poolId(token, denomination);\\n require(allowedDenominations[poolId], \\\"Denomination not allowed\\\");\\n require(isKnownRoot(poolId, root), \\\"Unknown root\\\");\\n require(!nullifierUsed[poolId][nullifierHash], \\\"Nullifier already used\\\");\\n require(_verifyMixerProof(root, nullifierHash, recipient, token, denomination, proof), \\\"Invalid proof\\\");\\n\\n nullifierUsed[poolId][nullifierHash] = true;\\n\\n if (token == address(0)) {\\n (bool success, ) = recipient.call{ value: denomination }(\\\"\\\");\\n require(success, \\\"ETH transfer failed\\\");\\n } else {\\n SafeERC20.safeTransfer(IERC20(token), recipient, denomination);\\n }\\n\\n emit Withdrawal(recipient, nullifierHash, token, denomination, block.timestamp);\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x9d9194b09a7796501db0572892637e613960671d83a5cda3e201c2c3edef7ba6\",\"license\":\"MIT\"},\"poseidon-solidity/PoseidonT3.sol\":{\"content\":\"/// SPDX-License-Identifier: MIT\\npragma solidity >=0.7.0;\\n\\nlibrary PoseidonT3 {\\n uint constant M00 = 0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b;\\n uint constant M01 = 0x2969f27eed31a480b9c36c764379dbca2cc8fdd1415c3dded62940bcde0bd771;\\n uint constant M02 = 0x143021ec686a3f330d5f9e654638065ce6cd79e28c5b3753326244ee65a1b1a7;\\n uint constant M10 = 0x16ed41e13bb9c0c66ae119424fddbcbc9314dc9fdbdeea55d6c64543dc4903e0;\\n uint constant M11 = 0x2e2419f9ec02ec394c9871c832963dc1b89d743c8c7b964029b2311687b1fe23;\\n uint constant M12 = 0x176cc029695ad02582a70eff08a6fd99d057e12e58e7d7b6b16cdfabc8ee2911;\\n\\n // See here for a simplified implementation: https://github.com/vimwitch/poseidon-solidity/blob/e57becdabb65d99fdc586fe1e1e09e7108202d53/contracts/Poseidon.sol#L40\\n // Inspired by: https://github.com/iden3/circomlibjs/blob/v0.0.8/src/poseidon_slow.js\\n function hash(uint[2] memory) public pure returns (uint) {\\n assembly {\\n let F := 21888242871839275222246405745257275088548364400416034343698204186575808495617\\n let M20 := 0x2b90bba00fca0589f617e7dcbfe82e0df706ab640ceb247b791a93b74e36736d\\n let M21 := 0x101071f0032379b697315876690f053d148d4e109f5fb065c8aacc55a0f89bfa\\n let M22 := 0x19a3fc0a56702bf417ba7fee3802593fa644470307043f7773279cd71d25d5e0\\n\\n // load the inputs from memory\\n let state1 := add(mod(mload(0x80), F), 0x00f1445235f2148c5986587169fc1bcd887b08d4d00868df5696fff40956e864)\\n let state2 := add(mod(mload(0xa0), F), 0x08dff3487e8ac99e1f29a058d0fa80b930c728730b7ab36ce879f3890ecf73f5)\\n let scratch0 := mulmod(state1, state1, F)\\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\\n scratch0 := mulmod(state2, state2, F)\\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\\n scratch0 := add(\\n 0x2f27be690fdaee46c3ce28f7532b13c856c35342c84bda6e20966310fadc01d0,\\n add(add(15452833169820924772166449970675545095234312153403844297388521437673434406763, mulmod(state1, M10, F)), mulmod(state2, M20, F))\\n )\\n let scratch1 := add(\\n 0x2b2ae1acf68b7b8d2416bebf3d4f6234b763fe04b8043ee48b8327bebca16cf2,\\n add(add(18674271267752038776579386132900109523609358935013267566297499497165104279117, mulmod(state1, M11, F)), mulmod(state2, M21, F))\\n )\\n let scratch2 := add(\\n 0x0319d062072bef7ecca5eac06f97d4d55952c175ab6b03eae64b44c7dbf11cfa,\\n add(add(14817777843080276494683266178512808687156649753153012854386334860566696099579, mulmod(state1, M12, F)), mulmod(state2, M22, F))\\n )\\n let state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := mulmod(scratch1, scratch1, F)\\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\\n state0 := mulmod(scratch2, scratch2, F)\\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\\n state0 := add(0x28813dcaebaeaa828a376df87af4a63bc8b7bf27ad49c6298ef7b387bf28526d, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x2727673b2ccbc903f181bf38e1c1d40d2033865200c352bc150928adddf9cb78, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x234ec45ca27727c2e74abd2b2a1494cd6efbd43e340587d6b8fb9e31e65cc632, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := mulmod(state1, state1, F)\\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\\n scratch0 := mulmod(state2, state2, F)\\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\\n scratch0 := add(0x15b52534031ae18f7f862cb2cf7cf760ab10a8150a337b1ccd99ff6e8797d428, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0dc8fad6d9e4b35f5ed9a3d186b79ce38e0e8a8d1b58b132d701d4eecf68d1f6, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1bcd95ffc211fbca600f705fad3fb567ea4eb378f62e1fec97805518a47e4d9c, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := mulmod(scratch1, scratch1, F)\\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\\n state0 := mulmod(scratch2, scratch2, F)\\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\\n state0 := add(0x10520b0ab721cadfe9eff81b016fc34dc76da36c2578937817cb978d069de559, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1f6d48149b8e7f7d9b257d8ed5fbbaf42932498075fed0ace88a9eb81f5627f6, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1d9655f652309014d29e00ef35a2089bfff8dc1c816f0dc9ca34bdb5460c8705, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x04df5a56ff95bcafb051f7b1cd43a99ba731ff67e47032058fe3d4185697cc7d, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0672d995f8fff640151b3d290cedaf148690a10a8c8424a7f6ec282b6e4be828, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x099952b414884454b21200d7ffafdd5f0c9a9dcc06f2708e9fc1d8209b5c75b9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x052cba2255dfd00c7c483143ba8d469448e43586a9b4cd9183fd0e843a6b9fa6, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0b8badee690adb8eb0bd74712b7999af82de55707251ad7716077cb93c464ddc, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x119b1590f13307af5a1ee651020c07c749c15d60683a8050b963d0a8e4b2bdd1, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x03150b7cd6d5d17b2529d36be0f67b832c4acfc884ef4ee5ce15be0bfb4a8d09, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2cc6182c5e14546e3cf1951f173912355374efb83d80898abe69cb317c9ea565, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x005032551e6378c450cfe129a404b3764218cadedac14e2b92d2cd73111bf0f9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x233237e3289baa34bb147e972ebcb9516469c399fcc069fb88f9da2cc28276b5, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x05c8f4f4ebd4a6e3c980d31674bfbe6323037f21b34ae5a4e80c2d4c24d60280, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0a7b1db13042d396ba05d818a319f25252bcf35ef3aeed91ee1f09b2590fc65b, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2a73b71f9b210cf5b14296572c9d32dbf156e2b086ff47dc5df542365a404ec0, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1ac9b0417abcc9a1935107e9ffc91dc3ec18f2c4dbe7f22976a760bb5c50c460, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x12c0339ae08374823fabb076707ef479269f3e4d6cb104349015ee046dc93fc0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0b7475b102a165ad7f5b18db4e1e704f52900aa3253baac68246682e56e9a28e, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x037c2849e191ca3edb1c5e49f6e8b8917c843e379366f2ea32ab3aa88d7f8448, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x05a6811f8556f014e92674661e217e9bd5206c5c93a07dc145fdb176a716346f, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x29a795e7d98028946e947b75d54e9f044076e87a7b2883b47b675ef5f38bd66e, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x20439a0c84b322eb45a3857afc18f5826e8c7382c8a1585c507be199981fd22f, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2e0ba8d94d9ecf4a94ec2050c7371ff1bb50f27799a84b6d4a2a6f2a0982c887, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x143fd115ce08fb27ca38eb7cce822b4517822cd2109048d2e6d0ddcca17d71c8, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0c64cbecb1c734b857968dbbdcf813cdf8611659323dbcbfc84323623be9caf1, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x028a305847c683f646fca925c163ff5ae74f348d62c2b670f1426cef9403da53, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2e4ef510ff0b6fda5fa940ab4c4380f26a6bcb64d89427b824d6755b5db9e30c, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0081c95bc43384e663d79270c956ce3b8925b4f6d033b078b96384f50579400e, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2ed5f0c91cbd9749187e2fade687e05ee2491b349c039a0bba8a9f4023a0bb38, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x30509991f88da3504bbf374ed5aae2f03448a22c76234c8c990f01f33a735206, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1c3f20fd55409a53221b7c4d49a356b9f0a1119fb2067b41a7529094424ec6ad, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x10b4e7f3ab5df003049514459b6e18eec46bb2213e8e131e170887b47ddcb96c, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2a1982979c3ff7f43ddd543d891c2abddd80f804c077d775039aa3502e43adef, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1c74ee64f15e1db6feddbead56d6d55dba431ebc396c9af95cad0f1315bd5c91, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x07533ec850ba7f98eab9303cace01b4b9e4f2e8b82708cfa9c2fe45a0ae146a0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x21576b438e500449a151e4eeaf17b154285c68f42d42c1808a11abf3764c0750, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x2f17c0559b8fe79608ad5ca193d62f10bce8384c815f0906743d6930836d4a9e, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x2d477e3862d07708a79e8aae946170bc9775a4201318474ae665b0b1b7e2730e, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x162f5243967064c390e095577984f291afba2266c38f5abcd89be0f5b2747eab, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2b4cb233ede9ba48264ecd2c8ae50d1ad7a8596a87f29f8a7777a70092393311, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2c8fbcb2dd8573dc1dbaf8f4622854776db2eece6d85c4cf4254e7c35e03b07a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x1d6f347725e4816af2ff453f0cd56b199e1b61e9f601e9ade5e88db870949da9, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x204b0c397f4ebe71ebc2d8b3df5b913df9e6ac02b68d31324cd49af5c4565529, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0c4cb9dc3c4fd8174f1149b3c63c3c2f9ecb827cd7dc25534ff8fb75bc79c502, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x174ad61a1448c899a25416474f4930301e5c49475279e0639a616ddc45bc7b54, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1a96177bcf4d8d89f759df4ec2f3cde2eaaa28c177cc0fa13a9816d49a38d2ef, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x066d04b24331d71cd0ef8054bc60c4ff05202c126a233c1a8242ace360b8a30a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2a4c4fc6ec0b0cf52195782871c6dd3b381cc65f72e02ad527037a62aa1bd804, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x13ab2d136ccf37d447e9f2e14a7cedc95e727f8446f6d9d7e55afc01219fd649, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1121552fca26061619d24d843dc82769c1b04fcec26f55194c2e3e869acc6a9a, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x00ef653322b13d6c889bc81715c37d77a6cd267d595c4a8909a5546c7c97cff1, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0e25483e45a665208b261d8ba74051e6400c776d652595d9845aca35d8a397d3, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x29f536dcb9dd7682245264659e15d88e395ac3d4dde92d8c46448db979eeba89, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2a56ef9f2c53febadfda33575dbdbd885a124e2780bbea170e456baace0fa5be, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1c8361c78eb5cf5decfb7a2d17b5c409f2ae2999a46762e8ee416240a8cb9af1, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x151aff5f38b20a0fc0473089aaf0206b83e8e68a764507bfd3d0ab4be74319c5, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x04c6187e41ed881dc1b239c88f7f9d43a9f52fc8c8b6cdd1e76e47615b51f100, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x13b37bd80f4d27fb10d84331f6fb6d534b81c61ed15776449e801b7ddc9c2967, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x01a5c536273c2d9df578bfbd32c17b7a2ce3664c2a52032c9321ceb1c4e8a8e4, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2ab3561834ca73835ad05f5d7acb950b4a9a2c666b9726da832239065b7c3b02, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1d4d8ec291e720db200fe6d686c0d613acaf6af4e95d3bf69f7ed516a597b646, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x041294d2cc484d228f5784fe7919fd2bb925351240a04b711514c9c80b65af1d, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x154ac98e01708c611c4fa715991f004898f57939d126e392042971dd90e81fc6, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0b339d8acca7d4f83eedd84093aef51050b3684c88f8b0b04524563bc6ea4da4, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x0955e49e6610c94254a4f84cfbab344598f0e71eaff4a7dd81ed95b50839c82e, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x06746a6156eba54426b9e22206f15abca9a6f41e6f535c6f3525401ea0654626, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0f18f5a0ecd1423c496f3820c549c27838e5790e2bd0a196ac917c7ff32077fb, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x04f6eeca1751f7308ac59eff5beb261e4bb563583ede7bc92a738223d6f76e13, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2b56973364c4c4f5c1a3ec4da3cdce038811eb116fb3e45bc1768d26fc0b3758, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x123769dd49d5b054dcd76b89804b1bcb8e1392b385716a5d83feb65d437f29ef, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2147b424fc48c80a88ee52b91169aacea989f6446471150994257b2fb01c63e9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0fdc1f58548b85701a6c5505ea332a29647e6f34ad4243c2ea54ad897cebe54d, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x12373a8251fea004df68abcf0f7786d4bceff28c5dbbe0c3944f685cc0a0b1f2, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x21e4f4ea5f35f85bad7ea52ff742c9e8a642756b6af44203dd8a1f35c1a90035, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x16243916d69d2ca3dfb4722224d4c462b57366492f45e90d8a81934f1bc3b147, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1efbe46dd7a578b4f66f9adbc88b4378abc21566e1a0453ca13a4159cac04ac2, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x07ea5e8537cf5dd08886020e23a7f387d468d5525be66f853b672cc96a88969a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x05a8c4f9968b8aa3b7b478a30f9a5b63650f19a75e7ce11ca9fe16c0b76c00bc, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x20f057712cc21654fbfe59bd345e8dac3f7818c701b9c7882d9d57b72a32e83f, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x04a12ededa9dfd689672f8c67fee31636dcd8e88d01d49019bd90b33eb33db69, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x27e88d8c15f37dcee44f1e5425a51decbd136ce5091a6767e49ec9544ccd101a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2feed17b84285ed9b8a5c8c5e95a41f66e096619a7703223176c41ee433de4d1, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1ed7cc76edf45c7c404241420f729cf394e5942911312a0d6972b8bd53aff2b8, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x15742e99b9bfa323157ff8c586f5660eac6783476144cdcadf2874be45466b1a, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1aac285387f65e82c895fc6887ddf40577107454c6ec0317284f033f27d0c785, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x25851c3c845d4790f9ddadbdb6057357832e2e7a49775f71ec75a96554d67c77, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x15a5821565cc2ec2ce78457db197edf353b7ebba2c5523370ddccc3d9f146a67, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2411d57a4813b9980efa7e31a1db5966dcf64f36044277502f15485f28c71727, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x002e6f8d6520cd4713e335b8c0b6d2e647e9a98e12f4cd2558828b5ef6cb4c9b, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2ff7bc8f4380cde997da00b616b0fcd1af8f0e91e2fe1ed7398834609e0315d2, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x00b9831b948525595ee02724471bcd182e9521f6b7bb68f1e93be4febb0d3cbe, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0a2f53768b8ebf6a86913b0e57c04e011ca408648a4743a87d77adbf0c9c3512, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x00248156142fd0373a479f91ff239e960f599ff7e94be69b7f2a290305e1198d, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x171d5620b87bfb1328cf8c02ab3f0c9a397196aa6a542c2350eb512a2b2bcda9, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x170a4f55536f7dc970087c7c10d6fad760c952172dd54dd99d1045e4ec34a808, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x29aba33f799fe66c2ef3134aea04336ecc37e38c1cd211ba482eca17e2dbfae1, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1e9bc179a4fdd758fdd1bb1945088d47e70d114a03f6a0e8b5ba650369e64973, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1dd269799b660fad58f7f4892dfb0b5afeaad869a9c4b44f9c9e1c43bdaf8f09, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x22cdbc8b70117ad1401181d02e15459e7ccd426fe869c7c95d1dd2cb0f24af38, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0ef042e454771c533a9f57a55c503fcefd3150f52ed94a7cd5ba93b9c7dacefd, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x11609e06ad6c8fe2f287f3036037e8851318e8b08a0359a03b304ffca62e8284, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x1166d9e554616dba9e753eea427c17b7fecd58c076dfe42708b08f5b783aa9af, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x2de52989431a859593413026354413db177fbf4cd2ac0b56f855a888357ee466, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x3006eb4ffc7a85819a6da492f3a8ac1df51aee5b17b8e89d74bf01cf5f71e9ad, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2af41fbb61ba8a80fdcf6fff9e3f6f422993fe8f0a4639f962344c8225145086, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x119e684de476155fe5a6b41a8ebc85db8718ab27889e85e781b214bace4827c3, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1835b786e2e8925e188bea59ae363537b51248c23828f047cff784b97b3fd800, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x28201a34c594dfa34d794996c6433a20d152bac2a7905c926c40e285ab32eeb6, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x083efd7a27d1751094e80fefaf78b000864c82eb571187724a761f88c22cc4e7, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0b6f88a3577199526158e61ceea27be811c16df7774dd8519e079564f61fd13b, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x0ec868e6d15e51d9644f66e1d6471a94589511ca00d29e1014390e6ee4254f5b, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2af33e3f866771271ac0c9b3ed2e1142ecd3e74b939cd40d00d937ab84c98591, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x0b520211f904b5e7d09b5d961c6ace7734568c547dd6858b364ce5e47951f178, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0b2d722d0919a1aad8db58f10062a92ea0c56ac4270e822cca228620188a1d40, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1f790d4d7f8cf094d980ceb37c2453e957b54a9991ca38bbe0061d1ed6e562d4, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0171eb95dfbf7d1eaea97cd385f780150885c16235a2a6a8da92ceb01e504233, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x0c2d0e3b5fd57549329bf6885da66b9b790b40defd2c8650762305381b168873, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1162fb28689c27154e5a8228b4e72b377cbcafa589e283c35d3803054407a18d, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2f1459b65dee441b64ad386a91e8310f282c5a92a89e19921623ef8249711bc0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x1e6ff3216b688c3d996d74367d5cd4c1bc489d46754eb712c243f70d1b53cfbb, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x01ca8be73832b8d0681487d27d157802d741a6f36cdc2a0576881f9326478875, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1f7735706ffe9fc586f976d5bdf223dc680286080b10cea00b9b5de315f9650e, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2522b60f4ea3307640a0c2dce041fba921ac10a3d5f096ef4745ca838285f019, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x23f0bee001b1029d5255075ddc957f833418cad4f52b6c3f8ce16c235572575b, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2bc1ae8b8ddbb81fcaac2d44555ed5685d142633e9df905f66d9401093082d59, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0f9406b8296564a37304507b8dba3ed162371273a07b1fc98011fcd6ad72205f, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x2360a8eb0cc7defa67b72998de90714e17e75b174a52ee4acb126c8cd995f0a8, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x15871a5cddead976804c803cbaef255eb4815a5e96df8b006dcbbc2767f88948, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x193a56766998ee9e0a8652dd2f3b1da0362f4f54f72379544f957ccdeefb420f, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2a394a43934f86982f9be56ff4fab1703b2e63c8ad334834e4309805e777ae0f, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1859954cfeb8695f3e8b635dcb345192892cd11223443ba7b4166e8876c0d142, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x04e1181763050e58013444dbcb99f1902b11bc25d90bbdca408d3819f4fed32b, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0fdb253dee83869d40c335ea64de8c5bb10eb82db08b5e8b1f5e5552bfd05f23, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x058cbe8a9a5027bdaa4efb623adead6275f08686f1c08984a9d7c5bae9b4f1c0, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x1382edce9971e186497eadb1aeb1f52b23b4b83bef023ab0d15228b4cceca59a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x03464990f045c6ee0819ca51fd11b0be7f61b8eb99f14b77e1e6634601d9e8b5, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x23f7bfc8720dc296fff33b41f98ff83c6fcab4605db2eb5aaa5bc137aeb70a58, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0a59a158e3eec2117e6e94e7f0e9decf18c3ffd5e1531a9219636158bbaf62f2, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x06ec54c80381c052b58bf23b312ffd3ce2c4eba065420af8f4c23ed0075fd07b, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x118872dc832e0eb5476b56648e867ec8b09340f7a7bcb1b4962f0ff9ed1f9d01, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x13d69fa127d834165ad5c7cba7ad59ed52e0b0f0e42d7fea95e1906b520921b1, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x169a177f63ea681270b1c6877a73d21bde143942fb71dc55fd8a49f19f10c77b, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x04ef51591c6ead97ef42f287adce40d93abeb032b922f66ffb7e9a5a7450544d, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x256e175a1dc079390ecd7ca703fb2e3b19ec61805d4f03ced5f45ee6dd0f69ec, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x30102d28636abd5fe5f2af412ff6004f75cc360d3205dd2da002813d3e2ceeb2, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x10998e42dfcd3bbf1c0714bc73eb1bf40443a3fa99bef4a31fd31be182fcc792, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x193edd8e9fcf3d7625fa7d24b598a1d89f3362eaf4d582efecad76f879e36860, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x18168afd34f2d915d0368ce80b7b3347d1c7a561ce611425f2664d7aa51f0b5d, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x29383c01ebd3b6ab0c017656ebe658b6a328ec77bc33626e29e2e95b33ea6111, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x10646d2f2603de39a1f4ae5e7771a64a702db6e86fb76ab600bf573f9010c711, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0beb5e07d1b27145f575f1395a55bf132f90c25b40da7b3864d0242dcb1117fb, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x16d685252078c133dc0d3ecad62b5c8830f95bb2e54b59abdffbf018d96fa336, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x0a6abd1d833938f33c74154e0404b4b40a555bbbec21ddfafd672dd62047f01a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1a679f5d36eb7b5c8ea12a4c2dedc8feb12dffeec450317270a6f19b34cf1860, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x0980fb233bd456c23974d50e0ebfde4726a423eada4e8f6ffbc7592e3f1b93d6, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x161b42232e61b84cbf1810af93a38fc0cece3d5628c9282003ebacb5c312c72b, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0ada10a90c7f0520950f7d47a60d5e6a493f09787f1564e5d09203db47de1a0b, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1a730d372310ba82320345a29ac4238ed3f07a8a2b4e121bb50ddb9af407f451, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2c8120f268ef054f817064c369dda7ea908377feaba5c4dffbda10ef58e8c556, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1c7c8824f758753fa57c00789c684217b930e95313bcb73e6e7b8649a4968f70, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2cd9ed31f5f8691c8e39e4077a74faa0f400ad8b491eb3f7b47b27fa3fd1cf77, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x23ff4f9d46813457cf60d92f57618399a5e022ac321ca550854ae23918a22eea, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x09945a5d147a4f66ceece6405dddd9d0af5a2c5103529407dff1ea58f180426d, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x188d9c528025d4c2b67660c6b771b90f7c7da6eaa29d3f268a6dd223ec6fc630, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x3050e37996596b7f81f68311431d8734dba7d926d3633595e0c0d8ddf4f0f47f, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x15af1169396830a91600ca8102c35c426ceae5461e3f95d89d829518d30afd78, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1da6d09885432ea9a06d9f37f873d985dae933e351466b2904284da3320d8acc, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2796ea90d269af29f5f8acf33921124e4e4fad3dbe658945e546ee411ddaa9cb, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x202d7dd1da0f6b4b0325c8b3307742f01e15612ec8e9304a7cb0319e01d32d60, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x096d6790d05bb759156a952ba263d672a2d7f9c788f4c831a29dace4c0f8be5f, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x054efa1f65b0fce283808965275d877b438da23ce5b13e1963798cb1447d25a4, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1b162f83d917e93edb3308c29802deb9d8aa690113b2e14864ccf6e18e4165f1, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x21e5241e12564dd6fd9f1cdd2a0de39eedfefc1466cc568ec5ceb745a0506edc, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := mulmod(scratch1, scratch1, F)\\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\\n state0 := mulmod(scratch2, scratch2, F)\\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\\n state0 := add(0x1cfb5662e8cf5ac9226a80ee17b36abecb73ab5f87e161927b4349e10e4bdf08, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0f21177e302a771bbae6d8d1ecb373b62c99af346220ac0129c53f666eb24100, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1671522374606992affb0dd7f71b12bec4236aede6290546bcef7e1f515c2320, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := mulmod(state1, state1, F)\\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\\n scratch0 := mulmod(state2, state2, F)\\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\\n scratch0 := add(0x0fa3ec5b9488259c2eb4cf24501bfad9be2ec9e42c5cc8ccd419d2a692cad870, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x193c0e04e0bd298357cb266c1506080ed36edce85c648cc085e8c57b1ab54bba, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x102adf8ef74735a27e9128306dcbc3c99f6f7291cd406578ce14ea2adaba68f8, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := mulmod(scratch1, scratch1, F)\\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\\n state0 := mulmod(scratch2, scratch2, F)\\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\\n state0 := add(0x0fe0af7858e49859e2a54d6f1ad945b1316aa24bfbdd23ae40a6d0cb70c3eab1, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x216f6717bbc7dedb08536a2220843f4e2da5f1daa9ebdefde8a5ea7344798d22, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1da55cc900f0d21f4a3e694391918a1b3c23b2ac773c6b3ef88e2e4228325161, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := mulmod(state1, state1, F)\\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\\n scratch0 := mulmod(state2, state2, F)\\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\\n\\n mstore(0x0, mod(add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)), F))\\n\\n return(0, 0x20)\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0102caa303bbc6690508f3615604f7730789ed990058c9513a87ccb30e4835be\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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__$75f79a42d9bcbdbb69ad79ebd80f556f39$__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", + "libraries": { + "PoseidonT3": "0x3333333C0A88F9BE4fd23ed0536F9B6c427e3B93" + }, + "devdoc": { + "errors": { + "AddressEmptyCode(address)": [ + { + "details": "There's no code at `target` (it is not a contract)." + } + ], + "AddressInsufficientBalance(address)": [ + { + "details": "The ETH balance of the account is not enough to perform the operation." + } + ], + "FailedInnerCall()": [ + { + "details": "A call to an address target failed. The target may have reverted." + } + ], + "ReentrancyGuardReentrantCall()": [ + { + "details": "Unauthorized reentrant call." + } + ], + "SafeERC20FailedOperation(address)": [ + { + "details": "An operation with an ERC20 token failed." + } + ] + }, + "kind": "dev", + "methods": { + "getZeroHash(uint256)": { + "details": "Exposed for Poseidon/zero-hash consistency tests (JS vs Solidity)" + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [ + { + "astId": 667, + "contract": "contracts/Mixer.sol:Mixer", + "label": "_status", + "offset": 0, + "slot": "0", + "type": "t_uint256" + }, + { + "astId": 805, + "contract": "contracts/Mixer.sol:Mixer", + "label": "trees", + "offset": 0, + "slot": "1", + "type": "t_mapping(t_bytes32,t_struct(MerkleTree)788_storage)" + }, + { + "astId": 811, + "contract": "contracts/Mixer.sol:Mixer", + "label": "rootHistory", + "offset": 0, + "slot": "2", + "type": "t_mapping(t_bytes32,t_array(t_bytes32)30_storage)" + }, + { + "astId": 815, + "contract": "contracts/Mixer.sol:Mixer", + "label": "rootHistoryIndex", + "offset": 0, + "slot": "3", + "type": "t_mapping(t_bytes32,t_uint256)" + }, + { + "astId": 821, + "contract": "contracts/Mixer.sol:Mixer", + "label": "nullifierUsed", + "offset": 0, + "slot": "4", + "type": "t_mapping(t_bytes32,t_mapping(t_bytes32,t_bool))" + }, + { + "astId": 825, + "contract": "contracts/Mixer.sol:Mixer", + "label": "allowedDenominations", + "offset": 0, + "slot": "5", + "type": "t_mapping(t_bytes32,t_bool)" + }, + { + "astId": 829, + "contract": "contracts/Mixer.sol:Mixer", + "label": "commitmentUsed", + "offset": 0, + "slot": "6", + "type": "t_mapping(t_bytes32,t_bool)" + }, + { + "astId": 835, + "contract": "contracts/Mixer.sol:Mixer", + "label": "zeroHashes", + "offset": 0, + "slot": "7", + "type": "t_array(t_uint256)21_storage" + } + ], + "types": { + "t_array(t_bytes32)30_storage": { + "base": "t_bytes32", + "encoding": "inplace", + "label": "bytes32[30]", + "numberOfBytes": "960" + }, + "t_array(t_uint256)20_storage": { + "base": "t_uint256", + "encoding": "inplace", + "label": "uint256[20]", + "numberOfBytes": "640" + }, + "t_array(t_uint256)21_storage": { + "base": "t_uint256", + "encoding": "inplace", + "label": "uint256[21]", + "numberOfBytes": "672" + }, + "t_bool": { + "encoding": "inplace", + "label": "bool", + "numberOfBytes": "1" + }, + "t_bytes32": { + "encoding": "inplace", + "label": "bytes32", + "numberOfBytes": "32" + }, + "t_mapping(t_bytes32,t_array(t_bytes32)30_storage)": { + "encoding": "mapping", + "key": "t_bytes32", + "label": "mapping(bytes32 => bytes32[30])", + "numberOfBytes": "32", + "value": "t_array(t_bytes32)30_storage" + }, + "t_mapping(t_bytes32,t_bool)": { + "encoding": "mapping", + "key": "t_bytes32", + "label": "mapping(bytes32 => bool)", + "numberOfBytes": "32", + "value": "t_bool" + }, + "t_mapping(t_bytes32,t_mapping(t_bytes32,t_bool))": { + "encoding": "mapping", + "key": "t_bytes32", + "label": "mapping(bytes32 => mapping(bytes32 => bool))", + "numberOfBytes": "32", + "value": "t_mapping(t_bytes32,t_bool)" + }, + "t_mapping(t_bytes32,t_struct(MerkleTree)788_storage)": { + "encoding": "mapping", + "key": "t_bytes32", + "label": "mapping(bytes32 => struct Mixer.MerkleTree)", + "numberOfBytes": "32", + "value": "t_struct(MerkleTree)788_storage" + }, + "t_mapping(t_bytes32,t_uint256)": { + "encoding": "mapping", + "key": "t_bytes32", + "label": "mapping(bytes32 => uint256)", + "numberOfBytes": "32", + "value": "t_uint256" + }, + "t_struct(MerkleTree)788_storage": { + "encoding": "inplace", + "label": "struct Mixer.MerkleTree", + "members": [ + { + "astId": 783, + "contract": "contracts/Mixer.sol:Mixer", + "label": "nextIndex", + "offset": 0, + "slot": "0", + "type": "t_uint256" + }, + { + "astId": 787, + "contract": "contracts/Mixer.sol:Mixer", + "label": "filledSubtrees", + "offset": 0, + "slot": "1", + "type": "t_array(t_uint256)20_storage" + } + ], + "numberOfBytes": "672" + }, + "t_uint256": { + "encoding": "inplace", + "label": "uint256", + "numberOfBytes": "32" + } + } + } +} \ No newline at end of file diff --git a/packages/hardhat/deployments/horizenTestnet/solcInputs/7f0373dedc61097daaf6a7dfc1f19d7a.json b/packages/hardhat/deployments/horizenTestnet/solcInputs/7f0373dedc61097daaf6a7dfc1f19d7a.json new file mode 100644 index 0000000..4714154 --- /dev/null +++ b/packages/hardhat/deployments/horizenTestnet/solcInputs/7f0373dedc61097daaf6a7dfc1f19d7a.json @@ -0,0 +1,54 @@ +{ + "language": "Solidity", + "sources": { + "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * ==== Security Considerations\n *\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\n * generally recommended is:\n *\n * ```solidity\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\n * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\n * doThing(..., value);\n * }\n *\n * function doThing(..., uint256 value) public {\n * token.safeTransferFrom(msg.sender, address(this), value);\n * ...\n * }\n * ```\n *\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\n * {SafeERC20-safeTransferFrom}).\n *\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\n * contracts should have entry points that don't rely on permit.\n */\ninterface IERC20Permit {\n /**\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n * given ``owner``'s signed approval.\n *\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n * ordering also apply here.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `deadline` must be a timestamp in the future.\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n * over the EIP712-formatted function arguments.\n * - the signature must use ``owner``'s current nonce (see {nonces}).\n *\n * For more information on the signature format, see the\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n * section].\n *\n * CAUTION: See Security Considerations above.\n */\n function permit(\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external;\n\n /**\n * @dev Returns the current nonce for `owner`. This value must be\n * included whenever a signature is generated for {permit}.\n *\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\n * prevents a signature from being used multiple times.\n */\n function nonces(address owner) external view returns (uint256);\n\n /**\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n */\n // solhint-disable-next-line func-name-mixedcase\n function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/IERC20.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n\n /**\n * @dev Returns the value of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the value of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address to, uint256 value) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n * caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 value) external returns (bool);\n\n /**\n * @dev Moves a `value` amount of tokens from `from` to `to` using the\n * allowance mechanism. `value` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n" + }, + "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\nimport {IERC20Permit} from \"../extensions/IERC20Permit.sol\";\nimport {Address} from \"../../../utils/Address.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n using Address for address;\n\n /**\n * @dev An operation with an ERC20 token failed.\n */\n error SafeERC20FailedOperation(address token);\n\n /**\n * @dev Indicates a failed `decreaseAllowance` request.\n */\n error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\n\n /**\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n * non-reverting calls are assumed to be successful.\n */\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\n }\n\n /**\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n */\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\n }\n\n /**\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n * non-reverting calls are assumed to be successful.\n */\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n uint256 oldAllowance = token.allowance(address(this), spender);\n forceApprove(token, spender, oldAllowance + value);\n }\n\n /**\n * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\n * value, non-reverting calls are assumed to be successful.\n */\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\n unchecked {\n uint256 currentAllowance = token.allowance(address(this), spender);\n if (currentAllowance < requestedDecrease) {\n revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\n }\n forceApprove(token, spender, currentAllowance - requestedDecrease);\n }\n }\n\n /**\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n * to be set to zero before setting it to a non-zero value, such as USDT.\n */\n function forceApprove(IERC20 token, address spender, uint256 value) internal {\n bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\n\n if (!_callOptionalReturnBool(token, approvalCall)) {\n _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\n _callOptionalReturn(token, approvalCall);\n }\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n */\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\n // the target address contains contract code and also asserts for success in the low-level call.\n\n bytes memory returndata = address(token).functionCall(data);\n if (returndata.length != 0 && !abi.decode(returndata, (bool))) {\n revert SafeERC20FailedOperation(address(token));\n }\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n *\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\n */\n function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\n // and not revert is the subcall reverts.\n\n (bool success, bytes memory returndata) = address(token).call(data);\n return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;\n }\n}\n" + }, + "@openzeppelin/contracts/utils/Address.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n /**\n * @dev The ETH balance of the account is not enough to perform the operation.\n */\n error AddressInsufficientBalance(address account);\n\n /**\n * @dev There's no code at `target` (it is not a contract).\n */\n error AddressEmptyCode(address target);\n\n /**\n * @dev A call to an address target failed. The target may have reverted.\n */\n error FailedInnerCall();\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n if (address(this).balance < amount) {\n revert AddressInsufficientBalance(address(this));\n }\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n if (!success) {\n revert FailedInnerCall();\n }\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason or custom error, it is bubbled\n * up by this function (like regular Solidity function calls). However, if\n * the call reverted with no returned reason, this function reverts with a\n * {FailedInnerCall} error.\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n if (address(this).balance < value) {\n revert AddressInsufficientBalance(address(this));\n }\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResultFromTarget(target, success, returndata);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResultFromTarget(target, success, returndata);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return verifyCallResultFromTarget(target, success, returndata);\n }\n\n /**\n * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\n * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an\n * unsuccessful call.\n */\n function verifyCallResultFromTarget(\n address target,\n bool success,\n bytes memory returndata\n ) internal view returns (bytes memory) {\n if (!success) {\n _revert(returndata);\n } else {\n // only check if target is a contract if the call was successful and the return data is empty\n // otherwise we already know that it was a contract\n if (returndata.length == 0 && target.code.length == 0) {\n revert AddressEmptyCode(target);\n }\n return returndata;\n }\n }\n\n /**\n * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\n * revert reason or with a default {FailedInnerCall} error.\n */\n function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\n if (!success) {\n _revert(returndata);\n } else {\n return returndata;\n }\n }\n\n /**\n * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.\n */\n function _revert(bytes memory returndata) private pure {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert FailedInnerCall();\n }\n }\n}\n" + }, + "@openzeppelin/contracts/utils/ReentrancyGuard.sol": { + "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard {\n // Booleans are more expensive than uint256 or any type that takes up a full\n // word because each write operation emits an extra SLOAD to first read the\n // slot's contents, replace the bits taken up by the boolean, and then write\n // back. This is the compiler's defense against contract upgrades and\n // pointer aliasing, and it cannot be disabled.\n\n // The values being non-zero value makes deployment a bit more expensive,\n // but in exchange the refund on every call to nonReentrant will be lower in\n // amount. Since refunds are capped to a percentage of the total\n // transaction's gas, it is best to keep them low in cases like this one, to\n // increase the likelihood of the full refund coming into effect.\n uint256 private constant NOT_ENTERED = 1;\n uint256 private constant ENTERED = 2;\n\n uint256 private _status;\n\n /**\n * @dev Unauthorized reentrant call.\n */\n error ReentrancyGuardReentrantCall();\n\n constructor() {\n _status = NOT_ENTERED;\n }\n\n /**\n * @dev Prevents a contract from calling itself, directly or indirectly.\n * Calling a `nonReentrant` function from another `nonReentrant`\n * function is not supported. It is possible to prevent this from happening\n * by making the `nonReentrant` function external, and making it call a\n * `private` function that does the actual work.\n */\n modifier nonReentrant() {\n _nonReentrantBefore();\n _;\n _nonReentrantAfter();\n }\n\n function _nonReentrantBefore() private {\n // On the first call to nonReentrant, _status will be NOT_ENTERED\n if (_status == ENTERED) {\n revert ReentrancyGuardReentrantCall();\n }\n\n // Any calls to nonReentrant after this point will fail\n _status = ENTERED;\n }\n\n function _nonReentrantAfter() private {\n // By storing the original value once again, a refund is triggered (see\n // https://eips.ethereum.org/EIPS/eip-2200)\n _status = NOT_ENTERED;\n }\n\n /**\n * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n * `nonReentrant` function in the call stack.\n */\n function _reentrancyGuardEntered() internal view returns (bool) {\n return _status == ENTERED;\n }\n}\n" + }, + "contracts/Mixer.sol": { + "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.13;\n\nimport \"@openzeppelin/contracts/utils/ReentrancyGuard.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"poseidon-solidity/PoseidonT3.sol\";\n\ninterface IVerifyProofAggregation {\n function verifyProofAggregation(\n uint256 _domainId,\n uint256 _aggregationId,\n bytes32 _leaf,\n bytes32[] calldata _merklePath,\n uint256 _leafCount,\n uint256 _index\n ) external view returns (bool);\n}\n\ncontract Mixer is ReentrancyGuard {\n uint256 public constant BN254_PRIME = 21888242871839275222246405745257275088548364400416034343698204186575808495617;\n bytes32 public constant PROVING_SYSTEM_ID = keccak256(abi.encodePacked(\"ultraplonk\"));\n bytes32 public constant VERSION_HASH = sha256(abi.encodePacked(\"\"));\n uint256 public constant TREE_DEPTH = 20;\n uint256 public constant ROOT_HISTORY_SIZE = 30;\n\n address public immutable zkvContract;\n bytes32 public immutable vkHash;\n\n struct MerkleTree {\n uint256 nextIndex;\n uint256[TREE_DEPTH] filledSubtrees;\n }\n\n struct MixerProof {\n uint256 aggregationId;\n uint256 domainId;\n bytes32[] zkMerklePath;\n uint256 leafCount;\n uint256 index;\n }\n\n mapping(bytes32 => MerkleTree) public trees;\n mapping(bytes32 => bytes32[ROOT_HISTORY_SIZE]) public rootHistory;\n mapping(bytes32 => uint256) public rootHistoryIndex;\n mapping(bytes32 => mapping(bytes32 => bool)) public nullifierUsed;\n mapping(bytes32 => bool) public allowedDenominations;\n mapping(bytes32 => bool) public commitmentUsed;\n\n uint256[TREE_DEPTH + 1] internal zeroHashes;\n\n event Deposit(bytes32 indexed commitment, uint256 leafIndex, uint256 timestamp, address indexed token, uint256 denomination);\n event Withdrawal(address indexed recipient, bytes32 nullifierHash, address indexed token, uint256 denomination, uint256 timestamp);\n\n constructor(\n address _zkvContract,\n bytes32 _vkHash,\n bytes32[] memory _allowedPoolIds\n ) {\n require(_zkvContract != address(0), \"Invalid zkv\");\n zkvContract = _zkvContract;\n vkHash = _vkHash;\n for (uint256 i = 0; i < _allowedPoolIds.length; i++) {\n allowedDenominations[_allowedPoolIds[i]] = true;\n }\n _computeZeroHashes();\n }\n\n function _computeZeroHashes() internal {\n zeroHashes[0] = 0;\n for (uint256 i = 1; i <= TREE_DEPTH; i++) {\n zeroHashes[i] = _poseidonHash2(zeroHashes[i - 1], zeroHashes[i - 1]);\n }\n }\n\n /// @dev Exposed for Poseidon/zero-hash consistency tests (JS vs Solidity)\n function getZeroHash(uint256 level) external view returns (bytes32) {\n require(level <= TREE_DEPTH, \"level\");\n return bytes32(zeroHashes[level]);\n }\n\n function _poseidonHash2(uint256 a, uint256 b) internal view returns (uint256) {\n uint256 safeA = a % BN254_PRIME;\n uint256 safeB = b % BN254_PRIME;\n return PoseidonT3.hash([safeA, safeB]);\n }\n\n function _poolId(address token, uint256 denomination) internal pure returns (bytes32) {\n return keccak256(abi.encodePacked(token, denomination));\n }\n\n function deposit(address token, uint256 denomination, bytes32 commitment) external payable nonReentrant {\n bytes32 poolId = _poolId(token, denomination);\n require(allowedDenominations[poolId], \"Denomination not allowed\");\n require(!commitmentUsed[commitment], \"Commitment already used\");\n\n if (token == address(0)) {\n require(msg.value == denomination, \"ETH value mismatch\");\n } else {\n require(msg.value == 0, \"No ETH for ERC20\");\n SafeERC20.safeTransferFrom(IERC20(token), msg.sender, address(this), denomination);\n }\n\n uint256 leaf = uint256(commitment);\n MerkleTree storage tree = trees[poolId];\n uint256 leafIndex = tree.nextIndex;\n tree.nextIndex++;\n\n uint256 current = leaf;\n for (uint256 i = 0; i < TREE_DEPTH; i++) {\n if ((leafIndex >> i) % 2 == 0) {\n tree.filledSubtrees[i] = current;\n current = _poseidonHash2(current, zeroHashes[i]);\n } else {\n current = _poseidonHash2(tree.filledSubtrees[i], current);\n }\n }\n\n uint256 root = current;\n uint256 rhi = rootHistoryIndex[poolId] % ROOT_HISTORY_SIZE;\n rootHistory[poolId][rhi] = bytes32(root);\n rootHistoryIndex[poolId]++;\n\n commitmentUsed[commitment] = true;\n\n emit Deposit(commitment, tree.nextIndex - 1, block.timestamp, token, denomination);\n }\n\n function isKnownRoot(bytes32 poolId, bytes32 root) public view returns (bool) {\n uint256 rhi = rootHistoryIndex[poolId];\n if (rhi == 0) return false;\n uint256 size = rhi < ROOT_HISTORY_SIZE ? rhi : ROOT_HISTORY_SIZE;\n for (uint256 i = 0; i < size; i++) {\n uint256 idx = (rhi - 1 - i) % ROOT_HISTORY_SIZE;\n if (rootHistory[poolId][idx] == root) return true;\n }\n return false;\n }\n\n function _verifyMixerProof(\n bytes32 root,\n bytes32 nullifierHash,\n address recipient,\n address token,\n uint256 denomination,\n MixerProof calldata proof\n ) internal view returns (bool) {\n bytes memory encodedInputs = abi.encodePacked(\n root,\n nullifierHash,\n uint256(uint160(recipient)),\n uint256(uint160(token)),\n denomination\n );\n bytes32 leaf = keccak256(abi.encodePacked(PROVING_SYSTEM_ID, vkHash, VERSION_HASH, keccak256(encodedInputs)));\n return IVerifyProofAggregation(zkvContract).verifyProofAggregation(\n proof.domainId,\n proof.aggregationId,\n leaf,\n proof.zkMerklePath,\n proof.leafCount,\n proof.index\n );\n }\n\n function withdraw(\n address token,\n uint256 denomination,\n address recipient,\n bytes32 nullifierHash,\n bytes32 root,\n MixerProof calldata proof\n ) external nonReentrant {\n bytes32 poolId = _poolId(token, denomination);\n require(allowedDenominations[poolId], \"Denomination not allowed\");\n require(isKnownRoot(poolId, root), \"Unknown root\");\n require(!nullifierUsed[poolId][nullifierHash], \"Nullifier already used\");\n require(_verifyMixerProof(root, nullifierHash, recipient, token, denomination, proof), \"Invalid proof\");\n\n nullifierUsed[poolId][nullifierHash] = true;\n\n if (token == address(0)) {\n (bool success, ) = recipient.call{ value: denomination }(\"\");\n require(success, \"ETH transfer failed\");\n } else {\n SafeERC20.safeTransfer(IERC20(token), recipient, denomination);\n }\n\n emit Withdrawal(recipient, nullifierHash, token, denomination, block.timestamp);\n }\n\n receive() external payable {}\n}\n" + }, + "poseidon-solidity/PoseidonT3.sol": { + "content": "/// SPDX-License-Identifier: MIT\npragma solidity >=0.7.0;\n\nlibrary PoseidonT3 {\n uint constant M00 = 0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b;\n uint constant M01 = 0x2969f27eed31a480b9c36c764379dbca2cc8fdd1415c3dded62940bcde0bd771;\n uint constant M02 = 0x143021ec686a3f330d5f9e654638065ce6cd79e28c5b3753326244ee65a1b1a7;\n uint constant M10 = 0x16ed41e13bb9c0c66ae119424fddbcbc9314dc9fdbdeea55d6c64543dc4903e0;\n uint constant M11 = 0x2e2419f9ec02ec394c9871c832963dc1b89d743c8c7b964029b2311687b1fe23;\n uint constant M12 = 0x176cc029695ad02582a70eff08a6fd99d057e12e58e7d7b6b16cdfabc8ee2911;\n\n // See here for a simplified implementation: https://github.com/vimwitch/poseidon-solidity/blob/e57becdabb65d99fdc586fe1e1e09e7108202d53/contracts/Poseidon.sol#L40\n // Inspired by: https://github.com/iden3/circomlibjs/blob/v0.0.8/src/poseidon_slow.js\n function hash(uint[2] memory) public pure returns (uint) {\n assembly {\n let F := 21888242871839275222246405745257275088548364400416034343698204186575808495617\n let M20 := 0x2b90bba00fca0589f617e7dcbfe82e0df706ab640ceb247b791a93b74e36736d\n let M21 := 0x101071f0032379b697315876690f053d148d4e109f5fb065c8aacc55a0f89bfa\n let M22 := 0x19a3fc0a56702bf417ba7fee3802593fa644470307043f7773279cd71d25d5e0\n\n // load the inputs from memory\n let state1 := add(mod(mload(0x80), F), 0x00f1445235f2148c5986587169fc1bcd887b08d4d00868df5696fff40956e864)\n let state2 := add(mod(mload(0xa0), F), 0x08dff3487e8ac99e1f29a058d0fa80b930c728730b7ab36ce879f3890ecf73f5)\n let scratch0 := mulmod(state1, state1, F)\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\n scratch0 := mulmod(state2, state2, F)\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\n scratch0 := add(\n 0x2f27be690fdaee46c3ce28f7532b13c856c35342c84bda6e20966310fadc01d0,\n add(add(15452833169820924772166449970675545095234312153403844297388521437673434406763, mulmod(state1, M10, F)), mulmod(state2, M20, F))\n )\n let scratch1 := add(\n 0x2b2ae1acf68b7b8d2416bebf3d4f6234b763fe04b8043ee48b8327bebca16cf2,\n add(add(18674271267752038776579386132900109523609358935013267566297499497165104279117, mulmod(state1, M11, F)), mulmod(state2, M21, F))\n )\n let scratch2 := add(\n 0x0319d062072bef7ecca5eac06f97d4d55952c175ab6b03eae64b44c7dbf11cfa,\n add(add(14817777843080276494683266178512808687156649753153012854386334860566696099579, mulmod(state1, M12, F)), mulmod(state2, M22, F))\n )\n let state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := mulmod(scratch1, scratch1, F)\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\n state0 := mulmod(scratch2, scratch2, F)\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\n state0 := add(0x28813dcaebaeaa828a376df87af4a63bc8b7bf27ad49c6298ef7b387bf28526d, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x2727673b2ccbc903f181bf38e1c1d40d2033865200c352bc150928adddf9cb78, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x234ec45ca27727c2e74abd2b2a1494cd6efbd43e340587d6b8fb9e31e65cc632, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := mulmod(state1, state1, F)\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\n scratch0 := mulmod(state2, state2, F)\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\n scratch0 := add(0x15b52534031ae18f7f862cb2cf7cf760ab10a8150a337b1ccd99ff6e8797d428, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x0dc8fad6d9e4b35f5ed9a3d186b79ce38e0e8a8d1b58b132d701d4eecf68d1f6, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x1bcd95ffc211fbca600f705fad3fb567ea4eb378f62e1fec97805518a47e4d9c, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := mulmod(scratch1, scratch1, F)\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\n state0 := mulmod(scratch2, scratch2, F)\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\n state0 := add(0x10520b0ab721cadfe9eff81b016fc34dc76da36c2578937817cb978d069de559, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x1f6d48149b8e7f7d9b257d8ed5fbbaf42932498075fed0ace88a9eb81f5627f6, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x1d9655f652309014d29e00ef35a2089bfff8dc1c816f0dc9ca34bdb5460c8705, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x04df5a56ff95bcafb051f7b1cd43a99ba731ff67e47032058fe3d4185697cc7d, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x0672d995f8fff640151b3d290cedaf148690a10a8c8424a7f6ec282b6e4be828, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x099952b414884454b21200d7ffafdd5f0c9a9dcc06f2708e9fc1d8209b5c75b9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x052cba2255dfd00c7c483143ba8d469448e43586a9b4cd9183fd0e843a6b9fa6, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x0b8badee690adb8eb0bd74712b7999af82de55707251ad7716077cb93c464ddc, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x119b1590f13307af5a1ee651020c07c749c15d60683a8050b963d0a8e4b2bdd1, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x03150b7cd6d5d17b2529d36be0f67b832c4acfc884ef4ee5ce15be0bfb4a8d09, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x2cc6182c5e14546e3cf1951f173912355374efb83d80898abe69cb317c9ea565, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x005032551e6378c450cfe129a404b3764218cadedac14e2b92d2cd73111bf0f9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x233237e3289baa34bb147e972ebcb9516469c399fcc069fb88f9da2cc28276b5, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x05c8f4f4ebd4a6e3c980d31674bfbe6323037f21b34ae5a4e80c2d4c24d60280, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x0a7b1db13042d396ba05d818a319f25252bcf35ef3aeed91ee1f09b2590fc65b, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x2a73b71f9b210cf5b14296572c9d32dbf156e2b086ff47dc5df542365a404ec0, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x1ac9b0417abcc9a1935107e9ffc91dc3ec18f2c4dbe7f22976a760bb5c50c460, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x12c0339ae08374823fabb076707ef479269f3e4d6cb104349015ee046dc93fc0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x0b7475b102a165ad7f5b18db4e1e704f52900aa3253baac68246682e56e9a28e, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x037c2849e191ca3edb1c5e49f6e8b8917c843e379366f2ea32ab3aa88d7f8448, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x05a6811f8556f014e92674661e217e9bd5206c5c93a07dc145fdb176a716346f, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x29a795e7d98028946e947b75d54e9f044076e87a7b2883b47b675ef5f38bd66e, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x20439a0c84b322eb45a3857afc18f5826e8c7382c8a1585c507be199981fd22f, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x2e0ba8d94d9ecf4a94ec2050c7371ff1bb50f27799a84b6d4a2a6f2a0982c887, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x143fd115ce08fb27ca38eb7cce822b4517822cd2109048d2e6d0ddcca17d71c8, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x0c64cbecb1c734b857968dbbdcf813cdf8611659323dbcbfc84323623be9caf1, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x028a305847c683f646fca925c163ff5ae74f348d62c2b670f1426cef9403da53, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x2e4ef510ff0b6fda5fa940ab4c4380f26a6bcb64d89427b824d6755b5db9e30c, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x0081c95bc43384e663d79270c956ce3b8925b4f6d033b078b96384f50579400e, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x2ed5f0c91cbd9749187e2fade687e05ee2491b349c039a0bba8a9f4023a0bb38, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x30509991f88da3504bbf374ed5aae2f03448a22c76234c8c990f01f33a735206, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x1c3f20fd55409a53221b7c4d49a356b9f0a1119fb2067b41a7529094424ec6ad, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x10b4e7f3ab5df003049514459b6e18eec46bb2213e8e131e170887b47ddcb96c, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x2a1982979c3ff7f43ddd543d891c2abddd80f804c077d775039aa3502e43adef, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x1c74ee64f15e1db6feddbead56d6d55dba431ebc396c9af95cad0f1315bd5c91, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x07533ec850ba7f98eab9303cace01b4b9e4f2e8b82708cfa9c2fe45a0ae146a0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x21576b438e500449a151e4eeaf17b154285c68f42d42c1808a11abf3764c0750, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x2f17c0559b8fe79608ad5ca193d62f10bce8384c815f0906743d6930836d4a9e, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x2d477e3862d07708a79e8aae946170bc9775a4201318474ae665b0b1b7e2730e, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x162f5243967064c390e095577984f291afba2266c38f5abcd89be0f5b2747eab, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x2b4cb233ede9ba48264ecd2c8ae50d1ad7a8596a87f29f8a7777a70092393311, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x2c8fbcb2dd8573dc1dbaf8f4622854776db2eece6d85c4cf4254e7c35e03b07a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x1d6f347725e4816af2ff453f0cd56b199e1b61e9f601e9ade5e88db870949da9, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x204b0c397f4ebe71ebc2d8b3df5b913df9e6ac02b68d31324cd49af5c4565529, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x0c4cb9dc3c4fd8174f1149b3c63c3c2f9ecb827cd7dc25534ff8fb75bc79c502, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x174ad61a1448c899a25416474f4930301e5c49475279e0639a616ddc45bc7b54, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x1a96177bcf4d8d89f759df4ec2f3cde2eaaa28c177cc0fa13a9816d49a38d2ef, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x066d04b24331d71cd0ef8054bc60c4ff05202c126a233c1a8242ace360b8a30a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x2a4c4fc6ec0b0cf52195782871c6dd3b381cc65f72e02ad527037a62aa1bd804, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x13ab2d136ccf37d447e9f2e14a7cedc95e727f8446f6d9d7e55afc01219fd649, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x1121552fca26061619d24d843dc82769c1b04fcec26f55194c2e3e869acc6a9a, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x00ef653322b13d6c889bc81715c37d77a6cd267d595c4a8909a5546c7c97cff1, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x0e25483e45a665208b261d8ba74051e6400c776d652595d9845aca35d8a397d3, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x29f536dcb9dd7682245264659e15d88e395ac3d4dde92d8c46448db979eeba89, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x2a56ef9f2c53febadfda33575dbdbd885a124e2780bbea170e456baace0fa5be, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x1c8361c78eb5cf5decfb7a2d17b5c409f2ae2999a46762e8ee416240a8cb9af1, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x151aff5f38b20a0fc0473089aaf0206b83e8e68a764507bfd3d0ab4be74319c5, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x04c6187e41ed881dc1b239c88f7f9d43a9f52fc8c8b6cdd1e76e47615b51f100, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x13b37bd80f4d27fb10d84331f6fb6d534b81c61ed15776449e801b7ddc9c2967, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x01a5c536273c2d9df578bfbd32c17b7a2ce3664c2a52032c9321ceb1c4e8a8e4, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x2ab3561834ca73835ad05f5d7acb950b4a9a2c666b9726da832239065b7c3b02, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x1d4d8ec291e720db200fe6d686c0d613acaf6af4e95d3bf69f7ed516a597b646, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x041294d2cc484d228f5784fe7919fd2bb925351240a04b711514c9c80b65af1d, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x154ac98e01708c611c4fa715991f004898f57939d126e392042971dd90e81fc6, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x0b339d8acca7d4f83eedd84093aef51050b3684c88f8b0b04524563bc6ea4da4, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x0955e49e6610c94254a4f84cfbab344598f0e71eaff4a7dd81ed95b50839c82e, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x06746a6156eba54426b9e22206f15abca9a6f41e6f535c6f3525401ea0654626, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x0f18f5a0ecd1423c496f3820c549c27838e5790e2bd0a196ac917c7ff32077fb, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x04f6eeca1751f7308ac59eff5beb261e4bb563583ede7bc92a738223d6f76e13, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x2b56973364c4c4f5c1a3ec4da3cdce038811eb116fb3e45bc1768d26fc0b3758, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x123769dd49d5b054dcd76b89804b1bcb8e1392b385716a5d83feb65d437f29ef, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x2147b424fc48c80a88ee52b91169aacea989f6446471150994257b2fb01c63e9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x0fdc1f58548b85701a6c5505ea332a29647e6f34ad4243c2ea54ad897cebe54d, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x12373a8251fea004df68abcf0f7786d4bceff28c5dbbe0c3944f685cc0a0b1f2, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x21e4f4ea5f35f85bad7ea52ff742c9e8a642756b6af44203dd8a1f35c1a90035, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x16243916d69d2ca3dfb4722224d4c462b57366492f45e90d8a81934f1bc3b147, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x1efbe46dd7a578b4f66f9adbc88b4378abc21566e1a0453ca13a4159cac04ac2, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x07ea5e8537cf5dd08886020e23a7f387d468d5525be66f853b672cc96a88969a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x05a8c4f9968b8aa3b7b478a30f9a5b63650f19a75e7ce11ca9fe16c0b76c00bc, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x20f057712cc21654fbfe59bd345e8dac3f7818c701b9c7882d9d57b72a32e83f, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x04a12ededa9dfd689672f8c67fee31636dcd8e88d01d49019bd90b33eb33db69, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x27e88d8c15f37dcee44f1e5425a51decbd136ce5091a6767e49ec9544ccd101a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x2feed17b84285ed9b8a5c8c5e95a41f66e096619a7703223176c41ee433de4d1, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x1ed7cc76edf45c7c404241420f729cf394e5942911312a0d6972b8bd53aff2b8, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x15742e99b9bfa323157ff8c586f5660eac6783476144cdcadf2874be45466b1a, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x1aac285387f65e82c895fc6887ddf40577107454c6ec0317284f033f27d0c785, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x25851c3c845d4790f9ddadbdb6057357832e2e7a49775f71ec75a96554d67c77, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x15a5821565cc2ec2ce78457db197edf353b7ebba2c5523370ddccc3d9f146a67, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x2411d57a4813b9980efa7e31a1db5966dcf64f36044277502f15485f28c71727, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x002e6f8d6520cd4713e335b8c0b6d2e647e9a98e12f4cd2558828b5ef6cb4c9b, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x2ff7bc8f4380cde997da00b616b0fcd1af8f0e91e2fe1ed7398834609e0315d2, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x00b9831b948525595ee02724471bcd182e9521f6b7bb68f1e93be4febb0d3cbe, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x0a2f53768b8ebf6a86913b0e57c04e011ca408648a4743a87d77adbf0c9c3512, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x00248156142fd0373a479f91ff239e960f599ff7e94be69b7f2a290305e1198d, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x171d5620b87bfb1328cf8c02ab3f0c9a397196aa6a542c2350eb512a2b2bcda9, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x170a4f55536f7dc970087c7c10d6fad760c952172dd54dd99d1045e4ec34a808, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x29aba33f799fe66c2ef3134aea04336ecc37e38c1cd211ba482eca17e2dbfae1, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x1e9bc179a4fdd758fdd1bb1945088d47e70d114a03f6a0e8b5ba650369e64973, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x1dd269799b660fad58f7f4892dfb0b5afeaad869a9c4b44f9c9e1c43bdaf8f09, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x22cdbc8b70117ad1401181d02e15459e7ccd426fe869c7c95d1dd2cb0f24af38, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x0ef042e454771c533a9f57a55c503fcefd3150f52ed94a7cd5ba93b9c7dacefd, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x11609e06ad6c8fe2f287f3036037e8851318e8b08a0359a03b304ffca62e8284, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x1166d9e554616dba9e753eea427c17b7fecd58c076dfe42708b08f5b783aa9af, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x2de52989431a859593413026354413db177fbf4cd2ac0b56f855a888357ee466, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x3006eb4ffc7a85819a6da492f3a8ac1df51aee5b17b8e89d74bf01cf5f71e9ad, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x2af41fbb61ba8a80fdcf6fff9e3f6f422993fe8f0a4639f962344c8225145086, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x119e684de476155fe5a6b41a8ebc85db8718ab27889e85e781b214bace4827c3, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x1835b786e2e8925e188bea59ae363537b51248c23828f047cff784b97b3fd800, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x28201a34c594dfa34d794996c6433a20d152bac2a7905c926c40e285ab32eeb6, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x083efd7a27d1751094e80fefaf78b000864c82eb571187724a761f88c22cc4e7, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x0b6f88a3577199526158e61ceea27be811c16df7774dd8519e079564f61fd13b, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x0ec868e6d15e51d9644f66e1d6471a94589511ca00d29e1014390e6ee4254f5b, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x2af33e3f866771271ac0c9b3ed2e1142ecd3e74b939cd40d00d937ab84c98591, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x0b520211f904b5e7d09b5d961c6ace7734568c547dd6858b364ce5e47951f178, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x0b2d722d0919a1aad8db58f10062a92ea0c56ac4270e822cca228620188a1d40, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x1f790d4d7f8cf094d980ceb37c2453e957b54a9991ca38bbe0061d1ed6e562d4, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x0171eb95dfbf7d1eaea97cd385f780150885c16235a2a6a8da92ceb01e504233, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x0c2d0e3b5fd57549329bf6885da66b9b790b40defd2c8650762305381b168873, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x1162fb28689c27154e5a8228b4e72b377cbcafa589e283c35d3803054407a18d, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x2f1459b65dee441b64ad386a91e8310f282c5a92a89e19921623ef8249711bc0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x1e6ff3216b688c3d996d74367d5cd4c1bc489d46754eb712c243f70d1b53cfbb, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x01ca8be73832b8d0681487d27d157802d741a6f36cdc2a0576881f9326478875, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x1f7735706ffe9fc586f976d5bdf223dc680286080b10cea00b9b5de315f9650e, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x2522b60f4ea3307640a0c2dce041fba921ac10a3d5f096ef4745ca838285f019, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x23f0bee001b1029d5255075ddc957f833418cad4f52b6c3f8ce16c235572575b, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x2bc1ae8b8ddbb81fcaac2d44555ed5685d142633e9df905f66d9401093082d59, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x0f9406b8296564a37304507b8dba3ed162371273a07b1fc98011fcd6ad72205f, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x2360a8eb0cc7defa67b72998de90714e17e75b174a52ee4acb126c8cd995f0a8, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x15871a5cddead976804c803cbaef255eb4815a5e96df8b006dcbbc2767f88948, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x193a56766998ee9e0a8652dd2f3b1da0362f4f54f72379544f957ccdeefb420f, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x2a394a43934f86982f9be56ff4fab1703b2e63c8ad334834e4309805e777ae0f, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x1859954cfeb8695f3e8b635dcb345192892cd11223443ba7b4166e8876c0d142, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x04e1181763050e58013444dbcb99f1902b11bc25d90bbdca408d3819f4fed32b, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x0fdb253dee83869d40c335ea64de8c5bb10eb82db08b5e8b1f5e5552bfd05f23, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x058cbe8a9a5027bdaa4efb623adead6275f08686f1c08984a9d7c5bae9b4f1c0, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x1382edce9971e186497eadb1aeb1f52b23b4b83bef023ab0d15228b4cceca59a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x03464990f045c6ee0819ca51fd11b0be7f61b8eb99f14b77e1e6634601d9e8b5, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x23f7bfc8720dc296fff33b41f98ff83c6fcab4605db2eb5aaa5bc137aeb70a58, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x0a59a158e3eec2117e6e94e7f0e9decf18c3ffd5e1531a9219636158bbaf62f2, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x06ec54c80381c052b58bf23b312ffd3ce2c4eba065420af8f4c23ed0075fd07b, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x118872dc832e0eb5476b56648e867ec8b09340f7a7bcb1b4962f0ff9ed1f9d01, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x13d69fa127d834165ad5c7cba7ad59ed52e0b0f0e42d7fea95e1906b520921b1, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x169a177f63ea681270b1c6877a73d21bde143942fb71dc55fd8a49f19f10c77b, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x04ef51591c6ead97ef42f287adce40d93abeb032b922f66ffb7e9a5a7450544d, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x256e175a1dc079390ecd7ca703fb2e3b19ec61805d4f03ced5f45ee6dd0f69ec, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x30102d28636abd5fe5f2af412ff6004f75cc360d3205dd2da002813d3e2ceeb2, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x10998e42dfcd3bbf1c0714bc73eb1bf40443a3fa99bef4a31fd31be182fcc792, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x193edd8e9fcf3d7625fa7d24b598a1d89f3362eaf4d582efecad76f879e36860, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x18168afd34f2d915d0368ce80b7b3347d1c7a561ce611425f2664d7aa51f0b5d, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x29383c01ebd3b6ab0c017656ebe658b6a328ec77bc33626e29e2e95b33ea6111, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x10646d2f2603de39a1f4ae5e7771a64a702db6e86fb76ab600bf573f9010c711, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x0beb5e07d1b27145f575f1395a55bf132f90c25b40da7b3864d0242dcb1117fb, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x16d685252078c133dc0d3ecad62b5c8830f95bb2e54b59abdffbf018d96fa336, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x0a6abd1d833938f33c74154e0404b4b40a555bbbec21ddfafd672dd62047f01a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x1a679f5d36eb7b5c8ea12a4c2dedc8feb12dffeec450317270a6f19b34cf1860, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x0980fb233bd456c23974d50e0ebfde4726a423eada4e8f6ffbc7592e3f1b93d6, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x161b42232e61b84cbf1810af93a38fc0cece3d5628c9282003ebacb5c312c72b, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x0ada10a90c7f0520950f7d47a60d5e6a493f09787f1564e5d09203db47de1a0b, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x1a730d372310ba82320345a29ac4238ed3f07a8a2b4e121bb50ddb9af407f451, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x2c8120f268ef054f817064c369dda7ea908377feaba5c4dffbda10ef58e8c556, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x1c7c8824f758753fa57c00789c684217b930e95313bcb73e6e7b8649a4968f70, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x2cd9ed31f5f8691c8e39e4077a74faa0f400ad8b491eb3f7b47b27fa3fd1cf77, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x23ff4f9d46813457cf60d92f57618399a5e022ac321ca550854ae23918a22eea, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x09945a5d147a4f66ceece6405dddd9d0af5a2c5103529407dff1ea58f180426d, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x188d9c528025d4c2b67660c6b771b90f7c7da6eaa29d3f268a6dd223ec6fc630, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x3050e37996596b7f81f68311431d8734dba7d926d3633595e0c0d8ddf4f0f47f, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x15af1169396830a91600ca8102c35c426ceae5461e3f95d89d829518d30afd78, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x1da6d09885432ea9a06d9f37f873d985dae933e351466b2904284da3320d8acc, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := add(0x2796ea90d269af29f5f8acf33921124e4e4fad3dbe658945e546ee411ddaa9cb, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x202d7dd1da0f6b4b0325c8b3307742f01e15612ec8e9304a7cb0319e01d32d60, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x096d6790d05bb759156a952ba263d672a2d7f9c788f4c831a29dace4c0f8be5f, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := add(0x054efa1f65b0fce283808965275d877b438da23ce5b13e1963798cb1447d25a4, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x1b162f83d917e93edb3308c29802deb9d8aa690113b2e14864ccf6e18e4165f1, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x21e5241e12564dd6fd9f1cdd2a0de39eedfefc1466cc568ec5ceb745a0506edc, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := mulmod(scratch1, scratch1, F)\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\n state0 := mulmod(scratch2, scratch2, F)\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\n state0 := add(0x1cfb5662e8cf5ac9226a80ee17b36abecb73ab5f87e161927b4349e10e4bdf08, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x0f21177e302a771bbae6d8d1ecb373b62c99af346220ac0129c53f666eb24100, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x1671522374606992affb0dd7f71b12bec4236aede6290546bcef7e1f515c2320, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := mulmod(state1, state1, F)\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\n scratch0 := mulmod(state2, state2, F)\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\n scratch0 := add(0x0fa3ec5b9488259c2eb4cf24501bfad9be2ec9e42c5cc8ccd419d2a692cad870, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\n scratch1 := add(0x193c0e04e0bd298357cb266c1506080ed36edce85c648cc085e8c57b1ab54bba, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\n scratch2 := add(0x102adf8ef74735a27e9128306dcbc3c99f6f7291cd406578ce14ea2adaba68f8, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\n state0 := mulmod(scratch0, scratch0, F)\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\n state0 := mulmod(scratch1, scratch1, F)\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\n state0 := mulmod(scratch2, scratch2, F)\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\n state0 := add(0x0fe0af7858e49859e2a54d6f1ad945b1316aa24bfbdd23ae40a6d0cb70c3eab1, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\n state1 := add(0x216f6717bbc7dedb08536a2220843f4e2da5f1daa9ebdefde8a5ea7344798d22, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\n state2 := add(0x1da55cc900f0d21f4a3e694391918a1b3c23b2ac773c6b3ef88e2e4228325161, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\n scratch0 := mulmod(state0, state0, F)\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\n scratch0 := mulmod(state1, state1, F)\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\n scratch0 := mulmod(state2, state2, F)\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\n\n mstore(0x0, mod(add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)), F))\n\n return(0, 0x20)\n }\n }\n}\n" + } + }, + "settings": { + "optimizer": { + "enabled": true, + "runs": 200 + }, + "evmVersion": "paris", + "outputSelection": { + "*": { + "*": [ + "abi", + "evm.bytecode", + "evm.deployedBytecode", + "evm.methodIdentifiers", + "metadata", + "devdoc", + "userdoc", + "storageLayout", + "evm.gasEstimates" + ], + "": [ + "ast" + ] + } + }, + "metadata": { + "useLiteralContent": true + } + } +} \ No newline at end of file diff --git a/packages/hardhat/package.json b/packages/hardhat/package.json index 31f554d..b107aee 100644 --- a/packages/hardhat/package.json +++ b/packages/hardhat/package.json @@ -24,6 +24,7 @@ "dependencies": { "@inquirer/password": "^4.0.2", "@openzeppelin/contracts": "~5.0.2", + "@polypay/shared": "1.0.0", "@typechain/ethers-v6": "~0.5.1", "dotenv": "~16.4.5", "envfile": "~7.1.0", diff --git a/packages/nextjs/public/mixer-circuit/Nargo.toml b/packages/nextjs/public/mixer-circuit/Nargo.toml new file mode 100644 index 0000000..742adbf --- /dev/null +++ b/packages/nextjs/public/mixer-circuit/Nargo.toml @@ -0,0 +1,7 @@ +[package] +name = "mixer_circuit" +type = "bin" +authors = [""] + +[dependencies] +poseidon = { tag = "v0.1.1", git = "https://github.com/noir-lang/poseidon" } diff --git a/packages/nextjs/public/mixer-circuit/src/main.nr b/packages/nextjs/public/mixer-circuit/src/main.nr new file mode 100644 index 0000000..0759333 --- /dev/null +++ b/packages/nextjs/public/mixer-circuit/src/main.nr @@ -0,0 +1,55 @@ +// ZK Mixer circuit: proves knowledge of (secret, nullifier) such that +// commitment = poseidon(secret, nullifier) is in the Merkle tree, +// and nullifier_hash = poseidon(nullifier, nullifier). +// Public inputs (recipient, token, denomination) are bound to the proof to prevent front-running. + +use poseidon::poseidon::bn254::hash_2; + +global TREE_DEPTH: u32 = 20; + +fn main( + // Private inputs + secret: Field, + nullifier: Field, + merkle_path: [Field; 20], + path_indices: [Field; 20], + + // Public inputs (ORDER IS CANONICAL - MUST MATCH CONTRACT) + merkle_root: pub Field, + nullifier_hash: pub Field, + recipient: pub Field, + token_address: pub Field, + denomination: pub Field, +) { + // 1. Verify commitment = poseidon(secret, nullifier) + // PolyPay convention: poseidon(x, y) for commitment. + let commitment = poseidon_hash2(secret, nullifier); + + // 2. Verify nullifier_hash = poseidon(nullifier, nullifier) + // We use poseidon_hash2(x, x) (squared-style) to stay consistent with + // existing app conventions; do not use poseidon(x, 1) as in some mixers. + assert(poseidon_hash2(nullifier, nullifier) == nullifier_hash); + + // 3. Verify commitment exists in Merkle tree + let computed_root = compute_merkle_root(commitment, merkle_path, path_indices); + assert(computed_root == merkle_root); + + // 4. Public inputs (recipient, token, denomination) are bound to the proof +} + +fn poseidon_hash2(a: Field, b: Field) -> Field { + hash_2([a, b]) +} + +/// Compute Merkle root from leaf, path siblings, and path indices. +/// path_indices[i] == 0 => current is left child => parent = H(current, sibling) +/// path_indices[i] == 1 => current is right child => parent = H(sibling, current) +fn compute_merkle_root(leaf: Field, merkle_path: [Field; 20], path_indices: [Field; 20]) -> Field { + let mut current = leaf; + for i in 0..TREE_DEPTH { + let sibling = merkle_path[i]; + let is_right = path_indices[i]; + current = (1 - is_right) * poseidon_hash2(current, sibling) + is_right * poseidon_hash2(sibling, current); + } + current +} diff --git a/packages/nextjs/public/mixer-circuit/target/mixer_circuit.json b/packages/nextjs/public/mixer-circuit/target/mixer_circuit.json new file mode 100644 index 0000000..69e0469 --- /dev/null +++ b/packages/nextjs/public/mixer-circuit/target/mixer_circuit.json @@ -0,0 +1,53 @@ +{ + "noir_version": "1.0.0-beta.12+9a5b3695b42e391fa27c48e87b9bbb07523d664d", + "hash": "8349044325836741088", + "abi": { + "parameters": [ + { "name": "secret", "type": { "kind": "field" }, "visibility": "private" }, + { "name": "nullifier", "type": { "kind": "field" }, "visibility": "private" }, + { + "name": "merkle_path", + "type": { "kind": "array", "length": 20, "type": { "kind": "field" } }, + "visibility": "private" + }, + { + "name": "path_indices", + "type": { "kind": "array", "length": 20, "type": { "kind": "field" } }, + "visibility": "private" + }, + { "name": "merkle_root", "type": { "kind": "field" }, "visibility": "public" }, + { "name": "nullifier_hash", "type": { "kind": "field" }, "visibility": "public" }, + { "name": "recipient", "type": { "kind": "field" }, "visibility": "public" }, + { "name": "token_address", "type": { "kind": "field" }, "visibility": "public" }, + { "name": "denomination", "type": { "kind": "field" }, "visibility": "public" } + ], + "return_type": null, + "error_types": {} + }, + "bytecode": "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", + "debug_symbols": "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", + "file_map": { + "18": { + "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n __assert_max_bit_size(self, BIT_SIZE);\n }\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = __to_le_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = __to_be_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_le_radix(self, radix)\n }\n\n fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_be_radix(self, radix)\n }\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n/// This slice will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits(value: Field) -> [u1; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits(value: Field) -> [u1; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n unconstrained fn not_enough_limbs_brillig() {\n let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n }\n\n #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n fn not_enough_limbs() {\n let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", + "path": "std/field/mod.nr" + }, + "50": { + "source": "// ZK Mixer circuit: proves knowledge of (secret, nullifier) such that\n// commitment = poseidon(secret, nullifier) is in the Merkle tree,\n// and nullifier_hash = poseidon(nullifier, nullifier).\n// Public inputs (recipient, token, denomination) are bound to the proof to prevent front-running.\n\nuse poseidon::poseidon::bn254::hash_2;\n\nglobal TREE_DEPTH: u32 = 20;\n\nfn main(\n // Private inputs\n secret: Field,\n nullifier: Field,\n merkle_path: [Field; 20],\n path_indices: [Field; 20],\n\n // Public inputs (ORDER IS CANONICAL - MUST MATCH CONTRACT)\n merkle_root: pub Field,\n nullifier_hash: pub Field,\n recipient: pub Field,\n token_address: pub Field,\n denomination: pub Field,\n) {\n // 1. Verify commitment = poseidon(secret, nullifier)\n // PolyPay convention: poseidon(x, y) for commitment.\n let commitment = poseidon_hash2(secret, nullifier);\n\n // 2. Verify nullifier_hash = poseidon(nullifier, nullifier)\n // We use poseidon_hash2(x, x) (squared-style) to stay consistent with\n // existing app conventions; do not use poseidon(x, 1) as in some mixers.\n assert(poseidon_hash2(nullifier, nullifier) == nullifier_hash);\n\n // 3. Verify commitment exists in Merkle tree\n let computed_root = compute_merkle_root(commitment, merkle_path, path_indices);\n assert(computed_root == merkle_root);\n\n // 4. Public inputs (recipient, token, denomination) are bound to the proof\n}\n\nfn poseidon_hash2(a: Field, b: Field) -> Field {\n hash_2([a, b])\n}\n\n/// Compute Merkle root from leaf, path siblings, and path indices.\n/// path_indices[i] == 0 => current is left child => parent = H(current, sibling)\n/// path_indices[i] == 1 => current is right child => parent = H(sibling, current)\nfn compute_merkle_root(leaf: Field, merkle_path: [Field; 20], path_indices: [Field; 20]) -> Field {\n let mut current = leaf;\n for i in 0..TREE_DEPTH {\n let sibling = merkle_path[i];\n let is_right = path_indices[i];\n current = (1 - is_right) * poseidon_hash2(current, sibling) + is_right * poseidon_hash2(sibling, current);\n }\n current\n}\n", + "path": "/Users/boron/works/polypay_app/packages/nextjs/public/mixer-circuit/src/main.nr" + }, + "54": { + "source": "// Instantiations of Poseidon permutation for the prime field of the same order as BN254\nuse crate::poseidon::bn254::consts;\nuse crate::poseidon::permute;\n\n#[field(bn254)]\npub fn x5_2(mut state: [Field; 2]) -> [Field; 2] {\n state = permute(consts::x5_2_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_3(mut state: [Field; 3]) -> [Field; 3] {\n state = permute(consts::x5_3_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_4(mut state: [Field; 4]) -> [Field; 4] {\n state = permute(consts::x5_4_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_5(mut state: [Field; 5]) -> [Field; 5] {\n state = permute(consts::x5_5_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_6(mut state: [Field; 6]) -> [Field; 6] {\n state = permute(consts::x5_6_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_7(mut state: [Field; 7]) -> [Field; 7] {\n state = permute(consts::x5_7_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_8(mut state: [Field; 8]) -> [Field; 8] {\n state = permute(consts::x5_8_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_9(mut state: [Field; 9]) -> [Field; 9] {\n state = permute(consts::x5_9_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_10(mut state: [Field; 10]) -> [Field; 10] {\n state = permute(consts::x5_10_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_11(mut state: [Field; 11]) -> [Field; 11] {\n state = permute(consts::x5_11_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_12(mut state: [Field; 12]) -> [Field; 12] {\n state = permute(consts::x5_12_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_13(mut state: [Field; 13]) -> [Field; 13] {\n state = permute(consts::x5_13_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_14(mut state: [Field; 14]) -> [Field; 14] {\n state = permute(consts::x5_14_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_15(mut state: [Field; 15]) -> [Field; 15] {\n state = permute(consts::x5_15_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_16(mut state: [Field; 16]) -> [Field; 16] {\n state = permute(consts::x5_16_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_17(mut state: [Field; 17]) -> [Field; 17] {\n state = permute(consts::x5_17_config(), state);\n\n state\n}\n", + "path": "/Users/boron/nargo/github.com/noir-lang/poseidon/v0.1.1/src/poseidon/bn254/perm.nr" + }, + "55": { + "source": "// Instantiations of Poseidon constants, permutations and sponge for prime field of the same order as BN254\npub mod perm;\npub mod consts;\n\nuse crate::poseidon::absorb;\n\n// Variable-length Poseidon-128 sponge as suggested in second bullet point of section 3 of https://eprint.iacr.org/2019/458.pdf\n#[field(bn254)]\npub fn sponge(msg: [Field; N]) -> Field {\n absorb(consts::x5_5_config(), [0; 5], 4, 1, msg)[1]\n}\n\n// Various instances of the Poseidon hash function\n// Consistent with Circom's implementation\n#[no_predicates]\npub fn hash_1(input: [Field; 1]) -> Field {\n let mut state = [0; 2];\n for i in 0..input.len() {\n state[i + 1] = input[i];\n }\n\n perm::x5_2(state)[0]\n}\n\n#[no_predicates]\npub fn hash_2(input: [Field; 2]) -> Field {\n let mut state = [0; 3];\n for i in 0..input.len() {\n state[i + 1] = input[i];\n }\n\n perm::x5_3(state)[0]\n}\n\n#[no_predicates]\npub fn hash_3(input: [Field; 3]) -> Field {\n let mut state = [0; 4];\n for i in 0..input.len() {\n state[i + 1] = input[i];\n }\n\n perm::x5_4(state)[0]\n}\n\n#[no_predicates]\npub fn hash_4(input: [Field; 4]) -> Field {\n let mut state = [0; 5];\n for i in 0..input.len() {\n state[i + 1] = input[i];\n }\n\n perm::x5_5(state)[0]\n}\n\n#[no_predicates]\npub fn hash_5(input: [Field; 5]) -> Field {\n let mut state = [0; 6];\n for i in 0..input.len() {\n state[i + 1] = input[i];\n }\n\n perm::x5_6(state)[0]\n}\n\n#[no_predicates]\npub fn hash_6(input: [Field; 6]) -> Field {\n let mut state = [0; 7];\n for i in 0..input.len() {\n state[i + 1] = input[i];\n }\n\n perm::x5_7(state)[0]\n}\n\n#[no_predicates]\npub fn hash_7(input: [Field; 7]) -> Field {\n let mut state = [0; 8];\n for i in 0..input.len() {\n state[i + 1] = input[i];\n }\n\n perm::x5_8(state)[0]\n}\n\n#[no_predicates]\npub fn hash_8(input: [Field; 8]) -> Field {\n let mut state = [0; 9];\n for i in 0..input.len() {\n state[i + 1] = input[i];\n }\n\n perm::x5_9(state)[0]\n}\n\n#[no_predicates]\npub fn hash_9(input: [Field; 9]) -> Field {\n let mut state = [0; 10];\n for i in 0..input.len() {\n state[i + 1] = input[i];\n }\n\n perm::x5_10(state)[0]\n}\n\n#[no_predicates]\npub fn hash_10(input: [Field; 10]) -> Field {\n let mut state = [0; 11];\n for i in 0..input.len() {\n state[i + 1] = input[i];\n }\n\n perm::x5_11(state)[0]\n}\n\n#[no_predicates]\npub fn hash_11(input: [Field; 11]) -> Field {\n let mut state = [0; 12];\n for i in 0..input.len() {\n state[i + 1] = input[i];\n }\n\n perm::x5_12(state)[0]\n}\n\n#[no_predicates]\npub fn hash_12(input: [Field; 12]) -> Field {\n let mut state = [0; 13];\n for i in 0..input.len() {\n state[i + 1] = input[i];\n }\n\n perm::x5_13(state)[0]\n}\n\n#[no_predicates]\npub fn hash_13(input: [Field; 13]) -> Field {\n let mut state = [0; 14];\n for i in 0..input.len() {\n state[i + 1] = input[i];\n }\n\n perm::x5_14(state)[0]\n}\n\n#[no_predicates]\npub fn hash_14(input: [Field; 14]) -> Field {\n let mut state = [0; 15];\n for i in 0..input.len() {\n state[i + 1] = input[i];\n }\n\n perm::x5_15(state)[0]\n}\n\n#[no_predicates]\npub fn hash_15(input: [Field; 15]) -> Field {\n let mut state = [0; 16];\n for i in 0..input.len() {\n state[i + 1] = input[i];\n }\n\n perm::x5_16(state)[0]\n}\n\n#[no_predicates]\npub fn hash_16(input: [Field; 16]) -> Field {\n let mut state = [0; 17];\n for i in 0..input.len() {\n state[i + 1] = input[i];\n }\n\n perm::x5_17(state)[0]\n}\n", + "path": "/Users/boron/nargo/github.com/noir-lang/poseidon/v0.1.1/src/poseidon/bn254.nr" + }, + "56": { + "source": "pub mod bn254; // Instantiations of Poseidon for prime field of the same order as BN254\nuse std::default::Default;\nuse std::hash::Hasher;\n\n// A config struct defining the parameters of the Poseidon instance to use.\n//\n// A thorough writeup of this method (along with an unoptimized method) can be found at: https://spec.filecoin.io/algorithms/crypto/poseidon/\npub struct PoseidonConfig {\n // State width, should be equal to `T`\n t: Field,\n // Number of full rounds. should be even\n rf: u8,\n // Number of partial rounds\n rp: u8,\n // S-box power; depends on the underlying field\n alpha: Field,\n // The round constants for the\n round_constants: [Field; N],\n // The MDS matrix for the Poseidon instance\n mds: [[Field; T]; T],\n // An MDS matrix which also applies a basis transformation which allows\n // sparse matrices to be used for the partial rounds.\n //\n // This should be applied instead of `mds` in the final full round.\n presparse_mds: [[Field; T]; T],\n // A set of sparse matrices used for MDS mixing for the partial rounds.\n sparse_mds: [Field; X],\n}\n\npub fn config(\n t: Field,\n rf: u8,\n rp: u8,\n alpha: Field,\n round_constants: [Field; N],\n mds: [[Field; T]; T],\n presparse_mds: [[Field; T]; T],\n sparse_mds: [Field; X],\n) -> PoseidonConfig {\n // Input checks\n assert_eq(rf & 1, 0);\n assert_eq((t as u8) * rf + rp, N as u8);\n assert_eq(t, T as Field);\n assert(alpha != 0);\n\n PoseidonConfig { t, rf, rp, alpha, round_constants, mds, presparse_mds, sparse_mds }\n}\n\npub fn permute(\n pos_conf: PoseidonConfig,\n mut state: [Field; T],\n) -> [Field; T] {\n let PoseidonConfig { t, rf, rp, alpha, round_constants, mds, presparse_mds, sparse_mds } =\n pos_conf;\n\n for i in 0..state.len() {\n state[i] += round_constants[i];\n }\n\n for _r in 0..rf / 2 - 1 {\n state = sigma(state);\n for i in 0..T {\n state[i] += round_constants[T * (_r + 1) as u32 + i];\n }\n state = apply_matrix(mds, state);\n }\n\n state = sigma(state);\n for i in 0..T {\n state[i] += round_constants[T * (rf / 2) as u32 + i];\n }\n state = apply_matrix(presparse_mds, state);\n\n for i in 0..T {\n std::as_witness(state[i]);\n }\n\n for _r in 0..rp {\n state[0] = state[0].pow_32(alpha);\n state[0] += round_constants[(rf / 2 + 1) as u32 * T + _r as u32];\n std::as_witness(state[0]);\n {\n let mut newState0 = 0;\n for j in 0..T {\n newState0 += sparse_mds[(T * 2 - 1) * _r as u32 + j as u32] * state[j];\n }\n for k in 1..T {\n state[k] += state[0] * sparse_mds[(t * 2 - 1) as u32 * _r as u32 + T + k - 1];\n }\n state[0] = newState0;\n\n if (_r & 1 == 0) {\n for k in 1..T {\n std::as_witness(state[k]);\n }\n }\n }\n }\n\n for _r in 0..rf / 2 - 1 {\n state = sigma(state);\n for i in 0..state.len() {\n state[i] += round_constants[(rf / 2 + 1) as u32 * T + rp as u32 + (_r as u32) * T + i];\n }\n state = apply_matrix(mds, state);\n }\n\n state = sigma(state);\n state = apply_matrix(mds, state);\n\n state\n}\n\n// Performs matrix multiplication on a vector\nfn apply_matrix(matrix: [[Field; N]; N], vec: [Field; N]) -> [Field; N] {\n let mut out = [0; N];\n\n for i in 0..N {\n for j in 0..N {\n out[i] += vec[j] * matrix[j][i];\n }\n }\n\n out\n}\n\n// Corresponding absorption.\nfn absorb(\n pos_conf: PoseidonConfig,\n // Initial state; usually [0; O]\n mut state: [Field; T],\n rate: u32,\n capacity: u32,\n msg: [Field; O], // Arbitrary length message\n) -> [Field; T] {\n assert_eq(pos_conf.t, (rate + capacity) as Field);\n\n let mut i = 0;\n\n for k in 0..msg.len() {\n // Add current block to state\n state[capacity + i] += msg[k];\n i = i + 1;\n // Enough to absorb\n if i == rate {\n state = permute(pos_conf, state);\n i = 0;\n }\n }\n // If we have one more block to permute\n if i != 0 {\n state = permute(pos_conf, state);\n }\n\n state\n}\n\nfn sigma(x: [Field; O]) -> [Field; O] {\n let mut y = x;\n for i in 0..O {\n let t = y[i];\n let tt = t * t;\n let tttt = tt * tt;\n y[i] *= tttt;\n }\n y\n}\n\npub struct PoseidonHasher {\n _state: [Field],\n}\n\nimpl Hasher for PoseidonHasher {\n #[field(bn254)]\n fn finish(self) -> Field {\n let mut result = 0;\n let len = self._state.len();\n assert(len < 16);\n if len == 1 {\n result = bn254::hash_1([self._state[0]]);\n }\n if len == 2 {\n result = bn254::hash_2([self._state[0], self._state[1]]);\n }\n if len == 3 {\n result = bn254::hash_3([self._state[0], self._state[1], self._state[2]]);\n }\n if len == 4 {\n result = bn254::hash_4([self._state[0], self._state[1], self._state[2], self._state[3]]);\n }\n if len == 5 {\n result = bn254::hash_5([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n ]);\n }\n if len == 6 {\n result = bn254::hash_6([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n ]);\n }\n if len == 7 {\n result = bn254::hash_7([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n ]);\n }\n if len == 8 {\n result = bn254::hash_8([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n self._state[7],\n ]);\n }\n if len == 9 {\n result = bn254::hash_9([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n self._state[7],\n self._state[8],\n ]);\n }\n if len == 10 {\n result = bn254::hash_10([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n self._state[7],\n self._state[8],\n self._state[9],\n ]);\n }\n if len == 11 {\n result = bn254::hash_11([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n self._state[7],\n self._state[8],\n self._state[9],\n self._state[10],\n ]);\n }\n if len == 12 {\n result = bn254::hash_12([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n self._state[7],\n self._state[8],\n self._state[9],\n self._state[10],\n self._state[11],\n ]);\n }\n if len == 13 {\n result = bn254::hash_13([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n self._state[7],\n self._state[8],\n self._state[9],\n self._state[10],\n self._state[11],\n self._state[12],\n ]);\n }\n if len == 14 {\n result = bn254::hash_14([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n self._state[7],\n self._state[8],\n self._state[9],\n self._state[10],\n self._state[11],\n self._state[12],\n self._state[13],\n ]);\n }\n if len == 15 {\n result = bn254::hash_15([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n self._state[7],\n self._state[8],\n self._state[9],\n self._state[10],\n self._state[11],\n self._state[12],\n self._state[13],\n self._state[14],\n ]);\n }\n\n result\n }\n\n #[inline_always]\n fn write(&mut self, input: Field) {\n self._state = self._state.push_back(input);\n }\n}\n\nimpl Default for PoseidonHasher {\n fn default() -> Self {\n PoseidonHasher { _state: &[] }\n }\n}\n", + "path": "/Users/boron/nargo/github.com/noir-lang/poseidon/v0.1.1/src/poseidon/mod.nr" + } + }, + "names": ["main"], + "brillig_names": [] +} diff --git a/packages/shared/src/contracts/Mixer.ts b/packages/shared/src/contracts/Mixer.ts new file mode 100644 index 0000000..5244c76 --- /dev/null +++ b/packages/shared/src/contracts/Mixer.ts @@ -0,0 +1,493 @@ +// Generated from packages/hardhat/artifacts/contracts/Mixer.sol/Mixer.json +export const MIXER_ABI = [ + { + inputs: [ + { + internalType: "address", + name: "_zkvContract", + type: "address", + }, + { + internalType: "bytes32", + name: "_vkHash", + type: "bytes32", + }, + { + internalType: "bytes32[]", + name: "_allowedPoolIds", + type: "bytes32[]", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [ + { + internalType: "address", + name: "target", + type: "address", + }, + ], + name: "AddressEmptyCode", + type: "error", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "AddressInsufficientBalance", + type: "error", + }, + { + inputs: [], + name: "FailedInnerCall", + type: "error", + }, + { + inputs: [], + name: "ReentrancyGuardReentrantCall", + type: "error", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + ], + name: "SafeERC20FailedOperation", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "bytes32", + name: "commitment", + type: "bytes32", + }, + { + indexed: false, + internalType: "uint256", + name: "leafIndex", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "timestamp", + type: "uint256", + }, + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "denomination", + type: "uint256", + }, + ], + name: "Deposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "recipient", + type: "address", + }, + { + indexed: false, + internalType: "bytes32", + name: "nullifierHash", + type: "bytes32", + }, + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "denomination", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "timestamp", + type: "uint256", + }, + ], + name: "Withdrawal", + type: "event", + }, + { + inputs: [], + name: "BN254_PRIME", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "PROVING_SYSTEM_ID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "ROOT_HISTORY_SIZE", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "TREE_DEPTH", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "VERSION_HASH", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + name: "allowedDenominations", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + name: "commitmentUsed", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "uint256", + name: "denomination", + type: "uint256", + }, + { + internalType: "bytes32", + name: "commitment", + type: "bytes32", + }, + ], + name: "deposit", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "level", + type: "uint256", + }, + ], + name: "getZeroHash", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "poolId", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "root", + type: "bytes32", + }, + ], + name: "isKnownRoot", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + name: "nullifierUsed", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + name: "rootHistory", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + name: "rootHistoryIndex", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + name: "trees", + outputs: [ + { + internalType: "uint256", + name: "nextIndex", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "vkHash", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "uint256", + name: "denomination", + type: "uint256", + }, + { + internalType: "address", + name: "recipient", + type: "address", + }, + { + internalType: "bytes32", + name: "nullifierHash", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "root", + type: "bytes32", + }, + { + components: [ + { + internalType: "uint256", + name: "aggregationId", + type: "uint256", + }, + { + internalType: "uint256", + name: "domainId", + type: "uint256", + }, + { + internalType: "bytes32[]", + name: "zkMerklePath", + type: "bytes32[]", + }, + { + internalType: "uint256", + name: "leafCount", + type: "uint256", + }, + { + internalType: "uint256", + name: "index", + type: "uint256", + }, + ], + internalType: "struct Mixer.MixerProof", + name: "proof", + type: "tuple", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "zkvContract", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + stateMutability: "payable", + type: "receive", + }, +] as const; +export const MIXER_BYTECODE = + "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"; diff --git a/packages/shared/src/contracts/contracts-config.ts b/packages/shared/src/contracts/contracts-config.ts index 0b8f640..1a8cfa8 100644 --- a/packages/shared/src/contracts/contracts-config.ts +++ b/packages/shared/src/contracts/contracts-config.ts @@ -5,6 +5,9 @@ export const CONTRACT_CONFIG_BY_CHAIN_ID = { vkHash: "0x80aca2e84f244400a76040aa5c77f9d83ff8409a2bf0d0cde96daffcf0a50e1b", poseidonT3Address: "0x3333333C0A88F9BE4fd23ed0536F9B6c427e3B93", + mixerAddress: "0x8F5f249210fFc91a2b1D86828764562f97C9eEdd" as `0x${string}`, + mixerVkHash: + "0x29236cc027580a6be3e581d9625a48710d39eb92e2c68e7b5e42841d11affe00" as `0x${string}`, }, 84532: { // Base Sepolia @@ -12,20 +15,31 @@ export const CONTRACT_CONFIG_BY_CHAIN_ID = { vkHash: "0x80aca2e84f244400a76040aa5c77f9d83ff8409a2bf0d0cde96daffcf0a50e1b", poseidonT3Address: "0x3333333C0A88F9BE4fd23ed0536F9B6c427e3B93", + mixerAddress: "0xd9E9103693014b00db0Bf262b65CB2226062e732" as `0x${string}`, + mixerVkHash: + "0x29236cc027580a6be3e581d9625a48710d39eb92e2c68e7b5e42841d11affe00" as `0x${string}`, }, 26514: { + // TODO: change address to actual address // Horizen mainnet zkVerifyAddress: "0xCb47A3C3B9Eb2E549a3F2EA4729De28CafbB2b69", vkHash: "0x80aca2e84f244400a76040aa5c77f9d83ff8409a2bf0d0cde96daffcf0a50e1b", poseidonT3Address: "0x3333333C0A88F9BE4fd23ed0536F9B6c427e3B93", + mixerAddress: "0x0000000000000000000000000000000000000000" as `0x${string}`, + mixerVkHash: + "0x29236cc027580a6be3e581d9625a48710d39eb92e2c68e7b5e42841d11affe00" as `0x${string}`, }, 8453: { + // TODO: change address to actual address // Base mainnet zkVerifyAddress: "0xCb47A3C3B9Eb2E549a3F2EA4729De28CafbB2b69", vkHash: "0x80aca2e84f244400a76040aa5c77f9d83ff8409a2bf0d0cde96daffcf0a50e1b", poseidonT3Address: "0x3333333C0A88F9BE4fd23ed0536F9B6c427e3B93", + mixerAddress: "0x0000000000000000000000000000000000000000" as `0x${string}`, + mixerVkHash: + "0x29236cc027580a6be3e581d9625a48710d39eb92e2c68e7b5e42841d11affe00" as `0x${string}`, }, } as const; diff --git a/packages/shared/src/contracts/index.ts b/packages/shared/src/contracts/index.ts index 1d4aceb..38ee7e2 100644 --- a/packages/shared/src/contracts/index.ts +++ b/packages/shared/src/contracts/index.ts @@ -1,2 +1,3 @@ export * from "./MetaMultiSigWallet"; +export * from "./Mixer"; export * from "./contracts-config"; diff --git a/yarn.lock b/yarn.lock index 3cfdd74..01c073f 100644 --- a/yarn.lock +++ b/yarn.lock @@ -6100,6 +6100,7 @@ __metadata: "@nomicfoundation/hardhat-network-helpers": ~1.0.11 "@nomicfoundation/hardhat-verify": ~2.0.10 "@openzeppelin/contracts": ~5.0.2 + "@polypay/shared": 1.0.0 "@typechain/ethers-v5": ~11.1.2 "@typechain/ethers-v6": ~0.5.1 "@typechain/hardhat": ~9.1.0 From 6a69da21da8f504e951586911425cea798dca75a Mon Sep 17 00:00:00 2001 From: BoHsuu Date: Tue, 10 Mar 2026 13:52:51 +0700 Subject: [PATCH 09/18] Add dto in package shared (migrate from backend to shared) --- .../nextjs/contracts/deployedContracts.ts | 1408 ++++++++++++++--- packages/nextjs/services/api/apiClient.ts | 8 +- packages/shared/src/api/endpoints.ts | 7 + packages/shared/src/crypto/index.ts | 1 + packages/shared/src/crypto/merkle-tree.ts | 122 ++ packages/shared/src/dto/index.ts | 1 + packages/shared/src/dto/mixer/index.ts | 2 + packages/shared/src/dto/mixer/withdraw.dto.ts | 64 + 8 files changed, 1403 insertions(+), 210 deletions(-) create mode 100644 packages/shared/src/crypto/merkle-tree.ts create mode 100644 packages/shared/src/dto/mixer/index.ts create mode 100644 packages/shared/src/dto/mixer/withdraw.dto.ts diff --git a/packages/nextjs/contracts/deployedContracts.ts b/packages/nextjs/contracts/deployedContracts.ts index 6b9a414..0540462 100644 --- a/packages/nextjs/contracts/deployedContracts.ts +++ b/packages/nextjs/contracts/deployedContracts.ts @@ -5,9 +5,9 @@ import { GenericContractsDeclaration } from "~~/utils/scaffold-eth/contract"; const deployedContracts = { - 2651420: { - MetaMultiSigWallet: { - address: "0x1EaCA128069b2bb1cd476ef66E2701F98cAB148E", + 84532: { + Mixer: { + address: "0xd9E9103693014b00db0Bf262b65CB2226062e732", abi: [ { inputs: [ @@ -22,66 +22,92 @@ const deployedContracts = { type: "bytes32", }, { - internalType: "uint256", - name: "_chainId", - type: "uint256", + internalType: "bytes32[]", + name: "_allowedPoolIds", + type: "bytes32[]", }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [ { - internalType: "uint256[]", - name: "_initialCommitments", - type: "uint256[]", + internalType: "address", + name: "target", + type: "address", }, + ], + name: "AddressEmptyCode", + type: "error", + }, + { + inputs: [ { - internalType: "uint256", - name: "_signaturesRequired", - type: "uint256", + internalType: "address", + name: "account", + type: "address", }, ], - stateMutability: "nonpayable", - type: "constructor", + name: "AddressInsufficientBalance", + type: "error", + }, + { + inputs: [], + name: "FailedInnerCall", + type: "error", + }, + { + inputs: [], + name: "ReentrancyGuardReentrantCall", + type: "error", }, { - anonymous: false, inputs: [ { - indexed: true, internalType: "address", - name: "sender", + name: "token", type: "address", }, + ], + name: "SafeERC20FailedOperation", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "bytes32", + name: "commitment", + type: "bytes32", + }, { indexed: false, internalType: "uint256", - name: "amount", + name: "leafIndex", type: "uint256", }, { indexed: false, internalType: "uint256", - name: "balance", + name: "timestamp", type: "uint256", }, - ], - name: "Deposit", - type: "event", - }, - { - anonymous: false, - inputs: [ { indexed: true, - internalType: "uint256", - name: "commitment", - type: "uint256", + internalType: "address", + name: "token", + type: "address", }, { indexed: false, - internalType: "bool", - name: "isAdded", - type: "bool", + internalType: "uint256", + name: "denomination", + type: "uint256", }, ], - name: "Owner", + name: "Deposit", type: "event", }, { @@ -89,36 +115,36 @@ const deployedContracts = { inputs: [ { indexed: true, - internalType: "uint256", - name: "nonce", - type: "uint256", + internalType: "address", + name: "recipient", + type: "address", }, { indexed: false, + internalType: "bytes32", + name: "nullifierHash", + type: "bytes32", + }, + { + indexed: true, internalType: "address", - name: "to", + name: "token", type: "address", }, { indexed: false, internalType: "uint256", - name: "value", + name: "denomination", type: "uint256", }, { indexed: false, - internalType: "bytes", - name: "data", - type: "bytes", - }, - { - indexed: false, - internalType: "bytes", - name: "result", - type: "bytes", + internalType: "uint256", + name: "timestamp", + type: "uint256", }, ], - name: "TransactionExecuted", + name: "Withdrawal", type: "event", }, { @@ -149,84 +175,57 @@ const deployedContracts = { }, { inputs: [], - name: "VERSION_HASH", + name: "ROOT_HISTORY_SIZE", outputs: [ { - internalType: "bytes32", + internalType: "uint256", name: "", - type: "bytes32", + type: "uint256", }, ], stateMutability: "view", type: "function", }, { - inputs: [ - { - internalType: "uint256[]", - name: "newCommitments", - type: "uint256[]", - }, + inputs: [], + name: "TREE_DEPTH", + outputs: [ { internalType: "uint256", - name: "newSigRequired", + name: "", type: "uint256", }, ], - name: "addSigners", - outputs: [], - stateMutability: "nonpayable", + stateMutability: "view", type: "function", }, { - inputs: [ - { - internalType: "address[]", - name: "recipients", - type: "address[]", - }, + inputs: [], + name: "VERSION_HASH", + outputs: [ { - internalType: "uint256[]", - name: "amounts", - type: "uint256[]", + internalType: "bytes32", + name: "", + type: "bytes32", }, ], - name: "batchTransfer", - outputs: [], - stateMutability: "nonpayable", + stateMutability: "view", type: "function", }, { inputs: [ { - internalType: "address[]", - name: "recipients", - type: "address[]", - }, - { - internalType: "uint256[]", - name: "amounts", - type: "uint256[]", - }, - { - internalType: "address[]", - name: "tokenAddresses", - type: "address[]", + internalType: "bytes32", + name: "", + type: "bytes32", }, ], - name: "batchTransferMulti", - outputs: [], - stateMutability: "nonpayable", - type: "function", - }, - { - inputs: [], - name: "chainId", + name: "allowedDenominations", outputs: [ { - internalType: "uint256", + internalType: "bool", name: "", - type: "uint256", + type: "bool", }, ], stateMutability: "view", @@ -235,17 +234,17 @@ const deployedContracts = { { inputs: [ { - internalType: "uint256", + internalType: "bytes32", name: "", - type: "uint256", + type: "bytes32", }, ], - name: "commitments", + name: "commitmentUsed", outputs: [ { - internalType: "uint256", + internalType: "bool", name: "", - type: "uint256", + type: "bool", }, ], stateMutability: "view", @@ -253,130 +252,974 @@ const deployedContracts = { }, { inputs: [ - { - internalType: "uint256", - name: "_nonce", - type: "uint256", - }, { internalType: "address", - name: "to", + name: "token", type: "address", }, { internalType: "uint256", - name: "value", + name: "denomination", type: "uint256", }, { - internalType: "bytes", - name: "data", - type: "bytes", + internalType: "bytes32", + name: "commitment", + type: "bytes32", }, + ], + name: "deposit", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ { - components: [ - { - internalType: "uint256", - name: "commitment", - type: "uint256", - }, - { - internalType: "uint256", - name: "nullifier", - type: "uint256", - }, - { - internalType: "uint256", - name: "aggregationId", - type: "uint256", - }, - { - internalType: "uint256", - name: "domainId", - type: "uint256", - }, - { - internalType: "bytes32[]", - name: "zkMerklePath", - type: "bytes32[]", - }, - { - internalType: "uint256", - name: "leafCount", - type: "uint256", - }, - { - internalType: "uint256", - name: "index", - type: "uint256", - }, - ], - internalType: "struct MetaMultiSigWallet.ZkProof[]", - name: "proofs", - type: "tuple[]", + internalType: "uint256", + name: "level", + type: "uint256", }, ], - name: "execute", + name: "getZeroHash", outputs: [ { - internalType: "bytes", + internalType: "bytes32", name: "", - type: "bytes", + type: "bytes32", }, ], - stateMutability: "nonpayable", + stateMutability: "view", type: "function", }, { - inputs: [], - name: "getCommitments", + inputs: [ + { + internalType: "bytes32", + name: "poolId", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "root", + type: "bytes32", + }, + ], + name: "isKnownRoot", outputs: [ { - internalType: "uint256[]", + internalType: "bool", name: "", - type: "uint256[]", + type: "bool", }, ], stateMutability: "view", type: "function", }, { - inputs: [], - name: "getSignersCount", - outputs: [ + inputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + name: "nullifierUsed", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + name: "rootHistory", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + name: "rootHistoryIndex", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + name: "trees", + outputs: [ + { + internalType: "uint256", + name: "nextIndex", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "vkHash", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "uint256", + name: "denomination", + type: "uint256", + }, + { + internalType: "address", + name: "recipient", + type: "address", + }, + { + internalType: "bytes32", + name: "nullifierHash", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "root", + type: "bytes32", + }, + { + components: [ + { + internalType: "uint256", + name: "aggregationId", + type: "uint256", + }, + { + internalType: "uint256", + name: "domainId", + type: "uint256", + }, + { + internalType: "bytes32[]", + name: "zkMerklePath", + type: "bytes32[]", + }, + { + internalType: "uint256", + name: "leafCount", + type: "uint256", + }, + { + internalType: "uint256", + name: "index", + type: "uint256", + }, + ], + internalType: "struct Mixer.MixerProof", + name: "proof", + type: "tuple", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "zkvContract", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + stateMutability: "payable", + type: "receive", + }, + ], + inheritedFunctions: {}, + deployedOnBlock: 38675302, + }, + }, + 2651420: { + MetaMultiSigWallet: { + address: "0x1EaCA128069b2bb1cd476ef66E2701F98cAB148E", + abi: [ + { + inputs: [ + { + internalType: "address", + name: "_zkvContract", + type: "address", + }, + { + internalType: "bytes32", + name: "_vkHash", + type: "bytes32", + }, + { + internalType: "uint256", + name: "_chainId", + type: "uint256", + }, + { + internalType: "uint256[]", + name: "_initialCommitments", + type: "uint256[]", + }, + { + internalType: "uint256", + name: "_signaturesRequired", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "balance", + type: "uint256", + }, + ], + name: "Deposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint256", + name: "commitment", + type: "uint256", + }, + { + indexed: false, + internalType: "bool", + name: "isAdded", + type: "bool", + }, + ], + name: "Owner", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint256", + name: "nonce", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + indexed: false, + internalType: "bytes", + name: "result", + type: "bytes", + }, + ], + name: "TransactionExecuted", + type: "event", + }, + { + inputs: [], + name: "BN254_PRIME", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "PROVING_SYSTEM_ID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "VERSION_HASH", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256[]", + name: "newCommitments", + type: "uint256[]", + }, + { + internalType: "uint256", + name: "newSigRequired", + type: "uint256", + }, + ], + name: "addSigners", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address[]", + name: "recipients", + type: "address[]", + }, + { + internalType: "uint256[]", + name: "amounts", + type: "uint256[]", + }, + ], + name: "batchTransfer", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address[]", + name: "recipients", + type: "address[]", + }, + { + internalType: "uint256[]", + name: "amounts", + type: "uint256[]", + }, + { + internalType: "address[]", + name: "tokenAddresses", + type: "address[]", + }, + ], + name: "batchTransferMulti", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "chainId", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + name: "commitments", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "_nonce", + type: "uint256", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + components: [ + { + internalType: "uint256", + name: "commitment", + type: "uint256", + }, + { + internalType: "uint256", + name: "nullifier", + type: "uint256", + }, + { + internalType: "uint256", + name: "aggregationId", + type: "uint256", + }, + { + internalType: "uint256", + name: "domainId", + type: "uint256", + }, + { + internalType: "bytes32[]", + name: "zkMerklePath", + type: "bytes32[]", + }, + { + internalType: "uint256", + name: "leafCount", + type: "uint256", + }, + { + internalType: "uint256", + name: "index", + type: "uint256", + }, + ], + internalType: "struct MetaMultiSigWallet.ZkProof[]", + name: "proofs", + type: "tuple[]", + }, + ], + name: "execute", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "getCommitments", + outputs: [ + { + internalType: "uint256[]", + name: "", + type: "uint256[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getSignersCount", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "_nonce", + type: "uint256", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "getTransactionHash", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "a", + type: "uint256", + }, + { + internalType: "uint256", + name: "b", + type: "uint256", + }, + ], + name: "poseidonHash2", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256[]", + name: "commitmentsToRemove", + type: "uint256[]", + }, + { + internalType: "uint256", + name: "newSigRequired", + type: "uint256", + }, + ], + name: "removeSigners", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "signaturesRequired", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "newSigRequired", + type: "uint256", + }, + ], + name: "updateSignaturesRequired", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + name: "usedNonces", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + name: "usedNullifiers", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "vkHash", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "zkvContract", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + stateMutability: "payable", + type: "receive", + }, + ], + inheritedFunctions: {}, + deployedOnBlock: 6615581, + }, + Mixer: { + address: "0x8F5f249210fFc91a2b1D86828764562f97C9eEdd", + abi: [ + { + inputs: [ + { + internalType: "address", + name: "_zkvContract", + type: "address", + }, + { + internalType: "bytes32", + name: "_vkHash", + type: "bytes32", + }, + { + internalType: "bytes32[]", + name: "_allowedPoolIds", + type: "bytes32[]", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [ + { + internalType: "address", + name: "target", + type: "address", + }, + ], + name: "AddressEmptyCode", + type: "error", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "AddressInsufficientBalance", + type: "error", + }, + { + inputs: [], + name: "FailedInnerCall", + type: "error", + }, + { + inputs: [], + name: "ReentrancyGuardReentrantCall", + type: "error", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + ], + name: "SafeERC20FailedOperation", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "bytes32", + name: "commitment", + type: "bytes32", + }, + { + indexed: false, + internalType: "uint256", + name: "leafIndex", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "timestamp", + type: "uint256", + }, + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "denomination", + type: "uint256", + }, + ], + name: "Deposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "recipient", + type: "address", + }, + { + indexed: false, + internalType: "bytes32", + name: "nullifierHash", + type: "bytes32", + }, + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "denomination", + type: "uint256", + }, { + indexed: false, internalType: "uint256", - name: "", + name: "timestamp", type: "uint256", }, ], - stateMutability: "view", - type: "function", + name: "Withdrawal", + type: "event", }, { - inputs: [ + inputs: [], + name: "BN254_PRIME", + outputs: [ { internalType: "uint256", - name: "_nonce", + name: "", type: "uint256", }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "PROVING_SYSTEM_ID", + outputs: [ { - internalType: "address", - name: "to", - type: "address", + internalType: "bytes32", + name: "", + type: "bytes32", }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "ROOT_HISTORY_SIZE", + outputs: [ { internalType: "uint256", - name: "value", + name: "", type: "uint256", }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "TREE_DEPTH", + outputs: [ { - internalType: "bytes", - name: "data", - type: "bytes", + internalType: "uint256", + name: "", + type: "uint256", }, ], - name: "getTransactionHash", + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "VERSION_HASH", outputs: [ { internalType: "bytes32", @@ -390,80 +1233,121 @@ const deployedContracts = { { inputs: [ { - internalType: "uint256", - name: "a", - type: "uint256", + internalType: "bytes32", + name: "", + type: "bytes32", }, + ], + name: "allowedDenominations", + outputs: [ { - internalType: "uint256", - name: "b", - type: "uint256", + internalType: "bool", + name: "", + type: "bool", }, ], - name: "poseidonHash2", + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + name: "commitmentUsed", outputs: [ { - internalType: "uint256", + internalType: "bool", name: "", - type: "uint256", + type: "bool", }, ], - stateMutability: "pure", + stateMutability: "view", type: "function", }, { inputs: [ { - internalType: "uint256[]", - name: "commitmentsToRemove", - type: "uint256[]", + internalType: "address", + name: "token", + type: "address", }, { internalType: "uint256", - name: "newSigRequired", + name: "denomination", type: "uint256", }, + { + internalType: "bytes32", + name: "commitment", + type: "bytes32", + }, ], - name: "removeSigners", + name: "deposit", outputs: [], - stateMutability: "nonpayable", + stateMutability: "payable", type: "function", }, { - inputs: [], - name: "signaturesRequired", - outputs: [ + inputs: [ { internalType: "uint256", - name: "", + name: "level", type: "uint256", }, ], + name: "getZeroHash", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], stateMutability: "view", type: "function", }, { inputs: [ { - internalType: "uint256", - name: "newSigRequired", - type: "uint256", + internalType: "bytes32", + name: "poolId", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "root", + type: "bytes32", }, ], - name: "updateSignaturesRequired", - outputs: [], - stateMutability: "nonpayable", + name: "isKnownRoot", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", type: "function", }, { inputs: [ { - internalType: "uint256", + internalType: "bytes32", name: "", - type: "uint256", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "", + type: "bytes32", }, ], - name: "usedNonces", + name: "nullifierUsed", outputs: [ { internalType: "bool", @@ -476,18 +1360,61 @@ const deployedContracts = { }, { inputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, { internalType: "uint256", name: "", type: "uint256", }, ], - name: "usedNullifiers", + name: "rootHistory", outputs: [ { - internalType: "bool", + internalType: "bytes32", name: "", - type: "bool", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + name: "rootHistoryIndex", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + name: "trees", + outputs: [ + { + internalType: "uint256", + name: "nextIndex", + type: "uint256", }, ], stateMutability: "view", @@ -506,6 +1433,71 @@ const deployedContracts = { stateMutability: "view", type: "function", }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "uint256", + name: "denomination", + type: "uint256", + }, + { + internalType: "address", + name: "recipient", + type: "address", + }, + { + internalType: "bytes32", + name: "nullifierHash", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "root", + type: "bytes32", + }, + { + components: [ + { + internalType: "uint256", + name: "aggregationId", + type: "uint256", + }, + { + internalType: "uint256", + name: "domainId", + type: "uint256", + }, + { + internalType: "bytes32[]", + name: "zkMerklePath", + type: "bytes32[]", + }, + { + internalType: "uint256", + name: "leafCount", + type: "uint256", + }, + { + internalType: "uint256", + name: "index", + type: "uint256", + }, + ], + internalType: "struct Mixer.MixerProof", + name: "proof", + type: "tuple", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, { inputs: [], name: "zkvContract", @@ -525,7 +1517,7 @@ const deployedContracts = { }, ], inheritedFunctions: {}, - deployedOnBlock: 6615581, + deployedOnBlock: 11529753, }, }, 11155111: { diff --git a/packages/nextjs/services/api/apiClient.ts b/packages/nextjs/services/api/apiClient.ts index cc8ed2c..078ef43 100644 --- a/packages/nextjs/services/api/apiClient.ts +++ b/packages/nextjs/services/api/apiClient.ts @@ -17,8 +17,12 @@ export const apiClient: AxiosInstance = axios.create({ apiClient.interceptors.request.use( (config: InternalAxiosRequestConfig) => { - // Increase timeout for auth endpoints (ZK proof takes time) - if (config.url?.includes("/auth") || config.url?.includes("/transaction")) { + // Increase timeout for auth and ZK-heavy endpoints (proof generation + verification) + if ( + config.url?.includes("/auth") || + config.url?.includes("/transaction") || + config.url?.includes("/mixer/withdraw") + ) { config.timeout = API_TIMEOUT_ZK; } diff --git a/packages/shared/src/api/endpoints.ts b/packages/shared/src/api/endpoints.ts index f9353e0..0e1b5ea 100644 --- a/packages/shared/src/api/endpoints.ts +++ b/packages/shared/src/api/endpoints.ts @@ -86,4 +86,11 @@ export const API_ENDPOINTS = { base: "/api/claims", summary: "/api/claims/summary", }, + + mixer: { + withdraw: "/api/mixer/withdraw", + deposits: "/api/mixer/deposits", + depositCount: "/api/mixer/deposit-count", + registerVk: "/api/mixer/register-vk", // TODO: remove this endpoint + }, } as const; diff --git a/packages/shared/src/crypto/index.ts b/packages/shared/src/crypto/index.ts index 9692a45..cc67025 100644 --- a/packages/shared/src/crypto/index.ts +++ b/packages/shared/src/crypto/index.ts @@ -1,3 +1,4 @@ export * from "./identity"; export * from "./constants"; export * from "./poseidon"; +export * from "./merkle-tree"; diff --git a/packages/shared/src/crypto/merkle-tree.ts b/packages/shared/src/crypto/merkle-tree.ts new file mode 100644 index 0000000..9d7d4e2 --- /dev/null +++ b/packages/shared/src/crypto/merkle-tree.ts @@ -0,0 +1,122 @@ +import { poseidonHash2 } from "./poseidon"; + +const TREE_DEPTH = 20; + +let zeroHashes: bigint[] | null = null; + +async function getZeroHashes(): Promise { + if (zeroHashes) return zeroHashes; + zeroHashes = [0n]; + for (let i = 1; i <= TREE_DEPTH; i++) { + const h = await poseidonHash2(zeroHashes[i - 1], zeroHashes[i - 1]); + zeroHashes.push(h); + } + return zeroHashes; +} + +/** Exported for zero-hash consistency tests (JS vs Solidity). Same sequence as Mixer.sol. */ +export async function getMerkleZeroHashes(): Promise { + return getZeroHashes(); +} + +/** + * Incremental Merkle tree matching Mixer.sol: same zero-hash sequence and insert algorithm. + * Zero[0]=0, zero[i]=poseidonHash2(zero[i-1], zero[i-1]). Used to rebuild tree from indexed deposits. + */ +export class IncrementalMerkleTree { + private leaves: bigint[] = []; + private zeroHashes: bigint[] = []; + private initialized = false; + + private async ensureZeroHashes(): Promise { + if (this.initialized) return; + this.zeroHashes = await getZeroHashes(); + this.initialized = true; + } + + async insert(leaf: bigint): Promise { + await this.ensureZeroHashes(); + this.leaves.push(leaf); + } + + /** + * Insert many leaves in order (e.g. from API). Does not compute root until getRoot(). + */ + async insertMany(leaves: bigint[]): Promise { + await this.ensureZeroHashes(); + this.leaves.push(...leaves); + } + + /** + * Replay contract insert algorithm to compute current root. + */ + async getRoot(): Promise { + await this.ensureZeroHashes(); + if (this.leaves.length === 0) { + return this.zeroHashes[TREE_DEPTH]; + } + const filledSubtrees = [...this.zeroHashes.slice(0, TREE_DEPTH)]; + let current = this.leaves[0]; + for (let i = 0; i < TREE_DEPTH; i++) { + if ((0 >> i) % 2 === 0) { + filledSubtrees[i] = current; + current = await poseidonHash2(current, this.zeroHashes[i]); + } else { + current = await poseidonHash2(filledSubtrees[i], current); + } + } + for (let leafIndex = 1; leafIndex < this.leaves.length; leafIndex++) { + current = this.leaves[leafIndex]; + for (let i = 0; i < TREE_DEPTH; i++) { + if ((leafIndex >> i) % 2 === 0) { + filledSubtrees[i] = current; + current = await poseidonHash2(current, this.zeroHashes[i]); + } else { + current = await poseidonHash2(filledSubtrees[i], current); + } + } + } + return current; + } + + /** + * Get Merkle path for the leaf at leafIndex (siblings and path indices for circuit). + * Replays inserts from 0 to leafIndex to capture siblings. + */ + async getMerklePath( + leafIndex: number, + ): Promise<{ siblings: bigint[]; pathIndices: number[] }> { + await this.ensureZeroHashes(); + if (leafIndex < 0 || leafIndex >= this.leaves.length) { + throw new Error( + `Leaf index ${leafIndex} out of range [0, ${this.leaves.length})`, + ); + } + const filledSubtrees = this.zeroHashes.slice(0, TREE_DEPTH).map((h) => h); + const siblings: bigint[] = []; + const pathIndices: number[] = []; + + for (let index = 0; index <= leafIndex; index++) { + let current = this.leaves[index]; + siblings.length = 0; + pathIndices.length = 0; + for (let i = 0; i < TREE_DEPTH; i++) { + if ((index >> i) % 2 === 0) { + siblings.push(this.zeroHashes[i]); + pathIndices.push(0); + filledSubtrees[i] = current; + current = await poseidonHash2(current, this.zeroHashes[i]); + } else { + siblings.push(filledSubtrees[i]); + pathIndices.push(1); + current = await poseidonHash2(filledSubtrees[i], current); + } + } + } + return { siblings, pathIndices }; + } + + get leafCount(): number { + return this.leaves.length; + } +} diff --git a/packages/shared/src/dto/index.ts b/packages/shared/src/dto/index.ts index e21f0c7..e90bc46 100644 --- a/packages/shared/src/dto/index.ts +++ b/packages/shared/src/dto/index.ts @@ -8,3 +8,4 @@ export * from "./auth/index"; export * from "./feature-request/index"; export * from "./pagination.dto"; export * from "./reward/index"; +export * from "./mixer/index"; diff --git a/packages/shared/src/dto/mixer/index.ts b/packages/shared/src/dto/mixer/index.ts new file mode 100644 index 0000000..c622a3f --- /dev/null +++ b/packages/shared/src/dto/mixer/index.ts @@ -0,0 +1,2 @@ +export * from "./withdraw.dto"; + diff --git a/packages/shared/src/dto/mixer/withdraw.dto.ts b/packages/shared/src/dto/mixer/withdraw.dto.ts new file mode 100644 index 0000000..b818502 --- /dev/null +++ b/packages/shared/src/dto/mixer/withdraw.dto.ts @@ -0,0 +1,64 @@ +import { IsArray, IsNumber, IsOptional, IsString, Min } from "class-validator"; +import { Type } from "class-transformer"; + +export class MixerWithdrawDto { + @IsNumber() + chainId: number; + + @IsString() + token: string; + + @IsString() + denomination: string; + + @IsString() + recipient: string; + + @IsString() + nullifierHash: string; + + @IsString() + root: string; + + @IsArray() + @IsNumber({}, { each: true }) + proof: number[]; + + @IsArray() + @IsString({ each: true }) + publicInputs: string[]; + + @IsOptional() + @IsString() + vk?: string; +} + +// TODO: remove this DTO +export class RegisterVkDto { + @IsString() + vk: string; +} + +export class MixerDepositsQueryDto { + @IsNumber() + chainId: number; + + @IsString() + token: string; + + @IsString() + denomination: string; + + @IsOptional() + @Type(() => Number) + @IsNumber() + @Min(0) + fromLeaf?: number; + + @IsOptional() + @Type(() => Number) + @IsNumber() + @Min(0) + toLeaf?: number; +} + From 0932407fab3a61889bc91542ec5867b49369b407 Mon Sep 17 00:00:00 2001 From: BoHsuu Date: Tue, 10 Mar 2026 14:24:21 +0700 Subject: [PATCH 10/18] feat: add Mixer module with controller, service, and indexer --- packages/backend/src/app.module.ts | 2 + .../backend/src/mixer/mixer.controller.ts | 33 +++++ packages/backend/src/mixer/mixer.indexer.ts | 122 +++++++++++++++ packages/backend/src/mixer/mixer.module.ts | 15 ++ packages/backend/src/mixer/mixer.service.ts | 139 ++++++++++++++++++ .../relayer-wallet/relayer-wallet.service.ts | 64 +++++++- .../backend/src/zkverify/zkverify.service.ts | 17 ++- .../shared/src/contracts/contracts-config.ts | 6 + 8 files changed, 396 insertions(+), 2 deletions(-) create mode 100644 packages/backend/src/mixer/mixer.controller.ts create mode 100644 packages/backend/src/mixer/mixer.indexer.ts create mode 100644 packages/backend/src/mixer/mixer.module.ts create mode 100644 packages/backend/src/mixer/mixer.service.ts diff --git a/packages/backend/src/app.module.ts b/packages/backend/src/app.module.ts index cef4dc1..18d5b8d 100644 --- a/packages/backend/src/app.module.ts +++ b/packages/backend/src/app.module.ts @@ -19,6 +19,7 @@ import { PartnerModule } from './partner/partner.module'; import { QuestModule } from './quest/quest.module'; import { RewardModule } from './reward/reward.module'; import { ScheduleModule } from '@nestjs/schedule'; +import { MixerModule } from './mixer/mixer.module'; @Module({ imports: [ @@ -40,6 +41,7 @@ import { ScheduleModule } from '@nestjs/schedule'; PartnerModule, QuestModule, RewardModule, + MixerModule, ScheduleModule.forRoot(), ], }) diff --git a/packages/backend/src/mixer/mixer.controller.ts b/packages/backend/src/mixer/mixer.controller.ts new file mode 100644 index 0000000..c61e232 --- /dev/null +++ b/packages/backend/src/mixer/mixer.controller.ts @@ -0,0 +1,33 @@ +import { Body, Controller, Get, Post, Query } from '@nestjs/common'; +import { MixerService } from './mixer.service'; +import { MixerDepositsQueryDto, MixerWithdrawDto, RegisterVkDto } from '@polypay/shared'; + +@Controller('mixer') +export class MixerController { + constructor(private readonly mixerService: MixerService) {} + + // TODO: remove this endpoint + @Post('register-vk') + async registerVk(@Body() dto: RegisterVkDto) { + return this.mixerService.registerVk(dto.vk); + } + + @Post('withdraw') + async withdraw(@Body() dto: MixerWithdrawDto) { + return this.mixerService.withdraw(dto); + } + + @Get('deposits') + async getDeposits(@Query() query: MixerDepositsQueryDto) { + return this.mixerService.getDeposits(query); + } + + @Get('deposit-count') + async getDepositCount( + @Query('chainId') chainId: string, + @Query('token') token: string, + @Query('denomination') denomination: string, + ) { + return this.mixerService.getDepositCount(Number(chainId), token, denomination); + } +} diff --git a/packages/backend/src/mixer/mixer.indexer.ts b/packages/backend/src/mixer/mixer.indexer.ts new file mode 100644 index 0000000..f5e27a6 --- /dev/null +++ b/packages/backend/src/mixer/mixer.indexer.ts @@ -0,0 +1,122 @@ +import { Injectable, Logger } from '@nestjs/common'; +import { Cron, CronExpression } from '@nestjs/schedule'; +import { createPublicClient, http, parseAbiItem, keccak256, encodePacked } from 'viem'; +import { getChainById, getContractConfigByChainId, MIXER_DEPLOYMENT_BLOCK } from '@polypay/shared'; +import { PrismaService } from '@/database/prisma.service'; + +const MIXER_CHAIN_IDS = [2651420, 84532]; +const BATCH_BLOCK_SIZE = 2000; + +const DEPOSIT_EVENT = parseAbiItem( + 'event Deposit(bytes32 indexed commitment, uint256 leafIndex, uint256 timestamp, address indexed token, uint256 denomination)', +); + +@Injectable() +export class MixerIndexerService { + private readonly logger = new Logger(MixerIndexerService.name); + + constructor(private readonly prisma: PrismaService) {} + + @Cron(CronExpression.EVERY_30_SECONDS) + async indexDeposits() { + for (const chainId of MIXER_CHAIN_IDS) { + try { + await this.indexChain(chainId); + } catch (err: any) { + this.logger.warn(`Mixer indexer chainId=${chainId}: ${err?.message}`); + } + } + } + + private async indexChain(chainId: number) { + const config = getContractConfigByChainId(chainId); + const mixerAddress = config.mixerAddress; + if (!mixerAddress || mixerAddress === '0x0000000000000000000000000000000000000000') { + return; + } + + const chain = getChainById(chainId); + const publicClient = createPublicClient({ + chain, + transport: http(), + }); + + const poolIdFor = (token: string, denomination: string) => + keccak256(encodePacked(['address', 'uint256'], [token as `0x${string}`, BigInt(denomination)])); + + let state = await this.prisma.mixerIndexerState.findUnique({ + where: { chainId }, + }); + + const deploymentNumber = MIXER_DEPLOYMENT_BLOCK[chainId as keyof typeof MIXER_DEPLOYMENT_BLOCK] ?? 0; + const deploymentBlock = BigInt(deploymentNumber); + if (deploymentBlock === 0n) { + this.logger.warn( + `Mixer indexer chainId=${chainId}: no deployment block configured, skipping`, + ); + return; + } + + const fromBlock = state + ? BigInt(state.lastIndexedBlock) + 1n + : deploymentBlock; + const toBlock = await publicClient.getBlockNumber(); + + if (fromBlock > toBlock) { + return; + } + + const endBlock = fromBlock + BigInt(BATCH_BLOCK_SIZE) - 1n; + const batchTo = endBlock > toBlock ? toBlock : endBlock; + + const logs = await publicClient.getLogs({ + address: mixerAddress as `0x${string}`, + event: DEPOSIT_EVENT, + fromBlock, + toBlock: batchTo, + }); + + for (const log of logs) { + const commitment = (log.args.commitment ?? log.topics?.[1] ?? '0x0') as string; + const leafIndex = Number(log.args.leafIndex ?? 0n); + const token = (log.args.token ?? '') as string; + const denomination = String(log.args.denomination ?? 0n); + const poolIdVal = poolIdFor(token, denomination); + + await this.prisma.mixerDeposit.upsert({ + where: { + chainId_poolId_leafIndex: { chainId, poolId: poolIdVal, leafIndex }, + }, + create: { + chainId, + poolId: poolIdVal, + leafIndex, + commitment: commitment as string, + token, + denomination, + blockNumber: Number(log.blockNumber ?? 0), + txHash: log.transactionHash ?? '', + }, + update: {}, + }); + } + + if (!state) { + await this.prisma.mixerIndexerState.create({ + data: { + chainId, + lastIndexedBlock: Number(batchTo), + }, + }); + } else { + await this.prisma.mixerIndexerState.update({ + where: { chainId }, + data: { lastIndexedBlock: Number(batchTo) }, + }); + } + + if (logs.length > 0) { + this.logger.log(`Mixer indexer chainId=${chainId}: indexed ${logs.length} deposits up to block ${batchTo}`); + } + } +} diff --git a/packages/backend/src/mixer/mixer.module.ts b/packages/backend/src/mixer/mixer.module.ts new file mode 100644 index 0000000..5b36fcc --- /dev/null +++ b/packages/backend/src/mixer/mixer.module.ts @@ -0,0 +1,15 @@ +import { Module } from '@nestjs/common'; +import { MixerController } from './mixer.controller'; +import { MixerService } from './mixer.service'; +import { MixerIndexerService } from './mixer.indexer'; +import { ZkVerifyModule } from '@/zkverify/zkverify.module'; +import { RelayerModule } from '@/relayer-wallet/relayer-wallet.module'; +import { DatabaseModule } from '@/database/database.module'; + +@Module({ + imports: [DatabaseModule, ZkVerifyModule, RelayerModule], + controllers: [MixerController], + providers: [MixerService, MixerIndexerService], + exports: [MixerService], +}) +export class MixerModule {} diff --git a/packages/backend/src/mixer/mixer.service.ts b/packages/backend/src/mixer/mixer.service.ts new file mode 100644 index 0000000..faf37cc --- /dev/null +++ b/packages/backend/src/mixer/mixer.service.ts @@ -0,0 +1,139 @@ +import { + Injectable, + Logger, + BadRequestException, +} from '@nestjs/common'; +import { keccak256, encodePacked } from 'viem'; +import { PrismaService } from '@/database/prisma.service'; +import { ZkVerifyService } from '@/zkverify/zkverify.service'; +import { RelayerService } from '@/relayer-wallet/relayer-wallet.service'; +import { getDomainId } from '@/common/utils/proof'; +import { MixerDepositsQueryDto, MixerWithdrawDto } from '@polypay/shared'; + +const MIXER_AGGREGATION_MAX_ATTEMPTS = 30; +const MIXER_AGGREGATION_INTERVAL_MS = 10000; + +@Injectable() +export class MixerService { + private readonly logger = new Logger(MixerService.name); + + constructor( + private readonly prisma: PrismaService, + private readonly zkVerifyService: ZkVerifyService, + private readonly relayerService: RelayerService, + ) {} + + // TODO: remove this endpoint + async registerVk(vk: string): Promise<{ vkHash: string }> { + const vkHash = await this.zkVerifyService.registerMixerVk(vk); + return { vkHash }; + } + + async withdraw(dto: MixerWithdrawDto): Promise<{ txHash: string; status: string }> { + const { chainId, token, denomination, recipient, nullifierHash, root, proof, publicInputs } = dto; + + if (!publicInputs || publicInputs.length !== 5) { + throw new BadRequestException('Mixer circuit expects exactly 5 public inputs'); + } + + this.logger.log(`Submitting mixer proof for chainId=${chainId}, recipient=${recipient}`); + + const { jobId, status: submitStatus } = await this.zkVerifyService.submitProofAndWaitFinalized( + { proof, publicInputs, vk: dto.vk }, + 'mixer', + chainId, + ); + + if (submitStatus === 'Failed' || !jobId) { + throw new BadRequestException('Proof submission failed'); + } + + const aggregationResult = await this.pollForAggregation(jobId); + if (!aggregationResult) { + throw new BadRequestException('MIXER_AGGREGATION_TIMEOUT'); + } + + const { aggregationId, aggregationDetails } = aggregationResult; + const domainId = getDomainId(chainId); + + const txHash = await this.relayerService.executeMixerWithdraw( + chainId, + token, + denomination, + recipient, + nullifierHash, + root, + { + aggregationId: String(aggregationId), + domainId, + zkMerklePath: aggregationDetails.merkleProof || [], + leafCount: aggregationDetails.numberOfLeaves ?? 0, + index: aggregationDetails.leafIndex ?? 0, + }, + ); + + this.logger.log(`Mixer withdraw executed: txHash=${txHash}`); + return { txHash, status: 'success' }; + } + + private async pollForAggregation( + jobId: string, + maxAttempts = MIXER_AGGREGATION_MAX_ATTEMPTS, + intervalMs = MIXER_AGGREGATION_INTERVAL_MS, + ): Promise<{ aggregationId?: number; aggregationDetails?: any } | null> { + for (let attempt = 0; attempt < maxAttempts; attempt++) { + try { + const jobStatus = await this.zkVerifyService.getJobStatus(jobId); + if (jobStatus.status === 'Aggregated') { + return { + aggregationId: jobStatus.aggregationId, + aggregationDetails: jobStatus.aggregationDetails, + }; + } + if (jobStatus.status === 'Failed') { + throw new BadRequestException('Proof aggregation failed'); + } + this.logger.log(`Mixer job ${jobId} status: ${jobStatus.status}, waiting...`); + } catch (err: any) { + this.logger.warn(`Error polling job ${jobId}: ${err?.message}`); + } + await this.sleep(intervalMs); + } + return null; + } + + private sleep(ms: number): Promise { + return new Promise((resolve) => setTimeout(resolve, ms)); + } + + async getDeposits(query: MixerDepositsQueryDto): Promise<{ commitments: string[]; leafIndices: number[] }> { + const { chainId, token, denomination, fromLeaf = 0, toLeaf } = query; + const poolId = this.getPoolId(token, denomination); + + const where: any = { chainId, poolId }; + if (toLeaf !== undefined) { + where.leafIndex = { gte: fromLeaf, lte: toLeaf }; + } else { + where.leafIndex = { gte: fromLeaf }; + } + + const deposits = await this.prisma.mixerDeposit.findMany({ + where, + orderBy: { leafIndex: 'asc' }, + }); + + return { + commitments: deposits.map((d) => d.commitment), + leafIndices: deposits.map((d) => d.leafIndex), + }; + } + + async getDepositCount(chainId: number, token: string, denomination: string): Promise { + const poolId = this.getPoolId(token, denomination); + return this.prisma.mixerDeposit.count({ where: { chainId, poolId } }); + } + + private getPoolId(token: string, denomination: string): string { + return keccak256(encodePacked(['address', 'uint256'], [token as `0x${string}`, BigInt(denomination)])); + } +} diff --git a/packages/backend/src/relayer-wallet/relayer-wallet.service.ts b/packages/backend/src/relayer-wallet/relayer-wallet.service.ts index 16cc8b1..def4022 100644 --- a/packages/backend/src/relayer-wallet/relayer-wallet.service.ts +++ b/packages/backend/src/relayer-wallet/relayer-wallet.service.ts @@ -11,7 +11,7 @@ import { getChainById, getContractConfigByChainId, } from '@polypay/shared'; -import { METAMULTISIG_ABI, METAMULTISIG_BYTECODE } from '@polypay/shared'; +import { METAMULTISIG_ABI, METAMULTISIG_BYTECODE, MIXER_ABI } from '@polypay/shared'; import { ConfigService } from '@nestjs/config'; import { CONFIG_KEYS } from '@/config/config.keys'; import { waitForReceiptWithRetry } from '@/common/utils/retry'; @@ -24,6 +24,7 @@ type RelayerChainClient = { zkVerifyAddress: `0x${string}`; vkHash: string; poseidonT3Address: `0x${string}` | string; + mixerAddress: `0x${string}`; }; }; @@ -362,4 +363,65 @@ export class RelayerService { return { txHash }; } + + /** + * Execute Mixer withdraw on-chain (relayer wallet pays gas) + */ + async executeMixerWithdraw( + chainId: number, + token: string, + denomination: string, + recipient: string, + nullifierHash: string, + root: string, + proof: { + aggregationId: string; + domainId: number; + zkMerklePath: string[]; + leafCount: number; + index: number; + }, + ): Promise { + const { walletClient, publicClient, chain, contractConfig } = + this.getChainClient(chainId); + + const mixerAddress = contractConfig.mixerAddress; + if (!mixerAddress || mixerAddress === '0x0000000000000000000000000000000000000000') { + throw new Error(`Mixer not deployed on chainId ${chainId}`); + } + + const args = [ + token as `0x${string}`, + BigInt(denomination), + recipient as `0x${string}`, + nullifierHash as `0x${string}`, + root as `0x${string}`, + { + aggregationId: BigInt(proof.aggregationId), + domainId: BigInt(proof.domainId), + zkMerklePath: proof.zkMerklePath as `0x${string}`[], + leafCount: BigInt(proof.leafCount), + index: BigInt(proof.index), + }, + ] as const; + + const txHash = await walletClient.writeContract({ + address: mixerAddress, + abi: MIXER_ABI, + functionName: 'withdraw', + args, + account: this.account, + chain, + }); + + this.logger.log(`Mixer withdraw tx sent: ${txHash}`); + + const receipt = await waitForReceiptWithRetry(publicClient, txHash); + + if (receipt.status === 'reverted') { + throw new Error(`Mixer withdraw reverted. TxHash: ${txHash}`); + } + + return txHash; + } } diff --git a/packages/backend/src/zkverify/zkverify.service.ts b/packages/backend/src/zkverify/zkverify.service.ts index 8e084b9..c9e36b1 100644 --- a/packages/backend/src/zkverify/zkverify.service.ts +++ b/packages/backend/src/zkverify/zkverify.service.ts @@ -22,7 +22,7 @@ import { ZK_POLLING_DELAY, } from '@/common/constants/timing'; -export type CircuitType = 'transaction' | 'auth'; +export type CircuitType = 'transaction' | 'auth' | 'mixer'; @Injectable() export class ZkVerifyService { @@ -247,6 +247,21 @@ export class ZkVerifyService { } } + // TODO: remove this method + /** + * Register mixer VK on Kurier and return vkHash. Used for pre-deploy setup. + */ + async registerMixerVk(vk: string): Promise { + await this.registerVk('mixer', vk, 5); + const vkeyPath = this.getVkeyPath('mixer'); + const vkData = JSON.parse(fs.readFileSync(vkeyPath, 'utf-8')); + const vkHash = vkData.vkHash || vkData.meta?.vkHash; + if (!vkHash) { + throw new BadRequestException('VK registration returned no vkHash'); + } + return vkHash; + } + /** * Load or register VK for a specific circuit type */ diff --git a/packages/shared/src/contracts/contracts-config.ts b/packages/shared/src/contracts/contracts-config.ts index 1a8cfa8..6a5e300 100644 --- a/packages/shared/src/contracts/contracts-config.ts +++ b/packages/shared/src/contracts/contracts-config.ts @@ -43,6 +43,12 @@ export const CONTRACT_CONFIG_BY_CHAIN_ID = { }, } as const; +// Starting blocks for Mixer deployments; used by backend indexer to avoid scanning from block 0. +export const MIXER_DEPLOYMENT_BLOCK = { + 2651420: 11529753, // Horizen testnet Mixer deploy block + 84532: 38675302, // Base Sepolia Mixer deploy block +} as const; + export const getContractConfigByChainId = (chainId: number) => { const config = CONTRACT_CONFIG_BY_CHAIN_ID[ From 8842a5c6a4851a71473dcb1c5b418fb47eea85ae Mon Sep 17 00:00:00 2001 From: BoHsuu Date: Tue, 10 Mar 2026 14:43:17 +0700 Subject: [PATCH 11/18] Add config and type, route --- packages/nextjs/app/mixer/page.tsx | 6 ++ .../components/Mixer/RegisterMixerVk.tsx | 50 +++++++++++ .../nextjs/components/Sidebar/Sidebar.tsx | 1 + packages/nextjs/configs/mixer.config.ts | 27 ++++++ packages/nextjs/configs/routes.config.ts | 6 ++ .../nextjs/hooks/app/useRegisterMixerVk.ts | 84 +++++++++++++++++++ packages/nextjs/hooks/app/useRouteApp.ts | 2 + packages/nextjs/services/api/mixerApi.ts | 55 ++++++++++++ packages/shared/src/types/index.ts | 1 + packages/shared/src/types/mixer.ts | 25 ++++++ 10 files changed, 257 insertions(+) create mode 100644 packages/nextjs/app/mixer/page.tsx create mode 100644 packages/nextjs/components/Mixer/RegisterMixerVk.tsx create mode 100644 packages/nextjs/configs/mixer.config.ts create mode 100644 packages/nextjs/hooks/app/useRegisterMixerVk.ts create mode 100644 packages/nextjs/services/api/mixerApi.ts create mode 100644 packages/shared/src/types/mixer.ts diff --git a/packages/nextjs/app/mixer/page.tsx b/packages/nextjs/app/mixer/page.tsx new file mode 100644 index 0000000..791d017 --- /dev/null +++ b/packages/nextjs/app/mixer/page.tsx @@ -0,0 +1,6 @@ +import React from "react"; +import MixerContainer from "~~/components/Mixer/MixerContainer"; + +export default function MixerPage() { + return ; +} diff --git a/packages/nextjs/components/Mixer/RegisterMixerVk.tsx b/packages/nextjs/components/Mixer/RegisterMixerVk.tsx new file mode 100644 index 0000000..07e2192 --- /dev/null +++ b/packages/nextjs/components/Mixer/RegisterMixerVk.tsx @@ -0,0 +1,50 @@ +"use client"; + +import React from "react"; +import { useRegisterMixerVk } from "~~/hooks/app/useRegisterMixerVk"; +import { notification } from "~~/utils/scaffold-eth"; + +// TODO: remove this component +/** + * Dev-only: Register mixer VK on Kurier before deploying Mixer contract. + * Copy the returned vkHash into contracts-config.ts mixerVkHash, then deploy. + */ +export function RegisterMixerVk() { + const { register, loadingState, vkHash, error, setError } = useRegisterMixerVk(); + + const handleRegister = async () => { + setError(null); + try { + const hash = await register(); + notification.success(`VK registered. vkHash: ${hash}`); + } catch (e: any) { + setError(e?.message ?? "Registration failed"); + notification.error(e?.message ?? "Registration failed"); + } + }; + + return ( +
+

+ Dev: Register Mixer VK (run once before deploy) +

+ + {vkHash && ( +
+

vkHash (copy to contracts-config.ts):

+ + {vkHash} + +
+ )} + {error &&

{error}

} +
+ ); +} diff --git a/packages/nextjs/components/Sidebar/Sidebar.tsx b/packages/nextjs/components/Sidebar/Sidebar.tsx index 73d0527..fbe8564 100644 --- a/packages/nextjs/components/Sidebar/Sidebar.tsx +++ b/packages/nextjs/components/Sidebar/Sidebar.tsx @@ -30,6 +30,7 @@ const sectionItems = [ menuItems: [ { icon: Routes.TRANSFER.icon, label: Routes.TRANSFER.title, link: Routes.TRANSFER.path }, { icon: Routes.BATCH.icon, label: Routes.BATCH.title, link: Routes.BATCH.path }, + { icon: Routes.MIXER.icon, label: Routes.MIXER.title, link: Routes.MIXER.path }, ], }, { diff --git a/packages/nextjs/configs/mixer.config.ts b/packages/nextjs/configs/mixer.config.ts new file mode 100644 index 0000000..18d3e33 --- /dev/null +++ b/packages/nextjs/configs/mixer.config.ts @@ -0,0 +1,27 @@ +/** + * Mixer pool options: denominations (in wei/smallest unit) per token type. + * Must match Mixer.sol allowed denominations. + */ +export const MIXER_DENOMINATIONS = { + ETH: [ + "10000000000000000", // 0.01 + "100000000000000000", // 0.1 + "1000000000000000000", // 1 + ], + ZEN: [ + "1000000000000000000", // 1 + "5000000000000000000", // 5 + "10000000000000000000", // 10 + "100000000000000000000", // 100 + "1000000000000000000000", // 1000 + ], + USDC: [ + "1000000", // 1 (6 decimals) + "5000000", // 5 + "10000000", // 10 + "100000000", // 100 + "1000000000", // 1000 + ], +} as const; + +export const MIXER_SUPPORTED_CHAIN_IDS = [2651420, 84532] as const; // TODO: add mainnet chain or use the same as the shared config diff --git a/packages/nextjs/configs/routes.config.ts b/packages/nextjs/configs/routes.config.ts index 3f1f12d..4068892 100644 --- a/packages/nextjs/configs/routes.config.ts +++ b/packages/nextjs/configs/routes.config.ts @@ -47,6 +47,12 @@ const Routes = { name: "mobile", title: "Mobile", }, + MIXER: { + path: "/mixer", + name: "mixer", + title: "Mixer", + icon: "/sidebar/transfer.svg", //TODO: change icon + }, } as const; export default Routes; diff --git a/packages/nextjs/hooks/app/useRegisterMixerVk.ts b/packages/nextjs/hooks/app/useRegisterMixerVk.ts new file mode 100644 index 0000000..3da1e4a --- /dev/null +++ b/packages/nextjs/hooks/app/useRegisterMixerVk.ts @@ -0,0 +1,84 @@ +"use client"; + +import { useCallback, useState } from "react"; +import { poseidonHash2 } from "@polypay/shared"; +import { IncrementalMerkleTree } from "@polypay/shared"; +import { mixerApi } from "~~/services/api/mixerApi"; + +// TODO: remove this hook +/** + * Generates mixer VK with mock data and registers it on Kurier. + * Use before deploying Mixer contract to get vkHash for contracts-config. + */ +export function useRegisterMixerVk() { + const [loadingState, setLoadingState] = useState(""); + const [vkHash, setVkHash] = useState(null); + const [error, setError] = useState(null); + + const register = useCallback(async () => { + setError(null); + setVkHash(null); + setLoadingState("Loading circuit..."); + + const circuitRes = await fetch("/mixer-circuit/target/mixer_circuit.json"); + const noirData = await circuitRes.json(); + const { bytecode, abi } = noirData; + + setLoadingState("Building mock Merkle tree..."); + const secret = 1n; + const nullifier = 2n; + const commitment = await poseidonHash2(secret, nullifier); + const nullifierHash = await poseidonHash2(nullifier, nullifier); + + const tree = new IncrementalMerkleTree(); + await tree.insert(commitment); + const root = await tree.getRoot(); + const { siblings, pathIndices } = await tree.getMerklePath(0); + + const recipientField = 1n; + const tokenField = 2n; + const denomField = 1n; + + const circuitInput = { + secret: secret.toString(), + nullifier: nullifier.toString(), + merkle_path: siblings.map((s) => s.toString()), + path_indices: pathIndices.map((i) => i.toString()), + merkle_root: root.toString(), + nullifier_hash: nullifierHash.toString(), + recipient: recipientField.toString(), + token_address: tokenField.toString(), + denomination: denomField.toString(), + }; + + setLoadingState("Loading ZK libraries..."); + const [{ Noir }, { UltraPlonkBackend }] = await Promise.all([ + import("@noir-lang/noir_js"), + import("@aztec/bb.js"), + ]); + + setLoadingState("Executing circuit..."); + const noir = new Noir({ bytecode, abi } as any); + const execResult = await noir.execute(circuitInput); + + setLoadingState("Generating proof & VK..."); + const plonk = new UltraPlonkBackend(bytecode, { threads: 2 }); + await plonk.generateProof(execResult.witness); + const vk = await plonk.getVerificationKey(); + + setLoadingState("Registering VK on Kurier..."); + const result = await mixerApi.registerVk(Buffer.from(vk).toString("base64")); // TODO: change to actual vk + + setVkHash(result.vkHash); + setLoadingState(""); + return result.vkHash; + }, []); + + return { + register, + loadingState, + vkHash, + error, + setError, + }; +} diff --git a/packages/nextjs/hooks/app/useRouteApp.ts b/packages/nextjs/hooks/app/useRouteApp.ts index 6bb298c..d632111 100644 --- a/packages/nextjs/hooks/app/useRouteApp.ts +++ b/packages/nextjs/hooks/app/useRouteApp.ts @@ -110,6 +110,7 @@ export function useAppRouter() { const goToTransfer = useCallback(() => router.push(Routes.TRANSFER.path), [router]); const goToBatch = useCallback(() => router.push(Routes.BATCH.path), [router]); const goToMobile = useCallback(() => router.push(Routes.MOBILE.path), [router]); + const goToMixer = useCallback(() => router.push(Routes.MIXER.path), [router]); return { navigateTo, @@ -123,6 +124,7 @@ export function useAppRouter() { goToTransfer, goToBatch, goToMobile, + goToMixer, isActiveRoute, currentRoute, pathname, diff --git a/packages/nextjs/services/api/mixerApi.ts b/packages/nextjs/services/api/mixerApi.ts new file mode 100644 index 0000000..8054150 --- /dev/null +++ b/packages/nextjs/services/api/mixerApi.ts @@ -0,0 +1,55 @@ +import { apiClient } from "./apiClient"; +import { + API_ENDPOINTS, + MixerDepositsParams, + MixerDepositsResponse, + MixerWithdrawParams, +} from "@polypay/shared"; + +export const mixerApi = { + getDeposits: async (params: MixerDepositsParams): Promise => { + const search = new URLSearchParams(); + search.set("chainId", String(params.chainId)); + search.set("token", params.token); + search.set("denomination", params.denomination); + if (params.fromLeaf !== undefined) search.set("fromLeaf", String(params.fromLeaf)); + if (params.toLeaf !== undefined) search.set("toLeaf", String(params.toLeaf)); + const { data } = await apiClient.get( + `${API_ENDPOINTS.mixer.deposits}?${search.toString()}`, + ); + return data; + }, + + getDepositCount: async ( + chainId: number, + token: string, + denomination: string, + ): Promise => { + const search = new URLSearchParams({ + chainId: String(chainId), + token, + denomination, + }); + const { data } = await apiClient.get( + `${API_ENDPOINTS.mixer.depositCount}?${search.toString()}`, + ); + return data; + }, + + withdraw: async (params: MixerWithdrawParams): Promise<{ txHash: string; status: string }> => { + const { data } = await apiClient.post<{ txHash: string; status: string }>( + API_ENDPOINTS.mixer.withdraw, + params, + ); + return data; + }, + + // TODO: remove this endpoint + registerVk: async (vk: string): Promise<{ vkHash: string }> => { + const { data } = await apiClient.post<{ vkHash: string }>( + API_ENDPOINTS.mixer.registerVk, + { vk }, + ); + return data; + }, +}; diff --git a/packages/shared/src/types/index.ts b/packages/shared/src/types/index.ts index a9781e9..ab09c5c 100644 --- a/packages/shared/src/types/index.ts +++ b/packages/shared/src/types/index.ts @@ -10,3 +10,4 @@ export * from "./auth"; export * from "./feature-request"; export * from "./quest"; export * from "./reward"; +export * from "./mixer"; diff --git a/packages/shared/src/types/mixer.ts b/packages/shared/src/types/mixer.ts new file mode 100644 index 0000000..f88fdda --- /dev/null +++ b/packages/shared/src/types/mixer.ts @@ -0,0 +1,25 @@ +export interface MixerDepositsParams { + chainId: number; + token: string; + denomination: string; + fromLeaf?: number; + toLeaf?: number; +} + +export interface MixerDepositsResponse { + commitments: string[]; + leafIndices: number[]; +} + +export interface MixerWithdrawParams { + chainId: number; + token: string; + denomination: string; + recipient: string; + nullifierHash: string; + root: string; + proof: number[]; + publicInputs: string[]; + vk?: string; +} + From d9dc681ff16f723bd998d6c4ac74adb68ac1b948 Mon Sep 17 00:00:00 2001 From: BoHsuu Date: Tue, 10 Mar 2026 15:26:00 +0700 Subject: [PATCH 12/18] add hook --- packages/nextjs/hooks/app/useMerkleTree.ts | 37 ++++ packages/nextjs/hooks/app/useMixerDeposit.ts | 91 ++++++++++ packages/nextjs/hooks/app/useMixerKeys.ts | 123 +++++++++++++ packages/nextjs/hooks/app/useMixerWithdraw.ts | 165 ++++++++++++++++++ 4 files changed, 416 insertions(+) create mode 100644 packages/nextjs/hooks/app/useMerkleTree.ts create mode 100644 packages/nextjs/hooks/app/useMixerDeposit.ts create mode 100644 packages/nextjs/hooks/app/useMixerKeys.ts create mode 100644 packages/nextjs/hooks/app/useMixerWithdraw.ts diff --git a/packages/nextjs/hooks/app/useMerkleTree.ts b/packages/nextjs/hooks/app/useMerkleTree.ts new file mode 100644 index 0000000..b0c358b --- /dev/null +++ b/packages/nextjs/hooks/app/useMerkleTree.ts @@ -0,0 +1,37 @@ +"use client"; + +import { useCallback, useMemo } from "react"; +import { IncrementalMerkleTree } from "@polypay/shared"; + +/** + * Rebuild Merkle tree from indexed deposits (commitments in order) and get root/path for a leaf index. + */ +export function useMerkleTree() { + const buildTree = useCallback(async (commitmentsHex: string[]) => { + const tree = new IncrementalMerkleTree(); + const leaves = commitmentsHex.map((c) => (c.startsWith("0x") ? BigInt(c) : BigInt("0x" + c))); + await tree.insertMany(leaves); + return tree; + }, []); + + const getRootAndPath = useCallback( + async ( + commitmentsHex: string[], + leafIndex: number, + ): Promise<{ root: bigint; siblings: bigint[]; pathIndices: number[] }> => { + const tree = await buildTree(commitmentsHex); + const root = await tree.getRoot(); + const { siblings, pathIndices } = await tree.getMerklePath(leafIndex); + return { root, siblings, pathIndices }; + }, + [buildTree], + ); + + return useMemo( + () => ({ + buildTree, + getRootAndPath, + }), + [buildTree, getRootAndPath], + ); +} diff --git a/packages/nextjs/hooks/app/useMixerDeposit.ts b/packages/nextjs/hooks/app/useMixerDeposit.ts new file mode 100644 index 0000000..6244e38 --- /dev/null +++ b/packages/nextjs/hooks/app/useMixerDeposit.ts @@ -0,0 +1,91 @@ +"use client"; + +import { useCallback, useState } from "react"; +import { getContractConfigByChainId, MIXER_ABI } from "@polypay/shared"; +import { useWriteContract } from "wagmi"; +import { mixerApi } from "~~/services/api/mixerApi"; +import { useMixerKeys } from "./useMixerKeys"; + +const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"; + +const ERC20_APPROVE_ABI = [ + { + name: "approve", + type: "function", + inputs: [ + { name: "spender", type: "address" }, + { name: "amount", type: "uint256" }, + ], + outputs: [{ name: "", type: "bool" }], + stateMutability: "nonpayable", + }, +] as const; + +function bigintToBytes32Hex(v: bigint): `0x${string}` { + const hex = v.toString(16).padStart(64, "0"); + return `0x${hex}` as `0x${string}`; +} + +export function useMixerDeposit() { + const { writeContractAsync, isPending: isWritePending } = useWriteContract(); + const { getNextDepositIndex, ensureBaseSecret, isReady: keysReady } = useMixerKeys(); + const [error, setError] = useState(null); + + const deposit = useCallback( + async (params: { + chainId: number; + token: string; + denomination: string; + value?: bigint; + }) => { + setError(null); + const { chainId, token, denomination, value } = params; + const config = getContractConfigByChainId(chainId); + const mixerAddress = config.mixerAddress; + if (!mixerAddress || mixerAddress === "0x0000000000000000000000000000000000000000") { + throw new Error("Mixer is not deployed on this network"); + } + await ensureBaseSecret(); + const { commitments } = await mixerApi.getDeposits({ chainId, token, denomination }); + const { commitment } = await getNextDepositIndex(commitments); + const commitmentHex = bigintToBytes32Hex(commitment); + const tokenAddress = token as `0x${string}`; + const denomBigInt = BigInt(denomination); + + if (token !== ZERO_ADDRESS) { + await writeContractAsync({ + address: tokenAddress, + abi: ERC20_APPROVE_ABI, + functionName: "approve", + args: [mixerAddress, denomBigInt], + }); + } + + if (value !== undefined && value > 0n) { + await writeContractAsync({ + address: mixerAddress, + abi: MIXER_ABI, + functionName: "deposit", + args: [tokenAddress, denomBigInt, commitmentHex], + value, + }); + } else { + await writeContractAsync({ + address: mixerAddress, + abi: MIXER_ABI, + functionName: "deposit", + args: [tokenAddress, denomBigInt, commitmentHex], + }); + } + }, + [ensureBaseSecret, getNextDepositIndex, writeContractAsync], + ); + + return { + deposit, + isPending: isWritePending, + error, + setError, + isReady: keysReady, + }; +} diff --git a/packages/nextjs/hooks/app/useMixerKeys.ts b/packages/nextjs/hooks/app/useMixerKeys.ts new file mode 100644 index 0000000..68745fc --- /dev/null +++ b/packages/nextjs/hooks/app/useMixerKeys.ts @@ -0,0 +1,123 @@ +"use client"; + +import { useCallback, useState } from "react"; +import { keccak256 } from "viem"; +import { useWalletClient } from "wagmi"; +import { BN254_MODULUS, poseidonHash2 } from "@polypay/shared"; + +const MIXER_SECRET_MESSAGE = "polypay-mixer-secret"; + +export interface MixerDepositSlot { + n: number; + commitment: bigint; + nullifier: bigint; + leafIndex: number; +} + +export function useMixerKeys() { + const { data: walletClient } = useWalletClient(); + const [baseSecret, setBaseSecret] = useState(null); + const [isLoading, setIsLoading] = useState(false); + const [error, setError] = useState(null); + + const deriveBaseSecret = useCallback(async (): Promise => { + if (!walletClient) throw new Error("Wallet not connected"); + const [account] = await walletClient.getAddresses(); + if (!account) throw new Error("No account"); + const signature = await walletClient.signMessage({ + account, + message: MIXER_SECRET_MESSAGE, + }); + const signatureHash = keccak256(signature); + return BigInt(signatureHash) % BN254_MODULUS; + }, [walletClient]); + + const ensureBaseSecret = useCallback(async (): Promise => { + if (baseSecret !== null) return baseSecret; + setIsLoading(true); + setError(null); + try { + const secret = await deriveBaseSecret(); + setBaseSecret(secret); + return secret; + } catch (e) { + const msg = e instanceof Error ? e.message : "Failed to derive mixer secret"; + setError(msg); + throw e; + } finally { + setIsLoading(false); + } + }, [baseSecret, deriveBaseSecret]); + + const computeCommitmentAndNullifier = useCallback( + async (secret: bigint, n: number): Promise<{ commitment: bigint; nullifier: bigint }> => { + const nullifier = await poseidonHash2(secret, BigInt(n)); + const commitment = await poseidonHash2(secret, nullifier); + return { commitment, nullifier }; + }, + [], + ); + + /** + * Find smallest n such that commitment_n is not in the pool (for next deposit). + */ + const getNextDepositIndex = useCallback( + async (commitmentsHex: string[]): Promise<{ n: number; commitment: bigint; nullifier: bigint }> => { + const secret = await ensureBaseSecret(); + const set = new Set(commitmentsHex.map((c) => (c.startsWith("0x") ? BigInt(c).toString() : BigInt("0x" + c).toString()))); + for (let n = 0; ; n++) { + const { commitment, nullifier } = await computeCommitmentAndNullifier(secret, n); + const key = commitment.toString(); + if (!set.has(key)) return { n, commitment, nullifier }; + } + }, + [ensureBaseSecret, computeCommitmentAndNullifier], + ); + + /** + * Find all n such that commitment_n is in the pool; returns slots with leafIndex from the index list. + */ + const findMyDeposits = useCallback( + async ( + commitmentsHex: string[], + leafIndices: number[], + ): Promise => { + if (commitmentsHex.length !== leafIndices.length) return []; + const secret = await ensureBaseSecret(); + const commitmentToLeafIndex = new Map(); + commitmentsHex.forEach((c, i) => { + const key = c.startsWith("0x") ? BigInt(c).toString() : BigInt("0x" + c).toString(); + commitmentToLeafIndex.set(key, leafIndices[i]); + }); + const result: MixerDepositSlot[] = []; + const maxN = Math.max(commitmentsHex.length * 2, 100); + for (let n = 0; n < maxN; n++) { + const { commitment, nullifier } = await computeCommitmentAndNullifier(secret, n); + const key = commitment.toString(); + const leafIndex = commitmentToLeafIndex.get(key); + if (leafIndex !== undefined) { + result.push({ n, commitment, nullifier, leafIndex }); + } + } + return result.sort((a, b) => a.leafIndex - b.leafIndex); + }, + [ensureBaseSecret, computeCommitmentAndNullifier], + ); + + const reset = useCallback(() => { + setBaseSecret(null); + setError(null); + }, []); + + return { + ensureBaseSecret, + getNextDepositIndex, + findMyDeposits, + deriveBaseSecret, + baseSecret, + isLoading, + error, + reset, + isReady: !!walletClient, + }; +} diff --git a/packages/nextjs/hooks/app/useMixerWithdraw.ts b/packages/nextjs/hooks/app/useMixerWithdraw.ts new file mode 100644 index 0000000..d6f520b --- /dev/null +++ b/packages/nextjs/hooks/app/useMixerWithdraw.ts @@ -0,0 +1,165 @@ +"use client"; + +import { useCallback, useState } from "react"; +import { getContractConfigByChainId, MIXER_ABI, poseidonHash2 } from "@polypay/shared"; +import { usePublicClient } from "wagmi"; +import { useMixerKeys, type MixerDepositSlot } from "./useMixerKeys"; +import { useMerkleTree } from "./useMerkleTree"; +import { mixerApi } from "~~/services/api/mixerApi"; +import { keccak256, encodePacked } from "viem"; + +function bigintToHex(v: bigint): string { + const hex = v.toString(16).padStart(64, "0"); + return "0x" + hex; +} + +export interface MixerWithdrawParams { + chainId: number; + token: string; + denomination: string; + recipient: string; + slot: MixerDepositSlot; +} + +function getPoolId(token: string, denomination: string): `0x${string}` { + return keccak256( + encodePacked(["address", "uint256"], [token as `0x${string}`, BigInt(denomination)]), + ) as `0x${string}`; +} + +function bigintToBytes32(v: bigint): `0x${string}` { + return ("0x" + v.toString(16).padStart(64, "0")) as `0x${string}`; +} + +export function useMixerWithdraw() { + const publicClient = usePublicClient(); + const { ensureBaseSecret, findMyDeposits, isReady: keysReady } = useMixerKeys(); + const { getRootAndPath } = useMerkleTree(); + const [loadingState, setLoadingState] = useState(""); + const [error, setError] = useState(null); + + const getWithdrawableSlots = useCallback( + async ( + chainId: number, + token: string, + denomination: string, + ): Promise => { + const config = getContractConfigByChainId(chainId); + if (!config.mixerAddress || config.mixerAddress === "0x0000000000000000000000000000000000000000") { + return []; + } + if (!publicClient) return []; + const { commitments, leafIndices } = await mixerApi.getDeposits({ + chainId, + token, + denomination, + }); + const allSlots = await findMyDeposits(commitments, leafIndices); + const poolId = getPoolId(token, denomination); + const withdrawable: MixerDepositSlot[] = []; + for (const slot of allSlots) { + const nullifierHash = await poseidonHash2(slot.nullifier, slot.nullifier); + const used = await publicClient.readContract({ + address: config.mixerAddress, + abi: MIXER_ABI, + functionName: "nullifierUsed", + args: [poolId, bigintToBytes32(nullifierHash)], + }); + if (!used) withdrawable.push(slot); + } + return withdrawable; + }, + [publicClient, findMyDeposits], + ); + + const withdraw = useCallback( + async (params: MixerWithdrawParams): Promise<{ txHash: string; status: string }> => { + setError(null); + const { chainId, token, denomination, recipient, slot } = params; + + setLoadingState("Preparing..."); + const secret = await ensureBaseSecret(); + + setLoadingState("Fetching deposits..."); + const { commitments, leafIndices } = await mixerApi.getDeposits({ + chainId, + token, + denomination, + }); + + setLoadingState("Building Merkle path..."); + const { root, siblings, pathIndices } = await getRootAndPath(commitments, slot.leafIndex); + const nullifierHash = await poseidonHash2(slot.nullifier, slot.nullifier); + + const recipientField = BigInt(recipient); + const tokenField = BigInt(token); + const denomField = BigInt(denomination); + + const circuitInput = { + secret: secret.toString(), + nullifier: slot.nullifier.toString(), + merkle_path: siblings.map((s) => s.toString()), + path_indices: pathIndices.map((i) => i.toString()), + merkle_root: root.toString(), + nullifier_hash: nullifierHash.toString(), + recipient: recipientField.toString(), + token_address: tokenField.toString(), + denomination: denomField.toString(), + }; + + setLoadingState("Loading ZK libraries..."); + const circuitRes = await fetch("/mixer-circuit/target/mixer_circuit.json"); + const noirData = await circuitRes.json(); + const { bytecode, abi } = noirData; + + const [{ Noir }, { UltraPlonkBackend }] = await Promise.all([ + import("@noir-lang/noir_js"), + import("@aztec/bb.js"), + ]); + + setLoadingState("Executing circuit..."); + const noir = new Noir({ bytecode, abi } as any); + const execResult = await noir.execute(circuitInput); + + setLoadingState("Generating ZK proof..."); + const plonk = new UltraPlonkBackend(bytecode, { threads: 2 }); + const { proof, publicInputs } = await plonk.generateProof(execResult.witness); + const vk = await plonk.getVerificationKey(); + + const publicInputsHex = [ + bigintToHex(root), + bigintToHex(nullifierHash), + bigintToHex(recipientField), + bigintToHex(tokenField), + bigintToHex(denomField), + ]; + + setLoadingState("Submitting withdraw..."); + const result = await mixerApi.withdraw({ + chainId, + token, + denomination, + recipient, + nullifierHash: bigintToHex(nullifierHash), + root: bigintToHex(root), + proof: Array.from(proof), + publicInputs: publicInputsHex, + vk: Buffer.from(vk).toString("base64"), + }); + + setLoadingState(""); + return result; + }, + [ensureBaseSecret, getRootAndPath], + ); + + return { + withdraw, + getWithdrawableSlots, + findMyDeposits, + loadingState, + error, + setError, + isReady: keysReady, + }; +} From 431ac7ac5fab7fd5eb32136b9ffc9826cd542f8a Mon Sep 17 00:00:00 2001 From: BoHsuu Date: Tue, 10 Mar 2026 17:42:21 +0700 Subject: [PATCH 13/18] Refactor: improve code formatting and structure across Mixer module - Enhanced readability by reformatting import statements and function parameters in `mixer.controller.ts`, `mixer.indexer.ts`, and `mixer.service.ts`. - Added new components for the Mixer UI: `DepositTab`, `WithdrawTab`, `MixerContainer`, and `PoolStats`. - Implemented hooks for managing deposits and withdrawals in `useMixerDeposit` and `useMixerWithdraw`. - Updated DTOs in the shared package to improve type validation. - Introduced new API methods in `mixerApi` for handling deposits and withdrawals. --- .../backend/src/mixer/mixer.controller.ts | 12 +- packages/backend/src/mixer/mixer.indexer.ts | 38 ++- packages/backend/src/mixer/mixer.service.ts | 70 ++++-- .../relayer-wallet/relayer-wallet.service.ts | 11 +- .../nextjs/components/Mixer/DepositTab.tsx | 126 ++++++++++ .../components/Mixer/MixerContainer.tsx | 55 +++++ .../nextjs/components/Mixer/PoolStats.tsx | 26 +++ .../components/Mixer/RegisterMixerVk.tsx | 8 +- .../nextjs/components/Mixer/WithdrawTab.tsx | 216 ++++++++++++++++++ packages/nextjs/hooks/app/useMerkleTree.ts | 2 +- packages/nextjs/hooks/app/useMixerDeposit.ts | 11 +- packages/nextjs/hooks/app/useMixerKeys.ts | 11 +- packages/nextjs/hooks/app/useMixerWithdraw.ts | 18 +- .../nextjs/hooks/app/useRegisterMixerVk.ts | 9 +- packages/nextjs/services/api/mixerApi.ts | 31 +-- packages/shared/src/dto/mixer/index.ts | 1 - packages/shared/src/dto/mixer/withdraw.dto.ts | 15 +- packages/shared/src/types/mixer.ts | 1 - 18 files changed, 560 insertions(+), 101 deletions(-) create mode 100644 packages/nextjs/components/Mixer/DepositTab.tsx create mode 100644 packages/nextjs/components/Mixer/MixerContainer.tsx create mode 100644 packages/nextjs/components/Mixer/PoolStats.tsx create mode 100644 packages/nextjs/components/Mixer/WithdrawTab.tsx diff --git a/packages/backend/src/mixer/mixer.controller.ts b/packages/backend/src/mixer/mixer.controller.ts index c61e232..1a4b87c 100644 --- a/packages/backend/src/mixer/mixer.controller.ts +++ b/packages/backend/src/mixer/mixer.controller.ts @@ -1,6 +1,10 @@ import { Body, Controller, Get, Post, Query } from '@nestjs/common'; import { MixerService } from './mixer.service'; -import { MixerDepositsQueryDto, MixerWithdrawDto, RegisterVkDto } from '@polypay/shared'; +import { + MixerDepositsQueryDto, + MixerWithdrawDto, + RegisterVkDto, +} from '@polypay/shared'; @Controller('mixer') export class MixerController { @@ -28,6 +32,10 @@ export class MixerController { @Query('token') token: string, @Query('denomination') denomination: string, ) { - return this.mixerService.getDepositCount(Number(chainId), token, denomination); + return this.mixerService.getDepositCount( + Number(chainId), + token, + denomination, + ); } } diff --git a/packages/backend/src/mixer/mixer.indexer.ts b/packages/backend/src/mixer/mixer.indexer.ts index f5e27a6..169ef35 100644 --- a/packages/backend/src/mixer/mixer.indexer.ts +++ b/packages/backend/src/mixer/mixer.indexer.ts @@ -1,7 +1,17 @@ import { Injectable, Logger } from '@nestjs/common'; import { Cron, CronExpression } from '@nestjs/schedule'; -import { createPublicClient, http, parseAbiItem, keccak256, encodePacked } from 'viem'; -import { getChainById, getContractConfigByChainId, MIXER_DEPLOYMENT_BLOCK } from '@polypay/shared'; +import { + createPublicClient, + http, + parseAbiItem, + keccak256, + encodePacked, +} from 'viem'; +import { + getChainById, + getContractConfigByChainId, + MIXER_DEPLOYMENT_BLOCK, +} from '@polypay/shared'; import { PrismaService } from '@/database/prisma.service'; const MIXER_CHAIN_IDS = [2651420, 84532]; @@ -31,7 +41,10 @@ export class MixerIndexerService { private async indexChain(chainId: number) { const config = getContractConfigByChainId(chainId); const mixerAddress = config.mixerAddress; - if (!mixerAddress || mixerAddress === '0x0000000000000000000000000000000000000000') { + if ( + !mixerAddress || + mixerAddress === '0x0000000000000000000000000000000000000000' + ) { return; } @@ -42,13 +55,20 @@ export class MixerIndexerService { }); const poolIdFor = (token: string, denomination: string) => - keccak256(encodePacked(['address', 'uint256'], [token as `0x${string}`, BigInt(denomination)])); + keccak256( + encodePacked( + ['address', 'uint256'], + [token as `0x${string}`, BigInt(denomination)], + ), + ); let state = await this.prisma.mixerIndexerState.findUnique({ where: { chainId }, }); - const deploymentNumber = MIXER_DEPLOYMENT_BLOCK[chainId as keyof typeof MIXER_DEPLOYMENT_BLOCK] ?? 0; + const deploymentNumber = + MIXER_DEPLOYMENT_BLOCK[chainId as keyof typeof MIXER_DEPLOYMENT_BLOCK] ?? + 0; const deploymentBlock = BigInt(deploymentNumber); if (deploymentBlock === 0n) { this.logger.warn( @@ -77,7 +97,9 @@ export class MixerIndexerService { }); for (const log of logs) { - const commitment = (log.args.commitment ?? log.topics?.[1] ?? '0x0') as string; + const commitment = (log.args.commitment ?? + log.topics?.[1] ?? + '0x0') as string; const leafIndex = Number(log.args.leafIndex ?? 0n); const token = (log.args.token ?? '') as string; const denomination = String(log.args.denomination ?? 0n); @@ -116,7 +138,9 @@ export class MixerIndexerService { } if (logs.length > 0) { - this.logger.log(`Mixer indexer chainId=${chainId}: indexed ${logs.length} deposits up to block ${batchTo}`); + this.logger.log( + `Mixer indexer chainId=${chainId}: indexed ${logs.length} deposits up to block ${batchTo}`, + ); } } } diff --git a/packages/backend/src/mixer/mixer.service.ts b/packages/backend/src/mixer/mixer.service.ts index faf37cc..388c5fa 100644 --- a/packages/backend/src/mixer/mixer.service.ts +++ b/packages/backend/src/mixer/mixer.service.ts @@ -1,8 +1,4 @@ -import { - Injectable, - Logger, - BadRequestException, -} from '@nestjs/common'; +import { Injectable, Logger, BadRequestException } from '@nestjs/common'; import { keccak256, encodePacked } from 'viem'; import { PrismaService } from '@/database/prisma.service'; import { ZkVerifyService } from '@/zkverify/zkverify.service'; @@ -29,21 +25,37 @@ export class MixerService { return { vkHash }; } - async withdraw(dto: MixerWithdrawDto): Promise<{ txHash: string; status: string }> { - const { chainId, token, denomination, recipient, nullifierHash, root, proof, publicInputs } = dto; + async withdraw( + dto: MixerWithdrawDto, + ): Promise<{ txHash: string; status: string }> { + const { + chainId, + token, + denomination, + recipient, + nullifierHash, + root, + proof, + publicInputs, + } = dto; if (!publicInputs || publicInputs.length !== 5) { - throw new BadRequestException('Mixer circuit expects exactly 5 public inputs'); + throw new BadRequestException( + 'Mixer circuit expects exactly 5 public inputs', + ); } - this.logger.log(`Submitting mixer proof for chainId=${chainId}, recipient=${recipient}`); - - const { jobId, status: submitStatus } = await this.zkVerifyService.submitProofAndWaitFinalized( - { proof, publicInputs, vk: dto.vk }, - 'mixer', - chainId, + this.logger.log( + `Submitting mixer proof for chainId=${chainId}, recipient=${recipient}`, ); + const { jobId, status: submitStatus } = + await this.zkVerifyService.submitProofAndWaitFinalized( + { proof, publicInputs, vk: dto.vk }, + 'mixer', + chainId, + ); + if (submitStatus === 'Failed' || !jobId) { throw new BadRequestException('Proof submission failed'); } @@ -93,7 +105,9 @@ export class MixerService { if (jobStatus.status === 'Failed') { throw new BadRequestException('Proof aggregation failed'); } - this.logger.log(`Mixer job ${jobId} status: ${jobStatus.status}, waiting...`); + this.logger.log( + `Mixer job ${jobId} status: ${jobStatus.status}, waiting...`, + ); } catch (err: any) { this.logger.warn(`Error polling job ${jobId}: ${err?.message}`); } @@ -106,8 +120,17 @@ export class MixerService { return new Promise((resolve) => setTimeout(resolve, ms)); } - async getDeposits(query: MixerDepositsQueryDto): Promise<{ commitments: string[]; leafIndices: number[] }> { - const { chainId, token, denomination, fromLeaf = 0, toLeaf } = query; + async getDeposits( + query: MixerDepositsQueryDto, + ): Promise<{ commitments: string[]; leafIndices: number[] }> { + const { + chainId: chainIdStr, + token, + denomination, + fromLeaf = 0, + toLeaf, + } = query; + const chainId = Number(chainIdStr); const poolId = this.getPoolId(token, denomination); const where: any = { chainId, poolId }; @@ -128,12 +151,21 @@ export class MixerService { }; } - async getDepositCount(chainId: number, token: string, denomination: string): Promise { + async getDepositCount( + chainId: number, + token: string, + denomination: string, + ): Promise { const poolId = this.getPoolId(token, denomination); return this.prisma.mixerDeposit.count({ where: { chainId, poolId } }); } private getPoolId(token: string, denomination: string): string { - return keccak256(encodePacked(['address', 'uint256'], [token as `0x${string}`, BigInt(denomination)])); + return keccak256( + encodePacked( + ['address', 'uint256'], + [token as `0x${string}`, BigInt(denomination)], + ), + ); } } diff --git a/packages/backend/src/relayer-wallet/relayer-wallet.service.ts b/packages/backend/src/relayer-wallet/relayer-wallet.service.ts index def4022..9f64569 100644 --- a/packages/backend/src/relayer-wallet/relayer-wallet.service.ts +++ b/packages/backend/src/relayer-wallet/relayer-wallet.service.ts @@ -11,7 +11,11 @@ import { getChainById, getContractConfigByChainId, } from '@polypay/shared'; -import { METAMULTISIG_ABI, METAMULTISIG_BYTECODE, MIXER_ABI } from '@polypay/shared'; +import { + METAMULTISIG_ABI, + METAMULTISIG_BYTECODE, + MIXER_ABI, +} from '@polypay/shared'; import { ConfigService } from '@nestjs/config'; import { CONFIG_KEYS } from '@/config/config.keys'; import { waitForReceiptWithRetry } from '@/common/utils/retry'; @@ -386,7 +390,10 @@ export class RelayerService { this.getChainClient(chainId); const mixerAddress = contractConfig.mixerAddress; - if (!mixerAddress || mixerAddress === '0x0000000000000000000000000000000000000000') { + if ( + !mixerAddress || + mixerAddress === '0x0000000000000000000000000000000000000000' + ) { throw new Error(`Mixer not deployed on chainId ${chainId}`); } diff --git a/packages/nextjs/components/Mixer/DepositTab.tsx b/packages/nextjs/components/Mixer/DepositTab.tsx new file mode 100644 index 0000000..af2a450 --- /dev/null +++ b/packages/nextjs/components/Mixer/DepositTab.tsx @@ -0,0 +1,126 @@ +"use client"; + +import React, { useState } from "react"; +import { PoolStats } from "./PoolStats"; +import { getContractConfigByChainId, getTokenBySymbol } from "@polypay/shared"; +import { useAccount } from "wagmi"; +import { MIXER_DENOMINATIONS, MIXER_SUPPORTED_CHAIN_IDS } from "~~/configs/mixer.config"; +import { useMixerDeposit } from "~~/hooks/app/useMixerDeposit"; +import { notification } from "~~/utils/scaffold-eth"; + +const TOKEN_KEYS = ["ETH", "ZEN", "USDC"] as const; + +export function DepositTab() { + const { chain } = useAccount(); + const chainId = chain?.id ?? MIXER_SUPPORTED_CHAIN_IDS[0]; + const [tokenKey, setTokenKey] = useState<"ETH" | "ZEN" | "USDC">("ETH"); + const [denomination, setDenomination] = useState(MIXER_DENOMINATIONS.ETH[0]); + + const config = getContractConfigByChainId(chainId); + const mixerDeployed = config.mixerAddress && config.mixerAddress !== "0x0000000000000000000000000000000000000000"; + + const resolvedToken = getTokenBySymbol(tokenKey, chainId); + const tokenAddress = resolvedToken?.address ?? "0x0000000000000000000000000000000000000000"; + const denominations = + tokenKey === "ETH" + ? MIXER_DENOMINATIONS.ETH + : tokenKey === "ZEN" + ? MIXER_DENOMINATIONS.ZEN + : MIXER_DENOMINATIONS.USDC; + + const { deposit, isPending, setError, isReady } = useMixerDeposit(); + + const handleDeposit = async () => { + if (!mixerDeployed) { + notification.error("Mixer is not deployed on this network"); + return; + } + setError(null); + try { + const value = tokenKey === "ETH" ? BigInt(denomination) : undefined; + await deposit({ + chainId, + token: tokenAddress, + denomination, + value, + }); + notification.success("Deposit submitted. Confirm in your wallet."); + } catch (e: any) { + notification.error(e?.message ?? "Deposit failed"); + } + }; + + const formatDenom = (d: string, decimals: number) => { + const n = Number(d) / 10 ** decimals; + if (n >= 1) return n.toFixed(0); + return n.toFixed(decimals === 18 ? 4 : 2); + }; + + return ( +
+

+ Deposit from your personal wallet. Your deposit is unlinkable to your withdrawal. +

+ {!MIXER_SUPPORTED_CHAIN_IDS.includes(chainId as any) && ( +

Switch to Horizen testnet or Base Sepolia to use the mixer.

+ )} + {!mixerDeployed && MIXER_SUPPORTED_CHAIN_IDS.includes(chainId as any) && ( +

Mixer contract is not deployed on this network yet.

+ )} + +
+ + +
+ +
+ +
+ {denominations.map(d => ( + + ))} +
+ +
+ + +
+ ); +} diff --git a/packages/nextjs/components/Mixer/MixerContainer.tsx b/packages/nextjs/components/Mixer/MixerContainer.tsx new file mode 100644 index 0000000..7d62689 --- /dev/null +++ b/packages/nextjs/components/Mixer/MixerContainer.tsx @@ -0,0 +1,55 @@ +"use client"; + +import React, { useState } from "react"; +import { DepositTab } from "./DepositTab"; +import { RegisterMixerVk } from "./RegisterMixerVk"; +import { WithdrawTab } from "./WithdrawTab"; + +type TabId = "deposit" | "withdraw"; + +export default function MixerContainer() { + const [activeTab, setActiveTab] = useState("deposit"); + + return ( +
+

Private Transfer (Mixer)

+

+ Deposit from your wallet, then withdraw to a different address. On-chain link between deposit and withdrawal is + broken. +

+ +
+ +
+ +
+ + +
+ +
+ {activeTab === "deposit" ? : } +
+
+ ); +} diff --git a/packages/nextjs/components/Mixer/PoolStats.tsx b/packages/nextjs/components/Mixer/PoolStats.tsx new file mode 100644 index 0000000..f4a657a --- /dev/null +++ b/packages/nextjs/components/Mixer/PoolStats.tsx @@ -0,0 +1,26 @@ +"use client"; + +import { useQuery } from "@tanstack/react-query"; +import { mixerApi } from "~~/services/api/mixerApi"; + +interface PoolStatsProps { + chainId: number; + token: string; + denomination: string; + label?: string; +} + +export function PoolStats({ chainId, token, denomination, label }: PoolStatsProps) { + const { data: count, isLoading } = useQuery({ + queryKey: ["mixer-deposit-count", chainId, token, denomination], + queryFn: () => mixerApi.getDepositCount(chainId, token, denomination), + enabled: !!chainId && !!token && !!denomination, + }); + + if (isLoading) return ...; + return ( + + {label ?? "Anonymity set"}: {count ?? 0} deposit{(count ?? 0) !== 1 ? "s" : ""} + + ); +} diff --git a/packages/nextjs/components/Mixer/RegisterMixerVk.tsx b/packages/nextjs/components/Mixer/RegisterMixerVk.tsx index 07e2192..0807cb7 100644 --- a/packages/nextjs/components/Mixer/RegisterMixerVk.tsx +++ b/packages/nextjs/components/Mixer/RegisterMixerVk.tsx @@ -25,9 +25,7 @@ export function RegisterMixerVk() { return (
-

- Dev: Register Mixer VK (run once before deploy) -

+

Dev: Register Mixer VK (run once before deploy)

)} {error &&

{error}

} diff --git a/packages/nextjs/components/Mixer/WithdrawTab.tsx b/packages/nextjs/components/Mixer/WithdrawTab.tsx new file mode 100644 index 0000000..ff6d835 --- /dev/null +++ b/packages/nextjs/components/Mixer/WithdrawTab.tsx @@ -0,0 +1,216 @@ +"use client"; + +import React, { useState } from "react"; +import { PoolStats } from "./PoolStats"; +import { getContractConfigByChainId, getTokenBySymbol } from "@polypay/shared"; +import { useAccount } from "wagmi"; +import { MIXER_DENOMINATIONS, MIXER_SUPPORTED_CHAIN_IDS } from "~~/configs/mixer.config"; +import { useMyAccounts } from "~~/hooks"; +import type { MixerDepositSlot } from "~~/hooks/app/useMixerKeys"; +import { useMixerWithdraw } from "~~/hooks/app/useMixerWithdraw"; +import { notification } from "~~/utils/scaffold-eth"; + +const TOKEN_KEYS = ["ETH", "ZEN", "USDC"] as const; + +export function WithdrawTab() { + const { chain } = useAccount(); + const chainId = chain?.id ?? MIXER_SUPPORTED_CHAIN_IDS[0]; + const [tokenKey, setTokenKey] = useState<"ETH" | "ZEN" | "USDC">("ETH"); + const [denomination, setDenomination] = useState(MIXER_DENOMINATIONS.ETH[0]); + const [slots, setSlots] = useState([]); + const [loadingSlots, setLoadingSlots] = useState(false); + const [selectedSlot, setSelectedSlot] = useState(null); + const [recipient, setRecipient] = useState(""); + + const config = getContractConfigByChainId(chainId); + const mixerDeployed = config.mixerAddress && config.mixerAddress !== "0x0000000000000000000000000000000000000000"; + const resolvedToken = getTokenBySymbol(tokenKey, chainId); + const tokenAddress = resolvedToken?.address ?? "0x0000000000000000000000000000000000000000"; + const denominations = + tokenKey === "ETH" + ? MIXER_DENOMINATIONS.ETH + : tokenKey === "ZEN" + ? MIXER_DENOMINATIONS.ZEN + : MIXER_DENOMINATIONS.USDC; + + const { data: accounts = [] } = useMyAccounts(); + const { withdraw, getWithdrawableSlots, loadingState, setError, isReady } = useMixerWithdraw(); + + const loadSlots = async () => { + setError(null); + setLoadingSlots(true); + setSlots([]); + setSelectedSlot(null); + try { + const list = await getWithdrawableSlots(chainId, tokenAddress, denomination); + setSlots(list); + if (list.length > 0 && !recipient && accounts.length > 0) { + setRecipient(accounts[0].address ?? ""); + } + } catch (e: any) { + notification.error(e?.message ?? "Failed to load deposits"); + } finally { + setLoadingSlots(false); + } + }; + + const handleWithdraw = async () => { + if (!selectedSlot || !recipient) { + notification.error("Select a deposit and enter recipient"); + return; + } + setError(null); + try { + const result = await withdraw({ + chainId, + token: tokenAddress, + denomination, + recipient, + slot: selectedSlot, + }); + notification.success(`Withdraw successful. Tx: ${result.txHash}`); + setSelectedSlot(null); + setSlots(prev => prev.filter(s => s.leafIndex !== selectedSlot.leafIndex)); + } catch (e: any) { + notification.error(e?.message ?? "Withdraw failed"); + } + }; + + const formatDenom = (d: string, decimals: number) => { + const n = Number(d) / 10 ** decimals; + if (n >= 1) return n.toFixed(0); + return n.toFixed(decimals === 18 ? 4 : 2); + }; + + return ( +
+

+ Withdraw to your multisig (or any address). Relayer submits the transaction so the link is broken. +

+ {!mixerDeployed && MIXER_SUPPORTED_CHAIN_IDS.includes(chainId as any) && ( +

Mixer contract is not deployed on this network yet.

+ )} + +
+ + +
+ +
+ +
+ {denominations.map(d => ( + + ))} +
+ +
+ + + + {slots.length > 0 && ( + <> +
+ + +
+ +
+ + + setRecipient(e.target.value)} + /> +
+ + + + )} + + {slots.length === 0 && !loadingSlots && ( +

+ No withdrawable deposits for this pool, or click "Load my deposits" to scan. +

+ )} +
+ ); +} diff --git a/packages/nextjs/hooks/app/useMerkleTree.ts b/packages/nextjs/hooks/app/useMerkleTree.ts index b0c358b..5f7508f 100644 --- a/packages/nextjs/hooks/app/useMerkleTree.ts +++ b/packages/nextjs/hooks/app/useMerkleTree.ts @@ -9,7 +9,7 @@ import { IncrementalMerkleTree } from "@polypay/shared"; export function useMerkleTree() { const buildTree = useCallback(async (commitmentsHex: string[]) => { const tree = new IncrementalMerkleTree(); - const leaves = commitmentsHex.map((c) => (c.startsWith("0x") ? BigInt(c) : BigInt("0x" + c))); + const leaves = commitmentsHex.map(c => (c.startsWith("0x") ? BigInt(c) : BigInt("0x" + c))); await tree.insertMany(leaves); return tree; }, []); diff --git a/packages/nextjs/hooks/app/useMixerDeposit.ts b/packages/nextjs/hooks/app/useMixerDeposit.ts index 6244e38..8a09dd2 100644 --- a/packages/nextjs/hooks/app/useMixerDeposit.ts +++ b/packages/nextjs/hooks/app/useMixerDeposit.ts @@ -1,10 +1,10 @@ "use client"; import { useCallback, useState } from "react"; -import { getContractConfigByChainId, MIXER_ABI } from "@polypay/shared"; +import { useMixerKeys } from "./useMixerKeys"; +import { MIXER_ABI, getContractConfigByChainId } from "@polypay/shared"; import { useWriteContract } from "wagmi"; import { mixerApi } from "~~/services/api/mixerApi"; -import { useMixerKeys } from "./useMixerKeys"; const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"; @@ -32,12 +32,7 @@ export function useMixerDeposit() { const [error, setError] = useState(null); const deposit = useCallback( - async (params: { - chainId: number; - token: string; - denomination: string; - value?: bigint; - }) => { + async (params: { chainId: number; token: string; denomination: string; value?: bigint }) => { setError(null); const { chainId, token, denomination, value } = params; const config = getContractConfigByChainId(chainId); diff --git a/packages/nextjs/hooks/app/useMixerKeys.ts b/packages/nextjs/hooks/app/useMixerKeys.ts index 68745fc..52bf801 100644 --- a/packages/nextjs/hooks/app/useMixerKeys.ts +++ b/packages/nextjs/hooks/app/useMixerKeys.ts @@ -1,9 +1,9 @@ "use client"; import { useCallback, useState } from "react"; +import { BN254_MODULUS, poseidonHash2 } from "@polypay/shared"; import { keccak256 } from "viem"; import { useWalletClient } from "wagmi"; -import { BN254_MODULUS, poseidonHash2 } from "@polypay/shared"; const MIXER_SECRET_MESSAGE = "polypay-mixer-secret"; @@ -64,7 +64,9 @@ export function useMixerKeys() { const getNextDepositIndex = useCallback( async (commitmentsHex: string[]): Promise<{ n: number; commitment: bigint; nullifier: bigint }> => { const secret = await ensureBaseSecret(); - const set = new Set(commitmentsHex.map((c) => (c.startsWith("0x") ? BigInt(c).toString() : BigInt("0x" + c).toString()))); + const set = new Set( + commitmentsHex.map(c => (c.startsWith("0x") ? BigInt(c).toString() : BigInt("0x" + c).toString())), + ); for (let n = 0; ; n++) { const { commitment, nullifier } = await computeCommitmentAndNullifier(secret, n); const key = commitment.toString(); @@ -78,10 +80,7 @@ export function useMixerKeys() { * Find all n such that commitment_n is in the pool; returns slots with leafIndex from the index list. */ const findMyDeposits = useCallback( - async ( - commitmentsHex: string[], - leafIndices: number[], - ): Promise => { + async (commitmentsHex: string[], leafIndices: number[]): Promise => { if (commitmentsHex.length !== leafIndices.length) return []; const secret = await ensureBaseSecret(); const commitmentToLeafIndex = new Map(); diff --git a/packages/nextjs/hooks/app/useMixerWithdraw.ts b/packages/nextjs/hooks/app/useMixerWithdraw.ts index d6f520b..faa26cf 100644 --- a/packages/nextjs/hooks/app/useMixerWithdraw.ts +++ b/packages/nextjs/hooks/app/useMixerWithdraw.ts @@ -1,12 +1,12 @@ "use client"; import { useCallback, useState } from "react"; -import { getContractConfigByChainId, MIXER_ABI, poseidonHash2 } from "@polypay/shared"; -import { usePublicClient } from "wagmi"; -import { useMixerKeys, type MixerDepositSlot } from "./useMixerKeys"; import { useMerkleTree } from "./useMerkleTree"; +import { type MixerDepositSlot, useMixerKeys } from "./useMixerKeys"; +import { MIXER_ABI, getContractConfigByChainId, poseidonHash2 } from "@polypay/shared"; +import { encodePacked, keccak256 } from "viem"; +import { usePublicClient } from "wagmi"; import { mixerApi } from "~~/services/api/mixerApi"; -import { keccak256, encodePacked } from "viem"; function bigintToHex(v: bigint): string { const hex = v.toString(16).padStart(64, "0"); @@ -39,11 +39,7 @@ export function useMixerWithdraw() { const [error, setError] = useState(null); const getWithdrawableSlots = useCallback( - async ( - chainId: number, - token: string, - denomination: string, - ): Promise => { + async (chainId: number, token: string, denomination: string): Promise => { const config = getContractConfigByChainId(chainId); if (!config.mixerAddress || config.mixerAddress === "0x0000000000000000000000000000000000000000") { return []; @@ -98,8 +94,8 @@ export function useMixerWithdraw() { const circuitInput = { secret: secret.toString(), nullifier: slot.nullifier.toString(), - merkle_path: siblings.map((s) => s.toString()), - path_indices: pathIndices.map((i) => i.toString()), + merkle_path: siblings.map(s => s.toString()), + path_indices: pathIndices.map(i => i.toString()), merkle_root: root.toString(), nullifier_hash: nullifierHash.toString(), recipient: recipientField.toString(), diff --git a/packages/nextjs/hooks/app/useRegisterMixerVk.ts b/packages/nextjs/hooks/app/useRegisterMixerVk.ts index 3da1e4a..f20b759 100644 --- a/packages/nextjs/hooks/app/useRegisterMixerVk.ts +++ b/packages/nextjs/hooks/app/useRegisterMixerVk.ts @@ -42,8 +42,8 @@ export function useRegisterMixerVk() { const circuitInput = { secret: secret.toString(), nullifier: nullifier.toString(), - merkle_path: siblings.map((s) => s.toString()), - path_indices: pathIndices.map((i) => i.toString()), + merkle_path: siblings.map(s => s.toString()), + path_indices: pathIndices.map(i => i.toString()), merkle_root: root.toString(), nullifier_hash: nullifierHash.toString(), recipient: recipientField.toString(), @@ -52,10 +52,7 @@ export function useRegisterMixerVk() { }; setLoadingState("Loading ZK libraries..."); - const [{ Noir }, { UltraPlonkBackend }] = await Promise.all([ - import("@noir-lang/noir_js"), - import("@aztec/bb.js"), - ]); + const [{ Noir }, { UltraPlonkBackend }] = await Promise.all([import("@noir-lang/noir_js"), import("@aztec/bb.js")]); setLoadingState("Executing circuit..."); const noir = new Noir({ bytecode, abi } as any); diff --git a/packages/nextjs/services/api/mixerApi.ts b/packages/nextjs/services/api/mixerApi.ts index 8054150..a8dc9c5 100644 --- a/packages/nextjs/services/api/mixerApi.ts +++ b/packages/nextjs/services/api/mixerApi.ts @@ -1,10 +1,5 @@ import { apiClient } from "./apiClient"; -import { - API_ENDPOINTS, - MixerDepositsParams, - MixerDepositsResponse, - MixerWithdrawParams, -} from "@polypay/shared"; +import { API_ENDPOINTS, MixerDepositsParams, MixerDepositsResponse, MixerWithdrawParams } from "@polypay/shared"; export const mixerApi = { getDeposits: async (params: MixerDepositsParams): Promise => { @@ -14,42 +9,28 @@ export const mixerApi = { search.set("denomination", params.denomination); if (params.fromLeaf !== undefined) search.set("fromLeaf", String(params.fromLeaf)); if (params.toLeaf !== undefined) search.set("toLeaf", String(params.toLeaf)); - const { data } = await apiClient.get( - `${API_ENDPOINTS.mixer.deposits}?${search.toString()}`, - ); + const { data } = await apiClient.get(`${API_ENDPOINTS.mixer.deposits}?${search.toString()}`); return data; }, - getDepositCount: async ( - chainId: number, - token: string, - denomination: string, - ): Promise => { + getDepositCount: async (chainId: number, token: string, denomination: string): Promise => { const search = new URLSearchParams({ chainId: String(chainId), token, denomination, }); - const { data } = await apiClient.get( - `${API_ENDPOINTS.mixer.depositCount}?${search.toString()}`, - ); + const { data } = await apiClient.get(`${API_ENDPOINTS.mixer.depositCount}?${search.toString()}`); return data; }, withdraw: async (params: MixerWithdrawParams): Promise<{ txHash: string; status: string }> => { - const { data } = await apiClient.post<{ txHash: string; status: string }>( - API_ENDPOINTS.mixer.withdraw, - params, - ); + const { data } = await apiClient.post<{ txHash: string; status: string }>(API_ENDPOINTS.mixer.withdraw, params); return data; }, // TODO: remove this endpoint registerVk: async (vk: string): Promise<{ vkHash: string }> => { - const { data } = await apiClient.post<{ vkHash: string }>( - API_ENDPOINTS.mixer.registerVk, - { vk }, - ); + const { data } = await apiClient.post<{ vkHash: string }>(API_ENDPOINTS.mixer.registerVk, { vk }); return data; }, }; diff --git a/packages/shared/src/dto/mixer/index.ts b/packages/shared/src/dto/mixer/index.ts index c622a3f..748992b 100644 --- a/packages/shared/src/dto/mixer/index.ts +++ b/packages/shared/src/dto/mixer/index.ts @@ -1,2 +1 @@ export * from "./withdraw.dto"; - diff --git a/packages/shared/src/dto/mixer/withdraw.dto.ts b/packages/shared/src/dto/mixer/withdraw.dto.ts index b818502..f6c85f1 100644 --- a/packages/shared/src/dto/mixer/withdraw.dto.ts +++ b/packages/shared/src/dto/mixer/withdraw.dto.ts @@ -1,5 +1,11 @@ -import { IsArray, IsNumber, IsOptional, IsString, Min } from "class-validator"; -import { Type } from "class-transformer"; +import { + IsArray, + IsNumber, + IsNumberString, + IsOptional, + IsString, + Min, +} from "class-validator"; export class MixerWithdrawDto { @IsNumber() @@ -40,7 +46,7 @@ export class RegisterVkDto { } export class MixerDepositsQueryDto { - @IsNumber() + @IsNumberString() chainId: number; @IsString() @@ -50,15 +56,12 @@ export class MixerDepositsQueryDto { denomination: string; @IsOptional() - @Type(() => Number) @IsNumber() @Min(0) fromLeaf?: number; @IsOptional() - @Type(() => Number) @IsNumber() @Min(0) toLeaf?: number; } - diff --git a/packages/shared/src/types/mixer.ts b/packages/shared/src/types/mixer.ts index f88fdda..062f034 100644 --- a/packages/shared/src/types/mixer.ts +++ b/packages/shared/src/types/mixer.ts @@ -22,4 +22,3 @@ export interface MixerWithdrawParams { publicInputs: string[]; vk?: string; } - From 326175a50545d73c8204f0d6385a2ae945251e48 Mon Sep 17 00:00:00 2001 From: BoHsuu Date: Wed, 11 Mar 2026 09:29:52 +0700 Subject: [PATCH 14/18] feat: enhance WithdrawTab and hooks for improved commitment handling - Added state management for cached commitments in `WithdrawTab` to optimize withdrawal processes. - Updated `getWithdrawableSlots` in `useMixerWithdraw` to return commitments alongside slots, reducing redundant API calls. - Refactored `useMixerKeys` to utilize refs for base secret management, improving performance during concurrent calls. - Adjusted `useMixerWithdraw` to accept commitments as parameters, streamlining the withdrawal flow. --- .../nextjs/components/Mixer/WithdrawTab.tsx | 8 +++- packages/nextjs/hooks/app/useMixerDeposit.ts | 1 - packages/nextjs/hooks/app/useMixerKeys.ts | 43 +++++++++++-------- packages/nextjs/hooks/app/useMixerWithdraw.ts | 24 ++++++----- 4 files changed, 47 insertions(+), 29 deletions(-) diff --git a/packages/nextjs/components/Mixer/WithdrawTab.tsx b/packages/nextjs/components/Mixer/WithdrawTab.tsx index ff6d835..bd81789 100644 --- a/packages/nextjs/components/Mixer/WithdrawTab.tsx +++ b/packages/nextjs/components/Mixer/WithdrawTab.tsx @@ -18,6 +18,7 @@ export function WithdrawTab() { const [tokenKey, setTokenKey] = useState<"ETH" | "ZEN" | "USDC">("ETH"); const [denomination, setDenomination] = useState(MIXER_DENOMINATIONS.ETH[0]); const [slots, setSlots] = useState([]); + const [cachedCommitments, setCachedCommitments] = useState([]); const [loadingSlots, setLoadingSlots] = useState(false); const [selectedSlot, setSelectedSlot] = useState(null); const [recipient, setRecipient] = useState(""); @@ -40,10 +41,12 @@ export function WithdrawTab() { setError(null); setLoadingSlots(true); setSlots([]); + setCachedCommitments([]); setSelectedSlot(null); try { - const list = await getWithdrawableSlots(chainId, tokenAddress, denomination); + const { slots: list, commitments } = await getWithdrawableSlots(chainId, tokenAddress, denomination); setSlots(list); + setCachedCommitments(commitments); if (list.length > 0 && !recipient && accounts.length > 0) { setRecipient(accounts[0].address ?? ""); } @@ -67,6 +70,7 @@ export function WithdrawTab() { denomination, recipient, slot: selectedSlot, + commitments: cachedCommitments.length > 0 ? cachedCommitments : undefined, }); notification.success(`Withdraw successful. Tx: ${result.txHash}`); setSelectedSlot(null); @@ -106,6 +110,7 @@ export function WithdrawTab() { : MIXER_DENOMINATIONS.USDC; setDenomination(denoms[0]); setSlots([]); + setCachedCommitments([]); setSelectedSlot(null); }} > @@ -132,6 +137,7 @@ export function WithdrawTab() { onClick={() => { setDenomination(d); setSlots([]); + setCachedCommitments([]); setSelectedSlot(null); }} > diff --git a/packages/nextjs/hooks/app/useMixerDeposit.ts b/packages/nextjs/hooks/app/useMixerDeposit.ts index 8a09dd2..7abee5c 100644 --- a/packages/nextjs/hooks/app/useMixerDeposit.ts +++ b/packages/nextjs/hooks/app/useMixerDeposit.ts @@ -40,7 +40,6 @@ export function useMixerDeposit() { if (!mixerAddress || mixerAddress === "0x0000000000000000000000000000000000000000") { throw new Error("Mixer is not deployed on this network"); } - await ensureBaseSecret(); const { commitments } = await mixerApi.getDeposits({ chainId, token, denomination }); const { commitment } = await getNextDepositIndex(commitments); const commitmentHex = bigintToBytes32Hex(commitment); diff --git a/packages/nextjs/hooks/app/useMixerKeys.ts b/packages/nextjs/hooks/app/useMixerKeys.ts index 52bf801..fa92939 100644 --- a/packages/nextjs/hooks/app/useMixerKeys.ts +++ b/packages/nextjs/hooks/app/useMixerKeys.ts @@ -1,6 +1,6 @@ "use client"; -import { useCallback, useState } from "react"; +import { useCallback, useRef, useState } from "react"; import { BN254_MODULUS, poseidonHash2 } from "@polypay/shared"; import { keccak256 } from "viem"; import { useWalletClient } from "wagmi"; @@ -16,7 +16,10 @@ export interface MixerDepositSlot { export function useMixerKeys() { const { data: walletClient } = useWalletClient(); - const [baseSecret, setBaseSecret] = useState(null); + // Use ref instead of state to avoid stale closure issues when called multiple times + // within the same async execution (e.g., deposit flow). + const baseSecretRef = useRef(null); + const pendingSecretRef = useRef | null>(null); const [isLoading, setIsLoading] = useState(false); const [error, setError] = useState(null); @@ -33,21 +36,27 @@ export function useMixerKeys() { }, [walletClient]); const ensureBaseSecret = useCallback(async (): Promise => { - if (baseSecret !== null) return baseSecret; + if (baseSecretRef.current !== null) return baseSecretRef.current; + // Deduplicate concurrent calls — only one sign request in flight at a time. + if (pendingSecretRef.current !== null) return pendingSecretRef.current; setIsLoading(true); setError(null); - try { - const secret = await deriveBaseSecret(); - setBaseSecret(secret); - return secret; - } catch (e) { - const msg = e instanceof Error ? e.message : "Failed to derive mixer secret"; - setError(msg); - throw e; - } finally { - setIsLoading(false); - } - }, [baseSecret, deriveBaseSecret]); + const promise = deriveBaseSecret() + .then(secret => { + baseSecretRef.current = secret; + pendingSecretRef.current = null; + return secret; + }) + .catch(e => { + pendingSecretRef.current = null; + const msg = e instanceof Error ? e.message : "Failed to derive mixer secret"; + setError(msg); + throw e; + }) + .finally(() => setIsLoading(false)); + pendingSecretRef.current = promise; + return promise; + }, [deriveBaseSecret]); const computeCommitmentAndNullifier = useCallback( async (secret: bigint, n: number): Promise<{ commitment: bigint; nullifier: bigint }> => { @@ -104,7 +113,8 @@ export function useMixerKeys() { ); const reset = useCallback(() => { - setBaseSecret(null); + baseSecretRef.current = null; + pendingSecretRef.current = null; setError(null); }, []); @@ -113,7 +123,6 @@ export function useMixerKeys() { getNextDepositIndex, findMyDeposits, deriveBaseSecret, - baseSecret, isLoading, error, reset, diff --git a/packages/nextjs/hooks/app/useMixerWithdraw.ts b/packages/nextjs/hooks/app/useMixerWithdraw.ts index faa26cf..26fff48 100644 --- a/packages/nextjs/hooks/app/useMixerWithdraw.ts +++ b/packages/nextjs/hooks/app/useMixerWithdraw.ts @@ -19,6 +19,8 @@ export interface MixerWithdrawParams { denomination: string; recipient: string; slot: MixerDepositSlot; + /** Pass commitments from a previous getWithdrawableSlots call to avoid double fetch */ + commitments?: string[]; } function getPoolId(token: string, denomination: string): `0x${string}` { @@ -39,12 +41,16 @@ export function useMixerWithdraw() { const [error, setError] = useState(null); const getWithdrawableSlots = useCallback( - async (chainId: number, token: string, denomination: string): Promise => { + async ( + chainId: number, + token: string, + denomination: string, + ): Promise<{ slots: MixerDepositSlot[]; commitments: string[] }> => { const config = getContractConfigByChainId(chainId); if (!config.mixerAddress || config.mixerAddress === "0x0000000000000000000000000000000000000000") { - return []; + return { slots: [], commitments: [] }; } - if (!publicClient) return []; + if (!publicClient) return { slots: [], commitments: [] }; const { commitments, leafIndices } = await mixerApi.getDeposits({ chainId, token, @@ -63,7 +69,7 @@ export function useMixerWithdraw() { }); if (!used) withdrawable.push(slot); } - return withdrawable; + return { slots: withdrawable, commitments }; }, [publicClient, findMyDeposits], ); @@ -77,14 +83,12 @@ export function useMixerWithdraw() { const secret = await ensureBaseSecret(); setLoadingState("Fetching deposits..."); - const { commitments, leafIndices } = await mixerApi.getDeposits({ - chainId, - token, - denomination, - }); + const resolvedCommitments = + params.commitments ?? + (await mixerApi.getDeposits({ chainId, token, denomination })).commitments; setLoadingState("Building Merkle path..."); - const { root, siblings, pathIndices } = await getRootAndPath(commitments, slot.leafIndex); + const { root, siblings, pathIndices } = await getRootAndPath(resolvedCommitments, slot.leafIndex); const nullifierHash = await poseidonHash2(slot.nullifier, slot.nullifier); const recipientField = BigInt(recipient); From ea324aee3885b035044c4b8e2eedd0f531e26341 Mon Sep 17 00:00:00 2001 From: BoHsuu Date: Wed, 11 Mar 2026 13:11:12 +0700 Subject: [PATCH 15/18] add debug function --- packages/backend/src/mixer/mixer.service.ts | 130 ++++++++++++++++-- packages/nextjs/hooks/app/useMixerWithdraw.ts | 10 +- 2 files changed, 121 insertions(+), 19 deletions(-) diff --git a/packages/backend/src/mixer/mixer.service.ts b/packages/backend/src/mixer/mixer.service.ts index 388c5fa..2bc1419 100644 --- a/packages/backend/src/mixer/mixer.service.ts +++ b/packages/backend/src/mixer/mixer.service.ts @@ -1,5 +1,6 @@ import { Injectable, Logger, BadRequestException } from '@nestjs/common'; -import { keccak256, encodePacked } from 'viem'; +import { keccak256, encodePacked, sha256, toHex } from 'viem'; +import { getContractConfigByChainId } from '@polypay/shared'; import { PrismaService } from '@/database/prisma.service'; import { ZkVerifyService } from '@/zkverify/zkverify.service'; import { RelayerService } from '@/relayer-wallet/relayer-wallet.service'; @@ -65,23 +66,30 @@ export class MixerService { throw new BadRequestException('MIXER_AGGREGATION_TIMEOUT'); } + // TODO: remove later const { aggregationId, aggregationDetails } = aggregationResult; const domainId = getDomainId(chainId); - const txHash = await this.relayerService.executeMixerWithdraw( + const proofArgs = { + aggregationId: String(aggregationId), + domainId, + zkMerklePath: aggregationDetails.merkleProof || [], + leafCount: aggregationDetails.numberOfLeaves ?? 0, + index: aggregationDetails.leafIndex ?? 0, + }; + + this.logger.log( + `Mixer aggregation ready. aggregationId=${aggregationId}, domainId=${domainId}. Waiting for on-chain availability...`, + ); + + const txHash = await this.executeWithRetry( chainId, token, denomination, recipient, nullifierHash, root, - { - aggregationId: String(aggregationId), - domainId, - zkMerklePath: aggregationDetails.merkleProof || [], - leafCount: aggregationDetails.numberOfLeaves ?? 0, - index: aggregationDetails.leafIndex ?? 0, - }, + proofArgs, ); this.logger.log(`Mixer withdraw executed: txHash=${txHash}`); @@ -92,7 +100,9 @@ export class MixerService { jobId: string, maxAttempts = MIXER_AGGREGATION_MAX_ATTEMPTS, intervalMs = MIXER_AGGREGATION_INTERVAL_MS, - ): Promise<{ aggregationId?: number; aggregationDetails?: any } | null> { + ): Promise< + { aggregationId?: number; aggregationDetails?: any; updatedAt?: string } | null + > { for (let attempt = 0; attempt < maxAttempts; attempt++) { try { const jobStatus = await this.zkVerifyService.getJobStatus(jobId); @@ -100,6 +110,7 @@ export class MixerService { return { aggregationId: jobStatus.aggregationId, aggregationDetails: jobStatus.aggregationDetails, + updatedAt: jobStatus.updatedAt as string | undefined, }; } if (jobStatus.status === 'Failed') { @@ -116,6 +127,105 @@ export class MixerService { return null; } + // TODO: remove this method + private async executeWithRetry( + chainId: number, + token: string, + denomination: string, + recipient: string, + nullifierHash: string, + root: string, + proofArgs: { + aggregationId: string; + domainId: number; + zkMerklePath: string[]; + leafCount: number; + index: number; + }, + maxRetries = 20, + retryIntervalMs = 30_000, + ): Promise { + for (let attempt = 1; attempt <= maxRetries; attempt++) { + try { + this.logger.log( + `executeMixerWithdraw attempt ${attempt}/${maxRetries}...`, + ); + return await this.relayerService.executeMixerWithdraw( + chainId, + token, + denomination, + recipient, + nullifierHash, + root, + proofArgs, + ); + } catch (err: any) { + const isInvalidProof = + err?.message?.includes('Invalid proof') || + err?.message?.includes('reverted'); + + if (isInvalidProof && attempt < maxRetries) { + this.logger.log( + `Attempt ${attempt} failed (on-chain batch not ready yet). Retrying in ${retryIntervalMs / 1000}s...`, + ); + await this.sleep(retryIntervalMs); + } else { + throw err; + } + } + } + throw new BadRequestException('MIXER_EXECUTE_TIMEOUT'); + } + + private debugLeafComparison( + chainId: number, + root: string, + nullifierHash: string, + recipient: string, + token: string, + denomination: string, + aggregationDetails: any, + ): void { + try { + const config = getContractConfigByChainId(chainId); + const vkHash = config.mixerVkHash as `0x${string}`; + + const PROVING_SYSTEM_ID = keccak256(toHex('ultraplonk')); + const VERSION_HASH = sha256(toHex('')); + + const encodedInputs = encodePacked( + ['bytes32', 'bytes32', 'uint256', 'uint256', 'uint256'], + [ + root as `0x${string}`, + nullifierHash as `0x${string}`, + BigInt(recipient), + BigInt(token), + BigInt(denomination), + ], + ); + const inputsHash = keccak256(encodedInputs); + const computedLeaf = keccak256( + encodePacked( + ['bytes32', 'bytes32', 'bytes32', 'bytes32'], + [PROVING_SYSTEM_ID, vkHash, VERSION_HASH, inputsHash], + ), + ); + + this.logger.log(`=== LEAF DEBUG ===`); + this.logger.log(`vkHash used: ${vkHash}`); + this.logger.log(`PROVING_SYSTEM_ID: ${PROVING_SYSTEM_ID}`); + this.logger.log(`VERSION_HASH: ${VERSION_HASH}`); + this.logger.log(`encodedInputs hash: ${inputsHash}`); + this.logger.log(`Kurier leaf: ${aggregationDetails?.leaf ?? 'N/A'}`); + this.logger.log(`Contract leaf: ${computedLeaf}`); + this.logger.log( + `Leaf match: ${aggregationDetails?.leaf === computedLeaf}`, + ); + } catch (e: any) { + this.logger.warn(`debugLeafComparison error: ${e?.message}`); + } + } + private sleep(ms: number): Promise { return new Promise((resolve) => setTimeout(resolve, ms)); } diff --git a/packages/nextjs/hooks/app/useMixerWithdraw.ts b/packages/nextjs/hooks/app/useMixerWithdraw.ts index 26fff48..495e630 100644 --- a/packages/nextjs/hooks/app/useMixerWithdraw.ts +++ b/packages/nextjs/hooks/app/useMixerWithdraw.ts @@ -126,14 +126,6 @@ export function useMixerWithdraw() { const { proof, publicInputs } = await plonk.generateProof(execResult.witness); const vk = await plonk.getVerificationKey(); - const publicInputsHex = [ - bigintToHex(root), - bigintToHex(nullifierHash), - bigintToHex(recipientField), - bigintToHex(tokenField), - bigintToHex(denomField), - ]; - setLoadingState("Submitting withdraw..."); const result = await mixerApi.withdraw({ chainId, @@ -143,7 +135,7 @@ export function useMixerWithdraw() { nullifierHash: bigintToHex(nullifierHash), root: bigintToHex(root), proof: Array.from(proof), - publicInputs: publicInputsHex, + publicInputs, vk: Buffer.from(vk).toString("base64"), }); From dcbbe82d1e7e6d7cc0987fb41968bf8120202242 Mon Sep 17 00:00:00 2001 From: BoHsuu Date: Fri, 13 Mar 2026 16:13:00 +0700 Subject: [PATCH 16/18] Fix invalid proof error and add model to save Aggregation data of Mixer --- .../migration.sql | 38 ++++++- packages/backend/prisma/schema.prisma | 32 ++++++ packages/backend/src/mixer/mixer.service.ts | 102 ++++++++---------- .../deployments/baseSepolia/Mixer.json | 20 ++-- .../deployments/horizenTestnet/Mixer.json | 20 ++-- .../nextjs/contracts/deployedContracts.ts | 8 +- .../shared/src/contracts/contracts-config.ts | 8 +- 7 files changed, 140 insertions(+), 88 deletions(-) rename packages/backend/prisma/migrations/{20260309000000_add_mixer_deposit_and_indexer_state => 20260313084414_mixer_model}/migration.sql (53%) diff --git a/packages/backend/prisma/migrations/20260309000000_add_mixer_deposit_and_indexer_state/migration.sql b/packages/backend/prisma/migrations/20260313084414_mixer_model/migration.sql similarity index 53% rename from packages/backend/prisma/migrations/20260309000000_add_mixer_deposit_and_indexer_state/migration.sql rename to packages/backend/prisma/migrations/20260313084414_mixer_model/migration.sql index 7d2affa..d1f158b 100644 --- a/packages/backend/prisma/migrations/20260309000000_add_mixer_deposit_and_indexer_state/migration.sql +++ b/packages/backend/prisma/migrations/20260313084414_mixer_model/migration.sql @@ -1,3 +1,6 @@ +-- CreateEnum +CREATE TYPE "MixerWithdrawStatus" AS ENUM ('PENDING', 'AGGREGATED', 'EXECUTED', 'FAILED'); + -- CreateTable CREATE TABLE "mixer_deposits" ( "id" TEXT NOT NULL, @@ -24,8 +27,30 @@ CREATE TABLE "mixer_indexer_state" ( CONSTRAINT "mixer_indexer_state_pkey" PRIMARY KEY ("id") ); --- CreateIndex -CREATE UNIQUE INDEX "mixer_deposits_chain_id_pool_id_leaf_index_key" ON "mixer_deposits"("chain_id", "pool_id", "leaf_index"); +-- CreateTable +CREATE TABLE "mixer_withdraw_requests" ( + "id" TEXT NOT NULL, + "job_id" TEXT NOT NULL, + "chain_id" INTEGER NOT NULL, + "token" TEXT NOT NULL, + "denomination" TEXT NOT NULL, + "recipient" TEXT NOT NULL, + "nullifier_hash" TEXT NOT NULL, + "root" TEXT NOT NULL, + "status" "MixerWithdrawStatus" NOT NULL DEFAULT 'PENDING', + "zkverify_tx_hash" TEXT, + "aggregation_id" TEXT, + "domain_id" INTEGER, + "merkle_proof" TEXT[], + "leaf_index" INTEGER, + "leaf_count" INTEGER, + "tx_hash" TEXT, + "error_message" TEXT, + "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + "updated_at" TIMESTAMP(3) NOT NULL, + + CONSTRAINT "mixer_withdraw_requests_pkey" PRIMARY KEY ("id") +); -- CreateIndex CREATE INDEX "mixer_deposits_chain_id_pool_id_idx" ON "mixer_deposits"("chain_id", "pool_id"); @@ -33,5 +58,14 @@ CREATE INDEX "mixer_deposits_chain_id_pool_id_idx" ON "mixer_deposits"("chain_id -- CreateIndex CREATE INDEX "mixer_deposits_chain_id_pool_id_leaf_index_idx" ON "mixer_deposits"("chain_id", "pool_id", "leaf_index"); +-- CreateIndex +CREATE UNIQUE INDEX "mixer_deposits_chain_id_pool_id_leaf_index_key" ON "mixer_deposits"("chain_id", "pool_id", "leaf_index"); + -- CreateIndex CREATE UNIQUE INDEX "mixer_indexer_state_chain_id_key" ON "mixer_indexer_state"("chain_id"); + +-- CreateIndex +CREATE UNIQUE INDEX "mixer_withdraw_requests_job_id_key" ON "mixer_withdraw_requests"("job_id"); + +-- CreateIndex +CREATE INDEX "mixer_withdraw_requests_status_idx" ON "mixer_withdraw_requests"("status"); diff --git a/packages/backend/prisma/schema.prisma b/packages/backend/prisma/schema.prisma index a0168e9..400dec3 100644 --- a/packages/backend/prisma/schema.prisma +++ b/packages/backend/prisma/schema.prisma @@ -341,3 +341,35 @@ model MixerIndexerState { @@map("mixer_indexer_state") } + +model MixerWithdrawRequest { + id String @id @default(cuid()) + jobId String @unique @map("job_id") + chainId Int @map("chain_id") + token String + denomination String + recipient String + nullifierHash String @map("nullifier_hash") + root String + status MixerWithdrawStatus @default(PENDING) + zkVerifyTxHash String? @map("zkverify_tx_hash") + aggregationId String? @map("aggregation_id") + domainId Int? @map("domain_id") + merkleProof String[] @map("merkle_proof") + leafIndex Int? @map("leaf_index") + leafCount Int? @map("leaf_count") + txHash String? @map("tx_hash") + errorMessage String? @map("error_message") + createdAt DateTime @default(now()) @map("created_at") + updatedAt DateTime @updatedAt @map("updated_at") + + @@index([status]) + @@map("mixer_withdraw_requests") +} + +enum MixerWithdrawStatus { + PENDING + AGGREGATED + EXECUTED + FAILED +} diff --git a/packages/backend/src/mixer/mixer.service.ts b/packages/backend/src/mixer/mixer.service.ts index 2bc1419..d0771ab 100644 --- a/packages/backend/src/mixer/mixer.service.ts +++ b/packages/backend/src/mixer/mixer.service.ts @@ -1,14 +1,15 @@ import { Injectable, Logger, BadRequestException } from '@nestjs/common'; -import { keccak256, encodePacked, sha256, toHex } from 'viem'; -import { getContractConfigByChainId } from '@polypay/shared'; +import { keccak256, encodePacked } from 'viem'; import { PrismaService } from '@/database/prisma.service'; import { ZkVerifyService } from '@/zkverify/zkverify.service'; import { RelayerService } from '@/relayer-wallet/relayer-wallet.service'; import { getDomainId } from '@/common/utils/proof'; import { MixerDepositsQueryDto, MixerWithdrawDto } from '@polypay/shared'; +import { MixerWithdrawStatus } from '@/generated/prisma/client'; const MIXER_AGGREGATION_MAX_ATTEMPTS = 30; const MIXER_AGGREGATION_INTERVAL_MS = 10000; +const MIXER_FINALIZATION_WAIT_MS = 40000; @Injectable() export class MixerService { @@ -50,7 +51,7 @@ export class MixerService { `Submitting mixer proof for chainId=${chainId}, recipient=${recipient}`, ); - const { jobId, status: submitStatus } = + const { jobId, status: submitStatus, txHash: zkVerifyTxHash } = await this.zkVerifyService.submitProofAndWaitFinalized( { proof, publicInputs, vk: dto.vk }, 'mixer', @@ -61,26 +62,56 @@ export class MixerService { throw new BadRequestException('Proof submission failed'); } + const request = await this.prisma.mixerWithdrawRequest.create({ + data: { + jobId, + chainId, + token, + denomination, + recipient, + nullifierHash, + root, + status: MixerWithdrawStatus.PENDING, + zkVerifyTxHash: zkVerifyTxHash ?? null, + merkleProof: [], + }, + }); + const aggregationResult = await this.pollForAggregation(jobId); if (!aggregationResult) { + await this.prisma.mixerWithdrawRequest.update({ + where: { id: request.id }, + data: { status: MixerWithdrawStatus.FAILED, errorMessage: 'MIXER_AGGREGATION_TIMEOUT' }, + }); throw new BadRequestException('MIXER_AGGREGATION_TIMEOUT'); } - // TODO: remove later const { aggregationId, aggregationDetails } = aggregationResult; const domainId = getDomainId(chainId); + await this.prisma.mixerWithdrawRequest.update({ + where: { id: request.id }, + data: { + status: MixerWithdrawStatus.AGGREGATED, + aggregationId: String(aggregationId), + domainId, + merkleProof: aggregationDetails?.merkleProof ?? [], + leafIndex: aggregationDetails?.leafIndex ?? null, + leafCount: aggregationDetails?.numberOfLeaves ?? null, + }, + }); const proofArgs = { aggregationId: String(aggregationId), domainId, - zkMerklePath: aggregationDetails.merkleProof || [], - leafCount: aggregationDetails.numberOfLeaves ?? 0, - index: aggregationDetails.leafIndex ?? 0, + zkMerklePath: aggregationDetails?.merkleProof ?? [], + leafCount: aggregationDetails?.numberOfLeaves ?? 0, + index: aggregationDetails?.leafIndex ?? 0, }; this.logger.log( - `Mixer aggregation ready. aggregationId=${aggregationId}, domainId=${domainId}. Waiting for on-chain availability...`, + `Mixer aggregation ready. Waiting ${MIXER_FINALIZATION_WAIT_MS / 1000}s before execute...`, ); + await this.sleep(MIXER_FINALIZATION_WAIT_MS); const txHash = await this.executeWithRetry( chainId, @@ -92,6 +123,11 @@ export class MixerService { proofArgs, ); + await this.prisma.mixerWithdrawRequest.update({ + where: { id: request.id }, + data: { status: MixerWithdrawStatus.EXECUTED, txHash }, + }); + this.logger.log(`Mixer withdraw executed: txHash=${txHash}`); return { txHash, status: 'success' }; } @@ -127,7 +163,6 @@ export class MixerService { return null; } - // TODO: remove this method private async executeWithRetry( chainId: number, token: string, @@ -177,55 +212,6 @@ export class MixerService { throw new BadRequestException('MIXER_EXECUTE_TIMEOUT'); } - private debugLeafComparison( - chainId: number, - root: string, - nullifierHash: string, - recipient: string, - token: string, - denomination: string, - aggregationDetails: any, - ): void { - try { - const config = getContractConfigByChainId(chainId); - const vkHash = config.mixerVkHash as `0x${string}`; - - const PROVING_SYSTEM_ID = keccak256(toHex('ultraplonk')); - const VERSION_HASH = sha256(toHex('')); - - const encodedInputs = encodePacked( - ['bytes32', 'bytes32', 'uint256', 'uint256', 'uint256'], - [ - root as `0x${string}`, - nullifierHash as `0x${string}`, - BigInt(recipient), - BigInt(token), - BigInt(denomination), - ], - ); - const inputsHash = keccak256(encodedInputs); - const computedLeaf = keccak256( - encodePacked( - ['bytes32', 'bytes32', 'bytes32', 'bytes32'], - [PROVING_SYSTEM_ID, vkHash, VERSION_HASH, inputsHash], - ), - ); - - this.logger.log(`=== LEAF DEBUG ===`); - this.logger.log(`vkHash used: ${vkHash}`); - this.logger.log(`PROVING_SYSTEM_ID: ${PROVING_SYSTEM_ID}`); - this.logger.log(`VERSION_HASH: ${VERSION_HASH}`); - this.logger.log(`encodedInputs hash: ${inputsHash}`); - this.logger.log(`Kurier leaf: ${aggregationDetails?.leaf ?? 'N/A'}`); - this.logger.log(`Contract leaf: ${computedLeaf}`); - this.logger.log( - `Leaf match: ${aggregationDetails?.leaf === computedLeaf}`, - ); - } catch (e: any) { - this.logger.warn(`debugLeafComparison error: ${e?.message}`); - } - } - private sleep(ms: number): Promise { return new Promise((resolve) => setTimeout(resolve, ms)); } diff --git a/packages/hardhat/deployments/baseSepolia/Mixer.json b/packages/hardhat/deployments/baseSepolia/Mixer.json index 0f87a1e..6fd24b4 100644 --- a/packages/hardhat/deployments/baseSepolia/Mixer.json +++ b/packages/hardhat/deployments/baseSepolia/Mixer.json @@ -1,5 +1,5 @@ { - "address": "0xd9E9103693014b00db0Bf262b65CB2226062e732", + "address": "0xE146bA86fef4056566D7EE9dBB9fFaCf8A994AC2", "abi": [ { "inputs": [ @@ -490,25 +490,25 @@ "type": "receive" } ], - "transactionHash": "0x9e9ab6adf72b1fc19b10b611e747fa5ea68f3194d1072c4d2285267f6b63740b", + "transactionHash": "0x8300ac3ea5442848bfa8daada542f53425c84934d2f0f1c39a482bc0d6d1b3c3", "receipt": { "to": null, "from": "0xd95E85e86D3Be5C86846435b8F0C3a476C5a9e42", - "contractAddress": "0xd9E9103693014b00db0Bf262b65CB2226062e732", - "transactionIndex": 12, - "gasUsed": "2329270", + "contractAddress": "0xE146bA86fef4056566D7EE9dBB9fFaCf8A994AC2", + "transactionIndex": 13, + "gasUsed": "2329642", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000", - "transactionHash": "0x9e9ab6adf72b1fc19b10b611e747fa5ea68f3194d1072c4d2285267f6b63740b", + "transactionHash": "0x8300ac3ea5442848bfa8daada542f53425c84934d2f0f1c39a482bc0d6d1b3c3", "logs": [], - "blockNumber": 38675302, - "cumulativeGasUsed": "2785031", + "blockNumber": 38809306, + "cumulativeGasUsed": "4370092", "status": 1, "byzantium": true }, "args": [ "0x0807C544D38aE7729f8798388d89Be6502A1e8A8", - "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x29236cc027580a6be3e581d9625a48710d39eb92e2c68e7b5e42841d11affe00", [ "0xe904c2b027ada6080c203c94ae7a6948682023cdbf53aef00dbc800ef97a132e", "0x73a9f33d373b966d8ef30721adda93c14785f3be5d60a65981b922edad5917c6", @@ -525,7 +525,7 @@ "0x16e60ccd514ceaa2e7a82e076aede6d01181e7422b479ed39cfc5d0ce6e11e0a" ] ], - "numDeployments": 1, + "numDeployments": 2, "solcInputHash": "7f0373dedc61097daaf6a7dfc1f19d7a", "metadata": "{\"compiler\":{\"version\":\"0.8.20+commit.a1b79de6\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zkvContract\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"_vkHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[]\",\"name\":\"_allowedPoolIds\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"AddressEmptyCode\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"AddressInsufficientBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedInnerCall\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrancyGuardReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"commitment\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"leafIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"denomination\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"nullifierHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"denomination\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"BN254_PRIME\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PROVING_SYSTEM_ID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ROOT_HISTORY_SIZE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"TREE_DEPTH\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"VERSION_HASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"allowedDenominations\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"commitmentUsed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"denomination\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"commitment\",\"type\":\"bytes32\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"level\",\"type\":\"uint256\"}],\"name\":\"getZeroHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"poolId\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"root\",\"type\":\"bytes32\"}],\"name\":\"isKnownRoot\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"nullifierUsed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"rootHistory\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"rootHistoryIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"trees\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"nextIndex\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"vkHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"denomination\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"nullifierHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"root\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"aggregationId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"domainId\",\"type\":\"uint256\"},{\"internalType\":\"bytes32[]\",\"name\":\"zkMerklePath\",\"type\":\"bytes32[]\"},{\"internalType\":\"uint256\",\"name\":\"leafCount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"internalType\":\"struct Mixer.MixerProof\",\"name\":\"proof\",\"type\":\"tuple\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zkvContract\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"errors\":{\"AddressEmptyCode(address)\":[{\"details\":\"There's no code at `target` (it is not a contract).\"}],\"AddressInsufficientBalance(address)\":[{\"details\":\"The ETH balance of the account is not enough to perform the operation.\"}],\"FailedInnerCall()\":[{\"details\":\"A call to an address target failed. The target may have reverted.\"}],\"ReentrancyGuardReentrantCall()\":[{\"details\":\"Unauthorized reentrant call.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"getZeroHash(uint256)\":{\"details\":\"Exposed for Poseidon/zero-hash consistency tests (JS vs Solidity)\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/Mixer.sol\":\"Mixer\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the value of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the value of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 value) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n * caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 value) external returns (bool);\\n\\n /**\\n * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n * allowance mechanism. `value` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0xc6a8ff0ea489379b61faa647490411b80102578440ab9d84e9a957cc12164e70\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n *\\n * ==== Security Considerations\\n *\\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\\n * generally recommended is:\\n *\\n * ```solidity\\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\\n * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\\n * doThing(..., value);\\n * }\\n *\\n * function doThing(..., uint256 value) public {\\n * token.safeTransferFrom(msg.sender, address(this), value);\\n * ...\\n * }\\n * ```\\n *\\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\\n * {SafeERC20-safeTransferFrom}).\\n *\\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\\n * contracts should have entry points that don't rely on permit.\\n */\\ninterface IERC20Permit {\\n /**\\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n *\\n * CAUTION: See Security Considerations above.\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0x6008dabfe393240d73d7dd7688033f72740d570aa422254d29a7dce8568f3aff\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC20Permit} from \\\"../extensions/IERC20Permit.sol\\\";\\nimport {Address} from \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n /**\\n * @dev An operation with an ERC20 token failed.\\n */\\n error SafeERC20FailedOperation(address token);\\n\\n /**\\n * @dev Indicates a failed `decreaseAllowance` request.\\n */\\n error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n /**\\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n }\\n\\n /**\\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n */\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n }\\n\\n /**\\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n forceApprove(token, spender, oldAllowance + value);\\n }\\n\\n /**\\n * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n * value, non-reverting calls are assumed to be successful.\\n */\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n unchecked {\\n uint256 currentAllowance = token.allowance(address(this), spender);\\n if (currentAllowance < requestedDecrease) {\\n revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n }\\n forceApprove(token, spender, currentAllowance - requestedDecrease);\\n }\\n }\\n\\n /**\\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n * to be set to zero before setting it to a non-zero value, such as USDT.\\n */\\n function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n if (!_callOptionalReturnBool(token, approvalCall)) {\\n _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n _callOptionalReturn(token, approvalCall);\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data);\\n if (returndata.length != 0 && !abi.decode(returndata, (bool))) {\\n revert SafeERC20FailedOperation(address(token));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n *\\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\\n */\\n function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\\n // and not revert is the subcall reverts.\\n\\n (bool success, bytes memory returndata) = address(token).call(data);\\n return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;\\n }\\n}\\n\",\"keccak256\":\"0x37bb49513c49c87c4642a891b13b63571bc87013dde806617aa1efb54605f386\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev The ETH balance of the account is not enough to perform the operation.\\n */\\n error AddressInsufficientBalance(address account);\\n\\n /**\\n * @dev There's no code at `target` (it is not a contract).\\n */\\n error AddressEmptyCode(address target);\\n\\n /**\\n * @dev A call to an address target failed. The target may have reverted.\\n */\\n error FailedInnerCall();\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n if (address(this).balance < amount) {\\n revert AddressInsufficientBalance(address(this));\\n }\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n if (!success) {\\n revert FailedInnerCall();\\n }\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason or custom error, it is bubbled\\n * up by this function (like regular Solidity function calls). However, if\\n * the call reverted with no returned reason, this function reverts with a\\n * {FailedInnerCall} error.\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n if (address(this).balance < value) {\\n revert AddressInsufficientBalance(address(this));\\n }\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResultFromTarget(target, success, returndata);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResultFromTarget(target, success, returndata);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResultFromTarget(target, success, returndata);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\\n * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an\\n * unsuccessful call.\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata\\n ) internal view returns (bytes memory) {\\n if (!success) {\\n _revert(returndata);\\n } else {\\n // only check if target is a contract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n if (returndata.length == 0 && target.code.length == 0) {\\n revert AddressEmptyCode(target);\\n }\\n return returndata;\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\\n * revert reason or with a default {FailedInnerCall} error.\\n */\\n function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\\n if (!success) {\\n _revert(returndata);\\n } else {\\n return returndata;\\n }\\n }\\n\\n /**\\n * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.\\n */\\n function _revert(bytes memory returndata) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert FailedInnerCall();\\n }\\n }\\n}\\n\",\"keccak256\":\"0xaf28a975a78550e45f65e559a3ad6a5ad43b9b8a37366999abd1b7084eb70721\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/ReentrancyGuard.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant NOT_ENTERED = 1;\\n uint256 private constant ENTERED = 2;\\n\\n uint256 private _status;\\n\\n /**\\n * @dev Unauthorized reentrant call.\\n */\\n error ReentrancyGuardReentrantCall();\\n\\n constructor() {\\n _status = NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant() {\\n _nonReentrantBefore();\\n _;\\n _nonReentrantAfter();\\n }\\n\\n function _nonReentrantBefore() private {\\n // On the first call to nonReentrant, _status will be NOT_ENTERED\\n if (_status == ENTERED) {\\n revert ReentrancyGuardReentrantCall();\\n }\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = ENTERED;\\n }\\n\\n function _nonReentrantAfter() private {\\n // By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Returns true if the reentrancy guard is currently set to \\\"entered\\\", which indicates there is a\\n * `nonReentrant` function in the call stack.\\n */\\n function _reentrancyGuardEntered() internal view returns (bool) {\\n return _status == ENTERED;\\n }\\n}\\n\",\"keccak256\":\"0xf980daa263b661ab8ddee7d4fd833c7da7e7995e2c359ff1f17e67e4112f2236\",\"license\":\"MIT\"},\"contracts/Mixer.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.13;\\n\\nimport \\\"@openzeppelin/contracts/utils/ReentrancyGuard.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"poseidon-solidity/PoseidonT3.sol\\\";\\n\\ninterface IVerifyProofAggregation {\\n function verifyProofAggregation(\\n uint256 _domainId,\\n uint256 _aggregationId,\\n bytes32 _leaf,\\n bytes32[] calldata _merklePath,\\n uint256 _leafCount,\\n uint256 _index\\n ) external view returns (bool);\\n}\\n\\ncontract Mixer is ReentrancyGuard {\\n uint256 public constant BN254_PRIME = 21888242871839275222246405745257275088548364400416034343698204186575808495617;\\n bytes32 public constant PROVING_SYSTEM_ID = keccak256(abi.encodePacked(\\\"ultraplonk\\\"));\\n bytes32 public constant VERSION_HASH = sha256(abi.encodePacked(\\\"\\\"));\\n uint256 public constant TREE_DEPTH = 20;\\n uint256 public constant ROOT_HISTORY_SIZE = 30;\\n\\n address public immutable zkvContract;\\n bytes32 public immutable vkHash;\\n\\n struct MerkleTree {\\n uint256 nextIndex;\\n uint256[TREE_DEPTH] filledSubtrees;\\n }\\n\\n struct MixerProof {\\n uint256 aggregationId;\\n uint256 domainId;\\n bytes32[] zkMerklePath;\\n uint256 leafCount;\\n uint256 index;\\n }\\n\\n mapping(bytes32 => MerkleTree) public trees;\\n mapping(bytes32 => bytes32[ROOT_HISTORY_SIZE]) public rootHistory;\\n mapping(bytes32 => uint256) public rootHistoryIndex;\\n mapping(bytes32 => mapping(bytes32 => bool)) public nullifierUsed;\\n mapping(bytes32 => bool) public allowedDenominations;\\n mapping(bytes32 => bool) public commitmentUsed;\\n\\n uint256[TREE_DEPTH + 1] internal zeroHashes;\\n\\n event Deposit(bytes32 indexed commitment, uint256 leafIndex, uint256 timestamp, address indexed token, uint256 denomination);\\n event Withdrawal(address indexed recipient, bytes32 nullifierHash, address indexed token, uint256 denomination, uint256 timestamp);\\n\\n constructor(\\n address _zkvContract,\\n bytes32 _vkHash,\\n bytes32[] memory _allowedPoolIds\\n ) {\\n require(_zkvContract != address(0), \\\"Invalid zkv\\\");\\n zkvContract = _zkvContract;\\n vkHash = _vkHash;\\n for (uint256 i = 0; i < _allowedPoolIds.length; i++) {\\n allowedDenominations[_allowedPoolIds[i]] = true;\\n }\\n _computeZeroHashes();\\n }\\n\\n function _computeZeroHashes() internal {\\n zeroHashes[0] = 0;\\n for (uint256 i = 1; i <= TREE_DEPTH; i++) {\\n zeroHashes[i] = _poseidonHash2(zeroHashes[i - 1], zeroHashes[i - 1]);\\n }\\n }\\n\\n /// @dev Exposed for Poseidon/zero-hash consistency tests (JS vs Solidity)\\n function getZeroHash(uint256 level) external view returns (bytes32) {\\n require(level <= TREE_DEPTH, \\\"level\\\");\\n return bytes32(zeroHashes[level]);\\n }\\n\\n function _poseidonHash2(uint256 a, uint256 b) internal view returns (uint256) {\\n uint256 safeA = a % BN254_PRIME;\\n uint256 safeB = b % BN254_PRIME;\\n return PoseidonT3.hash([safeA, safeB]);\\n }\\n\\n function _poolId(address token, uint256 denomination) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(token, denomination));\\n }\\n\\n function deposit(address token, uint256 denomination, bytes32 commitment) external payable nonReentrant {\\n bytes32 poolId = _poolId(token, denomination);\\n require(allowedDenominations[poolId], \\\"Denomination not allowed\\\");\\n require(!commitmentUsed[commitment], \\\"Commitment already used\\\");\\n\\n if (token == address(0)) {\\n require(msg.value == denomination, \\\"ETH value mismatch\\\");\\n } else {\\n require(msg.value == 0, \\\"No ETH for ERC20\\\");\\n SafeERC20.safeTransferFrom(IERC20(token), msg.sender, address(this), denomination);\\n }\\n\\n uint256 leaf = uint256(commitment);\\n MerkleTree storage tree = trees[poolId];\\n uint256 leafIndex = tree.nextIndex;\\n tree.nextIndex++;\\n\\n uint256 current = leaf;\\n for (uint256 i = 0; i < TREE_DEPTH; i++) {\\n if ((leafIndex >> i) % 2 == 0) {\\n tree.filledSubtrees[i] = current;\\n current = _poseidonHash2(current, zeroHashes[i]);\\n } else {\\n current = _poseidonHash2(tree.filledSubtrees[i], current);\\n }\\n }\\n\\n uint256 root = current;\\n uint256 rhi = rootHistoryIndex[poolId] % ROOT_HISTORY_SIZE;\\n rootHistory[poolId][rhi] = bytes32(root);\\n rootHistoryIndex[poolId]++;\\n\\n commitmentUsed[commitment] = true;\\n\\n emit Deposit(commitment, tree.nextIndex - 1, block.timestamp, token, denomination);\\n }\\n\\n function isKnownRoot(bytes32 poolId, bytes32 root) public view returns (bool) {\\n uint256 rhi = rootHistoryIndex[poolId];\\n if (rhi == 0) return false;\\n uint256 size = rhi < ROOT_HISTORY_SIZE ? rhi : ROOT_HISTORY_SIZE;\\n for (uint256 i = 0; i < size; i++) {\\n uint256 idx = (rhi - 1 - i) % ROOT_HISTORY_SIZE;\\n if (rootHistory[poolId][idx] == root) return true;\\n }\\n return false;\\n }\\n\\n function _verifyMixerProof(\\n bytes32 root,\\n bytes32 nullifierHash,\\n address recipient,\\n address token,\\n uint256 denomination,\\n MixerProof calldata proof\\n ) internal view returns (bool) {\\n bytes memory encodedInputs = abi.encodePacked(\\n root,\\n nullifierHash,\\n uint256(uint160(recipient)),\\n uint256(uint160(token)),\\n denomination\\n );\\n bytes32 leaf = keccak256(abi.encodePacked(PROVING_SYSTEM_ID, vkHash, VERSION_HASH, keccak256(encodedInputs)));\\n return IVerifyProofAggregation(zkvContract).verifyProofAggregation(\\n proof.domainId,\\n proof.aggregationId,\\n leaf,\\n proof.zkMerklePath,\\n proof.leafCount,\\n proof.index\\n );\\n }\\n\\n function withdraw(\\n address token,\\n uint256 denomination,\\n address recipient,\\n bytes32 nullifierHash,\\n bytes32 root,\\n MixerProof calldata proof\\n ) external nonReentrant {\\n bytes32 poolId = _poolId(token, denomination);\\n require(allowedDenominations[poolId], \\\"Denomination not allowed\\\");\\n require(isKnownRoot(poolId, root), \\\"Unknown root\\\");\\n require(!nullifierUsed[poolId][nullifierHash], \\\"Nullifier already used\\\");\\n require(_verifyMixerProof(root, nullifierHash, recipient, token, denomination, proof), \\\"Invalid proof\\\");\\n\\n nullifierUsed[poolId][nullifierHash] = true;\\n\\n if (token == address(0)) {\\n (bool success, ) = recipient.call{ value: denomination }(\\\"\\\");\\n require(success, \\\"ETH transfer failed\\\");\\n } else {\\n SafeERC20.safeTransfer(IERC20(token), recipient, denomination);\\n }\\n\\n emit Withdrawal(recipient, nullifierHash, token, denomination, block.timestamp);\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x9d9194b09a7796501db0572892637e613960671d83a5cda3e201c2c3edef7ba6\",\"license\":\"MIT\"},\"poseidon-solidity/PoseidonT3.sol\":{\"content\":\"/// SPDX-License-Identifier: MIT\\npragma solidity >=0.7.0;\\n\\nlibrary PoseidonT3 {\\n uint constant M00 = 0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b;\\n uint constant M01 = 0x2969f27eed31a480b9c36c764379dbca2cc8fdd1415c3dded62940bcde0bd771;\\n uint constant M02 = 0x143021ec686a3f330d5f9e654638065ce6cd79e28c5b3753326244ee65a1b1a7;\\n uint constant M10 = 0x16ed41e13bb9c0c66ae119424fddbcbc9314dc9fdbdeea55d6c64543dc4903e0;\\n uint constant M11 = 0x2e2419f9ec02ec394c9871c832963dc1b89d743c8c7b964029b2311687b1fe23;\\n uint constant M12 = 0x176cc029695ad02582a70eff08a6fd99d057e12e58e7d7b6b16cdfabc8ee2911;\\n\\n // See here for a simplified implementation: https://github.com/vimwitch/poseidon-solidity/blob/e57becdabb65d99fdc586fe1e1e09e7108202d53/contracts/Poseidon.sol#L40\\n // Inspired by: https://github.com/iden3/circomlibjs/blob/v0.0.8/src/poseidon_slow.js\\n function hash(uint[2] memory) public pure returns (uint) {\\n assembly {\\n let F := 21888242871839275222246405745257275088548364400416034343698204186575808495617\\n let M20 := 0x2b90bba00fca0589f617e7dcbfe82e0df706ab640ceb247b791a93b74e36736d\\n let M21 := 0x101071f0032379b697315876690f053d148d4e109f5fb065c8aacc55a0f89bfa\\n let M22 := 0x19a3fc0a56702bf417ba7fee3802593fa644470307043f7773279cd71d25d5e0\\n\\n // load the inputs from memory\\n let state1 := add(mod(mload(0x80), F), 0x00f1445235f2148c5986587169fc1bcd887b08d4d00868df5696fff40956e864)\\n let state2 := add(mod(mload(0xa0), F), 0x08dff3487e8ac99e1f29a058d0fa80b930c728730b7ab36ce879f3890ecf73f5)\\n let scratch0 := mulmod(state1, state1, F)\\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\\n scratch0 := mulmod(state2, state2, F)\\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\\n scratch0 := add(\\n 0x2f27be690fdaee46c3ce28f7532b13c856c35342c84bda6e20966310fadc01d0,\\n add(add(15452833169820924772166449970675545095234312153403844297388521437673434406763, mulmod(state1, M10, F)), mulmod(state2, M20, F))\\n )\\n let scratch1 := add(\\n 0x2b2ae1acf68b7b8d2416bebf3d4f6234b763fe04b8043ee48b8327bebca16cf2,\\n add(add(18674271267752038776579386132900109523609358935013267566297499497165104279117, mulmod(state1, M11, F)), mulmod(state2, M21, F))\\n )\\n let scratch2 := add(\\n 0x0319d062072bef7ecca5eac06f97d4d55952c175ab6b03eae64b44c7dbf11cfa,\\n add(add(14817777843080276494683266178512808687156649753153012854386334860566696099579, mulmod(state1, M12, F)), mulmod(state2, M22, F))\\n )\\n let state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := mulmod(scratch1, scratch1, F)\\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\\n state0 := mulmod(scratch2, scratch2, F)\\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\\n state0 := add(0x28813dcaebaeaa828a376df87af4a63bc8b7bf27ad49c6298ef7b387bf28526d, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x2727673b2ccbc903f181bf38e1c1d40d2033865200c352bc150928adddf9cb78, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x234ec45ca27727c2e74abd2b2a1494cd6efbd43e340587d6b8fb9e31e65cc632, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := mulmod(state1, state1, F)\\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\\n scratch0 := mulmod(state2, state2, F)\\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\\n scratch0 := add(0x15b52534031ae18f7f862cb2cf7cf760ab10a8150a337b1ccd99ff6e8797d428, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0dc8fad6d9e4b35f5ed9a3d186b79ce38e0e8a8d1b58b132d701d4eecf68d1f6, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1bcd95ffc211fbca600f705fad3fb567ea4eb378f62e1fec97805518a47e4d9c, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := mulmod(scratch1, scratch1, F)\\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\\n state0 := mulmod(scratch2, scratch2, F)\\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\\n state0 := add(0x10520b0ab721cadfe9eff81b016fc34dc76da36c2578937817cb978d069de559, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1f6d48149b8e7f7d9b257d8ed5fbbaf42932498075fed0ace88a9eb81f5627f6, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1d9655f652309014d29e00ef35a2089bfff8dc1c816f0dc9ca34bdb5460c8705, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x04df5a56ff95bcafb051f7b1cd43a99ba731ff67e47032058fe3d4185697cc7d, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0672d995f8fff640151b3d290cedaf148690a10a8c8424a7f6ec282b6e4be828, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x099952b414884454b21200d7ffafdd5f0c9a9dcc06f2708e9fc1d8209b5c75b9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x052cba2255dfd00c7c483143ba8d469448e43586a9b4cd9183fd0e843a6b9fa6, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0b8badee690adb8eb0bd74712b7999af82de55707251ad7716077cb93c464ddc, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x119b1590f13307af5a1ee651020c07c749c15d60683a8050b963d0a8e4b2bdd1, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x03150b7cd6d5d17b2529d36be0f67b832c4acfc884ef4ee5ce15be0bfb4a8d09, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2cc6182c5e14546e3cf1951f173912355374efb83d80898abe69cb317c9ea565, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x005032551e6378c450cfe129a404b3764218cadedac14e2b92d2cd73111bf0f9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x233237e3289baa34bb147e972ebcb9516469c399fcc069fb88f9da2cc28276b5, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x05c8f4f4ebd4a6e3c980d31674bfbe6323037f21b34ae5a4e80c2d4c24d60280, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0a7b1db13042d396ba05d818a319f25252bcf35ef3aeed91ee1f09b2590fc65b, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2a73b71f9b210cf5b14296572c9d32dbf156e2b086ff47dc5df542365a404ec0, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1ac9b0417abcc9a1935107e9ffc91dc3ec18f2c4dbe7f22976a760bb5c50c460, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x12c0339ae08374823fabb076707ef479269f3e4d6cb104349015ee046dc93fc0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0b7475b102a165ad7f5b18db4e1e704f52900aa3253baac68246682e56e9a28e, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x037c2849e191ca3edb1c5e49f6e8b8917c843e379366f2ea32ab3aa88d7f8448, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x05a6811f8556f014e92674661e217e9bd5206c5c93a07dc145fdb176a716346f, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x29a795e7d98028946e947b75d54e9f044076e87a7b2883b47b675ef5f38bd66e, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x20439a0c84b322eb45a3857afc18f5826e8c7382c8a1585c507be199981fd22f, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2e0ba8d94d9ecf4a94ec2050c7371ff1bb50f27799a84b6d4a2a6f2a0982c887, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x143fd115ce08fb27ca38eb7cce822b4517822cd2109048d2e6d0ddcca17d71c8, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0c64cbecb1c734b857968dbbdcf813cdf8611659323dbcbfc84323623be9caf1, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x028a305847c683f646fca925c163ff5ae74f348d62c2b670f1426cef9403da53, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2e4ef510ff0b6fda5fa940ab4c4380f26a6bcb64d89427b824d6755b5db9e30c, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0081c95bc43384e663d79270c956ce3b8925b4f6d033b078b96384f50579400e, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2ed5f0c91cbd9749187e2fade687e05ee2491b349c039a0bba8a9f4023a0bb38, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x30509991f88da3504bbf374ed5aae2f03448a22c76234c8c990f01f33a735206, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1c3f20fd55409a53221b7c4d49a356b9f0a1119fb2067b41a7529094424ec6ad, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x10b4e7f3ab5df003049514459b6e18eec46bb2213e8e131e170887b47ddcb96c, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2a1982979c3ff7f43ddd543d891c2abddd80f804c077d775039aa3502e43adef, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1c74ee64f15e1db6feddbead56d6d55dba431ebc396c9af95cad0f1315bd5c91, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x07533ec850ba7f98eab9303cace01b4b9e4f2e8b82708cfa9c2fe45a0ae146a0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x21576b438e500449a151e4eeaf17b154285c68f42d42c1808a11abf3764c0750, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x2f17c0559b8fe79608ad5ca193d62f10bce8384c815f0906743d6930836d4a9e, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x2d477e3862d07708a79e8aae946170bc9775a4201318474ae665b0b1b7e2730e, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x162f5243967064c390e095577984f291afba2266c38f5abcd89be0f5b2747eab, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2b4cb233ede9ba48264ecd2c8ae50d1ad7a8596a87f29f8a7777a70092393311, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2c8fbcb2dd8573dc1dbaf8f4622854776db2eece6d85c4cf4254e7c35e03b07a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x1d6f347725e4816af2ff453f0cd56b199e1b61e9f601e9ade5e88db870949da9, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x204b0c397f4ebe71ebc2d8b3df5b913df9e6ac02b68d31324cd49af5c4565529, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0c4cb9dc3c4fd8174f1149b3c63c3c2f9ecb827cd7dc25534ff8fb75bc79c502, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x174ad61a1448c899a25416474f4930301e5c49475279e0639a616ddc45bc7b54, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1a96177bcf4d8d89f759df4ec2f3cde2eaaa28c177cc0fa13a9816d49a38d2ef, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x066d04b24331d71cd0ef8054bc60c4ff05202c126a233c1a8242ace360b8a30a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2a4c4fc6ec0b0cf52195782871c6dd3b381cc65f72e02ad527037a62aa1bd804, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x13ab2d136ccf37d447e9f2e14a7cedc95e727f8446f6d9d7e55afc01219fd649, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1121552fca26061619d24d843dc82769c1b04fcec26f55194c2e3e869acc6a9a, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x00ef653322b13d6c889bc81715c37d77a6cd267d595c4a8909a5546c7c97cff1, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0e25483e45a665208b261d8ba74051e6400c776d652595d9845aca35d8a397d3, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x29f536dcb9dd7682245264659e15d88e395ac3d4dde92d8c46448db979eeba89, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2a56ef9f2c53febadfda33575dbdbd885a124e2780bbea170e456baace0fa5be, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1c8361c78eb5cf5decfb7a2d17b5c409f2ae2999a46762e8ee416240a8cb9af1, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x151aff5f38b20a0fc0473089aaf0206b83e8e68a764507bfd3d0ab4be74319c5, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x04c6187e41ed881dc1b239c88f7f9d43a9f52fc8c8b6cdd1e76e47615b51f100, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x13b37bd80f4d27fb10d84331f6fb6d534b81c61ed15776449e801b7ddc9c2967, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x01a5c536273c2d9df578bfbd32c17b7a2ce3664c2a52032c9321ceb1c4e8a8e4, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2ab3561834ca73835ad05f5d7acb950b4a9a2c666b9726da832239065b7c3b02, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1d4d8ec291e720db200fe6d686c0d613acaf6af4e95d3bf69f7ed516a597b646, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x041294d2cc484d228f5784fe7919fd2bb925351240a04b711514c9c80b65af1d, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x154ac98e01708c611c4fa715991f004898f57939d126e392042971dd90e81fc6, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0b339d8acca7d4f83eedd84093aef51050b3684c88f8b0b04524563bc6ea4da4, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x0955e49e6610c94254a4f84cfbab344598f0e71eaff4a7dd81ed95b50839c82e, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x06746a6156eba54426b9e22206f15abca9a6f41e6f535c6f3525401ea0654626, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0f18f5a0ecd1423c496f3820c549c27838e5790e2bd0a196ac917c7ff32077fb, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x04f6eeca1751f7308ac59eff5beb261e4bb563583ede7bc92a738223d6f76e13, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2b56973364c4c4f5c1a3ec4da3cdce038811eb116fb3e45bc1768d26fc0b3758, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x123769dd49d5b054dcd76b89804b1bcb8e1392b385716a5d83feb65d437f29ef, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2147b424fc48c80a88ee52b91169aacea989f6446471150994257b2fb01c63e9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0fdc1f58548b85701a6c5505ea332a29647e6f34ad4243c2ea54ad897cebe54d, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x12373a8251fea004df68abcf0f7786d4bceff28c5dbbe0c3944f685cc0a0b1f2, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x21e4f4ea5f35f85bad7ea52ff742c9e8a642756b6af44203dd8a1f35c1a90035, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x16243916d69d2ca3dfb4722224d4c462b57366492f45e90d8a81934f1bc3b147, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1efbe46dd7a578b4f66f9adbc88b4378abc21566e1a0453ca13a4159cac04ac2, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x07ea5e8537cf5dd08886020e23a7f387d468d5525be66f853b672cc96a88969a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x05a8c4f9968b8aa3b7b478a30f9a5b63650f19a75e7ce11ca9fe16c0b76c00bc, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x20f057712cc21654fbfe59bd345e8dac3f7818c701b9c7882d9d57b72a32e83f, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x04a12ededa9dfd689672f8c67fee31636dcd8e88d01d49019bd90b33eb33db69, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x27e88d8c15f37dcee44f1e5425a51decbd136ce5091a6767e49ec9544ccd101a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2feed17b84285ed9b8a5c8c5e95a41f66e096619a7703223176c41ee433de4d1, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1ed7cc76edf45c7c404241420f729cf394e5942911312a0d6972b8bd53aff2b8, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x15742e99b9bfa323157ff8c586f5660eac6783476144cdcadf2874be45466b1a, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1aac285387f65e82c895fc6887ddf40577107454c6ec0317284f033f27d0c785, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x25851c3c845d4790f9ddadbdb6057357832e2e7a49775f71ec75a96554d67c77, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x15a5821565cc2ec2ce78457db197edf353b7ebba2c5523370ddccc3d9f146a67, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2411d57a4813b9980efa7e31a1db5966dcf64f36044277502f15485f28c71727, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x002e6f8d6520cd4713e335b8c0b6d2e647e9a98e12f4cd2558828b5ef6cb4c9b, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2ff7bc8f4380cde997da00b616b0fcd1af8f0e91e2fe1ed7398834609e0315d2, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x00b9831b948525595ee02724471bcd182e9521f6b7bb68f1e93be4febb0d3cbe, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0a2f53768b8ebf6a86913b0e57c04e011ca408648a4743a87d77adbf0c9c3512, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x00248156142fd0373a479f91ff239e960f599ff7e94be69b7f2a290305e1198d, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x171d5620b87bfb1328cf8c02ab3f0c9a397196aa6a542c2350eb512a2b2bcda9, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x170a4f55536f7dc970087c7c10d6fad760c952172dd54dd99d1045e4ec34a808, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x29aba33f799fe66c2ef3134aea04336ecc37e38c1cd211ba482eca17e2dbfae1, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1e9bc179a4fdd758fdd1bb1945088d47e70d114a03f6a0e8b5ba650369e64973, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1dd269799b660fad58f7f4892dfb0b5afeaad869a9c4b44f9c9e1c43bdaf8f09, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x22cdbc8b70117ad1401181d02e15459e7ccd426fe869c7c95d1dd2cb0f24af38, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0ef042e454771c533a9f57a55c503fcefd3150f52ed94a7cd5ba93b9c7dacefd, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x11609e06ad6c8fe2f287f3036037e8851318e8b08a0359a03b304ffca62e8284, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x1166d9e554616dba9e753eea427c17b7fecd58c076dfe42708b08f5b783aa9af, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x2de52989431a859593413026354413db177fbf4cd2ac0b56f855a888357ee466, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x3006eb4ffc7a85819a6da492f3a8ac1df51aee5b17b8e89d74bf01cf5f71e9ad, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2af41fbb61ba8a80fdcf6fff9e3f6f422993fe8f0a4639f962344c8225145086, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x119e684de476155fe5a6b41a8ebc85db8718ab27889e85e781b214bace4827c3, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1835b786e2e8925e188bea59ae363537b51248c23828f047cff784b97b3fd800, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x28201a34c594dfa34d794996c6433a20d152bac2a7905c926c40e285ab32eeb6, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x083efd7a27d1751094e80fefaf78b000864c82eb571187724a761f88c22cc4e7, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0b6f88a3577199526158e61ceea27be811c16df7774dd8519e079564f61fd13b, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x0ec868e6d15e51d9644f66e1d6471a94589511ca00d29e1014390e6ee4254f5b, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2af33e3f866771271ac0c9b3ed2e1142ecd3e74b939cd40d00d937ab84c98591, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x0b520211f904b5e7d09b5d961c6ace7734568c547dd6858b364ce5e47951f178, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0b2d722d0919a1aad8db58f10062a92ea0c56ac4270e822cca228620188a1d40, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1f790d4d7f8cf094d980ceb37c2453e957b54a9991ca38bbe0061d1ed6e562d4, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0171eb95dfbf7d1eaea97cd385f780150885c16235a2a6a8da92ceb01e504233, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x0c2d0e3b5fd57549329bf6885da66b9b790b40defd2c8650762305381b168873, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1162fb28689c27154e5a8228b4e72b377cbcafa589e283c35d3803054407a18d, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2f1459b65dee441b64ad386a91e8310f282c5a92a89e19921623ef8249711bc0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x1e6ff3216b688c3d996d74367d5cd4c1bc489d46754eb712c243f70d1b53cfbb, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x01ca8be73832b8d0681487d27d157802d741a6f36cdc2a0576881f9326478875, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1f7735706ffe9fc586f976d5bdf223dc680286080b10cea00b9b5de315f9650e, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2522b60f4ea3307640a0c2dce041fba921ac10a3d5f096ef4745ca838285f019, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x23f0bee001b1029d5255075ddc957f833418cad4f52b6c3f8ce16c235572575b, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2bc1ae8b8ddbb81fcaac2d44555ed5685d142633e9df905f66d9401093082d59, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0f9406b8296564a37304507b8dba3ed162371273a07b1fc98011fcd6ad72205f, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x2360a8eb0cc7defa67b72998de90714e17e75b174a52ee4acb126c8cd995f0a8, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x15871a5cddead976804c803cbaef255eb4815a5e96df8b006dcbbc2767f88948, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x193a56766998ee9e0a8652dd2f3b1da0362f4f54f72379544f957ccdeefb420f, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2a394a43934f86982f9be56ff4fab1703b2e63c8ad334834e4309805e777ae0f, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1859954cfeb8695f3e8b635dcb345192892cd11223443ba7b4166e8876c0d142, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x04e1181763050e58013444dbcb99f1902b11bc25d90bbdca408d3819f4fed32b, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0fdb253dee83869d40c335ea64de8c5bb10eb82db08b5e8b1f5e5552bfd05f23, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x058cbe8a9a5027bdaa4efb623adead6275f08686f1c08984a9d7c5bae9b4f1c0, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x1382edce9971e186497eadb1aeb1f52b23b4b83bef023ab0d15228b4cceca59a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x03464990f045c6ee0819ca51fd11b0be7f61b8eb99f14b77e1e6634601d9e8b5, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x23f7bfc8720dc296fff33b41f98ff83c6fcab4605db2eb5aaa5bc137aeb70a58, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0a59a158e3eec2117e6e94e7f0e9decf18c3ffd5e1531a9219636158bbaf62f2, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x06ec54c80381c052b58bf23b312ffd3ce2c4eba065420af8f4c23ed0075fd07b, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x118872dc832e0eb5476b56648e867ec8b09340f7a7bcb1b4962f0ff9ed1f9d01, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x13d69fa127d834165ad5c7cba7ad59ed52e0b0f0e42d7fea95e1906b520921b1, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x169a177f63ea681270b1c6877a73d21bde143942fb71dc55fd8a49f19f10c77b, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x04ef51591c6ead97ef42f287adce40d93abeb032b922f66ffb7e9a5a7450544d, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x256e175a1dc079390ecd7ca703fb2e3b19ec61805d4f03ced5f45ee6dd0f69ec, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x30102d28636abd5fe5f2af412ff6004f75cc360d3205dd2da002813d3e2ceeb2, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x10998e42dfcd3bbf1c0714bc73eb1bf40443a3fa99bef4a31fd31be182fcc792, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x193edd8e9fcf3d7625fa7d24b598a1d89f3362eaf4d582efecad76f879e36860, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x18168afd34f2d915d0368ce80b7b3347d1c7a561ce611425f2664d7aa51f0b5d, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x29383c01ebd3b6ab0c017656ebe658b6a328ec77bc33626e29e2e95b33ea6111, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x10646d2f2603de39a1f4ae5e7771a64a702db6e86fb76ab600bf573f9010c711, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0beb5e07d1b27145f575f1395a55bf132f90c25b40da7b3864d0242dcb1117fb, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x16d685252078c133dc0d3ecad62b5c8830f95bb2e54b59abdffbf018d96fa336, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x0a6abd1d833938f33c74154e0404b4b40a555bbbec21ddfafd672dd62047f01a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1a679f5d36eb7b5c8ea12a4c2dedc8feb12dffeec450317270a6f19b34cf1860, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x0980fb233bd456c23974d50e0ebfde4726a423eada4e8f6ffbc7592e3f1b93d6, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x161b42232e61b84cbf1810af93a38fc0cece3d5628c9282003ebacb5c312c72b, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0ada10a90c7f0520950f7d47a60d5e6a493f09787f1564e5d09203db47de1a0b, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1a730d372310ba82320345a29ac4238ed3f07a8a2b4e121bb50ddb9af407f451, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2c8120f268ef054f817064c369dda7ea908377feaba5c4dffbda10ef58e8c556, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1c7c8824f758753fa57c00789c684217b930e95313bcb73e6e7b8649a4968f70, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2cd9ed31f5f8691c8e39e4077a74faa0f400ad8b491eb3f7b47b27fa3fd1cf77, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x23ff4f9d46813457cf60d92f57618399a5e022ac321ca550854ae23918a22eea, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x09945a5d147a4f66ceece6405dddd9d0af5a2c5103529407dff1ea58f180426d, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x188d9c528025d4c2b67660c6b771b90f7c7da6eaa29d3f268a6dd223ec6fc630, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x3050e37996596b7f81f68311431d8734dba7d926d3633595e0c0d8ddf4f0f47f, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x15af1169396830a91600ca8102c35c426ceae5461e3f95d89d829518d30afd78, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1da6d09885432ea9a06d9f37f873d985dae933e351466b2904284da3320d8acc, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2796ea90d269af29f5f8acf33921124e4e4fad3dbe658945e546ee411ddaa9cb, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x202d7dd1da0f6b4b0325c8b3307742f01e15612ec8e9304a7cb0319e01d32d60, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x096d6790d05bb759156a952ba263d672a2d7f9c788f4c831a29dace4c0f8be5f, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x054efa1f65b0fce283808965275d877b438da23ce5b13e1963798cb1447d25a4, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1b162f83d917e93edb3308c29802deb9d8aa690113b2e14864ccf6e18e4165f1, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x21e5241e12564dd6fd9f1cdd2a0de39eedfefc1466cc568ec5ceb745a0506edc, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := mulmod(scratch1, scratch1, F)\\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\\n state0 := mulmod(scratch2, scratch2, F)\\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\\n state0 := add(0x1cfb5662e8cf5ac9226a80ee17b36abecb73ab5f87e161927b4349e10e4bdf08, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0f21177e302a771bbae6d8d1ecb373b62c99af346220ac0129c53f666eb24100, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1671522374606992affb0dd7f71b12bec4236aede6290546bcef7e1f515c2320, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := mulmod(state1, state1, F)\\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\\n scratch0 := mulmod(state2, state2, F)\\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\\n scratch0 := add(0x0fa3ec5b9488259c2eb4cf24501bfad9be2ec9e42c5cc8ccd419d2a692cad870, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x193c0e04e0bd298357cb266c1506080ed36edce85c648cc085e8c57b1ab54bba, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x102adf8ef74735a27e9128306dcbc3c99f6f7291cd406578ce14ea2adaba68f8, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := mulmod(scratch1, scratch1, F)\\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\\n state0 := mulmod(scratch2, scratch2, F)\\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\\n state0 := add(0x0fe0af7858e49859e2a54d6f1ad945b1316aa24bfbdd23ae40a6d0cb70c3eab1, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x216f6717bbc7dedb08536a2220843f4e2da5f1daa9ebdefde8a5ea7344798d22, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1da55cc900f0d21f4a3e694391918a1b3c23b2ac773c6b3ef88e2e4228325161, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := mulmod(state1, state1, F)\\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\\n scratch0 := mulmod(state2, state2, F)\\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\\n\\n mstore(0x0, mod(add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)), F))\\n\\n return(0, 0x20)\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0102caa303bbc6690508f3615604f7730789ed990058c9513a87ccb30e4835be\",\"license\":\"MIT\"}},\"version\":1}", "bytecode": "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", diff --git a/packages/hardhat/deployments/horizenTestnet/Mixer.json b/packages/hardhat/deployments/horizenTestnet/Mixer.json index b0f0db4..4e69ca6 100644 --- a/packages/hardhat/deployments/horizenTestnet/Mixer.json +++ b/packages/hardhat/deployments/horizenTestnet/Mixer.json @@ -1,5 +1,5 @@ { - "address": "0x8F5f249210fFc91a2b1D86828764562f97C9eEdd", + "address": "0xd9E9103693014b00db0Bf262b65CB2226062e732", "abi": [ { "inputs": [ @@ -490,25 +490,25 @@ "type": "receive" } ], - "transactionHash": "0x664d0c63c348a9e66bfd7dae99de1defd8a07c635c80fde178793d72a726677f", + "transactionHash": "0x93a8ac32c8dd30eebfe0d93f0c98c91cd87aa88021fe40fea847db6d2ea71186", "receipt": { "to": null, "from": "0xd95E85e86D3Be5C86846435b8F0C3a476C5a9e42", - "contractAddress": "0x8F5f249210fFc91a2b1D86828764562f97C9eEdd", + "contractAddress": "0xd9E9103693014b00db0Bf262b65CB2226062e732", "transactionIndex": 1, - "gasUsed": "2329282", + "gasUsed": "2329654", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "blockHash": "0x4a5e41bec9b9369ec49f2b1f6e7d07b162cd943fc2cd4f931fb322b4e40ed6fa", - "transactionHash": "0x664d0c63c348a9e66bfd7dae99de1defd8a07c635c80fde178793d72a726677f", + "blockHash": "0x27bc7e70328f99d4bc54e0ed372a847c8d9477f2d8c560f6a119b697f8b0efe2", + "transactionHash": "0x93a8ac32c8dd30eebfe0d93f0c98c91cd87aa88021fe40fea847db6d2ea71186", "logs": [], - "blockNumber": 11529753, - "cumulativeGasUsed": "2373138", + "blockNumber": 11797624, + "cumulativeGasUsed": "2379098", "status": 1, "byzantium": true }, "args": [ "0xCC02D0A54F3184dF4c88811E5b9FAb7ff8131e4a", - "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x29236cc027580a6be3e581d9625a48710d39eb92e2c68e7b5e42841d11affe00", [ "0xe904c2b027ada6080c203c94ae7a6948682023cdbf53aef00dbc800ef97a132e", "0x73a9f33d373b966d8ef30721adda93c14785f3be5d60a65981b922edad5917c6", @@ -525,7 +525,7 @@ "0xc08d16a8b1478d1d237b587ac08d131a5651a3fa2da832bf8d8fee165d8193e4" ] ], - "numDeployments": 1, + "numDeployments": 2, "solcInputHash": "7f0373dedc61097daaf6a7dfc1f19d7a", "metadata": "{\"compiler\":{\"version\":\"0.8.20+commit.a1b79de6\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zkvContract\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"_vkHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[]\",\"name\":\"_allowedPoolIds\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"AddressEmptyCode\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"AddressInsufficientBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedInnerCall\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrancyGuardReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"commitment\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"leafIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"denomination\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"nullifierHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"denomination\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"BN254_PRIME\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PROVING_SYSTEM_ID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ROOT_HISTORY_SIZE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"TREE_DEPTH\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"VERSION_HASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"allowedDenominations\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"commitmentUsed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"denomination\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"commitment\",\"type\":\"bytes32\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"level\",\"type\":\"uint256\"}],\"name\":\"getZeroHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"poolId\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"root\",\"type\":\"bytes32\"}],\"name\":\"isKnownRoot\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"nullifierUsed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"rootHistory\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"rootHistoryIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"trees\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"nextIndex\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"vkHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"denomination\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"nullifierHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"root\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"aggregationId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"domainId\",\"type\":\"uint256\"},{\"internalType\":\"bytes32[]\",\"name\":\"zkMerklePath\",\"type\":\"bytes32[]\"},{\"internalType\":\"uint256\",\"name\":\"leafCount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"internalType\":\"struct Mixer.MixerProof\",\"name\":\"proof\",\"type\":\"tuple\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zkvContract\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"errors\":{\"AddressEmptyCode(address)\":[{\"details\":\"There's no code at `target` (it is not a contract).\"}],\"AddressInsufficientBalance(address)\":[{\"details\":\"The ETH balance of the account is not enough to perform the operation.\"}],\"FailedInnerCall()\":[{\"details\":\"A call to an address target failed. The target may have reverted.\"}],\"ReentrancyGuardReentrantCall()\":[{\"details\":\"Unauthorized reentrant call.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"getZeroHash(uint256)\":{\"details\":\"Exposed for Poseidon/zero-hash consistency tests (JS vs Solidity)\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/Mixer.sol\":\"Mixer\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the value of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the value of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 value) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n * caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 value) external returns (bool);\\n\\n /**\\n * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n * allowance mechanism. `value` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0xc6a8ff0ea489379b61faa647490411b80102578440ab9d84e9a957cc12164e70\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n *\\n * ==== Security Considerations\\n *\\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\\n * generally recommended is:\\n *\\n * ```solidity\\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\\n * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\\n * doThing(..., value);\\n * }\\n *\\n * function doThing(..., uint256 value) public {\\n * token.safeTransferFrom(msg.sender, address(this), value);\\n * ...\\n * }\\n * ```\\n *\\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\\n * {SafeERC20-safeTransferFrom}).\\n *\\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\\n * contracts should have entry points that don't rely on permit.\\n */\\ninterface IERC20Permit {\\n /**\\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n *\\n * CAUTION: See Security Considerations above.\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0x6008dabfe393240d73d7dd7688033f72740d570aa422254d29a7dce8568f3aff\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC20Permit} from \\\"../extensions/IERC20Permit.sol\\\";\\nimport {Address} from \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n /**\\n * @dev An operation with an ERC20 token failed.\\n */\\n error SafeERC20FailedOperation(address token);\\n\\n /**\\n * @dev Indicates a failed `decreaseAllowance` request.\\n */\\n error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n /**\\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n }\\n\\n /**\\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n */\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n }\\n\\n /**\\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n forceApprove(token, spender, oldAllowance + value);\\n }\\n\\n /**\\n * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n * value, non-reverting calls are assumed to be successful.\\n */\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n unchecked {\\n uint256 currentAllowance = token.allowance(address(this), spender);\\n if (currentAllowance < requestedDecrease) {\\n revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n }\\n forceApprove(token, spender, currentAllowance - requestedDecrease);\\n }\\n }\\n\\n /**\\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n * to be set to zero before setting it to a non-zero value, such as USDT.\\n */\\n function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n if (!_callOptionalReturnBool(token, approvalCall)) {\\n _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n _callOptionalReturn(token, approvalCall);\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data);\\n if (returndata.length != 0 && !abi.decode(returndata, (bool))) {\\n revert SafeERC20FailedOperation(address(token));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n *\\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\\n */\\n function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\\n // and not revert is the subcall reverts.\\n\\n (bool success, bytes memory returndata) = address(token).call(data);\\n return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;\\n }\\n}\\n\",\"keccak256\":\"0x37bb49513c49c87c4642a891b13b63571bc87013dde806617aa1efb54605f386\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev The ETH balance of the account is not enough to perform the operation.\\n */\\n error AddressInsufficientBalance(address account);\\n\\n /**\\n * @dev There's no code at `target` (it is not a contract).\\n */\\n error AddressEmptyCode(address target);\\n\\n /**\\n * @dev A call to an address target failed. The target may have reverted.\\n */\\n error FailedInnerCall();\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n if (address(this).balance < amount) {\\n revert AddressInsufficientBalance(address(this));\\n }\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n if (!success) {\\n revert FailedInnerCall();\\n }\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason or custom error, it is bubbled\\n * up by this function (like regular Solidity function calls). However, if\\n * the call reverted with no returned reason, this function reverts with a\\n * {FailedInnerCall} error.\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n if (address(this).balance < value) {\\n revert AddressInsufficientBalance(address(this));\\n }\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResultFromTarget(target, success, returndata);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResultFromTarget(target, success, returndata);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResultFromTarget(target, success, returndata);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\\n * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an\\n * unsuccessful call.\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata\\n ) internal view returns (bytes memory) {\\n if (!success) {\\n _revert(returndata);\\n } else {\\n // only check if target is a contract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n if (returndata.length == 0 && target.code.length == 0) {\\n revert AddressEmptyCode(target);\\n }\\n return returndata;\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\\n * revert reason or with a default {FailedInnerCall} error.\\n */\\n function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\\n if (!success) {\\n _revert(returndata);\\n } else {\\n return returndata;\\n }\\n }\\n\\n /**\\n * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.\\n */\\n function _revert(bytes memory returndata) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert FailedInnerCall();\\n }\\n }\\n}\\n\",\"keccak256\":\"0xaf28a975a78550e45f65e559a3ad6a5ad43b9b8a37366999abd1b7084eb70721\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/ReentrancyGuard.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant NOT_ENTERED = 1;\\n uint256 private constant ENTERED = 2;\\n\\n uint256 private _status;\\n\\n /**\\n * @dev Unauthorized reentrant call.\\n */\\n error ReentrancyGuardReentrantCall();\\n\\n constructor() {\\n _status = NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant() {\\n _nonReentrantBefore();\\n _;\\n _nonReentrantAfter();\\n }\\n\\n function _nonReentrantBefore() private {\\n // On the first call to nonReentrant, _status will be NOT_ENTERED\\n if (_status == ENTERED) {\\n revert ReentrancyGuardReentrantCall();\\n }\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = ENTERED;\\n }\\n\\n function _nonReentrantAfter() private {\\n // By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Returns true if the reentrancy guard is currently set to \\\"entered\\\", which indicates there is a\\n * `nonReentrant` function in the call stack.\\n */\\n function _reentrancyGuardEntered() internal view returns (bool) {\\n return _status == ENTERED;\\n }\\n}\\n\",\"keccak256\":\"0xf980daa263b661ab8ddee7d4fd833c7da7e7995e2c359ff1f17e67e4112f2236\",\"license\":\"MIT\"},\"contracts/Mixer.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.13;\\n\\nimport \\\"@openzeppelin/contracts/utils/ReentrancyGuard.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"poseidon-solidity/PoseidonT3.sol\\\";\\n\\ninterface IVerifyProofAggregation {\\n function verifyProofAggregation(\\n uint256 _domainId,\\n uint256 _aggregationId,\\n bytes32 _leaf,\\n bytes32[] calldata _merklePath,\\n uint256 _leafCount,\\n uint256 _index\\n ) external view returns (bool);\\n}\\n\\ncontract Mixer is ReentrancyGuard {\\n uint256 public constant BN254_PRIME = 21888242871839275222246405745257275088548364400416034343698204186575808495617;\\n bytes32 public constant PROVING_SYSTEM_ID = keccak256(abi.encodePacked(\\\"ultraplonk\\\"));\\n bytes32 public constant VERSION_HASH = sha256(abi.encodePacked(\\\"\\\"));\\n uint256 public constant TREE_DEPTH = 20;\\n uint256 public constant ROOT_HISTORY_SIZE = 30;\\n\\n address public immutable zkvContract;\\n bytes32 public immutable vkHash;\\n\\n struct MerkleTree {\\n uint256 nextIndex;\\n uint256[TREE_DEPTH] filledSubtrees;\\n }\\n\\n struct MixerProof {\\n uint256 aggregationId;\\n uint256 domainId;\\n bytes32[] zkMerklePath;\\n uint256 leafCount;\\n uint256 index;\\n }\\n\\n mapping(bytes32 => MerkleTree) public trees;\\n mapping(bytes32 => bytes32[ROOT_HISTORY_SIZE]) public rootHistory;\\n mapping(bytes32 => uint256) public rootHistoryIndex;\\n mapping(bytes32 => mapping(bytes32 => bool)) public nullifierUsed;\\n mapping(bytes32 => bool) public allowedDenominations;\\n mapping(bytes32 => bool) public commitmentUsed;\\n\\n uint256[TREE_DEPTH + 1] internal zeroHashes;\\n\\n event Deposit(bytes32 indexed commitment, uint256 leafIndex, uint256 timestamp, address indexed token, uint256 denomination);\\n event Withdrawal(address indexed recipient, bytes32 nullifierHash, address indexed token, uint256 denomination, uint256 timestamp);\\n\\n constructor(\\n address _zkvContract,\\n bytes32 _vkHash,\\n bytes32[] memory _allowedPoolIds\\n ) {\\n require(_zkvContract != address(0), \\\"Invalid zkv\\\");\\n zkvContract = _zkvContract;\\n vkHash = _vkHash;\\n for (uint256 i = 0; i < _allowedPoolIds.length; i++) {\\n allowedDenominations[_allowedPoolIds[i]] = true;\\n }\\n _computeZeroHashes();\\n }\\n\\n function _computeZeroHashes() internal {\\n zeroHashes[0] = 0;\\n for (uint256 i = 1; i <= TREE_DEPTH; i++) {\\n zeroHashes[i] = _poseidonHash2(zeroHashes[i - 1], zeroHashes[i - 1]);\\n }\\n }\\n\\n /// @dev Exposed for Poseidon/zero-hash consistency tests (JS vs Solidity)\\n function getZeroHash(uint256 level) external view returns (bytes32) {\\n require(level <= TREE_DEPTH, \\\"level\\\");\\n return bytes32(zeroHashes[level]);\\n }\\n\\n function _poseidonHash2(uint256 a, uint256 b) internal view returns (uint256) {\\n uint256 safeA = a % BN254_PRIME;\\n uint256 safeB = b % BN254_PRIME;\\n return PoseidonT3.hash([safeA, safeB]);\\n }\\n\\n function _poolId(address token, uint256 denomination) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(token, denomination));\\n }\\n\\n function deposit(address token, uint256 denomination, bytes32 commitment) external payable nonReentrant {\\n bytes32 poolId = _poolId(token, denomination);\\n require(allowedDenominations[poolId], \\\"Denomination not allowed\\\");\\n require(!commitmentUsed[commitment], \\\"Commitment already used\\\");\\n\\n if (token == address(0)) {\\n require(msg.value == denomination, \\\"ETH value mismatch\\\");\\n } else {\\n require(msg.value == 0, \\\"No ETH for ERC20\\\");\\n SafeERC20.safeTransferFrom(IERC20(token), msg.sender, address(this), denomination);\\n }\\n\\n uint256 leaf = uint256(commitment);\\n MerkleTree storage tree = trees[poolId];\\n uint256 leafIndex = tree.nextIndex;\\n tree.nextIndex++;\\n\\n uint256 current = leaf;\\n for (uint256 i = 0; i < TREE_DEPTH; i++) {\\n if ((leafIndex >> i) % 2 == 0) {\\n tree.filledSubtrees[i] = current;\\n current = _poseidonHash2(current, zeroHashes[i]);\\n } else {\\n current = _poseidonHash2(tree.filledSubtrees[i], current);\\n }\\n }\\n\\n uint256 root = current;\\n uint256 rhi = rootHistoryIndex[poolId] % ROOT_HISTORY_SIZE;\\n rootHistory[poolId][rhi] = bytes32(root);\\n rootHistoryIndex[poolId]++;\\n\\n commitmentUsed[commitment] = true;\\n\\n emit Deposit(commitment, tree.nextIndex - 1, block.timestamp, token, denomination);\\n }\\n\\n function isKnownRoot(bytes32 poolId, bytes32 root) public view returns (bool) {\\n uint256 rhi = rootHistoryIndex[poolId];\\n if (rhi == 0) return false;\\n uint256 size = rhi < ROOT_HISTORY_SIZE ? rhi : ROOT_HISTORY_SIZE;\\n for (uint256 i = 0; i < size; i++) {\\n uint256 idx = (rhi - 1 - i) % ROOT_HISTORY_SIZE;\\n if (rootHistory[poolId][idx] == root) return true;\\n }\\n return false;\\n }\\n\\n function _verifyMixerProof(\\n bytes32 root,\\n bytes32 nullifierHash,\\n address recipient,\\n address token,\\n uint256 denomination,\\n MixerProof calldata proof\\n ) internal view returns (bool) {\\n bytes memory encodedInputs = abi.encodePacked(\\n root,\\n nullifierHash,\\n uint256(uint160(recipient)),\\n uint256(uint160(token)),\\n denomination\\n );\\n bytes32 leaf = keccak256(abi.encodePacked(PROVING_SYSTEM_ID, vkHash, VERSION_HASH, keccak256(encodedInputs)));\\n return IVerifyProofAggregation(zkvContract).verifyProofAggregation(\\n proof.domainId,\\n proof.aggregationId,\\n leaf,\\n proof.zkMerklePath,\\n proof.leafCount,\\n proof.index\\n );\\n }\\n\\n function withdraw(\\n address token,\\n uint256 denomination,\\n address recipient,\\n bytes32 nullifierHash,\\n bytes32 root,\\n MixerProof calldata proof\\n ) external nonReentrant {\\n bytes32 poolId = _poolId(token, denomination);\\n require(allowedDenominations[poolId], \\\"Denomination not allowed\\\");\\n require(isKnownRoot(poolId, root), \\\"Unknown root\\\");\\n require(!nullifierUsed[poolId][nullifierHash], \\\"Nullifier already used\\\");\\n require(_verifyMixerProof(root, nullifierHash, recipient, token, denomination, proof), \\\"Invalid proof\\\");\\n\\n nullifierUsed[poolId][nullifierHash] = true;\\n\\n if (token == address(0)) {\\n (bool success, ) = recipient.call{ value: denomination }(\\\"\\\");\\n require(success, \\\"ETH transfer failed\\\");\\n } else {\\n SafeERC20.safeTransfer(IERC20(token), recipient, denomination);\\n }\\n\\n emit Withdrawal(recipient, nullifierHash, token, denomination, block.timestamp);\\n }\\n\\n receive() external payable {}\\n}\\n\",\"keccak256\":\"0x9d9194b09a7796501db0572892637e613960671d83a5cda3e201c2c3edef7ba6\",\"license\":\"MIT\"},\"poseidon-solidity/PoseidonT3.sol\":{\"content\":\"/// SPDX-License-Identifier: MIT\\npragma solidity >=0.7.0;\\n\\nlibrary PoseidonT3 {\\n uint constant M00 = 0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b;\\n uint constant M01 = 0x2969f27eed31a480b9c36c764379dbca2cc8fdd1415c3dded62940bcde0bd771;\\n uint constant M02 = 0x143021ec686a3f330d5f9e654638065ce6cd79e28c5b3753326244ee65a1b1a7;\\n uint constant M10 = 0x16ed41e13bb9c0c66ae119424fddbcbc9314dc9fdbdeea55d6c64543dc4903e0;\\n uint constant M11 = 0x2e2419f9ec02ec394c9871c832963dc1b89d743c8c7b964029b2311687b1fe23;\\n uint constant M12 = 0x176cc029695ad02582a70eff08a6fd99d057e12e58e7d7b6b16cdfabc8ee2911;\\n\\n // See here for a simplified implementation: https://github.com/vimwitch/poseidon-solidity/blob/e57becdabb65d99fdc586fe1e1e09e7108202d53/contracts/Poseidon.sol#L40\\n // Inspired by: https://github.com/iden3/circomlibjs/blob/v0.0.8/src/poseidon_slow.js\\n function hash(uint[2] memory) public pure returns (uint) {\\n assembly {\\n let F := 21888242871839275222246405745257275088548364400416034343698204186575808495617\\n let M20 := 0x2b90bba00fca0589f617e7dcbfe82e0df706ab640ceb247b791a93b74e36736d\\n let M21 := 0x101071f0032379b697315876690f053d148d4e109f5fb065c8aacc55a0f89bfa\\n let M22 := 0x19a3fc0a56702bf417ba7fee3802593fa644470307043f7773279cd71d25d5e0\\n\\n // load the inputs from memory\\n let state1 := add(mod(mload(0x80), F), 0x00f1445235f2148c5986587169fc1bcd887b08d4d00868df5696fff40956e864)\\n let state2 := add(mod(mload(0xa0), F), 0x08dff3487e8ac99e1f29a058d0fa80b930c728730b7ab36ce879f3890ecf73f5)\\n let scratch0 := mulmod(state1, state1, F)\\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\\n scratch0 := mulmod(state2, state2, F)\\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\\n scratch0 := add(\\n 0x2f27be690fdaee46c3ce28f7532b13c856c35342c84bda6e20966310fadc01d0,\\n add(add(15452833169820924772166449970675545095234312153403844297388521437673434406763, mulmod(state1, M10, F)), mulmod(state2, M20, F))\\n )\\n let scratch1 := add(\\n 0x2b2ae1acf68b7b8d2416bebf3d4f6234b763fe04b8043ee48b8327bebca16cf2,\\n add(add(18674271267752038776579386132900109523609358935013267566297499497165104279117, mulmod(state1, M11, F)), mulmod(state2, M21, F))\\n )\\n let scratch2 := add(\\n 0x0319d062072bef7ecca5eac06f97d4d55952c175ab6b03eae64b44c7dbf11cfa,\\n add(add(14817777843080276494683266178512808687156649753153012854386334860566696099579, mulmod(state1, M12, F)), mulmod(state2, M22, F))\\n )\\n let state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := mulmod(scratch1, scratch1, F)\\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\\n state0 := mulmod(scratch2, scratch2, F)\\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\\n state0 := add(0x28813dcaebaeaa828a376df87af4a63bc8b7bf27ad49c6298ef7b387bf28526d, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x2727673b2ccbc903f181bf38e1c1d40d2033865200c352bc150928adddf9cb78, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x234ec45ca27727c2e74abd2b2a1494cd6efbd43e340587d6b8fb9e31e65cc632, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := mulmod(state1, state1, F)\\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\\n scratch0 := mulmod(state2, state2, F)\\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\\n scratch0 := add(0x15b52534031ae18f7f862cb2cf7cf760ab10a8150a337b1ccd99ff6e8797d428, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0dc8fad6d9e4b35f5ed9a3d186b79ce38e0e8a8d1b58b132d701d4eecf68d1f6, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1bcd95ffc211fbca600f705fad3fb567ea4eb378f62e1fec97805518a47e4d9c, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := mulmod(scratch1, scratch1, F)\\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\\n state0 := mulmod(scratch2, scratch2, F)\\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\\n state0 := add(0x10520b0ab721cadfe9eff81b016fc34dc76da36c2578937817cb978d069de559, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1f6d48149b8e7f7d9b257d8ed5fbbaf42932498075fed0ace88a9eb81f5627f6, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1d9655f652309014d29e00ef35a2089bfff8dc1c816f0dc9ca34bdb5460c8705, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x04df5a56ff95bcafb051f7b1cd43a99ba731ff67e47032058fe3d4185697cc7d, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0672d995f8fff640151b3d290cedaf148690a10a8c8424a7f6ec282b6e4be828, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x099952b414884454b21200d7ffafdd5f0c9a9dcc06f2708e9fc1d8209b5c75b9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x052cba2255dfd00c7c483143ba8d469448e43586a9b4cd9183fd0e843a6b9fa6, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0b8badee690adb8eb0bd74712b7999af82de55707251ad7716077cb93c464ddc, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x119b1590f13307af5a1ee651020c07c749c15d60683a8050b963d0a8e4b2bdd1, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x03150b7cd6d5d17b2529d36be0f67b832c4acfc884ef4ee5ce15be0bfb4a8d09, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2cc6182c5e14546e3cf1951f173912355374efb83d80898abe69cb317c9ea565, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x005032551e6378c450cfe129a404b3764218cadedac14e2b92d2cd73111bf0f9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x233237e3289baa34bb147e972ebcb9516469c399fcc069fb88f9da2cc28276b5, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x05c8f4f4ebd4a6e3c980d31674bfbe6323037f21b34ae5a4e80c2d4c24d60280, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0a7b1db13042d396ba05d818a319f25252bcf35ef3aeed91ee1f09b2590fc65b, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2a73b71f9b210cf5b14296572c9d32dbf156e2b086ff47dc5df542365a404ec0, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1ac9b0417abcc9a1935107e9ffc91dc3ec18f2c4dbe7f22976a760bb5c50c460, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x12c0339ae08374823fabb076707ef479269f3e4d6cb104349015ee046dc93fc0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0b7475b102a165ad7f5b18db4e1e704f52900aa3253baac68246682e56e9a28e, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x037c2849e191ca3edb1c5e49f6e8b8917c843e379366f2ea32ab3aa88d7f8448, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x05a6811f8556f014e92674661e217e9bd5206c5c93a07dc145fdb176a716346f, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x29a795e7d98028946e947b75d54e9f044076e87a7b2883b47b675ef5f38bd66e, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x20439a0c84b322eb45a3857afc18f5826e8c7382c8a1585c507be199981fd22f, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2e0ba8d94d9ecf4a94ec2050c7371ff1bb50f27799a84b6d4a2a6f2a0982c887, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x143fd115ce08fb27ca38eb7cce822b4517822cd2109048d2e6d0ddcca17d71c8, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0c64cbecb1c734b857968dbbdcf813cdf8611659323dbcbfc84323623be9caf1, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x028a305847c683f646fca925c163ff5ae74f348d62c2b670f1426cef9403da53, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2e4ef510ff0b6fda5fa940ab4c4380f26a6bcb64d89427b824d6755b5db9e30c, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0081c95bc43384e663d79270c956ce3b8925b4f6d033b078b96384f50579400e, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2ed5f0c91cbd9749187e2fade687e05ee2491b349c039a0bba8a9f4023a0bb38, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x30509991f88da3504bbf374ed5aae2f03448a22c76234c8c990f01f33a735206, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1c3f20fd55409a53221b7c4d49a356b9f0a1119fb2067b41a7529094424ec6ad, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x10b4e7f3ab5df003049514459b6e18eec46bb2213e8e131e170887b47ddcb96c, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2a1982979c3ff7f43ddd543d891c2abddd80f804c077d775039aa3502e43adef, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1c74ee64f15e1db6feddbead56d6d55dba431ebc396c9af95cad0f1315bd5c91, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x07533ec850ba7f98eab9303cace01b4b9e4f2e8b82708cfa9c2fe45a0ae146a0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x21576b438e500449a151e4eeaf17b154285c68f42d42c1808a11abf3764c0750, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x2f17c0559b8fe79608ad5ca193d62f10bce8384c815f0906743d6930836d4a9e, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x2d477e3862d07708a79e8aae946170bc9775a4201318474ae665b0b1b7e2730e, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x162f5243967064c390e095577984f291afba2266c38f5abcd89be0f5b2747eab, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2b4cb233ede9ba48264ecd2c8ae50d1ad7a8596a87f29f8a7777a70092393311, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2c8fbcb2dd8573dc1dbaf8f4622854776db2eece6d85c4cf4254e7c35e03b07a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x1d6f347725e4816af2ff453f0cd56b199e1b61e9f601e9ade5e88db870949da9, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x204b0c397f4ebe71ebc2d8b3df5b913df9e6ac02b68d31324cd49af5c4565529, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0c4cb9dc3c4fd8174f1149b3c63c3c2f9ecb827cd7dc25534ff8fb75bc79c502, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x174ad61a1448c899a25416474f4930301e5c49475279e0639a616ddc45bc7b54, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1a96177bcf4d8d89f759df4ec2f3cde2eaaa28c177cc0fa13a9816d49a38d2ef, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x066d04b24331d71cd0ef8054bc60c4ff05202c126a233c1a8242ace360b8a30a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2a4c4fc6ec0b0cf52195782871c6dd3b381cc65f72e02ad527037a62aa1bd804, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x13ab2d136ccf37d447e9f2e14a7cedc95e727f8446f6d9d7e55afc01219fd649, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1121552fca26061619d24d843dc82769c1b04fcec26f55194c2e3e869acc6a9a, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x00ef653322b13d6c889bc81715c37d77a6cd267d595c4a8909a5546c7c97cff1, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0e25483e45a665208b261d8ba74051e6400c776d652595d9845aca35d8a397d3, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x29f536dcb9dd7682245264659e15d88e395ac3d4dde92d8c46448db979eeba89, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2a56ef9f2c53febadfda33575dbdbd885a124e2780bbea170e456baace0fa5be, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1c8361c78eb5cf5decfb7a2d17b5c409f2ae2999a46762e8ee416240a8cb9af1, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x151aff5f38b20a0fc0473089aaf0206b83e8e68a764507bfd3d0ab4be74319c5, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x04c6187e41ed881dc1b239c88f7f9d43a9f52fc8c8b6cdd1e76e47615b51f100, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x13b37bd80f4d27fb10d84331f6fb6d534b81c61ed15776449e801b7ddc9c2967, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x01a5c536273c2d9df578bfbd32c17b7a2ce3664c2a52032c9321ceb1c4e8a8e4, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2ab3561834ca73835ad05f5d7acb950b4a9a2c666b9726da832239065b7c3b02, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1d4d8ec291e720db200fe6d686c0d613acaf6af4e95d3bf69f7ed516a597b646, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x041294d2cc484d228f5784fe7919fd2bb925351240a04b711514c9c80b65af1d, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x154ac98e01708c611c4fa715991f004898f57939d126e392042971dd90e81fc6, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0b339d8acca7d4f83eedd84093aef51050b3684c88f8b0b04524563bc6ea4da4, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x0955e49e6610c94254a4f84cfbab344598f0e71eaff4a7dd81ed95b50839c82e, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x06746a6156eba54426b9e22206f15abca9a6f41e6f535c6f3525401ea0654626, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0f18f5a0ecd1423c496f3820c549c27838e5790e2bd0a196ac917c7ff32077fb, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x04f6eeca1751f7308ac59eff5beb261e4bb563583ede7bc92a738223d6f76e13, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2b56973364c4c4f5c1a3ec4da3cdce038811eb116fb3e45bc1768d26fc0b3758, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x123769dd49d5b054dcd76b89804b1bcb8e1392b385716a5d83feb65d437f29ef, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2147b424fc48c80a88ee52b91169aacea989f6446471150994257b2fb01c63e9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0fdc1f58548b85701a6c5505ea332a29647e6f34ad4243c2ea54ad897cebe54d, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x12373a8251fea004df68abcf0f7786d4bceff28c5dbbe0c3944f685cc0a0b1f2, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x21e4f4ea5f35f85bad7ea52ff742c9e8a642756b6af44203dd8a1f35c1a90035, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x16243916d69d2ca3dfb4722224d4c462b57366492f45e90d8a81934f1bc3b147, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1efbe46dd7a578b4f66f9adbc88b4378abc21566e1a0453ca13a4159cac04ac2, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x07ea5e8537cf5dd08886020e23a7f387d468d5525be66f853b672cc96a88969a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x05a8c4f9968b8aa3b7b478a30f9a5b63650f19a75e7ce11ca9fe16c0b76c00bc, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x20f057712cc21654fbfe59bd345e8dac3f7818c701b9c7882d9d57b72a32e83f, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x04a12ededa9dfd689672f8c67fee31636dcd8e88d01d49019bd90b33eb33db69, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x27e88d8c15f37dcee44f1e5425a51decbd136ce5091a6767e49ec9544ccd101a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2feed17b84285ed9b8a5c8c5e95a41f66e096619a7703223176c41ee433de4d1, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1ed7cc76edf45c7c404241420f729cf394e5942911312a0d6972b8bd53aff2b8, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x15742e99b9bfa323157ff8c586f5660eac6783476144cdcadf2874be45466b1a, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1aac285387f65e82c895fc6887ddf40577107454c6ec0317284f033f27d0c785, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x25851c3c845d4790f9ddadbdb6057357832e2e7a49775f71ec75a96554d67c77, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x15a5821565cc2ec2ce78457db197edf353b7ebba2c5523370ddccc3d9f146a67, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2411d57a4813b9980efa7e31a1db5966dcf64f36044277502f15485f28c71727, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x002e6f8d6520cd4713e335b8c0b6d2e647e9a98e12f4cd2558828b5ef6cb4c9b, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2ff7bc8f4380cde997da00b616b0fcd1af8f0e91e2fe1ed7398834609e0315d2, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x00b9831b948525595ee02724471bcd182e9521f6b7bb68f1e93be4febb0d3cbe, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0a2f53768b8ebf6a86913b0e57c04e011ca408648a4743a87d77adbf0c9c3512, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x00248156142fd0373a479f91ff239e960f599ff7e94be69b7f2a290305e1198d, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x171d5620b87bfb1328cf8c02ab3f0c9a397196aa6a542c2350eb512a2b2bcda9, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x170a4f55536f7dc970087c7c10d6fad760c952172dd54dd99d1045e4ec34a808, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x29aba33f799fe66c2ef3134aea04336ecc37e38c1cd211ba482eca17e2dbfae1, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1e9bc179a4fdd758fdd1bb1945088d47e70d114a03f6a0e8b5ba650369e64973, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1dd269799b660fad58f7f4892dfb0b5afeaad869a9c4b44f9c9e1c43bdaf8f09, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x22cdbc8b70117ad1401181d02e15459e7ccd426fe869c7c95d1dd2cb0f24af38, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x0ef042e454771c533a9f57a55c503fcefd3150f52ed94a7cd5ba93b9c7dacefd, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x11609e06ad6c8fe2f287f3036037e8851318e8b08a0359a03b304ffca62e8284, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x1166d9e554616dba9e753eea427c17b7fecd58c076dfe42708b08f5b783aa9af, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x2de52989431a859593413026354413db177fbf4cd2ac0b56f855a888357ee466, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x3006eb4ffc7a85819a6da492f3a8ac1df51aee5b17b8e89d74bf01cf5f71e9ad, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2af41fbb61ba8a80fdcf6fff9e3f6f422993fe8f0a4639f962344c8225145086, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x119e684de476155fe5a6b41a8ebc85db8718ab27889e85e781b214bace4827c3, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1835b786e2e8925e188bea59ae363537b51248c23828f047cff784b97b3fd800, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x28201a34c594dfa34d794996c6433a20d152bac2a7905c926c40e285ab32eeb6, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x083efd7a27d1751094e80fefaf78b000864c82eb571187724a761f88c22cc4e7, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0b6f88a3577199526158e61ceea27be811c16df7774dd8519e079564f61fd13b, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x0ec868e6d15e51d9644f66e1d6471a94589511ca00d29e1014390e6ee4254f5b, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2af33e3f866771271ac0c9b3ed2e1142ecd3e74b939cd40d00d937ab84c98591, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x0b520211f904b5e7d09b5d961c6ace7734568c547dd6858b364ce5e47951f178, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0b2d722d0919a1aad8db58f10062a92ea0c56ac4270e822cca228620188a1d40, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x1f790d4d7f8cf094d980ceb37c2453e957b54a9991ca38bbe0061d1ed6e562d4, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x0171eb95dfbf7d1eaea97cd385f780150885c16235a2a6a8da92ceb01e504233, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x0c2d0e3b5fd57549329bf6885da66b9b790b40defd2c8650762305381b168873, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1162fb28689c27154e5a8228b4e72b377cbcafa589e283c35d3803054407a18d, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2f1459b65dee441b64ad386a91e8310f282c5a92a89e19921623ef8249711bc0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x1e6ff3216b688c3d996d74367d5cd4c1bc489d46754eb712c243f70d1b53cfbb, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x01ca8be73832b8d0681487d27d157802d741a6f36cdc2a0576881f9326478875, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1f7735706ffe9fc586f976d5bdf223dc680286080b10cea00b9b5de315f9650e, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2522b60f4ea3307640a0c2dce041fba921ac10a3d5f096ef4745ca838285f019, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x23f0bee001b1029d5255075ddc957f833418cad4f52b6c3f8ce16c235572575b, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2bc1ae8b8ddbb81fcaac2d44555ed5685d142633e9df905f66d9401093082d59, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0f9406b8296564a37304507b8dba3ed162371273a07b1fc98011fcd6ad72205f, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x2360a8eb0cc7defa67b72998de90714e17e75b174a52ee4acb126c8cd995f0a8, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x15871a5cddead976804c803cbaef255eb4815a5e96df8b006dcbbc2767f88948, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x193a56766998ee9e0a8652dd2f3b1da0362f4f54f72379544f957ccdeefb420f, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x2a394a43934f86982f9be56ff4fab1703b2e63c8ad334834e4309805e777ae0f, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1859954cfeb8695f3e8b635dcb345192892cd11223443ba7b4166e8876c0d142, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x04e1181763050e58013444dbcb99f1902b11bc25d90bbdca408d3819f4fed32b, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0fdb253dee83869d40c335ea64de8c5bb10eb82db08b5e8b1f5e5552bfd05f23, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x058cbe8a9a5027bdaa4efb623adead6275f08686f1c08984a9d7c5bae9b4f1c0, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x1382edce9971e186497eadb1aeb1f52b23b4b83bef023ab0d15228b4cceca59a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x03464990f045c6ee0819ca51fd11b0be7f61b8eb99f14b77e1e6634601d9e8b5, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x23f7bfc8720dc296fff33b41f98ff83c6fcab4605db2eb5aaa5bc137aeb70a58, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x0a59a158e3eec2117e6e94e7f0e9decf18c3ffd5e1531a9219636158bbaf62f2, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x06ec54c80381c052b58bf23b312ffd3ce2c4eba065420af8f4c23ed0075fd07b, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x118872dc832e0eb5476b56648e867ec8b09340f7a7bcb1b4962f0ff9ed1f9d01, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x13d69fa127d834165ad5c7cba7ad59ed52e0b0f0e42d7fea95e1906b520921b1, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x169a177f63ea681270b1c6877a73d21bde143942fb71dc55fd8a49f19f10c77b, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x04ef51591c6ead97ef42f287adce40d93abeb032b922f66ffb7e9a5a7450544d, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x256e175a1dc079390ecd7ca703fb2e3b19ec61805d4f03ced5f45ee6dd0f69ec, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x30102d28636abd5fe5f2af412ff6004f75cc360d3205dd2da002813d3e2ceeb2, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x10998e42dfcd3bbf1c0714bc73eb1bf40443a3fa99bef4a31fd31be182fcc792, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x193edd8e9fcf3d7625fa7d24b598a1d89f3362eaf4d582efecad76f879e36860, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x18168afd34f2d915d0368ce80b7b3347d1c7a561ce611425f2664d7aa51f0b5d, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x29383c01ebd3b6ab0c017656ebe658b6a328ec77bc33626e29e2e95b33ea6111, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x10646d2f2603de39a1f4ae5e7771a64a702db6e86fb76ab600bf573f9010c711, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0beb5e07d1b27145f575f1395a55bf132f90c25b40da7b3864d0242dcb1117fb, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x16d685252078c133dc0d3ecad62b5c8830f95bb2e54b59abdffbf018d96fa336, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x0a6abd1d833938f33c74154e0404b4b40a555bbbec21ddfafd672dd62047f01a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1a679f5d36eb7b5c8ea12a4c2dedc8feb12dffeec450317270a6f19b34cf1860, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x0980fb233bd456c23974d50e0ebfde4726a423eada4e8f6ffbc7592e3f1b93d6, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x161b42232e61b84cbf1810af93a38fc0cece3d5628c9282003ebacb5c312c72b, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0ada10a90c7f0520950f7d47a60d5e6a493f09787f1564e5d09203db47de1a0b, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1a730d372310ba82320345a29ac4238ed3f07a8a2b4e121bb50ddb9af407f451, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x2c8120f268ef054f817064c369dda7ea908377feaba5c4dffbda10ef58e8c556, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1c7c8824f758753fa57c00789c684217b930e95313bcb73e6e7b8649a4968f70, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x2cd9ed31f5f8691c8e39e4077a74faa0f400ad8b491eb3f7b47b27fa3fd1cf77, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x23ff4f9d46813457cf60d92f57618399a5e022ac321ca550854ae23918a22eea, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x09945a5d147a4f66ceece6405dddd9d0af5a2c5103529407dff1ea58f180426d, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x188d9c528025d4c2b67660c6b771b90f7c7da6eaa29d3f268a6dd223ec6fc630, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x3050e37996596b7f81f68311431d8734dba7d926d3633595e0c0d8ddf4f0f47f, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x15af1169396830a91600ca8102c35c426ceae5461e3f95d89d829518d30afd78, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x1da6d09885432ea9a06d9f37f873d985dae933e351466b2904284da3320d8acc, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := add(0x2796ea90d269af29f5f8acf33921124e4e4fad3dbe658945e546ee411ddaa9cb, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x202d7dd1da0f6b4b0325c8b3307742f01e15612ec8e9304a7cb0319e01d32d60, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x096d6790d05bb759156a952ba263d672a2d7f9c788f4c831a29dace4c0f8be5f, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := add(0x054efa1f65b0fce283808965275d877b438da23ce5b13e1963798cb1447d25a4, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x1b162f83d917e93edb3308c29802deb9d8aa690113b2e14864ccf6e18e4165f1, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x21e5241e12564dd6fd9f1cdd2a0de39eedfefc1466cc568ec5ceb745a0506edc, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := mulmod(scratch1, scratch1, F)\\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\\n state0 := mulmod(scratch2, scratch2, F)\\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\\n state0 := add(0x1cfb5662e8cf5ac9226a80ee17b36abecb73ab5f87e161927b4349e10e4bdf08, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x0f21177e302a771bbae6d8d1ecb373b62c99af346220ac0129c53f666eb24100, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1671522374606992affb0dd7f71b12bec4236aede6290546bcef7e1f515c2320, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := mulmod(state1, state1, F)\\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\\n scratch0 := mulmod(state2, state2, F)\\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\\n scratch0 := add(0x0fa3ec5b9488259c2eb4cf24501bfad9be2ec9e42c5cc8ccd419d2a692cad870, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))\\n scratch1 := add(0x193c0e04e0bd298357cb266c1506080ed36edce85c648cc085e8c57b1ab54bba, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))\\n scratch2 := add(0x102adf8ef74735a27e9128306dcbc3c99f6f7291cd406578ce14ea2adaba68f8, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))\\n state0 := mulmod(scratch0, scratch0, F)\\n scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)\\n state0 := mulmod(scratch1, scratch1, F)\\n scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)\\n state0 := mulmod(scratch2, scratch2, F)\\n scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)\\n state0 := add(0x0fe0af7858e49859e2a54d6f1ad945b1316aa24bfbdd23ae40a6d0cb70c3eab1, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))\\n state1 := add(0x216f6717bbc7dedb08536a2220843f4e2da5f1daa9ebdefde8a5ea7344798d22, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))\\n state2 := add(0x1da55cc900f0d21f4a3e694391918a1b3c23b2ac773c6b3ef88e2e4228325161, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))\\n scratch0 := mulmod(state0, state0, F)\\n state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)\\n scratch0 := mulmod(state1, state1, F)\\n state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)\\n scratch0 := mulmod(state2, state2, F)\\n state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)\\n\\n mstore(0x0, mod(add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)), F))\\n\\n return(0, 0x20)\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0102caa303bbc6690508f3615604f7730789ed990058c9513a87ccb30e4835be\",\"license\":\"MIT\"}},\"version\":1}", "bytecode": "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", diff --git a/packages/nextjs/contracts/deployedContracts.ts b/packages/nextjs/contracts/deployedContracts.ts index 0540462..15f084d 100644 --- a/packages/nextjs/contracts/deployedContracts.ts +++ b/packages/nextjs/contracts/deployedContracts.ts @@ -7,7 +7,7 @@ import { GenericContractsDeclaration } from "~~/utils/scaffold-eth/contract"; const deployedContracts = { 84532: { Mixer: { - address: "0xd9E9103693014b00db0Bf262b65CB2226062e732", + address: "0xE146bA86fef4056566D7EE9dBB9fFaCf8A994AC2", abi: [ { inputs: [ @@ -499,7 +499,7 @@ const deployedContracts = { }, ], inheritedFunctions: {}, - deployedOnBlock: 38675302, + deployedOnBlock: 38809306, }, }, 2651420: { @@ -1025,7 +1025,7 @@ const deployedContracts = { deployedOnBlock: 6615581, }, Mixer: { - address: "0x8F5f249210fFc91a2b1D86828764562f97C9eEdd", + address: "0xd9E9103693014b00db0Bf262b65CB2226062e732", abi: [ { inputs: [ @@ -1517,7 +1517,7 @@ const deployedContracts = { }, ], inheritedFunctions: {}, - deployedOnBlock: 11529753, + deployedOnBlock: 11797624, }, }, 11155111: { diff --git a/packages/shared/src/contracts/contracts-config.ts b/packages/shared/src/contracts/contracts-config.ts index 6a5e300..a7c22e1 100644 --- a/packages/shared/src/contracts/contracts-config.ts +++ b/packages/shared/src/contracts/contracts-config.ts @@ -5,7 +5,7 @@ export const CONTRACT_CONFIG_BY_CHAIN_ID = { vkHash: "0x80aca2e84f244400a76040aa5c77f9d83ff8409a2bf0d0cde96daffcf0a50e1b", poseidonT3Address: "0x3333333C0A88F9BE4fd23ed0536F9B6c427e3B93", - mixerAddress: "0x8F5f249210fFc91a2b1D86828764562f97C9eEdd" as `0x${string}`, + mixerAddress: "0xd9E9103693014b00db0Bf262b65CB2226062e732" as `0x${string}`, mixerVkHash: "0x29236cc027580a6be3e581d9625a48710d39eb92e2c68e7b5e42841d11affe00" as `0x${string}`, }, @@ -15,7 +15,7 @@ export const CONTRACT_CONFIG_BY_CHAIN_ID = { vkHash: "0x80aca2e84f244400a76040aa5c77f9d83ff8409a2bf0d0cde96daffcf0a50e1b", poseidonT3Address: "0x3333333C0A88F9BE4fd23ed0536F9B6c427e3B93", - mixerAddress: "0xd9E9103693014b00db0Bf262b65CB2226062e732" as `0x${string}`, + mixerAddress: "0xE146bA86fef4056566D7EE9dBB9fFaCf8A994AC2" as `0x${string}`, mixerVkHash: "0x29236cc027580a6be3e581d9625a48710d39eb92e2c68e7b5e42841d11affe00" as `0x${string}`, }, @@ -45,8 +45,8 @@ export const CONTRACT_CONFIG_BY_CHAIN_ID = { // Starting blocks for Mixer deployments; used by backend indexer to avoid scanning from block 0. export const MIXER_DEPLOYMENT_BLOCK = { - 2651420: 11529753, // Horizen testnet Mixer deploy block - 84532: 38675302, // Base Sepolia Mixer deploy block + 2651420: 11797624, // Horizen testnet Mixer deploy block + 84532: 38809306, // Base Sepolia Mixer deploy block } as const; export const getContractConfigByChainId = (chainId: number) => { From d015cdcdec222c6f20cb787a27b53a912b24ae05 Mon Sep 17 00:00:00 2001 From: BoHsuu Date: Tue, 17 Mar 2026 13:35:04 +0700 Subject: [PATCH 17/18] Improve code to support token transfer --- .../nextjs/components/Mixer/WithdrawTab.tsx | 25 ++++--- packages/nextjs/hooks/app/useMixerDeposit.ts | 2 +- packages/nextjs/hooks/app/useMixerKeys.ts | 72 +++++++++++++++---- packages/nextjs/hooks/app/useMixerWithdraw.ts | 2 +- .../shared/src/contracts/contracts-config.ts | 4 +- 5 files changed, 79 insertions(+), 26 deletions(-) diff --git a/packages/nextjs/components/Mixer/WithdrawTab.tsx b/packages/nextjs/components/Mixer/WithdrawTab.tsx index bd81789..c3d7920 100644 --- a/packages/nextjs/components/Mixer/WithdrawTab.tsx +++ b/packages/nextjs/components/Mixer/WithdrawTab.tsx @@ -1,13 +1,13 @@ "use client"; -import React, { useState } from "react"; +import React, { useEffect, useState } from "react"; import { PoolStats } from "./PoolStats"; import { getContractConfigByChainId, getTokenBySymbol } from "@polypay/shared"; import { useAccount } from "wagmi"; import { MIXER_DENOMINATIONS, MIXER_SUPPORTED_CHAIN_IDS } from "~~/configs/mixer.config"; -import { useMyAccounts } from "~~/hooks"; import type { MixerDepositSlot } from "~~/hooks/app/useMixerKeys"; import { useMixerWithdraw } from "~~/hooks/app/useMixerWithdraw"; +import { useAccountStore } from "~~/services/store"; import { notification } from "~~/utils/scaffold-eth"; const TOKEN_KEYS = ["ETH", "ZEN", "USDC"] as const; @@ -34,9 +34,17 @@ export function WithdrawTab() { ? MIXER_DENOMINATIONS.ZEN : MIXER_DENOMINATIONS.USDC; - const { data: accounts = [] } = useMyAccounts(); + const { currentAccount } = useAccountStore(); const { withdraw, getWithdrawableSlots, loadingState, setError, isReady } = useMixerWithdraw(); + useEffect(() => { + if (currentAccount?.chainId === chainId) { + setRecipient(currentAccount.address); + } else { + setRecipient(""); + } + }, [chainId, currentAccount?.chainId, currentAccount?.address]); + const loadSlots = async () => { setError(null); setLoadingSlots(true); @@ -47,9 +55,6 @@ export function WithdrawTab() { const { slots: list, commitments } = await getWithdrawableSlots(chainId, tokenAddress, denomination); setSlots(list); setCachedCommitments(commitments); - if (list.length > 0 && !recipient && accounts.length > 0) { - setRecipient(accounts[0].address ?? ""); - } } catch (e: any) { notification.error(e?.message ?? "Failed to load deposits"); } finally { @@ -186,11 +191,11 @@ export function WithdrawTab() { onChange={e => setRecipient(e.target.value)} > - {accounts.map(a => ( - - ))} + )} [n1, n2, ...] + * - On deposit: save n used (from getNextDepositIndex) + * - On load: try known n first; if all match, skip scan. Fallback to scan if no cache. + * - Use address from useAccount/useWalletClient - when user switches wallet, different cache. + * - Consider Zustand store + persist if fits app patterns. + */ export interface MixerDepositSlot { n: number; @@ -14,6 +30,14 @@ export interface MixerDepositSlot { leafIndex: number; } +/** poolId as Field (bigint mod BN254) for nullifier derivation */ +function poolIdToField(token: string, denomination: string): bigint { + const poolId = keccak256( + encodePacked(["address", "uint256"], [token as `0x${string}`, BigInt(denomination)]), + ); + return BigInt(poolId) % BN254_MODULUS; +} + export function useMixerKeys() { const { data: walletClient } = useWalletClient(); // Use ref instead of state to avoid stale closure issues when called multiple times @@ -59,8 +83,15 @@ export function useMixerKeys() { }, [deriveBaseSecret]); const computeCommitmentAndNullifier = useCallback( - async (secret: bigint, n: number): Promise<{ commitment: bigint; nullifier: bigint }> => { - const nullifier = await poseidonHash2(secret, BigInt(n)); + async ( + secret: bigint, + n: number, + token: string, + denomination: string, + ): Promise<{ commitment: bigint; nullifier: bigint }> => { + const poolIdField = poolIdToField(token, denomination); + const inner = await poseidonHash2(secret, BigInt(n)); + const nullifier = await poseidonHash2(inner, poolIdField); const commitment = await poseidonHash2(secret, nullifier); return { commitment, nullifier }; }, @@ -71,13 +102,17 @@ export function useMixerKeys() { * Find smallest n such that commitment_n is not in the pool (for next deposit). */ const getNextDepositIndex = useCallback( - async (commitmentsHex: string[]): Promise<{ n: number; commitment: bigint; nullifier: bigint }> => { + async ( + commitmentsHex: string[], + token: string, + denomination: string, + ): Promise<{ n: number; commitment: bigint; nullifier: bigint }> => { const secret = await ensureBaseSecret(); const set = new Set( commitmentsHex.map(c => (c.startsWith("0x") ? BigInt(c).toString() : BigInt("0x" + c).toString())), ); for (let n = 0; ; n++) { - const { commitment, nullifier } = await computeCommitmentAndNullifier(secret, n); + const { commitment, nullifier } = await computeCommitmentAndNullifier(secret, n, token, denomination); const key = commitment.toString(); if (!set.has(key)) return { n, commitment, nullifier }; } @@ -87,9 +122,15 @@ export function useMixerKeys() { /** * Find all n such that commitment_n is in the pool; returns slots with leafIndex from the index list. + * Uses parallel batches to speed up scanning. */ const findMyDeposits = useCallback( - async (commitmentsHex: string[], leafIndices: number[]): Promise => { + async ( + commitmentsHex: string[], + leafIndices: number[], + token: string, + denomination: string, + ): Promise => { if (commitmentsHex.length !== leafIndices.length) return []; const secret = await ensureBaseSecret(); const commitmentToLeafIndex = new Map(); @@ -99,12 +140,19 @@ export function useMixerKeys() { }); const result: MixerDepositSlot[] = []; const maxN = Math.max(commitmentsHex.length * 2, 100); - for (let n = 0; n < maxN; n++) { - const { commitment, nullifier } = await computeCommitmentAndNullifier(secret, n); - const key = commitment.toString(); - const leafIndex = commitmentToLeafIndex.get(key); - if (leafIndex !== undefined) { - result.push({ n, commitment, nullifier, leafIndex }); + for (let start = 0; start < maxN; start += FIND_DEPOSITS_BATCH_SIZE) { + const batch = Array.from({ length: FIND_DEPOSITS_BATCH_SIZE }, (_, i) => start + i) + .filter(n => n < maxN) + .map(n => + computeCommitmentAndNullifier(secret, n, token, denomination).then(r => ({ n, ...r })), + ); + const batchResults = await Promise.all(batch); + for (const { n, commitment, nullifier } of batchResults) { + const key = commitment.toString(); + const leafIndex = commitmentToLeafIndex.get(key); + if (leafIndex !== undefined) { + result.push({ n, commitment, nullifier, leafIndex }); + } } } return result.sort((a, b) => a.leafIndex - b.leafIndex); diff --git a/packages/nextjs/hooks/app/useMixerWithdraw.ts b/packages/nextjs/hooks/app/useMixerWithdraw.ts index 495e630..e7a85ec 100644 --- a/packages/nextjs/hooks/app/useMixerWithdraw.ts +++ b/packages/nextjs/hooks/app/useMixerWithdraw.ts @@ -56,7 +56,7 @@ export function useMixerWithdraw() { token, denomination, }); - const allSlots = await findMyDeposits(commitments, leafIndices); + const allSlots = await findMyDeposits(commitments, leafIndices, token, denomination); const poolId = getPoolId(token, denomination); const withdrawable: MixerDepositSlot[] = []; for (const slot of allSlots) { diff --git a/packages/shared/src/contracts/contracts-config.ts b/packages/shared/src/contracts/contracts-config.ts index a7c22e1..388c44c 100644 --- a/packages/shared/src/contracts/contracts-config.ts +++ b/packages/shared/src/contracts/contracts-config.ts @@ -5,7 +5,7 @@ export const CONTRACT_CONFIG_BY_CHAIN_ID = { vkHash: "0x80aca2e84f244400a76040aa5c77f9d83ff8409a2bf0d0cde96daffcf0a50e1b", poseidonT3Address: "0x3333333C0A88F9BE4fd23ed0536F9B6c427e3B93", - mixerAddress: "0xd9E9103693014b00db0Bf262b65CB2226062e732" as `0x${string}`, + mixerAddress: "0xd9E9103693014b00db0Bf262b65CB2226062e732" as `0x${string}`, // TODO: redeploy it again when merged mixerVkHash: "0x29236cc027580a6be3e581d9625a48710d39eb92e2c68e7b5e42841d11affe00" as `0x${string}`, }, @@ -15,7 +15,7 @@ export const CONTRACT_CONFIG_BY_CHAIN_ID = { vkHash: "0x80aca2e84f244400a76040aa5c77f9d83ff8409a2bf0d0cde96daffcf0a50e1b", poseidonT3Address: "0x3333333C0A88F9BE4fd23ed0536F9B6c427e3B93", - mixerAddress: "0xE146bA86fef4056566D7EE9dBB9fFaCf8A994AC2" as `0x${string}`, + mixerAddress: "0xE146bA86fef4056566D7EE9dBB9fFaCf8A994AC2" as `0x${string}`, // TODO: redeploy it again when merged mixerVkHash: "0x29236cc027580a6be3e581d9625a48710d39eb92e2c68e7b5e42841d11affe00" as `0x${string}`, }, From 0f80cd2883ad9b986f88a4857784875d6e620046 Mon Sep 17 00:00:00 2001 From: BoHsuu Date: Tue, 17 Mar 2026 15:38:31 +0700 Subject: [PATCH 18/18] update docs for private transfer --- docs/SUMMARY.md | 2 + docs/developer-documentation/README.md | 1 + .../private-transfer-flow.md | 374 ++++++++++++++++++ docs/private-transfer.md | 144 +++++++ packages/backend/src/mixer/mixer.service.ts | 28 +- .../nextjs/components/Mixer/DepositTab.tsx | 1 + .../nextjs/components/Mixer/WithdrawTab.tsx | 1 + packages/nextjs/hooks/app/useMixerKeys.ts | 8 +- packages/nextjs/hooks/app/useMixerWithdraw.ts | 3 +- 9 files changed, 544 insertions(+), 18 deletions(-) create mode 100644 docs/developer-documentation/private-transfer-flow.md create mode 100644 docs/private-transfer.md diff --git a/docs/SUMMARY.md b/docs/SUMMARY.md index bc1b9fa..b2cb637 100644 --- a/docs/SUMMARY.md +++ b/docs/SUMMARY.md @@ -6,6 +6,7 @@ - [Privacy Architecture](privacy-architecture.md) - [Zero-Knowledge Implementation](zero-knowledge-implementation.md) - [ZK Authentication](zk-authentication.md) +- [Private Transfer](private-transfer.md) - [zkVerify, Horizen & Base Integration](zkverify-horizen-integration.md) - [Architecture](architecture.md) - [Developer Documentation](developer-documentation/README.md) @@ -13,3 +14,4 @@ - [API Documentation](developer-documentation/api-documentation.md) - [Database Connection Guide](developer-documentation/database-connection-guide.md) - [Circuit Code Walkthrough](developer-documentation/circuit-code-walkthrough.md) + - [Private Transfer Flow](developer-documentation/private-transfer-flow.md) diff --git a/docs/developer-documentation/README.md b/docs/developer-documentation/README.md index ddd9581..1779daa 100644 --- a/docs/developer-documentation/README.md +++ b/docs/developer-documentation/README.md @@ -9,6 +9,7 @@ This section covers: - [Getting Started](getting-started.md) - Prerequisites, setup, and running the project locally - [Database Connection Guide](database-connection-guide.md) - How to connect and query the PostgreSQL database - [Circuit Code Walkthrough](circuit-code-walkthrough.md) - Detailed explanation of the Noir ZK circuit +- [Private Transfer Flow](private-transfer-flow.md) - End-to-end technical flow of the mixer / private transfer feature ## Tech Stack diff --git a/docs/developer-documentation/private-transfer-flow.md b/docs/developer-documentation/private-transfer-flow.md new file mode 100644 index 0000000..bacfcd9 --- /dev/null +++ b/docs/developer-documentation/private-transfer-flow.md @@ -0,0 +1,374 @@ +## Private Transfer Flow (Developer Guide) + +This document explains the end-to-end private transfer (“Mixer”) flow in PolyPay from a developer’s perspective. + +A user deposits assets into a pool contract, which records a Poseidon commitment in an on-chain Merkle tree. To withdraw, the user generates a Noir zero-knowledge proof in the browser demonstrating ownership of a deposit without revealing which one. The backend relays this proof through zkVerify for aggregated verification, then executes the withdrawal on-chain so the user’s wallet never appears in the withdrawal transaction. + +It builds on: + +- [Privacy Architecture](../privacy-architecture.md) +- [Zero-Knowledge Implementation](../zero-knowledge-implementation.md) + +--- + +### High-Level Overview + +Goals: + +- Allow users to **deposit** assets into a shared Mixer contract. +- Later, allow them to **withdraw** to any address without linking: + - the deposit wallet, and + - the withdrawal recipient. +- Enforce: + - **Correctness** – withdrawals must correspond to real deposits. + - **Single use** – each deposit can only be withdrawn once. + +Core building blocks: + +- **Secret per wallet** – derived once from a wallet signature. +- **Per-pool index `n`** – distinguishes multiple deposits from the same secret. +- **Commitment + nullifier** – bind deposits and withdrawals. +- **Merkle tree per pool** – tracks all commitments for a (token, denomination) pair. +- **Noir circuit** – proves knowledge of a deposit without revealing which one. +- **zkVerify aggregation** – scalable verification of proofs. +- **Relayer backend** – hides the user’s EOA from on-chain interactions. + +```text +Deposit: + Client Contract Backend + | | | + | sign message, derive secret | | + | compute (commitment, nullifier) | + | | | + |--deposit(token, denom, commitment)->| | + | | insert leaf into Merkle | + | | emit Deposit event | + | |--------Deposit log---------->| + | | index into MixerDeposit table + +Withdraw: + Client Backend zkVerify Contract + | | | | + | load deposits, find owned | | | + | generate Noir proof | | | + | | | | + |---POST /mixer/withdraw-------->| | | + | |--submit proof------------->| | + | |<--aggregation result-------| | + | |---Mixer.withdraw(proof)------------------->| + | | | verify proof | + | | | transfer funds| + | |<-----------tx receipt----------------------| + |<------withdrawal complete------| | | +``` + +--- + +### Key Concepts + +#### Pools + +- A **pool** is defined by `(tokenAddress, denomination)`. +- On-chain: + - `poolId = keccak256(abi.encodePacked(token, denomination))`. + - Each `poolId` has its own Merkle tree and root history. + +#### Wallet Secret + +- Frontend derives a deterministic secret per wallet: + - `secret = keccak256(signatureBytes) mod BN254_MODULUS`, where `signatureBytes` is the raw byte output of `wallet.sign(MIXER_SECRET_MESSAGE)`. Keccak-256 is applied to the signature bytes, not the message string. + - The sign message is defined as `MIXER_SECRET_MESSAGE = "polypay-mixer-secret"`. +- Implemented client-side in the `useMixerKeys` hook. +- Never sent to the backend; stored in-memory (and recomputed via signing if needed). + +#### Index `n` + +- Integer `n = 0, 1, 2, ...`. +- Used to derive multiple deposits from the same secret. +- For each pool, the frontend finds the smallest `n` such that the resulting commitment is not already in that pool. + +#### Nullifier (pool-bound) + +- To avoid clashes between pools despite the global `commitmentUsed` check, PolyPay binds nullifiers to pools. +- Pseudocode: + +```text +poolIdField = keccak256(token, denomination) mod BN254 +inner = poseidon(secret, n) +nullifier = poseidon(inner, poolIdField) +commitment = poseidon(secret, nullifier) +``` + +- Implemented in `computeCommitmentAndNullifier()` in the frontend mixer keys hook. + +- Properties: + - Same `(secret, n)` but different `(token, denomination)` → different `nullifier` and `commitment`. + - Prevents “Commitment already used” when depositing in multiple pools. + +#### Merkle Tree + +- Each pool has a sparse Merkle tree of fixed depth (`TREE_DEPTH = 20`). +- Leaves are commitments. +- The contract stores: + - `trees[poolId].nextIndex` + - `trees[poolId].filledSubtrees` + - `rootHistory[poolId][i]` circular buffer of past roots. + +#### Nullifier Hash + +- Noir circuit and Solidity use: + +```text +nullifier_hash = poseidon(nullifier, nullifier) +``` + +- This is the public value stored on-chain to mark a deposit as spent: + - `nullifierUsed[poolId][nullifier_hash] = true`. + +--- + +### Deposit Flow (Client → Contract → Indexer) + +#### 1. Derive secret (client) + +- `useMixerKeys.ensureBaseSecret()`: + - Signs a fixed message with the wallet. + - Hashes the signature with Keccak-256. + - Reduces modulo BN254 prime to obtain `secret`. + +#### 2. Compute next `n` for the pool + +- Frontend calls backend: + - `GET /mixer/deposits?chainId&token&denomination` + - Backend returns: + - `commitments[]` – all commitment hex strings for that pool. + - `leafIndices[]` – corresponding leaf indices. +- `getNextDepositIndex(commitments, token, denomination)`: + - Maintains a `Set` of existing commitments in the pool. + - Iterates `n = 0, 1, 2, ...`: + - Computes `(commitment, nullifier)` using the pool-bound formula. + - Picks the first `n` whose `commitment` is not in the set. + +#### 3. Submit `deposit` transaction + +- Frontend: + - For ERC20: + - `approve(mixerAddress, denomination)` first (only if the current allowance is less than `denomination`; skipped when sufficient allowance already exists). + - Then call: + +```solidity +function deposit(address token, uint256 denomination, bytes32 commitment) external payable; +``` + +- Contract enforces: + - `allowedDenominations[poolId] == true` + - `!commitmentUsed[commitment]` (global across pools) + - `msg.value == denomination` for ETH pools + - `msg.value == 0` for ERC20 pools + +#### 4. Update Merkle tree and events (contract) + +- For each deposit: + - Inserts the `commitment` as a new leaf at `leafIndex = trees[poolId].nextIndex`. + - Updates internal tree nodes up to the root using Poseidon. + - Stores new root in `rootHistory[poolId]` (bounded circular buffer). + - Sets `commitmentUsed[commitment] = true`. + - Emits: + +```solidity +event Deposit(bytes32 indexed commitment, uint256 leafIndex, uint256 timestamp, address indexed token, uint256 denomination); +``` + +#### 5. Indexer persists deposits (backend) + +- A cron job (`MixerIndexerService`) reads `Deposit` logs from supported chains. +- For each log: + - Recomputes `poolId` from `(token, denomination)`. + - Upserts into `MixerDeposit` table: + - `chainId, poolId, leafIndex, commitment, token, denomination, blockNumber, txHash`. +- API `GET /mixer/deposits` is a thin wrapper over this table. + +--- + +### Withdraw Flow (Client → Backend → zkVerify → Contract) + +#### 1. Discover user-owned deposits + +Frontend `getWithdrawableSlots(chainId, token, denomination)`: + +1. Fetch deposits from backend: + - `GET /mixer/deposits` → `commitments[]`, `leafIndices[]` for the pool. + +2. Recover which deposits belong to the current wallet: + - `useMixerKeys.findMyDeposits(commitments, leafIndices, token, denomination)`: + - Ensures `secret` is available. + - Builds `Map(commitment → leafIndex)` for the pool. + - Iterates `n` from `0..maxN`, where `maxN = max(commitments.length * 2, 100)` (with `FIND_DEPOSITS_BATCH_SIZE = 50` controlling parallelism): + - Batches in chunks of 50 and runs `computeCommitmentAndNullifier(secret, n, token, denomination)` in parallel. + - If derived `commitment` exists in the map, returns a `MixerDepositSlot`. + - **Performance note:** `maxN` scales linearly with pool size (e.g., 10,000 deposits → `maxN = 20,000`). Each iteration calls `poseidonHash2` three times. With batch parallelism of 50, this results in 400 sequential batches in the worst case. For large pools this can take several seconds. Planned mitigations include progressive loading and per-wallet `n` caching in localStorage. + - Returns matched deposits as `MixerDepositSlot`: + +```text +MixerDepositSlot { + n: number; + commitment: bigint; + nullifier: bigint; + leafIndex: number; +} +``` + +3. Filter out already-withdrawn slots: + - For each slot: + - Compute `nullifierHash = poseidon(nullifier, nullifier)`. + - Call `mixer.nullifierUsed(poolId, nullifierHash)` via `readContract`. + - Keep only those with `nullifierUsed == false`. + +4. Return: + - `slots: MixerDepositSlot[]` + - `commitments: string[]` (full pool commitments, cached for Merkle proof). + +#### 2. Build Merkle path and circuit inputs + +When the user selects a slot and a recipient: + +1. Compute Merkle path: + - Using the same `commitments[]` and `slot.leafIndex`: + - `useMerkleTree.getRootAndPath(commitments, leafIndex)` → `root`, `siblings[20]`, `pathIndices[20]`. + +2. Compute `nullifierHash` and encode public inputs as fields: + +```text +nullifierHash = poseidon(nullifier, nullifier) +recipientField = BigInt(recipientAddress) +tokenField = BigInt(tokenAddress) +denomField = BigInt(denomination) +``` + +3. Circuit inputs to Noir: + +```text +Private: + secret : Field + nullifier : Field + merkle_path : [Field; 20] + path_indices : [Field; 20] + +Public: + merkle_root : Field + nullifier_hash: Field + recipient : Field + token_address : Field + denomination : Field +``` + +The circuit enforces: + +- `commitment = poseidon(secret, nullifier)` +- `poseidon(nullifier, nullifier) == nullifier_hash` +- `commitment` is a valid leaf in the Merkle tree with root `merkle_root`. + +It does **not** check `poolId` explicitly; binding to the pool is enforced at the contract level by: + +- Using the `root` from that pool’s root history. +- Checking `nullifierUsed[poolId][nullifierHash]`. + +#### 3. Generate proof in the browser + +- Frontend loads compiled Noir artifact from `packages/nextjs/public/mixer-circuit/target/mixer_circuit.json`. +- Steps: + 1. `noir.execute(circuitInput)` → witness. + 2. `UltraPlonkBackend.generateProof(witness)` → `{ proof, publicInputs }`. + 3. `UltraPlonkBackend.getVerificationKey()` → `vk` (exported as base64). + +#### 4. Submit withdrawal request to backend + +- Frontend sends: + - `chainId, token, denomination, recipient` + - `nullifierHash`, `root` + - `proof` (bytes array) + - `publicInputs` + - `vk` (verification key) +- Backend: + - Registers the verifying key with zkVerify (if needed). + - Submits the proof to zkVerify to obtain an aggregated leaf. + - Persists a `MixerWithdrawRequest` row with: + - `aggregationId, domainId` + - encoded public inputs + - status, retry metadata, etc. + +#### 5. zkVerify aggregation and on-chain execution + +- `MixerService.pollForAggregation()` polls zkVerify every **10 seconds** (`MIXER_AGGREGATION_INTERVAL_MS`) for up to **30 attempts** (`MIXER_AGGREGATION_MAX_ATTEMPTS`). +- Once the aggregation status is `'Aggregated'`, the backend waits **40 seconds** (`MIXER_FINALIZATION_WAIT_MS`) for on-chain finalization, then calls `Mixer.withdraw` on-chain via `MixerService.executeWithRetry()`: + +```solidity +function withdraw( + address token, + uint256 denomination, + address recipient, + bytes32 nullifierHash, + bytes32 root, + MixerProof calldata proof +) external; +``` + +- `MixerProof` includes: + - `aggregationId` + - `domainId` + - `zkMerklePath[]` (path inside zkVerify’s aggregation tree) + - `leafCount` + - `index` + +On-chain checks: + +1. `allowedDenominations[poolId]` +2. `isKnownRoot(poolId, root)` +3. `!nullifierUsed[poolId][nullifierHash]` +4. `_verifyMixerProof(root, nullifierHash, recipient, token, denomination, proof)`: + - Re-encodes the public inputs (`root`, `nullifierHash`, `recipient`, `token`, `denomination`). + - Computes the zkVerify leaf hash combining: + - `PROVING_SYSTEM_ID`, `vkHash`, `VERSION_HASH`, and `keccak256(encodedInputs)`. + - Asks zkVerify to confirm that this leaf is part of the aggregation. + +If all checks pass: + +- `nullifierUsed[poolId][nullifierHash] = true` +- Funds are transferred to `recipient`: + - ETH via `call{ value: denomination }` + - ERC20 via `SafeERC20.safeTransfer` +- `Withdrawal` event is emitted. + +--- + +### Privacy and UX Notes + +- **Privacy:** + - The deposit address is never used in the withdrawal transaction. + - The withdrawal is sent through a relayer backend. + - On-chain, observers see: + - `Deposit(commitment, leafIndex, token, denomination)` + - `Withdrawal(recipient, nullifierHash, token, denomination)` + - They cannot link which deposit belongs to which withdrawal. + +- **UX considerations:** + - `findMyDeposits` can become heavy as pools grow: + - Current implementation uses parallel batches to mitigate latency. + - Future work: + - Progressive loading of deposits. + - Local caching of `n` values per wallet and pool. + - Recipient selection: + - By default, the frontend uses the current PolyPay multisig account on the selected network. + - Users can override with any address for more flexible workflows. +--- + +### Constants Reference + +| Constant | Value | +|----------|-------| +| `TREE_DEPTH` | `20` | +| `ROOT_HISTORY_SIZE` | `30` | +| `BN254_MODULUS` | `21888242871839275222246405745257275088548364400416034343698204186575808495617` | +| `MIXER_SECRET_MESSAGE` | `"polypay-mixer-secret"` | +| `FIND_DEPOSITS_BATCH_SIZE` | `50` | +| `maxN` (computed) | `max(commitments.length * 2, 100)` | \ No newline at end of file diff --git a/docs/private-transfer.md b/docs/private-transfer.md new file mode 100644 index 0000000..21203d1 --- /dev/null +++ b/docs/private-transfer.md @@ -0,0 +1,144 @@ +## Private Transfer (User Guide) + +### What is Private Transfer? + +Private transfer lets you move funds so that: + +- **Observers cannot link your deposit wallet to your withdrawal address** +- On-chain, people only see: + - Someone deposited a fixed amount into a shared pool + - Later, someone withdrew the same amount to another address +- There is **no on-chain link** between your deposit and your withdrawal. + +You can think of it like: + +- Putting cash into a shared cash box (the pool) +- Later, taking out the same amount of cash from that box +- People see “someone put money in” and “someone took money out” but not who is who. + +--- + +### What you need + +- A wallet connected to **Horizen** or **Base** +- Some funds on that network: + - ETH / ZEN / USDC (depending on the chain) +- A deployed **PolyPay multisig account** — a shared wallet requiring multiple approvals to send funds. Withdrawing to a multisig keeps your personal wallet fully private while receiving funds into a team-controlled wallet. + +--- + +### Step 1 – Deposit into the Mixer + +1. **Open the Mixer screen** + - Go to the **Mixer** section in the app. + +2. **Choose token and amount** + - Choose the **token**: ETH, ZEN, or USDC. + - Choose a **fixed denomination** (for example: 0.01 ETH, 1 ZEN, 10 USDC). + - Fixed amounts ensure all deposits in the pool look identical, which makes it harder to trace individual users. + +3. **Confirm the deposit** + - Click **Deposit**. + - Your wallet will ask you to confirm the transaction. + - After the transaction confirms, your funds are in the Mixer pool. + +You can repeat this to create multiple deposits (for the same or different pools). + +--- + +### Step 2 – Wait for better privacy + +The Mixer provides better privacy when: + +- More users deposit into the **same pool** (same token + denomination) +- More deposits and withdrawals happen over time + +Practically: + +- You can withdraw immediately after depositing. +- However, waiting until the pool has more deposits improves privacy. + +--- + +### Step 3 – Load your deposits + +1. Go to the **Withdraw** tab. +2. Select the **same token and denomination** as your deposit. +3. Click **Load my deposits** — the app will find your available deposits. +4. If the app finds deposits for you: + - A list of “withdrawable deposits” appears; select the one you want to withdraw. + +If nothing shows up: + +- Make sure you selected the correct token and denomination. +- Check that the deposit transaction has been confirmed on-chain. + +--- + +### Step 4 – Choose recipient + +On the Withdraw tab: + +**Default recipient** + +- If you have a PolyPay multisig account, the app will automatically select your current multisig account as the recipient. + +**Change recipient (optional)** + +- You can pick another address by: + - Selecting from the dropdown (if available), or + - Pasting a custom address into the input box. + +**Security tips** + +- Double-check the recipient address (especially when pasting). +- If you want stronger separation from your personal wallet, use: + - A multisig account, or + - A fresh address created for receiving private transfers. + +--- + +### Step 5 – Withdraw (private) + +1. Confirm the recipient is correct. +2. Click **Withdraw** — the app will process your request (this may take few minutes). +3. When processing is complete, the funds will arrive at the recipient address. + +You can verify the withdrawal transaction in the network explorer: + +- The `from` address will be the relayer, **not** your wallet. + +--- + +### What information is public vs private? + +- **Public on-chain:** + - Deposit event: token, denomination, time, and a deposit record (an anonymous identifier, not linked to your wallet). + - Withdraw event: token, denomination, time, recipient address, and a withdrawal record (an anonymous identifier for the withdrawal). +- **Kept private:** + - Which wallet created which deposit. + - Which deposit corresponds to which withdrawal. + - The secret proving you own the deposit (stored only in your browser). + +For deeper technical details, see: + +- [Privacy Architecture](privacy-architecture.md) +- [Zero-Knowledge Implementation](zero-knowledge-implementation.md) +- [Private Transfer Flow (Developer)](developer-documentation/private-transfer-flow.md) + +--- + +### Troubleshooting / FAQ + +**Deposit confirmed but not showing in the Withdraw tab?** +Wait a few minutes and click **Load my deposits** again. The indexer may need some time to catch up. + +**Withdrawal failed?** +Please try again in a few moments. If the problem persists, check the app status or contact support. + +**Wrong recipient address?** +Once a withdrawal is completed, it cannot be reversed. Always double-check the recipient address before clicking **Withdraw**. + +**Can I deposit on one network and withdraw on another?** +No. Deposits and withdrawals must use the same network (and the same token + denomination). + diff --git a/packages/backend/src/mixer/mixer.service.ts b/packages/backend/src/mixer/mixer.service.ts index d0771ab..836a14d 100644 --- a/packages/backend/src/mixer/mixer.service.ts +++ b/packages/backend/src/mixer/mixer.service.ts @@ -51,12 +51,15 @@ export class MixerService { `Submitting mixer proof for chainId=${chainId}, recipient=${recipient}`, ); - const { jobId, status: submitStatus, txHash: zkVerifyTxHash } = - await this.zkVerifyService.submitProofAndWaitFinalized( - { proof, publicInputs, vk: dto.vk }, - 'mixer', - chainId, - ); + const { + jobId, + status: submitStatus, + txHash: zkVerifyTxHash, + } = await this.zkVerifyService.submitProofAndWaitFinalized( + { proof, publicInputs, vk: dto.vk }, + 'mixer', + chainId, + ); if (submitStatus === 'Failed' || !jobId) { throw new BadRequestException('Proof submission failed'); @@ -81,7 +84,10 @@ export class MixerService { if (!aggregationResult) { await this.prisma.mixerWithdrawRequest.update({ where: { id: request.id }, - data: { status: MixerWithdrawStatus.FAILED, errorMessage: 'MIXER_AGGREGATION_TIMEOUT' }, + data: { + status: MixerWithdrawStatus.FAILED, + errorMessage: 'MIXER_AGGREGATION_TIMEOUT', + }, }); throw new BadRequestException('MIXER_AGGREGATION_TIMEOUT'); } @@ -136,9 +142,11 @@ export class MixerService { jobId: string, maxAttempts = MIXER_AGGREGATION_MAX_ATTEMPTS, intervalMs = MIXER_AGGREGATION_INTERVAL_MS, - ): Promise< - { aggregationId?: number; aggregationDetails?: any; updatedAt?: string } | null - > { + ): Promise<{ + aggregationId?: number; + aggregationDetails?: any; + updatedAt?: string; + } | null> { for (let attempt = 0; attempt < maxAttempts; attempt++) { try { const jobStatus = await this.zkVerifyService.getJobStatus(jobId); diff --git a/packages/nextjs/components/Mixer/DepositTab.tsx b/packages/nextjs/components/Mixer/DepositTab.tsx index af2a450..17a8486 100644 --- a/packages/nextjs/components/Mixer/DepositTab.tsx +++ b/packages/nextjs/components/Mixer/DepositTab.tsx @@ -44,6 +44,7 @@ export function DepositTab() { denomination, value, }); + // TODO: Include deposit transaction hash in this notification once available from the hook. notification.success("Deposit submitted. Confirm in your wallet."); } catch (e: any) { notification.error(e?.message ?? "Deposit failed"); diff --git a/packages/nextjs/components/Mixer/WithdrawTab.tsx b/packages/nextjs/components/Mixer/WithdrawTab.tsx index c3d7920..6dcd8b4 100644 --- a/packages/nextjs/components/Mixer/WithdrawTab.tsx +++ b/packages/nextjs/components/Mixer/WithdrawTab.tsx @@ -77,6 +77,7 @@ export function WithdrawTab() { slot: selectedSlot, commitments: cachedCommitments.length > 0 ? cachedCommitments : undefined, }); + // TODO: Link to full transaction details (e.g., explorer URL) when showing this tx hash. notification.success(`Withdraw successful. Tx: ${result.txHash}`); setSelectedSlot(null); setSlots(prev => prev.filter(s => s.leafIndex !== selectedSlot.leafIndex)); diff --git a/packages/nextjs/hooks/app/useMixerKeys.ts b/packages/nextjs/hooks/app/useMixerKeys.ts index afa97c6..d8e80c3 100644 --- a/packages/nextjs/hooks/app/useMixerKeys.ts +++ b/packages/nextjs/hooks/app/useMixerKeys.ts @@ -32,9 +32,7 @@ export interface MixerDepositSlot { /** poolId as Field (bigint mod BN254) for nullifier derivation */ function poolIdToField(token: string, denomination: string): bigint { - const poolId = keccak256( - encodePacked(["address", "uint256"], [token as `0x${string}`, BigInt(denomination)]), - ); + const poolId = keccak256(encodePacked(["address", "uint256"], [token as `0x${string}`, BigInt(denomination)])); return BigInt(poolId) % BN254_MODULUS; } @@ -143,9 +141,7 @@ export function useMixerKeys() { for (let start = 0; start < maxN; start += FIND_DEPOSITS_BATCH_SIZE) { const batch = Array.from({ length: FIND_DEPOSITS_BATCH_SIZE }, (_, i) => start + i) .filter(n => n < maxN) - .map(n => - computeCommitmentAndNullifier(secret, n, token, denomination).then(r => ({ n, ...r })), - ); + .map(n => computeCommitmentAndNullifier(secret, n, token, denomination).then(r => ({ n, ...r }))); const batchResults = await Promise.all(batch); for (const { n, commitment, nullifier } of batchResults) { const key = commitment.toString(); diff --git a/packages/nextjs/hooks/app/useMixerWithdraw.ts b/packages/nextjs/hooks/app/useMixerWithdraw.ts index e7a85ec..86d47a2 100644 --- a/packages/nextjs/hooks/app/useMixerWithdraw.ts +++ b/packages/nextjs/hooks/app/useMixerWithdraw.ts @@ -84,8 +84,7 @@ export function useMixerWithdraw() { setLoadingState("Fetching deposits..."); const resolvedCommitments = - params.commitments ?? - (await mixerApi.getDeposits({ chainId, token, denomination })).commitments; + params.commitments ?? (await mixerApi.getDeposits({ chainId, token, denomination })).commitments; setLoadingState("Building Merkle path..."); const { root, siblings, pathIndices } = await getRootAndPath(resolvedCommitments, slot.leafIndex);