@aztec/txe 0.0.0-test.0

package/src/util/encoding.ts

@@ -0,0 +1,92 @@
+import { Fr } from '@aztec/foundation/fields';
+import { hexToBuffer } from '@aztec/foundation/string';
+import { type ContractArtifact, ContractArtifactSchema } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type ContractInstanceWithAddress, ContractInstanceWithAddressSchema } from '@aztec/stdlib/contract';
+
+import { z } from 'zod';
+
+export type ForeignCallSingle = string;
+
+export type ForeignCallArray = string[];
+
+export type ForeignCallArgs = (ForeignCallSingle | ForeignCallArray | ContractArtifact | ContractInstanceWithAddress)[];
+
+export type ForeignCallResult = {
+  values: (ForeignCallSingle | ForeignCallArray)[];
+};
+
+export function fromSingle(obj: ForeignCallSingle) {
+  return Fr.fromBuffer(Buffer.from(obj, 'hex'));
+}
+
+export function addressFromSingle(obj: ForeignCallSingle) {
+  return new AztecAddress(fromSingle(obj));
+}
+
+export function fromArray(obj: ForeignCallArray) {
+  return obj.map(str => Fr.fromBuffer(hexToBuffer(str)));
+}
+
+/**
+ * Converts an array of Noir unsigned integers to a single tightly-packed buffer.
+ * @param uintBitSize If it's an array of Noir u8's, put `8`, etc.
+ * @returns
+ */
+export function fromUintArray(obj: ForeignCallArray, uintBitSize: number): Buffer {
+  if (uintBitSize % 8 !== 0) {
+    throw new Error(`u${uintBitSize} is not a supported type in Noir`);
+  }
+  const uintByteSize = uintBitSize / 8;
+  return Buffer.concat(obj.map(str => hexToBuffer(str).slice(-uintByteSize)));
+}
+
+export function toSingle(obj: Fr | AztecAddress): ForeignCallSingle {
+  return obj.toString().slice(2);
+}
+
+export function toArray(objs: Fr[]): ForeignCallArray {
+  return objs.map(obj => obj.toString());
+}
+
+export function bufferToU8Array(buffer: Buffer): ForeignCallArray {
+  return toArray(Array.from(buffer).map(byte => new Fr(byte)));
+}
+
+/**
+ * Converts a ForeignCallArray into a tuple which represents a nr BoundedVec.
+ * If the input array is shorter than the maxLen, it pads the result with zeros,
+ * so that nr can correctly coerce this result into a BoundedVec.
+ * @param array
+ * @param maxLen - the max length of the BoundedVec.
+ * @returns a tuple representing a BoundedVec.
+ */
+export function arrayToBoundedVec(array: ForeignCallArray, maxLen: number): [ForeignCallArray, ForeignCallSingle] {
+  if (array.length > maxLen) {
+    throw new Error(`Array of length ${array.length} larger than maxLen ${maxLen}`);
+  }
+  const lengthDiff = maxLen - array.length;
+  // We pad the array to the maxLen of the BoundedVec.
+  const zeroPaddingArray = toArray(Array(lengthDiff).fill(new Fr(0)));
+
+  // These variable names match with the BoundedVec members in nr:
+  const storage = array.concat(zeroPaddingArray);
+  const len = toSingle(new Fr(array.length));
+  return [storage, len];
+}
+
+export function toForeignCallResult(obj: (ForeignCallSingle | ForeignCallArray)[]) {
+  return { values: obj };
+}
+
+export const ForeignCallSingleSchema = z.string();
+
+export const ForeignCallArraySchema = z.array(z.string());
+
+export const ForeignCallArgsSchema = z.array(
+  z.union([ForeignCallSingleSchema, ForeignCallArraySchema, ContractArtifactSchema, ContractInstanceWithAddressSchema]),
+);
+
+export const ForeignCallResultSchema = z.object({
+  values: z.array(z.union([ForeignCallSingleSchema, ForeignCallArraySchema])),
+});

package/src/util/expected_failure_error.ts

@@ -0,0 +1,5 @@
+export class ExpectedFailureError extends Error {
+  constructor(message: string) {
+    super(message);
+  }
+}

package/src/util/txe_account_data_provider.ts

@@ -0,0 +1,23 @@
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { CompleteAddress } from '@aztec/stdlib/contract';
+
+export class TXEAccountDataProvider {
+  #accounts: AztecAsyncMap<string, Buffer>;
+
+  constructor(store: AztecAsyncKVStore) {
+    this.#accounts = store.openMap('accounts');
+  }
+
+  async getAccount(key: AztecAddress) {
+    const completeAddress = await this.#accounts.getAsync(key.toString());
+    if (!completeAddress) {
+      throw new Error(`Account not found: ${key.toString()}`);
+    }
+    return CompleteAddress.fromBuffer(completeAddress);
+  }
+
+  async setAccount(key: AztecAddress, value: CompleteAddress) {
+    await this.#accounts.set(key.toString(), value.toBuffer());
+  }
+}

