@aztec/end-to-end 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/dest/automine/contracts/fixtures/storage_proof_fixture.js

@@ -0,0 +1,120 @@
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Capsule } from '@aztec/stdlib/tx';
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const FIXTURE_PATH = join(__dirname, './storage_proof.json');
+// Constants matching the Noir contract
+const ACCOUNT_CAPSULE_KEY_SEPARATOR = 100;
+const ACCOUNT_PROOF_CAPSULE_KEY_SEPARATOR = 101;
+const STORAGE_PROOF_CAPSULE_KEY_SEPARATOR = 102;
+const STORAGE_PROOF_NODE_CAPSULE_KEY_SEPARATOR = 103;
+const MAX_ACCOUNT_PROOF_LENGTH = 15;
+/** Node: rows [[u64;4];16] (64) + row_exist [bool;16] (16) + node_type u8 (1) = 81 fields */ const NODE_FIELD_COUNT = 81;
+// --- Serialization helpers (Noir struct Serialize layout) ---
+function serializeNode(node) {
+    const fields = [];
+    for (const row of node.rows){
+        for (const val of row){
+            fields.push(new Fr(BigInt(val)));
+        }
+    }
+    for (const exists of node.row_exist){
+        fields.push(new Fr(exists ? 1n : 0n));
+    }
+    fields.push(new Fr(BigInt(node.node_type)));
+    return fields;
+}
+/** Account: nonce [u8;8] + balance [u8;32] + address [u8;20] + nonce_length u8 + balance_length u8 + storage_hash [u64;4] + code_hash [u64;4] = 70 fields */ function serializeAccount(account) {
+    const fields = [];
+    for (const v of account.nonce){
+        fields.push(new Fr(BigInt(v)));
+    }
+    for (const v of account.balance){
+        fields.push(new Fr(BigInt(v)));
+    }
+    for (const v of account.address){
+        fields.push(new Fr(BigInt(v)));
+    }
+    fields.push(new Fr(BigInt(account.nonce_length)));
+    fields.push(new Fr(BigInt(account.balance_length)));
+    for (const v of account.storage_hash){
+        fields.push(new Fr(BigInt(v)));
+    }
+    for (const v of account.code_hash){
+        fields.push(new Fr(BigInt(v)));
+    }
+    return fields;
+}
+function zeroNode() {
+    return Array(NODE_FIELD_COUNT).fill(Fr.ZERO);
+}
+/** Loads the storage proof fixture from disk and returns the contract args. */ export function loadStorageProofArgs() {
+    const fixture = JSON.parse(readFileSync(FIXTURE_PATH, 'utf8'));
+    const addressBytes = Buffer.from(fixture.account.address.map((v)=>Number(v)));
+    return {
+        ethAddress: EthAddress.fromString('0x' + addressBytes.toString('hex')),
+        slotKey: fixture.slot_key.map((v)=>Number(v)),
+        slotContents: {
+            value: fixture.slot.value.map((v)=>Number(v)),
+            // eslint-disable-next-line camelcase
+            value_length: Number(fixture.slot.value_length)
+        },
+        root: fixture.root.map((v)=>BigInt(v))
+    };
+}
+/** Builds all the capsules the StorageProofTest contract expects during private execution. */ export async function buildStorageProofCapsules(contractAddress) {
+    const fixture = JSON.parse(readFileSync(FIXTURE_PATH, 'utf8'));
+    const root = fixture.root.map((v)=>BigInt(v));
+    const slotKey = fixture.slot_key.map((v)=>Number(v));
+    const accountNodeLength = Number(fixture.account_node_length);
+    const storageNodeLength = Number(fixture.storage_node_length);
+    const ethAddress = EthAddress.fromBuffer(Buffer.from(fixture.account.address.map((v)=>Number(v))));
+    // Compute capsule keys (must match the Noir contract's poseidon2_hash computations)
+    const addressCapsuleKey = await poseidon2Hash([
+        new Fr(ACCOUNT_CAPSULE_KEY_SEPARATOR),
+        ...root.map((v)=>new Fr(v)),
+        ethAddress.toField()
+    ]);
+    const accountProofCapsuleKey = await poseidon2Hash([
+        new Fr(ACCOUNT_PROOF_CAPSULE_KEY_SEPARATOR),
+        addressCapsuleKey
+    ]);
+    const storageProofCapsuleKey = await poseidon2Hash([
+        new Fr(STORAGE_PROOF_CAPSULE_KEY_SEPARATOR),
+        addressCapsuleKey,
+        ...slotKey.map((v)=>new Fr(v))
+    ]);
+    // Build capsule data
+    // 1. Account data
+    const accountData = serializeAccount(fixture.account);
+    // 2. Account proof nodes padded to MAX_ACCOUNT_PROOF_LENGTH
+    const accountProofData = [
+        new Fr(accountNodeLength)
+    ];
+    for(let i = 0; i < MAX_ACCOUNT_PROOF_LENGTH; i++){
+        accountProofData.push(...i < fixture.account_nodes.length ? serializeNode(fixture.account_nodes[i]) : zeroNode());
+    }
+    // 3. Storage proof length (u32)
+    const storageProofLengthData = [
+        new Fr(storageNodeLength)
+    ];
+    const capsules = [
+        new Capsule(contractAddress, addressCapsuleKey, accountData),
+        new Capsule(contractAddress, accountProofCapsuleKey, accountProofData),
+        new Capsule(contractAddress, storageProofCapsuleKey, storageProofLengthData)
+    ];
+    // 4. Individual storage node capsules for private recursion.
+    for(let i = 0; i < storageNodeLength; i++){
+        const nodeCapsuleKey = await poseidon2Hash([
+            new Fr(STORAGE_PROOF_NODE_CAPSULE_KEY_SEPARATOR),
+            storageProofCapsuleKey,
+            new Fr(i)
+        ]);
+        capsules.push(new Capsule(contractAddress, nodeCapsuleKey, serializeNode(fixture.storage_nodes[i])));
+    }
+    return capsules;
+}

