@aztec/end-to-end 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/spartan/utils.ts

@@ -1,89 +1,82 @@
-import { createAztecNodeClient, createLogger, sleep } from '@aztec/aztec.js';
-import type { RollupCheatCodes } from '@aztec/aztec.js/ethereum';
+import { createLogger, sleep } from '@aztec/aztec.js';
+import type { RollupCheatCodes } from '@aztec/aztec/testing';
+import type { L1ContractAddresses, ViemPublicClient } from '@aztec/ethereum';
 import type { Logger } from '@aztec/foundation/log';
-import type { SequencerConfig } from '@aztec/sequencer-client';
+import { makeBackoff, retry } from '@aztec/foundation/retry';
+import { schemas } from '@aztec/foundation/schemas';
+import {
+  type AztecNodeAdmin,
+  type AztecNodeAdminConfig,
+  createAztecNodeAdminClient,
+  createAztecNodeClient,
+} from '@aztec/stdlib/interfaces/client';
 
 import { ChildProcess, exec, execSync, spawn } from 'child_process';
 import path from 'path';
 import { promisify } from 'util';
+import { createPublicClient, fallback, http } from 'viem';
 import { z } from 'zod';
 
-import { AlertChecker, type AlertConfig } from '../quality_of_service/alert_checker.js';
-
 const execAsync = promisify(exec);
 
 const logger = createLogger('e2e:k8s-utils');
 
