@aztec/end-to-end 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/src/automine/delivery/onchain_delivery_harness.ts

@@ -0,0 +1,213 @@
+import { type InitialAccountData, generateSchnorrAccounts } from '@aztec/accounts/testing';
+import type { FieldLike } from '@aztec/aztec.js/abi';
+import { NO_FROM } from '@aztec/aztec.js/account';
+import type { AztecAddress, CompleteAddress } from '@aztec/aztec.js/addresses';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { AccountManager } from '@aztec/aztec.js/wallet';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { type DeliveryEvent, OnchainDeliveryTestContract } from '@aztec/noir-test-contracts.js/OnchainDeliveryTest';
+import type { CustomRequest, ResolveCustomRequest, ResolveTaggingSecretStrategy } from '@aztec/pxe/config';
+import type { AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
+
+import { jest } from '@jest/globals';
+
+import { AUTOMINE_E2E_OPTS } from '../../fixtures/fixtures.js';
+import { ensureHandshakeRegistryPublished, setup, setupPXEAndGetWallet } from '../../fixtures/setup.js';
+import { TestWallet } from '../../test-wallet/test_wallet.js';
+
+// Builds the hook serving custom requests issued during the sender's simulations. Installed on the sender PXE at
+// creation but built only once the recipient exists, since serving typically needs the recipient's wallet and keys.
+export type CustomRequestResponder = (
+  recipient: TestWallet,
+  recipientAccount: InitialAccountData,
+  recipientCompleteAddress: CompleteAddress,
+) => ResolveCustomRequest;
+
+export type Mode = 'constrained' | 'unconstrained';
+
+// A single mode applies to both the event and note sends; `{ events, notes }` sends each in its own mode, which
+// exercises cross-mode handshake reuse: bootstrap in one mode, deliver in the other on the same handshake.
+export type DeliveryMode = Mode | { events: Mode; notes: Mode };
+
+const formatMode = (mode: DeliveryMode): string => (typeof mode === 'string' ? mode : `${mode.events}->${mode.notes}`);
+
+// Onchain private delivery has two orthogonal axes: the delivery MODE (constrained = nullifier-chained sequence;
+// unconstrained = no nullifier, windowed scan) and the tagging-secret SOURCE, which the wallet's
+// `resolveTaggingSecretStrategy` hook selects. This harness exercises (strategy, mode) cells end to end across two
+// PXEs that share only a node: the sender PXE sends, the recipient PXE discovers purely from onchain logs plus the
+// HandshakeRegistry.
+//
+// Cross-PXE is the meaningful setup: the recipient PXE holds no sender state, so a cell only "discovers" a message if
+// the source truly reached it.
+export function buildMessageDeliveryTest(opts: {
+  // Names the tagging-secret source, e.g. 'non-interactive handshake' or 'arbitrary secret'. The describe title is
+  // derived as `${strategy} x ${mode}`.
+  strategy: string;
+  mode: DeliveryMode;
+  // Required: every cell states its source explicitly rather than leaning on the PXE default (covered by unit tests).
+  senderHook: ResolveTaggingSecretStrategy;
+  // Recipient-side setup the source requires (e.g. registering a raw arbitrary secret); runs once after deployment.
+  recipientRegistration?: (
+    recipient: TestWallet,
+    recipientAddress: AztecAddress,
+    sender: AztecAddress,
+  ) => Promise<void>;
+  // Serves the custom requests issued during the sender's simulations (e.g. the registry's interactive-handshake
+  // signature request).
+  customRequestResponder?: CustomRequestResponder;
+  // Extra `it()`s to register in this cell's suite, e.g. assertions against state a custom `senderHook` recorded.
+  // Called inside the same `describe`, after the two baseline assertions below, so it shares their `beforeAll`
+  // instead of depending on Jest's cross-`describe` execution order.
+  additionalTests?: () => void;
+}) {
+  const { strategy, mode, senderHook, recipientRegistration, customRequestResponder, additionalTests } = opts;
+  const description = `${strategy} x ${formatMode(mode)}`;
+
+  describe(description, () => {
+    jest.setTimeout(300_000);
+
+    const eventValues = [10n, 20n, 30n];
+    const noteValues = [40n, 50n, 60n];
+
+    let aztecNode: AztecNode & AztecNodeDebug;
+    let walletSender: TestWallet;
+    let walletRecipient: TestWallet;
+    let sender: AztecAddress;
+    let recipient: AztecAddress;
+    let contractSender: OnchainDeliveryTestContract;
+    let teardownSender: () => Promise<void>;
+    let teardownRecipient: () => Promise<void>;
+    // Discovery results captured in beforeAll, so the assertions in the actual tests below stay pure.
+    // A failure during delivery fails beforeAll loudly instead of being swallowed as an expected red.
+    let discoveredEvents: FieldLike[];
+    let readNotes: bigint[];
+
+    const { events: eventMode, notes: noteMode } = typeof mode === 'string' ? { events: mode, notes: mode } : mode;
+    const sendEvent = (value: bigint) =>
+      eventMode === 'constrained'
+        ? contractSender.methods.emit_event(recipient, value)
+        : contractSender.methods.emit_event_unconstrained(recipient, value);
+    const sendNote = (value: bigint) =>
+      noteMode === 'constrained'
+        ? contractSender.methods.emit_note(recipient, value)
+        : contractSender.methods.emit_note_unconstrained(recipient, value);
+
+    let additionallyFundedAccounts: InitialAccountData[];
+    let recipientAccount: AccountManager | undefined;
+    let customRequestCount = 0;
+
+    beforeAll(async () => {
+      // The sender PXE holds the sender and carries this cell's tagging-secret-strategy hook. The recipient is funded
+      // at genesis here but created and deployed on the isolated recipient PXE below, so it carries no sender state
+      // from other cells.
+      ({
+        aztecNode,
+        additionallyFundedAccounts,
+        wallet: walletSender,
+        accounts: [sender],
+        teardown: teardownSender,
+      } = await setup(1, {
+        ...AUTOMINE_E2E_OPTS,
+        additionallyFundedAccounts: await generateSchnorrAccounts(1, 'schnorr'),
+        pxeCreationOptions: {
+          hooks: {
+            resolveTaggingSecretStrategy: senderHook,
+            resolveCustomRequest: async (request: CustomRequest) => {
+              if (!customRequestResponder) {
+                throw new Error('A custom request arrived but this test cell has no customRequestResponder configured');
+              }
+              if (!recipientAccount) {
+                throw new Error('A custom request arrived before the recipient wallet was created');
+              }
+              customRequestCount++;
+              const respond = customRequestResponder(
+                walletRecipient,
+                additionallyFundedAccounts[0],
+                await recipientAccount.getCompleteAddress(),
+              );
+              return respond(request);
+            },
+          },
+        },
+      }));
+
+      ({ wallet: walletRecipient, teardown: teardownRecipient } = await setupPXEAndGetWallet(
+        aztecNode,
+        aztecNode,
+        {},
+        undefined,
+        'pxe-recipient',
+      ));
+      recipientAccount = await walletRecipient.createSchnorrAccount(
+        additionallyFundedAccounts[0].secret,
+        additionallyFundedAccounts[0].salt,
+        additionallyFundedAccounts[0].signingKey,
+      );
+      await (await recipientAccount.getDeployMethod()).send({ from: NO_FROM });
+      recipient = recipientAccount.address;
+
+      await ensureHandshakeRegistryPublished(walletSender, sender);
+      const { contract: deployed, instance } = await OnchainDeliveryTestContract.deploy(walletSender).send({
+        from: sender,
+      });
+      contractSender = deployed;
+
+      await ensureHandshakeRegistryPublished(walletRecipient, recipient);
+      await walletRecipient.registerContract(instance, OnchainDeliveryTestContract.artifact);
+
+      await recipientRegistration?.(walletRecipient, recipient, sender);
+
+      // Constrained sends to one pair are strictly ordered, so deliver one tx at a time. The first send bootstraps the
+      // handshake (when the source is a handshake); the rest reuse it.
+      const blockNumbers: number[] = [];
+      for (const value of eventValues) {
+        const { receipt } = await sendEvent(value).send({ from: sender });
+        blockNumbers.push(receipt.blockNumber!);
+      }
+      for (const value of noteValues) {
+        await sendNote(value).send({ from: sender });
+      }
+
+      await walletRecipient.sync();
+
+      const events = await walletRecipient.getPrivateEvents<DeliveryEvent>(
+        OnchainDeliveryTestContract.events.DeliveryEvent,
+        {
+          contractAddress: contractSender.address,
+          fromBlock: BlockNumber(Math.min(...blockNumbers)),
+          toBlock: BlockNumber(Math.max(...blockNumbers) + 1),
+          scopes: [recipient],
+        },
+      );
+      discoveredEvents = events.map(e => e.event.value);
+
+      const contractRecipient = OnchainDeliveryTestContract.at(contractSender.address, walletRecipient);
+      const { result } = await contractRecipient.methods.get_note_values(recipient).simulate({ from: recipient });
+      readNotes = result.storage.slice(0, Number(result.len));
+    });
+
+    afterAll(async () => {
+      await teardownRecipient();
+      await teardownSender();
+    });
+
+    it('the recipient PXE discovers the events delivered by the sender PXE', () => {
+      expect(discoveredEvents.length).toBe(eventValues.length);
+      for (const value of eventValues) {
+        expect(discoveredEvents).toContainEqual(value);
+      }
+    });
+
+    it('the recipient PXE reads back the notes delivered by the sender PXE', () => {
+      expect(readNotes).toEqual(noteValues);
+    });
+
+    if (customRequestResponder) {
+      it('the custom request hook fires exactly once, on the send that bootstraps the tagging secret', () => {
+        expect(customRequestCount).toBe(1);
+      });
+    }
+
+    additionalTests?.();
+  });
+}

package/src/automine/token/blacklist_token_contract_test.ts

@@ -0,0 +1,208 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { computeSecretHash } from '@aztec/aztec.js/crypto';
+import { Fr } from '@aztec/aztec.js/fields';
+import { createLogger } from '@aztec/aztec.js/log';
+import type { TxHash } from '@aztec/aztec.js/tx';
+import type { TokenContract } from '@aztec/noir-contracts.js/Token';
+import { TokenBlacklistContract } from '@aztec/noir-contracts.js/TokenBlacklist';
+import { GenericProxyContract } from '@aztec/noir-test-contracts.js/GenericProxy';
+import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
+
+import { jest } from '@jest/globals';
+
+import { ensureAuthRegistryPublished } from '../../fixtures/setup.js';
+import { TokenSimulator } from '../../simulators/token_simulator.js';
+import { AutomineTestContext, type AutomineTestOpts } from '../automine_test_context.js';
+
+export class Role {
+  private isAdmin = false;
+  private isMinter = false;
+  private isBlacklisted = false;
+
+  withAdmin() {
+    this.isAdmin = true;
+    return this;
+  }
+
+  withMinter() {
+    this.isMinter = true;
+    return this;
+  }
+
+  withBlacklisted() {
+    this.isBlacklisted = true;
+    return this;
+  }
+
+  toNoirStruct() {
+    // We need to use lowercase identifiers as those are what the noir interface expects
+    // eslint-disable-next-line camelcase
+    return { is_admin: this.isAdmin, is_minter: this.isMinter, is_blacklisted: this.isBlacklisted };
+  }
+}
+
+/**
+ * TokenBlacklist-domain harness over the automine topology: extends {@link AutomineTestContext} with a
+ * {@link TokenSimulator}, the {@link Role} helper, the TokenBlacklist deploy plus a bad-account and
+ * authwit proxy, and the role-change-delay warp. Base setup and mint run in {@link setup}.
+ */
+export class BlacklistTokenContractTest extends AutomineTestContext {
+  // This value MUST match the same value that we have in the contract
+  static CHANGE_ROLES_DELAY = 86400;
+
+  asset!: TokenBlacklistContract;
+  tokenSim!: TokenSimulator;
+  badAccount!: InvalidAccountContract;
+  authwitProxy!: GenericProxyContract;
+
+  adminAddress!: AztecAddress;
+  otherAddress!: AztecAddress;
+  blacklistedAddress!: AztecAddress;
+
+  private testName: string;
+
+  constructor(testName: string) {
+    super();
+    this.testName = testName;
+  }
+
+  async crossTimestampOfChange() {
+    await this.markProvenAndWarp(BlacklistTokenContractTest.CHANGE_ROLES_DELAY);
+  }
+
+  /**
+   * Applies base setup:
+   * 1. Add 3 accounts.
+   * 2. Publicly deploy accounts, deploy token contract and a "bad account".
+   */
+  async applyBaseSetup() {
+    // Bumped from 2 min: pipelined cadence (~24s/dependent-tx) makes the 3-account deploy plus token/bad-account/
+    // proxy deploys exceed the original window.
+    jest.setTimeout(600_000);
+
+    this.cheatCodes = this.context.cheatCodes;
+    this.aztecNode = this.context.aztecNodeService;
+    this.sequencer = this.context.sequencer!;
+    this.wallet = this.context.wallet;
+    [this.adminAddress, this.otherAddress, this.blacklistedAddress] = this.context.accounts;
+
+    this.logger.info('Setting up blacklist token contract');
+    await ensureAuthRegistryPublished(this.wallet, this.adminAddress);
+
+    this.logger.verbose(`Deploying TokenContract...`);
+    ({ contract: this.asset } = await TokenBlacklistContract.deploy(this.wallet, this.adminAddress).send({
+      from: this.adminAddress,
+    }));
+    this.logger.verbose(`Token deployed to ${this.asset.address}`);
+
+    this.logger.verbose(`Deploying bad account...`);
+    ({ contract: this.badAccount } = await InvalidAccountContract.deploy(this.wallet).send({
+      from: this.adminAddress,
+    }));
+    this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
+
+    // Deploy a proxy contract for "on behalf of other" tests. The note owner must be the tx sender
+    // (so their notes are in scope), but msg_sender in the target must differ from the note owner
+    // to trigger authwit validation. The proxy forwards calls so that msg_sender != tx sender.
+    this.logger.verbose(`Deploying generic proxy...`);
+    ({ contract: this.authwitProxy } = await GenericProxyContract.deploy(this.wallet).send({
+      from: this.adminAddress,
+    }));
+    this.logger.verbose(`Deployed to ${this.authwitProxy.address}.`);
+
+    await this.crossTimestampOfChange();
+
+    this.tokenSim = new TokenSimulator(
+      this.asset as unknown as TokenContract,
+      this.wallet,
+      this.adminAddress,
+      this.logger,
+      [this.adminAddress, this.otherAddress, this.blacklistedAddress],
+    );
+
+    expect(
+      (await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).result,
+    ).toEqual(new Role().withAdmin().toNoirStruct());
+  }
+
+  override async setup(opts: AutomineTestOpts = {}) {
+    await super.setup({ numberOfAccounts: 3, ...opts });
+    // hydrateFromContext repoints `this.logger` at the context logger; restore the harness-named one.
+    this.logger = createLogger(`e2e:automine:blacklist:${this.testName}`);
+    await this.applyBaseSetup();
+  }
+
+  async addPendingShieldNoteToPXE(
+    contract: TokenBlacklistContract,
+    recipient: AztecAddress,
+    amount: bigint,
+    secretHash: Fr,
+    txHash: TxHash,
+  ) {
+    const txEffects = await this.aztecNode.getTxEffect(txHash);
+    await contract.methods
+      .process_transparent_note(
+        contract.address,
+        amount,
+        secretHash,
+        txHash.hash,
+        txEffects!.data.noteHashes,
+        txEffects!.data.nullifiers[0],
+        recipient,
+      )
+      .simulate({ from: recipient });
+  }
+
+  async applyMint() {
+    this.logger.info('Applying mint setup');
+    const { asset, tokenSim } = this;
+    const amount = 10000n;
+
+    const adminMinterRole = new Role().withAdmin().withMinter();
+    await this.asset.methods
+      .update_roles(this.adminAddress, adminMinterRole.toNoirStruct())
+      .send({ from: this.adminAddress });
+
+    const blacklistRole = new Role().withBlacklisted();
+    await this.asset.methods
+      .update_roles(this.blacklistedAddress, blacklistRole.toNoirStruct())
+      .send({ from: this.adminAddress });
+
+    await this.crossTimestampOfChange();
+
+    expect(
+      (await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).result,
+    ).toEqual(adminMinterRole.toNoirStruct());
+
+    this.logger.verbose(`Minting ${amount} publicly...`);
+    await asset.methods.mint_public(this.adminAddress, amount).send({ from: this.adminAddress });
+
+    this.logger.verbose(`Minting ${amount} privately...`);
+    const secret = Fr.random();
+    const secretHash = await computeSecretHash(secret);
+    const { receipt } = await asset.methods.mint_private(amount, secretHash).send({ from: this.adminAddress });
+
+    await this.addPendingShieldNoteToPXE(asset, this.adminAddress, amount, secretHash, receipt.txHash);
+    await asset.methods.redeem_shield(this.adminAddress, amount, secret).send({ from: this.adminAddress });
+    this.logger.verbose(`Minting complete.`);
+
+    tokenSim.mintPublic(this.adminAddress, amount);
+
+    const { result: publicBalance } = await asset.methods
+      .balance_of_public(this.adminAddress)
+      .simulate({ from: this.adminAddress });
+    this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
+    expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(this.adminAddress));
+
+    tokenSim.mintPrivate(this.adminAddress, amount);
+    const { result: privateBalance } = await asset.methods
+      .balance_of_private(this.adminAddress)
+      .simulate({ from: this.adminAddress });
+    this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
+    expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(this.adminAddress));
+
+    const { result: totalSupply } = await asset.methods.total_supply().simulate({ from: this.adminAddress });
+    this.logger.verbose(`Total supply: ${totalSupply}`);
+    expect(totalSupply).toEqual(tokenSim.totalSupply);
+  }
+}

