@aztec/end-to-end 0.0.1-commit.4d79d1f2d → 0.0.1-commit.4d9804df

package/dest/test-wallet/test_wallet.js

@@ -1,27 +1,44 @@
 import { EcdsaKAccountContract, EcdsaRAccountContract } from '@aztec/accounts/ecdsa';
-import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
-import { StubAccountContractArtifact, createStubAccount } from '@aztec/accounts/stub';
-import { SignerlessAccount } from '@aztec/aztec.js/account';
+import { StubEcdsaAccountContractArtifact, createStubEcdsaAccount } from '@aztec/accounts/ecdsa/stub';
+import { SchnorrAccountContract, SchnorrInitializerlessAccountContract } from '@aztec/accounts/schnorr';
+import { StubSchnorrAccountContractArtifact, createStubSchnorrAccount } from '@aztec/accounts/schnorr/stub';
+import { NO_FROM } from '@aztec/aztec.js/account';
 import { SetPublicAuthwitContractInteraction, computeInnerAuthWitHashFromAction, isContractFunctionInteractionCallIntent, lookupValidity } from '@aztec/aztec.js/authorization';
+import { ContractFunctionInteraction } from '@aztec/aztec.js/contracts';
 import { AccountManager } from '@aztec/aztec.js/wallet';
+import { TxSimulationResultWithAppOffset } from '@aztec/aztec.js/wallet';
+import { DefaultEntrypoint } from '@aztec/entrypoints/default';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
 import { getPXEConfig } from '@aztec/pxe/config';
 import { createPXE } from '@aztec/pxe/server';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
-import { deriveSigningKey } from '@aztec/stdlib/keys';
+import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
+import { SimulationOverrides } from '@aztec/stdlib/tx';
 import { mergeExecutionPayloads } from '@aztec/stdlib/tx';
 import { BaseWallet } from '@aztec/wallet-sdk/base-wallet';
