@aztec/stdlib 0.77.0-testnet-ignition.17

package/dest/tx/tx_effect.js

@@ -0,0 +1,425 @@
+import { CONTRACT_CLASS_LOGS_PREFIX, CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, L2_L1_MSGS_PREFIX, MAX_CONTRACT_CLASS_LOGS_PER_TX, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_PRIVATE_LOGS_PER_TX, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, NOTES_PREFIX, NULLIFIERS_PREFIX, PRIVATE_LOGS_PREFIX, PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DATA_UPDATE_REQUESTS_PREFIX, PUBLIC_LOGS_PREFIX, PUBLIC_LOG_SIZE_IN_FIELDS, REVERT_CODE_PREFIX, TX_FEE_PREFIX } from '@aztec/constants';
+import { makeTuple, makeTupleAsync } from '@aztec/foundation/array';
+import { toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { sha256Trunc } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, FieldReader, serializeArrayOfBufferableToVector, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import { inspect } from 'util';
+import { z } from 'zod';
+import { PublicDataWrite } from '../avm/public_data_write.js';
+import { RevertCode } from '../avm/revert_code.js';
+import { ContractClassLog } from '../logs/contract_class_log.js';
+import { PrivateLog } from '../logs/private_log.js';
+import { PublicLog } from '../logs/public_log.js';
+import { TxHash } from './tx_hash.js';
+// This will appear as 0x74785f7374617274 in logs
+export const TX_START_PREFIX = 8392562855083340404n;
+// These are helper constants to decode tx effects from blob encoded fields
+export const TX_START_PREFIX_BYTES_LENGTH = TX_START_PREFIX.toString(16).length / 2;
+// 7 bytes for: | 0 | txlen[0] | txlen[1] | 0 | REVERT_CODE_PREFIX | 0 | revertCode |
+export const TX_EFFECT_PREFIX_BYTE_LENGTH = TX_START_PREFIX_BYTES_LENGTH + 7;
+export class TxEffect {
+    revertCode;
+    txHash;
+    transactionFee;
+    noteHashes;
+    nullifiers;
+    l2ToL1Msgs;
+    publicDataWrites;
+    privateLogs;
+    publicLogs;
+    contractClassLogs;
+    constructor(/**
+     * Whether the transaction reverted during public app logic.
+     */ revertCode, /**
+     * The identifier of the transaction.
+     */ txHash, /**
+     * The transaction fee, denominated in FPA.
+     */ transactionFee, /**
+     * The note hashes to be inserted into the note hash tree.
+     */ noteHashes, /**
+     * The nullifiers to be inserted into the nullifier tree.
+     */ nullifiers, /**
+     * The hash of L2 to L1 messages to be inserted into the messagebox on L1.
+     * TODO(just-mitch): rename to l2ToL1MsgHashes
+     */ l2ToL1Msgs, /**
+     * The public data writes to be inserted into the public data tree.
+     */ publicDataWrites, /**
+     * The private logs.
+     */ privateLogs, /**
+     * The public logs.
+     */ publicLogs, /**
+     * The contract class logs.
+     */ contractClassLogs){
+        this.revertCode = revertCode;
+        this.txHash = txHash;
+        this.transactionFee = transactionFee;
+        this.noteHashes = noteHashes;
+        this.nullifiers = nullifiers;
+        this.l2ToL1Msgs = l2ToL1Msgs;
+        this.publicDataWrites = publicDataWrites;
+        this.privateLogs = privateLogs;
+        this.publicLogs = publicLogs;
+        this.contractClassLogs = contractClassLogs;
+        // TODO(#4638): Clean this up once we have isDefault() everywhere --> then we don't have to deal with 2 different
+        // functions (isZero and isEmpty)
+        if (noteHashes.length > MAX_NOTE_HASHES_PER_TX) {
+            throw new Error(`Too many note hashes: ${noteHashes.length}, max: ${MAX_NOTE_HASHES_PER_TX}`);
+        }
+        noteHashes.forEach((h)=>{
+            if (h.isZero()) {
+                throw new Error('Note hash is zero');
+            }
+        });
+        if (nullifiers.length > MAX_NULLIFIERS_PER_TX) {
+            throw new Error(`Too many nullifiers: ${nullifiers.length}, max: ${MAX_NULLIFIERS_PER_TX}`);
+        }
+        nullifiers.forEach((h)=>{
+            if (h.isZero()) {
+                throw new Error('Nullifier is zero');
+            }
+        });
+        if (l2ToL1Msgs.length > MAX_L2_TO_L1_MSGS_PER_TX) {
+            throw new Error(`Too many L2 to L1 messages: ${l2ToL1Msgs.length}, max: ${MAX_L2_TO_L1_MSGS_PER_TX}`);
+        }
+        l2ToL1Msgs.forEach((h)=>{
+            if (h.isZero()) {
+                throw new Error('L2 to L1 message is zero');
+            }
+        });
+        if (publicDataWrites.length > MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX) {
+            throw new Error(`Too many public data writes: ${publicDataWrites.length}, max: ${MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX}`);
+        }
+        publicDataWrites.forEach((h)=>{
+            if (h.isEmpty()) {
+                throw new Error('Public data write is empty');
+            }
+        });
+        if (privateLogs.length > MAX_PRIVATE_LOGS_PER_TX) {
+            throw new Error(`Too many private logs: ${privateLogs.length}, max: ${MAX_PRIVATE_LOGS_PER_TX}`);
+        }
+        privateLogs.forEach((h)=>{
+            if (h.isEmpty()) {
+                throw new Error('Private log is empty');
+            }
+        });
+    }
+    toBuffer() {
+        return serializeToBuffer([
+            this.revertCode,
+            this.txHash,
+            this.transactionFee,
+            serializeArrayOfBufferableToVector(this.noteHashes, 1),
+            serializeArrayOfBufferableToVector(this.nullifiers, 1),
+            serializeArrayOfBufferableToVector(this.l2ToL1Msgs, 1),
+            serializeArrayOfBufferableToVector(this.publicDataWrites, 1),
+            serializeArrayOfBufferableToVector(this.privateLogs, 1),
+            serializeArrayOfBufferableToVector(this.publicLogs, 1),
+            serializeArrayOfBufferableToVector(this.contractClassLogs, 1)
+        ]);
+    }
+    /** Returns the size of this tx effect in bytes as serialized onto DA. */ getDASize() {
+        return this.toBlobFields().length * Fr.SIZE_IN_BYTES;
+    }
+    /**
+   * Deserializes the TxEffect object from a Buffer.
+   * @param buffer - Buffer or BufferReader object to deserialize.
+   * @returns An instance of TxEffect.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new TxEffect(RevertCode.fromBuffer(reader), TxHash.fromBuffer(reader), Fr.fromBuffer(reader), reader.readVectorUint8Prefix(Fr), reader.readVectorUint8Prefix(Fr), reader.readVectorUint8Prefix(Fr), reader.readVectorUint8Prefix(PublicDataWrite), reader.readVectorUint8Prefix(PrivateLog), reader.readVectorUint8Prefix(PublicLog), reader.readVectorUint8Prefix(ContractClassLog));
+    }
+    /**
+   * Computes txOutHash of this tx effect.
+   * TODO(#7218): Revert to fixed height tree for outbox
+   * @dev Follows new_sha in variable_merkle_tree.nr
+   */ txOutHash() {
+        const { l2ToL1Msgs } = this;
+        if (l2ToL1Msgs.length == 0) {
+            return Buffer.alloc(32);
+        }
+        const depth = l2ToL1Msgs.length == 1 ? 1 : Math.ceil(Math.log2(l2ToL1Msgs.length));
+        let thisLayer = padArrayEnd(l2ToL1Msgs.map((msg)=>msg.toBuffer()), Buffer.alloc(32), 2 ** depth);
+        let nextLayer = [];
+        for(let i = 0; i < depth; i++){
+            for(let j = 0; j < thisLayer.length; j += 2){
+                // Store the hash of each pair one layer up
+                nextLayer[j / 2] = sha256Trunc(Buffer.concat([
+                    thisLayer[j],
+                    thisLayer[j + 1]
+                ]));
+            }
+            thisLayer = nextLayer;
+            nextLayer = [];
+        }
+        return thisLayer[0];
+    }
+    static async random(numPublicCallsPerTx = 3, numPublicLogsPerCall = 1) {
+        return new TxEffect(RevertCode.random(), TxHash.random(), new Fr(Math.floor(Math.random() * 100_000)), makeTuple(MAX_NOTE_HASHES_PER_TX, Fr.random), makeTuple(MAX_NULLIFIERS_PER_TX, Fr.random), makeTuple(MAX_L2_TO_L1_MSGS_PER_TX, Fr.random), makeTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, ()=>new PublicDataWrite(Fr.random(), Fr.random())), makeTuple(MAX_PRIVATE_LOGS_PER_TX, ()=>new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr.random))), await makeTupleAsync(numPublicCallsPerTx * numPublicLogsPerCall, PublicLog.random), await makeTupleAsync(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog.random));
+    }
+    static empty() {
+        return new TxEffect(RevertCode.OK, TxHash.zero(), Fr.ZERO, [], [], [], [], [], [], []);
+    }
+    isEmpty() {
+        return this.nullifiers.length === 0;
+    }
+    /** Returns a hex representation of the TxEffect object. */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    /**
+   * Returns the prefix as used in a blob.
+   * Used to prefix a 'block' of tx effects with its type and length.
+   */ toPrefix(type, length) {
+        const buf = Buffer.alloc(4);
+        buf.writeUint8(type);
+        buf.writeUInt16BE(length, 2);
+        return new Fr(buf);
+    }
+    /**
+   * Decodes the prefix as used in a blob to tx effect type and length.
+   */ static fromPrefix(prefix) {
+        const buf = prefix.toBuffer().subarray(-4);
+        return {
+            type: buf[0],
+            length: new Fr(buf.subarray(-2)).toNumber()
+        };
+    }
+    /**
+   * Encodes the first field of a tx effect as used in a blob:
+   * TX_START_PREFIX | 0 | txlen[0] txlen[1] | 0 | REVERT_CODE_PREFIX | 0 | revert_code
+   */ encodeFirstField(length, revertCode) {
+        const lengthBuf = Buffer.alloc(2);
+        lengthBuf.writeUInt16BE(length, 0);
+        return new Fr(Buffer.concat([
+            toBufferBE(TX_START_PREFIX, TX_START_PREFIX_BYTES_LENGTH),
+            Buffer.alloc(1),
+            lengthBuf,
+            Buffer.alloc(1),
+            Buffer.from([
+                REVERT_CODE_PREFIX
+            ]),
+            Buffer.alloc(1),
+            revertCode.toBuffer()
+        ]));
+    }
+    /**
+   * Decodes the first field of a tx effect as used in a blob:
+   * TX_START_PREFIX | 0 | txlen[0] txlen[1] | 0 | REVERT_CODE_PREFIX | 0 | revert_code
+   * Assumes that isFirstField has been called already.
+   */ static decodeFirstField(field) {
+        const buf = field.toBuffer().subarray(-TX_EFFECT_PREFIX_BYTE_LENGTH);
+        return {
+            length: new Fr(buf.subarray(TX_START_PREFIX_BYTES_LENGTH + 1, TX_START_PREFIX_BYTES_LENGTH + 3)).toNumber(),
+            revertCode: buf[buf.length - 1]
+        };
+    }
+    /**
+   * Determines whether a field is the first field of a tx effect
+   */ static isFirstField(field) {
+        const buf = field.toBuffer();
+        if (!buf.subarray(0, field.size - TX_EFFECT_PREFIX_BYTE_LENGTH).equals(Buffer.alloc(field.size - TX_EFFECT_PREFIX_BYTE_LENGTH))) {
+            return false;
+        }
+        const sliced = buf.subarray(-TX_EFFECT_PREFIX_BYTE_LENGTH);
+        if (// Checking we start with the correct prefix...
+        !new Fr(sliced.subarray(0, TX_START_PREFIX_BYTES_LENGTH)).equals(new Fr(TX_START_PREFIX)) || // ...and include the revert code prefix..
+        sliced[sliced.length - 3] !== REVERT_CODE_PREFIX || // ...and the following revert code is valid.
+        sliced[sliced.length - 1] > 4) {
+            return false;
+        }
+        return true;
+    }
+    /**
+   * Returns a flat packed array of prefixed fields of all tx effects, used for blobs.
+   */ toBlobFields() {
+        if (this.isEmpty()) {
+            return [];
+        }
+        const flattened = [];
+        // We reassign the first field when we know the length of all effects - see below
+        flattened.push(Fr.ZERO);
+        flattened.push(this.txHash.hash);
+        // TODO: how long should tx fee be? For now, not using toPrefix()
+        flattened.push(new Fr(Buffer.concat([
+            Buffer.from([
+                TX_FEE_PREFIX
+            ]),
+            Buffer.alloc(1),
+            this.transactionFee.toBuffer().subarray(3)
+        ])));
+        if (this.noteHashes.length) {
+            flattened.push(this.toPrefix(NOTES_PREFIX, this.noteHashes.length));
+            flattened.push(...this.noteHashes);
+        }
+        if (this.nullifiers.length) {
+            flattened.push(this.toPrefix(NULLIFIERS_PREFIX, this.nullifiers.length));
+            flattened.push(...this.nullifiers);
+        }
+        if (this.l2ToL1Msgs.length) {
+            flattened.push(this.toPrefix(L2_L1_MSGS_PREFIX, this.l2ToL1Msgs.length));
+            flattened.push(...this.l2ToL1Msgs);
+        }
+        if (this.publicDataWrites.length) {
+            flattened.push(this.toPrefix(PUBLIC_DATA_UPDATE_REQUESTS_PREFIX, this.publicDataWrites.length * 2));
+            flattened.push(...this.publicDataWrites.map((w)=>[
+                    w.leafSlot,
+                    w.value
+                ]).flat());
+        }
+        if (this.privateLogs.length) {
+            flattened.push(this.toPrefix(PRIVATE_LOGS_PREFIX, this.privateLogs.length * PRIVATE_LOG_SIZE_IN_FIELDS));
+            flattened.push(...this.privateLogs.map((l)=>l.fields).flat());
+        }
+        if (this.publicLogs.length) {
+            flattened.push(this.toPrefix(PUBLIC_LOGS_PREFIX, this.publicLogs.length * PUBLIC_LOG_SIZE_IN_FIELDS));
+            flattened.push(...this.publicLogs.map((l)=>l.toFields()).flat());
+        }
+        if (this.contractClassLogs.length) {
+            const totalLogLen = this.contractClassLogs.reduce((total, log)=>total + (log.getEmittedLength() == 0 ? 0 : log.getEmittedLength() + 2), 0);
+            flattened.push(this.toPrefix(CONTRACT_CLASS_LOGS_PREFIX, totalLogLen));
+            flattened.push(...this.contractClassLogs.flatMap((l)=>[
+                    new Fr(l.getEmittedLength()),
+                    l.contractAddress.toField(),
+                    ...l.getEmittedFields()
+                ]));
+        }
+        // The first value appended to each list of fields representing a tx effect is:
+        // TX_START_PREFIX | 0 | txlen[0] txlen[1] | 0 | REVERT_CODE_PREFIX | 0 | revert_code
+        // Tx start and len are to aid decomposing/ identifying when we reach a new tx effect
+        // The remaining bytes are used for revert code, since that only requires 3 bytes
+        flattened[0] = this.encodeFirstField(flattened.length, this.revertCode);
+        return flattened;
+    }
+    /**
+   * Decodes a flat packed array of prefixed fields to TxEffect
+   */ static fromBlobFields(fields) {
+        const ensureEmpty = (arr)=>{
+            if (arr.length) {
+                throw new Error('Invalid fields given to TxEffect.fromBlobFields(): Attempted to assign property twice.');
+            }
+        };
+        const effect = this.empty();
+        if (!(fields instanceof FieldReader) && !fields.length) {
+            return effect;
+        }
+        const reader = FieldReader.asReader(fields);
+        const firstField = reader.readField();
+        if (!this.isFirstField(firstField)) {
+            throw new Error('Invalid fields given to TxEffect.fromBlobFields(): First field invalid.');
+        }
+        const { length: _, revertCode } = this.decodeFirstField(firstField);
+        effect.revertCode = RevertCode.fromField(new Fr(revertCode));
+        effect.txHash = new TxHash(reader.readField());
+        // TODO: how long should tx fee be? For now, not using fromPrefix()
+        const prefixedFee = reader.readField();
+        // NB: Fr.fromBuffer hangs here if you provide a buffer less than 32 in len
+        // todo: try new Fr(prefixedFee.toBuffer().subarray(3))
+        effect.transactionFee = Fr.fromBuffer(Buffer.concat([
+            Buffer.alloc(3),
+            prefixedFee.toBuffer().subarray(3)
+        ]));
+        while(!reader.isFinished()){
+            const { type, length } = this.fromPrefix(reader.readField());
+            switch(type){
+                case NOTES_PREFIX:
+                    ensureEmpty(effect.noteHashes);
+                    effect.noteHashes = reader.readFieldArray(length);
+                    break;
+                case NULLIFIERS_PREFIX:
+                    ensureEmpty(effect.nullifiers);
+                    effect.nullifiers = reader.readFieldArray(length);
+                    break;
+                case L2_L1_MSGS_PREFIX:
+                    ensureEmpty(effect.l2ToL1Msgs);
+                    effect.l2ToL1Msgs = reader.readFieldArray(length);
+                    break;
+                case PUBLIC_DATA_UPDATE_REQUESTS_PREFIX:
+                    {
+                        ensureEmpty(effect.publicDataWrites);
+                        const publicDataPairs = reader.readFieldArray(length);
+                        for(let i = 0; i < length; i += 2){
+                            effect.publicDataWrites.push(new PublicDataWrite(publicDataPairs[i], publicDataPairs[i + 1]));
+                        }
+                        break;
+                    }
+                case PRIVATE_LOGS_PREFIX:
+                    {
+                        // TODO(Miranda): squash log 0s in a nested loop and add len prefix?
+                        ensureEmpty(effect.privateLogs);
+                        const flatPrivateLogs = reader.readFieldArray(length);
+                        for(let i = 0; i < length; i += PRIVATE_LOG_SIZE_IN_FIELDS){
+                            effect.privateLogs.push(PrivateLog.fromFields(flatPrivateLogs.slice(i, i + PRIVATE_LOG_SIZE_IN_FIELDS)));
+                        }
+                        break;
+                    }
+                case PUBLIC_LOGS_PREFIX:
+                    {
+                        ensureEmpty(effect.publicLogs);
+                        const flatPublicLogs = reader.readFieldArray(length);
+                        for(let i = 0; i < length; i += PUBLIC_LOG_SIZE_IN_FIELDS){
+                            effect.publicLogs.push(PublicLog.fromFields(flatPublicLogs.slice(i, i + PUBLIC_LOG_SIZE_IN_FIELDS)));
+                        }
+                        break;
+                    }
+                case CONTRACT_CLASS_LOGS_PREFIX:
+                    {
+                        ensureEmpty(effect.contractClassLogs);
+                        const flatContractClassLogs = reader.readFieldArray(length);
+                        let i = 0;
+                        while(i < length){
+                            const logLen = flatContractClassLogs[i++].toNumber();
+                            // +1 for address
+                            const logFields = flatContractClassLogs.slice(i, i += logLen + 1);
+                            effect.contractClassLogs.push(ContractClassLog.fromFields(logFields.concat(new Array(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS - logLen).fill(Fr.ZERO))));
+                        }
+                        break;
+                    }
+                case REVERT_CODE_PREFIX:
+                default:
+                    throw new Error(`Too many fields to decode given to TxEffect.fromBlobFields()`);
+            }
+        }
+        return effect;
+    }
+    static from(fields) {
+        return new TxEffect(fields.revertCode, fields.txHash, fields.transactionFee, fields.noteHashes, fields.nullifiers, fields.l2ToL1Msgs, fields.publicDataWrites, fields.privateLogs, fields.publicLogs, fields.contractClassLogs);
+    }
+    static get schema() {
+        return z.object({
+            revertCode: RevertCode.schema,
+            txHash: TxHash.schema,
+            transactionFee: schemas.Fr,
+            noteHashes: z.array(schemas.Fr),
+            nullifiers: z.array(schemas.Fr),
+            l2ToL1Msgs: z.array(schemas.Fr),
+            publicDataWrites: z.array(PublicDataWrite.schema),
+            privateLogs: z.array(PrivateLog.schema),
+            publicLogs: z.array(PublicLog.schema),
+            contractClassLogs: z.array(ContractClassLog.schema)
+        }).transform(TxEffect.from);
+    }
+    [inspect.custom]() {
+        return `TxEffect {
+      revertCode: ${this.revertCode},
+      txHash: ${this.txHash},
+      transactionFee: ${this.transactionFee},
+      note hashes: [${this.noteHashes.map((h)=>h.toString()).join(', ')}],
+      nullifiers: [${this.nullifiers.map((h)=>h.toString()).join(', ')}],
+      l2ToL1Msgs: [${this.l2ToL1Msgs.map((h)=>h.toString()).join(', ')}],
+      publicDataWrites: [${this.publicDataWrites.map((h)=>h.toString()).join(', ')}],
+      privateLogs: [${this.privateLogs.map((l)=>l.toString()).join(', ')}],
+      publicLogs: [${this.publicLogs.map((l)=>l.toString()).join(', ')}],
+      contractClassLogs: [${this.contractClassLogs.map((l)=>l.toString()).join(', ')}],
+     }`;
+    }
+    /**
+   * Deserializes an TxEffect object from a string.
+   * @param str - String to deserialize.
+   * @returns An instance of TxEffect.
+   */ static fromString(str) {
+        return TxEffect.fromBuffer(hexToBuffer(str));
+    }
+}