package/dest/automine/delivery/onchain_delivery_harness.d.ts

@@ -0,0 +1,17 @@
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { PXECreationOptions } from '@aztec/pxe/server';
+import { TestWallet } from '../../test-wallet/test_wallet.js';
+export type SenderHook = NonNullable<NonNullable<PXECreationOptions['hooks']>['resolveTaggingSecretStrategy']>;
+export type Mode = 'constrained' | 'unconstrained';
+export type DeliveryMode = Mode | {
+    events: Mode;
+    notes: Mode;
+};
+export declare function buildMessageDeliveryTest(opts: {
+    strategy: string;
+    mode: DeliveryMode;
+    senderHook: SenderHook;
+    recipientRegistration?: (recipient: TestWallet, recipientAddress: AztecAddress, sender: AztecAddress) => Promise<void>;
+    additionalTests?: () => void;
+}): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25jaGFpbl9kZWxpdmVyeV9oYXJuZXNzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXV0b21pbmUvZGVsaXZlcnkvb25jaGFpbl9kZWxpdmVyeV9oYXJuZXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBSTlELE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFPNUQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBSTlELE1BQU0sTUFBTSxVQUFVLEdBQUcsV0FBVyxDQUFDLFdBQVcsQ0FBQyxrQkFBa0IsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLDhCQUE4QixDQUFDLENBQUMsQ0FBQztBQUUvRyxNQUFNLE1BQU0sSUFBSSxHQUFHLGFBQWEsR0FBRyxlQUFlLENBQUM7QUFJbkQsTUFBTSxNQUFNLFlBQVksR0FBRyxJQUFJLEdBQUc7SUFBRSxNQUFNLEVBQUUsSUFBSSxDQUFDO0lBQUMsS0FBSyxFQUFFLElBQUksQ0FBQTtDQUFFLENBQUM7QUFZaEUsd0JBQWdCLHdCQUF3QixDQUFDLElBQUksRUFBRTtJQUc3QyxRQUFRLEVBQUUsTUFBTSxDQUFDO0lBQ2pCLElBQUksRUFBRSxZQUFZLENBQUM7SUFFbkIsVUFBVSxFQUFFLFVBQVUsQ0FBQztJQUV2QixxQkFBcUIsQ0FBQyxFQUFFLENBQ3RCLFNBQVMsRUFBRSxVQUFVLEVBQ3JCLGdCQUFnQixFQUFFLFlBQVksRUFDOUIsTUFBTSxFQUFFLFlBQVksS0FDakIsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBSW5CLGVBQWUsQ0FBQyxFQUFFLE1BQU0sSUFBSSxDQUFDO0NBQzlCLFFBMkhBIn0=