package/src/automine/token/token_contract_test.ts

@@ -0,0 +1,146 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { createLogger } from '@aztec/aztec.js/log';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { TokenContract } from '@aztec/noir-contracts.js/Token';
+import { GenericProxyContract } from '@aztec/noir-test-contracts.js/GenericProxy';
+import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
+
+import { jest } from '@jest/globals';
+
+import { ensureAuthRegistryPublished } from '../../fixtures/setup.js';
+import { mintTokensToPrivate } from '../../fixtures/token_utils.js';
+import { TokenSimulator } from '../../simulators/token_simulator.js';
+import { AutomineTestContext, type AutomineTestOpts } from '../automine_test_context.js';
+
+const { METRICS_PORT: metricsPort } = process.env;
+
+/**
+ * Token-domain harness over the automine topology: extends {@link AutomineTestContext} with a
+ * {@link TokenSimulator}, the USDC Token deploy plus a bad-account and authwit proxy, and an optional
+ * mint. Base setup is opt-in via {@link applyBaseSnapshots} (run during `setup()`); {@link applyMint}
+ * is called explicitly after `setup()`.
+ */
+export class TokenContractTest extends AutomineTestContext {
+  static TOKEN_NAME = 'USDC';
+  static TOKEN_SYMBOL = 'USD';
+  static TOKEN_DECIMALS = 18n;
+  metricsPort?: number;
+  asset!: TokenContract;
+  tokenSim!: TokenSimulator;
+  node!: AztecNode;
+
+  badAccount!: InvalidAccountContract;
+  authwitProxy!: GenericProxyContract;
+  adminAddress!: AztecAddress;
+  otherAddress!: AztecAddress;
+  account2Address!: AztecAddress;
+
+  private shouldApplyBaseSetup = false;
+  private testName: string;
+
+  constructor(testName: string) {
+    super();
+    this.testName = testName;
+    this.metricsPort = metricsPort ? parseInt(metricsPort) : undefined;
+  }
+
+  /**
+   * Registers that base setup should be applied during setup().
+   * Call this before setup() to deploy 3 accounts, publicly deploy accounts, token contract and a "bad account".
+   */
+  applyBaseSnapshots() {
+    this.shouldApplyBaseSetup = true;
+  }
+
+  /**
+   * Applies base setup: deploys 3 accounts, publicly deploys accounts, token contract and a "bad account".
+   */
+  private async applyBaseSetup() {
+    // Adding a timeout of 2 minutes in here such that it is propagated to the underlying tests
+    jest.setTimeout(120_000);
+
+    this.node = this.context.aztecNodeService;
+    this.wallet = this.context.wallet;
+    [this.adminAddress, this.otherAddress, this.account2Address] = this.context.accounts;
+
+    this.logger.info('Applying base setup - deploying token contract');
+    await ensureAuthRegistryPublished(this.wallet, this.adminAddress);
+
+    this.logger.verbose(`Deploying TokenContract...`);
+    ({ contract: this.asset } = await TokenContract.deploy(
+      this.wallet,
+      this.adminAddress,
+      TokenContractTest.TOKEN_NAME,
+      TokenContractTest.TOKEN_SYMBOL,
+      TokenContractTest.TOKEN_DECIMALS,
+    ).send({ from: this.adminAddress }));
+    this.logger.verbose(`Token deployed to ${this.asset.address}`);
+
+    this.logger.verbose(`Deploying bad account...`);
+    ({ contract: this.badAccount } = await InvalidAccountContract.deploy(this.wallet).send({
+      from: this.adminAddress,
+    }));
+    this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
+
+    // Deploy a proxy contract for "on behalf of other" tests. The note owner must be the tx sender
+    // (so their notes are in scope), but msg_sender in the target must differ from the note owner
+    // to trigger authwit validation. The proxy forwards calls so that msg_sender != tx sender.
+    this.logger.verbose(`Deploying generic proxy...`);
+    ({ contract: this.authwitProxy } = await GenericProxyContract.deploy(this.wallet).send({
+      from: this.adminAddress,
+    }));
+    this.logger.verbose(`Deployed to ${this.authwitProxy.address}.`);
+
+    this.tokenSim = new TokenSimulator(this.asset, this.wallet, this.adminAddress, this.logger, [
+      this.adminAddress,
+      this.otherAddress,
+    ]);
+
+    expect((await this.asset.methods.get_admin().simulate({ from: this.adminAddress })).result).toBe(
+      this.adminAddress.toBigInt(),
+    );
+  }
+
+  override async setup(opts: AutomineTestOpts = {}) {
+    await super.setup({ numberOfAccounts: 3, metricsPort: this.metricsPort, ...opts });
+    // hydrateFromContext repoints `this.logger` at the context logger; restore the harness-named one.
+    this.logger = createLogger(`e2e:automine:token:${this.testName}`);
+
+    if (this.shouldApplyBaseSetup) {
+      await this.applyBaseSetup();
+    }
+  }
+
+  /** Mints an initial public and private balance to the admin account. Call after {@link setup}. */
+  async applyMint() {
+    this.logger.info('Applying mint setup');
+    const { asset, adminAddress, tokenSim } = this;
+    const amount = 10000n;
+
+    this.logger.verbose(`Minting ${amount} publicly...`);
+    await asset.methods.mint_to_public(adminAddress, amount).send({ from: adminAddress });
+    tokenSim.mintPublic(adminAddress, amount);
+
+    const { result: publicBalance } = await asset.methods
+      .balance_of_public(adminAddress)
+      .simulate({ from: adminAddress });
+    this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
+    expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(adminAddress));
+
+    this.logger.verbose(`Minting ${amount} privately...`);
+    await mintTokensToPrivate(asset, adminAddress, adminAddress, amount);
+    tokenSim.mintPrivate(adminAddress, amount);
+
+    const { result: privateBalance } = await asset.methods
+      .balance_of_private(adminAddress)
+      .simulate({ from: adminAddress });
+    this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
+    expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(adminAddress));
+
+    const { result: totalSupply } = await asset.methods.total_supply().simulate({ from: adminAddress });
+    this.logger.verbose(`Total supply: ${totalSupply}`);
+    expect(totalSupply).toEqual(tokenSim.totalSupply);
+
+    this.logger.verbose(`Minting complete.`);
+  }
+}