@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.b655e406

package/src/tx/content_commitment.ts

@@ -1,45 +1,31 @@
-import { CONTENT_COMMITMENT_LENGTH } from '@aztec/constants';
+import type { ViemContentCommitment } from '@aztec/ethereum';
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
-export const NUM_BYTES_PER_SHA256 = 32;
-
 export class ContentCommitment {
-  constructor(public numTxs: Fr, public blobsHash: Buffer, public inHash: Buffer, public outHash: Buffer) {
-    // NB: we do not calculate blobHash in the circuit, but we still truncate it so it fits in a field
-    if (blobsHash.length !== NUM_BYTES_PER_SHA256) {
-      throw new Error(`blobsHash buffer must be ${NUM_BYTES_PER_SHA256} bytes`);
-    }
-    if (blobsHash[0] !== 0) {
-      throw new Error(`blobsHash buffer should be truncated and left padded`);
-    }
-    if (inHash.length !== NUM_BYTES_PER_SHA256) {
-      throw new Error(`inHash buffer must be ${NUM_BYTES_PER_SHA256} bytes`);
-    }
-    if (inHash[0] !== 0) {
-      throw new Error(`inHash buffer should be truncated and left padded`);
-    }
-    if (outHash.length !== NUM_BYTES_PER_SHA256) {
-      throw new Error(`outHash buffer must be ${NUM_BYTES_PER_SHA256} bytes`);
-    }
-    if (outHash[0] !== 0) {
-      throw new Error(`outHash buffer should be truncated and left padded`);
-    }
-  }
+  constructor(
+    public blobsHash: Fr,
+    public inHash: Fr,
+    public outHash: Fr,
+  ) {}
 
   static get schema() {
     return z
       .object({
-        numTxs: schemas.Fr,
-        blobsHash: schemas.Buffer,
-        inHash: schemas.Buffer,
-        outHash: schemas.Buffer,
+        blobsHash: schemas.Fr,
+        inHash: schemas.Fr,
+        outHash: schemas.Fr,
       })
-      .transform(({ numTxs, blobsHash, inHash, outHash }) => new ContentCommitment(numTxs, blobsHash, inHash, outHash));
+      .transform(({ blobsHash, inHash, outHash }) => new ContentCommitment(blobsHash, inHash, outHash));
+  }
+
+  static getFields(fields: FieldsOf<ContentCommitment>) {
+    return [fields.blobsHash, fields.inHash, fields.outHash] as const;
   }
 
   getSize() {
@@ -47,70 +33,58 @@ export class ContentCommitment {
   }
 
   toBuffer() {
-    return serializeToBuffer(this.numTxs, this.blobsHash, this.inHash, this.outHash);
+    return serializeToBuffer(...ContentCommitment.getFields(this));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): ContentCommitment {
+    const reader = BufferReader.asReader(buffer);
+
+    return new ContentCommitment(reader.readObject(Fr), reader.readObject(Fr), reader.readObject(Fr));
   }
 
   toInspect() {
     return {
-      numTxs: this.numTxs.toNumber(),
-      blobsHash: bufferToHex(this.blobsHash),
-      inHash: bufferToHex(this.inHash),
-      outHash: bufferToHex(this.outHash),
+      blobsHash: this.blobsHash.toString(),
+      inHash: this.inHash.toString(),
+      outHash: this.outHash.toString(),
     };
   }
 
-  toFields(): Fr[] {
-    const serialized = [
-      this.numTxs,
-      Fr.fromBuffer(this.blobsHash),
-      Fr.fromBuffer(this.inHash),
-      Fr.fromBuffer(this.outHash),
-    ];
-    if (serialized.length !== CONTENT_COMMITMENT_LENGTH) {
-      throw new Error(
-        `Expected content commitment to have ${CONTENT_COMMITMENT_LENGTH} fields, but it has ${serialized.length} fields`,
-      );
-    }
-    return serialized;
+  toViem(): ViemContentCommitment {
+    return {
+      blobsHash: this.blobsHash.toString(),
+      inHash: this.inHash.toString(),
+      outHash: this.outHash.toString(),
+    };
   }
 
-  static fromBuffer(buffer: Buffer | BufferReader): ContentCommitment {
-    const reader = BufferReader.asReader(buffer);
-
+  static fromViem(contentCommitment: ViemContentCommitment) {
     return new ContentCommitment(
-      reader.readObject(Fr),
-      reader.readBytes(NUM_BYTES_PER_SHA256),
-      reader.readBytes(NUM_BYTES_PER_SHA256),
-      reader.readBytes(NUM_BYTES_PER_SHA256),
+      Fr.fromString(contentCommitment.blobsHash),
+      Fr.fromString(contentCommitment.inHash),
+      Fr.fromString(contentCommitment.outHash),
     );
   }
 
+  toFields(): Fr[] {
+    return serializeToFields(...ContentCommitment.getFields(this));
+  }
+
   static fromFields(fields: Fr[] | FieldReader): ContentCommitment {
     const reader = FieldReader.asReader(fields);
-    return new ContentCommitment(
-      reader.readField(),
-      reader.readField().toBuffer(),
-      reader.readField().toBuffer(),
-      reader.readField().toBuffer(),
-    );
+    return new ContentCommitment(reader.readField(), reader.readField(), reader.readField());
+  }
+
+  static random(): ContentCommitment {
+    return new ContentCommitment(Fr.random(), Fr.random(), Fr.random());
   }
 
   static empty(): ContentCommitment {
-    return new ContentCommitment(
-      Fr.zero(),
-      Buffer.alloc(NUM_BYTES_PER_SHA256),
-      Buffer.alloc(NUM_BYTES_PER_SHA256),
-      Buffer.alloc(NUM_BYTES_PER_SHA256),
-    );
+    return new ContentCommitment(Fr.zero(), Fr.zero(), Fr.zero());
   }
 
   isEmpty(): boolean {
-    return (
-      this.numTxs.isZero() &&
-      this.blobsHash.equals(Buffer.alloc(NUM_BYTES_PER_SHA256)) &&
-      this.inHash.equals(Buffer.alloc(NUM_BYTES_PER_SHA256)) &&
-      this.outHash.equals(Buffer.alloc(NUM_BYTES_PER_SHA256))
-    );
+    return this.blobsHash.isZero() && this.inHash.isZero() && this.outHash.isZero();
   }
 
   public toString(): string {
@@ -124,10 +98,7 @@ export class ContentCommitment {
 
   public equals(other: this): boolean {
     return (
-      this.inHash.equals(other.inHash) &&
-      this.outHash.equals(other.outHash) &&
-      this.numTxs.equals(other.numTxs) &&
-      this.blobsHash.equals(other.blobsHash)
+      this.blobsHash.equals(other.blobsHash) && this.inHash.equals(other.inHash) && this.outHash.equals(other.outHash)
     );
   }
 }

package/src/tx/global_variable_builder.ts

@@ -1,8 +1,8 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fr } from '@aztec/foundation/fields';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 import type { GasFees } from '../gas/gas_fees.js';
+import type { UInt32 } from '../types/index.js';
 import type { GlobalVariables } from './global_variables.js';
 
 /**
@@ -20,7 +20,7 @@ export interface GlobalVariableBuilder {
    * @returns A promise that resolves to the GlobalVariables for the given block number.
    */
   buildGlobalVariables(
-    blockNumber: Fr,
+    blockNumber: UInt32,
     coinbase: EthAddress,
     feeRecipient: AztecAddress,
     slotNumber?: bigint,

package/src/tx/global_variables.ts

@@ -2,7 +2,13 @@ import { GLOBAL_VARIABLES_LENGTH } from '@aztec/constants';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
-import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import {
+  BufferReader,
+  FieldReader,
+  bigintToUInt64BE,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
@@ -11,6 +17,7 @@ import { z } from 'zod';
 import { AztecAddress } from '../aztec-address/index.js';
 import { GasFees } from '../gas/gas_fees.js';
 import { schemas } from '../schemas/index.js';
+import type { UInt32, UInt64 } from '../types/index.js';
 
 /**
  * Global variables of the L2 block.
@@ -22,11 +29,11 @@ export class GlobalVariables {
     /** Version for the L2 block. */
     public version: Fr,
     /** Block number of the L2 block. */
-    public blockNumber: Fr,
+    public blockNumber: UInt32,
     /** Slot number of the L2 block */
     public slotNumber: Fr,
     /** Timestamp of the L2 block. */
-    public timestamp: Fr,
+    public timestamp: UInt64,
     /** Recipient of block reward. */
     public coinbase: EthAddress,
     /** Address to receive fees. */
@@ -40,9 +47,9 @@ export class GlobalVariables {
       .object({
         chainId: schemas.Fr,
         version: schemas.Fr,
-        blockNumber: schemas.Fr,
+        blockNumber: schemas.UInt32,
         slotNumber: schemas.Fr,
-        timestamp: schemas.Fr,
+        timestamp: schemas.BigInt,
         coinbase: schemas.EthAddress,
         feeRecipient: schemas.AztecAddress,
         gasFees: GasFees.schema,
@@ -60,9 +67,9 @@ export class GlobalVariables {
 
   static empty(fields: Partial<FieldsOf<GlobalVariables>> = {}): GlobalVariables {
     return GlobalVariables.from({
-      blockNumber: Fr.ZERO,
+      blockNumber: 0,
       slotNumber: Fr.ZERO,
-      timestamp: Fr.ZERO,
+      timestamp: 0n,
       chainId: Fr.ZERO,
       version: Fr.ZERO,
       coinbase: EthAddress.ZERO,
@@ -77,9 +84,9 @@ export class GlobalVariables {
     return new GlobalVariables(
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
+      reader.readNumber(),
       Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
+      reader.readUInt64(),
       reader.readObject(EthAddress),
       reader.readObject(AztecAddress),
       reader.readObject(GasFees),
@@ -92,9 +99,9 @@ export class GlobalVariables {
     return new GlobalVariables(
       reader.readField(),
       reader.readField(),
+      reader.readU32(),
       reader.readField(),
-      reader.readField(),
-      reader.readField(),
+      reader.readField().toBigInt(),
       EthAddress.fromField(reader.readField()),
       AztecAddress.fromField(reader.readField()),
       GasFees.fromFields(reader),
@@ -102,7 +109,6 @@ export class GlobalVariables {
   }
 
   static getFields(fields: FieldsOf<GlobalVariables>) {
-    // Note: The order here must match the order in the HeaderLib solidity library.
     return [
       fields.chainId,
       fields.version,
@@ -116,7 +122,16 @@ export class GlobalVariables {
   }
 
   toBuffer() {
-    return serializeToBuffer(...GlobalVariables.getFields(this));
+    return serializeToBuffer([
+      this.chainId,
+      this.version,
+      this.blockNumber,
+      this.slotNumber,
+      bigintToUInt64BE(this.timestamp),
+      this.coinbase,
+      this.feeRecipient,
+      this.gasFees,
+    ]);
   }
 
   toFields() {
@@ -135,7 +150,7 @@ export class GlobalVariables {
    */
   toFriendlyJSON() {
     return {
-      blockNumber: this.blockNumber.toNumber(),
+      blockNumber: this.blockNumber,
       slotNumber: this.slotNumber.toNumber(),
       timestamp: this.timestamp.toString(),
       coinbase: this.coinbase.toString(),
@@ -151,9 +166,9 @@ export class GlobalVariables {
     return (
       this.chainId.isZero() &&
       this.version.isZero() &&
-      this.blockNumber.isZero() &&
+      this.blockNumber === 0 &&
       this.slotNumber.isZero() &&
-      this.timestamp.isZero() &&
+      this.timestamp === 0n &&
       this.coinbase.isZero() &&
       this.feeRecipient.isZero() &&
       this.gasFees.isEmpty()
@@ -164,13 +179,13 @@ export class GlobalVariables {
     return {
       chainId: this.chainId.toNumber(),
       version: this.version.toNumber(),
-      blockNumber: this.blockNumber.toNumber(),
+      blockNumber: this.blockNumber,
       slotNumber: this.slotNumber.toNumber(),
-      timestamp: this.timestamp.toNumber(),
+      timestamp: this.timestamp,
       coinbase: this.coinbase.toString(),
       feeRecipient: this.feeRecipient.toString(),
-      feePerDaGas: this.gasFees.feePerDaGas.toNumber(),
-      feePerL2Gas: this.gasFees.feePerL2Gas.toNumber(),
+      feePerDaGas: Number(this.gasFees.feePerDaGas),
+      feePerL2Gas: Number(this.gasFees.feePerL2Gas),
     };
   }
 
@@ -182,9 +197,9 @@ export class GlobalVariables {
     return (
       this.chainId.equals(other.chainId) &&
       this.version.equals(other.version) &&
-      this.blockNumber.equals(other.blockNumber) &&
+      this.blockNumber === other.blockNumber &&
       this.slotNumber.equals(other.slotNumber) &&
-      this.timestamp.equals(other.timestamp) &&
+      this.timestamp === other.timestamp &&
       this.coinbase.equals(other.coinbase) &&
       this.feeRecipient.equals(other.feeRecipient) &&
       this.gasFees.equals(other.gasFees)

package/src/tx/hashed_values.ts

@@ -1,9 +1,10 @@
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
-import { computeVarArgsHash } from '../hash/index.js';
+import { computeCalldataHash, computeVarArgsHash } from '../hash/index.js';
 import { type ZodFor, schemas } from '../schemas/schemas.js';
 import { Vector } from '../types/index.js';
 
@@ -11,7 +12,7 @@ import { Vector } from '../types/index.js';
  * A container for storing a list of values and their hash.
  */
 export class HashedValues {
-  private constructor(
+  constructor(
     /**
      *  Raw values.
      */
@@ -22,20 +23,29 @@ export class HashedValues {
     public readonly hash: Fr,
   ) {}
 
+  getSize() {
+    return this.values.length + 1 /* hash */;
+  }
+
   static get schema(): ZodFor<HashedValues> {
-    return z.array(schemas.Fr).transform(HashedValues.fromValues);
+    return z
+      .object({
+        values: z.array(schemas.Fr),
+        hash: schemas.Fr,
+      })
+      .transform(HashedValues.from);
   }
 
-  toJSON() {
-    return this.values;
+  static from(fields: FieldsOf<HashedValues>): HashedValues {
+    return new HashedValues(...HashedValues.getFields(fields));
   }
 
-  static random() {
-    return HashedValues.fromValues([Fr.random(), Fr.random()]);
+  static getFields(fields: FieldsOf<HashedValues>) {
+    return [fields.values, fields.hash] as const;
   }
 
-  static async fromValues(values: Fr[]) {
-    return new HashedValues(values, await computeVarArgsHash(values));
+  static random() {
+    return new HashedValues([Fr.random(), Fr.random()], Fr.random());
   }
 
   toBuffer() {
@@ -46,4 +56,14 @@ export class HashedValues {
     const reader = BufferReader.asReader(buffer);
     return new HashedValues(reader.readVector(Fr), Fr.fromBuffer(reader));
   }
+
+  // Computes the hash of input arguments or return values for private functions, or for authwit creation.
+  static async fromArgs(args: Fr[]) {
+    return new HashedValues(args, await computeVarArgsHash(args));
+  }
+
+  // Computes the hash of calldata for public functions.
+  static async fromCalldata(calldata: Fr[]) {
+    return new HashedValues(calldata, await computeCalldataHash(calldata));
+  }
 }

package/src/tx/index.ts

@@ -1,27 +1,33 @@
 export * from './block_header.js';
 export * from './call_context.js';
 export * from './global_variables.js';
-export * from './max_block_number.js';
 export * from './content_commitment.js';
 export * from './state_reference.js';
 export * from './partial_state_reference.js';
 export * from './function_data.js';
 export * from './tree_snapshots.js';
+export * from './private_tx_constant_data.js';
 export * from './tx_constant_data.js';
 export * from './tx_context.js';
 export * from './tx_request.js';
 export * from './private_execution_result.js';
-export * from './public_execution_request.js';
+export * from './public_call_request_with_calldata.js';
 export * from './tx_hash.js';
 export * from './tx_receipt.js';
 export * from './tx.js';
 export * from './processed_tx.js';
+export * from './proven_tx.js';
 export * from './simulated_tx.js';
 export * from './tx_effect.js';
 export * from './public_simulation_output.js';
 export * from './tx_execution_request.js';
 export * from './validator/tx_validator.js';
 export * from './validator/empty_validator.js';
+export * from './validator/error_texts.js';
 export * from './capsule.js';
 export * from './global_variable_builder.js';
 export * from './hashed_values.js';
+export * from './indexed_tx_effect.js';
+export * from './offchain_effect.js';
+export * from './profiling.js';
+export * from './protocol_contracts.js';

package/src/tx/indexed_tx_effect.ts

@@ -0,0 +1,39 @@
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { L2BlockHash } from '../block/block_hash.js';
+import { type InBlock, inBlockSchemaFor, randomInBlock } from '../block/in_block.js';
+import { TxEffect } from './tx_effect.js';
+
+export type IndexedTxEffect = InBlock<TxEffect> & { txIndexInBlock: number };
+
+export function indexedTxSchema() {
+  return inBlockSchemaFor(TxEffect.schema).extend({ txIndexInBlock: schemas.Integer });
+}
+
+export async function randomIndexedTxEffect(): Promise<IndexedTxEffect> {
+  return {
+    ...randomInBlock(await TxEffect.random()),
+    txIndexInBlock: Math.floor(Math.random() * 1000),
+  };
+}
+
+export function serializeIndexedTxEffect(effect: IndexedTxEffect): Buffer {
+  return serializeToBuffer(effect.l2BlockHash, effect.l2BlockNumber, effect.txIndexInBlock, effect.data);
+}
+
+export function deserializeIndexedTxEffect(buffer: Buffer): IndexedTxEffect {
+  const reader = BufferReader.asReader(buffer);
+
+  const l2BlockHash = reader.readObject(L2BlockHash);
+  const l2BlockNumber = reader.readNumber();
+  const txIndexInBlock = reader.readNumber();
+  const data = reader.readObject(TxEffect);
+
+  return {
+    l2BlockHash,
+    l2BlockNumber,
+    txIndexInBlock,
+    data,
+  };
+}

package/src/tx/offchain_effect.ts

@@ -0,0 +1,20 @@
+import { Fr } from '@aztec/foundation/fields';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+
+// The following identifier was copied over from `noir-projects/aztec-nr/aztec/src/messages/offchain_messages.nr`.
+// poseidon2hash("aztecnr_offchain_message")
+export const OFFCHAIN_MESSAGE_IDENTIFIER: Fr = new Fr(
+  6023466688192654631553769360478808766602235351827869819420284624004071427516n,
+);
+
+/**
+ * Represents an offchain effect emitted via the `emit_offchain_effect` oracle (see the oracle documentation for
+ * more details).
+ */
+export type OffchainEffect = {
+  /** The emitted data */
+  data: Fr[];
+  /** The contract that emitted the data */
+  contractAddress: AztecAddress;
+};

package/src/tx/partial_state_reference.ts

@@ -1,4 +1,5 @@
 import { PARTIAL_STATE_REFERENCE_LENGTH } from '@aztec/constants';
+import type { ViemPartialStateReference } from '@aztec/ethereum';
 import type { Fr } from '@aztec/foundation/fields';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
@@ -55,11 +56,43 @@ export class PartialStateReference {
     return new PartialStateReference(noteHashTree, nullifierTree, publicDataTree);
   }
 
+  static fromViem(stateReference: ViemPartialStateReference) {
+    return new PartialStateReference(
+      AppendOnlyTreeSnapshot.fromViem(stateReference.noteHashTree),
+      AppendOnlyTreeSnapshot.fromViem(stateReference.nullifierTree),
+      AppendOnlyTreeSnapshot.fromViem(stateReference.publicDataTree),
+    );
+  }
+
+  static random(): PartialStateReference {
+    return new PartialStateReference(
+      AppendOnlyTreeSnapshot.random(),
+      AppendOnlyTreeSnapshot.random(),
+      AppendOnlyTreeSnapshot.random(),
+    );
+  }
+
+  toViem(): ViemPartialStateReference {
+    return {
+      noteHashTree: this.noteHashTree.toViem(),
+      nullifierTree: this.nullifierTree.toViem(),
+      publicDataTree: this.publicDataTree.toViem(),
+    };
+  }
+
+  toAbi(): [
+    ReturnType<AppendOnlyTreeSnapshot['toAbi']>,
+    ReturnType<AppendOnlyTreeSnapshot['toAbi']>,
+    ReturnType<AppendOnlyTreeSnapshot['toAbi']>,
+  ] {
+    return [this.noteHashTree.toAbi(), this.nullifierTree.toAbi(), this.publicDataTree.toAbi()];
+  }
+
   static empty(): PartialStateReference {
     return new PartialStateReference(
-      AppendOnlyTreeSnapshot.zero(),
-      AppendOnlyTreeSnapshot.zero(),
-      AppendOnlyTreeSnapshot.zero(),
+      AppendOnlyTreeSnapshot.empty(),
+      AppendOnlyTreeSnapshot.empty(),
+      AppendOnlyTreeSnapshot.empty(),
     );
   }
 
@@ -82,7 +115,7 @@ export class PartialStateReference {
   }
 
   isEmpty(): boolean {
-    return this.noteHashTree.isZero() && this.nullifierTree.isZero() && this.publicDataTree.isZero();
+    return this.noteHashTree.isEmpty() && this.nullifierTree.isEmpty() && this.publicDataTree.isEmpty();
   }
 
   public equals(other: this): boolean {