@aztec/txe 0.44.0

package/src/util/txe_public_contract_data_source.ts

@@ -0,0 +1,63 @@
+import { type AztecAddress, Fr, type FunctionSelector, unpackBytecode } from '@aztec/circuits.js';
+import { type ContractArtifact } from '@aztec/foundation/abi';
+import { PrivateFunctionsTree } from '@aztec/pxe';
+import {
+  type ContractClassPublic,
+  type ContractDataSource,
+  type ContractInstanceWithAddress,
+  type PublicFunction,
+} from '@aztec/types/contracts';
+
+import { type TXE } from '../oracle/txe_oracle.js';
+
+export class TXEPublicContractDataSource implements ContractDataSource {
+  constructor(private txeOracle: TXE) {}
+
+  async getPublicFunction(address: AztecAddress, selector: FunctionSelector): Promise<PublicFunction | undefined> {
+    const bytecode = await this.txeOracle.getContractDataOracle().getBytecode(address, selector);
+    if (!bytecode) {
+      return undefined;
+    }
+    return { bytecode, selector };
+  }
+
+  getBlockNumber(): Promise<number> {
+    return this.txeOracle.getBlockNumber();
+  }
+
+  async getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
+    const contractClass = await this.txeOracle.getContractDataOracle().getContractClass(id);
+    const artifact = await this.txeOracle.getContractDataOracle().getContractArtifact(id);
+    const tree = new PrivateFunctionsTree(artifact);
+    const privateFunctionsRoot = tree.getFunctionTreeRoot();
+
+    return {
+      id,
+      artifactHash: contractClass!.artifactHash,
+      packedBytecode: contractClass!.packedBytecode,
+      publicFunctions: unpackBytecode(contractClass!.packedBytecode),
+      privateFunctionsRoot: new Fr(privateFunctionsRoot!.root),
+      version: contractClass!.version,
+      privateFunctions: [],
+      unconstrainedFunctions: [],
+    };
+  }
+
+  async getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+    const instance = await this.txeOracle.getContractDataOracle().getContractInstance(address);
+    return { ...instance, address };
+  }
+
+  getContractClassIds(): Promise<Fr[]> {
+    throw new Error('Method not implemented.');
+  }
+
+  async getContractArtifact(address: AztecAddress): Promise<ContractArtifact | undefined> {
+    const instance = await this.txeOracle.getContractDataOracle().getContractInstance(address);
+    return this.txeOracle.getContractDataOracle().getContractArtifact(instance.contractClassId);
+  }
+
+  addContractArtifact(address: AztecAddress, contract: ContractArtifact): Promise<void> {
+    return this.txeOracle.addContractArtifact(contract);
+  }
+}

package/src/util/txe_public_state_db.ts

@@ -0,0 +1,57 @@
+import { MerkleTreeId } from '@aztec/circuit-types';
+import {
+  type AztecAddress,
+  Fr,
+  PUBLIC_DATA_SUBTREE_HEIGHT,
+  PublicDataTreeLeaf,
+  type PublicDataTreeLeafPreimage,
+} from '@aztec/circuits.js';
+import { computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash';
+import { type PublicStateDB } from '@aztec/simulator';
+
+import { type TXE } from '../oracle/txe_oracle.js';
+
+export class TXEPublicStateDB implements PublicStateDB {
+  constructor(private txeOracle: TXE) {}
+
+  async storageRead(contract: AztecAddress, slot: Fr): Promise<Fr> {
+    const db = this.txeOracle.getTrees().asLatest();
+    const leafSlot = computePublicDataTreeLeafSlot(contract, slot).toBigInt();
+
+    const lowLeafResult = await db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+
+    let value = Fr.ZERO;
+    if (lowLeafResult && lowLeafResult.alreadyPresent) {
+      const preimage = (await db.getLeafPreimage(
+        MerkleTreeId.PUBLIC_DATA_TREE,
+        lowLeafResult.index,
+      )) as PublicDataTreeLeafPreimage;
+      value = preimage.value;
+    }
+    return value;
+  }
+
+  async storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<bigint> {
+    const db = this.txeOracle.getTrees().asLatest();
+
+    await db.batchInsert(
+      MerkleTreeId.PUBLIC_DATA_TREE,
+      [new PublicDataTreeLeaf(computePublicDataTreeLeafSlot(contract, slot), newValue).toBuffer()],
+      PUBLIC_DATA_SUBTREE_HEIGHT,
+    );
+    return newValue.toBigInt();
+  }
+
+  checkpoint(): Promise<void> {
+    return Promise.resolve();
+  }
+  rollbackToCheckpoint(): Promise<void> {
+    throw new Error('Cannot rollback');
+  }
+  commit(): Promise<void> {
+    return Promise.resolve();
+  }
+  rollbackToCommit(): Promise<void> {
+    throw new Error('Cannot rollback');
+  }
+}