package/dest/automine/delivery/onchain_delivery_harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onchain_delivery_harness.d.ts","sourceRoot":"","sources":["../../../src/automine/delivery/onchain_delivery_harness.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAI9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAO5D,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAI9D,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,WAAW,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC,8BAA8B,CAAC,CAAC,CAAC;AAE/G,MAAM,MAAM,IAAI,GAAG,aAAa,GAAG,eAAe,CAAC;AAInD,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,IAAI,CAAA;CAAE,CAAC;AAYhE,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAG7C,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,YAAY,CAAC;IAEnB,UAAU,EAAE,UAAU,CAAC;IAEvB,qBAAqB,CAAC,EAAE,CACtB,SAAS,EAAE,UAAU,EACrB,gBAAgB,EAAE,YAAY,EAC9B,MAAM,EAAE,YAAY,KACjB,OAAO,CAAC,IAAI,CAAC,CAAC;IAInB,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;CAC9B,QA2HA"}

package/dest/automine/delivery/onchain_delivery_harness.js

@@ -0,0 +1,123 @@
+import { generateSchnorrAccounts } from '@aztec/accounts/testing';
+import { NO_FROM } from '@aztec/aztec.js/account';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { OnchainDeliveryTestContract } from '@aztec/noir-test-contracts.js/OnchainDeliveryTest';
+import { jest } from '@jest/globals';
+import { AUTOMINE_E2E_OPTS } from '../../fixtures/fixtures.js';
+import { ensureHandshakeRegistryPublished, setup, setupPXEAndGetWallet } from '../../fixtures/setup.js';
+const formatMode = (mode)=>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) {
+    const { strategy, mode, senderHook, recipientRegistration, 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;
+        let walletSender;
+        let walletRecipient;
+        let sender;
+        let recipient;
+        let contractSender;
+        let teardownSender;
+        let teardownRecipient;
+        // 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;
+        let readNotes;
+        const { events: eventMode, notes: noteMode } = typeof mode === 'string' ? {
+            events: mode,
+            notes: mode
+        } : mode;
+        const sendEvent = (value)=>eventMode === 'constrained' ? contractSender.methods.emit_event(recipient, value) : contractSender.methods.emit_event_unconstrained(recipient, value);
+        const sendNote = (value)=>noteMode === 'constrained' ? contractSender.methods.emit_note(recipient, value) : contractSender.methods.emit_note_unconstrained(recipient, value);
+        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.
+            let additionallyFundedAccounts;
+            ({ aztecNode, additionallyFundedAccounts, wallet: walletSender, accounts: [sender], teardown: teardownSender } = await setup(1, {
+                ...AUTOMINE_E2E_OPTS,
+                additionallyFundedAccounts: await generateSchnorrAccounts(1, 'schnorr'),
+                pxeCreationOptions: {
+                    hooks: {
+                        resolveTaggingSecretStrategy: senderHook
+                    }
+                }
+            }));
+            ({ wallet: walletRecipient, teardown: teardownRecipient } = await setupPXEAndGetWallet(aztecNode, aztecNode, {}, undefined, 'pxe-recipient'));
+            const 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 = [];
+            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(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);
+        });
+        additionalTests?.();
+    });
+}

package/dest/automine/token/blacklist_token_contract_test.d.ts

