done

Author: FilipHarald

k8s/local/event-cannon/deployment.yaml

@@ -33,17 +33,17 @@ spec:
             - name: INIFINITE_LOOP
               value: "true"
             - name: SCENARIO_SIMPLE_DEFAULT_ACCOUNT
-              value: "true"
+              value: "false"
             - name: SCENARIO_TOKEN_CONTRACT
-              value: "true"
+              value: "false"
             - name: SCENARIO_FUNCTIONS_VOTE
               value: "true"
             - name: SCENARIO_SIMPLE_CONTRACT
-              value: "true"
+              value: "false"
             - name: SCENARIO_SIMPLE_LOG
-              value: "true"
+              value: "false"
             - name: SCENARIO_L1L2_PUBLIC_MESSAGING
-              value: "true"
+              value: "false"
             - name: SCENARIO_L1L2_PRIVATE_MESSAGING
-              value: "true"
+              value: "false"
 status: {}

k8s/local/skaffold.no_ui.yaml

@@ -3,8 +3,8 @@ kind: Config
 metadata:
   name: no_ui
 requires:
-  - path: ./common/skaffold.infra.yaml
-  - path: ./common/skaffold.aztec_sanbox_nodes.yaml
+  #- path: ./common/skaffold.infra.yaml
+  #- path: ./common/skaffold.aztec_sanbox_nodes.yaml
   - path: ./explorer-api/skaffold.sandbox.yaml
   - path: ./ethereum-listener/skaffold.sandbox.yaml
   - path: ./aztec-listener/skaffold.sandbox.yaml

packages/contract-verification/src/artifact/generate-payload.ts

@@ -1,8 +1,8 @@
 import { NoirCompiledContract } from "@aztec/aztec.js";
