@aztec/stdlib 0.77.0-testnet-ignition.17

package/dest/avm/revert_code.d.ts

@@ -0,0 +1,49 @@
+/// <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, FieldReader } from '@aztec/foundation/serialize';
+import { inspect } from 'util';
+import { z } from 'zod';
+export declare enum RevertCodeEnum {
+    OK = 0,
+    APP_LOGIC_REVERTED = 1,
+    TEARDOWN_REVERTED = 2,
+    BOTH_REVERTED = 3
+}
+/**
+ * Wrapper class over a field to safely represent a revert code.
+ */
+export declare class RevertCode {
+    private code;
+    private constructor();
+    static readonly OK: RevertCode;
+    static readonly APP_LOGIC_REVERTED: RevertCode;
+    static readonly TEARDOWN_REVERTED: RevertCode;
+    static readonly BOTH_REVERTED: RevertCode;
+    getCode(): RevertCodeEnum;
+    equals(other: RevertCode): boolean;
+    isOK(): boolean;
+    getDescription(): string;
+    toJSON(): number;
+    static get schema(): z.ZodEffects<z.ZodNativeEnum<typeof RevertCodeEnum>, RevertCode, RevertCodeEnum>;
+    /**
+     * Having different serialization methods allows for
+     * decoupling the serialization for producing the content commitment hash
+     * (where we use fields)
+     * from serialization for transmitting the data.
+     */
+    private static readonly PREIMAGE_SIZE_IN_BYTES;
+    toHashPreimage(): Buffer;
+    private static readonly PACKED_SIZE_IN_BYTES;
+    toBuffer(): Buffer;
+    toField(): Fr;
+    getSerializedLength(): number;
+    static fromField(fr: Fr): RevertCode;
+    static fromFields(fields: Fr[] | FieldReader): RevertCode;
+    static fromBuffer(buffer: Buffer | BufferReader): RevertCode;
+    private static readonly NUM_OPTIONS;
+    static random(): RevertCode;
+    [inspect.custom](): string;
+}
+//# sourceMappingURL=revert_code.d.ts.map

package/dest/avm/revert_code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revert_code.d.ts","sourceRoot":"","sources":["../../src/avm/revert_code.ts"],"names":[],"mappings":";;;AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAExE,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,oBAAY,cAAc;IACxB,EAAE,IAAI;IACN,kBAAkB,IAAI;IACtB,iBAAiB,IAAI;IACrB,aAAa,IAAI;CAClB;AAWD;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO;IAGP,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAqC;IACnE,MAAM,CAAC,QAAQ,CAAC,kBAAkB,EAAE,UAAU,CAAqD;IACnG,MAAM,CAAC,QAAQ,CAAC,iBAAiB,EAAE,UAAU,CAAoD;IACjG,MAAM,CAAC,QAAQ,CAAC,aAAa,EAAE,UAAU,CAAgD;IAElF,OAAO,IAAI,cAAc;IAIzB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IAIlC,IAAI,IAAI,OAAO;IAIf,cAAc;IAed,MAAM;IAIb,MAAM,KAAK,MAAM,qFAEhB;IAED;;;;;OAKG;IAEH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAM;IAC7C,cAAc,IAAI,MAAM;IAK/B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,oBAAoB,CAAK;IAC1C,QAAQ,IAAI,MAAM;IAMlB,OAAO,IAAI,EAAE;IAIb,mBAAmB,IAAI,MAAM;WAItB,SAAS,CAAC,EAAE,EAAE,EAAE,GAAG,UAAU;WAO7B,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,UAAU;WAKlD,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,UAAU;IASnE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAK;IACxC,MAAM,CAAC,MAAM,IAAI,UAAU;IAI3B,CAAC,OAAO,CAAC,MAAM,CAAC;CAGjB"}

package/dest/avm/revert_code.js

