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

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/interactive_handshake_responder.d.ts

@@ -0,0 +1,48 @@
+import { AztecAddress, type CompleteAddress } from '@aztec/aztec.js/addresses';
+import { type SchnorrSignature } from '@aztec/foundation/crypto/schnorr';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
+import type { CustomRequest } from '@aztec/pxe/config';
+import { type PublicKeys } from '@aztec/stdlib/keys';
+/**
+ * The decoded payload of the registry's interactive-handshake signature request. Note it never carries the sender,
+ * so the recipient authorizes the handshake without learning who initiated it.
+ */
+export type InteractiveHandshakeRequest = {
+    /** The account whose authorization is being requested. */
+    recipient: AztecAddress;
+    chainId: Fr;
+    version: Fr;
+    /** The x-coordinate of the handshake's ephemeral public key (its y-coordinate is positive by construction). */
+    ephPkX: Fr;
+};
+/**
+ * The recipient's signed authorization for an interactive handshake. Mirrors the registry contract's
+ * `RecipientSignature` struct field for field.
+ */
+export type RecipientSignature = {
+    /** The recipient's master public keys, bound in-circuit to the recipient's address via `partialAddress`. */
+    publicKeys: PublicKeys;
+    partialAddress: Fr;
+    /** The x-coordinate of the recipient's master message-signing public key. */
+    mspkX: Fr;
+    /** Whether that key's y-coordinate is positive, so the circuit can reconstruct the point from `mspkX`. */
+    mspkYIsPositive: boolean;
+    /** The schnorr signature over the handshake message. */
+    signature: SchnorrSignature;
+};
+/**
+ * Parses and validates the registry's interactive-handshake signature request.
+ *
+ * @throws If the request kind is not {@link INTERACTIVE_HANDSHAKE_REQUEST_KIND}, the issuing contract is not the
+ * standard HandshakeRegistry, or the payload does not have the expected shape.
+ */
+export declare function parseInteractiveHandshakeRequest(request: CustomRequest): InteractiveHandshakeRequest;
+/**
+ * Produces the recipient's signed authorization for an interactive handshake, signing with the master
+ * message-signing secret key.
+ */
+export declare function signInteractiveHandshake(request: InteractiveHandshakeRequest, completeAddress: CompleteAddress, masterMessageSigningSecretKey: GrumpkinScalar): Promise<RecipientSignature>;
+/** Serializes a {@link RecipientSignature} to the field layout the registry's in-circuit deserialization expects. */
+export declare function recipientSignatureToFields(recipientSignature: RecipientSignature): Fr[];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJhY3RpdmVfaGFuZHNoYWtlX3Jlc3BvbmRlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F1dG9taW5lL2RlbGl2ZXJ5L2ludGVyYWN0aXZlX2hhbmRzaGFrZV9yZXNwb25kZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxLQUFLLGVBQWUsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBRy9FLE9BQU8sRUFBVyxLQUFLLGdCQUFnQixFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDbEYsT0FBTyxFQUFNLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3hELE9BQU8sS0FBSyxFQUFFLGNBQWMsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQ3hFLE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBS3ZELE9BQU8sRUFBRSxLQUFLLFVBQVUsRUFBZ0MsTUFBTSxvQkFBb0IsQ0FBQztBQUVuRjs7O0dBR0c7QUFDSCxNQUFNLE1BQU0sMkJBQTJCLEdBQUc7SUFDeEMsMERBQTBEO0lBQzFELFNBQVMsRUFBRSxZQUFZLENBQUM7SUFDeEIsT0FBTyxFQUFFLEVBQUUsQ0FBQztJQUNaLE9BQU8sRUFBRSxFQUFFLENBQUM7SUFDWiwrR0FBK0c7SUFDL0csTUFBTSxFQUFFLEVBQUUsQ0FBQztDQUNaLENBQUM7QUFFRjs7O0dBR0c7QUFDSCxNQUFNLE1BQU0sa0JBQWtCLEdBQUc7SUFDL0IsNEdBQTRHO0lBQzVHLFVBQVUsRUFBRSxVQUFVLENBQUM7SUFDdkIsY0FBYyxFQUFFLEVBQUUsQ0FBQztJQUNuQiw2RUFBNkU7SUFDN0UsS0FBSyxFQUFFLEVBQUUsQ0FBQztJQUNWLDBHQUEwRztJQUMxRyxlQUFlLEVBQUUsT0FBTyxDQUFDO0lBQ3pCLHdEQUF3RDtJQUN4RCxTQUFTLEVBQUUsZ0JBQWdCLENBQUM7Q0FDN0IsQ0FBQztBQUVGOzs7OztHQUtHO0FBQ0gsd0JBQWdCLGdDQUFnQyxDQUFDLE9BQU8sRUFBRSxhQUFhLEdBQUcsMkJBQTJCLENBZXBHO0FBRUQ7OztHQUdHO0FBQ0gsd0JBQXNCLHdCQUF3QixDQUM1QyxPQUFPLEVBQUUsMkJBQTJCLEVBQ3BDLGVBQWUsRUFBRSxlQUFlLEVBQ2hDLDZCQUE2QixFQUFFLGNBQWMsR0FDNUMsT0FBTyxDQUFDLGtCQUFrQixDQUFDLENBbUI3QjtBQUVELHFIQUFxSDtBQUNySCx3QkFBZ0IsMEJBQTBCLENBQUMsa0JBQWtCLEVBQUUsa0JBQWtCLEdBQUcsRUFBRSxFQUFFLENBYXZGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"interactive_handshake_responder.d.ts","sourceRoot":"","sources":["../../../src/automine/delivery/interactive_handshake_responder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAG/E,OAAO,EAAW,KAAK,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAClF,OAAO,EAAM,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAKvD,OAAO,EAAE,KAAK,UAAU,EAAgC,MAAM,oBAAoB,CAAC;AAEnF;;;GAGG;AACH,MAAM,MAAM,2BAA2B,GAAG;IACxC,0DAA0D;IAC1D,SAAS,EAAE,YAAY,CAAC;IACxB,OAAO,EAAE,EAAE,CAAC;IACZ,OAAO,EAAE,EAAE,CAAC;IACZ,+GAA+G;IAC/G,MAAM,EAAE,EAAE,CAAC;CACZ,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,4GAA4G;IAC5G,UAAU,EAAE,UAAU,CAAC;IACvB,cAAc,EAAE,EAAE,CAAC;IACnB,6EAA6E;IAC7E,KAAK,EAAE,EAAE,CAAC;IACV,0GAA0G;IAC1G,eAAe,EAAE,OAAO,CAAC;IACzB,wDAAwD;IACxD,SAAS,EAAE,gBAAgB,CAAC;CAC7B,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,aAAa,GAAG,2BAA2B,CAepG;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,2BAA2B,EACpC,eAAe,EAAE,eAAe,EAChC,6BAA6B,EAAE,cAAc,GAC5C,OAAO,CAAC,kBAAkB,CAAC,CAmB7B;AAED,qHAAqH;AACrH,wBAAgB,0BAA0B,CAAC,kBAAkB,EAAE,kBAAkB,GAAG,EAAE,EAAE,CAavF"}

