@aztec/cli 0.0.1-commit.ec5f612 → 0.0.1-commit.ef17749e1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (13) hide show
  1. package/dest/config/cached_fetch.d.ts +19 -10
  2. package/dest/config/cached_fetch.d.ts.map +1 -1
  3. package/dest/config/cached_fetch.js +110 -32
  4. package/dest/config/generated/networks.d.ts +15 -15
  5. package/dest/config/generated/networks.d.ts.map +1 -1
  6. package/dest/config/generated/networks.js +16 -16
  7. package/dest/config/network_config.d.ts +1 -1
  8. package/dest/config/network_config.d.ts.map +1 -1
  9. package/dest/config/network_config.js +3 -2
  10. package/package.json +30 -30
  11. package/src/config/cached_fetch.ts +119 -31
  12. package/src/config/generated/networks.ts +14 -14
  13. package/src/config/network_config.ts +3 -2
package/dest/config/cached_fetch.d.ts CHANGED
@@ -1,18 +1,27 @@
1
1
  export interface CachedFetchOptions {
2
- /** Cache duration in milliseconds */
3
- cacheDurationMs: number;
4
- /** The cache file */
2
+ /** The cache file path for storing data. If not provided, no caching is performed. */
5
3
  cacheFile?: string;
4
+ /** Fallback max-age in milliseconds when server sends no Cache-Control header. Defaults to 5 minutes. */
5
+ defaultMaxAgeMs?: number;
6
6
  }
7
+ /** Extracts max-age value in milliseconds from a Response's Cache-Control header. Returns undefined if not present. */
8
+ export declare function parseMaxAge(response: {
9
+ headers: {
10
+ get(name: string): string | null;
11
+ };
12
+ }): number | undefined;
7
13
  /**
8
- * Fetches data from a URL with file-based caching support.
9
- * This utility can be used by both remote config and bootnodes fetching.
14
+ * Fetches data from a URL with file-based HTTP conditional caching.
15
+ *
16
+ * Data is stored as raw JSON in the cache file (same format as the server returns).
17
+ * Caching metadata (ETag, expiry) is stored in a separate sidecar `.meta` file.
18
+ * This keeps the data file human-readable and backward-compatible with older code.
10
19
  *
11
20
  * @param url - The URL to fetch from
12
- * @param networkName - Network name for cache directory structure
13
- * @param options - Caching and error handling options
14
- * @param cacheDir - Optional cache directory (defaults to no caching)
15
- * @returns The fetched and parsed JSON data, or undefined if fetch fails and throwOnError is false
21
+ * @param options - Caching options
22
+ * @param fetch - Fetch implementation (defaults to globalThis.fetch)
23
+ * @param log - Logger instance
24
+ * @returns The fetched and parsed JSON data, or undefined if fetch fails
16
25
  */
17
26
  export declare function cachedFetch<T = any>(url: string, options: CachedFetchOptions, fetch?: typeof globalThis.fetch, log?: import("@aztec/aztec.js/log").Logger): Promise<T | undefined>;