package/dest/tx/tx_execution_request.d.ts

@@ -0,0 +1,114 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { inspect } from 'util';
+import { FunctionSelector } from '../abi/function_selector.js';
+import { AuthWitness } from '../auth_witness/auth_witness.js';
+import { AztecAddress } from '../aztec-address/index.js';
+import { type ZodFor } from '../schemas/index.js';
+import { Capsule } from './capsule.js';
+import { HashedValues } from './hashed_values.js';
+import { TxContext } from './tx_context.js';
+import { TxRequest } from './tx_request.js';
+/**
+ * Request to execute a transaction. Similar to TxRequest, but has the full args.
+ */
+export declare class TxExecutionRequest {
+    /**
+     * Sender.
+     */
+    origin: AztecAddress;
+    /**
+     * Selector of the function to call.
+     */
+    functionSelector: FunctionSelector;
+    /**
+     * The hash of arguments of first call to be executed (usually account entrypoint).
+     * @dev This hash is a pointer to `argsOfCalls` unordered array.
+     */
+    firstCallArgsHash: Fr;
+    /**
+     * Transaction context.
+     */
+    txContext: TxContext;
+    /**
+     * An unordered array of packed arguments for each call in the transaction.
+     * @dev These arguments are accessed in Noir via oracle and constrained against the args hash. The length of
+     * the array is equal to the number of function calls in the transaction (1 args per 1 call).
+     */
+    argsOfCalls: HashedValues[];
+    /**
+     * Transient authorization witnesses for authorizing the execution of one or more actions during this tx.
+     * These witnesses are not expected to be stored in the local witnesses database of the PXE.
+     */
+    authWitnesses: AuthWitness[];
+    /**
+     * Read-only data passed through the oracle calls during this tx execution.
+     */
+    capsules: Capsule[];
+    constructor(
+    /**
+     * Sender.
+     */
+    origin: AztecAddress, 
+    /**
+     * Selector of the function to call.
+     */
+    functionSelector: FunctionSelector, 
+    /**
+     * The hash of arguments of first call to be executed (usually account entrypoint).
+     * @dev This hash is a pointer to `argsOfCalls` unordered array.
+     */
+    firstCallArgsHash: Fr, 
+    /**
+     * Transaction context.
+     */
+    txContext: TxContext, 
+    /**
+     * An unordered array of packed arguments for each call in the transaction.
+     * @dev These arguments are accessed in Noir via oracle and constrained against the args hash. The length of
+     * the array is equal to the number of function calls in the transaction (1 args per 1 call).
+     */
+    argsOfCalls: HashedValues[], 
+    /**
+     * Transient authorization witnesses for authorizing the execution of one or more actions during this tx.
+     * These witnesses are not expected to be stored in the local witnesses database of the PXE.
+     */
+    authWitnesses: AuthWitness[], 
+    /**
+     * Read-only data passed through the oracle calls during this tx execution.
+     */
+    capsules: Capsule[]);
+    static get schema(): ZodFor<TxExecutionRequest>;
+    toTxRequest(): TxRequest;
+    static getFields(fields: FieldsOf<TxExecutionRequest>): readonly [AztecAddress, FunctionSelector, Fr, TxContext, HashedValues[], AuthWitness[], Capsule[]];
+    static from(fields: FieldsOf<TxExecutionRequest>): TxExecutionRequest;
+    /**
+     * Serialize as a buffer.
+     * @returns The buffer.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Serialize as a string.
+     * @returns The string.
+     */
+    toString(): `0x${string}`;
+    /**
+     * Deserializes from a buffer or reader, corresponding to a write in cpp.
+     * @param buffer - Buffer to read from.
+     * @returns The deserialized TxRequest object.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): TxExecutionRequest;
+    /**
+     * Deserializes from a string, corresponding to a write in cpp.
+     * @param str - String to read from.
+     * @returns The deserialized TxRequest object.
+     */
+    static fromString(str: string): TxExecutionRequest;
+    static random(): Promise<TxExecutionRequest>;
+    [inspect.custom](): string;
+}
+//# sourceMappingURL=tx_execution_request.d.ts.map