@@ -0,0 +1,105 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+import { inspect } from 'util';
+import { z } from 'zod';
+export var RevertCodeEnum = /*#__PURE__*/ function(RevertCodeEnum) {
+    RevertCodeEnum[RevertCodeEnum["OK"] = 0] = "OK";
+    RevertCodeEnum[RevertCodeEnum["APP_LOGIC_REVERTED"] = 1] = "APP_LOGIC_REVERTED";
+    RevertCodeEnum[RevertCodeEnum["TEARDOWN_REVERTED"] = 2] = "TEARDOWN_REVERTED";
+    RevertCodeEnum[RevertCodeEnum["BOTH_REVERTED"] = 3] = "BOTH_REVERTED";
+    return RevertCodeEnum;
+}({});
+function isRevertCodeEnum(value) {
+    return value === 0 || value === 1 || value === 2 || value === 3;
+}
+/**
+ * Wrapper class over a field to safely represent a revert code.
+ */ export class RevertCode {
+    code;
+    constructor(e){
+        this.code = e.valueOf();
+    }
+    static OK = new RevertCode(0);
+    static APP_LOGIC_REVERTED = new RevertCode(1);
+    static TEARDOWN_REVERTED = new RevertCode(2);
+    static BOTH_REVERTED = new RevertCode(3);
+    getCode() {
+        return this.code;
+    }
+    equals(other) {
+        return this.code === other.code;
+    }
+    isOK() {
+        return this.equals(RevertCode.OK);
+    }
+    getDescription() {
+        switch(this.code){
+            case 0:
+                return 'OK';
+            case 1:
+                return 'Application logic reverted';
+            case 2:
+                return 'Teardown reverted';
+            case 3:
+                return 'Both reverted';
+            default:
+                return `Unknown RevertCode: ${this.code}`;
+        }
+    }
+    toJSON() {
+        return this.code;
+    }
+    static get schema() {
+        return z.nativeEnum(RevertCodeEnum).transform((value)=>new RevertCode(value));
+    }
+    /**
+   * Having different serialization methods allows for
+   * decoupling the serialization for producing the content commitment hash
+   * (where we use fields)
+   * from serialization for transmitting the data.
+   */ static PREIMAGE_SIZE_IN_BYTES = 32;
+    toHashPreimage() {
+        const padding = Buffer.alloc(RevertCode.PREIMAGE_SIZE_IN_BYTES - RevertCode.PACKED_SIZE_IN_BYTES);
+        return Buffer.concat([
+            padding,
+            this.toBuffer()
+        ]);
+    }
+    static PACKED_SIZE_IN_BYTES = 1;
+    toBuffer() {
+        const b = Buffer.alloc(RevertCode.PACKED_SIZE_IN_BYTES);
+        b.writeUInt8(this.code, 0);
+        return b;
+    }
+    toField() {
+        return new Fr(this.toBuffer());
+    }
+    getSerializedLength() {
+        return this.toBuffer().length;
+    }
+    static fromField(fr) {
+        if (!isRevertCodeEnum(fr.toNumber())) {
+            throw new Error(`Invalid RevertCode: ${fr.toNumber()}`);
+        }
+        return new RevertCode(fr.toNumber());
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return RevertCode.fromField(reader.readField());
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const code = reader.readBytes(RevertCode.PACKED_SIZE_IN_BYTES).readUInt8(0);
+        if (!isRevertCodeEnum(code)) {
+            throw new Error(`Invalid RevertCode: ${code}`);
+        }
+        return new RevertCode(code);
+    }
+    static NUM_OPTIONS = 4;
+    static random() {
+        return new RevertCode(Math.floor(Math.random() * RevertCode.NUM_OPTIONS));
+    }
+    [inspect.custom]() {
+        return `RevertCode<${this.code.toString()}>`;
+    }
+}

