@aztec/pxe 5.0.0-rc.1 → 5.0.0

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/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;
-    });
-  }
-}