refactor: using ExtendedContractData in tx

Author: benesjan

yarn-project/aztec-rpc/src/aztec_rpc_server/aztec_rpc_server.ts

@@ -7,6 +7,7 @@ import {
 import {
   AztecAddress,
   CompleteAddress,
+  EthAddress,
   FunctionData,
   KernelCircuitPublicInputs,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
@@ -395,23 +396,20 @@ export class AztecRPCServer implements AztecRPC {
     const encryptedLogs = new TxL2Logs(collectEncryptedLogs(executionResult));
     const unencryptedLogs = new TxL2Logs(collectUnencryptedLogs(executionResult));
     const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(executionResult);
-    const partialAddress = newContract?.completeAddress.partialAddress ?? Fr.ZERO;
-    const publicKey = newContract?.completeAddress.publicKey ?? Point.ZERO;
+
+    const contractData = new ContractData(newContract?.completeAddress.address ?? AztecAddress.ZERO, EthAddress.ZERO);
+    const extendedContractData = new ExtendedContractData(
+      contractData,
+      newContractPublicFunctions,
+      newContract?.completeAddress.partialAddress ?? Fr.ZERO,
+      newContract?.completeAddress.publicKey ?? Point.ZERO,
+    );
 
     // HACK(#1639): Manually patches the ordering of the public call stack
     // TODO(#757): Enforce proper ordering of enqueued public calls
     await this.patchPublicCallStackOrdering(publicInputs, enqueuedPublicFunctions);
 
-    return new Tx(
-      publicInputs,
-      proof,
-      encryptedLogs,
-      unencryptedLogs,
-      newContractPublicFunctions,
-      enqueuedPublicFunctions,
-      [partialAddress],
-      [publicKey],
-    );
+    return new Tx(publicInputs, proof, encryptedLogs, unencryptedLogs, enqueuedPublicFunctions, [extendedContractData]);
   }
 
   // HACK(#1639): this is a hack to fix ordering of public calls enqueued in the call stack. Since the private kernel

yarn-project/p2p/src/service/tx_messages.test.ts

@@ -25,11 +25,9 @@ const verifyTx = (actual: Tx, expected: Tx) => {
   expect(actual.data!.toBuffer()).toEqual(expected.data?.toBuffer());
   expect(actual.proof!.toBuffer()).toEqual(expected.proof!.toBuffer());
   expect(actual.encryptedLogs!.toBuffer()).toEqual(expected.encryptedLogs?.toBuffer());
-  expect(actual.newContractPublicFunctions!.length).toEqual(expected.newContractPublicFunctions!.length);
-  for (let i = 0; i < actual.newContractPublicFunctions!.length; i++) {
-    expect(actual.newContractPublicFunctions![i].toBuffer()).toEqual(
-      expected.newContractPublicFunctions![i].toBuffer(),
-    );
+  expect(actual.newContracts!.length).toEqual(expected.newContracts!.length);
+  for (let i = 0; i < actual.newContracts!.length; i++) {
+    expect(actual.newContracts![i].toBuffer()).toEqual(expected.newContracts![i].toBuffer());
   }
 };
 

yarn-project/p2p/src/service/tx_messages.ts

@@ -1,15 +1,6 @@
-import {
-  Fr,
-  KernelCircuitPublicInputs,
-  MAX_NEW_CONTRACTS_PER_TX,
-  PartialAddress,
-  Point,
-  Proof,
-  PublicCallRequest,
-  PublicKey,
-} from '@aztec/circuits.js';
+import { KernelCircuitPublicInputs, MAX_NEW_CONTRACTS_PER_TX, Proof, PublicCallRequest } from '@aztec/circuits.js';
 import { Tuple, numToUInt32BE } from '@aztec/foundation/serialize';
-import { EncodedContractFunction, Tx, TxHash, TxL2Logs } from '@aztec/types';
+import { ExtendedContractData, Tx, TxHash, TxL2Logs } from '@aztec/types';
 
 /**
  * Enumeration of P2P message types.
@@ -154,10 +145,8 @@ export function toTxMessage(tx: Tx): Buffer {
     createMessageComponent(tx.proof),
     createMessageComponent(tx.encryptedLogs),
     createMessageComponent(tx.unencryptedLogs),
-    createMessageComponents(tx.newContractPublicFunctions),
     createMessageComponents(tx.enqueuedPublicFunctionCalls),
-    createMessageComponents(tx.partialAddresses),
-    createMessageComponents(tx.publicKeys),
+    createMessageComponents(tx.newContracts),
   ]);
   const messageLength = numToUInt32BE(messageBuffer.length);
   return Buffer.concat([messageLength, messageBuffer]);
@@ -209,18 +198,14 @@ export function fromTxMessage(buffer: Buffer): Tx {
     unencryptedLogs.obj = new TxL2Logs([]);
   }
 
-  const functions = toObjectArray(unencryptedLogs.remainingData, EncodedContractFunction);
-  const publicCalls = toObjectArray(functions.remainingData, PublicCallRequest);
-  const partialAddresses = toObjectArray(publicCalls.remainingData, Fr);
-  const publicKeys = toObjectArray(partialAddresses.remainingData, Point);
+  const publicCalls = toObjectArray(unencryptedLogs.remainingData, PublicCallRequest);
+  const newContracts = toObjectArray(publicCalls.remainingData, ExtendedContractData);
   return new Tx(
     publicInputs.obj!,
     proof.obj!,
     encryptedLogs.obj,
     unencryptedLogs.obj,
-    functions.objects,
     publicCalls.objects,
-    partialAddresses.objects as Tuple<PartialAddress, typeof MAX_NEW_CONTRACTS_PER_TX>,
-    publicKeys.objects as Tuple<PublicKey, typeof MAX_NEW_CONTRACTS_PER_TX>,
+    newContracts.objects as Tuple<ExtendedContractData, typeof MAX_NEW_CONTRACTS_PER_TX>,
   );
 }

yarn-project/sequencer-client/src/block_builder/solo_block_builder.test.ts

@@ -33,6 +33,7 @@ import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { to2Fields } from '@aztec/foundation/serialize';
 import {
   ContractData,
+  ExtendedContractData,
   L2Block,
   L2BlockL2Logs,
   MerkleTreeId,
@@ -178,10 +179,8 @@ describe('sequencer/solo_block_builder', () => {
         emptyProof,
         makeEmptyLogs(),
         makeEmptyLogs(),
-        [],
         times(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, makePublicCallRequest),
-        [new Fr(0)],
-        [Point.ZERO],
+        [ExtendedContractData.random()],
       ),
     );
 

yarn-project/sequencer-client/src/sequencer/public_processor.test.ts

@@ -12,11 +12,10 @@ import {
   MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
   PUBLIC_DATA_TREE_HEIGHT,
-  Point,
   Proof,
   PublicCallRequest,
   makeEmptyProof,
-  makeTuple,
+  makeTuple
 } from '@aztec/circuits.js';
 import { computeCallStackItemHash } from '@aztec/circuits.js/abis';
 import {
@@ -156,16 +155,9 @@ describe('public_processor', () => {
       kernelOutput.end.publicCallStack = padArrayEnd(callStackHashes, Fr.ZERO, MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX);
       kernelOutput.end.privateCallStack = padArrayEnd([], Fr.ZERO, MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX);
 
-      const tx = new Tx(
-        kernelOutput,
-        proof,
-        TxL2Logs.random(2, 3),
-        TxL2Logs.random(3, 2),
-        [],
-        callRequests,
-        [Fr.random()],
-        [Point.random()],
-      );
+      const tx = new Tx(kernelOutput, proof, TxL2Logs.random(2, 3), TxL2Logs.random(3, 2), callRequests, [
+        ExtendedContractData.random(),
+      ]);
 
       publicExecutor.execute.mockImplementation(execution => {
         for (const request of callRequests) {
@@ -198,10 +190,8 @@ describe('public_processor', () => {
         proof,
         TxL2Logs.random(2, 3),
         TxL2Logs.random(3, 2),
-        [],
         [callRequest],
-        [Fr.random()],
-        [Point.random()],
+        [ExtendedContractData.random()],
       );
 
       const publicExecutionResult = makePublicExecutionResultFromRequest(callRequest);

yarn-project/sequencer-client/src/sequencer/sequencer.ts

@@ -194,12 +194,7 @@ export class Sequencer {
         // Currently can only have 1 new contract per tx
         const newContract = tx.data?.end.newContracts[0];
         if (newContract) {
-          return new ExtendedContractData(
-            new ContractData(newContract.contractAddress, newContract.portalContractAddress),
-            tx.newContractPublicFunctions,
-            tx.partialAddresses[0],
-            tx.publicKeys[0],
-          );
+          return tx.newContracts[0];
         }
       })
       .filter((cd): cd is Exclude<typeof cd, undefined> => cd !== undefined);

yarn-project/types/src/mocks.ts

@@ -1,13 +1,9 @@
 import {
   CompleteAddress,
   EthAddress,
-  Fr,
   MAX_NEW_CONTRACTS_PER_TX,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
-  PartialAddress,
-  Point,
   Proof,
-  PublicKey,
 } from '@aztec/circuits.js';
 import { makeKernelPublicInputs, makePublicCallRequest } from '@aztec/circuits.js/factories';
 import { ContractAbi } from '@aztec/foundation/abi';
@@ -16,7 +12,7 @@ import { Tuple } from '@aztec/foundation/serialize';
 
 import times from 'lodash.times';
 
-import { DeployedContract, EncodedContractFunction, FunctionL2Logs, TxL2Logs } from './index.js';
+import { DeployedContract, ExtendedContractData, FunctionL2Logs, TxL2Logs } from './index.js';
 import { Tx } from './tx/index.js';
 
 /**
@@ -33,10 +29,11 @@ export const mockTx = (seed = 1) => {
     new Proof(Buffer.alloc(0)),
     TxL2Logs.random(8, 3), // 8 priv function invocations creating 3 encrypted logs each
     TxL2Logs.random(11, 2), // 8 priv + 3 pub function invocations creating 2 unencrypted logs each
-    times(3, EncodedContractFunction.random),
     times(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, makePublicCallRequest),
-    times(MAX_NEW_CONTRACTS_PER_TX, Fr.random) as Tuple<PartialAddress, typeof MAX_NEW_CONTRACTS_PER_TX>,
-    times(MAX_NEW_CONTRACTS_PER_TX, Point.random) as Tuple<PublicKey, typeof MAX_NEW_CONTRACTS_PER_TX>,
+    times(MAX_NEW_CONTRACTS_PER_TX, ExtendedContractData.random) as Tuple<
+      ExtendedContractData,
+      typeof MAX_NEW_CONTRACTS_PER_TX
+    >,
   );
 };
 

yarn-project/types/src/tx/tx.ts

@@ -1,19 +1,15 @@
 import {
-  Fr,
   KernelCircuitPublicInputs,
   MAX_NEW_CONTRACTS_PER_TX,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
-  PartialAddress,
-  Point,
   Proof,
   PublicCallRequest,
-  PublicKey,
 } from '@aztec/circuits.js';
 import { serializeToBuffer } from '@aztec/circuits.js/utils';
 import { arrayNonEmptyLength } from '@aztec/foundation/collection';
-import { BufferReader, Tuple, numToUInt32BE } from '@aztec/foundation/serialize';
+import { BufferReader, Tuple } from '@aztec/foundation/serialize';
 
-import { EncodedContractFunction } from '../contract_data.js';
+import { ExtendedContractData } from '../contract_data.js';
 import { TxL2Logs } from '../logs/tx_l2_logs.js';
 import { TxHash } from './tx_hash.js';
 
@@ -38,19 +34,16 @@ export class Tx {
      * Unencrypted logs generated by the tx.
      */
     public readonly unencryptedLogs: TxL2Logs,
-    /**
-     * New public functions made available by this tx.
-     */
-    public readonly newContractPublicFunctions: EncodedContractFunction[],
     /**
      * Enqueued public functions from the private circuit to be run by the sequencer.
      * Preimages of the public call stack entries from the private kernel circuit output.
      */
     public readonly enqueuedPublicFunctionCalls: PublicCallRequest[],
-    /** Partial addresses of new contracts. */
-    public readonly partialAddresses: Tuple<PartialAddress, typeof MAX_NEW_CONTRACTS_PER_TX>,
-    /** Public keys of new contracts. */
-    public readonly publicKeys: Tuple<PublicKey, typeof MAX_NEW_CONTRACTS_PER_TX>,
+    /**
+     * Contracts deployed in this tx.
+     * Note: Portal address is always set to zero in the tx's new contracts.
+     */
+    public readonly newContracts: Tuple<ExtendedContractData, typeof MAX_NEW_CONTRACTS_PER_TX>,
   ) {
     if (this.unencryptedLogs.functionLogs.length < this.encryptedLogs.functionLogs.length) {
       // This check is present because each private function invocation creates encrypted FunctionL2Logs object and
@@ -84,10 +77,8 @@ export class Tx {
       reader.readObject(Proof),
       reader.readObject(TxL2Logs),
       reader.readObject(TxL2Logs),
-      reader.readArray(reader.readNumber(), EncodedContractFunction),
       reader.readArray(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, PublicCallRequest),
-      reader.readArray(MAX_NEW_CONTRACTS_PER_TX, Fr),
-      reader.readArray(MAX_NEW_CONTRACTS_PER_TX, Point),
+      reader.readArray(MAX_NEW_CONTRACTS_PER_TX, ExtendedContractData),
     );
   }
 
@@ -101,12 +92,8 @@ export class Tx {
       this.proof,
       this.encryptedLogs,
       this.unencryptedLogs,
-      // number of new contract public functions is not constant so we need to include it in the serialization
-      numToUInt32BE(this.newContractPublicFunctions.length),
-      this.newContractPublicFunctions,
       this.enqueuedPublicFunctionCalls,
-      this.partialAddresses,
-      this.publicKeys,
+      this.newContracts,
     ]);
   }
 
@@ -120,10 +107,8 @@ export class Tx {
       encryptedLogs: this.encryptedLogs.toBuffer().toString('hex'),
       unencryptedLogs: this.unencryptedLogs.toBuffer().toString('hex'),
       proof: this.proof.toBuffer().toString('hex'),
-      newContractPublicFunctions: this.newContractPublicFunctions.map(f => f.toBuffer().toString('hex')) ?? [],
       enqueuedPublicFunctions: this.enqueuedPublicFunctionCalls.map(f => f.toBuffer().toString('hex')) ?? [],
-      partialAddresses: this.partialAddresses.map(f => f.toBuffer().toString('hex')),
-      publicKeys: this.publicKeys.map(f => f.toBuffer().toString('hex')),
+      newContracts: this.newContracts.map(c => c.toBuffer().toString('hex')),
     };
   }
 