package/dest/tx/tx_execution_request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx_execution_request.d.ts","sourceRoot":"","sources":["../../src/tx/tx_execution_request.ts"],"names":[],"mappings":";;;AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAG/B,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;GAEG;AACH,qBAAa,kBAAkB;IAE3B;;OAEG;IACI,MAAM,EAAE,YAAY;IAC3B;;OAEG;IACI,gBAAgB,EAAE,gBAAgB;IACzC;;;OAGG;IACI,iBAAiB,EAAE,EAAE;IAC5B;;OAEG;IACI,SAAS,EAAE,SAAS;IAC3B;;;;OAIG;IACI,WAAW,EAAE,YAAY,EAAE;IAClC;;;OAGG;IACI,aAAa,EAAE,WAAW,EAAE;IACnC;;OAEG;IACI,QAAQ,EAAE,OAAO,EAAE;;IA/B1B;;OAEG;IACI,MAAM,EAAE,YAAY;IAC3B;;OAEG;IACI,gBAAgB,EAAE,gBAAgB;IACzC;;;OAGG;IACI,iBAAiB,EAAE,EAAE;IAC5B;;OAEG;IACI,SAAS,EAAE,SAAS;IAC3B;;;;OAIG;IACI,WAAW,EAAE,YAAY,EAAE;IAClC;;;OAGG;IACI,aAAa,EAAE,WAAW,EAAE;IACnC;;OAEG;IACI,QAAQ,EAAE,OAAO,EAAE;IAG5B,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,kBAAkB,CAAC,CAY9C;IAED,WAAW,IAAI,SAAS;IAUxB,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,kBAAkB,CAAC;IAYrD,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,kBAAkB,CAAC,GAAG,kBAAkB;IAIrE;;;OAGG;IACH,QAAQ;IAYR;;;OAGG;IACH,QAAQ;IAIR;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,kBAAkB;IAapE;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB;WAIrC,MAAM;IAenB,CAAC,OAAO,CAAC,MAAM,CAAC;CAGjB"}

