@aztec/pxe 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/src/contract_function_simulator/proxied_contract_data_source.ts

@@ -1,60 +0,0 @@
-import { type FunctionSelector, findFunctionArtifactBySelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractOverrides } from '@aztec/stdlib/tx';
-
-import type { ContractStore } from '../storage/contract_store/contract_store.js';
-
-/*
- * Proxy generator for a ContractStore that allows overriding contract instances at given addresses,
- * so the contract function simulator can execute different bytecode on certain addresses. An example
- * use case would be overriding your own account contract so that valid signatures don't have to be
- * provided while simulating.
- *
- * Function artifact lookups for an overridden address are routed via the override-instance's
- * `currentContractClassId` rather than the underlying ContractStore's address→class mapping —
- * `ContractStore.getFunctionArtifact` calls `this.getContractInstance` internally, which the proxy
- * cannot intercept (the binding sees the raw target, not the proxy). The target class must be
- * registered ahead of time via `pxe.registerContractClass(...)`.
- */
-export class ProxiedContractStoreFactory {
-  static create(contractStore: ContractStore, overrides?: ContractOverrides) {
-    if (!overrides) {
-      return contractStore;
-    }
-
-    return new Proxy(contractStore, {
-      get(target, prop: keyof ContractStore) {
-        if (prop === 'getContractInstance') {
-          return (address: AztecAddress) => {
-            const override = overrides[address.toString()];
-            return override ? Promise.resolve(override.instance) : target.getContractInstance(address);
-          };
-        }
-        if (prop === 'getFunctionArtifact' || prop === 'getFunctionArtifactWithDebugMetadata') {
-          return async (contractAddress: AztecAddress, selector: FunctionSelector) => {
-            const override = overrides[contractAddress.toString()];
-            if (!override) {
-              return (target[prop] as Function).call(target, contractAddress, selector);
-            }
-            const artifact = await target.getContractArtifact(override.instance.currentContractClassId);
-            if (!artifact) {
-              throw new Error(
-                `No artifact registered for override class ${override.instance.currentContractClassId} ` +
-                  `at ${contractAddress}. Register it via pxe.registerContractClass(...) before simulating.`,
-              );
-            }
-            const fn = await findFunctionArtifactBySelector(artifact, selector);
-            if (!fn) {
-              throw new Error(
-                `Function with selector ${selector} not found in stub artifact for overridden contract at ${contractAddress}.`,
-              );
-            }
-            return { ...fn, contractName: artifact.name };
-          };
-        }
-        const value = Reflect.get(target, prop);
-        return typeof value === 'function' ? value.bind(target) : value;
-      },
-    }) satisfies ContractStore;
-  }
-}

package/src/contract_sync/helpers.ts

@@ -1,86 +0,0 @@
-import { ProtocolContractAddress, isProtocolContract } from '@aztec/protocol-contracts';
-import type { FunctionCall, FunctionSelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractInstance } from '@aztec/stdlib/contract';
-import { DelayedPublicMutableValues, DelayedPublicMutableValuesWithHash } from '@aztec/stdlib/delayed-public-mutable';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { BlockHeader } from '@aztec/stdlib/tx';
-
-import type { ContractStore } from '../storage/contract_store/contract_store.js';
-
-/**
- * Read the current class id of a contract from the execution data provider or AztecNode. If not found, class id
- * from the instance is used.
- * @param contractAddress - The address of the contract to read the class id for.
- * @param instance - The instance of the contract.
- * @param aztecNode - The Aztec node to query for storage.
- * @param header - The header of the block at which to load the DelayedPublicMutable storing the class id.
- * @returns The current class id.
- */
-export async function readCurrentClassId(
-  contractAddress: AztecAddress,
-  instance: ContractInstance,
-  aztecNode: AztecNode,
-  header: BlockHeader,
-) {
-  const blockHash = await header.hash();
-  const timestamp = header.globalVariables.timestamp;
-  const { delayedPublicMutableSlot } = await DelayedPublicMutableValuesWithHash.getContractUpdateSlots(contractAddress);
-  const delayedPublicMutableValues = await DelayedPublicMutableValues.readFromTree(delayedPublicMutableSlot, slot =>
-    aztecNode.getPublicStorageAt(blockHash, ProtocolContractAddress.ContractInstanceRegistry, slot),
-  );
-  let currentClassId = delayedPublicMutableValues.svc.getCurrentAt(timestamp)[0];
-  if (currentClassId.isZero()) {
-    currentClassId = instance.originalContractClassId;
-  }
-  return currentClassId;
-}
-
-export async function syncScope(
-  contractAddress: AztecAddress,
-  contractStore: ContractStore,
-  functionToInvokeAfterSync: FunctionSelector | null,
-  utilityExecutor: (privateSyncCall: FunctionCall, scopes: AztecAddress[]) => Promise<any>,
-  scope: AztecAddress,
-) {
-  // Protocol contracts don't have private state to sync
-  if (isProtocolContract(contractAddress)) {
-    return;
-  }
-
-  const syncStateFunctionCall = await contractStore.getFunctionCall('sync_state', [scope], contractAddress);
-  if (functionToInvokeAfterSync && functionToInvokeAfterSync.equals(syncStateFunctionCall.selector)) {
-    throw new Error(
-      'Forbidden `sync_state` invocation. `sync_state` can only be invoked by PXE, manual execution can lead to inconsistencies.',
-    );
-  }
-
-  await utilityExecutor(syncStateFunctionCall, [scope]);
-}
-
-/**
- * Verify that the current class id of a contract obtained from AztecNode is the same as the one in contract data
- * provider (i.e. PXE's own storage).
- * @param contractAddress - The address of the contract to verify.
- * @param aztecNode - The Aztec node to query for storage.
- * @param contractStore - The contract store to fetch the local instance from.
- * @param header - The header of the block at which to verify the current class id.
- */
-export async function verifyCurrentClassId(
-  contractAddress: AztecAddress,
-  aztecNode: AztecNode,
-  contractStore: ContractStore,
-  header: BlockHeader,
-) {
-  const instance = await contractStore.getContractInstance(contractAddress);
-  if (!instance) {
-    throw new Error(`No contract instance found for address ${contractAddress.toString()}`);
-  }
-
-  const currentClassId = await readCurrentClassId(contractAddress, instance, aztecNode, header);
-  if (!instance.currentContractClassId.equals(currentClassId)) {
-    throw new Error(
-      `Contract ${contractAddress} is outdated, current class id is ${currentClassId}, local class id is ${instance.currentContractClassId}`,
-    );
-  }
-}

