@aztec/txe 0.44.0 → 0.45.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/txe",
-  "version": "0.44.0",
+  "version": "0.45.1",
   "type": "module",
   "exports": "./dest/index.js",
   "bin": "./dest/bin/index.js",
@@ -18,7 +18,7 @@
     "formatting": "run -T prettier --check ./src && run -T eslint ./src",
     "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests",
-    "dev": "DEBUG='aztec:*' && node ./dest/bin/index.js",
+    "dev": "DEBUG='aztec:*' LOG_LEVEL=debug && node ./dest/bin/index.js",
     "start": "node ./dest/bin/index.js"
   },
   "inherits": [
@@ -57,18 +57,18 @@
     ]
   },
   "dependencies": {
-    "@aztec/archiver": "0.44.0",
-    "@aztec/aztec.js": "0.44.0",
-    "@aztec/circuit-types": "0.44.0",
-    "@aztec/circuits.js": "0.44.0",
-    "@aztec/foundation": "0.44.0",
-    "@aztec/key-store": "0.44.0",
-    "@aztec/kv-store": "0.44.0",
-    "@aztec/noir-contracts.js": "0.44.0",
-    "@aztec/pxe": "0.44.0",
-    "@aztec/simulator": "0.44.0",
-    "@aztec/types": "0.44.0",
-    "@aztec/world-state": "0.44.0"
+    "@aztec/archiver": "0.45.1",
+    "@aztec/aztec.js": "0.45.1",
+    "@aztec/circuit-types": "0.45.1",
+    "@aztec/circuits.js": "0.45.1",
+    "@aztec/foundation": "0.45.1",
+    "@aztec/key-store": "0.45.1",
+    "@aztec/kv-store": "0.45.1",
+    "@aztec/noir-contracts.js": "0.45.1",
+    "@aztec/pxe": "0.45.1",
+    "@aztec/simulator": "0.45.1",
+    "@aztec/types": "0.45.1",
+    "@aztec/world-state": "0.45.1"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",

package/src/oracle/txe_oracle.ts

@@ -113,6 +113,10 @@ export class TXE implements TypedOracle {
     return this.msgSender;
   }
 
+  getFunctionSelector() {
+    return this.functionSelector;
+  }
+
   setMsgSender(msgSender: Fr) {
     this.msgSender = msgSender;
   }
@@ -185,11 +189,10 @@ export class TXE implements TypedOracle {
 
   getPublicContextInputs() {
     const inputs = {
-      functionSelector: FunctionSelector.fromField(new Fr(0)),
       argsHash: new Fr(0),
       isStaticCall: false,
       toFields: function () {
-        return [this.functionSelector.toField(), this.argsHash, new Fr(this.isStaticCall)];
+        return [this.argsHash, new Fr(this.isStaticCall)];
       },
     };
     return inputs;
@@ -434,13 +437,45 @@ export class TXE implements TypedOracle {
     throw new Error('Method not implemented.');
   }
 
-  async storageRead(startStorageSlot: Fr, numberOfElements: number): Promise<Fr[]> {
+  async avmOpcodeStorageRead(slot: Fr, length: Fr) {
     const db = this.trees.asLatest();
 
+    const result = [];
+
+    for (let i = 0; i < length.toNumber(); i++) {
+      const leafSlot = computePublicDataTreeLeafSlot(this.contractAddress, slot.add(new Fr(i))).toBigInt();
+
+      const lowLeafResult = await db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+      if (!lowLeafResult || !lowLeafResult.alreadyPresent) {
+        result.push(Fr.ZERO);
+        continue;
+      }
+
+      const preimage = (await db.getLeafPreimage(
+        MerkleTreeId.PUBLIC_DATA_TREE,
+        lowLeafResult.index,
+      )) as PublicDataTreeLeafPreimage;
+
+      result.push(preimage.value);
+    }
+    return result;
+  }
+
+  async storageRead(
+    contractAddress: Fr,
+    startStorageSlot: Fr,
+    blockNumber: number,
+    numberOfElements: number,
+  ): Promise<Fr[]> {
+    const db =
+      blockNumber === (await this.getBlockNumber())
+        ? this.trees.asLatest()
+        : new MerkleTreeSnapshotOperationsFacade(this.trees, blockNumber);
+
     const values = [];
     for (let i = 0n; i < numberOfElements; i++) {
       const storageSlot = startStorageSlot.add(new Fr(i));
-      const leafSlot = computePublicDataTreeLeafSlot(this.contractAddress, storageSlot).toBigInt();
+      const leafSlot = computePublicDataTreeLeafSlot(contractAddress, storageSlot).toBigInt();
 
       const lowLeafResult = await db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
 
@@ -582,12 +617,12 @@ export class TXE implements TypedOracle {
 
       await this.addNullifiers(
         targetContractAddress,
-        publicInputs.newNullifiers.filter(nullifier => !nullifier.isEmpty()).map(nullifier => nullifier.value),
+        publicInputs.nullifiers.filter(nullifier => !nullifier.isEmpty()).map(nullifier => nullifier.value),
       );
 
       await this.addNoteHashes(
         targetContractAddress,
-        publicInputs.newNoteHashes.filter(noteHash => !noteHash.isEmpty()).map(noteHash => noteHash.value),
+        publicInputs.noteHashes.filter(noteHash => !noteHash.isEmpty()).map(noteHash => noteHash.value),
       );
 
       return callStackItem;
@@ -685,7 +720,7 @@ export class TXE implements TypedOracle {
       Gas.test(),
       TxContext.empty(),
       /* pendingNullifiers */ [],
-      /* transactionFee */ Fr.ZERO,
+      /* transactionFee */ Fr.ONE,
       callContext.sideEffectCounter,
     );
   }
@@ -830,14 +865,23 @@ export class TXE implements TypedOracle {
   }
 
   setPublicTeardownFunctionCall(
-    _targetContractAddress: AztecAddress,
-    _functionSelector: FunctionSelector,
-    _argsHash: Fr,
-    _sideEffectCounter: number,
-    _isStaticCall: boolean,
-    _isDelegateCall: boolean,
+    targetContractAddress: AztecAddress,
+    functionSelector: FunctionSelector,
+    argsHash: Fr,
+    sideEffectCounter: number,
+    isStaticCall: boolean,
+    isDelegateCall: boolean,
   ): Promise<PublicCallRequest> {
-    throw new Error('Method not implemented.');
+    // Definitely not right, in that the teardown should always be last.
+    // But useful for executing flows.
+    return this.enqueuePublicFunctionCall(
+      targetContractAddress,
+      functionSelector,
+      argsHash,
+      sideEffectCounter,
+      isStaticCall,
+      isDelegateCall,
+    );
   }
 
   aes128Encrypt(input: Buffer, initializationVector: Buffer, key: Buffer): Buffer {

package/src/txe_service/txe_service.ts

@@ -251,6 +251,16 @@ export class TXEService {
     return toForeignCallResult([]);
   }
 
+  setFunctionSelector(functionSelector: ForeignCallSingle) {
+    (this.typedOracle as TXE).setFunctionSelector(FunctionSelector.fromField(fromSingle(functionSelector)));
+    return toForeignCallResult([]);
+  }
+
+  getFunctionSelector() {
+    const functionSelector = (this.typedOracle as TXE).getFunctionSelector();
+    return toForeignCallResult([toSingle(functionSelector.toField())]);
+  }
+
   // PXE oracles
 
   getRandomField() {
@@ -277,6 +287,11 @@ export class TXEService {
     return toForeignCallResult([toSingle(new Fr(blockNumber))]);
   }
 
+  avmOpcodeFunctionSelector() {
+    const functionSelector = (this.typedOracle as TXE).getFunctionSelector();
+    return toForeignCallResult([toSingle(functionSelector.toField())]);
+  }
+
   async packArgumentsArray(args: ForeignCallArray) {
     const packed = await this.typedOracle.packArgumentsArray(fromArray(args));
     return toForeignCallResult([toSingle(packed)]);
@@ -308,9 +323,16 @@ export class TXEService {
     return toForeignCallResult([]);
   }
 
-  async storageRead(startStorageSlot: ForeignCallSingle, numberOfElements: ForeignCallSingle) {
+  async storageRead(
+    contractAddress: ForeignCallSingle,
+    startStorageSlot: ForeignCallSingle,
+    blockNumber: ForeignCallSingle,
+    numberOfElements: ForeignCallSingle,
+  ) {
     const values = await this.typedOracle.storageRead(
+      fromSingle(contractAddress),
       fromSingle(startStorageSlot),
+      fromSingle(blockNumber).toNumber(),
       fromSingle(numberOfElements).toNumber(),
     );
     return toForeignCallResult([toArray(values)]);
@@ -499,13 +521,41 @@ export class TXEService {
       fromSingle(address),
       FunctionSelector.fromField(fromSingle(functionSelector)),
       fromArray(args),
-      false,
-      false,
+      /* isStaticCall */ false,
+      /* isDelegateCall */ false,
     );
 
     return toForeignCallResult([toArray(result.returnValues), toSingle(new Fr(1))]);
   }
 
+  async avmOpcodeStaticCall(
+    _gas: ForeignCallArray,
+    address: ForeignCallSingle,
+    _length: ForeignCallSingle,
+    args: ForeignCallArray,
+    functionSelector: ForeignCallSingle,
+  ) {
+    const result = await (this.typedOracle as TXE).avmOpcodeCall(
+      fromSingle(address),
+      FunctionSelector.fromField(fromSingle(functionSelector)),
+      fromArray(args),
+      /* isStaticCall */ true,
+      /* isDelegateCall */ false,
+    );
+
+    return toForeignCallResult([toArray(result.returnValues), toSingle(new Fr(1))]);
+  }
+
+  async avmOpcodeStorageRead(slot: ForeignCallSingle, length: ForeignCallSingle) {
+    const values = await (this.typedOracle as TXE).avmOpcodeStorageRead(fromSingle(slot), fromSingle(length));
+    return toForeignCallResult([toArray(values)]);
+  }
+
+  async avmOpcodeStorageWrite(startStorageSlot: ForeignCallSingle, values: ForeignCallArray) {
+    await this.typedOracle.storageWrite(fromSingle(startStorageSlot), fromArray(values));
+    return toForeignCallResult([]);
+  }
+
   async getPublicKeysAndPartialAddress(address: ForeignCallSingle) {
     const parsedAddress = AztecAddress.fromField(fromSingle(address));
     const { publicKeys, partialAddress } = await this.typedOracle.getCompleteAddress(parsedAddress);
@@ -564,6 +614,10 @@ export class TXEService {
     return toForeignCallResult([]);
   }
 
+  emitEncryptedEventLog(_contractAddress: AztecAddress, _randomness: Fr, _encryptedEvent: Buffer, _counter: number) {
+    return toForeignCallResult([]);
+  }
+
   async callPrivateFunction(
     targetContractAddress: ForeignCallSingle,
     functionSelector: ForeignCallSingle,
@@ -626,6 +680,33 @@ export class TXEService {
     return toForeignCallResult([toArray(fields)]);
   }
 
+  public async setPublicTeardownFunctionCall(
+    targetContractAddress: ForeignCallSingle,
+    functionSelector: ForeignCallSingle,
+    argsHash: ForeignCallSingle,
+    sideEffectCounter: ForeignCallSingle,
+    isStaticCall: ForeignCallSingle,
+    isDelegateCall: ForeignCallSingle,
+  ) {
+    const publicTeardownCallRequest = await this.typedOracle.setPublicTeardownFunctionCall(
+      fromSingle(targetContractAddress),
+      FunctionSelector.fromField(fromSingle(functionSelector)),
+      fromSingle(argsHash),
+      fromSingle(sideEffectCounter).toNumber(),
+      fromSingle(isStaticCall).toBool(),
+      fromSingle(isDelegateCall).toBool(),
+    );
+
+    const fields = [
+      publicTeardownCallRequest.contractAddress.toField(),
+      publicTeardownCallRequest.functionSelector.toField(),
+      ...publicTeardownCallRequest.callContext.toFields(),
+      publicTeardownCallRequest.getArgsHash(),
+    ];
+
+    return toForeignCallResult([toArray(fields)]);
+  }
+
   async getChainId() {
     return toForeignCallResult([toSingle(await this.typedOracle.getChainId())]);
   }