@@ -137,23 +122,17 @@ export class Tx {
     const encryptedLogs = TxL2Logs.fromBuffer(Buffer.from(obj.encryptedLogs, 'hex'));
     const unencryptedLogs = TxL2Logs.fromBuffer(Buffer.from(obj.unencryptedLogs, 'hex'));
     const proof = Buffer.from(obj.proof, 'hex');
-    const newContractPublicFunctions = obj.newContractPublicFunctions
-      ? obj.newContractPublicFunctions.map((x: string) => EncodedContractFunction.fromBuffer(Buffer.from(x, 'hex')))
-      : [];
     const enqueuedPublicFunctions = obj.enqueuedPublicFunctions
       ? obj.enqueuedPublicFunctions.map((x: string) => PublicCallRequest.fromBuffer(Buffer.from(x, 'hex')))
       : [];
-    const partialAddresses = obj.partialAddresses.map((x: string) => Fr.fromBuffer(Buffer.from(x, 'hex')));
-    const publicKeys = obj.publicKeys.map((x: string) => Point.fromBuffer(Buffer.from(x, 'hex')));
+    const newContracts = obj.newContracts.map((x: string) => ExtendedContractData.fromBuffer(Buffer.from(x, 'hex')));
     return new Tx(
       publicInputs,
       Proof.fromBuffer(proof),
       encryptedLogs,
       unencryptedLogs,
-      newContractPublicFunctions,
       enqueuedPublicFunctions,
-      partialAddresses,
-      publicKeys,
+      newContracts,
     );
   }
 
