@aztec/ethereum 0.0.1-commit.4d3c002 → 0.0.1-commit.4d9804df

package/dest/contracts/outbox.js

@@ -1,3 +1,4 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { OutboxAbi } from '@aztec/l1-artifacts/OutboxAbi';
 import { encodeAbiParameters, getContract, hexToBigInt, keccak256 } from 'viem';
@@ -12,11 +13,19 @@ export class OutboxContract {
     }
     static getFromConfig(config) {
         const client = getPublicClient(config);
-        const address = config.l1Contracts.outboxAddress.toString();
+        const address = config.outboxAddress.toString();
         return new OutboxContract(client, address);
     }
-    static getEpochRootStorageSlot(epoch) {
-        return hexToBigInt(keccak256(encodeAbiParameters([
+    /**
+   * Storage slot of `epochs[epoch].roots[numCheckpointsInEpoch - 1]` in the Outbox contract.
+   *
+   * The Outbox lays out storage as `mapping(Epoch => EpochData) internal epochs` at base slot 0
+   * (ROLLUP and VERSION are immutable and do not occupy slots). For a mapping at slot `b`, the
+   * value for key `k` begins at `keccak256(abi.encode(k, b))`. `EpochData` starts with a fixed-
+   * size `bytes32[MAX_CHECKPOINTS_PER_EPOCH] roots` array, so `roots[i]` sits at the EpochData's
+   * base slot plus `i`. `numCheckpointsInEpoch` is 1-indexed (matches `Outbox.insert`/`consume`).
+   */ static getEpochRootStorageSlot(epoch, numCheckpointsInEpoch) {
+        const epochDataSlot = hexToBigInt(keccak256(encodeAbiParameters([
             {
                 type: 'uint256'
             },
@@ -27,6 +36,7 @@ export class OutboxContract {
             BigInt(epoch),
             0n
         ])));
+        return epochDataSlot + BigInt(numCheckpointsInEpoch - 1);
     }
     constructor(client, address){
         this.client = client;
@@ -51,16 +61,32 @@ export class OutboxContract {
             leafId
         ]);
     }
-    getRootData(epoch) {
+    getRootData(epoch, numCheckpointsInEpoch) {
         return this.outbox.read.getRootData([
-            BigInt(epoch)
+            BigInt(epoch),
+            BigInt(numCheckpointsInEpoch)
         ]);
     }
-    consume(message, epoch, leafIndex, path) {
+    /**
+   * Returns every root stored for `epoch`. Slot `i` of the returned array holds the root inserted
+   * for `numCheckpointsInEpoch = i + 1`, or `Fr.ZERO` if no proof of that depth has been inserted
+   * yet. The array length is always `MAX_CHECKPOINTS_PER_EPOCH`.
+   *
+   * @param opts - Optional viem read options. Pass `blockNumber` to pin the read to a specific L1
+   *   block, which is important for callers that want a consistent snapshot across multiple reads
+   *   (e.g. the archiver's outbox-trees resolver, which pins to the node's synced L1 block).
+   */ async getRoots(epoch, opts) {
+        const raw = await this.outbox.read.getRoots([
+            BigInt(epoch)
+        ], opts);
+        return raw.map((hex)=>Fr.fromString(hex));
+    }
+    consume(message, epoch, numCheckpointsInEpoch, leafIndex, path) {
         const wallet = this.assertWallet();
         return wallet.write.consume([
             message,
             BigInt(epoch),
+            BigInt(numCheckpointsInEpoch),
             leafIndex,
             path
         ]);
@@ -74,7 +100,8 @@ export class OutboxContract {
                 epoch: event.args.epoch,
                 root: event.args.root,
                 messageHash: event.args.messageHash,
-                leafId: event.args.leafId
+                leafId: event.args.leafId,
+                numCheckpointsInEpoch: event.args.numCheckpointsInEpoch
             }));
     }
     assertWallet() {