@aztec/aztec 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/src/examples/token.ts

@@ -0,0 +1,74 @@
+import { getSingleKeyAccount } from '@aztec/accounts/single_key';
+import { type AccountWallet, Fr, createPXEClient } from '@aztec/aztec.js';
+import { createLogger } from '@aztec/foundation/log';
+import { TokenContract } from '@aztec/noir-contracts.js/Token';
+
+const logger = createLogger('example:token');
+
+export const alicePrivateKey = Fr.random();
+export const bobPrivateKey = Fr.random();
+
+const url = 'http://localhost:8080';
+
+const pxe = createPXEClient(url);
+
+let aliceWallet: AccountWallet;
+let bobWallet: AccountWallet;
+
+const ALICE_MINT_BALANCE = 333n;
+const TRANSFER_AMOUNT = 33n;
+
+/**
+ * Main function.
+ */
+async function main() {
+  logger.info('Running token contract test on HTTP interface.');
+
+  const aliceAccount = await getSingleKeyAccount(pxe, alicePrivateKey);
+  aliceWallet = await aliceAccount.waitSetup();
+  const bobAccount = await getSingleKeyAccount(pxe, bobPrivateKey);
+  bobWallet = await bobAccount.waitSetup();
+  const alice = aliceWallet.getCompleteAddress();
+  const bob = bobWallet.getCompleteAddress();
+
+  logger.info(`Created Alice and Bob accounts: ${alice.address.toString()}, ${bob.address.toString()}`);
+
+  logger.info('Deploying Token...');
+  const token = await TokenContract.deploy(aliceWallet, alice, 'TokenName', 'TokenSymbol', 18).send().deployed();
+  logger.info('Token deployed');
+
+  // Create the contract abstraction and link it to Alice's and Bob's wallet for future signing
+  const tokenAlice = await TokenContract.at(token.address, aliceWallet);
+  const tokenBob = await TokenContract.at(token.address, bobWallet);
+
+  // Mint tokens to Alice
+  logger.info(`Minting ${ALICE_MINT_BALANCE} more coins to Alice...`);
+  const from = aliceWallet.getAddress(); // we are setting from to Alice here because of TODO(#9887)
+  await tokenAlice.methods.mint_to_private(from, aliceWallet.getAddress(), ALICE_MINT_BALANCE).send().wait();
+
+  logger.info(`${ALICE_MINT_BALANCE} tokens were successfully minted by Alice and transferred to private`);
+
+  const balanceAfterMint = await tokenAlice.methods.balance_of_private(alice).simulate();
+  logger.info(`Tokens successfully minted. New Alice's balance: ${balanceAfterMint}`);
+
+  // We will now transfer tokens from Alice to Bob
+  logger.info(`Transferring ${TRANSFER_AMOUNT} tokens from Alice to Bob...`);
+  await tokenAlice.methods.transfer(bob, TRANSFER_AMOUNT).send().wait();
+
+  // Check the new balances
+  const aliceBalance = await tokenAlice.methods.balance_of_private(alice).simulate();
+  logger.info(`Alice's balance ${aliceBalance}`);
+
+  const bobBalance = await tokenBob.methods.balance_of_private(bob).simulate();
+  logger.info(`Bob's balance ${bobBalance}`);
+}
+
+main()
+  .then(() => {
+    logger.info('Finished running successfully.');
+    process.exit(0);
+  })
+  .catch(err => {
+    logger.error('Error in main fn: ', err);
+    process.exit(1);
+  });

package/src/examples/util.ts