-import { VerifyArtifactPayload } from "types.js";
+import { VerifyArtifactPayload } from "../types.js";
 
 export const generateVerifyArtifactPayload = (
-  artifactObj: { default: NoirCompiledContract } | NoirCompiledContract
+  artifactObj: { default: NoirCompiledContract } | NoirCompiledContract,
 ): VerifyArtifactPayload => {
   const artifactJson = (artifactObj as { default: NoirCompiledContract })
     .default
@@ -17,5 +17,5 @@ export const generateVerifyArtifactPayload = (
 export const generateVerifyArtifactUrl = (
   apiBaseUrl: string,
   contractClassId: string,
-  version: number
+  version: number,
 ) => `${apiBaseUrl}/l2/contract-classes/${contractClassId}/versions/${version}`;

packages/contract-verification/src/artifact/verify-payload.ts

@@ -4,7 +4,7 @@ import {
   loadContractArtifact,
 } from "@aztec/aztec.js";
 import { ChicmozL2ContractClassRegisteredEvent } from "@chicmoz-pkg/types";
-import { VerifyArtifactPayload } from "types.js";
+import { VerifyArtifactPayload } from "../types.js";
 
 export type VerificationResult = {
   isMatchingByteCode: boolean;
@@ -13,15 +13,15 @@ export type VerificationResult = {
 
 export const verifyArtifactPayload = async (
   artifactPayload: VerifyArtifactPayload,
-  storedArtifact: ChicmozL2ContractClassRegisteredEvent
+  storedArtifact: ChicmozL2ContractClassRegisteredEvent,
 ): Promise<VerificationResult> => {
   const parsedArtifact = JSON.parse(
-    artifactPayload.stringifiedArtifactJson
+    artifactPayload.stringifiedArtifactJson,
   ) as NoirCompiledContract;
   const loadedArtifact = loadContractArtifact(parsedArtifact);
   const contractClass = await getContractClassFromArtifact(loadedArtifact);
   const isMatchingByteCode = storedArtifact.packedBytecode.equals(
-    contractClass.packedBytecode
+    contractClass.packedBytecode,
   );
   return {
     isMatchingByteCode,

packages/contract-verification/src/instance-deployment/generate-payload.ts

@@ -1,5 +1,8 @@
 import { NoirCompiledContract } from "@aztec/aztec.js";
-import { VerifyInstanceDeploymentPayload } from "types.js";
+import {
+  VerifyInstanceDeploymentPayload,
+  verifyInstanceDeploymentPayloadSchema,
+} from "../types.js";
 
 export const generateVerifyInstancePayload = ({
   publicKeysString,
@@ -23,7 +26,7 @@ export const generateVerifyInstancePayload = ({
   if (salt.length !== 66) {
     throw new Error(`Invalid salt length: ${salt.length}`);
   }
-  return {
+  return verifyInstanceDeploymentPayloadSchema.parse({
     publicKeysString,
     deployer,
     salt,
@@ -32,13 +35,13 @@ export const generateVerifyInstancePayload = ({
       ? JSON.stringify(
           (artifactObj as { default: NoirCompiledContract }).default
             ? (artifactObj as { default: NoirCompiledContract }).default
-            : artifactObj
+            : artifactObj,
         )
       : undefined,
-  };
+  });
 };
 
 export const generateVerifyInstanceUrl = (
   apiBaseUrl: string,
-  address: string
-) => `${apiBaseUrl}/l2/contract-instances/${address}/verified-deployment`;
+  address: string,
+) => `${apiBaseUrl}/l2/contract-instances/${address}`;

packages/contract-verification/src/instance-deployment/verify-payload.ts

@@ -17,7 +17,7 @@ export const verifyInstanceDeploymentPayload = async (
     instanceAddress: string;
     stringifiedArtifactJson: string;
     contractClassId: string;
-  }
+  },
 ): Promise<boolean> => {
   const {
     stringifiedArtifactJson,
@@ -28,13 +28,13 @@ export const verifyInstanceDeploymentPayload = async (
     publicKeysString,
   } = payload;
   const artifact = loadContractArtifact(
-    JSON.parse(stringifiedArtifactJson) as unknown as NoirCompiledContract
+    JSON.parse(stringifiedArtifactJson) as unknown as NoirCompiledContract,
   );
 
   const initFn = artifact.functions.find((fn) => fn.name === "constructor");
   const initializationHash = await computeInitializationHash(
     initFn,
-    constructorArgs
+    constructorArgs,
   );
   const saltedHash = await computeSaltedInitializationHash({
     initializationHash,

packages/contract-verification/src/types.ts

@@ -1,3 +1,4 @@
+import { chicmozL2ContractInstanceVerifiedDeploymentArgumentsSchema } from "@chicmoz-pkg/types";
 import { z } from "zod";
 
 export type VerifyArtifactPayload = {
@@ -8,13 +9,17 @@ export type IsTokenArtifactResult = {
   contractName: string;
   details: string;
 };
-export const verifyInstanceDeploymentPayloadSchema = z.object({
-  stringifiedArtifactJson: z.string().optional(),
-  publicKeysString: z.string(),
-  salt: z.string(),
-  deployer: z.string(),
-  constructorArgs: z.string().array(),
-});
+
+export const verifyInstanceDeploymentPayloadSchema = z.lazy(() =>
+  z.object({
+    ...chicmozL2ContractInstanceVerifiedDeploymentArgumentsSchema.omit({
+      id: true,
+      address: true,
+    }).shape,
+    stringifiedArtifactJson: z.string().optional(),
+  }),
+);
+
 export type VerifyInstanceDeploymentPayload = z.infer<
   typeof verifyInstanceDeploymentPayloadSchema
 >;

packages/types/src/aztec/l2Contract.ts

@@ -23,17 +23,17 @@ export type ChicmozL2ContractInstanceDeployedEvent = z.infer<
   typeof chicmozL2ContractInstanceDeployedEventSchema
 >;
 
-export const chicmozL2ContractInstanceVerifiedDeploymentArguments = z.object({
+export const chicmozL2ContractInstanceVerifiedDeploymentArgumentsSchema = z.object({
   id: z.string().uuid().optional(),
   address: aztecAddressSchema,
   salt: frSchema,
   deployer: aztecAddressSchema,
   publicKeysString: z.string(),
-  constructorArgs: z.string(),
+  constructorArgs: z.string().array(),
 });
 
 export type ChicmozL2ContractInstanceVerifiedDeploymentArgumnetsSchema = z.infer<
-  typeof chicmozL2ContractInstanceVerifiedDeploymentArguments
+  typeof chicmozL2ContractInstanceVerifiedDeploymentArgumentsSchema
 >;
 
 export const chicmozL2ContractClassRegisteredEventSchema = z.object({

packages/types/src/aztec/special.ts

@@ -7,7 +7,7 @@ import { chicmozL2BlockSchema } from "./l2Block.js";
 import {
   chicmozL2ContractClassRegisteredEventSchema,
   chicmozL2ContractInstanceDeployedEventSchema,
-  chicmozL2ContractInstanceVerifiedDeploymentArguments,
+  chicmozL2ContractInstanceVerifiedDeploymentArgumentsSchema,
 } from "./l2Contract.js";
 import { chicmozL2TxEffectSchema } from "./l2TxEffect.js";
 
@@ -22,8 +22,8 @@ export const chicmozL2ContractInstanceDeployerMetadataSchema = z.object({
   creatorContact: z.string(),
   appUrl: z.string(),
   repoUrl: z.string(),
-  uploadedAt: z.date(),
-  reviewedAt: z.date().optional(),
+  uploadedAt: z.coerce.date(),
+  reviewedAt: z.coerce.date().optional(),
 });
 
 export type ChicmozL2ContractInstanceDeployerMetadata = z.infer<
@@ -36,7 +36,7 @@ export const chicmozL2ContractInstanceDeluxeSchema = z.object({
   blockHeight: chicmozL2BlockSchema.shape.height.optional(),
   deployerMetadata: chicmozL2ContractInstanceDeployerMetadataSchema.optional(),
   verifiedDeploymentArguments:
-    chicmozL2ContractInstanceVerifiedDeploymentArguments.optional(),
+    chicmozL2ContractInstanceVerifiedDeploymentArgumentsSchema.optional(),
 });
 
 export type ChicmozL2ContractInstanceDeluxe = z.infer<

services/event-cannon/src/cannon/scenarios/deploy-and-interact-vote-contract.ts

@@ -13,62 +13,76 @@ import {
   verifyContractInstanceDeployment,
 } from "./utils/index.js";
 
+const contractId = "VotingContract";
+
 export async function run() {
-  logger.info("===== VOTING CONTRACT =====");
+  logger.info(`===== ${contractId} =====`);
   const pxe = getPxe();
   await waitForPXE(pxe);
   const namedWallets = getWallets();
 
   const deployerWallet = namedWallets.alice;
   const votingAdmin = namedWallets.alice.getAddress();
 
-  const contractLoggingName = "Voting Contract";
+  const contractLoggingName = contractId;
   const contract = await deployContract({
     contractLoggingName,
     deployFn: (): DeploySentTx<EasyPrivateVotingContract> =>
       EasyPrivateVotingContract.deploy(deployerWallet, votingAdmin).send(),
-    broadcastWithWallet: deployerWallet, // NOTE: comment this out to not broadcast
+    //broadcastWithWallet: deployerWallet, // NOTE: comment this out to not broadcast
     node: getAztecNodeClient(),
   });
   registerContractClassArtifact(
     contractLoggingName,
     contractArtifactJson,
     contract.instance.contractClassId.toString(),
-    contract.instance.version
+    contract.instance.version,
   ).catch((err) => {
     logger.error(
-      `Failed to register contract class artifact: ${(err as Error).stack}`
+      `Failed to register contract class artifact: ${(err as Error).stack}`,
     );
   });
 
   verifyContractInstanceDeployment({
     contractLoggingName,
-    artifactObj: contractArtifactJson,
     contractInstanceAddress: contract.address.toString(),
-    publicKeysString: contract.instance.publicKeys.toString(),
-    deployer: contract.instance.deployer.toString(),
-    salt: contract.instance.salt.toString(),
-    args: [votingAdmin.toString()]
+    verifyArgs: {
+      artifactObj: contractArtifactJson,
+      publicKeysString: contract.instance.publicKeys.toString(),
+      deployer: contract.instance.deployer.toString(),
+      salt: contract.instance.salt.toString(),
+      constructorArgs: [votingAdmin.toString()],
+    },
+    deployerMetadata: {
+      contractIdentifier: contractId,
+      details: "Easy private voting contract",
+      creatorName: "Event Cannon",
+      creatorContact:
+        "email: [email protected], discord: test#1234, telegram: @test",
+      appUrl: "https://aztec.network",
+      repoUrl: "https://github.com/AztecProtocol/aztec-packages",
+      reviewedAt: new Date(),
+    },
   }).catch((err) => {
     logger.error(
-      `Failed to verify contract instance deployment: ${(err as Error).stack}`
+      `Failed to verify contract instance deployment: ${(err as Error).stack}`,
     );
   });
 
   const votingContractAlice = await Contract.at(
     contract.address,
     EasyPrivateVotingContractArtifact,
-    namedWallets.alice
+    namedWallets.alice,
   );
   const votingContractBob = await Contract.at(
     contract.address,
     EasyPrivateVotingContractArtifact,
-    namedWallets.bob
+    namedWallets.bob,
   );
   const votingContractCharlie = await Contract.at(
     contract.address,
     EasyPrivateVotingContractArtifact,
-    namedWallets.charlie
+    namedWallets.charlie,
   );
 
   const candidateA = new Fr(1);
@@ -77,15 +91,15 @@ export async function run() {
   await Promise.all([
     logAndWaitForTx(
       votingContractAlice.methods.cast_vote(candidateA).send(),
-      "Cast vote 1 - candidate A"
+      "Cast vote 1 - candidate A",
     ),
     logAndWaitForTx(
       votingContractBob.methods.cast_vote(candidateA).send(),
-      "Cast vote 2 - candidate A"
+      "Cast vote 2 - candidate A",
     ),
     await logAndWaitForTx(
       votingContractCharlie.methods.cast_vote(candidateB).send(),
-      "Cast vote 3 - candidate B"
+      "Cast vote 3 - candidate B",
     ),
   ]);