@aztec-labs/stdlib 6.0.0-nightly.20260829

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

@@ -0,0 +1 @@
+{"version":3,"file":"avm_proving_request.d.ts","sourceRoot":"","sources":["../../src/avm/avm_proving_request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE5C,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGlC,CAAC"}

package/dest/avm/avm_proving_request.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { ProvingRequestType } from '../proofs/proving_request_type.js';
+import { AvmCircuitInputs } from './avm.js';
+export const AvmProvingRequestSchema = z.object({
+    type: z.literal(ProvingRequestType.PUBLIC_VM),
+    inputs: AvmCircuitInputs.schema
+});

package/dest/avm/index.d.ts

@@ -0,0 +1,8 @@
+export * from './avm.js';
+export * from './avm_accumulated_data.js';
+export * from './avm_circuit_public_inputs.js';
+export * from './revert_code.js';
+export * from './public_data_write.js';
+export * from './avm_proving_request.js';
+export * from './message_pack.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hdm0vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsbUJBQW1CLENBQUMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/avm/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC"}

package/dest/avm/index.js

@@ -0,0 +1,7 @@
+export * from './avm.js';
+export * from './avm_accumulated_data.js';
+export * from './avm_circuit_public_inputs.js';
+export * from './revert_code.js';
+export * from './public_data_write.js';
+export * from './avm_proving_request.js';
+export * from './message_pack.js';

package/dest/avm/message_pack.d.ts

@@ -0,0 +1,3 @@
+export declare function serializeWithMessagePack(obj: any): Buffer;
+export declare function deserializeFromMessagePack(buffer: Buffer): any;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZV9wYWNrLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXZtL21lc3NhZ2VfcGFjay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFRQSx3QkFBZ0Isd0JBQXdCLENBQUMsR0FBRyxFQUFFLEdBQUcsR0FBRyxNQUFNLENBVXpEO0FBS0Qsd0JBQWdCLDBCQUEwQixDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsR0FBRyxDQVE5RCJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"message_pack.d.ts","sourceRoot":"","sources":["../../src/avm/message_pack.ts"],"names":[],"mappings":"AAQA,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAUzD;AAKD,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAQ9D"}

package/dest/avm/message_pack.js

@@ -0,0 +1,90 @@
+import { Fq, Fr } from '@aztec-labs/foundation/curves/bn254';
+import { Point } from '@aztec-labs/foundation/curves/grumpkin';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { strict as assert } from 'assert';
+import { Decoder, Encoder, addExtension } from 'msgpackr';
+import { AztecAddress } from '../aztec-address/index.js';
+export function serializeWithMessagePack(obj) {
+    setUpMessagePackExtensions();
+    const encoder = new Encoder({
+        // always encode JS objects as MessagePack maps
+        // this makes it compatible with other MessagePack decoders
+        useRecords: false,
+        int64AsType: 'bigint',
+        largeBigIntToString: true
+    });
+    return encoder.encode(obj);
+}
+// This deserializes into a JS object. If you want a specific
+// class, you need to use zod to parse it into the specific class.
+// You can use T.schema.parse() for that.
+export function deserializeFromMessagePack(buffer) {
+    setUpMessagePackExtensions();
+    const decoder = new Decoder({
+        useRecords: false,
+        int64AsType: 'bigint',
+        largeBigIntToString: true
+    });
+    return decoder.decode(buffer);
+}
+let messagePackWasSetUp = false;
+function setUpMessagePackExtensions() {
+    if (messagePackWasSetUp) {
+        return;
+    }
+    // C++ Fr and Fq classes work well with the buffer serialization.
+    addExtension({
+        Class: Fr,
+        write: (fr)=>fr.toBuffer(),
+        read: (data)=>Fr.fromBuffer(data)
+    });
+    addExtension({
+        Class: Fq,
+        write: (fq)=>fq.toBuffer(),
+        read: (data)=>Fq.fromBuffer(data)
+    });
+    // AztecAddress is a class that has a field in TS, but is itself a field in C++.
+    addExtension({
+        Class: AztecAddress,
+        write: (addr)=>addr.toField(),
+        read: (data)=>{
+            // If C++ sent it as Fr, wrap it. If as buffer, construct from buffer.
+            if (data instanceof Fr) {
+                return new AztecAddress(data);
+            }
+            return new AztecAddress(Fr.fromBuffer(data));
+        }
+    });
+    // Affine points are a mess, we do our best.
+    addExtension({
+        Class: Point,
+        write: (p)=>{
+            // TODO: Now that we use a 2 elt point representation, we should be able to handle infs here.
+            // However this opens possible bad paths with public keys and requires sanitised conversion between
+            // BB's inf representation (see below), and ours/Noir's (0, 0), and empty points from BB, when inf
+            // does not actually pass through.
+            assert(!p.isInfinite, 'Cannot serialize infinity');
+            return {
+                x: new Fq(p.x.toBigInt()),
+                y: new Fq(p.y.toBigInt())
+            };
+        },
+        read: (data)=>{
+            // Note: BB encodes infinity as x == y == Buffer of all ones.
+            // Infinity should never pass through here, but for correctness:
+            const ALL_ONES = (1n << 256n) - 1n;
+            if (data.x.toBigInt() === ALL_ONES && data.y.toBigInt() === ALL_ONES) {
+                return Point.INFINITY;
+            }
+            // Convert Fq back to Fr for Point constructor
+            return new Point(new Fr(data.x.toBigInt()), new Fr(data.y.toBigInt()));
+        }
+    });
+    // EthAddress is a class that has a buffer in TS, but is itself just a field in C++.
+    addExtension({
+        Class: EthAddress,
+        write: (addr)=>addr.toField().toBuffer(),
+        read: (data)=>EthAddress.fromField(Fr.fromBuffer(data))
+    });
+    messagePackWasSetUp = true;
+}