package/dest/tx/tx_execution_request.js

@@ -0,0 +1,127 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import { inspect } from 'util';
+import { z } from 'zod';
+import { FunctionSelector } from '../abi/function_selector.js';
+import { AuthWitness } from '../auth_witness/auth_witness.js';
+import { AztecAddress } from '../aztec-address/index.js';
+import { schemas } from '../schemas/index.js';
+import { Vector } from '../types/shared.js';
+import { Capsule } from './capsule.js';
+import { FunctionData } from './function_data.js';
+import { HashedValues } from './hashed_values.js';
+import { TxContext } from './tx_context.js';
+import { TxRequest } from './tx_request.js';
+/**
+ * Request to execute a transaction. Similar to TxRequest, but has the full args.
+ */ export class TxExecutionRequest {
+    origin;
+    functionSelector;
+    firstCallArgsHash;
+    txContext;
+    argsOfCalls;
+    authWitnesses;
+    capsules;
+    constructor(/**
+     * Sender.
+     */ origin, /**
+     * Selector of the function to call.
+     */ functionSelector, /**
+     * The hash of arguments of first call to be executed (usually account entrypoint).
+     * @dev This hash is a pointer to `argsOfCalls` unordered array.
+     */ firstCallArgsHash, /**
+     * Transaction context.
+     */ txContext, /**
+     * An unordered array of packed arguments for each call in the transaction.
+     * @dev These arguments are accessed in Noir via oracle and constrained against the args hash. The length of
+     * the array is equal to the number of function calls in the transaction (1 args per 1 call).
+     */ argsOfCalls, /**
+     * Transient authorization witnesses for authorizing the execution of one or more actions during this tx.
+     * These witnesses are not expected to be stored in the local witnesses database of the PXE.
+     */ authWitnesses, /**
+     * Read-only data passed through the oracle calls during this tx execution.
+     */ capsules){
+        this.origin = origin;
+        this.functionSelector = functionSelector;
+        this.firstCallArgsHash = firstCallArgsHash;
+        this.txContext = txContext;
+        this.argsOfCalls = argsOfCalls;
+        this.authWitnesses = authWitnesses;
+        this.capsules = capsules;
+    }
+    static get schema() {
+        return z.object({
+            origin: schemas.AztecAddress,
+            functionSelector: schemas.FunctionSelector,
+            firstCallArgsHash: schemas.Fr,
+            txContext: TxContext.schema,
+            argsOfCalls: z.array(HashedValues.schema),
+            authWitnesses: z.array(AuthWitness.schema),
+            capsules: z.array(Capsule.schema)
+        }).transform(TxExecutionRequest.from);
+    }
+    toTxRequest() {
+        return new TxRequest(this.origin, // Entrypoints must be private as as defined by the protocol.
+        new FunctionData(this.functionSelector, true), this.firstCallArgsHash, this.txContext);
+    }
+    static getFields(fields) {
+        return [
+            fields.origin,
+            fields.functionSelector,
+            fields.firstCallArgsHash,
+            fields.txContext,
+            fields.argsOfCalls,
+            fields.authWitnesses,
+            fields.capsules
+        ];
+    }
+    static from(fields) {
+        return new TxExecutionRequest(...TxExecutionRequest.getFields(fields));
+    }
+    /**
+   * Serialize as a buffer.
+   * @returns The buffer.
+   */ toBuffer() {
+        return serializeToBuffer(this.origin, this.functionSelector, this.firstCallArgsHash, this.txContext, new Vector(this.argsOfCalls), new Vector(this.authWitnesses), new Vector(this.capsules));
+    }
+    /**
+   * Serialize as a string.
+   * @returns The string.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    /**
+   * Deserializes from a buffer or reader, corresponding to a write in cpp.
+   * @param buffer - Buffer to read from.
+   * @returns The deserialized TxRequest object.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new TxExecutionRequest(reader.readObject(AztecAddress), reader.readObject(FunctionSelector), Fr.fromBuffer(reader), reader.readObject(TxContext), reader.readVector(HashedValues), reader.readVector(AuthWitness), reader.readVector(Capsule));
+    }
+    /**
+   * Deserializes from a string, corresponding to a write in cpp.
+   * @param str - String to read from.
+   * @returns The deserialized TxRequest object.
+   */ static fromString(str) {
+        return TxExecutionRequest.fromBuffer(hexToBuffer(str));
+    }
+    static async random() {
+        return new TxExecutionRequest(await AztecAddress.random(), FunctionSelector.random(), Fr.random(), TxContext.empty(), [
+            await HashedValues.random()
+        ], [
+            AuthWitness.random()
+        ], [
+            new Capsule(await AztecAddress.random(), Fr.random(), [
+                Fr.random(),
+                Fr.random()
+            ]),
+            new Capsule(await AztecAddress.random(), Fr.random(), [
+                Fr.random()
+            ])
+        ]);
+    }
+    [inspect.custom]() {
+        return `TxExecutionRequest(${this.origin} called ${this.functionSelector})`;
+    }
+}