-const ethereumHostsSchema = z.string().refine(
-  str =>
-    str.split(',').every(url => {
-      try {
-        new URL(url.trim());
-        return true;
-      } catch {
-        return false;
-      }
-    }),
-  'ETHEREUM_HOSTS must be a comma-separated list of valid URLs',
-);
-
-const k8sLocalConfigSchema = z.object({
-  ETHEREUM_SLOT_DURATION: z.coerce.number().min(1, 'ETHEREUM_SLOT_DURATION env variable must be set'),
-  AZTEC_SLOT_DURATION: z.coerce.number().min(1, 'AZTEC_SLOT_DURATION env variable must be set'),
-  AZTEC_EPOCH_DURATION: z.coerce.number().min(1, 'AZTEC_EPOCH_DURATION env variable must be set'),
-  AZTEC_PROOF_SUBMISSION_WINDOW: z.coerce.number().min(1, 'AZTEC_PROOF_SUBMISSION_WINDOW env variable must be set'),
-  INSTANCE_NAME: z.string().min(1, 'INSTANCE_NAME env variable must be set'),
-  NAMESPACE: z.string().min(1, 'NAMESPACE env variable must be set'),
-  CONTAINER_NODE_PORT: z.coerce.number().default(8080),
-  CONTAINER_SEQUENCER_PORT: z.coerce.number().default(8080),
-  CONTAINER_PROVER_NODE_PORT: z.coerce.number().default(8080),
-  CONTAINER_PXE_PORT: z.coerce.number().default(8080),
-  CONTAINER_ETHEREUM_PORT: z.coerce.number().default(8545),
-  CONTAINER_METRICS_PORT: z.coerce.number().default(80),
-  GRAFANA_PASSWORD: z.string().optional(),
-  METRICS_API_PATH: z.string().default('/api/datasources/proxy/uid/spartan-metrics-prometheus/api/v1'),
-  SPARTAN_DIR: z.string().min(1, 'SPARTAN_DIR env variable must be set'),
-  ETHEREUM_HOSTS: ethereumHostsSchema.optional(),
-  L1_ACCOUNT_MNEMONIC: z.string().default('test test test test test test test test test test test junk'),
-  SEPOLIA_RUN: z.string().default('false'),
-  K8S: z.literal('local'),
+const testConfigSchema = z.object({
+  NAMESPACE: z.string().default('scenario'),
+  REAL_VERIFIER: schemas.Boolean.optional().default(true),
+  CREATE_ETH_DEVNET: schemas.Boolean.optional().default(false),
+  L1_RPC_URLS_JSON: z.string().optional(),
 });
 
-const k8sGCloudConfigSchema = k8sLocalConfigSchema.extend({
-  K8S: z.literal('gcloud'),
-  CLUSTER_NAME: z.string().min(1, 'CLUSTER_NAME env variable must be set'),
-  REGION: z.string().min(1, 'REGION env variable must be set'),
-});
-
-const directConfigSchema = z.object({
-  PXE_URL: z.string().url('PXE_URL must be a valid URL'),
-  NODE_URL: z.string().url('NODE_URL must be a valid URL'),
-  ETHEREUM_HOSTS: ethereumHostsSchema,
-  K8S: z.literal('false'),
-});
+export type TestConfig = z.infer<typeof testConfigSchema>;
 
-const envSchema = z.discriminatedUnion('K8S', [k8sLocalConfigSchema, k8sGCloudConfigSchema, directConfigSchema]);
+export function setupEnvironment(env: unknown): TestConfig {
+  const config = testConfigSchema.parse(env);
+  logger.warn(`Loaded env config`, config);
+  return config;
+}
 
-export type K8sLocalConfig = z.infer<typeof k8sLocalConfigSchema>;
-export type K8sGCloudConfig = z.infer<typeof k8sGCloudConfigSchema>;
-export type DirectConfig = z.infer<typeof directConfigSchema>;
-export type EnvConfig = z.infer<typeof envSchema>;
+/**
+ * @param path - The path to the script, relative to the project root
+ * @param args - The arguments to pass to the script
+ * @param logger - The logger to use
+ * @returns The exit code of the script
+ */
+function runScript(path: string, args: string[], logger: Logger, env?: Record<string, string>) {
+  const childProcess = spawn(path, args, {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: env ? { ...process.env, ...env } : process.env,
+  });
+  return new Promise<number>((resolve, reject) => {
+    childProcess.on('close', (code: number | null) => resolve(code ?? 0));
+    childProcess.on('error', reject);
+    childProcess.stdout?.on('data', (data: Buffer) => {
+      logger.info(data.toString());
+    });
+    childProcess.stderr?.on('data', (data: Buffer) => {
+      logger.error(data.toString());
+    });
+  });
+}
 
-export function isK8sConfig(config: EnvConfig): config is K8sLocalConfig | K8sGCloudConfig {
-  return config.K8S === 'local' || config.K8S === 'gcloud';
+export function getAztecBin() {
+  return path.join(getGitProjectRoot(), 'yarn-project/aztec/dest/bin/index.js');
 }
 
-export function isGCloudConfig(config: EnvConfig): config is K8sGCloudConfig {
-  return config.K8S === 'gcloud';
+/**
+ * Runs the Aztec binary
+ * @param args - The arguments to pass to the Aztec binary
+ * @param logger - The logger to use
+ * @param env - Optional environment variables to set for the process
+ * @returns The exit code of the Aztec binary
+ */
+export function runAztecBin(args: string[], logger: Logger, env?: Record<string, string>) {
+  return runScript('node', [getAztecBin(), ...args], logger, env);
 }
 
-export function setupEnvironment(env: unknown): EnvConfig {
-  const config = envSchema.parse(env);
-  if (isGCloudConfig(config)) {
-    const command = `gcloud container clusters get-credentials ${config.CLUSTER_NAME} --region=${config.REGION}`;
-    execSync(command);
-  }
-  return config;
+export function runProjectScript(script: string, args: string[], logger: Logger, env?: Record<string, string>) {
+  const scriptPath = script.startsWith('/') ? script : path.join(getGitProjectRoot(), script);
+  return runScript(scriptPath, args, logger, env);
 }
 
 export async function startPortForward({
@@ -103,7 +96,7 @@ export async function startPortForward({
 }> {
   const hostPortAsString = hostPort ? hostPort.toString() : '';
 
-  logger.info(`kubectl port-forward -n ${namespace} ${resource} ${hostPortAsString}:${containerPort}`);
+  logger.debug(`kubectl port-forward -n ${namespace} ${resource} ${hostPortAsString}:${containerPort}`);
 
   const process = spawn(
     'kubectl',
@@ -121,21 +114,20 @@ export async function startPortForward({
       const str = data.toString() as string;
       if (!isResolved && str.includes('Forwarding from')) {
         isResolved = true;
-        logger.info(str);
+        logger.debug(`Port forward for ${resource}: ${str}`);
         const port = str.search(/:\d+/);
         if (port === -1) {
           throw new Error('Port not found in port forward output');
         }
         const portNumber = parseInt(str.slice(port + 1));
-        logger.info(`Port forward connected: ${portNumber}`);
-        logger.info(`Port forward connected: ${portNumber}`);
+        logger.verbose(`Port forwarded for ${resource} at ${portNumber}:${containerPort}`);
         resolve(portNumber);
       } else {
         logger.silent(str);
       }
     });
     process.stderr?.on('data', data => {
-      logger.info(data.toString());
+      logger.verbose(`Port forward for ${resource}: ${data.toString()}`);
       // It's a strange thing:
       // If we don't pipe stderr, then the port forwarding does not work.
       // Log to silent because this doesn't actually report errors,
@@ -145,16 +137,16 @@ export async function startPortForward({
     process.on('close', () => {
       if (!isResolved) {
         isResolved = true;
-        logger.warn('Port forward closed before connection established');
+        logger.warn(`Port forward for ${resource} closed before connection established`);
         resolve(0);
       }
     });
     process.on('error', error => {
-      logger.error(`Port forward error: ${error}`);
+      logger.error(`Port forward for ${resource} error: ${error}`);
       resolve(0);
     });
     process.on('exit', code => {
-      logger.info(`Port forward exited with code ${code}`);
+      logger.verbose(`Port forward for ${resource} exited with code ${code}`);
       resolve(0);
     });
   });
@@ -164,6 +156,22 @@ export async function startPortForward({
   return { process, port };
 }
 
+export function startPortForwardForRPC(namespace: string) {
+  return startPortForward({
+    resource: `services/${namespace}-rpc-aztec-node`,
+    namespace,
+    containerPort: 8080,
+  });
+}
+
+export function startPortForwardForEthereum(namespace: string) {
+  return startPortForward({
+    resource: `services/${namespace}-eth-execution`,
+    namespace,
+    containerPort: 8545,
+  });
+}
+
 export async function deleteResourceByName({
   resource,
   namespace,
@@ -187,12 +195,18 @@ export async function deleteResourceByLabel({
   resource,
   namespace,
   label,
+  timeout = '5m',
+  force = false,
 }: {
   resource: string;
   namespace: string;
   label: string;
+  timeout?: string;
+  force?: boolean;
 }) {
-  const command = `kubectl delete ${resource} -l ${label} -n ${namespace} --ignore-not-found=true --wait=true`;
+  const command = `kubectl delete ${resource} -l ${label} -n ${namespace} --ignore-not-found=true --wait=true --timeout=${timeout} ${
+    force ? '--force' : ''
+  }`;
   logger.info(`command: ${command}`);
   const { stdout } = await execAsync(command);
   return stdout;
@@ -304,13 +318,13 @@ export async function installChaosMeshChart({
     const deleteArgs = {
       resource: 'podchaos',
       namespace: chaosMeshNamespace,
-      name: `${targetNamespace}-${instanceName}`,
+      label: `app.kubernetes.io/instance=${instanceName}`,
     };
     logger.info(`Deleting podchaos resource`);
-    await deleteResourceByName(deleteArgs).catch(e => {
+    await deleteResourceByLabel(deleteArgs).catch(e => {
       logger.error(`Error deleting podchaos resource: ${e}`);
       logger.info(`Force deleting podchaos resource`);
-      return deleteResourceByName({ ...deleteArgs, force: true });
+      return deleteResourceByLabel({ ...deleteArgs, force: true });
     });
   }
 
@@ -412,10 +426,12 @@ export function applyValidatorKill({
   namespace,
   spartanDir,
   logger,
+  values,
 }: {
   namespace: string;
   spartanDir: string;
   logger: Logger;
+  values?: Record<string, string | number>;
 }) {
   return installChaosMeshChart({
     instanceName: 'validator-kill',
@@ -423,6 +439,7 @@ export function applyValidatorKill({
     valuesFile: 'validator-kill.yaml',
     helmChartDir: getChartDir(spartanDir, 'aztec-chaos-scenarios'),
     logger,
+    values,
   });
 }
 
@@ -497,64 +514,109 @@ export async function enableValidatorDynamicBootNode(
   logger.info(`Validator dynamic boot node enabled`);
 }
 
-export async function runAlertCheck(config: EnvConfig, alerts: AlertConfig[], logger: Logger) {
-  if (isK8sConfig(config)) {
-    const { process, port } = await startPortForward({
-      resource: `svc/metrics-grafana`,
-      namespace: 'metrics',
-      containerPort: config.CONTAINER_METRICS_PORT,
-    });
-    const alertChecker = new AlertChecker(logger, {
-      grafanaEndpoint: `http://localhost:${port}${config.METRICS_API_PATH}`,
-      grafanaCredentials: `admin:${config.GRAFANA_PASSWORD}`,
-    });
-    await alertChecker.runAlertCheck(alerts);
-    process.kill();
-  } else {
-    logger.info('Not running alert check in non-k8s environment');
-  }
+export async function getSequencers(namespace: string) {
+  const command = `kubectl get pods -l app.kubernetes.io/component=validator -n ${namespace} -o jsonpath='{.items[*].metadata.name}'`;
+  const { stdout } = await execAsync(command);
+  const sequencers = stdout.split(' ');
+  logger.verbose(`Found sequencer pods ${sequencers.join(', ')}`);
+  return sequencers;
 }
 
-export async function updateSequencerConfig(url: string, config: Partial<SequencerConfig>) {
-  const node = createAztecNodeClient(url);
-  await node.setConfig(config);
+export function updateSequencersConfig(env: TestConfig, config: Partial<AztecNodeAdminConfig>) {
+  return withSequencersAdmin(env, async client => {
+    await client.setConfig(config);
+    return client.getConfig();
+  });
 }
 
-export async function getSequencers(namespace: string) {
-  const command = `kubectl get pods -l app=validator -n ${namespace} -o jsonpath='{.items[*].metadata.name}'`;
-  const { stdout } = await execAsync(command);
-  return stdout.split(' ');
+export function getSequencersConfig(env: TestConfig) {
+  return withSequencersAdmin(env, client => client.getConfig());
 }
 
-export async function updateK8sSequencersConfig(args: {
-  containerPort: number;
-  namespace: string;
-  config: Partial<SequencerConfig>;
-}) {
-  const { containerPort, namespace, config } = args;
+export async function withSequencersAdmin<T>(env: TestConfig, fn: (node: AztecNodeAdmin) => Promise<T>): Promise<T[]> {
+  const adminContainerPort = 8880;
+  const namespace = env.NAMESPACE;
   const sequencers = await getSequencers(namespace);
+  const results = [];
+
   for (const sequencer of sequencers) {
     const { process, port } = await startPortForward({
       resource: `pod/${sequencer}`,
       namespace,
-      containerPort,
+      containerPort: adminContainerPort,
     });
 
     const url = `http://localhost:${port}`;
-    await updateSequencerConfig(url, config);
+    await retry(
+      () => fetch(`${url}/status`).then(res => res.status === 200),
+      'forward node admin port',
+      makeBackoff([1, 1, 2, 6]),
+      logger,
+      true,
+    );
+    const client = createAztecNodeAdminClient(url);
+    results.push(await fn(client));
     process.kill();
   }
+
+  return results;
 }
 
-export async function updateSequencersConfig(env: EnvConfig, config: Partial<SequencerConfig>) {
-  if (isK8sConfig(env)) {
-    await updateK8sSequencersConfig({
-      containerPort: env.CONTAINER_NODE_PORT,
-      namespace: env.NAMESPACE,
-      config,
+/**
+ * Returns a public viem client to the eth execution node. If it was part of a local eth devnet,
+ * it first port-forwards the service and points to it. Otherwise, just uses the external RPC url.
+ */
+export async function getPublicViemClient(
+  env: TestConfig,
+  /** If set, will push the new process into it */
+  processes?: ChildProcess[],
+): Promise<{ url: string; client: ViemPublicClient; process?: ChildProcess }> {
+  const { NAMESPACE, CREATE_ETH_DEVNET, L1_RPC_URLS_JSON } = env;
+  if (CREATE_ETH_DEVNET) {
+    logger.info(`Creating port forward to eth execution node`);
+    const { process, port } = await startPortForward({
+      resource: `svc/${NAMESPACE}-eth-execution`,
+      namespace: NAMESPACE,
+      containerPort: 8545,
     });
+    const url = `http://127.0.0.1:${port}`;
+    const client: ViemPublicClient = createPublicClient({ transport: fallback([http(url)]) });
+    if (processes) {
+      processes.push(process);
+    }
+    return { url, client, process };
   } else {
-    await updateSequencerConfig(env.NODE_URL, config);
+    logger.info(`Connecting to the eth execution node at ${L1_RPC_URLS_JSON}`);
+    if (!L1_RPC_URLS_JSON) {
+      throw new Error(`L1_RPC_URLS_JSON is not defined`);
+    }
+    const client: ViemPublicClient = createPublicClient({ transport: fallback([http(L1_RPC_URLS_JSON)]) });
+    return { url: L1_RPC_URLS_JSON, client };
+  }
+}
+
+/** Queries an Aztec node for the L1 deployment addresses */
+export async function getL1DeploymentAddresses(env: TestConfig): Promise<L1ContractAddresses> {
+  let forwardProcess: ChildProcess | undefined;
+  try {
+    const [sequencer] = await getSequencers(env.NAMESPACE);
+    const { process, port } = await startPortForward({
+      resource: `pod/${sequencer}`,
+      namespace: env.NAMESPACE,
+      containerPort: 8080,
+    });
+
+    forwardProcess = process;
+    const url = `http://127.0.0.1:${port}`;
+    const node = createAztecNodeClient(url);
+    return await retry(
+      () => node.getNodeInfo().then(i => i.l1ContractAddresses),
+      'get node info',
+      makeBackoff([1, 3, 6]),
+      logger,
+    );
+  } finally {
+    forwardProcess?.kill();
   }
 }
 
@@ -580,3 +642,19 @@ export async function rollAztecPods(namespace: string) {
   await waitForResourceByLabel({ resource: 'pods', namespace: namespace, label: 'app=validator' });
   await waitForResourceByLabel({ resource: 'pods', namespace: namespace, label: 'app=pxe' });
 }
+
+/**
+ * Returns the absolute path to the git repository root
+ */
+export function getGitProjectRoot(): string {
+  try {
+    const rootDir = execSync('git rev-parse --show-toplevel', {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+
+    return rootDir;
+  } catch (error) {
+    throw new Error(`Failed to determine git project root: ${error}`);
+  }
+}

package/dest/e2e_prover/e2e_prover_test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"e2e_prover_test.d.ts","sourceRoot":"","sources":["../../src/e2e_prover/e2e_prover_test.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,2BAA2B,EAChC,UAAU,EACV,KAAK,MAAM,EAIZ,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAqB,KAAK,6BAA6B,EAAuB,MAAM,kBAAkB,CAAC;AAE9G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAG9D,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAQpD,OAAO,EAEL,KAAK,iBAAiB,EAIvB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AASlE;;;;;GAKG;AAEH,qBAAa,cAAc;IA4BvB,OAAO,CAAC,sBAAsB;IAE9B,OAAO,CAAC,UAAU;IA7BpB,MAAM,CAAC,UAAU,SAAU;IAC3B,MAAM,CAAC,YAAY,SAAS;IAC5B,MAAM,CAAC,cAAc,SAAO;IAC5B,OAAO,CAAC,eAAe,CAAmB;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,kBAAkB,EAAE,CAAM;IAC5C,OAAO,EAAE,0BAA0B,EAAE,CAAM;IAC3C,QAAQ,EAAE,eAAe,EAAE,CAAM;IACjC,eAAe,EAAG,aAAa,CAAC;IAChC,QAAQ,EAAG,cAAc,CAAC;IAC1B,SAAS,EAAG,SAAS,CAAC;IACtB,GAAG,EAAG,UAAU,CAAC;IACjB,UAAU,EAAG,UAAU,CAAC;IACxB,QAAQ,EAAG,cAAc,CAAC;IAC1B,OAAO,CAAC,gBAAgB,CAAqB;IAC7C,OAAO,CAAC,eAAe,CAAC,CAAsB;IAC9C,OAAO,CAAC,iBAAiB,CAAC,CAAsB;IAChD,oBAAoB,CAAC,EAAE,6BAA6B,CAAC;IACrD,YAAY,EAAE,aAAa,EAAE,CAAM;IACnC,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,mBAAmB,CAAc;IAClC,WAAW,EAAG,2BAA2B,CAAC;IAC1C,aAAa,EAAG,UAAU,CAAC;gBAGhC,QAAQ,EAAE,MAAM,EACR,sBAAsB,EAAE,MAAM,EACtC,QAAQ,EAAE,UAAU,EACZ,UAAU,UAAO;IAW3B;;;;OAIG;IACG,kBAAkB;IAqDlB,KAAK;YA0JG,WAAW;IAQzB,QAAQ,YACA,MAAM,SACL,CAAC,OAAO,EAAE,iBAAiB,KAAK,QAAQ,CAAC,CAAC,YACxC,CAAC,YAAY,EAAE,CAAC,EAAE,OAAO,EAAE,iBAAiB,KAAK,QAAQ,IAAI,CAAC,KACtE,QAAQ,IAAI,CAAC,CAAwD;IAElE,QAAQ;IAeR,iBAAiB;IAiDjB,cAAc;CA4BrB"}

package/dest/sample-dapp/connect.js

@@ -1,12 +0,0 @@
-// docs:start:all
-import { createPXEClient } from '@aztec/aztec.js';
-const { PXE_URL = 'http://localhost:8080' } = process.env;
-async function main() {
-    const pxe = await createPXEClient(PXE_URL);
-    const { l1ChainId } = await pxe.getNodeInfo();
-    console.log(`Connected to chain ${l1ChainId}`);
-}
-main().catch((err)=>{
-    console.error(`Error in app: ${err}`);
-    process.exit(1);
-}); // docs:end:all

package/dest/sample-dapp/contracts.js

@@ -1,10 +0,0 @@
-// docs:start:imports
-import { AztecAddress } from '@aztec/aztec.js';
-import { TokenContract } from '@aztec/noir-contracts.js/Token';
-import { readFileSync } from 'fs';
-// docs:end:imports
-// docs:start:get-tokens
-export async function getToken(wallet) {
-    const addresses = JSON.parse(readFileSync('addresses.json'));
-    return TokenContract.at(AztecAddress.fromString(addresses.token), wallet);
-} // docs:end:get-tokens

package/dest/sample-dapp/deploy.js

@@ -1,35 +0,0 @@
-// docs:start:deploy-imports
-import { getInitialTestAccountsWallets } from '@aztec/accounts/testing';
-import { Contract, createPXEClient, waitForPXE } from '@aztec/aztec.js';
-// docs:end:deploy-imports
-import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
-import { writeFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-// docs:start:dapp-deploy
-const { PXE_URL = 'http://localhost:8080' } = process.env;
-async function main() {
-    const pxe = createPXEClient(PXE_URL);
-    await waitForPXE(pxe);
-    const [ownerWallet] = await getInitialTestAccountsWallets(pxe);
-    const ownerAddress = ownerWallet.getAddress();
-    const token = await Contract.deploy(ownerWallet, TokenContractArtifact, [
-        ownerAddress,
-        'TokenName',
-        'TKN',
-        18
-    ]).send().deployed();
-    console.log(`Token deployed at ${token.address.toString()}`);
-    const addresses = {
-        token: token.address.toString()
-    };
-    writeFileSync('addresses.json', JSON.stringify(addresses, null, 2));
-}
-// docs:end:dapp-deploy
-// Execute main only if run directly
-if (process.argv[1].replace(/\/index\.m?js$/, '') === fileURLToPath(import.meta.url).replace(/\/index\.m?js$/, '')) {
-    main().catch((err)=>{
-        console.error(`Error in deployment script: ${err}`);
-        process.exit(1);
-    });
-}
-export { main as deploy };

package/dest/sample-dapp/index.js

@@ -1,98 +0,0 @@
-// docs:start:imports
-import { getInitialTestAccountsWallets } from '@aztec/accounts/testing';
-import { createPXEClient, waitForPXE } from '@aztec/aztec.js';
-import { fileURLToPath } from '@aztec/foundation/url';
-import { getToken } from './contracts.mjs';
-// docs:end:imports
-const { PXE_URL = 'http://localhost:8080' } = process.env;
-// docs:start:showAccounts
-async function showAccounts(pxe) {
-    const accounts = await pxe.getRegisteredAccounts();
-    console.log(`User accounts:\n${accounts.map((a)=>a.address).join('\n')}`);
-}
-// docs:end:showAccounts
-// docs:start:showPrivateBalances
-async function showPrivateBalances(pxe) {
-    const [owner] = await getInitialTestAccountsWallets(pxe);
-    const token = await getToken(owner);
-    const accounts = await pxe.getRegisteredAccounts();
-    for (const account of accounts){
-        // highlight-next-line:showPrivateBalances
-        const balance = await token.methods.balance_of_private(account.address).simulate();
-        console.log(`Balance of ${account.address}: ${balance}`);
-    }
-}
-// docs:end:showPrivateBalances
-// docs:start:mintPrivateFunds
-async function mintPrivateFunds(pxe) {
-    const [ownerWallet] = await getInitialTestAccountsWallets(pxe);
-    const token = await getToken(ownerWallet);
-    await showPrivateBalances(pxe);
-    // We mint tokens to the owner
-    const mintAmount = 20n;
-    const from = ownerWallet.getAddress(); // we are setting from to owner here because we need a sender to calculate the tag
-    await token.methods.mint_to_private(from, ownerWallet.getAddress(), mintAmount).send().wait();
-    await showPrivateBalances(pxe);
-}
-// docs:end:mintPrivateFunds
-// docs:start:transferPrivateFunds
-async function transferPrivateFunds(pxe) {
-    const [owner, recipient] = await getInitialTestAccountsWallets(pxe);
-    const token = await getToken(owner);
-    await showPrivateBalances(pxe);
-    console.log(`Sending transaction, awaiting transaction to be mined`);
-    const receipt = await token.methods.transfer(recipient.getAddress(), 1).send().wait();
-    console.log(`Transaction ${receipt.txHash} has been mined on block ${receipt.blockNumber}`);
-    await showPrivateBalances(pxe);
-}
-// docs:end:transferPrivateFunds
-// docs:start:showPublicBalances
-async function showPublicBalances(pxe) {
-    const [owner] = await getInitialTestAccountsWallets(pxe);
-    const token = await getToken(owner);
-    const accounts = await pxe.getRegisteredAccounts();
-    for (const account of accounts){
-        // highlight-next-line:showPublicBalances
-        const balance = await token.methods.balance_of_public(account.address).simulate();
-        console.log(`Balance of ${account.address}: ${balance}`);
-    }
-}
-// docs:end:showPublicBalances
-// docs:start:mintPublicFunds
-async function mintPublicFunds(pxe) {
-    const [owner] = await getInitialTestAccountsWallets(pxe);
-    const token = await getToken(owner);
-    await showPublicBalances(pxe);
-    console.log(`Sending transaction, awaiting transaction to be mined`);
-    const receipt = await token.methods.mint_to_public(owner.getAddress(), 100).send().wait();
-    console.log(`Transaction ${receipt.txHash} has been mined on block ${receipt.blockNumber}`);
-    await showPublicBalances(pxe);
-    // docs:start:showLogs
-    const blockNumber = await pxe.getBlockNumber();
-    const logs = (await pxe.getPublicLogs({
-        fromBlock: blockNumber - 1
-    })).logs;
-    const textLogs = logs.map((extendedLog)=>extendedLog.toHumanReadable().slice(0, 200));
-    for (const log of textLogs)console.log(`Log emitted: ${log}`);
-// docs:end:showLogs
-}
-// docs:end:mintPublicFunds
-async function main() {
-    const pxe = createPXEClient(PXE_URL);
-    await waitForPXE(pxe);
-    const { l1ChainId } = await pxe.getNodeInfo();
-    console.log(`Connected to chain ${l1ChainId}`);
-    await showAccounts(pxe);
-    await mintPrivateFunds(pxe);
-    await transferPrivateFunds(pxe);
-    await mintPublicFunds(pxe);
-}
-// Execute main only if run directly
-if (process.argv[1].replace(/\/index\.m?js$/, '') === fileURLToPath(import.meta.url).replace(/\/index\.m?js$/, '')) {
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    main().then(()=>process.exit(0)).catch((err)=>{
-        console.error(`Error in app: ${err}`);
-        process.exit(1);
-    });
-}
-export { main };

package/src/sample-dapp/connect.mjs

@@ -1,16 +0,0 @@
-// docs:start:all
-import { createPXEClient } from '@aztec/aztec.js';
-
-const { PXE_URL = 'http://localhost:8080' } = process.env;
-
-async function main() {
-  const pxe = await createPXEClient(PXE_URL);
-  const { l1ChainId } = await pxe.getNodeInfo();
-  console.log(`Connected to chain ${l1ChainId}`);
-}
-
-main().catch(err => {
-  console.error(`Error in app: ${err}`);
-  process.exit(1);
-});
-// docs:end:all

package/src/sample-dapp/contracts.mjs

@@ -1,14 +0,0 @@
-// docs:start:imports
-import { AztecAddress } from '@aztec/aztec.js';
-import { TokenContract } from '@aztec/noir-contracts.js/Token';
-
-import { readFileSync } from 'fs';
-
-// docs:end:imports
-
-// docs:start:get-tokens
-export async function getToken(wallet) {
-  const addresses = JSON.parse(readFileSync('addresses.json'));
-  return TokenContract.at(AztecAddress.fromString(addresses.token), wallet);
-}
-// docs:end:get-tokens