@@ -187,29 +166,13 @@ export class Tx {
     const proof = Proof.fromBuffer(tx.proof.toBuffer());
     const encryptedLogs = TxL2Logs.fromBuffer(tx.encryptedLogs.toBuffer());
     const unencryptedLogs = TxL2Logs.fromBuffer(tx.unencryptedLogs.toBuffer());
-    const publicFunctions = tx.newContractPublicFunctions.map(x => {
-      return EncodedContractFunction.fromBuffer(x.toBuffer());
-    });
     const enqueuedPublicFunctions = tx.enqueuedPublicFunctionCalls.map(x => {
       return PublicCallRequest.fromBuffer(x.toBuffer());
     });
-    const partialAddresses = tx.partialAddresses.map(x => Fr.fromBuffer(x.toBuffer())) as Tuple<
-      PartialAddress,
-      typeof MAX_NEW_CONTRACTS_PER_TX
-    >;
-    const publicKeys = tx.publicKeys.map(x => Point.fromBuffer(x.toBuffer())) as Tuple<
-      PublicKey,
+    const newContracts = tx.newContracts.map(c => ExtendedContractData.fromBuffer(c.toBuffer())) as Tuple<
+      ExtendedContractData,
       typeof MAX_NEW_CONTRACTS_PER_TX
     >;
-    return new Tx(
-      publicInputs,
-      proof,
-      encryptedLogs,
-      unencryptedLogs,
-      publicFunctions,
-      enqueuedPublicFunctions,
-      partialAddresses,
-      publicKeys,
-    );
+    return new Tx(publicInputs, proof, encryptedLogs, unencryptedLogs, enqueuedPublicFunctions, newContracts);
   }
 }