package/src/messages/message_context_service.ts

@@ -1,45 +0,0 @@
-import { uniqueBy } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import type { AztecNode } from '@aztec/stdlib/interfaces/server';
-import { MessageContext } from '@aztec/stdlib/logs';
-import { type IndexedTxEffect, TxHash } from '@aztec/stdlib/tx';
-
-/** Resolves transaction hashes into the context needed to process messages. */
-export class MessageContextService {
-  constructor(private readonly aztecNode: AztecNode) {}
-
-  /**
-   * Resolves a list of tx hashes into their message contexts.
-   *
-   * For each tx hash, looks up the corresponding tx effect and extracts the note hashes and first nullifier needed to
-   * process messages that originated from that transaction. Returns `null` for tx hashes that are zero, not yet
-   * available, or in blocks beyond the anchor block.
-   */
-  async getMessageContextsByTxHash(txHashes: Fr[], anchorBlockNumber: number): Promise<(MessageContext | null)[]> {
-    const nonZeroTxHashes = txHashes.filter(h => !h.isZero()).map(h => TxHash.fromField(h));
-    const uniqueTxHashes = uniqueBy(nonZeroTxHashes, h => h.toString());
-    const fetched = await Promise.all(uniqueTxHashes.map(h => this.aztecNode.getTxEffect(h)));
-    const txEffects = new Map(
-      uniqueTxHashes
-        .map((h, i): [string, IndexedTxEffect | undefined] => [h.toString(), fetched[i]])
-        .filter((entry): entry is [string, IndexedTxEffect] => entry[1] !== undefined),
-    );
-
-    return txHashes.map(txHashField => {
-      const txHash = TxHash.fromField(txHashField);
-      const txEffect = txEffects.get(txHash.toString());
-      if (!txEffect || txEffect.l2BlockNumber > anchorBlockNumber) {
-        return null;
-      }
-
-      // Every tx has at least one nullifier (the first nullifier derived from the tx hash). Hitting this condition
-      // would mean a buggy node, but since we need to access data.nullifiers[0], the defensive check does no harm.
-      const data = txEffect.data;
-      if (data.nullifiers.length === 0) {
-        throw new Error(`Tx effect for ${txHash} has no nullifiers`);
-      }
-
-      return new MessageContext(data.txHash, data.noteHashes, data.nullifiers[0]);
-    });
-  }
-}

package/src/storage/backwards_compatibility_tests/__snapshots__/SenderAddressBookStore.json

@@ -1,16 +0,0 @@
-{
-  "address_book": [
-    {
-      "key": "utf8:0x0000000000000000000000000000000000000000000000000000000000000002",
-      "value": "true"
-    },
-    {
-      "key": "utf8:0x0000000000000000000000000000000000000000000000000000000000000003",
-      "value": "true"
-    },
-    {
-      "key": "utf8:0x0000000000000000000000000000000000000000000000000000000000000005",
-      "value": "true"
-    }
-  ]
-}