package/dest/avm/public_data_read.d.ts

@@ -0,0 +1,39 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, FieldReader } from '@aztec-labs/foundation/serialize';
+/**
+ * Read operations from the public state tree.
+ */
+export declare class PublicDataRead {
+    /**
+     * Index of the leaf in the public data tree.
+     */
+    readonly leafSlot: Fr;
+    /**
+     * Returned value from the public data tree.
+     */
+    readonly value: Fr;
+    /**
+     * Side effect counter tracking position of this event in tx execution.
+     */
+    readonly counter: number;
+    constructor(
+    /**
+     * Index of the leaf in the public data tree.
+     */
+    leafSlot: Fr, 
+    /**
+     * Returned value from the public data tree.
+     */
+    value: Fr, 
+    /**
+     * Side effect counter tracking position of this event in tx execution.
+     */
+    counter: number);
+    toBuffer(): Buffer<ArrayBufferLike>;
+    isEmpty(): boolean;
+    static fromFields(fields: Fr[] | FieldReader): PublicDataRead;
+    static fromBuffer(buffer: Buffer | BufferReader): PublicDataRead;
+    static empty(): PublicDataRead;
+    equals(other: PublicDataRead): boolean;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2RhdGFfcmVhZC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2F2bS9wdWJsaWNfZGF0YV9yZWFkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUN6RCxPQUFPLEVBQUUsWUFBWSxFQUFFLFdBQVcsRUFBcUIsTUFBTSxrQ0FBa0MsQ0FBQztBQUVoRzs7R0FFRztBQUNILHFCQUFhLGNBQWM7SUFFdkI7O09BRUc7YUFDYSxRQUFRLEVBQUUsRUFBRTtJQUM1Qjs7T0FFRzthQUNhLEtBQUssRUFBRSxFQUFFO0lBQ3pCOztPQUVHO2FBQ2EsT0FBTyxFQUFFLE1BQU07SUFaakM7SUFDRTs7T0FFRztJQUNhLFFBQVEsRUFBRSxFQUFFO0lBQzVCOztPQUVHO0lBQ2EsS0FBSyxFQUFFLEVBQUU7SUFDekI7O09BRUc7SUFDYSxPQUFPLEVBQUUsTUFBTSxFQUM3QjtJQUVKLFFBQVEsNEJBRVA7SUFFRCxPQUFPLFlBRU47SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxFQUFFLEVBQUUsR0FBRyxXQUFXLGtCQUczQztJQUVELE1BQU0sQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxZQUFZLGtCQUc5QztJQUVELE1BQU0sQ0FBQyxLQUFLLG1CQUVYO0lBRUQsTUFBTSxDQUFDLEtBQUssRUFBRSxjQUFjLFdBRTNCO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"public_data_read.d.ts","sourceRoot":"","sources":["../../src/avm/public_data_read.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,kCAAkC,CAAC;AAEhG;;GAEG;AACH,qBAAa,cAAc;IAEvB;;OAEG;aACa,QAAQ,EAAE,EAAE;IAC5B;;OAEG;aACa,KAAK,EAAE,EAAE;IACzB;;OAEG;aACa,OAAO,EAAE,MAAM;IAZjC;IACE;;OAEG;IACa,QAAQ,EAAE,EAAE;IAC5B;;OAEG;IACa,KAAK,EAAE,EAAE;IACzB;;OAEG;IACa,OAAO,EAAE,MAAM,EAC7B;IAEJ,QAAQ,4BAEP;IAED,OAAO,YAEN;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,kBAG3C;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,kBAG9C;IAED,MAAM,CAAC,KAAK,mBAEX;IAED,MAAM,CAAC,KAAK,EAAE,cAAc,WAE3B;CACF"}

package/dest/avm/public_data_read.js

@@ -0,0 +1,40 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+/**
+ * Read operations from the public state tree.
+ */ export class PublicDataRead {
+    leafSlot;
+    value;
+    counter;
+    constructor(/**
+     * Index of the leaf in the public data tree.
+     */ leafSlot, /**
+     * Returned value from the public data tree.
+     */ value, /**
+     * Side effect counter tracking position of this event in tx execution.
+     */ counter){
+        this.leafSlot = leafSlot;
+        this.value = value;
+        this.counter = counter;
+    }
+    toBuffer() {
+        return serializeToBuffer(this.leafSlot, this.value, this.counter);
+    }
+    isEmpty() {
+        return this.leafSlot.isZero() && this.value.isZero() && !this.counter;
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new PublicDataRead(reader.readField(), reader.readField(), reader.readU32());
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new PublicDataRead(Fr.fromBuffer(reader), Fr.fromBuffer(reader), reader.readNumber());
+    }
+    static empty() {
+        return new PublicDataRead(Fr.ZERO, Fr.ZERO, 0);
+    }
+    equals(other) {
+        return this.leafSlot.equals(other.leafSlot) && this.value.equals(other.value) && this.counter == other.counter;
+    }
+}

package/dest/avm/public_data_write.d.ts

@@ -0,0 +1,58 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, FieldReader } from '@aztec-labs/foundation/serialize';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+import { z } from 'zod';
+/**
+ * Write operations on the public state tree.
+ */
+export declare class PublicDataWrite {
+    /**
+     * The updated leaf.
+     */
+    readonly leafSlot: Fr;
+    /**
+     * New value of the leaf.
+     */
+    readonly value: Fr;
+    static SIZE_IN_BYTES: number;
+    constructor(
+    /**
+     * The updated leaf.
+     */
+    leafSlot: Fr, 
+    /**
+     * New value of the leaf.
+     */
+    value: Fr);
+    static get schema(): z.ZodPipe<z.ZodObject<{
+        leafSlot: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+        value: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
+    }, z.core.$strip>, z.ZodTransform<PublicDataWrite, {
+        leafSlot: Fr;
+        value: Fr;
+    }>>;
+    static from(fields: FieldsOf<PublicDataWrite>): PublicDataWrite;
+    static getFields(fields: FieldsOf<PublicDataWrite>): readonly [Fr, Fr];
+    static fromFields(fields: Fr[] | FieldReader): PublicDataWrite;
+    toFields(): Fr[];
+    static fromBlobFields(fields: Fr[] | FieldReader): PublicDataWrite;
+    toBlobFields(): [Fr, Fr];
+    static fromBuffer(buffer: Buffer | BufferReader): PublicDataWrite;
+    toBuffer(): Buffer<ArrayBufferLike>;
+    static fromString(str: string): PublicDataWrite;
+    toString(): `0x${string}`;
+    static empty(): PublicDataWrite;
+    /**
+     * Creates a PublicDataWrite instance from a plain object without Zod validation.
+     * This method is optimized for performance and skips validation, making it suitable
+     * for deserializing trusted data (e.g., from C++ via MessagePack).
+     * @param obj - Plain object containing PublicDataWrite fields
+     * @returns A PublicDataWrite instance
+     */
+    static fromPlainObject(obj: any): PublicDataWrite;
+    static random(): PublicDataWrite;
+    static isEmpty(data: PublicDataWrite): boolean;
+    isEmpty(): boolean;
+    equals(other: PublicDataWrite): boolean;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2RhdGFfd3JpdGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hdm0vcHVibGljX2RhdGFfd3JpdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBRXpELE9BQU8sRUFBRSxZQUFZLEVBQUUsV0FBVyxFQUF3QyxNQUFNLGtDQUFrQyxDQUFDO0FBRW5ILE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQzdELE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEI7O0dBRUc7QUFDSCxxQkFBYSxlQUFlO0lBSXhCOztPQUVHO2FBQ2EsUUFBUSxFQUFFLEVBQUU7SUFDNUI7O09BRUc7YUFDYSxLQUFLLEVBQUUsRUFBRTtJQVYzQixNQUFNLENBQUMsYUFBYSxTQUF3QjtJQUU1QztJQUNFOztPQUVHO0lBQ2EsUUFBUSxFQUFFLEVBQUU7SUFDNUI7O09BRUc7SUFDYSxLQUFLLEVBQUUsRUFBRSxFQUN2QjtJQUVKLE1BQU0sS0FBSyxNQUFNOzs7Ozs7UUFPaEI7SUFFRCxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsZUFBZSxDQUFDLG1CQUU1QztJQUVELE1BQU0sQ0FBQyxTQUFTLENBQUMsTUFBTSxFQUFFLFFBQVEsQ0FBQyxlQUFlLENBQUMscUJBRWpEO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsRUFBRSxFQUFFLEdBQUcsV0FBVyxHQUFHLGVBQWUsQ0FHN0Q7SUFFRCxRQUFRLElBQUksRUFBRSxFQUFFLENBUWY7SUFFRCxNQUFNLENBQUMsY0FBYyxDQUFDLE1BQU0sRUFBRSxFQUFFLEVBQUUsR0FBRyxXQUFXLG1CQUcvQztJQUVELFlBQVksSUFBSSxDQUFDLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FFdkI7SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsWUFBWSxtQkFHOUM7SUFFRCxRQUFRLDRCQUVQO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxHQUFHLEVBQUUsTUFBTSxtQkFFNUI7SUFFRCxRQUFRLGtCQUVQO0lBRUQsTUFBTSxDQUFDLEtBQUssb0JBRVg7SUFFRDs7Ozs7O09BTUc7SUFDSCxNQUFNLENBQUMsZUFBZSxDQUFDLEdBQUcsRUFBRSxHQUFHLEdBQUcsZUFBZSxDQUVoRDtJQUVELE1BQU0sQ0FBQyxNQUFNLG9CQUVaO0lBRUQsTUFBTSxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsZUFBZSxHQUFHLE9BQU8sQ0FFN0M7SUFFRCxPQUFPLFlBRU47SUFFRCxNQUFNLENBQUMsS0FBSyxFQUFFLGVBQWUsR0FBRyxPQUFPLENBRXRDO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"public_data_write.d.ts","sourceRoot":"","sources":["../../src/avm/public_data_write.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAwC,MAAM,kCAAkC,CAAC;AAEnH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,qBAAa,eAAe;IAIxB;;OAEG;aACa,QAAQ,EAAE,EAAE;IAC5B;;OAEG;aACa,KAAK,EAAE,EAAE;IAV3B,MAAM,CAAC,aAAa,SAAwB;IAE5C;IACE;;OAEG;IACa,QAAQ,EAAE,EAAE;IAC5B;;OAEG;IACa,KAAK,EAAE,EAAE,EACvB;IAEJ,MAAM,KAAK,MAAM;;;;;;QAOhB;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,mBAE5C;IAED,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,qBAEjD;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,eAAe,CAG7D;IAED,QAAQ,IAAI,EAAE,EAAE,CAQf;IAED,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,mBAG/C;IAED,YAAY,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAEvB;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,mBAG9C;IAED,QAAQ,4BAEP;IAED,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,mBAE5B;IAED,QAAQ,kBAEP;IAED,MAAM,CAAC,KAAK,oBAEX;IAED;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,eAAe,CAEhD;IAED,MAAM,CAAC,MAAM,oBAEZ;IAED,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAE7C;IAED,OAAO,YAEN;IAED,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAEtC;CACF"}

package/dest/avm/public_data_write.js

@@ -0,0 +1,94 @@
+import { PUBLIC_DATA_WRITE_LENGTH } from '@aztec-labs/constants';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { schemas } from '@aztec-labs/foundation/schemas';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec-labs/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec-labs/foundation/string';
+import { z } from 'zod';
+/**
+ * Write operations on the public state tree.
+ */ export class PublicDataWrite {
+    leafSlot;
+    value;
+    static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * 2;
+    constructor(/**
+     * The updated leaf.
+     */ leafSlot, /**
+     * New value of the leaf.
+     */ value){
+        this.leafSlot = leafSlot;
+        this.value = value;
+    }
+    static get schema() {
+        return z.object({
+            leafSlot: schemas.Fr,
+            value: schemas.Fr
+        }).transform(PublicDataWrite.from);
+    }
+    static from(fields) {
+        return new PublicDataWrite(...PublicDataWrite.getFields(fields));
+    }
+    static getFields(fields) {
+        return [
+            fields.leafSlot,
+            fields.value
+        ];
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new PublicDataWrite(reader.readField(), reader.readField());
+    }
+    toFields() {
+        const fields = serializeToFields(...PublicDataWrite.getFields(this));
+        if (fields.length !== PUBLIC_DATA_WRITE_LENGTH) {
+            throw new Error(`Invalid number of fields for PublicDataWrite. Expected ${PUBLIC_DATA_WRITE_LENGTH}, got ${fields.length}`);
+        }
+        return fields;
+    }
+    static fromBlobFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new PublicDataWrite(reader.readField(), reader.readField());
+    }
+    toBlobFields() {
+        return [
+            this.leafSlot,
+            this.value
+        ];
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new PublicDataWrite(Fr.fromBuffer(reader), Fr.fromBuffer(reader));
+    }
+    toBuffer() {
+        return serializeToBuffer(...PublicDataWrite.getFields(this));
+    }
+    static fromString(str) {
+        return PublicDataWrite.fromBuffer(hexToBuffer(str));
+    }
+    toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    static empty() {
+        return new PublicDataWrite(Fr.ZERO, Fr.ZERO);
+    }
+    /**
+   * Creates a PublicDataWrite instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PublicDataWrite fields
+   * @returns A PublicDataWrite instance
+   */ static fromPlainObject(obj) {
+        return new PublicDataWrite(Fr.fromPlainObject(obj.leafSlot), Fr.fromPlainObject(obj.value));
+    }
+    static random() {
+        return new PublicDataWrite(Fr.random(), Fr.random());
+    }
+    static isEmpty(data) {
+        return data.isEmpty();
+    }
+    isEmpty() {
+        return this.leafSlot.isZero() && this.value.isZero();
+    }
+    equals(other) {
+        return this.leafSlot.equals(other.leafSlot) && this.value.equals(other.value);
+    }
+}