package/dest/automine/delivery/interactive_handshake_responder.js

@@ -0,0 +1,76 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { DomainSeparator } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Schnorr } from '@aztec/foundation/crypto/schnorr';
+import { Fq, Fr } from '@aztec/foundation/curves/bn254';
+import { INTERACTIVE_HANDSHAKE_REQUEST_KIND, STANDARD_HANDSHAKE_REGISTRY_ADDRESS } from '@aztec/standard-contracts/handshake-registry/constants';
+import { derivePublicKeyFromSecretKey } from '@aztec/stdlib/keys';
+/**
+ * Parses and validates the registry's interactive-handshake signature request.
+ *
+ * @throws If the request kind is not {@link INTERACTIVE_HANDSHAKE_REQUEST_KIND}, the issuing contract is not the
+ * standard HandshakeRegistry, or the payload does not have the expected shape.
+ */ export function parseInteractiveHandshakeRequest(request) {
+    if (!request.kind.equals(INTERACTIVE_HANDSHAKE_REQUEST_KIND)) {
+        throw new Error(`Not an interactive-handshake signature request: unexpected kind ${request.kind}`);
+    }
+    if (!request.contractAddress.equals(STANDARD_HANDSHAKE_REGISTRY_ADDRESS)) {
+        throw new Error(`Interactive-handshake signature request issued by ${request.contractAddress}, expected the standard HandshakeRegistry at ${STANDARD_HANDSHAKE_REGISTRY_ADDRESS}`);
+    }
+    if (request.payload.length !== 4) {
+        throw new Error(`Interactive-handshake signature request payload has ${request.payload.length} fields, expected 4`);
+    }
+    const [recipient, chainId, version, ephPkX] = request.payload;
+    return {
+        recipient: new AztecAddress(recipient),
+        chainId,
+        version,
+        ephPkX
+    };
+}
+/**
+ * Produces the recipient's signed authorization for an interactive handshake, signing with the master
+ * message-signing secret key.
+ */ export async function signInteractiveHandshake(request, completeAddress, masterMessageSigningSecretKey) {
+    const mspk = await derivePublicKeyFromSecretKey(masterMessageSigningSecretKey);
+    const [mspkX, mspkYIsPositive] = mspk.toXAndSign();
+    const message = await computeInteractiveHandshakeSignatureMessage({
+        chainId: request.chainId,
+        version: request.version,
+        registry: STANDARD_HANDSHAKE_REGISTRY_ADDRESS,
+        ephPkX: request.ephPkX
+    });
+    const signature = await new Schnorr().constructSignature(message, masterMessageSigningSecretKey);
+    return {
+        publicKeys: completeAddress.publicKeys,
+        partialAddress: completeAddress.partialAddress,
+        mspkX,
+        mspkYIsPositive,
+        signature
+    };
+}
+/** Serializes a {@link RecipientSignature} to the field layout the registry's in-circuit deserialization expects. */ export function recipientSignatureToFields(recipientSignature) {
+    const s = Fq.fromBuffer(recipientSignature.signature.s);
+    const e = Fq.fromBuffer(recipientSignature.signature.e);
+    return [
+        ...recipientSignature.publicKeys.toFields(),
+        recipientSignature.partialAddress,
+        recipientSignature.mspkX,
+        new Fr(recipientSignature.mspkYIsPositive),
+        s.lo,
+        s.hi,
+        e.lo,
+        e.hi
+    ];
+}
+/**
+ * The message an interactive-handshake authorization signs: the handshake's ephemeral key and chain context under
+ * `DomainSeparator.INTERACTIVE_HANDSHAKE_SIGNATURE`, exactly as the registry recomputes it in-circuit.
+ */ function computeInteractiveHandshakeSignatureMessage(args) {
+    return poseidon2HashWithSeparator([
+        args.chainId,
+        args.version,
+        args.registry,
+        args.ephPkX
+    ], DomainSeparator.INTERACTIVE_HANDSHAKE_SIGNATURE);
+}

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