package/src/storage/tagging_store/sender_address_book_store.ts

@@ -1,48 +0,0 @@
-import { toArray } from '@aztec/foundation/iterable';
-import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-
-/**
- * Stores sender addresses. During recipient log synchronization, these senders are used, along with a given recipient,
- * to derive directional app tagging secrets that are then used to sync the logs.
- */
-export class SenderAddressBookStore {
-  #store: AztecAsyncKVStore;
-  #addressBook: AztecAsyncMap<string, true>;
-
-  constructor(store: AztecAsyncKVStore) {
-    this.#store = store;
-
-    this.#addressBook = this.#store.openMap('address_book');
-  }
-
-  addSender(address: AztecAddress): Promise<boolean> {
-    return this.#store.transactionAsync(async () => {
-      if (await this.#addressBook.hasAsync(address.toString())) {
-        return false;
-      }
-
-      await this.#addressBook.set(address.toString(), true);
-
-      return true;
-    });
-  }
-
-  getSenders(): Promise<AztecAddress[]> {
-    return this.#store.transactionAsync(async () => {
-      return (await toArray(this.#addressBook.keysAsync())).map(AztecAddress.fromString);
-    });
-  }
-
-  removeSender(address: AztecAddress): Promise<boolean> {
-    return this.#store.transactionAsync(async () => {
-      if (!(await this.#addressBook.hasAsync(address.toString()))) {
-        return false;
-      }
-
-      await this.#addressBook.delete(address.toString());
-
-      return true;
-    });
-  }
-}

package/src/tagging/sender_sync/utils/get_status_change_of_pending.ts

@@ -1,66 +0,0 @@
-import type { AztecNode } from '@aztec/stdlib/interfaces/server';
-import { TxHash, TxStatus } from '@aztec/stdlib/tx';
-
-/** Classification of a batch of pending tx hashes by the status change implied by their receipts. */
-export type StatusChange = {
-  txHashesToFinalize: TxHash[];
-  txHashesToDrop: TxHash[];
-  txHashesWithExecutionReverted: TxHash[];
-};
-
-export const EMPTY_STATUS_CHANGE: StatusChange = {
-  txHashesToFinalize: [],
-  txHashesToDrop: [],
-  txHashesWithExecutionReverted: [],
-};
-
-/** Concatenates two status changes field-by-field. */
-export function mergeStatusChanges(a: StatusChange, b: StatusChange): StatusChange {
-  return {
-    txHashesToFinalize: [...a.txHashesToFinalize, ...b.txHashesToFinalize],
-    txHashesToDrop: [...a.txHashesToDrop, ...b.txHashesToDrop],
-    txHashesWithExecutionReverted: [...a.txHashesWithExecutionReverted, ...b.txHashesWithExecutionReverted],
-  };
-}
-
-/**
- * Based on receipts obtained from `aztecNode` returns which pending transactions changed their status to finalized,
- * dropped, or execution-reverted (but mined).
- */
-export async function getStatusChangeOfPending(pending: TxHash[], aztecNode: AztecNode): Promise<StatusChange> {
-  // Get receipts for all pending tx hashes.
-  const receipts = await Promise.all(pending.map(pendingTxHash => aztecNode.getTxReceipt(pendingTxHash)));
-
-  const txHashesToFinalize: TxHash[] = [];
-  const txHashesToDrop: TxHash[] = [];
-  const txHashesWithExecutionReverted: TxHash[] = [];
-
-  for (let i = 0; i < receipts.length; i++) {
-    const receipt = receipts[i];
-    const txHash = pending[i];
-
-    if (receipt.status === TxStatus.FINALIZED) {
-      // Tx has been included in a block and the corresponding block is finalized
-      if (receipt.hasExecutionSucceeded()) {
-        // No part of execution reverted - we just finalize all the indexes.
-        txHashesToFinalize.push(txHash);
-      } else if (receipt.hasExecutionReverted()) {
-        // Tx was mined but execution reverted (app logic, teardown, or both). Some logs from the non-revertible
-        // phase may still be onchain. We check which tags made it onchain and finalize those; drop the rest.
-        txHashesWithExecutionReverted.push(txHash);
-      } else {
-        // Defensive check - this branch should never be triggered
-        throw new Error(
-          'Both hasExecutionSucceeded and hasExecutionReverted on the receipt returned false. This should never happen and it implies a bug. Please open an issue.',
-        );
-      }
-    } else if (receipt.isDropped()) {
-      // Tx was dropped from the mempool --> we drop the corresponding pending indexes.
-      txHashesToDrop.push(txHash);
-    } else {
-      // Tx is still pending, not yet finalized, or was mined successfully but not yet finalized --> we don't do anything.
-    }
-  }
-
-  return { txHashesToFinalize, txHashesToDrop, txHashesWithExecutionReverted };
-}