@aztec/stdlib 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

package/dest/gas/gas_settings.d.ts

@@ -1,9 +1,13 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+import { BufferReader, BufferSink, FieldReader } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/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 {
     readonly gasLimits: Gas;
@@ -11,99 +15,41 @@ export declare class GasSettings {
     readonly maxFeesPerGas: GasFees;
     readonly maxPriorityFeesPerGas: GasFees;
     constructor(gasLimits: Gas, teardownGasLimits: Gas, maxFeesPerGas: GasFees, maxPriorityFeesPerGas: GasFees);
-    static get schema(): z.ZodEffects<z.ZodObject<{
-        gasLimits: z.ZodEffects<z.ZodObject<{
-            daGas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
-            l2Gas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
+    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;
-        }, {
-            daGas: string | number | bigint;
-            l2Gas: string | number | bigint;
-        }>, Gas, {
-            daGas: string | number | bigint;
-            l2Gas: string | number | bigint;
-        }>;
-        teardownGasLimits: z.ZodEffects<z.ZodObject<{
-            daGas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
-            l2Gas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
+        }>>;
+        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;
-        }, {
-            daGas: string | number | bigint;
-            l2Gas: string | number | bigint;
-        }>, Gas, {
-            daGas: string | number | bigint;
-            l2Gas: string | number | bigint;
-        }>;
-        maxFeesPerGas: z.ZodEffects<z.ZodObject<{
-            feePerDaGas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
-            feePerL2Gas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
-        }, "strip", z.ZodTypeAny, {
+        }>>;
+        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;
-        }, {
-            feePerDaGas: string | number | bigint;
-            feePerL2Gas: string | number | bigint;
-        }>, GasFees, {
-            feePerDaGas: string | number | bigint;
-            feePerL2Gas: string | number | bigint;
-        }>;
-        maxPriorityFeesPerGas: z.ZodEffects<z.ZodObject<{
-            feePerDaGas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
-            feePerL2Gas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
-        }, "strip", z.ZodTypeAny, {
+        }>>;
+        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;
-        }, {
-            feePerDaGas: string | number | bigint;
-            feePerL2Gas: string | number | bigint;
-        }>, GasFees, {
-            feePerDaGas: string | number | bigint;
-            feePerL2Gas: string | number | bigint;
-        }>;
-    }, "strip", z.ZodTypeAny, {
+        }>>;
+    }, z.core.$strip>, z.ZodTransform<GasSettings, {
         gasLimits: Gas;
         teardownGasLimits: Gas;
         maxFeesPerGas: GasFees;
         maxPriorityFeesPerGas: GasFees;
-    }, {
-        gasLimits: {
-            daGas: string | number | bigint;
-            l2Gas: string | number | bigint;
-        };
-        teardownGasLimits: {
-            daGas: string | number | bigint;
-            l2Gas: string | number | bigint;
-        };
-        maxFeesPerGas: {
-            feePerDaGas: string | number | bigint;
-            feePerL2Gas: string | number | bigint;
-        };
-        maxPriorityFeesPerGas: {
-            feePerDaGas: string | number | bigint;
-            feePerL2Gas: string | number | bigint;
-        };
-    }>, GasSettings, {
-        gasLimits: {
-            daGas: string | number | bigint;
-            l2Gas: string | number | bigint;
-        };
-        teardownGasLimits: {
-            daGas: string | number | bigint;
-            l2Gas: string | number | bigint;
-        };
-        maxFeesPerGas: {
-            feePerDaGas: string | number | bigint;
-            feePerL2Gas: string | number | bigint;
-        };
-        maxPriorityFeesPerGas: {
-            feePerDaGas: string | number | bigint;
-            feePerL2Gas: string | number | bigint;
-        };
-    }>;
+    }>>;
     getSize(): number;
     static from(args: {
         gasLimits: FieldsOf<Gas>;
@@ -124,8 +70,35 @@ export declare class GasSettings {
     getFeeLimit(): Fr;
     /** Zero-value gas settings. */
     static empty(): GasSettings;
-    /** Default gas settings to use when user has not provided them. Requires explicit max fees per gas. */
-    static default(overrides: {
+    /**
+     * 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. To be used in conjunction
+     * with skipTxValidation: true during public simulation, or the node would reject the transaction
+     * outright due to gas limits being above protocol max.
+     */
+    static forEstimation(overrides: {
         gasLimits?: Gas;
         teardownGasLimits?: Gas;
         maxFeesPerGas: GasFees;
@@ -134,9 +107,10 @@ export declare class GasSettings {
     isEmpty(): boolean;
     equals(other: GasSettings): boolean;
     static fromBuffer(buffer: Buffer | BufferReader): GasSettings;
-    toBuffer(): Buffer<ArrayBufferLike>;
+    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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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"gas_settings.d.ts","sourceRoot":"","sources":["../../src/gas/gas_settings.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAwC,MAAM,6BAA6B,CAAC;AAC9G,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,GAAG,EAAiB,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAGxC,mGAAmG;AACnG,qBAAa,WAAW;aAEJ,SAAS,EAAE,GAAG;aACd,iBAAiB,EAAE,GAAG;aACtB,aAAa,EAAE,OAAO;aACtB,qBAAqB,EAAE,OAAO;IAJhD,YACkB,SAAS,EAAE,GAAG,EACd,iBAAiB,EAAE,GAAG,EACtB,aAAa,EAAE,OAAO,EACtB,qBAAqB,EAAE,OAAO,EAC5C;IAGJ,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAShB;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,uGAAuG;IACvG,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE;QACxB,SAAS,CAAC,EAAE,GAAG,CAAC;QAChB,iBAAiB,CAAC,EAAE,GAAG,CAAC;QACxB,aAAa,EAAE,OAAO,CAAC;QACvB,qBAAqB,CAAC,EAAE,OAAO,CAAC;KACjC,eAUA;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,4BAEP;IAED,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"}
+{"version":3,"file":"gas_settings.d.ts","sourceRoot":"","sources":["../../src/gas/gas_settings.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAsC,MAAM,6BAA6B,CAAC;AACxH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,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;aAEJ,SAAS,EAAE,GAAG;aACd,iBAAiB,EAAE,GAAG;aACtB,aAAa,EAAE,OAAO;aACtB,qBAAqB,EAAE,OAAO;IAJhD,YACkB,SAAS,EAAE,GAAG,EACd,iBAAiB,EAAE,GAAG,EACtB,aAAa,EAAE,OAAO,EACtB,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

@@ -1,9 +1,16 @@
-import { DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT, DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT, GAS_SETTINGS_LENGTH } from '@aztec/constants';
+import { GAS_SETTINGS_LENGTH, MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { BufferReader, BufferSink, FieldReader, serializeToFields, serializeToSink } from '@aztec/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;
@@ -52,15 +59,45 @@ import { GasFees } from './gas_fees.js';
     /** Zero-value gas settings. */ static empty() {
         return new GasSettings(Gas.empty(), Gas.empty(), GasFees.empty(), GasFees.empty());
     }
-    /** Default gas settings to use when user has not provided them. Requires explicit max fees per gas. */ static default(overrides) {
+    /**
+   * 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. To be used in conjunction
+   * with skipTxValidation: true during public simulation, or the node would reject the transaction
+   * outright due to gas limits being above protocol max.
+   */ static forEstimation(overrides) {
         return GasSettings.from({
             gasLimits: overrides.gasLimits ?? {
-                l2Gas: DEFAULT_L2_GAS_LIMIT,
-                daGas: DEFAULT_DA_GAS_LIMIT
+                l2Gas: GAS_ESTIMATION_L2_GAS_LIMIT,
+                daGas: GAS_ESTIMATION_DA_GAS_LIMIT
             },
             teardownGasLimits: overrides.teardownGasLimits ?? {
-                l2Gas: DEFAULT_TEARDOWN_L2_GAS_LIMIT,
-                daGas: DEFAULT_TEARDOWN_DA_GAS_LIMIT
+                l2Gas: GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT,
+                daGas: GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT
             },
             maxFeesPerGas: overrides.maxFeesPerGas,
             maxPriorityFeesPerGas: overrides.maxPriorityFeesPerGas ?? GasFees.empty()
@@ -76,8 +113,11 @@ import { GasFees } from './gas_fees.js';
         const reader = BufferReader.asReader(buffer);
         return new GasSettings(reader.readObject(Gas), reader.readObject(Gas), reader.readObject(GasFees), reader.readObject(GasFees));
     }
-    toBuffer() {
-        return serializeToBuffer(...GasSettings.getFields(this));
+    toBuffer(sink) {
+        if (!sink) {
+            return BufferSink.serialize(this);
+        }
+        serializeToSink(sink, ...GasSettings.getFields(this));
     }
     static fromFields(fields) {
         const reader = FieldReader.asReader(fields);

package/dest/gas/index.d.ts

@@ -1,5 +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';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9nYXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGVBQWUsQ0FBQyJ9
+export * from './tx_gas_limits.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9nYXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLG9CQUFvQixDQUFDIn0=

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/gas/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC"}
+{"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

@@ -1,4 +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,72 @@
+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`),
+ * - the first block's block-end fields (`NUM_FIRST_BLOCK_END_BLOB_FIELDS`, 7), and
+ * - `NUM_BLOCK_END_BLOB_FIELDS` (6) for each of the `blocks - 1` subsequent 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfZ2FzX2xpbWl0cy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2dhcy90eF9nYXNfbGltaXRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWFBLE9BQU8sRUFBRSxLQUFLLHVCQUF1QixFQUEwQixNQUFNLDBDQUEwQyxDQUFDO0FBQ2hILE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDL0UsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUUvQjs7Ozs7R0FLRztBQUNILGVBQU8sTUFBTSxtQ0FBbUMsTUFBTSxDQUFDO0FBRXZEOzs7Ozs7O0dBT0c7QUFDSCxlQUFPLE1BQU0sc0NBQXNDLE1BQU0sQ0FBQztBQUUxRDs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FpQkc7QUFDSCx3QkFBZ0IsMkJBQTJCLENBQUMsc0JBQXNCLEVBQUUsTUFBTSxHQUFHLE1BQU0sQ0FZbEY7QUFFRDs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQW1CRztBQUNILHdCQUFnQix5QkFBeUIsQ0FBQyxJQUFJLEVBQUU7SUFBRSxzQkFBc0IsRUFBRSxNQUFNLENBQUM7SUFBQyxvQkFBb0IsRUFBRSxNQUFNLENBQUE7Q0FBRSxHQUFHLEdBQUcsQ0FxQnJIO0FBRUQ7Ozs7O0dBS0c7QUFDSCx3QkFBZ0IscUJBQXFCLENBQ25DLE1BQU0sRUFBRSx1QkFBdUIsRUFDL0IsV0FBVyxFQUFFLG1CQUFtQixHQUFHO0lBQUUsZUFBZSxFQUFFLE1BQU0sQ0FBQTtDQUFFLEdBQzdELEdBQUcsQ0FHTCJ9

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":"AAaA,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;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,2BAA2B,CAAC,sBAAsB,EAAE,MAAM,GAAG,MAAM,CAYlF;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,85 @@
+import { NUM_BLOCK_END_BLOB_FIELDS, NUM_CHECKPOINT_END_MARKER_FIELDS, NUM_FIRST_BLOCK_END_BLOB_FIELDS } from '@aztec/blob-lib/encoding';
+import { BLOBS_PER_CHECKPOINT, DA_GAS_PER_FIELD, FIELDS_PER_BLOB, MAX_PROCESSABLE_L2_GAS, MAX_TX_DA_GAS } from '@aztec/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`),
+ * - the first block's block-end fields (`NUM_FIRST_BLOCK_END_BLOB_FIELDS`, 7), and
+ * - `NUM_BLOCK_END_BLOB_FIELDS` (6) for each of the `blocks - 1` subsequent 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 - NUM_FIRST_BLOCK_END_BLOB_FIELDS - (blocks - 1) * 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
+    });
+}

package/dest/ha-signing/config.d.ts

@@ -0,0 +1,86 @@
+import { type L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import { type ConfigMappingsType, SecretValue } from '@aztec/foundation/config';
+import { z } from 'zod';
+/**
+ * Base signing protection configuration shared by both HA (Postgres) and local (LMDB) signers.
+ */
+export type BaseSignerConfig = {
+    /** Unique identifier for this node */
+    nodeId: string;
+    /** How long to wait between polls when a duty is being signed (ms) */
+    pollingIntervalMs: number;
+    /**
+     * How long (ms) to wait for a peer node's in-progress signing before giving up and treating the
+     * duty as already handled. This is the cross-node wait/poll timeout, distinct from
+     * signerCallTimeoutMs (the hard upper bound on this node's own signer call).
+     */
+    peerSigningTimeoutMs: number;
+    /**
+     * Hard upper bound (ms) on a single signer call made by this node. If the (possibly remote)
+     * signer does not return within this time, the call is aborted, the duty lock is released, and
+     * signing fails so it can be safely retried. The effective value is clamped to
+     * maxStuckDutiesAgeMs / 2 at construction, so a slow signer's lock is always released before
+     * stuck-duty cleanup could reclaim it. Defaults to 30_000 when unset.
+     */
+    signerCallTimeoutMs?: number;
+    /** Maximum age of a stuck duty in ms (defaults to 2x hardcoded Aztec slot duration if not set) */
+    maxStuckDutiesAgeMs?: number;
+    /** Optional: clean up old duties after this many hours (disabled if not set) */
+    cleanupOldDutiesAfterHours?: number;
+} & Pick<L1ContractAddresses, 'rollupAddress'>;
+export declare const baseSignerConfigMappings: ConfigMappingsType<BaseSignerConfig>;
+export declare const BaseSignerConfigSchema: z.ZodObject<{
+    rollupAddress: z.ZodType<import("@aztec/foundation/eth-address").EthAddress, string, z.core.$ZodTypeInternals<import("@aztec/foundation/eth-address").EthAddress, string>>;
+    nodeId: z.ZodString;
+    pollingIntervalMs: z.ZodNumber;
+    peerSigningTimeoutMs: z.ZodNumber;
+    signerCallTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    maxStuckDutiesAgeMs: z.ZodOptional<z.ZodNumber>;
+    cleanupOldDutiesAfterHours: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Configuration for the Validator HA Signer.
+ *
+ * Extends BaseSignerConfig with a flag to enable HA mode and Postgres connection settings.
+ */
+export interface ValidatorHASignerConfig extends BaseSignerConfig {
+    /** Whether HA signing / slashing protection is enabled */
+    haSigningEnabled: boolean;
+    /**
+     * PostgreSQL connection string
+     * Format: postgresql://user:password@host:port/database
+     */
+    databaseUrl?: SecretValue<string>;
+    /** Maximum number of clients in the pool (default: 10) */
+    poolMaxCount?: number;
+    /** Minimum number of clients in the pool (default: 0) */
+    poolMinCount?: number;
+    /** Idle timeout in milliseconds (default: 10000) */
+    poolIdleTimeoutMs?: number;
+    /** Connection timeout in milliseconds (default: 0, no timeout) */
+    poolConnectionTimeoutMs?: number;
+}
+export declare const validatorHASignerConfigMappings: ConfigMappingsType<ValidatorHASignerConfig>;
+export declare const defaultValidatorHASignerConfig: ValidatorHASignerConfig;
+/**
+ * Returns the validator HA signer configuration from environment variables.
+ * Note: If an environment variable is not set, the default value is used.
+ * @returns The validator HA signer configuration.
+ */
+export declare function getConfigEnvVars(): ValidatorHASignerConfig;
+export declare const ValidatorHASignerConfigSchema: z.ZodObject<{
+    rollupAddress: z.ZodType<import("@aztec/foundation/eth-address").EthAddress, string, z.core.$ZodTypeInternals<import("@aztec/foundation/eth-address").EthAddress, string>>;
+    nodeId: z.ZodString;
+    pollingIntervalMs: z.ZodNumber;
+    peerSigningTimeoutMs: z.ZodNumber;
+    signerCallTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    maxStuckDutiesAgeMs: z.ZodOptional<z.ZodNumber>;
+    cleanupOldDutiesAfterHours: z.ZodOptional<z.ZodNumber>;
+    haSigningEnabled: z.ZodBoolean;
+    databaseUrl: z.ZodOptional<z.ZodType<SecretValue<string>, any, z.core.$ZodTypeInternals<SecretValue<string>, any>>>;
+    poolMaxCount: z.ZodOptional<z.ZodNumber>;
+    poolMinCount: z.ZodOptional<z.ZodNumber>;
+    poolIdleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    poolConnectionTimeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaGEtc2lnbmluZy9jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLEtBQUssbUJBQW1CLEVBR3pCLE1BQU0sdUNBQXVDLENBQUM7QUFDL0MsT0FBTyxFQUNMLEtBQUssa0JBQWtCLEVBQ3ZCLFdBQVcsRUFPWixNQUFNLDBCQUEwQixDQUFDO0FBR2xDLE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEI7O0dBRUc7QUFDSCxNQUFNLE1BQU0sZ0JBQWdCLEdBQUc7SUFDN0Isc0NBQXNDO0lBQ3RDLE1BQU0sRUFBRSxNQUFNLENBQUM7SUFDZixzRUFBc0U7SUFDdEUsaUJBQWlCLEVBQUUsTUFBTSxDQUFDO0lBQzFCOzs7O09BSUc7SUFDSCxvQkFBb0IsRUFBRSxNQUFNLENBQUM7SUFDN0I7Ozs7OztPQU1HO0lBQ0gsbUJBQW1CLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDN0Isa0dBQWtHO0lBQ2xHLG1CQUFtQixDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQzdCLGdGQUFnRjtJQUNoRiwwQkFBMEIsQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUNyQyxHQUFHLElBQUksQ0FBQyxtQkFBbUIsRUFBRSxlQUFlLENBQUMsQ0FBQztBQUUvQyxlQUFPLE1BQU0sd0JBQXdCLEVBQUUsa0JBQWtCLENBQUMsZ0JBQWdCLENBZ0N6RSxDQUFDO0FBRUYsZUFBTyxNQUFNLHNCQUFzQjs7Ozs7Ozs7aUJBUUUsQ0FBQztBQUV0Qzs7OztHQUlHO0FBQ0gsTUFBTSxXQUFXLHVCQUF3QixTQUFRLGdCQUFnQjtJQUMvRCwwREFBMEQ7SUFDMUQsZ0JBQWdCLEVBQUUsT0FBTyxDQUFDO0lBQzFCOzs7T0FHRztJQUNILFdBQVcsQ0FBQyxFQUFFLFdBQVcsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUNsQywwREFBMEQ7SUFDMUQsWUFBWSxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3RCLHlEQUF5RDtJQUN6RCxZQUFZLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDdEIsb0RBQW9EO0lBQ3BELGlCQUFpQixDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQzNCLGtFQUFrRTtJQUNsRSx1QkFBdUIsQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUNsQztBQUVELGVBQU8sTUFBTSwrQkFBK0IsRUFBRSxrQkFBa0IsQ0FBQyx1QkFBdUIsQ0FpQ3ZGLENBQUM7QUFFRixlQUFPLE1BQU0sOEJBQThCLEVBQUUsdUJBRTVDLENBQUM7QUFFRjs7OztHQUlHO0FBQ0gsd0JBQWdCLGdCQUFnQixJQUFJLHVCQUF1QixDQUUxRDtBQUVELGVBQU8sTUFBTSw2QkFBNkI7Ozs7Ozs7Ozs7Ozs7O2lCQU9FLENBQUMifQ==

package/dest/ha-signing/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/ha-signing/config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EAGzB,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EACL,KAAK,kBAAkB,EACvB,WAAW,EAOZ,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,oBAAoB,EAAE,MAAM,CAAC;IAC7B;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,kGAAkG;IAClG,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,gFAAgF;IAChF,0BAA0B,CAAC,EAAE,MAAM,CAAC;CACrC,GAAG,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC,CAAC;AAE/C,eAAO,MAAM,wBAAwB,EAAE,kBAAkB,CAAC,gBAAgB,CAgCzE,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;iBAQE,CAAC;AAEtC;;;;GAIG;AACH,MAAM,WAAW,uBAAwB,SAAQ,gBAAgB;IAC/D,0DAA0D;IAC1D,gBAAgB,EAAE,OAAO,CAAC;IAC1B;;;OAGG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAClC,0DAA0D;IAC1D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yDAAyD;IACzD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oDAAoD;IACpD,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kEAAkE;IAClE,uBAAuB,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,eAAO,MAAM,+BAA+B,EAAE,kBAAkB,CAAC,uBAAuB,CAiCvF,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,uBAE5C,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,uBAAuB,CAE1D;AAED,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;iBAOE,CAAC"}