@@ -0,0 +1,49 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { Fr } from '@aztec/aztec.js/fields';
+import type { TxHash } from '@aztec/aztec.js/tx';
+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 { TokenSimulator } from '../../simulators/token_simulator.js';
+import { AutomineTestContext, type AutomineTestOpts } from '../automine_test_context.js';
+export declare class Role {
+    private isAdmin;
+    private isMinter;
+    private isBlacklisted;
+    withAdmin(): this;
+    withMinter(): this;
+    withBlacklisted(): this;
+    toNoirStruct(): {
+        is_admin: boolean;
+        is_minter: boolean;
+        is_blacklisted: boolean;
+    };
+}
+/**
+ * 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 declare class BlacklistTokenContractTest extends AutomineTestContext {
+    static CHANGE_ROLES_DELAY: number;
+    asset: TokenBlacklistContract;
+    tokenSim: TokenSimulator;
+    badAccount: InvalidAccountContract;
+    authwitProxy: GenericProxyContract;
+    adminAddress: AztecAddress;
+    otherAddress: AztecAddress;
+    blacklistedAddress: AztecAddress;
+    private testName;
+    constructor(testName: string);
+    crossTimestampOfChange(): Promise<void>;
+    /**
+     * Applies base setup:
+     * 1. Add 3 accounts.
+     * 2. Publicly deploy accounts, deploy token contract and a "bad account".
+     */
+    applyBaseSetup(): Promise<void>;
+    setup(opts?: AutomineTestOpts): Promise<void>;
+    addPendingShieldNoteToPXE(contract: TokenBlacklistContract, recipient: AztecAddress, amount: bigint, secretHash: Fr, txHash: TxHash): Promise<void>;
+    applyMint(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxhY2tsaXN0X3Rva2VuX2NvbnRyYWN0X3Rlc3QuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hdXRvbWluZS90b2tlbi9ibGFja2xpc3RfdG9rZW5fY29udHJhY3RfdGVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFekQsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRTVDLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRWpELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHlDQUF5QyxDQUFDO0FBQ2pGLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDRDQUE0QyxDQUFDO0FBQ2xGLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBS3RGLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUNyRSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsS0FBSyxnQkFBZ0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBRXpGLHFCQUFhLElBQUk7SUFDZixPQUFPLENBQUMsT0FBTyxDQUFTO0lBQ3hCLE9BQU8sQ0FBQyxRQUFRLENBQVM7SUFDekIsT0FBTyxDQUFDLGFBQWEsQ0FBUztJQUU5QixTQUFTLFNBR1I7SUFFRCxVQUFVLFNBR1Q7SUFFRCxlQUFlLFNBR2Q7SUFFRCxZQUFZOzs7O01BSVg7Q0FDRjtBQUVEOzs7O0dBSUc7QUFDSCxxQkFBYSwwQkFBMkIsU0FBUSxtQkFBbUI7SUFFakUsTUFBTSxDQUFDLGtCQUFrQixTQUFTO0lBRWxDLEtBQUssRUFBRyxzQkFBc0IsQ0FBQztJQUMvQixRQUFRLEVBQUcsY0FBYyxDQUFDO0lBQzFCLFVBQVUsRUFBRyxzQkFBc0IsQ0FBQztJQUNwQyxZQUFZLEVBQUcsb0JBQW9CLENBQUM7SUFFcEMsWUFBWSxFQUFHLFlBQVksQ0FBQztJQUM1QixZQUFZLEVBQUcsWUFBWSxDQUFDO0lBQzVCLGtCQUFrQixFQUFHLFlBQVksQ0FBQztJQUVsQyxPQUFPLENBQUMsUUFBUSxDQUFTO0lBRXpCLFlBQVksUUFBUSxFQUFFLE1BQU0sRUFHM0I7SUFFSyxzQkFBc0Isa0JBRTNCO0lBRUQ7Ozs7T0FJRztJQUNHLGNBQWMsa0JBZ0RuQjtJQUVjLEtBQUssQ0FBQyxJQUFJLEdBQUUsZ0JBQXFCLGlCQUsvQztJQUVLLHlCQUF5QixDQUM3QixRQUFRLEVBQUUsc0JBQXNCLEVBQ2hDLFNBQVMsRUFBRSxZQUFZLEVBQ3ZCLE1BQU0sRUFBRSxNQUFNLEVBQ2QsVUFBVSxFQUFFLEVBQUUsRUFDZCxNQUFNLEVBQUUsTUFBTSxpQkFjZjtJQUVLLFNBQVMsa0JBbURkO0NBQ0YifQ==

package/dest/automine/token/blacklist_token_contract_test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blacklist_token_contract_test.d.ts","sourceRoot":"","sources":["../../../src/automine/token/blacklist_token_contract_test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAC;AAE5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACjF,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAClF,OAAO,EAAE,sBAAsB,EAAE,MAAM,8CAA8C,CAAC;AAKtF,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AACrE,OAAO,EAAE,mBAAmB,EAAE,KAAK,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAEzF,qBAAa,IAAI;IACf,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,aAAa,CAAS;IAE9B,SAAS,SAGR;IAED,UAAU,SAGT;IAED,eAAe,SAGd;IAED,YAAY;;;;MAIX;CACF;AAED;;;;GAIG;AACH,qBAAa,0BAA2B,SAAQ,mBAAmB;IAEjE,MAAM,CAAC,kBAAkB,SAAS;IAElC,KAAK,EAAG,sBAAsB,CAAC;IAC/B,QAAQ,EAAG,cAAc,CAAC;IAC1B,UAAU,EAAG,sBAAsB,CAAC;IACpC,YAAY,EAAG,oBAAoB,CAAC;IAEpC,YAAY,EAAG,YAAY,CAAC;IAC5B,YAAY,EAAG,YAAY,CAAC;IAC5B,kBAAkB,EAAG,YAAY,CAAC;IAElC,OAAO,CAAC,QAAQ,CAAS;IAEzB,YAAY,QAAQ,EAAE,MAAM,EAG3B;IAEK,sBAAsB,kBAE3B;IAED;;;;OAIG;IACG,cAAc,kBAgDnB;IAEc,KAAK,CAAC,IAAI,GAAE,gBAAqB,iBAK/C;IAEK,yBAAyB,CAC7B,QAAQ,EAAE,sBAAsB,EAChC,SAAS,EAAE,YAAY,EACvB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,EAAE,EACd,MAAM,EAAE,MAAM,iBAcf;IAEK,SAAS,kBAmDd;CACF"}

package/dest/automine/token/blacklist_token_contract_test.js

@@ -0,0 +1,166 @@
+import { computeSecretHash } from '@aztec/aztec.js/crypto';
+import { Fr } from '@aztec/aztec.js/fields';
+import { createLogger } from '@aztec/aztec.js/log';
+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 } from '../automine_test_context.js';
+export class Role {
+    isAdmin = false;
+    isMinter = false;
+    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;
+    tokenSim;
+    badAccount;
+    authwitProxy;
+    adminAddress;
+    otherAddress;
+    blacklistedAddress;
+    testName;
+    constructor(testName){
+        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, 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());
+    }
+    async setup(opts = {}) {
+        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, recipient, amount, secretHash, 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/dest/automine/token/token_contract_test.d.ts

@@ -0,0 +1,40 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+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 { TokenSimulator } from '../../simulators/token_simulator.js';
+import { AutomineTestContext, type AutomineTestOpts } from '../automine_test_context.js';
+/**
+ * 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 declare class TokenContractTest extends AutomineTestContext {
+    static TOKEN_NAME: string;
+    static TOKEN_SYMBOL: string;
+    static TOKEN_DECIMALS: bigint;
+    metricsPort?: number;
+    asset: TokenContract;
+    tokenSim: TokenSimulator;
+    node: AztecNode;
+    badAccount: InvalidAccountContract;
+    authwitProxy: GenericProxyContract;
+    adminAddress: AztecAddress;
+    otherAddress: AztecAddress;
+    account2Address: AztecAddress;
+    private shouldApplyBaseSetup;
+    private testName;
+    constructor(testName: string);
+    /**
+     * 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(): void;
+    private applyBaseSetup;
+    setup(opts?: AutomineTestOpts): Promise<void>;
+    /** Mints an initial public and private balance to the admin account. Call after {@link setup}. */
+    applyMint(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5fY29udHJhY3RfdGVzdC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F1dG9taW5lL3Rva2VuL3Rva2VuX2NvbnRyYWN0X3Rlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBRXpELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUMvRCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw0Q0FBNEMsQ0FBQztBQUNsRixPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSw4Q0FBOEMsQ0FBQztBQU10RixPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDckUsT0FBTyxFQUFFLG1CQUFtQixFQUFFLEtBQUssZ0JBQWdCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUl6Rjs7Ozs7R0FLRztBQUNILHFCQUFhLGlCQUFrQixTQUFRLG1CQUFtQjtJQUN4RCxNQUFNLENBQUMsVUFBVSxTQUFVO0lBQzNCLE1BQU0sQ0FBQyxZQUFZLFNBQVM7SUFDNUIsTUFBTSxDQUFDLGNBQWMsU0FBTztJQUM1QixXQUFXLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDckIsS0FBSyxFQUFHLGFBQWEsQ0FBQztJQUN0QixRQUFRLEVBQUcsY0FBYyxDQUFDO0lBQzFCLElBQUksRUFBRyxTQUFTLENBQUM7SUFFakIsVUFBVSxFQUFHLHNCQUFzQixDQUFDO0lBQ3BDLFlBQVksRUFBRyxvQkFBb0IsQ0FBQztJQUNwQyxZQUFZLEVBQUcsWUFBWSxDQUFDO0lBQzVCLFlBQVksRUFBRyxZQUFZLENBQUM7SUFDNUIsZUFBZSxFQUFHLFlBQVksQ0FBQztJQUUvQixPQUFPLENBQUMsb0JBQW9CLENBQVM7SUFDckMsT0FBTyxDQUFDLFFBQVEsQ0FBUztJQUV6QixZQUFZLFFBQVEsRUFBRSxNQUFNLEVBSTNCO0lBRUQ7OztPQUdHO0lBQ0gsa0JBQWtCLFNBRWpCO1lBS2EsY0FBYztJQThDYixLQUFLLENBQUMsSUFBSSxHQUFFLGdCQUFxQixpQkFRL0M7SUFFRCxrR0FBa0c7SUFDNUYsU0FBUyxrQkE4QmQ7Q0FDRiJ9

package/dest/automine/token/token_contract_test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token_contract_test.d.ts","sourceRoot":"","sources":["../../../src/automine/token/token_contract_test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAClF,OAAO,EAAE,sBAAsB,EAAE,MAAM,8CAA8C,CAAC;AAMtF,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AACrE,OAAO,EAAE,mBAAmB,EAAE,KAAK,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAIzF;;;;;GAKG;AACH,qBAAa,iBAAkB,SAAQ,mBAAmB;IACxD,MAAM,CAAC,UAAU,SAAU;IAC3B,MAAM,CAAC,YAAY,SAAS;IAC5B,MAAM,CAAC,cAAc,SAAO;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,EAAG,aAAa,CAAC;IACtB,QAAQ,EAAG,cAAc,CAAC;IAC1B,IAAI,EAAG,SAAS,CAAC;IAEjB,UAAU,EAAG,sBAAsB,CAAC;IACpC,YAAY,EAAG,oBAAoB,CAAC;IACpC,YAAY,EAAG,YAAY,CAAC;IAC5B,YAAY,EAAG,YAAY,CAAC;IAC5B,eAAe,EAAG,YAAY,CAAC;IAE/B,OAAO,CAAC,oBAAoB,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAS;IAEzB,YAAY,QAAQ,EAAE,MAAM,EAI3B;IAED;;;OAGG;IACH,kBAAkB,SAEjB;YAKa,cAAc;IA8Cb,KAAK,CAAC,IAAI,GAAE,gBAAqB,iBAQ/C;IAED,kGAAkG;IAC5F,SAAS,kBA8Bd;CACF"}

package/dest/automine/token/token_contract_test.js

@@ -0,0 +1,119 @@
+import { createLogger } from '@aztec/aztec.js/log';
+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 } 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;
+    asset;
+    tokenSim;
+    node;
+    badAccount;
+    authwitProxy;
+    adminAddress;
+    otherAddress;
+    account2Address;
+    shouldApplyBaseSetup = false;
+    testName;
+    constructor(testName){
+        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".
+   */ 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());
+    }
+    async setup(opts = {}) {
+        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.`);
+    }
+}