@aztec/end-to-end 0.0.1-commit.e3c1de76 → 0.0.1-commit.e57c76e

package/dest/e2e_p2p/shared.d.ts

@@ -4,21 +4,51 @@ import { AztecAddress } from '@aztec/aztec.js/addresses';
 import type { Logger } from '@aztec/aztec.js/log';
 import { TxHash } from '@aztec/aztec.js/tx';
 import type { RollupCheatCodes } from '@aztec/aztec/testing';
-import type { EmpireSlashingProposerContract, RollupContract, TallySlashingProposerContract } from '@aztec/ethereum/contracts';
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import type { RollupContract, SlashingProposerContract } from '@aztec/ethereum/contracts';
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import type { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
-import type { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
-import { type ProvenTx } from '@aztec/test-wallet/server';
+import { type ProvenTx } from '../test-wallet/utils.js';
 export declare const submitComplexTxsTo: (logger: Logger, from: AztecAddress, spamContract: SpamContract, numTxs: number, opts?: {
     callPublic?: boolean | undefined;
 }) => Promise<TxHash[]>;
 export declare const submitTransactions: (logger: Logger, node: AztecNodeService, numTxs: number, fundedAccount: InitialAccountData) => Promise<TxHash[]>;
 export declare function prepareTransactions(logger: Logger, node: AztecNodeService, numTxs: number, fundedAccount: InitialAccountData): Promise<ProvenTx[]>;
-export declare function awaitProposalExecution(slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract, timeoutSeconds: number, logger: Logger): Promise<bigint>;
+export declare function awaitProposalExecution(slashingProposer: SlashingProposerContract, timeoutSeconds: number, logger: Logger): Promise<bigint>;
 export declare function awaitCommitteeExists({ rollup, logger }: {
     rollup: RollupContract;
     logger: Logger;
 }): Promise<readonly `0x${string}`[]>;
+/**
+ * Advance epochs until we find one where the target proposer is selected for a slot at least
+ * `warmupSlots` into the epoch, then stop one epoch before it. This leaves time for the caller to
+ * start sequencers before warping to the target epoch, avoiding the race where the target epoch
+ * passes before sequencers are ready.
+ *
+ * The first `warmupSlots` slots of the epoch are skipped on purpose. Callers warp to one slot
+ * before the target epoch and, under proposer pipelining, the proposer begins building one slot
+ * before its proposal slot. If the proposer were in the first slot of the epoch, that build would
+ * begin at the exact instant of the warp, leaving the freshly-started sequencer no warm-up margin;
+ * it then serializes its (often AVM-heavy) proposal past the slot boundary and honest receivers
+ * reject it as late. Picking a slot at least `warmupSlots` into the epoch guarantees that many full
+ * slots of wall-clock between the warp and the start of the proposer's build.
+ *
+ * Returns the target epoch and the concrete target slot so the caller can warp to it after starting
+ * sequencers.
+ */
+export declare function advanceToEpochBeforeProposer({ epochCache, cheatCodes, targetProposer, logger, maxAttempts, warmupSlots }: {
+    epochCache: EpochCacheInterface;
+    cheatCodes: RollupCheatCodes;
+    targetProposer: EthAddress;
+    logger: Logger;
+    maxAttempts?: number;
+    warmupSlots?: number;
+}): Promise<{
+    targetEpoch: EpochNumber;
+    targetSlot: SlotNumber;
+}>;
 export declare function awaitOffenseDetected({ logger, nodeAdmin, slashingRoundSize, epochDuration, waitUntilOffenseCount, timeoutSeconds }: {
     nodeAdmin: AztecNodeAdmin;
     logger: Logger;
@@ -31,16 +61,15 @@ export declare function awaitOffenseDetected({ logger, nodeAdmin, slashingRoundS
  * Await the committee to be slashed out of the validator set.
  * Currently assumes that the committee is the same size as the validator set.
  */
-export declare function awaitCommitteeKicked({ rollup, cheatCodes, committee, slashFactory, slashingProposer, slashingRoundSize, aztecSlotDuration, aztecEpochDuration, logger, offenseEpoch }: {
+export declare function awaitCommitteeKicked({ rollup, cheatCodes, committee, slashingProposer, slashingRoundSize, aztecSlotDuration, aztecEpochDuration, logger, offenseEpoch }: {
     rollup: RollupContract;
     cheatCodes: RollupCheatCodes;
     committee: readonly `0x${string}`[];
-    slashFactory: SlashFactoryContract;
-    slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
+    slashingProposer: SlashingProposerContract | undefined;
     slashingRoundSize: number;
     aztecSlotDuration: number;
     aztecEpochDuration: number;
     logger: Logger;
     offenseEpoch: number;
 }): Promise<void>;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/e2e_p2p/shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/e2e_p2p/shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EACV,8BAA8B,EAC9B,cAAc,EACd,6BAA6B,EAC9B,MAAM,2BAA2B,CAAC;AAMnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAIvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAE,KAAK,QAAQ,EAAgC,MAAM,2BAA2B,CAAC;AAKxF,eAAO,MAAM,kBAAkB;;uBAkB9B,CAAC;AAGF,eAAO,MAAM,kBAAkB,kHAe9B,CAAC;AAEF,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,kBAAkB,GAChC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAwBrB;AAED,wBAAgB,sBAAsB,CACpC,gBAAgB,EAAE,8BAA8B,GAAG,6BAA6B,EAChF,cAAc,EAAE,MAAM,EACtB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,CA0BjB;AAED,wBAAsB,oBAAoB,CAAC,EACzC,MAAM,EACN,MAAM,EACP,EAAE;IACD,MAAM,EAAE,cAAc,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,SAAS,KAAK,MAAM,EAAE,EAAE,CAAC,CAYpC;AAED,wBAAsB,oBAAoB,CAAC,EACzC,MAAM,EACN,SAAS,EACT,iBAAiB,EACjB,aAAa,EACb,qBAAqB,EACrB,cAAoB,EACrB,EAAE;IACD,SAAS,EAAE,cAAc,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,+CAkBA;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CAAC,EACzC,MAAM,EACN,UAAU,EACV,SAAS,EACT,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,MAAM,EACN,YAAY,EACb,EAAE;IACD,MAAM,EAAE,cAAc,CAAC;IACvB,UAAU,EAAE,gBAAgB,CAAC;IAC7B,SAAS,EAAE,SAAS,KAAK,MAAM,EAAE,EAAE,CAAC;IACpC,YAAY,EAAE,oBAAoB,CAAC;IACnC,gBAAgB,EAAE,8BAA8B,GAAG,6BAA6B,GAAG,SAAS,CAAC;IAC7F,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;CACtB,iBA6EA"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/e2e_p2p/shared.ts"],"names":[],"mappings":"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"}

package/dest/e2e_p2p/shared.js

@@ -1,14 +1,16 @@
 import { NO_WAIT, getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
 import { Fr } from '@aztec/aztec.js/fields';
-import { EpochNumber } from '@aztec/foundation/branded-types';
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { timesAsync, unique } from '@aztec/foundation/collection';
 import { retryUntil } from '@aztec/foundation/retry';
 import { pluralize } from '@aztec/foundation/string';
 import { TestContract, TestContractArtifact } from '@aztec/noir-test-contracts.js/Test';
 import { getPXEConfig, getPXEConfig as getRpcConfig } from '@aztec/pxe/server';
 import { getRoundForOffense } from '@aztec/slasher';
-import { TestWallet, proveInteraction } from '@aztec/test-wallet/server';
+import { SchnorrHardcodedKeyAccountContract } from '../fixtures/schnorr_hardcoded_account_contract.js';
 import { submitTxsTo } from '../shared/submit-transactions.js';
+import { TestWallet } from '../test-wallet/test_wallet.js';
+import { proveInteraction } from '../test-wallet/utils.js';
 // submits a set of transactions to the provided Private eXecution Environment (PXE)
 export const submitComplexTxsTo = async (logger, from, spamContract, numTxs, opts = {})=>{
     const txs = [];
@@ -16,7 +18,7 @@ export const submitComplexTxsTo = async (logger, from, spamContract, numTxs, opt
     const spamCount = 15;
     for(let i = 0; i < numTxs; i++){
         const method = spamContract.methods.spam(seed + BigInt(i * spamCount), spamCount, !!opts.callPublic);
-        const txHash = await method.send({
+        const { txHash } = await method.send({
             from,
             wait: NO_WAIT
         });
@@ -29,13 +31,21 @@ export const submitComplexTxsTo = async (logger, from, spamContract, numTxs, opt
 export const submitTransactions = async (logger, node, numTxs, fundedAccount)=>{
     const rpcConfig = getRpcConfig();
     rpcConfig.proverEnabled = false;
-    const wallet = await TestWallet.create(node, {
+    const wallet = await TestWallet.create(node, // Use checkpointed chain tip to avoid anchoring on provisional blocks that the archiver can prune
+    // when their slot ends without a checkpoint landing on L1.
+    {
         ...getPXEConfig(),
-        proverEnabled: false
+        proverEnabled: false,
+        syncChainTip: 'checkpointed'
     }, {
         loggerActorLabel: 'pxe-tx'
     });
-    const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
+    const contract = new SchnorrHardcodedKeyAccountContract();
+    const fundedAccountManager = await wallet.createAccount({
+        secret: fundedAccount.secret,
+        salt: fundedAccount.salt,
+        contract
+    });
     return submitTxsTo(wallet, fundedAccountManager.address, numTxs, logger);
 };
 export async function prepareTransactions(logger, node, numTxs, fundedAccount) {
@@ -43,11 +53,17 @@ export async function prepareTransactions(logger, node, numTxs, fundedAccount) {
     rpcConfig.proverEnabled = false;
     const wallet = await TestWallet.create(node, {
         ...getPXEConfig(),
-        proverEnabled: false
+        proverEnabled: false,
+        syncChainTip: 'checkpointed'
     }, {
         loggerActorLabel: 'pxe-tx'
     });
-    const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
+    const accountContract = new SchnorrHardcodedKeyAccountContract();
+    const fundedAccountManager = await wallet.createAccount({
+        secret: fundedAccount.secret,
+        salt: fundedAccount.salt,
+        contract: accountContract
+    });
     const testContractInstance = await getContractInstanceFromInstantiationParams(TestContractArtifact, {
         salt: Fr.random()
     });
@@ -67,24 +83,12 @@ export function awaitProposalExecution(slashingProposer, timeoutSeconds, logger)
             logger.warn(`Timed out waiting for proposal execution`);
             reject(new Error(`Timeout waiting for proposal execution after ${timeoutSeconds}s`));
         }, timeoutSeconds * 1000);
-        if (slashingProposer.type === 'empire') {
-            const unwatch = slashingProposer.listenToPayloadSubmitted((args)=>{
-                logger.warn(`Proposal ${args.payload} from round ${args.round} executed`);
-                clearTimeout(timeout);
-                unwatch();
-                resolve(args.round);
-            });
-        } else if (slashingProposer.type === 'tally') {
-            const unwatch = slashingProposer.listenToRoundExecuted((args)=>{
-                logger.warn(`Slash from round ${args.round} executed`);
-                clearTimeout(timeout);
-                unwatch();
-                resolve(args.round);
-            });
-        } else {
+        const unwatch = slashingProposer.listenToRoundExecuted((args)=>{
+            logger.warn(`Slash from round ${args.round} executed`);
             clearTimeout(timeout);
-            reject(new Error(`Unknown slashing proposer type: ${slashingProposer.type}`));
-        }
+            unwatch();
+            resolve(args.round);
+        });
     });
 }
 export async function awaitCommitteeExists({ rollup, logger }) {
@@ -94,8 +98,55 @@ export async function awaitCommitteeExists({ rollup, logger }) {
         committee = await rollup.getCurrentEpochCommittee();
         return committee && committee.length > 0;
     }, 'non-empty committee', 60);
+    logger.warn(`Committee has been formed`, {
+        committee: committee.map((c)=>c.toString())
+    });
     return committee.map((c)=>c.toString());
 }
+/**
+ * Advance epochs until we find one where the target proposer is selected for a slot at least
+ * `warmupSlots` into the epoch, then stop one epoch before it. This leaves time for the caller to
+ * start sequencers before warping to the target epoch, avoiding the race where the target epoch
+ * passes before sequencers are ready.
+ *
+ * The first `warmupSlots` slots of the epoch are skipped on purpose. Callers warp to one slot
+ * before the target epoch and, under proposer pipelining, the proposer begins building one slot
+ * before its proposal slot. If the proposer were in the first slot of the epoch, that build would
+ * begin at the exact instant of the warp, leaving the freshly-started sequencer no warm-up margin;
+ * it then serializes its (often AVM-heavy) proposal past the slot boundary and honest receivers
+ * reject it as late. Picking a slot at least `warmupSlots` into the epoch guarantees that many full
+ * slots of wall-clock between the warp and the start of the proposer's build.
+ *
+ * Returns the target epoch and the concrete target slot so the caller can warp to it after starting
+ * sequencers.
+ */ export async function advanceToEpochBeforeProposer({ epochCache, cheatCodes, targetProposer, logger, maxAttempts = 20, warmupSlots = 1 }) {
+    const { epochDuration } = await cheatCodes.getConfig();
+    for(let attempt = 0; attempt < maxAttempts; attempt++){
+        const currentEpoch = await cheatCodes.getEpoch();
+        // Check the NEXT epoch's slots so we stay one epoch before the target,
+        // giving the caller time to start sequencers before the target epoch arrives.
+        const nextEpoch = Number(currentEpoch) + 1;
+        const epochStartSlot = nextEpoch * Number(epochDuration);
+        // Skip the first `warmupSlots` slots so the caller keeps a warm-up margin after warping to one
+        // slot before the epoch (see the doc comment above).
+        const startSlot = epochStartSlot + warmupSlots;
+        const endSlot = epochStartSlot + Number(epochDuration);
+        logger.info(`Checking next epoch ${nextEpoch} (slots ${startSlot}-${endSlot - 1}) for proposer ${targetProposer} (current epoch: ${currentEpoch})`);
+        for(let s = startSlot; s < endSlot; s++){
+            const proposer = await epochCache.getProposerAttesterAddressInSlot(SlotNumber(s));
+            if (proposer && proposer.equals(targetProposer)) {
+                logger.warn(`Found target proposer ${targetProposer} in slot ${s} of epoch ${nextEpoch}. Staying at epoch ${currentEpoch} to allow sequencer startup.`);
+                return {
+                    targetEpoch: EpochNumber(nextEpoch),
+                    targetSlot: SlotNumber(s)
+                };
+            }
+        }
+        logger.info(`Target proposer not found in epoch ${nextEpoch}, advancing to next epoch`);
+        await cheatCodes.advanceToNextEpoch();
+    }
+    throw new Error(`Target proposer ${targetProposer} not found in any slot after ${maxAttempts} epoch attempts`);
+}
 export async function awaitOffenseDetected({ logger, nodeAdmin, slashingRoundSize, epochDuration, waitUntilOffenseCount, timeoutSeconds = 120 }) {
     const targetOffenseCount = waitUntilOffenseCount ?? 1;
     logger.warn(`Waiting for ${pluralize('offense', targetOffenseCount)} to be detected`);
@@ -116,42 +167,31 @@ export async function awaitOffenseDetected({ logger, nodeAdmin, slashingRoundSiz
 /**
  * Await the committee to be slashed out of the validator set.
  * Currently assumes that the committee is the same size as the validator set.
- */ export async function awaitCommitteeKicked({ rollup, cheatCodes, committee, slashFactory, slashingProposer, slashingRoundSize, aztecSlotDuration, aztecEpochDuration, logger, offenseEpoch }) {
+ */ export async function awaitCommitteeKicked({ rollup, cheatCodes, committee, slashingProposer, slashingRoundSize, aztecSlotDuration, aztecEpochDuration, logger, offenseEpoch }) {
     if (!slashingProposer) {
         throw new Error('No slashing proposer configured. Cannot test slashing.');
     }
     await cheatCodes.debugRollup();
-    if (slashingProposer.type === 'empire') {
-        // Await for the slash payload to be created if empire (no payload is created on tally until execution time)
-        const targetEpoch = EpochNumber(await cheatCodes.getEpoch() + await rollup.getLagInEpochsForValidatorSet() + 1);
-        logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
-        await cheatCodes.advanceToEpoch(targetEpoch);
-        const slashPayloadEvents = await retryUntil(async ()=>{
-            const events = await slashFactory.getSlashPayloadCreatedEvents();
-            return events.length > 0 ? events : undefined;
-        }, 'slash payload created', 120, 1);
-        expect(slashPayloadEvents.length).toBe(1);
-        // The uniqueness check is needed since a validator may be slashed more than once on the same round (eg because they let two epochs be pruned)
-        expect(unique(slashPayloadEvents[0].slashes.map((slash)=>slash.validator.toString()))).toHaveLength(committee.length);
-    } else {
-        // Use the slash offset to ensure we are in the right epoch for tally
-        const slashOffsetInRounds = await slashingProposer.getSlashOffsetInRounds();
-        const slashingRoundSizeInEpochs = slashingRoundSize / aztecEpochDuration;
-        const slashingOffsetInEpochs = Number(slashOffsetInRounds) * slashingRoundSizeInEpochs;
-        const firstEpochInOffenseRound = offenseEpoch - offenseEpoch % slashingRoundSizeInEpochs;
-        const targetEpoch = firstEpochInOffenseRound + slashingOffsetInEpochs;
-        logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
-        await cheatCodes.advanceToEpoch(EpochNumber(targetEpoch), {
-            offset: -aztecSlotDuration / 2
-        });
-    }
+    // Use the slash offset to ensure we are in the right epoch for tally
+    const slashOffsetInRounds = await slashingProposer.getSlashOffsetInRounds();
+    const slashingRoundSizeInEpochs = slashingRoundSize / aztecEpochDuration;
+    const slashingOffsetInEpochs = Number(slashOffsetInRounds) * slashingRoundSizeInEpochs;
+    const firstEpochInOffenseRound = offenseEpoch - offenseEpoch % slashingRoundSizeInEpochs;
+    const targetEpoch = firstEpochInOffenseRound + slashingOffsetInEpochs;
+    logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
+    await cheatCodes.advanceToEpoch(EpochNumber(targetEpoch), {
+        offset: -aztecSlotDuration / 2
+    });
     const attestersPre = await rollup.getAttesters();
     expect(attestersPre.length).toBe(committee.length);
     for (const attester of attestersPre){
         const attesterInfo = await rollup.getAttesterView(attester);
         expect(attesterInfo.status).toEqual(1); // Validating
     }
-    const timeout = slashingRoundSize * 2 * aztecSlotDuration + 30;
+    // Allow up to four round-lengths so that under proposer pipelining, where individual rounds
+    // sometimes fail to gather quorum because parts of the committee miss votes due to chain-state
+    // races, we still see a later round execute the slash.
+    const timeout = slashingRoundSize * 4 * aztecSlotDuration + 30;
     logger.info(`Waiting for slash to be executed (timeout ${timeout}s)`);
     await awaitProposalExecution(slashingProposer, timeout, logger);
     // The attesters should still form the committee but they should be reduced to the "living" status

package/dest/e2e_storage_proof/fixtures/storage_proof_fetcher.d.ts

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

package/dest/e2e_storage_proof/fixtures/storage_proof_fetcher.d.ts.map

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

package/dest/e2e_storage_proof/fixtures/storage_proof_fetcher.js

@@ -0,0 +1,184 @@
+/**
+ * Fetches a ERC20 balance storage proof from the Ethereum mainnet and saves it to a Prover.toml compatible JSON.
+ * The JSON can be converted to toml for use with nargo, or used directly as a JSON file when used in
+ * Aztec contracts. This script is not using any Aztec library code, so it's easily portable.
+ */ import fs from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { createPublicClient, encodeAbiParameters, fromRlp, hexToBytes, http, keccak256 } from 'viem';
+import { mainnet } from 'viem/chains';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const RPC_URL = process.env.RPC_URL;
+const ERC20_CONTRACT = process.env.ERC20_CONTRACT || '0xdAC17F958D2ee523a2206206994597C13D831ec7';
+const HOLDER = process.env.HOLDER || '0x23878914EFE38d27C4D67Ab83ed1b93A74D4086a';
+const SLOT = BigInt(process.env.SLOT || '2');
+const BLOCK_TAG = process.env.BLOCK_NUMBER ? BigInt(process.env.BLOCK_NUMBER) : 'latest';
+const MAX_ACCOUNT_PATH = 15;
+const MAX_STORAGE_PATH = 10;
+function padTo(arr, len) {
+    return [
+        ...arr,
+        ...Array(len - arr.length).fill(0)
+    ].slice(0, len);
+}
+function toBytes(hex) {
+    return Array.from(hexToBytes(hex));
+}
+function bytesToU64s(bytes) {
+    const paddedBytes = padTo(bytes, 32);
+    return Array.from({
+        length: 4
+    }, (_, i)=>{
+        let val = 0n;
+        for(let j = 0; j < 8; j++){
+            val += BigInt(paddedBytes[i * 8 + j]) << BigInt(j * 8);
+        }
+        return val.toString();
+    });
+}
+function toBytesAndLen(val) {
+    if (val === 0n || val === 0) {
+        return {
+            bytes: [
+                0
+            ],
+            length: 0
+        };
+    }
+    let hex = val.toString(16);
+    if (hex.length % 2) {
+        hex = '0' + hex;
+    }
+    const bytes = toBytes(`0x${hex}`);
+    return {
+        bytes,
+        length: bytes.length
+    };
+}
+function parseNode(rlp) {
+    // Should be safe when working with branches and extensions without embedded children.
+    const decoded = fromRlp(rlp);
+    const node = {
+        rows: Array(16).fill(0).map(()=>Array(32).fill(0)),
+        row_exist: Array(16).fill(false),
+        node_type: 0
+    };
+    if (decoded.length === 17) {
+        for(let i = 0; i < 16; i++){
+            if (decoded[i] !== '0x') {
+                node.row_exist[i] = true;
+                node.rows[i] = padTo(toBytes(decoded[i]), 32);
+            }
+        }
+    } else if (decoded.length === 2) {
+        const keyBytes = toBytes(decoded[0]);
+        const prefix = keyBytes[0];
+        if (prefix >> 4 >= 2) {
+            throw new Error('Unsupported: leaf node in proof path');
+        }
+        node.node_type = 1;
+        // Extension header format expected by the noir code: check out storage_proof types.nr.
+        node.rows[0][0] = prefix >> 4;
+        node.rows[0][8] = prefix & 0x0f;
+        node.rows[0][16] = keyBytes.length - 1;
+        for(let i = 1; i < keyBytes.length && i < 32; i++){
+            node.rows[1][i - 1] = keyBytes[i];
+        }
+        node.rows[2] = padTo(toBytes(decoded[1]), 32);
+        node.row_exist[0] = node.row_exist[1] = node.row_exist[2] = true;
+    }
+    return node;
+}
+function parseProof(proof, maxLen) {
+    const nodes = proof.slice(0, -1).slice(0, maxLen).map(parseNode);
+    while(nodes.length < maxLen){
+        nodes.push({
+            rows: Array(16).fill(0).map(()=>Array(32).fill(0)),
+            row_exist: Array(16).fill(false),
+            node_type: 0
+        });
+    }
+    return nodes;
+}
+function nodeToLibFormat(node) {
+    return {
+        rows: node.rows.map(bytesToU64s),
+        row_exist: node.row_exist,
+        node_type: String(node.node_type)
+    };
+}
+async function main() {
+    if (!RPC_URL) {
+        throw new Error('RPC_URL is not set');
+    }
+    const storageKey = keccak256(encodeAbiParameters([
+        {
+            type: 'address'
+        },
+        {
+            type: 'uint256'
+        }
+    ], [
+        HOLDER,
+        SLOT
+    ]));
+    console.log(`Fetching storage proof for ${ERC20_CONTRACT}, holder ${HOLDER}, slot ${SLOT}`);
+    console.log(`Storage key: ${storageKey}`);
+    const client = createPublicClient({
+        chain: mainnet,
+        transport: http(RPC_URL)
+    });
+    const [blockNumber, proof, block] = await Promise.all([
+        client.getBlockNumber(),
+        client.getProof({
+            address: ERC20_CONTRACT,
+            storageKeys: [
+                storageKey
+            ],
+            blockNumber: BLOCK_TAG === 'latest' ? undefined : BLOCK_TAG
+        }),
+        client.getBlock({
+            blockNumber: BLOCK_TAG === 'latest' ? undefined : BLOCK_TAG
+        })
+    ]);
+    const storageProof = proof.storageProof[0];
+    console.log(`Block: ${blockNumber}, Account nodes: ${proof.accountProof.length}, Storage nodes: ${storageProof.proof.length}`);
+    console.log(`Value: ${storageProof.value}`);
+    // The -1 is because the last node in the proof is the leaf, which is excluded from path verification.
+    const accountPathLen = proof.accountProof.length - 1;
+    const storagePathLen = storageProof.proof.length - 1;
+    if (accountPathLen > MAX_ACCOUNT_PATH) {
+        throw new Error(`Account proof path length ${accountPathLen} exceeds MAX_ACCOUNT_PATH ${MAX_ACCOUNT_PATH}. Increase the limit.`);
+    }
+    if (storagePathLen > MAX_STORAGE_PATH) {
+        throw new Error(`Storage proof path length ${storagePathLen} exceeds MAX_STORAGE_PATH ${MAX_STORAGE_PATH}. Increase the limit.`);
+    }
+    const nonce = toBytesAndLen(proof.nonce);
+    const balance = toBytesAndLen(proof.balance);
+    const slotValue = toBytesAndLen(storageProof.value);
+    const data = {
+        account_nodes: parseProof(proof.accountProof, MAX_ACCOUNT_PATH).map(nodeToLibFormat),
+        account_node_length: String(accountPathLen),
+        storage_nodes: parseProof(storageProof.proof, MAX_STORAGE_PATH).map(nodeToLibFormat),
+        storage_node_length: String(storagePathLen),
+        account: {
+            nonce: padTo(nonce.bytes, 8).map(String),
+            nonce_length: String(nonce.length),
+            balance: padTo(balance.bytes, 32).map(String),
+            balance_length: String(balance.length),
+            address: toBytes(ERC20_CONTRACT).map(String),
+            storage_hash: bytesToU64s(toBytes(proof.storageHash)),
+            code_hash: bytesToU64s(toBytes(proof.codeHash))
+        },
+        slot: {
+            value: padTo(slotValue.bytes, 32).map(String),
+            value_length: String(slotValue.length)
+        },
+        slot_key: toBytes(storageKey).map(String),
+        root: bytesToU64s(toBytes(block.stateRoot)),
+        block_number: String(blockNumber)
+    };
+    fs.writeFileSync(join(__dirname, 'storage_proof.json'), JSON.stringify(data, null, 2));
+    console.log('storage_proof.json generated');
+}
+main().catch(console.error);

package/dest/e2e_storage_proof/fixtures/storage_proof_fixture.d.ts

@@ -0,0 +1,18 @@
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Capsule } from '@aztec/stdlib/tx';
+/** Parsed + typed fixture data ready for use as contract function arguments. */
+export type StorageProofArgs = {
+    ethAddress: EthAddress;
+    slotKey: number[];
+    slotContents: {
+        value: number[];
+        value_length: number;
+    };
+    root: bigint[];
+};
+/** Loads the storage proof fixture from disk and returns the contract args. */
+export declare function loadStorageProofArgs(): StorageProofArgs;
+/** Builds all the capsules the StorageProofTest contract expects during private execution. */
+export declare function buildStorageProofCapsules(contractAddress: AztecAddress): Promise<Capsule[]>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZV9wcm9vZl9maXh0dXJlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZTJlX3N0b3JhZ2VfcHJvb2YvZml4dHVyZXMvc3RvcmFnZV9wcm9vZl9maXh0dXJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBRzlELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUMzRCxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUF3RjNDLGdGQUFnRjtBQUNoRixNQUFNLE1BQU0sZ0JBQWdCLEdBQUc7SUFDN0IsVUFBVSxFQUFFLFVBQVUsQ0FBQztJQUN2QixPQUFPLEVBQUUsTUFBTSxFQUFFLENBQUM7SUFDbEIsWUFBWSxFQUFFO1FBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxDQUFDO1FBQUMsWUFBWSxFQUFFLE1BQU0sQ0FBQTtLQUFFLENBQUM7SUFDeEQsSUFBSSxFQUFFLE1BQU0sRUFBRSxDQUFDO0NBQ2hCLENBQUM7QUFFRiwrRUFBK0U7QUFDL0Usd0JBQWdCLG9CQUFvQixJQUFJLGdCQUFnQixDQWF2RDtBQUVELDhGQUE4RjtBQUM5Rix3QkFBc0IseUJBQXlCLENBQUMsZUFBZSxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUMsQ0F1RGpHIn0=

package/dest/e2e_storage_proof/fixtures/storage_proof_fixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage_proof_fixture.d.ts","sourceRoot":"","sources":["../../../src/e2e_storage_proof/fixtures/storage_proof_fixture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAG9D,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAwF3C,gFAAgF;AAChF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,UAAU,CAAC;IACvB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,EAAE;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IACxD,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAEF,+EAA+E;AAC/E,wBAAgB,oBAAoB,IAAI,gBAAgB,CAavD;AAED,8FAA8F;AAC9F,wBAAsB,yBAAyB,CAAC,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAuDjG"}

package/dest/e2e_storage_proof/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;
+}