+import { DEFAULT_MIN_FEE_PADDING } from '../fixtures/fixtures.js';
 import { AztecNodeProxy, ProvenTx } from './utils.js';
 /**
  * Wallet implementation that stores accounts in memory and provides extra debugging
  * utilities
  * It is intended to be used in e2e tests.
- */ export class TestWallet extends BaseWallet {
+ */ /**
+ * Poll interval (in seconds) for in-process TestWallet tx waits. In-process nodes reach CHECKPOINTED synchronously
+ * under automine and cheaply otherwise, so a sub-second cadence removes almost-pure dead time from every send().wait().
+ * Spartan tests run against remote JSON-RPC nodes and restore the 1s default via setDefaultWaitInterval.
+ */ export const IN_PROCESS_WAIT_INTERVAL_SECONDS = 0.25;
+export class TestWallet extends BaseWallet {
     nodeRef;
     constructor(pxe, nodeRef){
-        super(pxe, nodeRef), this.nodeRef = nodeRef, this.accounts = new Map(), this.simulatedSimulations = false;
+        super(pxe, nodeRef), this.nodeRef = nodeRef, this.stubClassIds = new Map(), this.accounts = new Map(), this.simulationMode = 'kernelless';
+        this.minFeePadding = DEFAULT_MIN_FEE_PADDING;
+        this.defaultWaitInterval = IN_PROCESS_WAIT_INTERVAL_SECONDS;
+    }
+    /**
+   * Overrides the poll interval (in seconds) used when a send().wait() caller does not specify one. Pass `undefined`
+   * to fall back to the DefaultWaitOpts cadence. Spartan tests set this to 1 so they do not hammer remote nodes.
+   */ setDefaultWaitInterval(interval) {
+        this.defaultWaitInterval = interval;
     }
     static async create(node, overridePXEConfig, options = {
         loggers: {}
@@ -32,7 +49,9 @@ import { AztecNodeProxy, ProvenTx } from './utils.js';
             ...overridePXEConfig
         });
         const pxe = await createPXE(nodeRef, pxeConfig, options);
-        return new TestWallet(pxe, nodeRef);
+        const wallet = new TestWallet(pxe, nodeRef);
+        await wallet.initStubClasses();
+        return wallet;
     }
     /**
    * Updates the underlying node that this wallet and its PXE communicate with.
@@ -41,95 +60,150 @@ import { AztecNodeProxy, ProvenTx } from './utils.js';
         this.nodeRef.updateTargetNode(node);
     }
     createSchnorrAccount(secret, salt, signingKey) {
-        signingKey = signingKey ?? deriveSigningKey(secret);
-        const accountData = {
+        return this.createAccount({
             secret,
             salt,
+            type: 'schnorr',
             contract: new SchnorrAccountContract(signingKey)
-        };
-        return this.createAccount(accountData);
+        });
+    }
+    createSchnorrInitializerlessAccount(secret, salt, signingKey) {
+        return this.createAccount({
+            secret,
+            salt,
+            type: 'schnorr_initializerless',
+            contract: new SchnorrInitializerlessAccountContract(signingKey)
+        });
     }
     createECDSARAccount(secret, salt, signingKey) {
-        const accountData = {
+        return this.createAccount({
             secret,
             salt,
+            type: 'ecdsasecp256r1',
             contract: new EcdsaRAccountContract(signingKey)
-        };
-        return this.createAccount(accountData);
+        });
     }
     createECDSAKAccount(secret, salt, signingKey) {
-        const accountData = {
+        return this.createAccount({
             secret,
             salt,
+            type: 'ecdsasecp256k1',
             contract: new EcdsaKAccountContract(signingKey)
-        };
-        return this.createAccount(accountData);
+        });
     }
-    async getFakeAccountDataFor(address) {
-        const originalAccount = await this.getAccountFromAddress(address);
-        if (originalAccount instanceof SignerlessAccount) {
-            throw new Error(`Cannot create fake account data for SignerlessAccount at address: ${address}`);
-        }
-        const originalAddress = originalAccount.getCompleteAddress();
-        const contractInstance = await this.pxe.getContractInstance(originalAddress.address);
-        if (!contractInstance) {
-            throw new Error(`No contract instance found for address: ${originalAddress.address}`);
+    // Stub class ids, populated on wallet startup
+    // to avoid redundant work per simulation
+    stubClassIds;
+    /**
+   * Hashes and registers the stub class for every supported account type with PXE, populating
+   * stubClassIds. Called on wallet initialization.
+   */ async initStubClasses() {
+        const { id: schnorrClassId } = await getContractClassFromArtifact(StubSchnorrAccountContractArtifact);
+        await this.pxe.registerContractClass(StubSchnorrAccountContractArtifact);
+        // ecdsa stubs share the same class id
+        const { id: ecdsaClassId } = await getContractClassFromArtifact(StubEcdsaAccountContractArtifact);
+        await this.pxe.registerContractClass(StubEcdsaAccountContractArtifact);
+        this.stubClassIds.set('schnorr', schnorrClassId);
+        // Initializerless accounts share the schnorr stub class for kernelless simulation.
+        this.stubClassIds.set('schnorr_initializerless', schnorrClassId);
+        this.stubClassIds.set('ecdsasecp256k1', ecdsaClassId);
+        this.stubClassIds.set('ecdsasecp256r1', ecdsaClassId);
+    }
+    /**
+   * Builds contract overrides for all provided addresses by replacing their account contracts with stub implementations.
+   */ async buildAccountOverrides(addresses) {
+        const accounts = await this.getAccounts();
+        const contracts = {};
+        const filtered = accounts.filter((acc)=>addresses.some((addr)=>addr.equals(acc.item)));
+        for (const account of filtered){
+            const address = account.item;
+            const originalAccount = await this.getAccountFromAddress(address);
+            const completeAddress = originalAccount.getCompleteAddress();
+            const contractInstance = await this.pxe.getContractInstance(completeAddress.address);
+            if (!contractInstance) {
+                throw new Error(`No contract instance found for address: ${completeAddress.address} during account override building. This is a bug!`);
+            }
+            const type = this.getTypeFor(address);
+            const stubClassId = this.stubClassIds.get(type);
+            if (!stubClassId) {
+                throw new Error(`Stub class for account type '${type}' was not registered at wallet init. This is a bug — initStubClasses should cover every supported AccountType.`);
+            }
+            contracts[address.toString()] = {
+                instance: {
+                    ...contractInstance,
+                    currentContractClassId: stubClassId
+                }
+            };
         }
-        const stubAccount = createStubAccount(originalAddress);
-        const instance = await getContractInstanceFromInstantiationParams(StubAccountContractArtifact, {
-            salt: Fr.random()
-        });
-        return {
-            account: stubAccount,
-            instance,
-            artifact: StubAccountContractArtifact
-        };
+        return contracts;
     }
     accounts;
+    getTypeFor(address) {
+        return this.accounts.get(address.toString())?.type ?? 'schnorr';
+    }
+    getStubAccountFor(address, completeAddress) {
+        const type = this.getTypeFor(address);
+        return type === 'schnorr' || type === 'schnorr_initializerless' ? createStubSchnorrAccount(completeAddress) : createStubEcdsaAccount(completeAddress);
+    }
     /**
-   * Toggle for running "simulated simulations" when calling simulateTx.
-   *
-   * When this flag is true, simulateViaEntrypoint constructs a request using a fake account
-   * (and accepts contract overrides on the input) and the PXE emulates kernel effects without
-   * generating kernel witnesses. When false, simulateViaEntrypoint defers to the standard
-   * simulation path via the real account entrypoint.
-   */ simulatedSimulations;
-    enableSimulatedSimulations() {
-        this.simulatedSimulations = true;
-    }
-    disableSimulatedSimulations() {
-        this.simulatedSimulations = false;
+   * Controls how the test wallet simulates transactions:
+   * - `kernelless`: Skips kernel circuits but uses the real account contract. Default.
+   * - `kernelless-override`: Skips kernels and replaces the account with a stub that doesn't do authwit validation.
+   * - `full`: Uses real kernel circuits and real account contracts. Slow!
+   */ simulationMode;
+    setSimulationMode(mode) {
+        this.simulationMode = mode;
     }
     setMinFeePadding(value) {
-        this.minFeePadding = value ?? 0.5;
+        this.minFeePadding = value ?? DEFAULT_MIN_FEE_PADDING;
     }
     getAccountFromAddress(address) {
-        let account;
-        if (address.equals(AztecAddress.ZERO)) {
-            account = new SignerlessAccount();
-        } else {
-            account = this.accounts.get(address?.toString() ?? '');
-        }
-        if (!account) {
+        const entry = this.accounts.get(address?.toString() ?? '');
+        if (!entry) {
             throw new Error(`Account not found in wallet for address: ${address}`);
         }
-        return Promise.resolve(account);
+        return Promise.resolve(entry.account);
     }
     getAccounts() {
-        return Promise.resolve(Array.from(this.accounts.values()).map((acc)=>({
+        return Promise.resolve(Array.from(this.accounts.values()).map((entry)=>({
                 alias: '',
-                item: acc.getAddress()
+                item: entry.account.getAddress()
             })));
     }
     async createAccount(accountData) {
         const secret = accountData?.secret ?? Fr.random();
         const salt = accountData?.salt ?? Fr.random();
+        const type = accountData?.type ?? 'schnorr';
         const contract = accountData?.contract ?? new SchnorrAccountContract(GrumpkinScalar.random());
-        const accountManager = await AccountManager.create(this, secret, contract, salt);
+        // Initializerless accounts have no deployment tx: the address commits to the signing public key
+        // (via the contract's immutablesHash, resolved by AccountManager.create) and the constructor's
+        // storage writes are materialized locally via a simulated "store" call below.
+        // Mirrors EmbeddedWallet.createAccountInternal.
+        const accountManager = await AccountManager.create(this, secret, contract, {
+            salt
+        });
         const instance = accountManager.getInstance();
         const artifact = await contract.getContractArtifact();
         await this.registerContract(instance, artifact, secret);
-        this.accounts.set(accountManager.address.toString(), await accountManager.getAccount());
+        const address = accountManager.address.toString();
+        this.accounts.set(address, {
+            account: await accountManager.getAccount(),
+            type
+        });
+        if (contract instanceof SchnorrInitializerlessAccountContract) {
+            const constructorAbi = artifact.functions.find((f)=>f.name === 'constructor');
+            if (!constructorAbi) {
+                throw new Error('Could not create SchnorrInitializerlessAccount: constructor ABI not found');
+            }
+            const { x, y } = await contract.getSigningPublicKey();
+            const storeCall = new ContractFunctionInteraction(this, instance.address, constructorAbi, [
+                x,
+                y
+            ]);
+            await storeCall.simulate({
+                from: instance.address
+            });
+        }
         return accountManager;
     }
     lookupValidity(onBehalfOf, intent, witness) {
@@ -154,46 +228,71 @@ import { AztecNodeProxy, ProvenTx } from './utils.js';
         }
         return account.createAuthWit(intentInnerHash, chainInfo);
     }
-    /**
-   * Override simulateViaEntrypoint to use fake accounts for kernelless simulation
-   * when simulatedSimulations is enabled. Otherwise falls through to the real entrypoint path.
-   */ async simulateViaEntrypoint(executionPayload, from, feeOptions, skipTxValidation, skipFeeEnforcement, scopes) {
-        if (!this.simulatedSimulations) {
-            return super.simulateViaEntrypoint(executionPayload, from, feeOptions, skipTxValidation, skipFeeEnforcement, scopes);
-        }
+    async simulateViaEntrypoint(executionPayload, opts) {
+        const { from, feeOptions, additionalScopes, skipTxValidation, skipFeeEnforcement, sendMessagesAs } = opts;
+        const scopes = this.scopesFrom(from, additionalScopes ?? [], sendMessagesAs);
+        const skipKernels = this.simulationMode !== 'full';
+        const useOverride = this.simulationMode === 'kernelless-override';
         const feeExecutionPayload = await feeOptions.walletFeePaymentMethod?.getExecutionPayload();
-        const executionOptions = {
-            txNonce: Fr.random(),
-            cancellable: this.cancellableTransactions,
-            feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions
-        };
         const finalExecutionPayload = feeExecutionPayload ? mergeExecutionPayloads([
             feeExecutionPayload,
             executionPayload
         ]) : executionPayload;
-        const { account: fromAccount, instance, artifact } = await this.getFakeAccountDataFor(from);
         const chainInfo = await this.getChainInfo();
-        const txRequest = await fromAccount.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo, executionOptions);
-        const contractOverrides = {
-            [from.toString()]: {
-                instance,
-                artifact
+        let overrides = opts.overrides;
+        let txRequest;
+        if (useOverride) {
+            const accountOverrides = await this.buildAccountOverrides(scopes);
+            overrides = new SimulationOverrides({
+                publicStorage: overrides?.publicStorage,
+                contracts: {
+                    ...overrides?.contracts,
+                    ...accountOverrides
+                }
+            });
+        }
+        if (from === NO_FROM) {
+            const entrypoint = new DefaultEntrypoint();
+            txRequest = await entrypoint.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo);
+        } else {
+            let fromAccount;
+            if (useOverride) {
+                const originalAccount = await this.getAccountFromAddress(from);
+                fromAccount = this.getStubAccountFor(from, originalAccount.getCompleteAddress());
+            } else {
+                fromAccount = await this.getAccountFromAddress(from);
             }
-        };
-        return this.pxe.simulateTx(txRequest, {
+            const executionOptions = {
+                txNonce: Fr.random(),
+                cancellable: this.cancellableTransactions,
+                // If from is an address, feeOptions include the way the account contract should handle the fee payment
+                feePaymentMethodOptions: feeOptions.accountFeePaymentMethodOptions
+            };
+            txRequest = await fromAccount.createTxExecutionRequest(finalExecutionPayload, feeOptions.gasSettings, chainInfo, executionOptions);
+        }
+        const result = await this.pxe.simulateTx(txRequest, {
             simulatePublic: true,
-            skipFeeEnforcement: true,
-            skipTxValidation: true,
-            overrides: {
-                contracts: contractOverrides
-            },
-            scopes
+            skipKernels,
+            skipFeeEnforcement,
+            skipTxValidation,
+            overrides,
+            scopes,
+            senderForTags: this.senderForTagsFrom(from, sendMessagesAs)
         });
+        const appCallOffset = await this.computeAppCallOffset(from, feeOptions);
+        return TxSimulationResultWithAppOffset.fromResultAndOffset(result, appCallOffset);
     }
     async proveTx(exec, opts) {
-        const fee = await this.completeFeeOptions(opts.from, exec.feePayer, opts.fee?.gasSettings);
+        const fee = await this.completeFeeOptions({
+            from: opts.from,
+            feePayer: exec.feePayer,
+            gasSettings: opts.fee?.gasSettings
+        });
         const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(exec, opts.from, fee);
-        const txProvingResult = await this.pxe.proveTx(txRequest, this.scopesFor(opts.from));
+        const txProvingResult = await this.pxe.proveTx(txRequest, {
+            scopes: this.scopesFrom(opts.from, opts.additionalScopes ?? [], opts.sendMessagesAs),
+            senderForTags: this.senderForTagsFrom(opts.from, opts.sendMessagesAs)
+        });
         return new ProvenTx(this.aztecNode, await txProvingResult.toTx(), txProvingResult.getOffchainEffects(), txProvingResult.stats);
     }
     getTxReceipt(txHash) {
@@ -206,7 +305,14 @@ import { AztecNodeProxy, ProvenTx } from './utils.js';
         return this.pxe.getSyncedBlockHeader();
     }
     sync() {
-        return this.pxe.debug.sync();
+        return this.pxe.sync();
+    }
+    /**
+   * Registers a non-sender tagging-secret source (e.g. a raw out-of-band shared secret) so this PXE discovers messages
+   * tagged with it. Test-only surface over {@link PXE.registerTaggingSecretSource}, which the base `Wallet` does not
+   * expose. The `address-derived` (sender) variant is excluded: use {@link Wallet.registerSender} for that.
+   */ registerTaggingSecretSource(source) {
+        return this.pxe.registerTaggingSecretSource(source);
     }
     stop() {
         return this.pxe.stop();

package/dest/test-wallet/utils.d.ts

@@ -1,5 +1,7 @@
-import { ContractFunctionInteraction, DeployMethod, type DeployOptions, type NoWait, type SendInteractionOptions, type WaitOpts } from '@aztec/aztec.js/contracts';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { BatchCall, ContractFunctionInteraction, DeployMethod, type DeployOptions, type NoWait, type SendInteractionOptions, type WaitOpts } from '@aztec/aztec.js/contracts';
 import { type AztecNode } from '@aztec/aztec.js/node';
+import type { Logger } from '@aztec/foundation/log';
 import { type OffchainEffect, type ProvingStats, Tx, TxHash, type TxReceipt } from '@aztec/stdlib/tx';
 import type { TestWallet } from './test_wallet.js';
 export type ProvenTxSendOpts = {
@@ -15,9 +17,42 @@ export declare class ProvenTx extends Tx {
     send<W extends ProvenTxSendOpts['wait']>(options: ProvenTxSendOpts & {
         wait: W;
     }): Promise<ProvenTxSendReturn<W>>;
+    private sendInner;
     private contextualizeError;
 }
-export declare function proveInteraction(wallet: TestWallet, interaction: ContractFunctionInteraction | DeployMethod, options: SendInteractionOptions | DeployOptions): Promise<ProvenTx>;
+export declare function proveInteraction(wallet: TestWallet, interaction: ContractFunctionInteraction | DeployMethod | BatchCall, options: SendInteractionOptions | DeployOptions): Promise<ProvenTx>;
+/** Builds an interaction for index `i` of a batch. */
+export type MakeBatchCall = (i: number) => ContractFunctionInteraction | DeployMethod | BatchCall;
+/**
+ * Pre-proves `count` interactions built by `makeCall(i)` against `wallet`, all with the same
+ * `options`. Returns the proven txs so the caller can send them individually (e.g. with sleeps
+ * between sends, or anchored to intermediate tips). For the common "send the whole batch at once"
+ * case use {@link proveAndSendTxs}.
+ */
+export declare function proveTxs(wallet: TestWallet, count: number, makeCall: MakeBatchCall, options: SendInteractionOptions | DeployOptions): Promise<ProvenTx[]>;
+/**
+ * Pre-proves `count` interactions built by `makeCall(i)` and sends each one with `NO_WAIT`, all at
+ * once. Returns the tx hashes in batch order. Pairs with `waitForTxs` for the "send N, wait for N"
+ * arc. Use {@link proveTxs} instead when the sends need bespoke sequencing.
+ */
+export declare function proveAndSendTxs(wallet: TestWallet, count: number, makeCall: MakeBatchCall, options: SendInteractionOptions | DeployOptions): Promise<TxHash[]>;
+/** Options for {@link startMempoolFeeder}. */
+export type MempoolFeederOpts = {
+    /** The account the txs are sent from. */
+    from: AztecAddress;
+    /** Keep the pending-tx count at or above this threshold; defaults to 3. */
+    minPending?: number;
+    /** Milliseconds between top-up polls; defaults to 1000. */
+    intervalMs?: number;
+    /** Logger for verbose top-up traces. */
+    logger?: Logger;
+};
+/**
+ * Starts a background loop that keeps `node`'s mempool topped up: whenever the pending-tx count drops
+ * below `opts.minPending`, it proves and sends one interaction built by `makeCall()` (NO_WAIT). Errors
+ * are swallowed and retried. Returns an {@link AsyncDisposable}; disposing stops the loop and awaits it.
+ */
+export declare function startMempoolFeeder(wallet: TestWallet, node: AztecNode, makeCall: () => ContractFunctionInteraction | DeployMethod | BatchCall, opts: MempoolFeederOpts): AsyncDisposable;
 /**
  * Extends AztecNode via declaration merging so instances can be used wherever AztecNode is expected.
  * The actual method forwarding is handled by a Proxy in the class constructor.
@@ -38,4 +73,4 @@ export declare class AztecNodeProxy {
      */
     updateTargetNode(node: AztecNode): void;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0LXdhbGxldC91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsMkJBQTJCLEVBQzNCLFlBQVksRUFDWixLQUFLLGFBQWEsRUFFbEIsS0FBSyxNQUFNLEVBQ1gsS0FBSyxzQkFBc0IsRUFDM0IsS0FBSyxRQUFRLEVBRWQsTUFBTSwyQkFBMkIsQ0FBQztBQUNuQyxPQUFPLEVBQUUsS0FBSyxTQUFTLEVBQWEsTUFBTSxzQkFBc0IsQ0FBQztBQUVqRSxPQUFPLEVBQUUsS0FBSyxjQUFjLEVBQUUsS0FBSyxZQUFZLEVBQUUsRUFBRSxFQUFFLE1BQU0sRUFBRSxLQUFLLFNBQVMsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBSXRHLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRW5ELE1BQU0sTUFBTSxnQkFBZ0IsR0FBRztJQUM3QixJQUFJLENBQUMsRUFBRSxNQUFNLEdBQUcsUUFBUSxDQUFDO0NBQzFCLENBQUM7QUFFRixNQUFNLE1BQU0sa0JBQWtCLENBQUMsQ0FBQyxTQUFTLE1BQU0sR0FBRyxRQUFRLEdBQUcsU0FBUyxJQUFJLENBQUMsU0FBUyxNQUFNLEdBQUcsTUFBTSxHQUFHLFNBQVMsQ0FBQztBQUVoSCxxQkFBYSxRQUFTLFNBQVEsRUFBRTtJQUU1QixPQUFPLENBQUMsSUFBSTtJQUVMLGVBQWUsRUFBRSxjQUFjLEVBQUU7SUFDakMsS0FBSyxDQUFDO0lBSmYsWUFDVSxJQUFJLEVBQUUsU0FBUyxFQUN2QixFQUFFLEVBQUUsRUFBRSxFQUNDLGVBQWUsRUFBRSxjQUFjLEVBQUUsRUFDakMsS0FBSyxDQUFDLDBCQUFjLEVBRzVCO0lBRUQsSUFBSSxDQUFDLE9BQU8sQ0FBQyxFQUFFLElBQUksQ0FBQyxnQkFBZ0IsRUFBRSxNQUFNLENBQUMsR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDbkUsSUFBSSxDQUFDLENBQUMsU0FBUyxnQkFBZ0IsQ0FBQyxNQUFNLENBQUMsRUFBRSxPQUFPLEVBQUUsZ0JBQWdCLEdBQUc7UUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFBO0tBQUUsR0FBRyxPQUFPLENBQUMsa0JBQWtCLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQWVsSCxPQUFPLENBQUMsa0JBQWtCO0NBVTNCO0FBRUQsd0JBQXNCLGdCQUFnQixDQUNwQyxNQUFNLEVBQUUsVUFBVSxFQUNsQixXQUFXLEVBQUUsMkJBQTJCLEdBQUcsWUFBWSxFQUN2RCxPQUFPLEVBQUUsc0JBQXNCLEdBQUcsYUFBYSxxQkFTaEQ7QUFFRDs7O0dBR0c7QUFFSCxNQUFNLFdBQVcsY0FBZSxTQUFRLFNBQVM7Q0FBRztBQUVwRDs7OztHQUlHO0FBRUgscUJBQWEsY0FBYztJQUNiLE9BQU8sQ0FBQyxNQUFNO0lBQTFCLFlBQW9CLE1BQU0sRUFBRSxTQUFTLEVBWXBDO0lBRUQ7OztPQUdHO0lBQ0gsZ0JBQWdCLENBQUMsSUFBSSxFQUFFLFNBQVMsR0FBRyxJQUFJLENBRXRDO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0LXdhbGxldC91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUM5RCxPQUFPLEVBQ0wsU0FBUyxFQUNULDJCQUEyQixFQUMzQixZQUFZLEVBQ1osS0FBSyxhQUFhLEVBRWxCLEtBQUssTUFBTSxFQUNYLEtBQUssc0JBQXNCLEVBQzNCLEtBQUssUUFBUSxFQUVkLE1BQU0sMkJBQTJCLENBQUM7QUFDbkMsT0FBTyxFQUFFLEtBQUssU0FBUyxFQUFhLE1BQU0sc0JBQXNCLENBQUM7QUFFakUsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFHcEQsT0FBTyxFQUFFLEtBQUssY0FBYyxFQUFFLEtBQUssWUFBWSxFQUFFLEVBQUUsRUFBRSxNQUFNLEVBQUUsS0FBSyxTQUFTLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUt0RyxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVuRCxNQUFNLE1BQU0sZ0JBQWdCLEdBQUc7SUFDN0IsSUFBSSxDQUFDLEVBQUUsTUFBTSxHQUFHLFFBQVEsQ0FBQztDQUMxQixDQUFDO0FBRUYsTUFBTSxNQUFNLGtCQUFrQixDQUFDLENBQUMsU0FBUyxNQUFNLEdBQUcsUUFBUSxHQUFHLFNBQVMsSUFBSSxDQUFDLFNBQVMsTUFBTSxHQUFHLE1BQU0sR0FBRyxTQUFTLENBQUM7QUFFaEgscUJBQWEsUUFBUyxTQUFRLEVBQUU7SUFFNUIsT0FBTyxDQUFDLElBQUk7SUFFTCxlQUFlLEVBQUUsY0FBYyxFQUFFO0lBQ2pDLEtBQUssQ0FBQztJQUpmLFlBQ1UsSUFBSSxFQUFFLFNBQVMsRUFDdkIsRUFBRSxFQUFFLEVBQUUsRUFDQyxlQUFlLEVBQUUsY0FBYyxFQUFFLEVBQ2pDLEtBQUssQ0FBQywwQkFBYyxFQUc1QjtJQUVELElBQUksQ0FBQyxPQUFPLENBQUMsRUFBRSxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsTUFBTSxDQUFDLEdBQUcsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ25FLElBQUksQ0FBQyxDQUFDLFNBQVMsZ0JBQWdCLENBQUMsTUFBTSxDQUFDLEVBQUUsT0FBTyxFQUFFLGdCQUFnQixHQUFHO1FBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQTtLQUFFLEdBQUcsT0FBTyxDQUFDLGtCQUFrQixDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFLcEcsU0FBUztJQWN2QixPQUFPLENBQUMsa0JBQWtCO0NBVTNCO0FBRUQsd0JBQWdCLGdCQUFnQixDQUM5QixNQUFNLEVBQUUsVUFBVSxFQUNsQixXQUFXLEVBQUUsMkJBQTJCLEdBQUcsWUFBWSxHQUFHLFNBQVMsRUFDbkUsT0FBTyxFQUFFLHNCQUFzQixHQUFHLGFBQWEsR0FDOUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxDQUtuQjtBQUVELHNEQUFzRDtBQUN0RCxNQUFNLE1BQU0sYUFBYSxHQUFHLENBQUMsQ0FBQyxFQUFFLE1BQU0sS0FBSywyQkFBMkIsR0FBRyxZQUFZLEdBQUcsU0FBUyxDQUFDO0FBRWxHOzs7OztHQUtHO0FBQ0gsd0JBQWdCLFFBQVEsQ0FDdEIsTUFBTSxFQUFFLFVBQVUsRUFDbEIsS0FBSyxFQUFFLE1BQU0sRUFDYixRQUFRLEVBQUUsYUFBYSxFQUN2QixPQUFPLEVBQUUsc0JBQXNCLEdBQUcsYUFBYSxHQUM5QyxPQUFPLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FFckI7QUFFRDs7OztHQUlHO0FBQ0gsd0JBQXNCLGVBQWUsQ0FDbkMsTUFBTSxFQUFFLFVBQVUsRUFDbEIsS0FBSyxFQUFFLE1BQU0sRUFDYixRQUFRLEVBQUUsYUFBYSxFQUN2QixPQUFPLEVBQUUsc0JBQXNCLEdBQUcsYUFBYSxHQUM5QyxPQUFPLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FHbkI7QUFFRCw4Q0FBOEM7QUFDOUMsTUFBTSxNQUFNLGlCQUFpQixHQUFHO0lBQzlCLHlDQUF5QztJQUN6QyxJQUFJLEVBQUUsWUFBWSxDQUFDO0lBQ25CLDJFQUEyRTtJQUMzRSxVQUFVLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDcEIsMkRBQTJEO0lBQzNELFVBQVUsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNwQix3Q0FBd0M7SUFDeEMsTUFBTSxDQUFDLEVBQUUsTUFBTSxDQUFDO0NBQ2pCLENBQUM7QUFFRjs7OztHQUlHO0FBQ0gsd0JBQWdCLGtCQUFrQixDQUNoQyxNQUFNLEVBQUUsVUFBVSxFQUNsQixJQUFJLEVBQUUsU0FBUyxFQUNmLFFBQVEsRUFBRSxNQUFNLDJCQUEyQixHQUFHLFlBQVksR0FBRyxTQUFTLEVBQ3RFLElBQUksRUFBRSxpQkFBaUIsR0FDdEIsZUFBZSxDQTZCakI7QUFFRDs7O0dBR0c7QUFFSCxNQUFNLFdBQVcsY0FBZSxTQUFRLFNBQVM7Q0FBRztBQUVwRDs7OztHQUlHO0FBRUgscUJBQWEsY0FBYztJQUNiLE9BQU8sQ0FBQyxNQUFNO0lBQTFCLFlBQW9CLE1BQU0sRUFBRSxTQUFTLEVBWXBDO0lBRUQ7OztPQUdHO0lBQ0gsZ0JBQWdCLENBQUMsSUFBSSxFQUFFLFNBQVMsR0FBRyxJQUFJLENBRXRDO0NBQ0YifQ==

package/dest/test-wallet/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/test-wallet/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,YAAY,EACZ,KAAK,aAAa,EAElB,KAAK,MAAM,EACX,KAAK,sBAAsB,EAC3B,KAAK,QAAQ,EAEd,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,sBAAsB,CAAC;AAEjE,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,YAAY,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAItG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,MAAM,GAAG,QAAQ,GAAG,SAAS,IAAI,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AAEhH,qBAAa,QAAS,SAAQ,EAAE;IAE5B,OAAO,CAAC,IAAI;IAEL,eAAe,EAAE,cAAc,EAAE;IACjC,KAAK,CAAC;IAJf,YACU,IAAI,EAAE,SAAS,EACvB,EAAE,EAAE,EAAE,EACC,eAAe,EAAE,cAAc,EAAE,EACjC,KAAK,CAAC,0BAAc,EAG5B;IAED,IAAI,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IACnE,IAAI,CAAC,CAAC,SAAS,gBAAgB,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,gBAAgB,GAAG;QAAE,IAAI,EAAE,CAAC,CAAA;KAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC;IAelH,OAAO,CAAC,kBAAkB;CAU3B;AAED,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,2BAA2B,GAAG,YAAY,EACvD,OAAO,EAAE,sBAAsB,GAAG,aAAa,qBAShD;AAED;;;GAGG;AAEH,MAAM,WAAW,cAAe,SAAQ,SAAS;CAAG;AAEpD;;;;GAIG;AAEH,qBAAa,cAAc;IACb,OAAO,CAAC,MAAM;IAA1B,YAAoB,MAAM,EAAE,SAAS,EAYpC;IAED;;;OAGG;IACH,gBAAgB,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAEtC;CACF"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/test-wallet/utils.ts"],"names":[],"mappings":"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"}

package/dest/test-wallet/utils.js

@@ -1,8 +1,11 @@
-import { DeployMethod, NO_WAIT, toSendOptions } from '@aztec/aztec.js/contracts';
+import { NO_WAIT, toSendOptions } from '@aztec/aztec.js/contracts';
 import { waitForTx } from '@aztec/aztec.js/node';
+import { timesAsync } from '@aztec/foundation/collection';
+import { sleep } from '@aztec/foundation/sleep';
 import { SimulationError } from '@aztec/stdlib/errors';
 import { Tx } from '@aztec/stdlib/tx';
 import { inspect } from 'util';
+import { testSpan, withTestSpanOwner } from '../fixtures/timing.js';
 export class ProvenTx extends Tx {
     node;
     offchainEffects;
@@ -10,7 +13,10 @@ export class ProvenTx extends Tx {
     constructor(node, tx, offchainEffects, stats){
         super(tx.getTxHash(), tx.data, tx.chonkProof, tx.contractClassLogFields, tx.publicFunctionCalldata), this.node = node, this.offchainEffects = offchainEffects, this.stats = stats;
     }
-    async send(options) {
+    send(options) {
+        return testSpan('tx:send', ()=>this.sendInner(options));
+    }
+    async sendInner(options) {
         const txHash = this.getTxHash();
         await this.node.sendTx(this).catch((err)=>{
             throw this.contextualizeError(err, inspect(this));
@@ -32,14 +38,63 @@ export class ProvenTx extends Tx {
         return err;
     }
 }
-export async function proveInteraction(wallet, interaction, options) {
-    let execPayload;
-    if (interaction instanceof DeployMethod) {
-        execPayload = await interaction.request(interaction.convertDeployOptionsToRequestOptions(options));
-    } else {
-        execPayload = await interaction.request(options);
-    }
-    return wallet.proveTx(execPayload, toSendOptions(options));
+export function proveInteraction(wallet, interaction, options) {
+    return testSpan('tx:prove', async ()=>{
+        const execPayload = await interaction.request(options);
+        return wallet.proveTx(execPayload, toSendOptions(options));
+    });
+}
+/**
+ * Pre-proves `count` interactions built by `makeCall(i)` against `wallet`, all with the same
+ * `options`. Returns the proven txs so the caller can send them individually (e.g. with sleeps
+ * between sends, or anchored to intermediate tips). For the common "send the whole batch at once"
+ * case use {@link proveAndSendTxs}.
+ */ export function proveTxs(wallet, count, makeCall, options) {
+    return timesAsync(count, (i)=>proveInteraction(wallet, makeCall(i), options));
+}
+/**
+ * Pre-proves `count` interactions built by `makeCall(i)` and sends each one with `NO_WAIT`, all at
+ * once. Returns the tx hashes in batch order. Pairs with `waitForTxs` for the "send N, wait for N"
+ * arc. Use {@link proveTxs} instead when the sends need bespoke sequencing.
+ */ export async function proveAndSendTxs(wallet, count, makeCall, options) {
+    const txs = await proveTxs(wallet, count, makeCall, options);
+    return Promise.all(txs.map((tx)=>tx.send({
+            wait: NO_WAIT
+        })));
+}
+/**
+ * Starts a background loop that keeps `node`'s mempool topped up: whenever the pending-tx count drops
+ * below `opts.minPending`, it proves and sends one interaction built by `makeCall()` (NO_WAIT). Errors
+ * are swallowed and retried. Returns an {@link AsyncDisposable}; disposing stops the loop and awaits it.
+ */ export function startMempoolFeeder(wallet, node, makeCall, opts) {
+    const minPending = opts.minPending ?? 3;
+    const intervalMs = opts.intervalMs ?? 1000;
+    let stopped = false;
+    // Pin the feeder's prove/send spans to a fixed non-test owner. It runs interleaved with arbitrary
+    // tests, so without this its tx:prove/tx:send spans would smear onto whichever test was current
+    // when each round fired; the pinned owner matches no test/suite record, excluding them cleanly.
+    const loop = withTestSpanOwner('other:mempool-feeder', async ()=>{
+        while(!stopped){
+            try {
+                const pendingCount = await node.getPendingTxCount();
+                if (pendingCount < minPending) {
+                    await proveAndSendTxs(wallet, 1, makeCall, {
+                        from: opts.from
+                    });
+                    opts.logger?.verbose(`Topped up mempool (was ${pendingCount})`);
+                }
+            } catch (err) {
+                opts.logger?.verbose(`Mempool top-up error (will retry): ${err}`);
+            }
+            await sleep(intervalMs);
+        }
+    });
+    return {
+        async [Symbol.asyncDispose] () {
+            stopped = true;
+            await loop;
+        }
+    };
 }
 /**
  * Mutable wrapper around an AztecNode that forwards all calls to the current target.

package/dest/test-wallet/wallet_worker_script.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2FsbGV0X3dvcmtlcl9zY3JpcHQuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0LXdhbGxldC93YWxsZXRfd29ya2VyX3NjcmlwdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dest/test-wallet/wallet_worker_script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet_worker_script.d.ts","sourceRoot":"","sources":["../../src/test-wallet/wallet_worker_script.ts"],"names":[],"mappings":""}

package/dest/test-wallet/wallet_worker_script.js

@@ -0,0 +1,56 @@
+import { DefaultWaitOpts } from '@aztec/aztec.js/contracts';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import { BackendType, BarretenbergSync } from '@aztec/bb.js';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import { createLogger } from '@aztec/foundation/log';
+import { getSchemaParameters, parseWithOptionals, schemaHasMethod } from '@aztec/foundation/schemas';
+import { NodeListener, TransportServer } from '@aztec/foundation/transport';
+import { Tx } from '@aztec/stdlib/tx';
+import { workerData } from 'worker_threads';
+import { TestWallet } from './test_wallet.js';
+import { WorkerWalletSchema } from './worker_wallet_schema.js';
+const logger = createLogger('e2e:test-wallet:worker');
+try {
+    const { nodeUrl, pxeConfig } = workerData;
+    logger.info('Initializing worker wallet', {
+        nodeUrl
+    });
+    const node = createAztecNodeClient(nodeUrl);
+    // Worker sync bb use is limited to crypto and proof serialization helpers.
+    await BarretenbergSync.initSingleton({
+        backend: BackendType.Wasm
+    });
+    const wallet = await TestWallet.create(node, pxeConfig);
+    // Worker wallets are only used by spartan tests against remote JSON-RPC nodes: keep the 1s poll cadence.
+    wallet.setDefaultWaitInterval(DefaultWaitOpts.interval);
+    logger.info('Worker wallet initialized');
+    const customMethods = {
+        proveTx: async (exec, opts)=>{
+            const provenTx = await wallet.proveTx(exec, opts);
+            return new Tx(provenTx.getTxHash(), provenTx.data, provenTx.chonkProof, provenTx.contractClassLogFields, provenTx.publicFunctionCalldata);
+        },
+        registerAccount: async (secret, salt, signingKey)=>{
+            const manager = await wallet.createSchnorrAccount(secret, salt, signingKey);
+            return manager.address;
+        }
+    };
+    const schema = WorkerWalletSchema;
+    const listener = new NodeListener();
+    const server = new TransportServer(listener, async (msg)=>{
+        if (!schemaHasMethod(schema, msg.fn)) {
+            throw new Error(`Unknown method: ${msg.fn}`);
+        }
+        const jsonParams = JSON.parse(msg.args);
+        const args = await parseWithOptionals(jsonParams, getSchemaParameters(schema[msg.fn]));
+        // we have to erase the fn type in order to be able to spread ...args
+        const handler = msg.fn in customMethods ? customMethods[msg.fn] : undefined;
+        const result = handler ? await handler(...args) : await wallet[msg.fn](...args);
+        return jsonStringify(result);
+    });
+    server.start();
+} catch (err) {
+    logger.error('Worker wallet initialization failed', {
+        error: err instanceof Error ? err.stack : String(err)
+    });
+    process.exit(1);
+}