Merge

Author: Mautjee

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,11 +7,12 @@ import { chicmozL2BlockSchema } from "./l2Block.js";
 import {
   chicmozL2ContractClassRegisteredEventSchema,
   chicmozL2ContractInstanceDeployedEventSchema,
-  chicmozL2ContractInstanceVerifiedDeploymentArguments,
+  chicmozL2ContractInstanceVerifiedDeploymentArgumentsSchema,
 } from "./l2Contract.js";
 import { chicmozL2TxEffectSchema } from "./l2TxEffect.js";
 
-export const chicmozL2ContractInstanceDeployerMetadata = z.object({
+export const chicmozL2ContractInstanceDeployerMetadataSchema = z.object({
+  // TODO: update schema with better/more info
   address: z.lazy(
     () => chicmozL2ContractInstanceDeployedEventSchema.shape.address
   ),
@@ -21,19 +22,21 @@ export const chicmozL2ContractInstanceDeployerMetadata = z.object({
   creatorContact: z.string(),
   appUrl: z.string(),
   repoUrl: z.string(),
+  uploadedAt: z.coerce.date(),
+  reviewedAt: z.coerce.date().optional(),
 });
 
-export type ChicmozL2VerifiedContractInctanceData = z.infer<
-  typeof chicmozL2ContractInstanceDeployerMetadata
+export type ChicmozL2ContractInstanceDeployerMetadata = z.infer<
+  typeof chicmozL2ContractInstanceDeployerMetadataSchema
 >;
 
 export const chicmozL2ContractInstanceDeluxeSchema = z.object({
   ...chicmozL2ContractInstanceDeployedEventSchema.shape,
   ...chicmozL2ContractClassRegisteredEventSchema.shape,
   blockHeight: chicmozL2BlockSchema.shape.height.optional(),
-  deployerMetadata: chicmozL2ContractInstanceDeployerMetadata.optional(),
+  deployerMetadata: chicmozL2ContractInstanceDeployerMetadataSchema.optional(),
   verifiedDeploymentArguments:
-    chicmozL2ContractInstanceVerifiedDeploymentArguments.optional(),
+    chicmozL2ContractInstanceVerifiedDeploymentArgumentsSchema.optional(),
 });
 
 export type ChicmozL2ContractInstanceDeluxe = z.infer<

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

@@ -1,13 +1,18 @@
-import { Contract, DeploySentTx, waitForPXE } from "@aztec/aztec.js";
+import {
+  AztecAddress,
+  Contract,
+  DeploySentTx,
+  waitForPXE,
+} from "@aztec/aztec.js";
+import { TokenContract } from "@aztec/noir-contracts.js/Token";
+import * as tokenContractArtifactJson from "@aztec/noir-contracts.js/artifacts/token_contract-Token" assert { type: "json" };
 import { logger } from "../../logger.js";
 import { getAztecNodeClient, getPxe, getWallets } from "../pxe.js";
 import {
   deployContract,
   logAndWaitForTx,
-  registerContractClassArtifact,
+  verifyContractInstanceDeployment,
 } from "./utils/index.js";
-import { TokenContract } from "@aztec/noir-contracts.js/Token";
-import * as tokenContractArtifactJson from "@aztec/noir-contracts.js/artifacts/token_contract-Token" assert { type: "json" };
 
 export async function run() {
   logger.info("===== TOKEN CONTRACT =====");
@@ -19,47 +24,68 @@ export async function run() {
   const tokenAdmin = namedWallets.alice.getAddress();
 
   const contractLoggingName = "Token Contract";
+  const constructorArgs: [AztecAddress, string, string, number] = [
+    tokenAdmin,
+    "lol",
+    "LOL",
+    9,
+  ];
   const tokenContract = await deployContract({
     contractLoggingName,
     deployFn: (): DeploySentTx<TokenContract> => {
       return TokenContract.deploy(
         deployerWallet,
-        tokenAdmin,
-        "lol",
-        "LOL",
-        9
+        constructorArgs[0],
+        constructorArgs[1],
+        constructorArgs[2],
+        constructorArgs[3],
       ).send();
     },
     node: getAztecNodeClient(),
   });
 
-  registerContractClassArtifact(
+  verifyContractInstanceDeployment({
     contractLoggingName,
-    tokenContractArtifactJson,
-    tokenContract.instance.contractClassId.toString(),
-    tokenContract.instance.version
-  ).catch((err) => {
-    logger.error(err);
+    contractInstanceAddress: tokenContract.address.toString(),
+    verifyArgs: {
+      artifactObj: tokenContractArtifactJson,
+      publicKeysString: tokenContract.instance.publicKeys.toString(),
+      deployer: tokenContract.instance.deployer.toString(),
+      salt: tokenContract.instance.salt.toString(),
+      constructorArgs: constructorArgs.map((arg) => arg.toString()),
+    },
+    deployerMetadata: {
+      contractIdentifier: contractLoggingName,
+      details: "Token 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}`);
   });
 
   await Promise.all([
     logAndWaitForTx(
       tokenContract.methods
         .mint_to_public(namedWallets.alice.getAddress(), 1000)
         .send(),
-      "Mint to Alice"
+      "Mint to Alice",
     ),
     logAndWaitForTx(
       tokenContract.methods
         .mint_to_public(namedWallets.bob.getAddress(), 1000)
         .send(),
-      "Mint to Bob"
+      "Mint to Bob",
     ),
     logAndWaitForTx(
       tokenContract.methods
         .mint_to_public(namedWallets.charlie.getAddress(), 1000)
         .send(),
-      "Mint to Charlie"
+      "Mint to Charlie",
     ),
   ]);
   const [balanceAlice, balanceBob, balanceCharlie] = await Promise.all([
@@ -83,19 +109,19 @@ export async function run() {
   const aliceContract = (await Contract.at(
     tokenContract.address,
     TokenContract.artifact,
-    namedWallets.alice
+    namedWallets.alice,
   )) as TokenContract;
 
   const bobsTokenContract = (await Contract.at(
     tokenContract.address,
     TokenContract.artifact,
-    namedWallets.bob
+    namedWallets.bob,
   )) as TokenContract;
 
   const charliesTokenContract = (await Contract.at(
     tokenContract.address,
     TokenContract.artifact,
-    namedWallets.charlie
+    namedWallets.charlie,
   )) as TokenContract;
 
   let bobNonce = 0;
@@ -105,10 +131,10 @@ export async function run() {
         namedWallets.bob.getAddress(),
         namedWallets.alice.getAddress(),
         100,
-        bobNonce
+        bobNonce,
       )
       .send(),
-    "Public transfer from Alice to Bob"
+    "Public transfer from Alice to Bob",
   );
   bobNonce++;
 
@@ -130,7 +156,7 @@ export async function run() {
     charliesTokenContract.methods
       .transfer_to_private(namedWallets.alice.getAddress(), 100)
       .send(),
-    "Public to private transfer from Charlie to Alice"
+    "Public to private transfer from Charlie to Alice",
   );
 
   let aliceNonce = 0;
@@ -140,10 +166,10 @@ export async function run() {
         namedWallets.alice.getAddress(),
         namedWallets.bob.getAddress(),
         100,
-        aliceNonce
+        aliceNonce,
       )
       .send(),
-    "Private transfer from Bob to Alice"
+    "Private transfer from Bob to Alice",
   );
   aliceNonce++;