18
- //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGVkX2ZldGNoLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL2NhY2hlZF9mZXRjaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSxNQUFNLFdBQVcsa0JBQWtCO0lBQ2pDLHFDQUFxQztJQUNyQyxlQUFlLEVBQUUsTUFBTSxDQUFDO0lBQ3hCLHFCQUFxQjtJQUNyQixTQUFTLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDcEI7QUFFRDs7Ozs7Ozs7O0dBU0c7QUFDSCx3QkFBc0IsV0FBVyxDQUFDLENBQUMsR0FBRyxHQUFHLEVBQ3ZDLEdBQUcsRUFBRSxNQUFNLEVBQ1gsT0FBTyxFQUFFLGtCQUFrQixFQUMzQixLQUFLLDBCQUFtQixFQUN4QixHQUFHLHVDQUErQixHQUNqQyxPQUFPLENBQUMsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxDQXVDeEIifQ==
27
+ //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGVkX2ZldGNoLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL2NhY2hlZF9mZXRjaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSxNQUFNLFdBQVcsa0JBQWtCO0lBQ2pDLHNGQUFzRjtJQUN0RixTQUFTLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDbkIseUdBQXlHO0lBQ3pHLGVBQWUsQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUMxQjtBQVVELHVIQUF1SDtBQUN2SCx3QkFBZ0IsV0FBVyxDQUFDLFFBQVEsRUFBRTtJQUFFLE9BQU8sRUFBRTtRQUFFLEdBQUcsQ0FBQyxJQUFJLEVBQUUsTUFBTSxHQUFHLE1BQU0sR0FBRyxJQUFJLENBQUE7S0FBRSxDQUFBO0NBQUUsR0FBRyxNQUFNLEdBQUcsU0FBUyxDQVUzRztBQUVEOzs7Ozs7Ozs7Ozs7R0FZRztBQUNILHdCQUFzQixXQUFXLENBQUMsQ0FBQyxHQUFHLEdBQUcsRUFDdkMsR0FBRyxFQUFFLE1BQU0sRUFDWCxPQUFPLEVBQUUsa0JBQWtCLEVBQzNCLEtBQUssMEJBQW1CLEVBQ3hCLEdBQUcsdUNBQStCLEdBQ2pDLE9BQU8sQ0FBQyxDQUFDLEdBQUcsU0FBUyxDQUFDLENBb0V4QiJ9
package/dest/config/cached_fetch.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"cached_fetch.d.ts","sourceRoot":"","sources":["../../src/config/cached_fetch.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,kBAAkB;IACjC,qCAAqC;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB,qBAAqB;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,CAAC,GAAG,GAAG,EACvC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,kBAAkB,EAC3B,KAAK,0BAAmB,EACxB,GAAG,uCAA+B,GACjC,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAuCxB"}
1
+ {"version":3,"file":"cached_fetch.d.ts","sourceRoot":"","sources":["../../src/config/cached_fetch.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,kBAAkB;IACjC,sFAAsF;IACtF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yGAAyG;IACzG,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAUD,uHAAuH;AACvH,wBAAgB,WAAW,CAAC,QAAQ,EAAE;IAAE,OAAO,EAAE;QAAE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;KAAE,CAAA;CAAE,GAAG,MAAM,GAAG,SAAS,CAU3G;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,WAAW,CAAC,CAAC,GAAG,GAAG,EACvC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,kBAAkB,EAC3B,KAAK,0BAAmB,EACxB,GAAG,uCAA+B,GACjC,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAoExB"}
package/dest/config/cached_fetch.js CHANGED
@@ -1,50 +1,105 @@
1
1
  import { createLogger } from '@aztec/aztec.js/log';
2
- import { mkdir, readFile, stat, writeFile } from 'fs/promises';
2
+ import { mkdir, readFile, writeFile } from 'fs/promises';
3
3
  import { dirname } from 'path';
4
+ const DEFAULT_MAX_AGE_MS = 5 * 60 * 1000; // 5 minutes
5
+ /** Extracts max-age value in milliseconds from a Response's Cache-Control header. Returns undefined if not present. */ export function parseMaxAge(response) {
6
+ const cacheControl = response.headers.get('cache-control');
7
+ if (!cacheControl) {
8
+ return undefined;
9
+ }
10
+ const match = cacheControl.match(/max-age=(\d+)/);
11
+ if (!match) {
12
+ return undefined;
13
+ }
14
+ return parseInt(match[1], 10) * 1000;
15
+ }
4
16
  /**
5
- * Fetches data from a URL with file-based caching support.
6
- * This utility can be used by both remote config and bootnodes fetching.
17
+ * Fetches data from a URL with file-based HTTP conditional caching.
18
+ *
19
+ * Data is stored as raw JSON in the cache file (same format as the server returns).
20
+ * Caching metadata (ETag, expiry) is stored in a separate sidecar `.meta` file.
21
+ * This keeps the data file human-readable and backward-compatible with older code.
7
22
  *
8
23
  * @param url - The URL to fetch from
9
- * @param networkName - Network name for cache directory structure
10
- * @param options - Caching and error handling options
11
- * @param cacheDir - Optional cache directory (defaults to no caching)
12
- * @returns The fetched and parsed JSON data, or undefined if fetch fails and throwOnError is false
24
+ * @param options - Caching options
25
+ * @param fetch - Fetch implementation (defaults to globalThis.fetch)
26
+ * @param log - Logger instance
27
+ * @returns The fetched and parsed JSON data, or undefined if fetch fails
13
28
  */ export async function cachedFetch(url, options, fetch = globalThis.fetch, log = createLogger('cached_fetch')) {
14
- const { cacheDurationMs, cacheFile } = options;
15
- // Try to read from cache first
29
+ const { cacheFile, defaultMaxAgeMs = DEFAULT_MAX_AGE_MS } = options;
30
+ // If no cacheFile, just fetch normally without caching
31
+ if (!cacheFile) {
32
+ return fetchAndParse(url, fetch, log);
33
+ }
34
+ const metaFile = cacheFile + '.meta';
35
+ // Try to read metadata
36
+ let meta;
16
37
  try {
17
- if (cacheFile) {
18
- const info = await stat(cacheFile);
19
- if (info.mtimeMs + cacheDurationMs > Date.now()) {
20
- const cachedData = JSON.parse(await readFile(cacheFile, 'utf-8'));
21
- return cachedData;
22
- }
23
- }
38
+ meta = JSON.parse(await readFile(metaFile, 'utf-8'));
24
39
  } catch {
25
- log.trace('Failed to read data from cache');
40
+ log.trace('No usable cache metadata found');
26
41
  }
42
+ // Try to read cached data
43
+ let cachedData;
27
44
  try {
28
- const response = await fetch(url);
45
+ cachedData = JSON.parse(await readFile(cacheFile, 'utf-8'));
46
+ } catch {
47
+ log.trace('No usable cached data found');
48
+ }
49
+ // If metadata and data exist and cache is fresh, return directly
50
+ if (meta && cachedData !== undefined && meta.expiresAt > Date.now()) {
51
+ return cachedData;
52
+ }
53
+ // Cache is stale or missing — make a (possibly conditional) request
54
+ try {
55
+ const headers = {};
56
+ if (meta?.etag && cachedData !== undefined) {
57
+ headers['If-None-Match'] = meta.etag;
58
+ }
59
+ const response = await fetch(url, {
60
+ headers
61
+ });
62
+ if (response.status === 304 && cachedData !== undefined) {
63
+ // Not modified — recompute expiry from new response headers and return cached data
64
+ const maxAgeMs = parseMaxAge(response) ?? defaultMaxAgeMs;
65
+ await writeMetaFile(metaFile, {
66
+ etag: meta?.etag,
67
+ expiresAt: Date.now() + maxAgeMs
68
+ }, log);
69
+ return cachedData;
70
+ }
29
71
  if (!response.ok) {
30
72
  log.warn(`Failed to fetch from ${url}: ${response.status} ${response.statusText}`);
31
- return undefined;
73
+ return cachedData;
32
74
  }
75
+ // 200 — parse new data and cache it
33
76
  const data = await response.json();
34
- try {
35
- if (cacheFile) {
36
- await mkdir(dirname(cacheFile), {
37
- recursive: true
38
- });
39
- await writeFile(cacheFile, JSON.stringify(data), 'utf-8');
40
- }
41
- } catch (err) {
42
- log.warn('Failed to cache data on disk: ' + cacheFile, {
43
- cacheFile,
44
- err
45
- });
46
- }
77
+ const maxAgeMs = parseMaxAge(response) ?? defaultMaxAgeMs;
78
+ const etag = response.headers.get('etag') ?? undefined;
79
+ await ensureDir(cacheFile, log);
80
+ await Promise.all([
81
+ writeFile(cacheFile, JSON.stringify(data), 'utf-8'),
82
+ writeFile(metaFile, JSON.stringify({
83
+ etag,
84
+ expiresAt: Date.now() + maxAgeMs
85
+ }), 'utf-8')
86
+ ]);
47
87
  return data;
88
+ } catch (err) {
89
+ log.warn(`Failed to fetch from ${url}`, {
90
+ err
91
+ });
92
+ return cachedData;
93
+ }
94
+ }
95
+ async function fetchAndParse(url, fetch, log) {
96
+ try {
97
+ const response = await fetch(url);
98
+ if (!response.ok) {
99
+ log.warn(`Failed to fetch from ${url}: ${response.status} ${response.statusText}`);
100
+ return undefined;
101
+ }
102
+ return await response.json();
48
103
  } catch (err) {
49
104
  log.warn(`Failed to fetch from ${url}`, {
50
105
  err
@@ -52,3 +107,26 @@ import { dirname } from 'path';
52
107
  return undefined;
53
108
  }
54
109
  }
110
+ async function ensureDir(filePath, log) {
111
+ try {
112
+ await mkdir(dirname(filePath), {
113
+ recursive: true
114
+ });
115
+ } catch (err) {
116
+ log.warn('Failed to create cache directory for: ' + filePath, {
117
+ err
118
+ });
119
+ }
120
+ }
121
+ async function writeMetaFile(metaFile, meta, log) {
122
+ try {
123
+ await mkdir(dirname(metaFile), {
124
+ recursive: true
125
+ });
126
+ await writeFile(metaFile, JSON.stringify(meta), 'utf-8');
127
+ } catch (err) {
128
+ log.warn('Failed to write cache metadata: ' + metaFile, {
129
+ err
130
+ });
131
+ }
132
+ }
package/dest/config/generated/networks.d.ts CHANGED
@@ -24,7 +24,7 @@ export declare const devnetConfig: {
24
24
  readonly SLASH_MIN_PENALTY_PERCENTAGE: 0.5;
25
25
  readonly SLASH_MAX_PENALTY_PERCENTAGE: 2;
26
26
  readonly SLASH_OFFENSE_EXPIRATION_ROUNDS: 4;
27
- readonly SLASH_MAX_PAYLOAD_SIZE: 50;
27
+ readonly SLASH_MAX_PAYLOAD_SIZE: 80;
28
28
  readonly SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4;
29
29
  readonly P2P_ENABLED: true;
30
30
  readonly BOOTSTRAP_NODES: "";
@@ -55,8 +55,6 @@ export declare const devnetConfig: {
55
55
  readonly BLOB_ALLOW_EMPTY_SOURCES: false;
56
56
  readonly P2P_MAX_PENDING_TX_COUNT: 1000;
57
57
  readonly P2P_TX_POOL_DELETE_TXS_AFTER_REORG: false;
58
- readonly AUTO_UPDATE: "none";
59
- readonly AUTO_UPDATE_URL: "";
60
58
  readonly PUBLIC_OTEL_OPT_OUT: true;
61
59
  readonly PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: "";
62
60
  readonly PUBLIC_OTEL_COLLECT_FROM: "";
@@ -72,6 +70,7 @@ export declare const devnetConfig: {
72
70
  readonly SLASH_UNKNOWN_PENALTY: 10000000000000000000;
73
71
  readonly SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000;
74
72
  readonly SLASH_GRACE_PERIOD_L2_SLOTS: 0;
73
+ readonly ENABLE_VERSION_CHECK: true;
75
74
  };
76
75
  export declare const testnetConfig: {
77
76
  readonly ETHEREUM_SLOT_DURATION: 12;
@@ -91,7 +90,7 @@ export declare const testnetConfig: {
91
90
  readonly SLASH_MIN_PENALTY_PERCENTAGE: 0.5;
92
91
  readonly SLASH_MAX_PENALTY_PERCENTAGE: 2;
93
92
  readonly SLASH_OFFENSE_EXPIRATION_ROUNDS: 4;
94
- readonly SLASH_MAX_PAYLOAD_SIZE: 50;
93
+ readonly SLASH_MAX_PAYLOAD_SIZE: 80;
95
94
  readonly SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4;
96
95
  readonly P2P_ENABLED: true;
97
96
  readonly BOOTSTRAP_NODES: "";
@@ -124,8 +123,9 @@ export declare const testnetConfig: {
124
123
  readonly TEST_ACCOUNTS: false;
125
124
  readonly SPONSORED_FPC: true;
126
125
  readonly TRANSACTIONS_DISABLED: false;
127
- readonly SEQ_MAX_TX_PER_BLOCK: 2;
126
+ readonly SEQ_MAX_TX_PER_CHECKPOINT: 72;
128
127
  readonly PROVER_REAL_PROOFS: true;
128
+ readonly P2P_MAX_PENDING_TX_COUNT: 1000;
129
129
  readonly P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true;
130
130
  readonly SLASH_PRUNE_PENALTY: 10000000000000000000;
131
131
  readonly SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000;
@@ -139,6 +139,7 @@ export declare const testnetConfig: {
139
139
  readonly SLASH_UNKNOWN_PENALTY: 10000000000000000000;
140
140
  readonly SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000;
141
141
  readonly SLASH_GRACE_PERIOD_L2_SLOTS: 64;
142
+ readonly ENABLE_VERSION_CHECK: true;
142
143
  };
143
144
  export declare const mainnetConfig: {
144
145
  readonly ETHEREUM_SLOT_DURATION: 12;
@@ -155,7 +156,7 @@ export declare const mainnetConfig: {
155
156
  readonly SLASH_MIN_PENALTY_PERCENTAGE: 0.5;
156
157
  readonly SLASH_MAX_PENALTY_PERCENTAGE: 2;
157
158
  readonly SLASH_OFFENSE_EXPIRATION_ROUNDS: 4;
158
- readonly SLASH_MAX_PAYLOAD_SIZE: 50;
159
+ readonly SLASH_MAX_PAYLOAD_SIZE: 80;
159
160
  readonly SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4;
160
161
  readonly P2P_ENABLED: true;
161
162
  readonly BOOTSTRAP_NODES: "";
@@ -173,7 +174,7 @@ export declare const mainnetConfig: {
173
174
  readonly AZTEC_SLOT_DURATION: 72;
174
175
  readonly AZTEC_ACTIVATION_THRESHOLD: 2e+23;
175
176
  readonly AZTEC_EJECTION_THRESHOLD: 1e+23;
176
- readonly AZTEC_LOCAL_EJECTION_THRESHOLD: 1.62e+23;
177
+ readonly AZTEC_LOCAL_EJECTION_THRESHOLD: 1.9e+23;
177
178
  readonly AZTEC_SLASH_AMOUNT_SMALL: 2e+21;
178
179
  readonly AZTEC_SLASH_AMOUNT_MEDIUM: 2e+21;
179
180
  readonly AZTEC_SLASH_AMOUNT_LARGE: 2e+21;
@@ -195,17 +196,16 @@ export declare const mainnetConfig: {
195
196
  readonly L1_CHAIN_ID: 1;
196
197
  readonly TEST_ACCOUNTS: false;
197
198
  readonly SPONSORED_FPC: false;
198
- readonly TRANSACTIONS_DISABLED: true;
199
- readonly SEQ_MAX_TX_PER_BLOCK: 0;
199
+ readonly TRANSACTIONS_DISABLED: false;
200
+ readonly SEQ_MAX_TX_PER_CHECKPOINT: 72;
200
201
  readonly PROVER_REAL_PROOFS: true;
201
202
  readonly SYNC_SNAPSHOTS_URLS: "https://aztec-labs-snapshots.com/mainnet/";
202
203
  readonly BLOB_ALLOW_EMPTY_SOURCES: true;
203
- readonly P2P_MAX_PENDING_TX_COUNT: 0;
204
+ readonly P2P_MAX_PENDING_TX_COUNT: 1000;
204
205
  readonly P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true;
205
- readonly AUTO_UPDATE: "notify";
206
- readonly AUTO_UPDATE_URL: "https://storage.googleapis.com/aztec-mainnet/auto-update/mainnet.json";
207
- readonly PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: "https://telemetry.alpha-testnet.aztec-labs.com/v1/metrics";
208
- readonly PUBLIC_OTEL_COLLECT_FROM: "sequencer";
206
+ readonly PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: "";
207
+ readonly PUBLIC_OTEL_COLLECT_FROM: "";
208
+ readonly ENABLE_VERSION_CHECK: false;
209
209
  readonly SLASH_PRUNE_PENALTY: 0;
210
210
  readonly SLASH_DATA_WITHHOLDING_PENALTY: 0;
211
211
  readonly SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.8;
@@ -219,4 +219,4 @@ export declare const mainnetConfig: {
219
219
  readonly SLASH_INVALID_BLOCK_PENALTY: 2e+21;
220
220
  readonly SLASH_GRACE_PERIOD_L2_SLOTS: 1200;
221
221
  };
222
- //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29ya3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25maWcvZ2VuZXJhdGVkL25ldHdvcmtzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLGVBQU8sTUFBTSxZQUFZOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztDQTBFZixDQUFDO0FBRVgsZUFBTyxNQUFNLGFBQWE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztDQWtFaEIsQ0FBQztBQUVYLGVBQU8sTUFBTSxhQUFhOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0E4RWhCLENBQUMifQ==
222
+ //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29ya3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25maWcvZ2VuZXJhdGVkL25ldHdvcmtzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLGVBQU8sTUFBTSxZQUFZOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBeUVmLENBQUM7QUFFWCxlQUFPLE1BQU0sYUFBYTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0FvRWhCLENBQUM7QUFFWCxlQUFPLE1BQU0sYUFBYTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0E2RWhCLENBQUMifQ==
package/dest/config/generated/networks.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"networks.d.ts","sourceRoot":"","sources":["../../../src/config/generated/networks.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Ef,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkEhB,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8EhB,CAAC"}
1
+ {"version":3,"file":"networks.d.ts","sourceRoot":"","sources":["../../../src/config/generated/networks.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyEf,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoEhB,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6EhB,CAAC"}
package/dest/config/generated/networks.js CHANGED
@@ -26,7 +26,7 @@ export const devnetConfig = {
26
26
  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
27
27
  SLASH_MAX_PENALTY_PERCENTAGE: 2,
28
28
  SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
29
- SLASH_MAX_PAYLOAD_SIZE: 50,
29
+ SLASH_MAX_PAYLOAD_SIZE: 80,
30
30
  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
31
31
  P2P_ENABLED: true,
32
32
  BOOTSTRAP_NODES: '',
@@ -57,8 +57,6 @@ export const devnetConfig = {
57
57
  BLOB_ALLOW_EMPTY_SOURCES: false,
58
58
  P2P_MAX_PENDING_TX_COUNT: 1000,
59
59
  P2P_TX_POOL_DELETE_TXS_AFTER_REORG: false,
60
- AUTO_UPDATE: 'none',
61
- AUTO_UPDATE_URL: '',
62
60
  PUBLIC_OTEL_OPT_OUT: true,
63
61
  PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '',
64
62
  PUBLIC_OTEL_COLLECT_FROM: '',
@@ -73,7 +71,8 @@ export const devnetConfig = {
73
71
  SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000,
74
72
  SLASH_UNKNOWN_PENALTY: 10000000000000000000,
75
73
  SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
76
- SLASH_GRACE_PERIOD_L2_SLOTS: 0
74
+ SLASH_GRACE_PERIOD_L2_SLOTS: 0,
75
+ ENABLE_VERSION_CHECK: true
77
76
  };
78
77
  export const testnetConfig = {
79
78
  ETHEREUM_SLOT_DURATION: 12,
@@ -93,7 +92,7 @@ export const testnetConfig = {
93
92
  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
94
93
  SLASH_MAX_PENALTY_PERCENTAGE: 2,
95
94
  SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
96
- SLASH_MAX_PAYLOAD_SIZE: 50,
95
+ SLASH_MAX_PAYLOAD_SIZE: 80,
97
96
  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
98
97
  P2P_ENABLED: true,
99
98
  BOOTSTRAP_NODES: '',
@@ -126,8 +125,9 @@ export const testnetConfig = {
126
125
  TEST_ACCOUNTS: false,
127
126
  SPONSORED_FPC: true,
128
127
  TRANSACTIONS_DISABLED: false,
129
- SEQ_MAX_TX_PER_BLOCK: 2,
128
+ SEQ_MAX_TX_PER_CHECKPOINT: 72,
130
129
  PROVER_REAL_PROOFS: true,
130
+ P2P_MAX_PENDING_TX_COUNT: 1000,
131
131
  P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true,
132
132
  SLASH_PRUNE_PENALTY: 10000000000000000000,
133
133
  SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000,
@@ -140,7 +140,8 @@ export const testnetConfig = {
140
140
  SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000,
141
141
  SLASH_UNKNOWN_PENALTY: 10000000000000000000,
142
142
  SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
143
- SLASH_GRACE_PERIOD_L2_SLOTS: 64
143
+ SLASH_GRACE_PERIOD_L2_SLOTS: 64,
144
+ ENABLE_VERSION_CHECK: true
144
145
  };
145
146
  export const mainnetConfig = {
146
147
  ETHEREUM_SLOT_DURATION: 12,
@@ -157,7 +158,7 @@ export const mainnetConfig = {
157
158
  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
158
159
  SLASH_MAX_PENALTY_PERCENTAGE: 2,
159
160
  SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
160
- SLASH_MAX_PAYLOAD_SIZE: 50,
161
+ SLASH_MAX_PAYLOAD_SIZE: 80,
161
162
  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
162
163
  P2P_ENABLED: true,
163
164
  BOOTSTRAP_NODES: '',
@@ -175,7 +176,7 @@ export const mainnetConfig = {
175
176
  AZTEC_SLOT_DURATION: 72,
176
177
  AZTEC_ACTIVATION_THRESHOLD: 2E+23,
177
178
  AZTEC_EJECTION_THRESHOLD: 1E+23,
178
- AZTEC_LOCAL_EJECTION_THRESHOLD: 1.62E+23,
179
+ AZTEC_LOCAL_EJECTION_THRESHOLD: 1.9E+23,
179
180
  AZTEC_SLASH_AMOUNT_SMALL: 2E+21,
180
181
  AZTEC_SLASH_AMOUNT_MEDIUM: 2E+21,
181
182
  AZTEC_SLASH_AMOUNT_LARGE: 2E+21,
@@ -197,17 +198,16 @@ export const mainnetConfig = {
197
198
  L1_CHAIN_ID: 1,
198
199
  TEST_ACCOUNTS: false,
199
200
  SPONSORED_FPC: false,
200
- TRANSACTIONS_DISABLED: true,
201
- SEQ_MAX_TX_PER_BLOCK: 0,
201
+ TRANSACTIONS_DISABLED: false,
202
+ SEQ_MAX_TX_PER_CHECKPOINT: 72,
202
203
  PROVER_REAL_PROOFS: true,
203
204
  SYNC_SNAPSHOTS_URLS: 'https://aztec-labs-snapshots.com/mainnet/',
204
205
  BLOB_ALLOW_EMPTY_SOURCES: true,
205
- P2P_MAX_PENDING_TX_COUNT: 0,
206
+ P2P_MAX_PENDING_TX_COUNT: 1000,
206
207
  P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true,
207
- AUTO_UPDATE: 'notify',
208
- AUTO_UPDATE_URL: 'https://storage.googleapis.com/aztec-mainnet/auto-update/mainnet.json',
209
- PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: 'https://telemetry.alpha-testnet.aztec-labs.com/v1/metrics',
210
- PUBLIC_OTEL_COLLECT_FROM: 'sequencer',
208
+ PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '',
209
+ PUBLIC_OTEL_COLLECT_FROM: '',
210
+ ENABLE_VERSION_CHECK: false,
211
211
  SLASH_PRUNE_PENALTY: 0,
212
212
  SLASH_DATA_WITHHOLDING_PENALTY: 0,
213
213
  SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.8,
package/dest/config/network_config.d.ts CHANGED
@@ -19,4 +19,4 @@ export declare function getNetworkConfig(networkName: NetworkNames, cacheDir?: s
19
19
  * Does not throw if the network simply doesn't exist in the config - just returns without enriching
20
20
  */
21
21
  export declare function enrichEnvironmentWithNetworkConfig(networkName: NetworkNames): Promise<void>;
22
- //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29ya19jb25maWcuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25maWcvbmV0d29ya19jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssYUFBYSxFQUEwQixLQUFLLFlBQVksRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBYXpHOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQXNCLGdCQUFnQixDQUNwQyxXQUFXLEVBQUUsWUFBWSxFQUN6QixRQUFRLENBQUMsRUFBRSxNQUFNLEdBQ2hCLE9BQU8sQ0FBQyxhQUFhLEdBQUcsU0FBUyxDQUFDLENBOEJwQztBQXVERDs7Ozs7Ozs7R0FRRztBQUNILHdCQUFzQixrQ0FBa0MsQ0FBQyxXQUFXLEVBQUUsWUFBWSxpQkEyQmpGIn0=
22
+ //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29ya19jb25maWcuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25maWcvbmV0d29ya19jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssYUFBYSxFQUEwQixLQUFLLFlBQVksRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBWXpHOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQXNCLGdCQUFnQixDQUNwQyxXQUFXLEVBQUUsWUFBWSxFQUN6QixRQUFRLENBQUMsRUFBRSxNQUFNLEdBQ2hCLE9BQU8sQ0FBQyxhQUFhLEdBQUcsU0FBUyxDQUFDLENBOEJwQztBQXNERDs7Ozs7Ozs7R0FRRztBQUNILHdCQUFzQixrQ0FBa0MsQ0FBQyxXQUFXLEVBQUUsWUFBWSxpQkE4QmpGIn0=
package/dest/config/network_config.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"network_config.d.ts","sourceRoot":"","sources":["../../src/config/network_config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAA0B,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAazG;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,YAAY,EACzB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CA8BpC;AAuDD;;;;;;;;GAQG;AACH,wBAAsB,kCAAkC,CAAC,WAAW,EAAE,YAAY,iBA2BjF"}
1
+ {"version":3,"file":"network_config.d.ts","sourceRoot":"","sources":["../../src/config/network_config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAA0B,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAYzG;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,YAAY,EACzB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CA8BpC;AAsDD;;;;;;;;GAQG;AACH,wBAAsB,kCAAkC,CAAC,WAAW,EAAE,YAAY,iBA8BjF"}
package/dest/config/network_config.js CHANGED
@@ -5,7 +5,6 @@ import { cachedFetch } from './cached_fetch.js';
5
5
  import { enrichEthAddressVar, enrichVar } from './enrich_env.js';
6
6
  const DEFAULT_CONFIG_URL = 'https://raw.githubusercontent.com/AztecProtocol/networks/refs/heads/main/network_config.json';
7
7
  const FALLBACK_CONFIG_URL = 'https://metadata.aztec.network/network_config.json';
8
- const NETWORK_CONFIG_CACHE_DURATION_MS = 60 * 60 * 1000; // 1 hour
9
8
  /**
10
9
  * Fetches remote network configuration from GitHub with caching support.
11
10
  * Uses the reusable cachedFetch utility. Falls back to metadata.aztec.network if the default URL fails.
@@ -64,7 +63,6 @@ const NETWORK_CONFIG_CACHE_DURATION_MS = 60 * 60 * 1000; // 1 hour
64
63
  let rawConfig;
65
64
  if (url.protocol === 'http:' || url.protocol === 'https:') {
66
65
  rawConfig = await cachedFetch(url.href, {
67
- cacheDurationMs: NETWORK_CONFIG_CACHE_DURATION_MS,
68
66
  cacheFile: cacheDir ? join(cacheDir, networkName, 'network_config.json') : undefined
69
67
  });
70
68
  } else if (url.protocol === 'file:') {
@@ -112,4 +110,7 @@ const NETWORK_CONFIG_CACHE_DURATION_MS = 60 * 60 * 1000; // 1 hour
112
110
  if (networkConfig.blockDurationMs !== undefined) {
113
111
  enrichVar('SEQ_BLOCK_DURATION_MS', String(networkConfig.blockDurationMs));
114
112
  }
113
+ if (networkConfig.txPublicSetupAllowListExtend) {
114
+ enrichVar('TX_PUBLIC_SETUP_ALLOWLIST', networkConfig.txPublicSetupAllowListExtend);
115
+ }
115
116
  }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@aztec/cli",
3
- "version": "0.0.1-commit.ec5f612",
3
+ "version": "0.0.1-commit.ef17749e1",
4
4
  "type": "module",
5
5
  "exports": {
6
6
  "./contracts": "./dest/cmds/contracts/index.js",
@@ -77,23 +77,23 @@
77
77
  ]
78
78
  },
79
79
  "dependencies": {
80
- "@aztec/accounts": "0.0.1-commit.ec5f612",
81
- "@aztec/archiver": "0.0.1-commit.ec5f612",
82
- "@aztec/aztec.js": "0.0.1-commit.ec5f612",
83
- "@aztec/constants": "0.0.1-commit.ec5f612",
84
- "@aztec/entrypoints": "0.0.1-commit.ec5f612",
85
- "@aztec/ethereum": "0.0.1-commit.ec5f612",
86
- "@aztec/foundation": "0.0.1-commit.ec5f612",
87
- "@aztec/l1-artifacts": "0.0.1-commit.ec5f612",
88
- "@aztec/node-keystore": "0.0.1-commit.ec5f612",
89
- "@aztec/node-lib": "0.0.1-commit.ec5f612",
90
- "@aztec/p2p": "0.0.1-commit.ec5f612",
91
- "@aztec/protocol-contracts": "0.0.1-commit.ec5f612",
92
- "@aztec/sequencer-client": "0.0.1-commit.ec5f612",
93
- "@aztec/slasher": "0.0.1-commit.ec5f612",
94
- "@aztec/stdlib": "0.0.1-commit.ec5f612",
95
- "@aztec/wallets": "0.0.1-commit.ec5f612",
96
- "@aztec/world-state": "0.0.1-commit.ec5f612",
80
+ "@aztec/accounts": "0.0.1-commit.ef17749e1",
81
+ "@aztec/archiver": "0.0.1-commit.ef17749e1",
82
+ "@aztec/aztec.js": "0.0.1-commit.ef17749e1",
83
+ "@aztec/constants": "0.0.1-commit.ef17749e1",
84
+ "@aztec/entrypoints": "0.0.1-commit.ef17749e1",
85
+ "@aztec/ethereum": "0.0.1-commit.ef17749e1",
86
+ "@aztec/foundation": "0.0.1-commit.ef17749e1",
87
+ "@aztec/l1-artifacts": "0.0.1-commit.ef17749e1",
88
+ "@aztec/node-keystore": "0.0.1-commit.ef17749e1",
89
+ "@aztec/node-lib": "0.0.1-commit.ef17749e1",
90
+ "@aztec/p2p": "0.0.1-commit.ef17749e1",
91
+ "@aztec/protocol-contracts": "0.0.1-commit.ef17749e1",
92
+ "@aztec/sequencer-client": "0.0.1-commit.ef17749e1",
93
+ "@aztec/slasher": "0.0.1-commit.ef17749e1",
94
+ "@aztec/stdlib": "0.0.1-commit.ef17749e1",
95
+ "@aztec/wallets": "0.0.1-commit.ef17749e1",
96
+ "@aztec/world-state": "0.0.1-commit.ef17749e1",
97
97
  "@ethersproject/wallet": "^5.8.0",
98
98
  "@iarna/toml": "^2.2.5",
99
99
  "@libp2p/peer-id-factory": "^3.0.4",
@@ -107,9 +107,9 @@
107
107
  "viem": "npm:@aztec/viem@2.38.2"
108
108
  },
109
109
  "devDependencies": {
110
- "@aztec/aztec-node": "0.0.1-commit.ec5f612",
111
- "@aztec/kv-store": "0.0.1-commit.ec5f612",
112
- "@aztec/telemetry-client": "0.0.1-commit.ec5f612",
110
+ "@aztec/aztec-node": "0.0.1-commit.ef17749e1",
111
+ "@aztec/kv-store": "0.0.1-commit.ef17749e1",
112
+ "@aztec/telemetry-client": "0.0.1-commit.ef17749e1",
113
113
  "@jest/globals": "^30.0.0",
114
114
  "@types/jest": "^30.0.0",
115
115
  "@types/lodash.chunk": "^4.2.9",
@@ -126,15 +126,15 @@
126
126
  "typescript": "^5.3.3"
127
127
  },
128
128
  "peerDependencies": {
129
- "@aztec/accounts": "0.0.1-commit.ec5f612",
130
- "@aztec/bb-prover": "0.0.1-commit.ec5f612",
131
- "@aztec/ethereum": "0.0.1-commit.ec5f612",
132
- "@aztec/l1-artifacts": "0.0.1-commit.ec5f612",
133
- "@aztec/noir-contracts.js": "0.0.1-commit.ec5f612",
134
- "@aztec/noir-protocol-circuits-types": "0.0.1-commit.ec5f612",
135
- "@aztec/noir-test-contracts.js": "0.0.1-commit.ec5f612",
136
- "@aztec/protocol-contracts": "0.0.1-commit.ec5f612",
137
- "@aztec/stdlib": "0.0.1-commit.ec5f612"
129
+ "@aztec/accounts": "0.0.1-commit.ef17749e1",
130
+ "@aztec/bb-prover": "0.0.1-commit.ef17749e1",
131
+ "@aztec/ethereum": "0.0.1-commit.ef17749e1",
132
+ "@aztec/l1-artifacts": "0.0.1-commit.ef17749e1",
133
+ "@aztec/noir-contracts.js": "0.0.1-commit.ef17749e1",
134
+ "@aztec/noir-protocol-circuits-types": "0.0.1-commit.ef17749e1",
135
+ "@aztec/noir-test-contracts.js": "0.0.1-commit.ef17749e1",
136
+ "@aztec/protocol-contracts": "0.0.1-commit.ef17749e1",
137
+ "@aztec/stdlib": "0.0.1-commit.ef17749e1"
138
138
  },
139
139
  "files": [
140
140
  "dest",
package/src/config/cached_fetch.ts CHANGED
@@ -1,24 +1,48 @@
1
1
  import { createLogger } from '@aztec/aztec.js/log';
2
2
 
3
- import { mkdir, readFile, stat, writeFile } from 'fs/promises';
3
+ import { mkdir, readFile, writeFile } from 'fs/promises';
4
4
  import { dirname } from 'path';
5
5
 
6
6
  export interface CachedFetchOptions {
7
- /** Cache duration in milliseconds */
8
- cacheDurationMs: number;
9
- /** The cache file */
7
+ /** The cache file path for storing data. If not provided, no caching is performed. */
10
8
  cacheFile?: string;
9
+ /** Fallback max-age in milliseconds when server sends no Cache-Control header. Defaults to 5 minutes. */
10
+ defaultMaxAgeMs?: number;
11
+ }
12
+
13
+ /** Cache metadata stored in a sidecar .meta file alongside the data file. */
14
+ interface CacheMeta {
15
+ etag?: string;
16
+ expiresAt: number;
17
+ }
18
+
19
+ const DEFAULT_MAX_AGE_MS = 5 * 60 * 1000; // 5 minutes
20
+
21
+ /** Extracts max-age value in milliseconds from a Response's Cache-Control header. Returns undefined if not present. */
22
+ export function parseMaxAge(response: { headers: { get(name: string): string | null } }): number | undefined {
23
+ const cacheControl = response.headers.get('cache-control');
24
+ if (!cacheControl) {
25
+ return undefined;
26
+ }
27
+ const match = cacheControl.match(/max-age=(\d+)/);
28
+ if (!match) {
29
+ return undefined;
30
+ }
31
+ return parseInt(match[1], 10) * 1000;
11
32
  }
12
33
 
13
34
  /**
14
- * Fetches data from a URL with file-based caching support.
15
- * This utility can be used by both remote config and bootnodes fetching.
35
+ * Fetches data from a URL with file-based HTTP conditional caching.
36
+ *
37
+ * Data is stored as raw JSON in the cache file (same format as the server returns).
38
+ * Caching metadata (ETag, expiry) is stored in a separate sidecar `.meta` file.
39
+ * This keeps the data file human-readable and backward-compatible with older code.
16
40
  *
17
41
  * @param url - The URL to fetch from
18
- * @param networkName - Network name for cache directory structure
19
- * @param options - Caching and error handling options
20
- * @param cacheDir - Optional cache directory (defaults to no caching)
21
- * @returns The fetched and parsed JSON data, or undefined if fetch fails and throwOnError is false
42
+ * @param options - Caching options
43
+ * @param fetch - Fetch implementation (defaults to globalThis.fetch)
44
+ * @param log - Logger instance
45
+ * @returns The fetched and parsed JSON data, or undefined if fetch fails
22
46
  */
23
47
  export async function cachedFetch<T = any>(
24
48
  url: string,
@@ -26,42 +50,106 @@ export async function cachedFetch<T = any>(
26
50
  fetch = globalThis.fetch,
27
51
  log = createLogger('cached_fetch'),
28
52
  ): Promise<T | undefined> {
29
- const { cacheDurationMs, cacheFile } = options;
53
+ const { cacheFile, defaultMaxAgeMs = DEFAULT_MAX_AGE_MS } = options;
54
+
55
+ // If no cacheFile, just fetch normally without caching
56
+ if (!cacheFile) {
57
+ return fetchAndParse<T>(url, fetch, log);
58
+ }
59
+
60
+ const metaFile = cacheFile + '.meta';
30
61
 
31
- // Try to read from cache first
62
+ // Try to read metadata
63
+ let meta: CacheMeta | undefined;
32
64
  try {
33
- if (cacheFile) {
34
- const info = await stat(cacheFile);
35
- if (info.mtimeMs + cacheDurationMs > Date.now()) {
36
- const cachedData = JSON.parse(await readFile(cacheFile, 'utf-8'));
37
- return cachedData;
38
- }
39
- }
65
+ meta = JSON.parse(await readFile(metaFile, 'utf-8'));
40
66
  } catch {
41
- log.trace('Failed to read data from cache');
67
+ log.trace('No usable cache metadata found');
42
68
  }
43
69
 
70
+ // Try to read cached data
71
+ let cachedData: T | undefined;
44
72
  try {
45
- const response = await fetch(url);
73
+ cachedData = JSON.parse(await readFile(cacheFile, 'utf-8'));
74
+ } catch {
75
+ log.trace('No usable cached data found');
76
+ }
77
+
78
+ // If metadata and data exist and cache is fresh, return directly
79
+ if (meta && cachedData !== undefined && meta.expiresAt > Date.now()) {
80
+ return cachedData;
81
+ }
82
+
83
+ // Cache is stale or missing — make a (possibly conditional) request
84
+ try {
85
+ const headers: Record<string, string> = {};
86
+ if (meta?.etag && cachedData !== undefined) {
87
+ headers['If-None-Match'] = meta.etag;
88
+ }
89
+
90
+ const response = await fetch(url, { headers });
91
+
92
+ if (response.status === 304 && cachedData !== undefined) {
93
+ // Not modified — recompute expiry from new response headers and return cached data
94
+ const maxAgeMs = parseMaxAge(response) ?? defaultMaxAgeMs;
95
+ await writeMetaFile(metaFile, { etag: meta?.etag, expiresAt: Date.now() + maxAgeMs }, log);
96
+ return cachedData;
97
+ }
98
+
46
99
  if (!response.ok) {
47
100
  log.warn(`Failed to fetch from ${url}: ${response.status} ${response.statusText}`);
48
- return undefined;
101
+ return cachedData;
49
102
  }
50
103
 
51
- const data = await response.json();
104
+ // 200 — parse new data and cache it
105
+ const data = (await response.json()) as T;
106
+ const maxAgeMs = parseMaxAge(response) ?? defaultMaxAgeMs;
107
+ const etag = response.headers.get('etag') ?? undefined;
52
108
 
53
- try {
54
- if (cacheFile) {
55
- await mkdir(dirname(cacheFile), { recursive: true });
56
- await writeFile(cacheFile, JSON.stringify(data), 'utf-8');
57
- }
58
- } catch (err) {
59
- log.warn('Failed to cache data on disk: ' + cacheFile, { cacheFile, err });
60
- }
109
+ await ensureDir(cacheFile, log);
110
+ await Promise.all([
111
+ writeFile(cacheFile, JSON.stringify(data), 'utf-8'),
112
+ writeFile(metaFile, JSON.stringify({ etag, expiresAt: Date.now() + maxAgeMs }), 'utf-8'),
113
+ ]);
61
114
 
62
115
  return data;
116
+ } catch (err) {
117
+ log.warn(`Failed to fetch from ${url}`, { err });
118
+ return cachedData;
119
+ }
120
+ }
121
+
122
+ async function fetchAndParse<T>(
123
+ url: string,
124
+ fetch: typeof globalThis.fetch,
125
+ log: ReturnType<typeof createLogger>,
126
+ ): Promise<T | undefined> {
127
+ try {
128
+ const response = await fetch(url);
129
+ if (!response.ok) {
130
+ log.warn(`Failed to fetch from ${url}: ${response.status} ${response.statusText}`);
131
+ return undefined;
132
+ }
133
+ return (await response.json()) as T;
63
134
  } catch (err) {
64
135
  log.warn(`Failed to fetch from ${url}`, { err });
65
136
  return undefined;
66
137
  }
67
138
  }
139
+
140
+ async function ensureDir(filePath: string, log: ReturnType<typeof createLogger>) {
141
+ try {
142
+ await mkdir(dirname(filePath), { recursive: true });
143
+ } catch (err) {
144
+ log.warn('Failed to create cache directory for: ' + filePath, { err });
145
+ }
146
+ }
147
+
148
+ async function writeMetaFile(metaFile: string, meta: CacheMeta, log: ReturnType<typeof createLogger>) {
149
+ try {
150
+ await mkdir(dirname(metaFile), { recursive: true });
151
+ await writeFile(metaFile, JSON.stringify(meta), 'utf-8');
152
+ } catch (err) {
153
+ log.warn('Failed to write cache metadata: ' + metaFile, { err });
154
+ }
155
+ }
package/src/config/generated/networks.ts CHANGED
@@ -27,7 +27,7 @@ export const devnetConfig = {
27
27
  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
28
28
  SLASH_MAX_PENALTY_PERCENTAGE: 2,
29
29
  SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
30
- SLASH_MAX_PAYLOAD_SIZE: 50,
30
+ SLASH_MAX_PAYLOAD_SIZE: 80,
31
31
  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
32
32
  P2P_ENABLED: true,
33
33
  BOOTSTRAP_NODES: '',
@@ -58,8 +58,6 @@ export const devnetConfig = {
58
58
  BLOB_ALLOW_EMPTY_SOURCES: false,
59
59
  P2P_MAX_PENDING_TX_COUNT: 1000,
60
60
  P2P_TX_POOL_DELETE_TXS_AFTER_REORG: false,
61
- AUTO_UPDATE: 'none',
62
- AUTO_UPDATE_URL: '',
63
61
  PUBLIC_OTEL_OPT_OUT: true,
64
62
  PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '',
65
63
  PUBLIC_OTEL_COLLECT_FROM: '',
@@ -75,6 +73,7 @@ export const devnetConfig = {
75
73
  SLASH_UNKNOWN_PENALTY: 10000000000000000000,
76
74
  SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
77
75
  SLASH_GRACE_PERIOD_L2_SLOTS: 0,
76
+ ENABLE_VERSION_CHECK: true,
78
77
  } as const;
79
78
 
80
79
  export const testnetConfig = {
@@ -95,7 +94,7 @@ export const testnetConfig = {
95
94
  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
96
95
  SLASH_MAX_PENALTY_PERCENTAGE: 2,
97
96
  SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
98
- SLASH_MAX_PAYLOAD_SIZE: 50,
97
+ SLASH_MAX_PAYLOAD_SIZE: 80,
99
98
  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
100
99
  P2P_ENABLED: true,
101
100
  BOOTSTRAP_NODES: '',
@@ -128,8 +127,9 @@ export const testnetConfig = {
128
127
  TEST_ACCOUNTS: false,
129
128
  SPONSORED_FPC: true,
130
129
  TRANSACTIONS_DISABLED: false,
131
- SEQ_MAX_TX_PER_BLOCK: 2,
130
+ SEQ_MAX_TX_PER_CHECKPOINT: 72,
132
131
  PROVER_REAL_PROOFS: true,
132
+ P2P_MAX_PENDING_TX_COUNT: 1000,
133
133
  P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true,
134
134
  SLASH_PRUNE_PENALTY: 10000000000000000000,
135
135
  SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000,
@@ -143,6 +143,7 @@ export const testnetConfig = {
143
143
  SLASH_UNKNOWN_PENALTY: 10000000000000000000,
144
144
  SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
145
145
  SLASH_GRACE_PERIOD_L2_SLOTS: 64,
146
+ ENABLE_VERSION_CHECK: true,
146
147
  } as const;
147
148
 
148
149
  export const mainnetConfig = {
@@ -160,7 +161,7 @@ export const mainnetConfig = {
160
161
  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
161
162
  SLASH_MAX_PENALTY_PERCENTAGE: 2,
162
163
  SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
163
- SLASH_MAX_PAYLOAD_SIZE: 50,
164
+ SLASH_MAX_PAYLOAD_SIZE: 80,
164
165
  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
165
166
  P2P_ENABLED: true,
166
167
  BOOTSTRAP_NODES: '',
@@ -178,7 +179,7 @@ export const mainnetConfig = {
178
179
  AZTEC_SLOT_DURATION: 72,
179
180
  AZTEC_ACTIVATION_THRESHOLD: 2E+23,
180
181
  AZTEC_EJECTION_THRESHOLD: 1E+23,
181
- AZTEC_LOCAL_EJECTION_THRESHOLD: 1.62E+23,
182
+ AZTEC_LOCAL_EJECTION_THRESHOLD: 1.9E+23,
182
183
  AZTEC_SLASH_AMOUNT_SMALL: 2E+21,
183
184
  AZTEC_SLASH_AMOUNT_MEDIUM: 2E+21,
184
185
  AZTEC_SLASH_AMOUNT_LARGE: 2E+21,
@@ -200,17 +201,16 @@ export const mainnetConfig = {
200
201
  L1_CHAIN_ID: 1,
201
202
  TEST_ACCOUNTS: false,
202
203
  SPONSORED_FPC: false,
203
- TRANSACTIONS_DISABLED: true,
204
- SEQ_MAX_TX_PER_BLOCK: 0,
204
+ TRANSACTIONS_DISABLED: false,
205
+ SEQ_MAX_TX_PER_CHECKPOINT: 72,
205
206
  PROVER_REAL_PROOFS: true,
206
207
  SYNC_SNAPSHOTS_URLS: 'https://aztec-labs-snapshots.com/mainnet/',
207
208
  BLOB_ALLOW_EMPTY_SOURCES: true,
208
- P2P_MAX_PENDING_TX_COUNT: 0,
209
+ P2P_MAX_PENDING_TX_COUNT: 1000,
209
210
  P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true,
210
- AUTO_UPDATE: 'notify',
211
- AUTO_UPDATE_URL: 'https://storage.googleapis.com/aztec-mainnet/auto-update/mainnet.json',
212
- PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: 'https://telemetry.alpha-testnet.aztec-labs.com/v1/metrics',
213
- PUBLIC_OTEL_COLLECT_FROM: 'sequencer',
211
+ PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '',
212
+ PUBLIC_OTEL_COLLECT_FROM: '',
213
+ ENABLE_VERSION_CHECK: false,
214
214
  SLASH_PRUNE_PENALTY: 0,
215
215
  SLASH_DATA_WITHHOLDING_PENALTY: 0,
216
216
  SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.8,
package/src/config/network_config.ts CHANGED
@@ -9,7 +9,6 @@ import { enrichEthAddressVar, enrichVar } from './enrich_env.js';
9
9
  const DEFAULT_CONFIG_URL =
10
10
  'https://raw.githubusercontent.com/AztecProtocol/networks/refs/heads/main/network_config.json';
11
11
  const FALLBACK_CONFIG_URL = 'https://metadata.aztec.network/network_config.json';
12
- const NETWORK_CONFIG_CACHE_DURATION_MS = 60 * 60 * 1000; // 1 hour
13
12
 
14
13
  /**
15
14
  * Fetches remote network configuration from GitHub with caching support.
@@ -87,7 +86,6 @@ async function fetchNetworkConfigFromUrl(
87
86
 
88
87
  if (url.protocol === 'http:' || url.protocol === 'https:') {
89
88
  rawConfig = await cachedFetch(url.href, {
90
- cacheDurationMs: NETWORK_CONFIG_CACHE_DURATION_MS,
91
89
  cacheFile: cacheDir ? join(cacheDir, networkName, 'network_config.json') : undefined,
92
90
  });
93
91
  } else if (url.protocol === 'file:') {
@@ -144,4 +142,7 @@ export async function enrichEnvironmentWithNetworkConfig(networkName: NetworkNam
144
142
  if (networkConfig.blockDurationMs !== undefined) {
145
143
  enrichVar('SEQ_BLOCK_DURATION_MS', String(networkConfig.blockDurationMs));
146
144
  }
145
+ if (networkConfig.txPublicSetupAllowListExtend) {
146
+ enrichVar('TX_PUBLIC_SETUP_ALLOWLIST', networkConfig.txPublicSetupAllowListExtend);
147
+ }
147
148
  }