@@ -0,0 +1,19 @@
+import { type InitialAccountData } from '@aztec/accounts/testing';
+import type { AztecAddress, CompleteAddress } from '@aztec/aztec.js/addresses';
+import type { ResolveCustomRequest, ResolveTaggingSecretStrategy } from '@aztec/pxe/config';
+import { TestWallet } from '../../test-wallet/test_wallet.js';
+export type CustomRequestResponder = (recipient: TestWallet, recipientAccount: InitialAccountData, recipientCompleteAddress: CompleteAddress) => ResolveCustomRequest;
+export type Mode = 'constrained' | 'unconstrained';
+export type DeliveryMode = Mode | {
+    events: Mode;
+    notes: Mode;
+};
+export declare function buildMessageDeliveryTest(opts: {
+    strategy: string;
+    mode: DeliveryMode;
+    senderHook: ResolveTaggingSecretStrategy;
+    recipientRegistration?: (recipient: TestWallet, recipientAddress: AztecAddress, sender: AztecAddress) => Promise<void>;
+    customRequestResponder?: CustomRequestResponder;
+    additionalTests?: () => void;
+}): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25jaGFpbl9kZWxpdmVyeV9oYXJuZXNzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXV0b21pbmUvZGVsaXZlcnkvb25jaGFpbl9kZWxpdmVyeV9oYXJuZXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLGtCQUFrQixFQUEyQixNQUFNLHlCQUF5QixDQUFDO0FBRzNGLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxlQUFlLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUsvRSxPQUFPLEtBQUssRUFBaUIsb0JBQW9CLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQU8zRyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFJOUQsTUFBTSxNQUFNLHNCQUFzQixHQUFHLENBQ25DLFNBQVMsRUFBRSxVQUFVLEVBQ3JCLGdCQUFnQixFQUFFLGtCQUFrQixFQUNwQyx3QkFBd0IsRUFBRSxlQUFlLEtBQ3RDLG9CQUFvQixDQUFDO0FBRTFCLE1BQU0sTUFBTSxJQUFJLEdBQUcsYUFBYSxHQUFHLGVBQWUsQ0FBQztBQUluRCxNQUFNLE1BQU0sWUFBWSxHQUFHLElBQUksR0FBRztJQUFFLE1BQU0sRUFBRSxJQUFJLENBQUM7SUFBQyxLQUFLLEVBQUUsSUFBSSxDQUFBO0NBQUUsQ0FBQztBQVloRSx3QkFBZ0Isd0JBQXdCLENBQUMsSUFBSSxFQUFFO0lBRzdDLFFBQVEsRUFBRSxNQUFNLENBQUM7SUFDakIsSUFBSSxFQUFFLFlBQVksQ0FBQztJQUVuQixVQUFVLEVBQUUsNEJBQTRCLENBQUM7SUFFekMscUJBQXFCLENBQUMsRUFBRSxDQUN0QixTQUFTLEVBQUUsVUFBVSxFQUNyQixnQkFBZ0IsRUFBRSxZQUFZLEVBQzlCLE1BQU0sRUFBRSxZQUFZLEtBQ2pCLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUduQixzQkFBc0IsQ0FBQyxFQUFFLHNCQUFzQixDQUFDO0lBSWhELGVBQWUsQ0FBQyxFQUFFLE1BQU0sSUFBSSxDQUFDO0NBQzlCLFFBdUpBIn0=

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":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAA2B,MAAM,yBAAyB,CAAC;AAG3F,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAK/E,OAAO,KAAK,EAAiB,oBAAoB,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAC;AAO3G,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAI9D,MAAM,MAAM,sBAAsB,GAAG,CACnC,SAAS,EAAE,UAAU,EACrB,gBAAgB,EAAE,kBAAkB,EACpC,wBAAwB,EAAE,eAAe,KACtC,oBAAoB,CAAC;AAE1B,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,4BAA4B,CAAC;IAEzC,qBAAqB,CAAC,EAAE,CACtB,SAAS,EAAE,UAAU,EACrB,gBAAgB,EAAE,YAAY,EAC9B,MAAM,EAAE,YAAY,KACjB,OAAO,CAAC,IAAI,CAAC,CAAC;IAGnB,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;IAIhD,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;CAC9B,QAuJA"}

package/dest/automine/delivery/onchain_delivery_harness.js

@@ -0,0 +1,141 @@
+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, 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;
+        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);
+        let additionallyFundedAccounts;
+        let recipientAccount;
+        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)=>{
+                            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 = [];
+            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);
+        });
+        if (customRequestResponder) {
+            it('the custom request hook fires exactly once, on the send that bootstraps the tagging secret', ()=>{
+                expect(customRequestCount).toBe(1);
+            });
+        }
+        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);
+    }
+}