package/src/util/txe_public_contract_data_source.ts

@@ -0,0 +1,101 @@
+import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { PrivateFunctionsTree } from '@aztec/pxe/server';
+import { type ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import {
+  type ContractClassPublic,
+  type ContractDataSource,
+  type ContractInstanceWithAddress,
+  type PublicFunction,
+  computePublicBytecodeCommitment,
+} from '@aztec/stdlib/contract';
+
+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.getContractDataProvider().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.getContractDataProvider().getContractClass(id);
+    const artifact = await this.txeOracle.getContractDataProvider().getContractArtifact(id);
+    const tree = await PrivateFunctionsTree.create(artifact);
+    const privateFunctionsRoot = await tree.getFunctionTreeRoot();
+
+    const publicFunctions: PublicFunction[] = [];
+    if (contractClass!.packedBytecode.length > 0) {
+      publicFunctions.push({
+        selector: FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
+        bytecode: contractClass!.packedBytecode,
+      });
+    }
+
+    return {
+      id,
+      artifactHash: contractClass!.artifactHash,
+      packedBytecode: contractClass!.packedBytecode,
+      publicFunctions: publicFunctions,
+      privateFunctionsRoot: new Fr(privateFunctionsRoot!.root),
+      version: contractClass!.version,
+      privateFunctions: [],
+      unconstrainedFunctions: [],
+    };
+  }
+
+  async getBytecodeCommitment(id: Fr): Promise<Fr | undefined> {
+    const contractClass = await this.txeOracle.getContractDataProvider().getContractClass(id);
+    return computePublicBytecodeCommitment(contractClass.packedBytecode);
+  }
+
+  async getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+    const instance = await this.txeOracle.getContractDataProvider().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.getContractDataProvider().getContractInstance(address);
+    return this.txeOracle.getContractDataProvider().getContractArtifact(instance.currentContractClassId);
+  }
+
+  async getContractFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
+    const artifact = await this.getContractArtifact(address);
+    if (!artifact) {
+      return undefined;
+    }
+    const functionSelectorsAndNames = await Promise.all(
+      artifact.functions.map(async f => ({
+        name: f.name,
+        selector: await FunctionSelector.fromNameAndParameters({ name: f.name, parameters: f.parameters }),
+      })),
+    );
+    const func = functionSelectorsAndNames.find(f => f.selector.equals(selector));
+
+    return Promise.resolve(func?.name);
+  }
+
+  registerContractFunctionSignatures(_address: AztecAddress, _signatures: []): Promise<void> {
+    return Promise.resolve();
+  }
+
+  // TODO(#10007): Remove this method.
+  addContractClass(_contractClass: ContractClassPublic): Promise<void> {
+    // We don't really need to do anything for the txe here
+    return Promise.resolve();
+  }
+}

package/src/util/txe_world_state_db.ts

@@ -0,0 +1,38 @@
+import { Fr } from '@aztec/foundation/fields';
+import { WorldStateDB } from '@aztec/simulator/server';
+import { PublicDataWrite } from '@aztec/stdlib/avm';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId, type PublicDataTreeLeafPreimage } from '@aztec/stdlib/trees';
+
+import type { TXE } from '../oracle/txe_oracle.js';
+
+export class TXEWorldStateDB extends WorldStateDB {
+  constructor(private merkleDb: MerkleTreeWriteOperations, dataSource: ContractDataSource, private txe: TXE) {
+    super(merkleDb, dataSource);
+  }
+
+  override async storageRead(contract: AztecAddress, slot: Fr): Promise<Fr> {
+    const leafSlot = (await computePublicDataTreeLeafSlot(contract, slot)).toBigInt();
+
+    const lowLeafResult = await this.merkleDb.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+
+    let value = Fr.ZERO;
+    if (lowLeafResult && lowLeafResult.alreadyPresent) {
+      const preimage = (await this.merkleDb.getLeafPreimage(
+        MerkleTreeId.PUBLIC_DATA_TREE,
+        lowLeafResult.index,
+      )) as PublicDataTreeLeafPreimage;
+      value = preimage.value;
+    }
+    return value;
+  }
+
+  override async storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void> {
+    await this.txe.addPublicDataWrites([
+      new PublicDataWrite(await computePublicDataTreeLeafSlot(contract, slot), newValue),
+    ]);
+  }
+}