package/dest/aztec-address/index.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr, Point } from '@aztec/foundation/fields';
+import { type ZodFor } from '@aztec/foundation/schemas';
+import { type BufferReader, FieldReader } from '@aztec/foundation/serialize';
+import { inspect } from 'util';
+/** Branding to ensure fields are not interchangeable types. */
+export interface AztecAddress {
+    /** Brand. */
+    _branding: 'AztecAddress';
+}
+/**
+ * AztecAddress represents a 32-byte address in the Aztec Protocol. It provides methods to create, manipulate, and
+ * compare addresses, as well as conversion to and from strings, buffers, and other formats.
+ * Addresses are the x coordinate of a point in the Grumpkin curve, and therefore their maximum is determined by the
+ * field modulus. An address with a value that is not the x coordinate of a point in the curve is a called an 'invalid
+ * address'. These addresses have a greatly reduced feature set, as they cannot own secrets nor have messages encrypted
+ * to them, making them quite useless. We need to be able to represent them however as they can be encountered in the
+ * wild.
+ */
+export declare class AztecAddress {
+    private xCoord;
+    constructor(buffer: Buffer | Fr);
+    [inspect.custom](): string;
+    static isAddress(str: string): boolean;
+    static SIZE_IN_BYTES: number;
+    static ZERO: AztecAddress;
+    static zero(): AztecAddress;
+    static fromField(fr: Fr): AztecAddress;
+    static fromBuffer(buffer: Buffer | BufferReader): AztecAddress;
+    static fromFields(fields: Fr[] | FieldReader): AztecAddress;
+    static fromBigInt(value: bigint): AztecAddress;
+    static fromNumber(value: number): AztecAddress;
+    static fromString(buf: string): AztecAddress;
+    /**
+     * @returns a random valid address (i.e. one that can be encrypted to).
+     */
+    static random(): Promise<AztecAddress>;
+    get size(): number;
+    equals(other: AztecAddress): boolean;
+    isZero(): boolean;
+    /**
+     * @returns true if the address is valid. Invalid addresses cannot receive encrypted messages.
+     */
+    isValid(): Promise<boolean>;
+    /**
+     * @returns the Point from which the address is derived. Throws if the address is invalid.
+     */
+    toAddressPoint(): Promise<Point>;
+    toBuffer(): Buffer;
+    toBigInt(): bigint;
+    toField(): Fr;
+    toString(): `0x${string}`;
+    toJSON(): `0x${string}`;
+    static get schema(): ZodFor<AztecAddress>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dest/aztec-address/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/aztec-address/index.ts"],"names":[],"mappings":";;;AACA,OAAO,EAAE,EAAE,EAAE,KAAK,EAAc,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,2BAA2B,CAAC;AACtE,OAAO,EAAE,KAAK,YAAY,EAAE,WAAW,EAAgB,MAAM,6BAA6B,CAAC;AAG3F,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAE/B,+DAA+D;AAC/D,MAAM,WAAW,YAAY;IAC3B,aAAa;IACb,SAAS,EAAE,cAAc,CAAC;CAC3B;AACD;;;;;;;;GAQG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAK;gBAEP,MAAM,EAAE,MAAM,GAAG,EAAE;IAO/B,CAAC,OAAO,CAAC,MAAM,CAAC;IAIhB,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM;IAI5B,MAAM,CAAC,aAAa,SAAoB;IAExC,MAAM,CAAC,IAAI,eAAyC;IAEpD,MAAM,CAAC,IAAI,IAAI,YAAY;IAI3B,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE;IAIvB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAI/C,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;IAK5C,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,MAAM;IAI/B,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,MAAM;IAI/B,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM;IAI7B;;OAEG;WACU,MAAM;IAUnB,IAAI,IAAI,WAEP;IAED,MAAM,CAAC,KAAK,EAAE,YAAY;IAI1B,MAAM;IAIN;;OAEG;IACG,OAAO;IAUb;;OAEG;IACH,cAAc,IAAI,OAAO,CAAC,KAAK,CAAC;IAIhC,QAAQ;IAIR,QAAQ;IAIR,OAAO;IAIP,QAAQ;IAIR,MAAM;IAIN,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,YAAY,CAAC,CAExC;CACF"}

package/dest/aztec-address/index.js

@@ -0,0 +1,108 @@
+/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */ import { Fr, Point, fromBuffer } from '@aztec/foundation/fields';
+import { hexSchemaFor } from '@aztec/foundation/schemas';
+import { FieldReader, TypeRegistry } from '@aztec/foundation/serialize';
+import { hexToBuffer } from '@aztec/foundation/string';
+import { inspect } from 'util';
+/**
+ * AztecAddress represents a 32-byte address in the Aztec Protocol. It provides methods to create, manipulate, and
+ * compare addresses, as well as conversion to and from strings, buffers, and other formats.
+ * Addresses are the x coordinate of a point in the Grumpkin curve, and therefore their maximum is determined by the
+ * field modulus. An address with a value that is not the x coordinate of a point in the curve is a called an 'invalid
+ * address'. These addresses have a greatly reduced feature set, as they cannot own secrets nor have messages encrypted
+ * to them, making them quite useless. We need to be able to represent them however as they can be encountered in the
+ * wild.
+ */ export class AztecAddress {
+    xCoord;
+    constructor(buffer){
+        if ('length' in buffer && buffer.length !== 32) {
+            throw new Error(`Invalid AztecAddress length ${buffer.length}.`);
+        }
+        this.xCoord = new Fr(buffer);
+    }
+    [inspect.custom]() {
+        return `AztecAddress<${this.toString()}>`;
+    }
+    static isAddress(str) {
+        return /^(0x)?[a-fA-F0-9]{64}$/.test(str);
+    }
+    static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES;
+    static ZERO = new AztecAddress(Buffer.alloc(32, 0));
+    static zero() {
+        return AztecAddress.ZERO;
+    }
+    static fromField(fr) {
+        return new AztecAddress(fr);
+    }
+    static fromBuffer(buffer) {
+        return new AztecAddress(fromBuffer(buffer, Fr));
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new AztecAddress(reader.readField());
+    }
+    static fromBigInt(value) {
+        return new AztecAddress(new Fr(value));
+    }
+    static fromNumber(value) {
+        return new AztecAddress(new Fr(value));
+    }
+    static fromString(buf) {
+        return new AztecAddress(hexToBuffer(buf));
+    }
+    /**
+   * @returns a random valid address (i.e. one that can be encrypted to).
+   */ static async random() {
+        // About half of random field elements result in invalid addresses, so we loop until we get a valid one.
+        while(true){
+            const candidate = new AztecAddress(Fr.random());
+            if (await candidate.isValid()) {
+                return candidate;
+            }
+        }
+    }
+    get size() {
+        return this.xCoord.size;
+    }
+    equals(other) {
+        return this.xCoord.equals(other.xCoord);
+    }
+    isZero() {
+        return this.xCoord.isZero();
+    }
+    /**
+   * @returns true if the address is valid. Invalid addresses cannot receive encrypted messages.
+   */ async isValid() {
+        // An address is a field value (Fr), which for some purposes is assumed to be the x coordinate of a point in the
+        // Grumpkin curve (notably in order to encrypt to it). An address that is not the x coordinate of such a point is
+        // called an 'invalid' address.
+        //
+        // For Grumpkin, y^2 = x^3 − 17 . There exist values x ∈ Fr for which no y satisfies this equation. This means that
+        // given such an x and t = x^3 − 17, then sqrt(t) does not exist in Fr.
+        return await Point.YFromX(this.xCoord) !== null;
+    }
+    /**
+   * @returns the Point from which the address is derived. Throws if the address is invalid.
+   */ toAddressPoint() {
+        return Point.fromXAndSign(this.xCoord, true);
+    }
+    toBuffer() {
+        return this.xCoord.toBuffer();
+    }
+    toBigInt() {
+        return this.xCoord.toBigInt();
+    }
+    toField() {
+        return this.xCoord;
+    }
+    toString() {
+        return this.xCoord.toString();
+    }
+    toJSON() {
+        return this.toString();
+    }
+    static get schema() {
+        return hexSchemaFor(AztecAddress, AztecAddress.isAddress);
+    }
+}
+// For deserializing JSON.
+TypeRegistry.register('AztecAddress', AztecAddress);

package/dest/block/block_hash.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { Fr } from '@aztec/foundation/fields';
+/** Hash of an L2 block. */
+export declare class L2BlockHash extends Buffer32 {
+    constructor(
+    /** The buffer containing the hash. */
+    hash: Buffer);
+    static random(): L2BlockHash;
+    static get schema(): import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>, Buffer, string>, L2BlockHash, string>;
+    static zero(): L2BlockHash;
+    static fromField(hash: Fr): L2BlockHash;
+}
+//# sourceMappingURL=block_hash.d.ts.map

package/dest/block/block_hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_hash.d.ts","sourceRoot":"","sources":["../../src/block/block_hash.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAI9C,2BAA2B;AAC3B,qBAAa,WAAY,SAAQ,QAAQ;;IAErC,sCAAsC;IACtC,IAAI,EAAE,MAAM;WAKE,MAAM;IAItB,MAAM,KAAK,MAAM,yMAEhB;IAED,MAAM,CAAC,IAAI;WAIK,SAAS,CAAC,IAAI,EAAE,EAAE;CAGnC"}

package/dest/block/block_hash.js

@@ -0,0 +1,20 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '../schemas/schemas.js';
+/** Hash of an L2 block. */ export class L2BlockHash extends Buffer32 {
+    constructor(/** The buffer containing the hash. */ hash){
+        super(hash);
+    }
+    static random() {
+        return new L2BlockHash(Fr.random().toBuffer());
+    }
+    static get schema() {
+        return schemas.BufferHex.transform((value)=>new L2BlockHash(value));
+    }
+    static zero() {
+        return new L2BlockHash(Buffer32.ZERO.toBuffer());
+    }
+    static fromField(hash) {
+        return new L2BlockHash(hash.toBuffer());
+    }
+}

package/dest/block/body.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { inspect } from 'util';
+import type { ZodFor } from '../schemas/index.js';
+import { TxEffect } from '../tx/tx_effect.js';
+export declare class Body {
+    txEffects: TxEffect[];
+    constructor(txEffects: TxEffect[]);
+    static get schema(): ZodFor<Body>;
+    /**
+     * Serializes a block body
+     * @returns A serialized L2 block body.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Deserializes a block from a buffer
+     * @returns A deserialized L2 block.
+     */
+    static fromBuffer(buf: Buffer | BufferReader): Body;
+    /**
+     * Returns a flat packed array of fields of all tx effects - used for blobs.
+     */
+    toBlobFields(): Fr[];
+    /**
+     * Decodes a block from blob fields.
+     */
+    static fromBlobFields(fields: Fr[]): Body;
+    [inspect.custom](): string;
+    static random(txsPerBlock?: number, numPublicCallsPerTx?: number, numPublicLogsPerCall?: number): Promise<Body>;
+    static empty(): Body;
+}
+//# sourceMappingURL=body.d.ts.map

package/dest/block/body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"body.d.ts","sourceRoot":"","sources":["../../src/block/body.ts"],"names":[],"mappings":";;;AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAG/B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAE9C,qBAAa,IAAI;IACI,SAAS,EAAE,QAAQ,EAAE;gBAArB,SAAS,EAAE,QAAQ,EAAE;IAQxC,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,IAAI,CAAC,CAMhC;IAED;;;OAGG;IACH,QAAQ;IAIR;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY;IAM5C;;OAEG;IACH,YAAY;IAgBZ;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE;IAelC,CAAC,OAAO,CAAC,MAAM,CAAC;WAMH,MAAM,CAAC,WAAW,SAAI,EAAE,mBAAmB,SAAI,EAAE,oBAAoB,SAAI;IAQtF,MAAM,CAAC,KAAK;CAGb"}