package/dest/avm/revert_code.d.ts

@@ -0,0 +1,54 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { ZodFor } from '@aztec-labs/foundation/schemas';
+import { BufferReader, FieldReader } from '@aztec-labs/foundation/serialize';
+import { inspect } from 'util';
+/** Whether a transaction's public execution reverted. */
+export declare enum RevertCodeEnum {
+    /** All phases completed successfully; no state was rolled back. */
+    OK = 0,
+    /** One or more revertible phases reverted; their state changes were discarded. */
+    REVERTED = 1
+}
+/**
+ * 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 REVERTED: RevertCode;
+    getCode(): RevertCodeEnum;
+    equals(other: RevertCode): boolean;
+    isOK(): boolean;
+    getDescription(): string;
+    toJSON(): number;
+    static get schema(): ZodFor<RevertCode>;
+    /**
+     * Creates a RevertCode from a plain object without Zod validation.
+     * This method is optimized for performance and skips validation, making it suitable
+     * for deserializing trusted data (e.g., from C++ via MessagePack).
+     * @param obj - Plain object, number, or RevertCode instance
+     * @returns A RevertCode instance
+     */
+    static fromPlainObject(obj: any): RevertCode;
+    /**
+     * 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 fromNumber(code: number): RevertCode;
+    static fromField(field: 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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmV2ZXJ0X2NvZGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hdm0vcmV2ZXJ0X2NvZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQ3pELE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQzdELE9BQU8sRUFBRSxZQUFZLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDN0UsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUcvQix5REFBeUQ7QUFDekQsb0JBQVksY0FBYztJQUN4QixtRUFBbUU7SUFDbkUsRUFBRSxJQUFJO0lBQ04sa0ZBQWtGO0lBQ2xGLFFBQVEsSUFBSTtDQUNiO0FBT0Q7O0dBRUc7QUFDSCxxQkFBYSxVQUFVO0lBQ3JCLE9BQU8sQ0FBQyxJQUFJLENBQVM7SUFDckIsT0FBTyxlQUVOO0lBQ0QsTUFBTSxDQUFDLFFBQVEsQ0FBQyxFQUFFLEVBQUUsVUFBVSxDQUFxQztJQUNuRSxNQUFNLENBQUMsUUFBUSxDQUFDLFFBQVEsRUFBRSxVQUFVLENBQTJDO0lBRXhFLE9BQU8sSUFBSSxjQUFjLENBRS9CO0lBRU0sTUFBTSxDQUFDLEtBQUssRUFBRSxVQUFVLEdBQUcsT0FBTyxDQUV4QztJQUVNLElBQUksSUFBSSxPQUFPLENBRXJCO0lBRU0sY0FBYyxXQVNwQjtJQUVNLE1BQU0sV0FFWjtJQUVELE1BQU0sS0FBSyxNQUFNLElBQUksTUFBTSxDQUFDLFVBQVUsQ0FBQyxDQU10QztJQUVEOzs7Ozs7T0FNRztJQUNILE1BQU0sQ0FBQyxlQUFlLENBQUMsR0FBRyxFQUFFLEdBQUcsR0FBRyxVQUFVLENBUzNDO0lBRUQ7Ozs7O09BS0c7SUFFSCxPQUFPLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxzQkFBc0IsQ0FBTTtJQUM3QyxjQUFjLElBQUksTUFBTSxDQUc5QjtJQUVELE9BQU8sQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLG9CQUFvQixDQUFLO0lBQzFDLFFBQVEsSUFBSSxNQUFNLENBSXhCO0lBRU0sT0FBTyxJQUFJLEVBQUUsQ0FFbkI7SUFFTSxtQkFBbUIsSUFBSSxNQUFNLENBRW5DO0lBRUQsT0FBYyxVQUFVLENBQUMsSUFBSSxFQUFFLE1BQU0sR0FBRyxVQUFVLENBS2pEO0lBRUQsT0FBYyxTQUFTLENBQUMsS0FBSyxFQUFFLEVBQUUsR0FBRyxVQUFVLENBRTdDO0lBRUQsT0FBYyxVQUFVLENBQUMsTUFBTSxFQUFFLEVBQUUsRUFBRSxHQUFHLFdBQVcsR0FBRyxVQUFVLENBRy9EO0lBRUQsT0FBYyxVQUFVLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxZQUFZLEdBQUcsVUFBVSxDQUlsRTtJQUVELE9BQU8sQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBSztJQUN4QyxNQUFNLENBQUMsTUFBTSxJQUFJLFVBQVUsQ0FFMUI7SUFFRCxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsV0FFZjtDQUNGIn0=

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,qCAAqC,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAC7E,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAG/B,yDAAyD;AACzD,oBAAY,cAAc;IACxB,mEAAmE;IACnE,EAAE,IAAI;IACN,kFAAkF;IAClF,QAAQ,IAAI;CACb;AAOD;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,eAEN;IACD,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAqC;IACnE,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAA2C;IAExE,OAAO,IAAI,cAAc,CAE/B;IAEM,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAExC;IAEM,IAAI,IAAI,OAAO,CAErB;IAEM,cAAc,WASpB;IAEM,MAAM,WAEZ;IAED,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,UAAU,CAAC,CAMtC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,UAAU,CAS3C;IAED;;;;;OAKG;IAEH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAM;IAC7C,cAAc,IAAI,MAAM,CAG9B;IAED,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,oBAAoB,CAAK;IAC1C,QAAQ,IAAI,MAAM,CAIxB;IAEM,OAAO,IAAI,EAAE,CAEnB;IAEM,mBAAmB,IAAI,MAAM,CAEnC;IAED,OAAc,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAKjD;IAED,OAAc,SAAS,CAAC,KAAK,EAAE,EAAE,GAAG,UAAU,CAE7C;IAED,OAAc,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,UAAU,CAG/D;IAED,OAAc,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,UAAU,CAIlE;IAED,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAK;IACxC,MAAM,CAAC,MAAM,IAAI,UAAU,CAE1B;IAED,CAAC,OAAO,CAAC,MAAM,CAAC,WAEf;CACF"}

package/dest/avm/revert_code.js

@@ -0,0 +1,115 @@
+var _computedKey;
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, FieldReader } from '@aztec-labs/foundation/serialize';
+import { inspect } from 'util';
+import { z } from 'zod';
+/** Whether a transaction's public execution reverted. */ export var RevertCodeEnum = /*#__PURE__*/ function(RevertCodeEnum) {
+    /** All phases completed successfully; no state was rolled back. */ RevertCodeEnum[RevertCodeEnum["OK"] = 0] = "OK";
+    /** One or more revertible phases reverted; their state changes were discarded. */ RevertCodeEnum[RevertCodeEnum["REVERTED"] = 1] = "REVERTED";
+    return RevertCodeEnum;
+}({});
+/** Returns a valid RevertCodeEnum, coercing any value >= 1 to REVERTED. */ function toRevertCodeEnum(value) {
+    return value >= 1 ? 1 : 0;
+}
+_computedKey = inspect.custom;
+/**
+ * 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 REVERTED = new RevertCode(1);
+    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 'Reverted';
+            default:
+                return `Unknown RevertCode: ${this.code}`;
+        }
+    }
+    toJSON() {
+        return this.code;
+    }
+    static get schema() {
+        return z.number().int().min(0).transform((value)=>new RevertCode(toRevertCodeEnum(value)));
+    }
+    /**
+   * Creates a RevertCode from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object, number, or RevertCode instance
+   * @returns A RevertCode instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof RevertCode) {
+            return obj;
+        }
+        const code = typeof obj === 'number' ? obj : obj.code ?? obj;
+        if (typeof code !== 'number' || code < 0) {
+            throw new Error(`Invalid RevertCode: ${code}`);
+        }
+        return new RevertCode(toRevertCodeEnum(code));
+    }
+    /**
+   * 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 fromNumber(code) {
+        if (code < 0) {
+            throw new Error(`Invalid RevertCode: ${code}`);
+        }
+        return new RevertCode(toRevertCodeEnum(code));
+    }
+    static fromField(field) {
+        return RevertCode.fromNumber(field.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);
+        return RevertCode.fromNumber(code);
+    }
+    static NUM_OPTIONS = 2;
+    static random() {
+        return new RevertCode(Math.floor(Math.random() * RevertCode.NUM_OPTIONS));
+    }
+    [_computedKey]() {
+        return `RevertCode<${this.code.toString()}>`;
+    }
+}

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

@@ -0,0 +1,95 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { Point } from '@aztec-labs/foundation/curves/grumpkin';
+import { type ZodFor } from '@aztec-labs/foundation/schemas';
+import { type BufferReader, type BufferSink, FieldReader } from '@aztec-labs/foundation/serialize';
+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 declare class AztecAddress {
+    /** Branding for nominal typing. */
+    private readonly _branding;
+    private xCoord;
+    constructor(buffer: Buffer | Fr);
+    [inspect.custom](): string;
+    static isAddress(str: string): boolean;
+    static SIZE_IN_BYTES: number;
+    static ZERO: AztecAddress;
+    /** Null msg sender address. Not part of the protocol contracts tree. */
+    static NULL_MSG_SENDER: AztecAddress;
+    static zero(): AztecAddress;
+    /**
+     * Builds an `AztecAddress` from a field **without checking it is a valid address** (the x-coordinate of a point on
+     * the Grumpkin curve, which is what lets it be encrypted to). Use {@link AztecAddress.isValid} to validate an
+     * untrusted one, or {@link AztecAddress.random} for valid test addresses.
+     */
+    static fromFieldUnsafe(fr: Fr): AztecAddress;
+    /**
+     * Deserializes an `AztecAddress` from a buffer. It does **not** check the value is a valid Grumpkin-curve address
+     * (see {@link AztecAddress.isValid}); it is meant for reading addresses from already-validated serialized data. Use
+     * {@link AztecAddress.random} for valid test addresses.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): AztecAddress;
+    /**
+     * Deserializes an `AztecAddress` from a field reader. It does **not** check the value is a valid Grumpkin-curve
+     * address (see {@link AztecAddress.isValid}); it is meant for reading addresses from already-validated serialized
+     * data. Use {@link AztecAddress.random} for valid test addresses.
+     */
+    static fromFields(fields: Fr[] | FieldReader): AztecAddress;
+    /**
+     * Builds an `AztecAddress` from a bigint **without checking it is a valid address** (the x-coordinate of a point on
+     * the Grumpkin curve, which is what lets it be encrypted to). Use {@link AztecAddress.isValid} to validate an
+     * untrusted one, or {@link AztecAddress.random} for valid test addresses.
+     */
+    static fromBigIntUnsafe(value: bigint): AztecAddress;
+    /**
+     * Builds an `AztecAddress` from a number **without checking it is a valid address** (the x-coordinate of a point on
+     * the Grumpkin curve, which is what lets it be encrypted to). Use {@link AztecAddress.isValid} to validate an
+     * untrusted one, or {@link AztecAddress.random} for valid test addresses.
+     */
+    static fromNumberUnsafe(value: number): AztecAddress;
+    /**
+     * Builds an `AztecAddress` from a hex string **without checking it is a valid address** (the x-coordinate of a
+     * point on the Grumpkin curve, which is what lets it be encrypted to). Use {@link AztecAddress.isValid} to
+     * validate an untrusted one, or {@link AztecAddress.random} for valid test addresses.
+     */
+    static fromStringUnsafe(buf: string): AztecAddress;
+    /**
+     * Creates an AztecAddress from a plain object without Zod validation.
+     * This method is optimized for performance and skips validation, making it suitable
+     * for deserializing trusted data (e.g., from C++ via MessagePack).
+     * Handles buffers, strings, or existing instances.
+     * @param obj - Plain object, buffer, string, or AztecAddress instance
+     * @returns An AztecAddress instance
+     */
+    static fromPlainObject(obj: any): 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;
+    toBuffer(sink: BufferSink): void;
+    toBigInt(): bigint;
+    toField(): Fr;
+    toString(): `0x${string}`;
+    toJSON(): `0x${string}`;
+    static get schema(): ZodFor<AztecAddress>;
+}
+//# sourceMappingURL=data:application/json;base64,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