@aztec-labs/stdlib 6.0.0-nightly.20260829

package/dest/gas/gas_fees.js

@@ -0,0 +1,106 @@
+var _computedKey;
+import { schemas } from '@aztec-labs/foundation/schemas';
+import { BufferReader, BufferSink, FieldReader, serializeToFields } from '@aztec-labs/foundation/serialize';
+import { inspect } from 'util';
+import { z } from 'zod';
+/**
+ * Multiplies a bigint by a non-integer scalar and returns the ceiling of the result.
+ * Avoids converting the bigint to Number (which loses precision above 2^53) by instead
+ * scaling the scalar into a bigint rational and performing ceiling division.
+ */ function bigintMulCeil(value, scalar) {
+    const SCALE = 1_000_000_000_000n; // 1e12
+    const scaledScalar = BigInt(Math.round(scalar * 1e12));
+    return (value * scaledScalar + SCALE - 1n) / SCALE;
+}
+_computedKey = inspect.custom;
+/** Gas prices for each dimension. */ export class GasFees {
+    feePerDaGas;
+    feePerL2Gas;
+    constructor(feePerDaGas, feePerL2Gas){
+        this.feePerDaGas = BigInt(feePerDaGas);
+        this.feePerL2Gas = BigInt(feePerL2Gas);
+    }
+    static get schema() {
+        return z.object({
+            feePerDaGas: schemas.BigInt,
+            feePerL2Gas: schemas.BigInt
+        }).transform(GasFees.from);
+    }
+    clone() {
+        return new GasFees(this.feePerDaGas, this.feePerL2Gas);
+    }
+    equals(other) {
+        return this.feePerDaGas === other.feePerDaGas && this.feePerL2Gas === other.feePerL2Gas;
+    }
+    get(dimension) {
+        switch(dimension){
+            case 'da':
+                return this.feePerDaGas;
+            case 'l2':
+                return this.feePerL2Gas;
+        }
+    }
+    mul(scalar) {
+        if (scalar === 1 || scalar === 1n) {
+            return this.clone();
+        } else if (typeof scalar === 'bigint') {
+            return new GasFees(this.feePerDaGas * scalar, this.feePerL2Gas * scalar);
+        } else if (Number.isInteger(scalar)) {
+            const s = BigInt(scalar);
+            return new GasFees(this.feePerDaGas * s, this.feePerL2Gas * s);
+        } else {
+            return new GasFees(bigintMulCeil(this.feePerDaGas, scalar), bigintMulCeil(this.feePerL2Gas, scalar));
+        }
+    }
+    static from(fields) {
+        return new GasFees(fields.feePerDaGas, fields.feePerL2Gas);
+    }
+    /**
+   * Creates a GasFees 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 GasFees fields
+   * @returns A GasFees instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof GasFees) {
+            return obj;
+        }
+        return GasFees.from(obj);
+    }
+    static random() {
+        return new GasFees(Math.floor(Math.random() * 1e9), Math.floor(Math.random() * 1e9));
+    }
+    static empty() {
+        return new GasFees(0, 0);
+    }
+    isEmpty() {
+        return this.feePerDaGas === 0n && this.feePerL2Gas === 0n;
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new GasFees(reader.readUInt128(), reader.readUInt128());
+    }
+    toBuffer(sink) {
+        if (!sink) {
+            return BufferSink.serialize(this);
+        }
+        sink.writeBigInt(this.feePerDaGas, 16);
+        sink.writeBigInt(this.feePerL2Gas, 16);
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new GasFees(reader.readField().toBigInt(), reader.readField().toBigInt());
+    }
+    toFields() {
+        return serializeToFields(this.feePerDaGas, this.feePerL2Gas);
+    }
+    toInspect() {
+        return {
+            feePerDaGas: this.feePerDaGas,
+            feePerL2Gas: this.feePerL2Gas
+        };
+    }
+    [_computedKey]() {
+        return `GasFees { feePerDaGas=${this.feePerDaGas} feePerL2Gas=${this.feePerL2Gas} }`;
+    }
+}

package/dest/gas/gas_settings.d.ts

@@ -0,0 +1,128 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, BufferSink, FieldReader } from '@aztec-labs/foundation/serialize';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+import { z } from 'zod';
+import { Gas } from './gas.js';
+import { GasFees } from './gas_fees.js';
+export declare const GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT = 6540000;
+export declare const GAS_ESTIMATION_L2_GAS_LIMIT: number;
+export declare const GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT = 786432;
+export declare const GAS_ESTIMATION_DA_GAS_LIMIT: number;
+/** Gas usage and fees limits set by the transaction sender for different dimensions and phases. */
+export declare class GasSettings {
+    /** Total gas the tx may consume across all phases, teardown included. */
+    readonly gasLimits: Gas;
+    /** Portion of gasLimits reserved for the teardown phase, billed in full when the tx has a teardown call. */
+    readonly teardownGasLimits: Gas;
+    /** Maximum fees per gas unit the sender is willing to pay. */
+    readonly maxFeesPerGas: GasFees;
+    /** Maximum priority fees per gas unit the sender is willing to pay on top of the base fee. */
+    readonly maxPriorityFeesPerGas: GasFees;
+    constructor(
+    /** Total gas the tx may consume across all phases, teardown included. */
+    gasLimits: Gas, 
+    /** Portion of gasLimits reserved for the teardown phase, billed in full when the tx has a teardown call. */
+    teardownGasLimits: Gas, 
+    /** Maximum fees per gas unit the sender is willing to pay. */
+    maxFeesPerGas: GasFees, 
+    /** Maximum priority fees per gas unit the sender is willing to pay on top of the base fee. */
+    maxPriorityFeesPerGas: GasFees);
+    static get schema(): z.ZodPipe<z.ZodObject<{
+        gasLimits: z.ZodPipe<z.ZodObject<{
+            daGas: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+            l2Gas: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+        }, z.core.$strip>, z.ZodTransform<Gas, {
+            daGas: number;
+            l2Gas: number;
+        }>>;
+        teardownGasLimits: z.ZodPipe<z.ZodObject<{
+            daGas: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+            l2Gas: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
+        }, z.core.$strip>, z.ZodTransform<Gas, {
+            daGas: number;
+            l2Gas: number;
+        }>>;
+        maxFeesPerGas: z.ZodPipe<z.ZodObject<{
+            feePerDaGas: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedBigInt<string | number | bigint>>;
+            feePerL2Gas: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedBigInt<string | number | bigint>>;
+        }, z.core.$strip>, z.ZodTransform<GasFees, {
+            feePerDaGas: bigint;
+            feePerL2Gas: bigint;
+        }>>;
+        maxPriorityFeesPerGas: z.ZodPipe<z.ZodObject<{
+            feePerDaGas: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedBigInt<string | number | bigint>>;
+            feePerL2Gas: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedBigInt<string | number | bigint>>;
+        }, z.core.$strip>, z.ZodTransform<GasFees, {
+            feePerDaGas: bigint;
+            feePerL2Gas: bigint;
+        }>>;
+    }, z.core.$strip>, z.ZodTransform<GasSettings, {
+        gasLimits: Gas;
+        teardownGasLimits: Gas;
+        maxFeesPerGas: GasFees;
+        maxPriorityFeesPerGas: GasFees;
+    }>>;
+    getSize(): number;
+    static from(args: {
+        gasLimits: FieldsOf<Gas>;
+        teardownGasLimits: FieldsOf<Gas>;
+        maxFeesPerGas: FieldsOf<GasFees>;
+        maxPriorityFeesPerGas: FieldsOf<GasFees>;
+    }): GasSettings;
+    /**
+     * Creates a GasSettings 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 GasSettings fields
+     * @returns A GasSettings instance
+     */
+    static fromPlainObject(obj: any): GasSettings;
+    clone(): GasSettings;
+    /** Returns the maximum fee to be paid according to gas limits and max fees set. */
+    getFeeLimit(): Fr;
+    /** Zero-value gas settings. */
+    static empty(): GasSettings;
+    /**
+     * Fills in gas limits high enough for transactions to be included in most cases.
+     * Callers must supply `gasLimits` — typically the most a single tx may declare on the network
+     * (`min(per-tx max, per-block allocation)`), i.e. a node's advertised `txsLimits.gas`. Since teardown gas
+     * is reserved from gasLimits during private execution (see gas_meter.nr), the effective gas available for
+     * app logic is gasLimits - teardownGasLimits - privateOverhead; the teardown default is derived from the
+     * effective total so it always stays below it.
+     * These values won't work if:
+     *  - Teardown consumes more than the arbitrarily assigned fallback limits
+     *  - The rest of the transaction consumes more than the remaining gas after teardown
+     *  - The DA gas limit is too low for the transaction, while still within the checkpoint limit
+     */
+    static fallback(overrides: {
+        gasLimits: Gas;
+        teardownGasLimits?: Gas;
+        maxFeesPerGas: GasFees;
+        maxPriorityFeesPerGas?: GasFees;
+    }): GasSettings;
+    /**
+     * Gas settings for simulation/estimation only.
+     * Since teardown gas is reserved upfront from gasLimits during private execution (see gas_meter.nr),
+     * the effective gas available for app logic is gasLimits - teardownGasLimits - privateOverhead.
+     * To ensure estimation never hits gas caps, we set both limits above what the protocol allows:
+     * teardown gets MAX_PROCESSABLE and gasLimits gets teardown + MAX_PROCESSABLE, so the full
+     * processable amount remains available for each phase independently. Tx validation exempts
+     * simulated txs from gas-limit admission (`isValidTx` with `isSimulation: true`), so these
+     * inflated limits pass validation; the wallet clamps the real tx to the admission limit afterward.
+     */
+    static forEstimation(overrides: {
+        gasLimits?: Gas;
+        teardownGasLimits?: Gas;
+        maxFeesPerGas: GasFees;
+        maxPriorityFeesPerGas?: GasFees;
+    }): GasSettings;
+    isEmpty(): boolean;
+    equals(other: GasSettings): boolean;
+    static fromBuffer(buffer: Buffer | BufferReader): GasSettings;
+    toBuffer(): Buffer;
+    toBuffer(sink: BufferSink): void;
+    static fromFields(fields: Fr[] | FieldReader): GasSettings;
+    toFields(): Fr[];
+    static getFields(fields: FieldsOf<GasSettings>): readonly [Gas, Gas, GasFees, GasFees];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/gas/gas_settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gas_settings.d.ts","sourceRoot":"","sources":["../../src/gas/gas_settings.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AACzD,OAAO,EACL,YAAY,EACZ,UAAU,EACV,WAAW,EAGZ,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,GAAG,EAAiB,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAKxC,eAAO,MAAM,oCAAoC,UAAyB,CAAC;AAC3E,eAAO,MAAM,2BAA2B,QAAgE,CAAC;AACzG,eAAO,MAAM,oCAAoC,SAAwC,CAAC;AAC1F,eAAO,MAAM,2BAA2B,QAA+E,CAAC;AAGxH,mGAAmG;AACnG,qBAAa,WAAW;IAEpB,yEAAyE;aACzD,SAAS,EAAE,GAAG;IAC9B,4GAA4G;aAC5F,iBAAiB,EAAE,GAAG;IACtC,8DAA8D;aAC9C,aAAa,EAAE,OAAO;IACtC,8FAA8F;aAC9E,qBAAqB,EAAE,OAAO;IARhD;IACE,yEAAyE;IACzD,SAAS,EAAE,GAAG;IAC9B,4GAA4G;IAC5F,iBAAiB,EAAE,GAAG;IACtC,8DAA8D;IAC9C,aAAa,EAAE,OAAO;IACtC,8FAA8F;IAC9E,qBAAqB,EAAE,OAAO,EAC5C;IAGJ,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAShB;IAED,OAAO,IAAI,MAAM,CAEhB;IAED,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE;QAChB,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACzB,iBAAiB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACjC,aAAa,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;QACjC,qBAAqB,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;KAC1C,eAOA;IAED;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,WAAW,CAU5C;IAED,KAAK,gBAOJ;IAED,mFAAmF;IACnF,WAAW,OAKV;IAED,+BAA+B;IAC/B,MAAM,CAAC,KAAK,gBAEX;IAED;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE;QACzB,SAAS,EAAE,GAAG,CAAC;QACf,iBAAiB,CAAC,EAAE,GAAG,CAAC;QACxB,aAAa,EAAE,OAAO,CAAC;QACvB,qBAAqB,CAAC,EAAE,OAAO,CAAC;KACjC,eAUA;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,aAAa,CAAC,SAAS,EAAE;QAC9B,SAAS,CAAC,EAAE,GAAG,CAAC;QAChB,iBAAiB,CAAC,EAAE,GAAG,CAAC;QACxB,aAAa,EAAE,OAAO,CAAC;QACvB,qBAAqB,CAAC,EAAE,OAAO,CAAC;KACjC,eAaA;IAED,OAAO,YAON;IAED,MAAM,CAAC,KAAK,EAAE,WAAW,WAOxB;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,WAAW,CAQ5D;IAED,QAAQ,IAAI,MAAM,CAAC;IACnB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;IAQjC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,WAAW,CAQzD;IAED,QAAQ,IAAI,EAAE,EAAE,CAQf;IAED,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,yCAE7C;CACF"}

package/dest/gas/gas_settings.js

@@ -0,0 +1,141 @@
+import { GAS_SETTINGS_LENGTH, MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, MAX_PROCESSABLE_L2_GAS } from '@aztec-labs/constants';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, BufferSink, FieldReader, serializeToFields, serializeToSink } from '@aztec-labs/foundation/serialize';
+import { z } from 'zod';
+import { Gas, GasDimensions } from './gas.js';
+import { GasFees } from './gas_fees.js';
+// For gas estimation, we use intentionally high limits above what the network can process,
+// so the simulation runs without hitting gas caps. Since teardown gas is counted towards total,
+// the total estimation limit is teardown + max processable.
+export const GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT = MAX_PROCESSABLE_L2_GAS;
+export const GAS_ESTIMATION_L2_GAS_LIMIT = GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT + MAX_PROCESSABLE_L2_GAS;
+export const GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT = MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT;
+export const GAS_ESTIMATION_DA_GAS_LIMIT = GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT + MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT;
+// docs:start:gas_settings_vars
+/** Gas usage and fees limits set by the transaction sender for different dimensions and phases. */ export class GasSettings {
+    gasLimits;
+    teardownGasLimits;
+    maxFeesPerGas;
+    maxPriorityFeesPerGas;
+    constructor(/** Total gas the tx may consume across all phases, teardown included. */ gasLimits, /** Portion of gasLimits reserved for the teardown phase, billed in full when the tx has a teardown call. */ teardownGasLimits, /** Maximum fees per gas unit the sender is willing to pay. */ maxFeesPerGas, /** Maximum priority fees per gas unit the sender is willing to pay on top of the base fee. */ maxPriorityFeesPerGas){
+        this.gasLimits = gasLimits;
+        this.teardownGasLimits = teardownGasLimits;
+        this.maxFeesPerGas = maxFeesPerGas;
+        this.maxPriorityFeesPerGas = maxPriorityFeesPerGas;
+    }
+    // docs:end:gas_settings_vars
+    static get schema() {
+        return z.object({
+            gasLimits: Gas.schema,
+            teardownGasLimits: Gas.schema,
+            maxFeesPerGas: GasFees.schema,
+            maxPriorityFeesPerGas: GasFees.schema
+        }).transform(GasSettings.from);
+    }
+    getSize() {
+        return this.toBuffer().length;
+    }
+    static from(args) {
+        return new GasSettings(Gas.from(args.gasLimits), Gas.from(args.teardownGasLimits), GasFees.from(args.maxFeesPerGas), GasFees.from(args.maxPriorityFeesPerGas));
+    }
+    /**
+   * Creates a GasSettings 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 GasSettings fields
+   * @returns A GasSettings instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof GasSettings) {
+            return obj;
+        }
+        return new GasSettings(Gas.fromPlainObject(obj.gasLimits), Gas.fromPlainObject(obj.teardownGasLimits), GasFees.fromPlainObject(obj.maxFeesPerGas), GasFees.fromPlainObject(obj.maxPriorityFeesPerGas));
+    }
+    clone() {
+        return new GasSettings(this.gasLimits.clone(), this.teardownGasLimits.clone(), this.maxFeesPerGas.clone(), this.maxPriorityFeesPerGas.clone());
+    }
+    /** Returns the maximum fee to be paid according to gas limits and max fees set. */ getFeeLimit() {
+        return GasDimensions.reduce((acc, dimension)=>new Fr(this.maxFeesPerGas.get(dimension)).mul(new Fr(this.gasLimits.get(dimension))).add(acc), Fr.ZERO);
+    }
+    /** Zero-value gas settings. */ static empty() {
+        return new GasSettings(Gas.empty(), Gas.empty(), GasFees.empty(), GasFees.empty());
+    }
+    /**
+   * Fills in gas limits high enough for transactions to be included in most cases.
+   * Callers must supply `gasLimits` — typically the most a single tx may declare on the network
+   * (`min(per-tx max, per-block allocation)`), i.e. a node's advertised `txsLimits.gas`. Since teardown gas
+   * is reserved from gasLimits during private execution (see gas_meter.nr), the effective gas available for
+   * app logic is gasLimits - teardownGasLimits - privateOverhead; the teardown default is derived from the
+   * effective total so it always stays below it.
+   * These values won't work if:
+   *  - Teardown consumes more than the arbitrarily assigned fallback limits
+   *  - The rest of the transaction consumes more than the remaining gas after teardown
+   *  - The DA gas limit is too low for the transaction, while still within the checkpoint limit
+   */ static fallback(overrides) {
+        const gasLimits = overrides.gasLimits;
+        const teardownGasLimits = overrides.teardownGasLimits ?? new Gas(Math.floor(gasLimits.daGas / 2), Math.floor(gasLimits.l2Gas / 8));
+        return GasSettings.from({
+            gasLimits,
+            teardownGasLimits,
+            maxFeesPerGas: overrides.maxFeesPerGas,
+            maxPriorityFeesPerGas: overrides.maxPriorityFeesPerGas ?? GasFees.empty()
+        });
+    }
+    /**
+   * Gas settings for simulation/estimation only.
+   * Since teardown gas is reserved upfront from gasLimits during private execution (see gas_meter.nr),
+   * the effective gas available for app logic is gasLimits - teardownGasLimits - privateOverhead.
+   * To ensure estimation never hits gas caps, we set both limits above what the protocol allows:
+   * teardown gets MAX_PROCESSABLE and gasLimits gets teardown + MAX_PROCESSABLE, so the full
+   * processable amount remains available for each phase independently. Tx validation exempts
+   * simulated txs from gas-limit admission (`isValidTx` with `isSimulation: true`), so these
+   * inflated limits pass validation; the wallet clamps the real tx to the admission limit afterward.
+   */ static forEstimation(overrides) {
+        return GasSettings.from({
+            gasLimits: overrides.gasLimits ?? {
+                l2Gas: GAS_ESTIMATION_L2_GAS_LIMIT,
+                daGas: GAS_ESTIMATION_DA_GAS_LIMIT
+            },
+            teardownGasLimits: overrides.teardownGasLimits ?? {
+                l2Gas: GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT,
+                daGas: GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT
+            },
+            maxFeesPerGas: overrides.maxFeesPerGas,
+            maxPriorityFeesPerGas: overrides.maxPriorityFeesPerGas ?? GasFees.empty()
+        });
+    }
+    isEmpty() {
+        return this.gasLimits.isEmpty() && this.teardownGasLimits.isEmpty() && this.maxFeesPerGas.isEmpty() && this.maxPriorityFeesPerGas.isEmpty();
+    }
+    equals(other) {
+        return this.gasLimits.equals(other.gasLimits) && this.teardownGasLimits.equals(other.teardownGasLimits) && this.maxFeesPerGas.equals(other.maxFeesPerGas) && this.maxPriorityFeesPerGas.equals(other.maxPriorityFeesPerGas);
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new GasSettings(reader.readObject(Gas), reader.readObject(Gas), reader.readObject(GasFees), reader.readObject(GasFees));
+    }
+    toBuffer(sink) {
+        if (!sink) {
+            return BufferSink.serialize(this);
+        }
+        serializeToSink(sink, ...GasSettings.getFields(this));
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new GasSettings(reader.readObject(Gas), reader.readObject(Gas), reader.readObject(GasFees), reader.readObject(GasFees));
+    }
+    toFields() {
+        const fields = serializeToFields(...GasSettings.getFields(this));
+        if (fields.length !== GAS_SETTINGS_LENGTH) {
+            throw new Error(`Invalid number of fields for GasSettings. Expected ${GAS_SETTINGS_LENGTH} but got ${fields.length}`);
+        }
+        return fields;
+    }
+    static getFields(fields) {
+        return [
+            fields.gasLimits,
+            fields.teardownGasLimits,
+            fields.maxFeesPerGas,
+            fields.maxPriorityFeesPerGas
+        ];
+    }
+}

package/dest/gas/gas_used.d.ts

@@ -0,0 +1,31 @@
+import { Gas } from './gas.js';
+export interface GasUsed {
+    /**
+     * Total gas used across both private and public executions.
+     * Note that this does not determine the transaction fee. The fee is calculated with billedGas, which uses `teardownGasLimits` from
+     * `GasSettings`, rather than actual teardown gas.
+     */
+    totalGas: Gas;
+    /** Total gas used during public execution, including actual teardown gas */
+    publicGas: Gas;
+    /**
+     * The actual gas used in the teardown phase.
+     */
+    teardownGas: Gas;
+    /**
+     * The gas billed for the transaction. This uses teardown gas limit instead of actual teardown gas.
+     */
+    billedGas: Gas;
+}
+/**
+ * Creates a GasUsed 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 GasUsed fields
+ * @returns A GasUsed object
+ */
+export declare function gasUsedFromPlainObject(obj: any): GasUsed;
+export declare const GasUsed: {
+    fromPlainObject: typeof gasUsedFromPlainObject;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2FzX3VzZWQuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9nYXMvZ2FzX3VzZWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUUvQixNQUFNLFdBQVcsT0FBTztJQUN0Qjs7OztPQUlHO0lBQ0gsUUFBUSxFQUFFLEdBQUcsQ0FBQztJQUVkLDRFQUE0RTtJQUM1RSxTQUFTLEVBQUUsR0FBRyxDQUFDO0lBRWY7O09BRUc7SUFDSCxXQUFXLEVBQUUsR0FBRyxDQUFDO0lBRWpCOztPQUVHO0lBQ0gsU0FBUyxFQUFFLEdBQUcsQ0FBQztDQUNoQjtBQUVEOzs7Ozs7R0FNRztBQUNILHdCQUFnQixzQkFBc0IsQ0FBQyxHQUFHLEVBQUUsR0FBRyxHQUFHLE9BQU8sQ0FPeEQ7QUFHRCxlQUFPLE1BQU0sT0FBTzs7Q0FFbkIsQ0FBQyJ9

package/dest/gas/gas_used.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gas_used.d.ts","sourceRoot":"","sources":["../../src/gas/gas_used.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B,MAAM,WAAW,OAAO;IACtB;;;;OAIG;IACH,QAAQ,EAAE,GAAG,CAAC;IAEd,4EAA4E;IAC5E,SAAS,EAAE,GAAG,CAAC;IAEf;;OAEG;IACH,WAAW,EAAE,GAAG,CAAC;IAEjB;;OAEG;IACH,SAAS,EAAE,GAAG,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAOxD;AAGD,eAAO,MAAM,OAAO;;CAEnB,CAAC"}

package/dest/gas/gas_used.js

@@ -0,0 +1,19 @@
+import { Gas } from './gas.js';
+/**
+ * Creates a GasUsed 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 GasUsed fields
+ * @returns A GasUsed object
+ */ export function gasUsedFromPlainObject(obj) {
+    return {
+        totalGas: Gas.fromPlainObject(obj.totalGas),
+        publicGas: Gas.fromPlainObject(obj.publicGas),
+        teardownGas: Gas.fromPlainObject(obj.teardownGas),
+        billedGas: Gas.fromPlainObject(obj.billedGas)
+    };
+}
+// Export as a namespace to match the pattern
+export const GasUsed = {
+    fromPlainObject: gasUsedFromPlainObject
+};

package/dest/gas/index.d.ts

@@ -0,0 +1,7 @@
+export * from './fee_math.js';
+export * from './gas.js';
+export * from './gas_fees.js';
+export * from './gas_settings.js';
+export * from './gas_used.js';
+export * from './tx_gas_limits.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9nYXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLG9CQUFvQixDQUFDIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/gas/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC"}

package/dest/gas/index.js

@@ -0,0 +1,6 @@
+export * from './fee_math.js';
+export * from './gas.js';
+export * from './gas_fees.js';
+export * from './gas_settings.js';
+export * from './gas_used.js';
+export * from './tx_gas_limits.js';

package/dest/gas/tx_gas_limits.d.ts

@@ -0,0 +1,71 @@
+import { type ProposerTimetableConfig } from '../timetable/build_proposer_timetable.js';
+import type { SlotTimingConstants } from '../timetable/consensus_timetable.js';
+import { Gas } from './gas.js';
+/**
+ * Network-minimum per-block budget multiplier for L2 gas and tx-count allocation. A block packer must
+ * grant at least this share of the even per-block split to a single tx; operators may configure a higher
+ * multiplier (more generous), but not a lower one — enforced at sequencer startup. Also used as the default
+ * for `SequencerConfig.perBlockAllocationMultiplier`.
+ */
+export declare const MIN_PER_BLOCK_ALLOCATION_MULTIPLIER = 1.2;
+/**
+ * Network-minimum per-block budget multiplier for DA gas, applied in place of the general
+ * {@link MIN_PER_BLOCK_ALLOCATION_MULTIPLIER}. Higher than the general multiplier so the largest tx we
+ * want to support — a maximal contract class registration (~97k DA gas) — fits a single block under v5
+ * mainnet geometry (72s slots, 6s blocks → 10 blocks per checkpoint). A builder may configure a higher
+ * multiplier but never a lower one. Also used as the default for
+ * `SequencerConfig.perBlockDAAllocationMultiplier`.
+ */
+export declare const MIN_PER_BLOCK_DA_ALLOCATION_MULTIPLIER = 1.5;
+/**
+ * The DA gas budget available to tx data within a checkpoint of `maxBlocksPerCheckpoint` blocks. This is the
+ * raw blob capacity (`BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB * DA_GAS_PER_FIELD`) minus the fields the blob
+ * encoding reserves for overhead that no tx pays DA gas for:
+ *
+ * - one checkpoint-end marker field (`NUM_CHECKPOINT_END_MARKER_FIELDS`), and
+ * - `NUM_BLOCK_END_BLOB_FIELDS` (7, including the per-block l1-to-l2 root) for each of the `blocks` blocks.
+ *
+ * Subtracting the overhead for every block (not just the first) keeps the network DA admission limit at or
+ * below the builder's first-block blob-field cap at every geometry. The builder is the MOST generous for the
+ * first block — it only reserves that block's own block-end overhead — so being conservative here (assuming
+ * the checkpoint is full of blocks, each spending its share) is what guarantees admitted ⇒ buildable: a tx
+ * admitted under this budget always fits the first block's blob-field cap, regardless of how many blocks the
+ * builder ends up packing.
+ *
+ * @param maxBlocksPerCheckpoint - Number of blocks the checkpoint may contain; clamped to at least 1.
+ */
+export declare function getDaCheckpointBudgetForTxs(maxBlocksPerCheckpoint: number): number;
+/**
+ * Computes the maximum gas a single tx may declare on a network: the smaller of the per-tx protocol
+ * maximum and the per-block allocation a proposer grants to the first block of a checkpoint. The per-block
+ * allocation mirrors `CheckpointBuilder.capLimitsByCheckpointBudgets`
+ * (`ceil(checkpointBudget / maxBlocksPerCheckpoint * multiplier)`) using the network-minimum multipliers, so
+ * a tx declaring this much is admissible into a block under that geometry.
+ *
+ * This is a *network* limit: a function of network-wide constants only (timetable-derived
+ * blocks-per-checkpoint, checkpoint budgets, the network-minimum multipliers). It must NOT depend on a
+ * node's local restrictiveness — its multipliers configured above the network minimum, or its
+ * `maxDABlockGas` / `validateMaxDABlockGas` caps — because those make a node stricter at block-building
+ * time but cannot define what the network considers a valid tx for relay. The same value is advertised by
+ * `getNodeInfo` and enforced by the RPC/gossip/pool gas validators.
+ *
+ * The DA budget is {@link getDaCheckpointBudgetForTxs} evaluated at the clamped blocks-per-checkpoint — the
+ * raw blob capacity net of encoding overhead for every block — so the admission limit is consistent with the
+ * builder's blob-field cap.
+ *
+ * @param manaCheckpointBudget - L2 (mana) budget per checkpoint (`rollupManaLimit`).
+ */
+export declare function computeNetworkTxGasLimits(opts: {
+    maxBlocksPerCheckpoint: number;
+    manaCheckpointBudget: number;
+}): Gas;
+/**
+ * Network tx gas limits derived from a sequencer/p2p config and the L1 slot-timing + mana constants. The
+ * single source of truth shared by `getNodeInfo` (advertising) and the RPC/gossip/pool gas validators
+ * (enforcing), so a node never rejects a tx it advertised as admissible. Always uses the network-minimum
+ * multipliers, never the node's (possibly higher) configured multipliers.
+ */
+export declare function getNetworkTxGasLimits(config: ProposerTimetableConfig, l1Constants: SlotTimingConstants & {
+    rollupManaLimit: number;
+}): Gas;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfZ2FzX2xpbWl0cy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2dhcy90eF9nYXNfbGltaXRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVNBLE9BQU8sRUFBRSxLQUFLLHVCQUF1QixFQUEwQixNQUFNLDBDQUEwQyxDQUFDO0FBQ2hILE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDL0UsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUUvQjs7Ozs7R0FLRztBQUNILGVBQU8sTUFBTSxtQ0FBbUMsTUFBTSxDQUFDO0FBRXZEOzs7Ozs7O0dBT0c7QUFDSCxlQUFPLE1BQU0sc0NBQXNDLE1BQU0sQ0FBQztBQUUxRDs7Ozs7Ozs7Ozs7Ozs7OztHQWdCRztBQUNILHdCQUFnQiwyQkFBMkIsQ0FBQyxzQkFBc0IsRUFBRSxNQUFNLEdBQUcsTUFBTSxDQVNsRjtBQUVEOzs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBbUJHO0FBQ0gsd0JBQWdCLHlCQUF5QixDQUFDLElBQUksRUFBRTtJQUFFLHNCQUFzQixFQUFFLE1BQU0sQ0FBQztJQUFDLG9CQUFvQixFQUFFLE1BQU0sQ0FBQTtDQUFFLEdBQUcsR0FBRyxDQXFCckg7QUFFRDs7Ozs7R0FLRztBQUNILHdCQUFnQixxQkFBcUIsQ0FDbkMsTUFBTSxFQUFFLHVCQUF1QixFQUMvQixXQUFXLEVBQUUsbUJBQW1CLEdBQUc7SUFBRSxlQUFlLEVBQUUsTUFBTSxDQUFBO0NBQUUsR0FDN0QsR0FBRyxDQUdMIn0=

package/dest/gas/tx_gas_limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx_gas_limits.d.ts","sourceRoot":"","sources":["../../src/gas/tx_gas_limits.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,uBAAuB,EAA0B,MAAM,0CAA0C,CAAC;AAChH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC/E,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B;;;;;GAKG;AACH,eAAO,MAAM,mCAAmC,MAAM,CAAC;AAEvD;;;;;;;GAOG;AACH,eAAO,MAAM,sCAAsC,MAAM,CAAC;AAE1D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,2BAA2B,CAAC,sBAAsB,EAAE,MAAM,GAAG,MAAM,CASlF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAAE,sBAAsB,EAAE,MAAM,CAAC;IAAC,oBAAoB,EAAE,MAAM,CAAA;CAAE,GAAG,GAAG,CAqBrH;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,mBAAmB,GAAG;IAAE,eAAe,EAAE,MAAM,CAAA;CAAE,GAC7D,GAAG,CAGL"}

package/dest/gas/tx_gas_limits.js

@@ -0,0 +1,84 @@
+import { NUM_BLOCK_END_BLOB_FIELDS, NUM_CHECKPOINT_END_MARKER_FIELDS } from '@aztec-labs/blob-lib/encoding';
+import { BLOBS_PER_CHECKPOINT, DA_GAS_PER_FIELD, FIELDS_PER_BLOB, MAX_PROCESSABLE_L2_GAS, MAX_TX_DA_GAS } from '@aztec-labs/constants';
+import { buildProposerTimetable } from '../timetable/build_proposer_timetable.js';
+import { Gas } from './gas.js';
+/**
+ * Network-minimum per-block budget multiplier for L2 gas and tx-count allocation. A block packer must
+ * grant at least this share of the even per-block split to a single tx; operators may configure a higher
+ * multiplier (more generous), but not a lower one — enforced at sequencer startup. Also used as the default
+ * for `SequencerConfig.perBlockAllocationMultiplier`.
+ */ export const MIN_PER_BLOCK_ALLOCATION_MULTIPLIER = 1.2;
+/**
+ * Network-minimum per-block budget multiplier for DA gas, applied in place of the general
+ * {@link MIN_PER_BLOCK_ALLOCATION_MULTIPLIER}. Higher than the general multiplier so the largest tx we
+ * want to support — a maximal contract class registration (~97k DA gas) — fits a single block under v5
+ * mainnet geometry (72s slots, 6s blocks → 10 blocks per checkpoint). A builder may configure a higher
+ * multiplier but never a lower one. Also used as the default for
+ * `SequencerConfig.perBlockDAAllocationMultiplier`.
+ */ export const MIN_PER_BLOCK_DA_ALLOCATION_MULTIPLIER = 1.5;
+/**
+ * The DA gas budget available to tx data within a checkpoint of `maxBlocksPerCheckpoint` blocks. This is the
+ * raw blob capacity (`BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB * DA_GAS_PER_FIELD`) minus the fields the blob
+ * encoding reserves for overhead that no tx pays DA gas for:
+ *
+ * - one checkpoint-end marker field (`NUM_CHECKPOINT_END_MARKER_FIELDS`), and
+ * - `NUM_BLOCK_END_BLOB_FIELDS` (7, including the per-block l1-to-l2 root) for each of the `blocks` blocks.
+ *
+ * Subtracting the overhead for every block (not just the first) keeps the network DA admission limit at or
+ * below the builder's first-block blob-field cap at every geometry. The builder is the MOST generous for the
+ * first block — it only reserves that block's own block-end overhead — so being conservative here (assuming
+ * the checkpoint is full of blocks, each spending its share) is what guarantees admitted ⇒ buildable: a tx
+ * admitted under this budget always fits the first block's blob-field cap, regardless of how many blocks the
+ * builder ends up packing.
+ *
+ * @param maxBlocksPerCheckpoint - Number of blocks the checkpoint may contain; clamped to at least 1.
+ */ export function getDaCheckpointBudgetForTxs(maxBlocksPerCheckpoint) {
+    const blocks = Math.max(1, maxBlocksPerCheckpoint);
+    // Clamp at zero: for absurd geometries (blocks greater than ~4094) the per-block overhead alone exceeds the
+    // raw blob capacity, which would otherwise yield a negative advertised DA budget.
+    const fields = Math.max(0, BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB - NUM_CHECKPOINT_END_MARKER_FIELDS - blocks * NUM_BLOCK_END_BLOB_FIELDS);
+    return fields * DA_GAS_PER_FIELD;
+}
+/**
+ * Computes the maximum gas a single tx may declare on a network: the smaller of the per-tx protocol
+ * maximum and the per-block allocation a proposer grants to the first block of a checkpoint. The per-block
+ * allocation mirrors `CheckpointBuilder.capLimitsByCheckpointBudgets`
+ * (`ceil(checkpointBudget / maxBlocksPerCheckpoint * multiplier)`) using the network-minimum multipliers, so
+ * a tx declaring this much is admissible into a block under that geometry.
+ *
+ * This is a *network* limit: a function of network-wide constants only (timetable-derived
+ * blocks-per-checkpoint, checkpoint budgets, the network-minimum multipliers). It must NOT depend on a
+ * node's local restrictiveness — its multipliers configured above the network minimum, or its
+ * `maxDABlockGas` / `validateMaxDABlockGas` caps — because those make a node stricter at block-building
+ * time but cannot define what the network considers a valid tx for relay. The same value is advertised by
+ * `getNodeInfo` and enforced by the RPC/gossip/pool gas validators.
+ *
+ * The DA budget is {@link getDaCheckpointBudgetForTxs} evaluated at the clamped blocks-per-checkpoint — the
+ * raw blob capacity net of encoding overhead for every block — so the admission limit is consistent with the
+ * builder's blob-field cap.
+ *
+ * @param manaCheckpointBudget - L2 (mana) budget per checkpoint (`rollupManaLimit`).
+ */ export function computeNetworkTxGasLimits(opts) {
+    const blocks = Math.max(1, opts.maxBlocksPerCheckpoint);
+    const daBudget = getDaCheckpointBudgetForTxs(blocks);
+    // Clamp by the whole-checkpoint budget too: at small block counts the per-block share scaled by the
+    // multiplier can exceed the checkpoint budget itself (e.g. at blocks=1 a >1 multiplier overshoots), which
+    // would admit a tx no builder can ever pack — the builder caps each block by the remaining budget. Clamping
+    // by the budget makes "admitted ⇒ buildable" unconditional. (For DA the per-tx maximum always binds first,
+    // so the budget clamp is currently moot, but it keeps the invariant explicit.)
+    const daGas = Math.min(MAX_TX_DA_GAS, daBudget, Math.ceil(daBudget / blocks * MIN_PER_BLOCK_DA_ALLOCATION_MULTIPLIER));
+    const l2Gas = Math.min(MAX_PROCESSABLE_L2_GAS, opts.manaCheckpointBudget, Math.ceil(opts.manaCheckpointBudget / blocks * MIN_PER_BLOCK_ALLOCATION_MULTIPLIER));
+    return new Gas(daGas, l2Gas);
+}
+/**
+ * Network tx gas limits derived from a sequencer/p2p config and the L1 slot-timing + mana constants. The
+ * single source of truth shared by `getNodeInfo` (advertising) and the RPC/gossip/pool gas validators
+ * (enforcing), so a node never rejects a tx it advertised as admissible. Always uses the network-minimum
+ * multipliers, never the node's (possibly higher) configured multipliers.
+ */ export function getNetworkTxGasLimits(config, l1Constants) {
+    const maxBlocksPerCheckpoint = buildProposerTimetable(config, l1Constants).getMaxBlocksPerCheckpoint();
+    return computeNetworkTxGasLimits({
+        maxBlocksPerCheckpoint,
+        manaCheckpointBudget: l1Constants.rollupManaLimit
+    });
+}