package/dest/block/body.js

@@ -0,0 +1,75 @@
+import { BLOBS_PER_BLOCK, FIELDS_PER_BLOB } from '@aztec/constants';
+import { timesParallel } from '@aztec/foundation/collection';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { inspect } from 'util';
+import { z } from 'zod';
+import { TxEffect } from '../tx/tx_effect.js';
+export class Body {
+    txEffects;
+    constructor(txEffects){
+        this.txEffects = txEffects;
+        txEffects.forEach((txEffect)=>{
+            if (txEffect.isEmpty()) {
+                throw new Error('Empty tx effect not allowed in Body');
+            }
+        });
+    }
+    static get schema() {
+        return z.object({
+            txEffects: z.array(TxEffect.schema)
+        }).transform(({ txEffects })=>new Body(txEffects));
+    }
+    /**
+   * Serializes a block body
+   * @returns A serialized L2 block body.
+   */ toBuffer() {
+        return serializeToBuffer(this.txEffects.length, this.txEffects);
+    }
+    /**
+   * Deserializes a block from a buffer
+   * @returns A deserialized L2 block.
+   */ static fromBuffer(buf) {
+        const reader = BufferReader.asReader(buf);
+        return new this(reader.readVector(TxEffect));
+    }
+    /**
+   * Returns a flat packed array of fields of all tx effects - used for blobs.
+   */ toBlobFields() {
+        let flattened = [];
+        this.txEffects.forEach((effect)=>{
+            flattened = flattened.concat(effect.toBlobFields());
+        });
+        if (flattened.length > BLOBS_PER_BLOCK * FIELDS_PER_BLOB) {
+            throw new Error(`Attempted to overfill block's blobs with ${flattened.length} elements. The maximum is ${BLOBS_PER_BLOCK * FIELDS_PER_BLOB}`);
+        }
+        return flattened;
+    }
+    /**
+   * Decodes a block from blob fields.
+   */ static fromBlobFields(fields) {
+        const txEffectsFields = [];
+        let checkedFields = 0;
+        while(checkedFields !== fields.length){
+            if (!TxEffect.isFirstField(fields[checkedFields])) {
+                throw new Error('Invalid fields given to Body.fromBlobFields(): First field invalid.');
+            }
+            const len = TxEffect.decodeFirstField(fields[checkedFields]).length;
+            txEffectsFields.push(fields.slice(checkedFields, checkedFields + len));
+            checkedFields += len;
+        }
+        const txEffects = txEffectsFields.filter((effect)=>effect.length).map((effect)=>TxEffect.fromBlobFields(effect));
+        return new this(txEffects);
+    }
+    [inspect.custom]() {
+        return `Body {
+  txEffects: ${inspect(this.txEffects)},
+}`;
+    }
+    static async random(txsPerBlock = 4, numPublicCallsPerTx = 3, numPublicLogsPerCall = 1) {
+        const txEffects = await timesParallel(txsPerBlock, ()=>TxEffect.random(numPublicCallsPerTx, numPublicLogsPerCall));
+        return new Body(txEffects);
+    }
+    static empty() {
+        return new Body([]);
+    }
+}