@@ -0,0 +1,44 @@
+import { EthAddress } from '@aztec/aztec.js';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+
+import type { Abi, Narrow } from 'abitype';
+import { type Account, type Chain, type Hex, type HttpTransport, type PublicClient, type WalletClient } from 'viem';
+
+/**
+ * Helper function to deploy ETH contracts.
+ * @param walletClient - A viem WalletClient.
+ * @param publicClient - A viem PublicClient.
+ * @param abi - The ETH contract's ABI (as abitype's Abi).
+ * @param bytecode  - The ETH contract's bytecode.
+ * @param args - Constructor arguments for the contract.
+ * @returns The ETH address the contract was deployed to.
+ */
+export async function deployL1Contract(
+  walletClient: WalletClient<HttpTransport, Chain, Account>,
+  publicClient: PublicClient<HttpTransport, Chain>,
+  abi: Narrow<Abi | readonly unknown[]>,
+  bytecode: Hex,
+  args: readonly unknown[] = [],
+): Promise<EthAddress> {
+  const hash = await walletClient.deployContract({
+    abi,
+    bytecode,
+    args,
+  });
+
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  const contractAddress = receipt.contractAddress;
+  if (!contractAddress) {
+    throw new Error(`No contract address found in receipt: ${jsonStringify(receipt)}`);
+  }
+
+  return EthAddress.fromString(receipt.contractAddress!);
+}
+
+/**
+ * Sleep for a given number of milliseconds.
+ * @param ms - the number of milliseconds to sleep for
+ */
+export function delay(ms: number): Promise<void> {
+  return new Promise<void>(resolve => setTimeout(resolve, ms));
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { createSandbox } from './sandbox.js';

package/src/mnemonic.ts

@@ -0,0 +1 @@
+export const DefaultMnemonic = 'test test test test test test test test test test test junk';

package/src/sandbox.ts

@@ -0,0 +1,165 @@
+#!/usr/bin/env -S node --no-warnings
+import { type AztecNodeConfig, AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
+import { AnvilTestWatcher, EthCheatCodes, SignerlessWallet } from '@aztec/aztec.js';
+import { DefaultMultiCallEntrypoint } from '@aztec/aztec.js/entrypoint';
+import { type BlobSinkClientInterface, createBlobSinkClient } from '@aztec/blob-sink/client';
+import { type AztecNode } from '@aztec/circuit-types';
+import { setupCanonicalL2FeeJuice } from '@aztec/cli/setup-contracts';
+import {
+  NULL_KEY,
+  createEthereumChain,
+  deployL1Contracts,
+  getL1ContractsConfigEnvVars,
+  waitForPublicClient,
+} from '@aztec/ethereum';
+import { createLogger } from '@aztec/foundation/log';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vks';
+import { ProtocolContractAddress, protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { type PXEServiceConfig, createPXEService, getPXEServiceConfig } from '@aztec/pxe';
+import {
+  type TelemetryClient,
+  getConfigEnvVars as getTelemetryClientConfig,
+  initTelemetryClient,
+} from '@aztec/telemetry-client';
+
+import { type HDAccount, type PrivateKeyAccount, createPublicClient, http as httpViemTransport } from 'viem';
+import { mnemonicToAccount } from 'viem/accounts';
+import { foundry } from 'viem/chains';
+
+import { DefaultMnemonic } from './mnemonic.js';
+
+const logger = createLogger('sandbox');
+
+const localAnvil = foundry;
+
+/**
+ * Function to deploy our L1 contracts to the sandbox L1
+ * @param aztecNodeConfig - The Aztec Node Config
+ * @param hdAccount - Account for publishing L1 contracts
+ */
+export async function deployContractsToL1(
+  aztecNodeConfig: AztecNodeConfig,
+  hdAccount: HDAccount | PrivateKeyAccount,
+  contractDeployLogger = logger,
+  opts: { assumeProvenThroughBlockNumber?: number; salt?: number } = {},
+) {
+  const chain = aztecNodeConfig.l1RpcUrl
+    ? createEthereumChain(aztecNodeConfig.l1RpcUrl, aztecNodeConfig.l1ChainId)
+    : { chainInfo: localAnvil };
+
+  await waitForPublicClient(aztecNodeConfig);
+
+  const l1Contracts = await deployL1Contracts(
+    aztecNodeConfig.l1RpcUrl,
+    hdAccount,
+    chain.chainInfo,
+    contractDeployLogger,
+    {
+      ...getL1ContractsConfigEnvVars(), // TODO: We should not need to be loading config from env again, caller should handle this
+      ...aztecNodeConfig,
+      l2FeeJuiceAddress: ProtocolContractAddress.FeeJuice,
+      vkTreeRoot: await getVKTreeRoot(),
+      protocolContractTreeRoot,
+      assumeProvenThrough: opts.assumeProvenThroughBlockNumber,
+      salt: opts.salt,
+    },
+  );
+
+  aztecNodeConfig.l1Contracts = l1Contracts.l1ContractAddresses;
+
+  return aztecNodeConfig.l1Contracts;
+}
+
+/** Sandbox settings. */
+export type SandboxConfig = AztecNodeConfig & {
+  /** Mnemonic used to derive the L1 deployer private key.*/
+  l1Mnemonic: string;
+  /** Salt used to deploy L1 contracts.*/
+  l1Salt: string;
+};
+
+/**
+ * Create and start a new Aztec Node and PXE. Deploys L1 contracts.
+ * Does not start any HTTP services nor populate any initial accounts.
+ * @param config - Optional Sandbox settings.
+ */
+export async function createSandbox(config: Partial<SandboxConfig> = {}) {
+  const aztecNodeConfig: AztecNodeConfig = { ...getConfigEnvVars(), ...config };
+  const hdAccount = mnemonicToAccount(config.l1Mnemonic || DefaultMnemonic);
+  if (!aztecNodeConfig.publisherPrivateKey || aztecNodeConfig.publisherPrivateKey === NULL_KEY) {
+    const privKey = hdAccount.getHdKey().privateKey;
+    aztecNodeConfig.publisherPrivateKey = `0x${Buffer.from(privKey!).toString('hex')}`;
+  }
+  if (!aztecNodeConfig.validatorPrivateKey || aztecNodeConfig.validatorPrivateKey === NULL_KEY) {
+    const privKey = hdAccount.getHdKey().privateKey;
+    aztecNodeConfig.validatorPrivateKey = `0x${Buffer.from(privKey!).toString('hex')}`;
+  }
+
+  let watcher: AnvilTestWatcher | undefined = undefined;
+  if (!aztecNodeConfig.p2pEnabled) {
+    const l1ContractAddresses = await deployContractsToL1(aztecNodeConfig, hdAccount, undefined, {
+      assumeProvenThroughBlockNumber: Number.MAX_SAFE_INTEGER,
+      salt: config.l1Salt ? parseInt(config.l1Salt) : undefined,
+    });
+
+    const chain = aztecNodeConfig.l1RpcUrl
+      ? createEthereumChain(aztecNodeConfig.l1RpcUrl, aztecNodeConfig.l1ChainId)
+      : { chainInfo: localAnvil };
+
+    const publicClient = createPublicClient({
+      chain: chain.chainInfo,
+      transport: httpViemTransport(aztecNodeConfig.l1RpcUrl),
+    });
+
+    watcher = new AnvilTestWatcher(
+      new EthCheatCodes(aztecNodeConfig.l1RpcUrl),
+      l1ContractAddresses.rollupAddress,
+      publicClient,
+    );
+    watcher.setIsSandbox(true);
+    await watcher.start();
+  }
+
+  const telemetry = initTelemetryClient(getTelemetryClientConfig());
+  // Create a local blob sink client inside the sandbox, no http connectivity
+  const blobSinkClient = createBlobSinkClient();
+  const node = await createAztecNode(aztecNodeConfig, { telemetry, blobSinkClient });
+  const pxe = await createAztecPXE(node);
+
+  await setupCanonicalL2FeeJuice(
+    new SignerlessWallet(pxe, new DefaultMultiCallEntrypoint(aztecNodeConfig.l1ChainId, aztecNodeConfig.version)),
+    aztecNodeConfig.l1Contracts.feeJuicePortalAddress,
+    undefined,
+    logger.info,
+  );
+
+  const stop = async () => {
+    await node.stop();
+    await watcher?.stop();
+  };
+
+  return { node, pxe, aztecNodeConfig, stop };
+}
+
+/**
+ * Create and start a new Aztec RPC HTTP Server
+ * @param config - Optional Aztec node settings.
+ */
+export async function createAztecNode(
+  config: Partial<AztecNodeConfig> = {},
+  deps: { telemetry?: TelemetryClient; blobSinkClient?: BlobSinkClientInterface } = {},
+) {
+  const aztecNodeConfig: AztecNodeConfig = { ...getConfigEnvVars(), ...config };
+  const node = await AztecNodeService.createAndSync(aztecNodeConfig, deps);
+  return node;
+}
+
+/**
+ * Create and start a new Aztec PXE HTTP Server
+ * @param config - Optional PXE settings.
+ */
+export async function createAztecPXE(node: AztecNode, config: Partial<PXEServiceConfig> = {}) {
+  const pxeServiceConfig: PXEServiceConfig = { ...getPXEServiceConfig(), ...config };
+  const pxe = await createPXEService(node, pxeServiceConfig);
+  return pxe;
+}

package/src/splash.ts

@@ -0,0 +1,10 @@
+export const splash: string =
+  '\n' +
+  '               _\n' +
+  '    /\\        | |\n' +
+  '   /  \\    ___| |_ ___  ___ \n' +
+  '  / /\\ \\  |_  / __/ _ \\/ __|\n' +
+  ' / ____ \\  / /| ||  __/ (__ \n' +
+  '/_/___ \\_\\/___|\\__\\___|\\___|\n';
+
+export const github = 'https://github.com/AztecProtocol';