package/dest/block/in_block.d.ts

@@ -0,0 +1,31 @@
+import { type ZodTypeAny, z } from 'zod';
+import type { L2Block } from './l2_block.js';
+export type InBlock<T> = {
+    l2BlockNumber: number;
+    l2BlockHash: string;
+    data: T;
+};
+export declare function randomInBlock<T>(data: T): InBlock<T>;
+export declare function wrapInBlock<T>(data: T, block: L2Block): Promise<InBlock<T>>;
+export declare function inBlockSchemaFor<T extends ZodTypeAny>(schema: T): z.ZodObject<{
+    data: T;
+    l2BlockNumber: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+    l2BlockHash: z.ZodString;
+}, "strip", ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    data: T;
+    l2BlockNumber: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+    l2BlockHash: z.ZodString;
+}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    data: T;
+    l2BlockNumber: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+    l2BlockHash: z.ZodString;
+}>, any>[k]; }, { [k_1 in keyof z.baseObjectInputType<{
+    data: T;
+    l2BlockNumber: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+    l2BlockHash: z.ZodString;
+}>]: z.baseObjectInputType<{
+    data: T;
+    l2BlockNumber: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+    l2BlockHash: z.ZodString;
+}>[k_1]; }>;
+//# sourceMappingURL=in_block.d.ts.map

package/dest/block/in_block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in_block.d.ts","sourceRoot":"","sources":["../../src/block/in_block.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,UAAU,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,CAAC,CAAC;CACT,CAAC;AAEF,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAMpD;AAED,wBAAsB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAMjF;AAED,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,UAAU,EAAE,MAAM,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;YAM/D"}

package/dest/block/in_block.js

@@ -0,0 +1,24 @@
+import { Fr } from '@aztec/foundation/fields';
+import { z } from 'zod';
+import { schemas } from '../schemas/index.js';
+export function randomInBlock(data) {
+    return {
+        data,
+        l2BlockNumber: Math.floor(Math.random() * 1000),
+        l2BlockHash: Fr.random().toString()
+    };
+}
+export async function wrapInBlock(data, block) {
+    return {
+        data,
+        l2BlockNumber: block.number,
+        l2BlockHash: (await block.hash()).toString()
+    };
+}
+export function inBlockSchemaFor(schema) {
+    return z.object({
+        data: schema,
+        l2BlockNumber: schemas.Integer,
+        l2BlockHash: z.string()
+    });
+}

package/dest/block/index.d.ts

@@ -0,0 +1,9 @@
+export * from './l2_block.js';
+export * from './l2_block_downloader/index.js';
+export * from './nullifier_with_block_source.js';
+export * from './in_block.js';
+export * from './body.js';
+export * from './l2_block_number.js';
+export * from './l2_block_source.js';
+export * from './block_hash.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/block/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/block/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC"}

package/dest/block/index.js

@@ -0,0 +1,8 @@
+export * from './l2_block.js';
+export * from './l2_block_downloader/index.js';
+export * from './nullifier_with_block_source.js';
+export * from './in_block.js';
+export * from './body.js';
+export * from './l2_block_number.js';
+export * from './l2_block_source.js';
+export * from './block_hash.js';