@aztec/cli 0.0.1-commit.f504929 → 0.0.1-commit.f81dbcf

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 (17) 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/chain_l2_config.d.ts +1 -1
  5. package/dest/config/chain_l2_config.d.ts.map +1 -1
  6. package/dest/config/chain_l2_config.js +1 -3
  7. package/dest/config/generated/networks.d.ts +36 -37
  8. package/dest/config/generated/networks.d.ts.map +1 -1
  9. package/dest/config/generated/networks.js +36 -37
  10. package/dest/config/network_config.d.ts +1 -1
  11. package/dest/config/network_config.d.ts.map +1 -1
  12. package/dest/config/network_config.js +3 -2
  13. package/package.json +30 -30
  14. package/src/config/cached_fetch.ts +119 -31
  15. package/src/config/chain_l2_config.ts +1 -3
  16. package/src/config/generated/networks.ts +35 -36
  17. 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/chain_l2_config.d.ts CHANGED
@@ -11,4 +11,4 @@ import type { NetworkNames } from '@aztec/foundation/config';
11
11
  * @param networkName - The network name
12
12
  */
13
13
  export declare function enrichEnvironmentWithChainName(networkName: NetworkNames): void;
14
- //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhaW5fbDJfY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL2NoYWluX2wyX2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQTBCN0Q7Ozs7Ozs7Ozs7R0FVRztBQUNILHdCQUFnQiw4QkFBOEIsQ0FBQyxXQUFXLEVBQUUsWUFBWSxRQXFCdkUifQ==
14
+ //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhaW5fbDJfY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL2NoYWluX2wyX2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQTBCN0Q7Ozs7Ozs7Ozs7R0FVRztBQUNILHdCQUFnQiw4QkFBOEIsQ0FBQyxXQUFXLEVBQUUsWUFBWSxRQW1CdkUifQ==
package/dest/config/chain_l2_config.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"chain_l2_config.d.ts","sourceRoot":"","sources":["../../src/config/chain_l2_config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AA0B7D;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,YAAY,QAqBvE"}
1
+ {"version":3,"file":"chain_l2_config.d.ts","sourceRoot":"","sources":["../../src/config/chain_l2_config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AA0B7D;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,YAAY,QAmBvE"}
package/dest/config/chain_l2_config.js CHANGED
@@ -34,9 +34,7 @@ function getDefaultDataDir(networkName) {
34
34
  return;
35
35
  }
36
36
  // Apply generated network config from defaults.yml
37
- // For devnet iterations (v4-devnet-1, etc.), use the base devnet config
38
- const configKey = /^v\d+-devnet-\d+$/.test(networkName) ? 'devnet' : networkName;
39
- const generatedConfig = NetworkConfigs[configKey];
37
+ const generatedConfig = NetworkConfigs[networkName];
40
38
  if (generatedConfig) {
41
39
  enrichEnvironmentWithNetworkConfig(generatedConfig);
42
40
  }
package/dest/config/generated/networks.d.ts CHANGED
@@ -24,11 +24,11 @@ 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: 80;
27
+ readonly SLASH_MAX_PAYLOAD_SIZE: 50;
28
28
  readonly SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4;
29
29
  readonly P2P_ENABLED: true;
30
30
  readonly BOOTSTRAP_NODES: "";
31
- readonly SEQ_MIN_TX_PER_BLOCK: 0;
31
+ readonly SEQ_MIN_TX_PER_BLOCK: 1;
32
32
  readonly SEQ_BUILD_CHECKPOINT_IF_EMPTY: true;
33
33
  readonly SEQ_BLOCK_DURATION_MS: 6000;
34
34
  readonly SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36;
@@ -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,13 +70,14 @@ 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;
78
77
  readonly AZTEC_EPOCH_DURATION: 32;
79
78
  readonly AZTEC_TARGET_COMMITTEE_SIZE: 48;
80
79
  readonly AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2;
81
- readonly AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2;
80
+ readonly AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 1;
82
81
  readonly AZTEC_EXIT_DELAY_SECONDS: 172800;
83
82
  readonly AZTEC_INBOX_LAG: 1;
84
83
  readonly AZTEC_PROOF_SUBMISSION_EPOCHS: 1;
@@ -91,11 +90,11 @@ 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: 80;
93
+ readonly SLASH_MAX_PAYLOAD_SIZE: 50;
95
94
  readonly SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4;
96
95
  readonly P2P_ENABLED: true;
97
96
  readonly BOOTSTRAP_NODES: "";
98
- readonly SEQ_MIN_TX_PER_BLOCK: 0;
97
+ readonly SEQ_MIN_TX_PER_BLOCK: 1;
99
98
  readonly SEQ_BUILD_CHECKPOINT_IF_EMPTY: true;
100
99
  readonly SEQ_BLOCK_DURATION_MS: 6000;
101
100
  readonly SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36;
@@ -122,30 +121,32 @@ export declare const testnetConfig: {
122
121
  readonly AZTEC_SLASH_AMOUNT_LARGE: 1e+23;
123
122
  readonly L1_CHAIN_ID: 11155111;
124
123
  readonly TEST_ACCOUNTS: false;
125
- readonly SPONSORED_FPC: true;
124
+ readonly SPONSORED_FPC: false;
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
- readonly SLASH_PRUNE_PENALTY: 10000000000000000000;
131
- readonly SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000;
132
- readonly SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9;
133
- readonly SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1;
134
- readonly SLASH_INACTIVITY_PENALTY: 10000000000000000000;
135
- readonly SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000;
136
- readonly SLASH_DUPLICATE_PROPOSAL_PENALTY: 10000000000000000000;
137
- readonly SLASH_DUPLICATE_ATTESTATION_PENALTY: 10000000000000000000;
138
- readonly SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000;
139
- readonly SLASH_UNKNOWN_PENALTY: 10000000000000000000;
140
- readonly SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000;
141
- readonly SLASH_GRACE_PERIOD_L2_SLOTS: 64;
130
+ readonly SLASH_PRUNE_PENALTY: 0;
131
+ readonly SLASH_DATA_WITHHOLDING_PENALTY: 0;
132
+ readonly SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.7;
133
+ readonly SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 2;
134
+ readonly SLASH_INACTIVITY_PENALTY: 1e+23;
135
+ readonly SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 1e+23;
136
+ readonly SLASH_DUPLICATE_PROPOSAL_PENALTY: 0;
137
+ readonly SLASH_DUPLICATE_ATTESTATION_PENALTY: 0;
138
+ readonly SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 1e+23;
139
+ readonly SLASH_UNKNOWN_PENALTY: 1e+23;
140
+ readonly SLASH_INVALID_BLOCK_PENALTY: 1e+23;
141
+ readonly SLASH_GRACE_PERIOD_L2_SLOTS: 3600;
142
+ readonly ENABLE_VERSION_CHECK: true;
142
143
  };
143
144
  export declare const mainnetConfig: {
144
145
  readonly ETHEREUM_SLOT_DURATION: 12;
145
146
  readonly AZTEC_EPOCH_DURATION: 32;
146
147
  readonly AZTEC_TARGET_COMMITTEE_SIZE: 48;
147
148
  readonly AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2;
148
- readonly AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2;
149
+ readonly AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 1;
149
150
  readonly AZTEC_INBOX_LAG: 1;
150
151
  readonly AZTEC_PROOF_SUBMISSION_EPOCHS: 1;
151
152
  readonly AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000;
@@ -155,11 +156,11 @@ 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: 80;
159
+ readonly SLASH_MAX_PAYLOAD_SIZE: 50;
159
160
  readonly SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4;
160
161
  readonly P2P_ENABLED: true;
161
162
  readonly BOOTSTRAP_NODES: "";
162
- readonly SEQ_MIN_TX_PER_BLOCK: 0;
163
+ readonly SEQ_MIN_TX_PER_BLOCK: 1;
163
164
  readonly SEQ_BUILD_CHECKPOINT_IF_EMPTY: true;
164
165
  readonly SEQ_BLOCK_DURATION_MS: 6000;
165
166
  readonly SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36;
@@ -195,28 +196,26 @@ 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
- readonly SYNC_SNAPSHOTS_URLS: "https://aztec-labs-snapshots.com/mainnet/";
202
202
  readonly BLOB_ALLOW_EMPTY_SOURCES: true;
203
- readonly P2P_MAX_PENDING_TX_COUNT: 0;
203
+ readonly P2P_MAX_PENDING_TX_COUNT: 1000;
204
204
  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";
205
+ readonly PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: "";
206
+ readonly PUBLIC_OTEL_COLLECT_FROM: "";
207
+ readonly ENABLE_VERSION_CHECK: false;
209
208
  readonly SLASH_PRUNE_PENALTY: 0;
210
209
  readonly SLASH_DATA_WITHHOLDING_PENALTY: 0;
211
- readonly SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.8;
210
+ readonly SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.7;
212
211
  readonly SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 2;
213
212
  readonly SLASH_INACTIVITY_PENALTY: 2e+21;
214
213
  readonly SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 2e+21;
215
- readonly SLASH_DUPLICATE_PROPOSAL_PENALTY: 2e+21;
216
- readonly SLASH_DUPLICATE_ATTESTATION_PENALTY: 2e+21;
214
+ readonly SLASH_DUPLICATE_PROPOSAL_PENALTY: 0;
215
+ readonly SLASH_DUPLICATE_ATTESTATION_PENALTY: 0;
217
216
  readonly SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 2e+21;
218
217
  readonly SLASH_UNKNOWN_PENALTY: 2e+21;
219
218
  readonly SLASH_INVALID_BLOCK_PENALTY: 2e+21;
220
- readonly SLASH_GRACE_PERIOD_L2_SLOTS: 1200;
219
+ readonly SLASH_GRACE_PERIOD_L2_SLOTS: 8400;
221
220
  };
222
- //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29ya3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25maWcvZ2VuZXJhdGVkL25ldHdvcmtzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLGVBQU8sTUFBTSxZQUFZOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztDQTBFZixDQUFDO0FBRVgsZUFBTyxNQUFNLGFBQWE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztDQWtFaEIsQ0FBQztBQUVYLGVBQU8sTUFBTSxhQUFhOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0E4RWhCLENBQUMifQ==
221
+ //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29ya3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25maWcvZ2VuZXJhdGVkL25ldHdvcmtzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLGVBQU8sTUFBTSxZQUFZOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBeUVmLENBQUM7QUFFWCxlQUFPLE1BQU0sYUFBYTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0FvRWhCLENBQUM7QUFFWCxlQUFPLE1BQU0sYUFBYTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztDQTRFaEIsQ0FBQyJ9
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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4EhB,CAAC"}
package/dest/config/generated/networks.js CHANGED
@@ -26,11 +26,11 @@ 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: 80,
29
+ SLASH_MAX_PAYLOAD_SIZE: 50,
30
30
  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
31
31
  P2P_ENABLED: true,
32
32
  BOOTSTRAP_NODES: '',
33
- SEQ_MIN_TX_PER_BLOCK: 0,
33
+ SEQ_MIN_TX_PER_BLOCK: 1,
34
34
  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
35
35
  SEQ_BLOCK_DURATION_MS: 6000,
36
36
  SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
@@ -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,14 +71,15 @@ 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,
80
79
  AZTEC_EPOCH_DURATION: 32,
81
80
  AZTEC_TARGET_COMMITTEE_SIZE: 48,
82
81
  AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
83
- AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
82
+ AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 1,
84
83
  AZTEC_EXIT_DELAY_SECONDS: 172800,
85
84
  AZTEC_INBOX_LAG: 1,
86
85
  AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
@@ -93,11 +92,11 @@ 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: 80,
95
+ SLASH_MAX_PAYLOAD_SIZE: 50,
97
96
  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
98
97
  P2P_ENABLED: true,
99
98
  BOOTSTRAP_NODES: '',
100
- SEQ_MIN_TX_PER_BLOCK: 0,
99
+ SEQ_MIN_TX_PER_BLOCK: 1,
101
100
  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
102
101
  SEQ_BLOCK_DURATION_MS: 6000,
103
102
  SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
@@ -124,30 +123,32 @@ export const testnetConfig = {
124
123
  AZTEC_SLASH_AMOUNT_LARGE: 1E+23,
125
124
  L1_CHAIN_ID: 11155111,
126
125
  TEST_ACCOUNTS: false,
127
- SPONSORED_FPC: true,
126
+ SPONSORED_FPC: false,
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
- SLASH_PRUNE_PENALTY: 10000000000000000000,
133
- SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000,
134
- SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9,
135
- SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1,
136
- SLASH_INACTIVITY_PENALTY: 10000000000000000000,
137
- SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000,
138
- SLASH_DUPLICATE_PROPOSAL_PENALTY: 10000000000000000000,
139
- SLASH_DUPLICATE_ATTESTATION_PENALTY: 10000000000000000000,
140
- SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000,
141
- SLASH_UNKNOWN_PENALTY: 10000000000000000000,
142
- SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
143
- SLASH_GRACE_PERIOD_L2_SLOTS: 64
132
+ SLASH_PRUNE_PENALTY: 0,
133
+ SLASH_DATA_WITHHOLDING_PENALTY: 0,
134
+ SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.7,
135
+ SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 2,
136
+ SLASH_INACTIVITY_PENALTY: 1E+23,
137
+ SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 1E+23,
138
+ SLASH_DUPLICATE_PROPOSAL_PENALTY: 0,
139
+ SLASH_DUPLICATE_ATTESTATION_PENALTY: 0,
140
+ SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 1E+23,
141
+ SLASH_UNKNOWN_PENALTY: 1E+23,
142
+ SLASH_INVALID_BLOCK_PENALTY: 1E+23,
143
+ SLASH_GRACE_PERIOD_L2_SLOTS: 3600,
144
+ ENABLE_VERSION_CHECK: true
144
145
  };
145
146
  export const mainnetConfig = {
146
147
  ETHEREUM_SLOT_DURATION: 12,
147
148
  AZTEC_EPOCH_DURATION: 32,
148
149
  AZTEC_TARGET_COMMITTEE_SIZE: 48,
149
150
  AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
150
- AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
151
+ AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 1,
151
152
  AZTEC_INBOX_LAG: 1,
152
153
  AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
153
154
  AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
@@ -157,11 +158,11 @@ 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: 80,
161
+ SLASH_MAX_PAYLOAD_SIZE: 50,
161
162
  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
162
163
  P2P_ENABLED: true,
163
164
  BOOTSTRAP_NODES: '',
164
- SEQ_MIN_TX_PER_BLOCK: 0,
165
+ SEQ_MIN_TX_PER_BLOCK: 1,
165
166
  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
166
167
  SEQ_BLOCK_DURATION_MS: 6000,
167
168
  SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
@@ -197,27 +198,25 @@ 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
- SYNC_SNAPSHOTS_URLS: 'https://aztec-labs-snapshots.com/mainnet/',
204
204
  BLOB_ALLOW_EMPTY_SOURCES: true,
205
- P2P_MAX_PENDING_TX_COUNT: 0,
205
+ P2P_MAX_PENDING_TX_COUNT: 1000,
206
206
  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',
207
+ PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '',
208
+ PUBLIC_OTEL_COLLECT_FROM: '',
209
+ ENABLE_VERSION_CHECK: false,
211
210
  SLASH_PRUNE_PENALTY: 0,
212
211
  SLASH_DATA_WITHHOLDING_PENALTY: 0,
213
- SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.8,
212
+ SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.7,
214
213
  SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 2,
215
214
  SLASH_INACTIVITY_PENALTY: 2E+21,
216
215
  SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 2E+21,
217
- SLASH_DUPLICATE_PROPOSAL_PENALTY: 2E+21,
218
- SLASH_DUPLICATE_ATTESTATION_PENALTY: 2E+21,
216
+ SLASH_DUPLICATE_PROPOSAL_PENALTY: 0,
217
+ SLASH_DUPLICATE_ATTESTATION_PENALTY: 0,
219
218
  SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 2E+21,
220
219
  SLASH_UNKNOWN_PENALTY: 2E+21,
221
220
  SLASH_INVALID_BLOCK_PENALTY: 2E+21,
222
- SLASH_GRACE_PERIOD_L2_SLOTS: 1200
221
+ SLASH_GRACE_PERIOD_L2_SLOTS: 8400
223
222
  };
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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29ya19jb25maWcuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25maWcvbmV0d29ya19jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssYUFBYSxFQUEwQixLQUFLLFlBQVksRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBYXpHOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQXNCLGdCQUFnQixDQUNwQyxXQUFXLEVBQUUsWUFBWSxFQUN6QixRQUFRLENBQUMsRUFBRSxNQUFNLEdBQ2hCLE9BQU8sQ0FBQyxhQUFhLEdBQUcsU0FBUyxDQUFDLENBOEJwQztBQXVERDs7Ozs7Ozs7R0FRRztBQUNILHdCQUFzQixrQ0FBa0MsQ0FBQyxXQUFXLEVBQUUsWUFBWSxpQkE4QmpGIn0=
22
+ //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29ya19jb25maWcuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25maWcvbmV0d29ya19jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssYUFBYSxFQUEwQixLQUFLLFlBQVksRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBWXpHOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQXNCLGdCQUFnQixDQUNwQyxXQUFXLEVBQUUsWUFBWSxFQUN6QixRQUFRLENBQUMsRUFBRSxNQUFNLEdBQ2hCLE9BQU8sQ0FBQyxhQUFhLEdBQUcsU0FBUyxDQUFDLENBOEJwQztBQXNERDs7Ozs7Ozs7R0FRRztBQUNILHdCQUFzQixrQ0FBa0MsQ0FBQyxXQUFXLEVBQUUsWUFBWSxpQkFpQ2pGIn0=
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,iBA8BjF"}
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,iBAiCjF"}
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:') {
@@ -109,6 +107,9 @@ const NETWORK_CONFIG_CACHE_DURATION_MS = 60 * 60 * 1000; // 1 hour
109
107
  if (networkConfig.blobFileStoreUrls?.length) {
110
108
  enrichVar('BLOB_FILE_STORE_URLS', networkConfig.blobFileStoreUrls.join(','));
111
109
  }
110
+ if (networkConfig.txCollectionFileStoreUrls?.length) {
111
+ enrichVar('TX_COLLECTION_FILE_STORE_URLS', networkConfig.txCollectionFileStoreUrls.join(','));
112
+ }
112
113
  if (networkConfig.blockDurationMs !== undefined) {
113
114
  enrichVar('SEQ_BLOCK_DURATION_MS', String(networkConfig.blockDurationMs));
114
115
  }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@aztec/cli",
3
- "version": "0.0.1-commit.f504929",
3
+ "version": "0.0.1-commit.f81dbcf",
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.f504929",
81
- "@aztec/archiver": "0.0.1-commit.f504929",
82
- "@aztec/aztec.js": "0.0.1-commit.f504929",
83
- "@aztec/constants": "0.0.1-commit.f504929",
84
- "@aztec/entrypoints": "0.0.1-commit.f504929",
85
- "@aztec/ethereum": "0.0.1-commit.f504929",
86
- "@aztec/foundation": "0.0.1-commit.f504929",
87
- "@aztec/l1-artifacts": "0.0.1-commit.f504929",
88
- "@aztec/node-keystore": "0.0.1-commit.f504929",
89
- "@aztec/node-lib": "0.0.1-commit.f504929",
90
- "@aztec/p2p": "0.0.1-commit.f504929",
91
- "@aztec/protocol-contracts": "0.0.1-commit.f504929",
92
- "@aztec/sequencer-client": "0.0.1-commit.f504929",
93
- "@aztec/slasher": "0.0.1-commit.f504929",
94
- "@aztec/stdlib": "0.0.1-commit.f504929",
95
- "@aztec/wallets": "0.0.1-commit.f504929",
96
- "@aztec/world-state": "0.0.1-commit.f504929",
80
+ "@aztec/accounts": "0.0.1-commit.f81dbcf",
81
+ "@aztec/archiver": "0.0.1-commit.f81dbcf",
82
+ "@aztec/aztec.js": "0.0.1-commit.f81dbcf",
83
+ "@aztec/constants": "0.0.1-commit.f81dbcf",
84
+ "@aztec/entrypoints": "0.0.1-commit.f81dbcf",
85
+ "@aztec/ethereum": "0.0.1-commit.f81dbcf",
86
+ "@aztec/foundation": "0.0.1-commit.f81dbcf",
87
+ "@aztec/l1-artifacts": "0.0.1-commit.f81dbcf",
88
+ "@aztec/node-keystore": "0.0.1-commit.f81dbcf",
89
+ "@aztec/node-lib": "0.0.1-commit.f81dbcf",
90
+ "@aztec/p2p": "0.0.1-commit.f81dbcf",
91
+ "@aztec/protocol-contracts": "0.0.1-commit.f81dbcf",
92
+ "@aztec/sequencer-client": "0.0.1-commit.f81dbcf",
93
+ "@aztec/slasher": "0.0.1-commit.f81dbcf",
94
+ "@aztec/stdlib": "0.0.1-commit.f81dbcf",
95
+ "@aztec/wallets": "0.0.1-commit.f81dbcf",
96
+ "@aztec/world-state": "0.0.1-commit.f81dbcf",
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.f504929",
111
- "@aztec/kv-store": "0.0.1-commit.f504929",
112
- "@aztec/telemetry-client": "0.0.1-commit.f504929",
110
+ "@aztec/aztec-node": "0.0.1-commit.f81dbcf",
111
+ "@aztec/kv-store": "0.0.1-commit.f81dbcf",
112
+ "@aztec/telemetry-client": "0.0.1-commit.f81dbcf",
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.f504929",
130
- "@aztec/bb-prover": "0.0.1-commit.f504929",
131
- "@aztec/ethereum": "0.0.1-commit.f504929",
132
- "@aztec/l1-artifacts": "0.0.1-commit.f504929",
133
- "@aztec/noir-contracts.js": "0.0.1-commit.f504929",
134
- "@aztec/noir-protocol-circuits-types": "0.0.1-commit.f504929",
135
- "@aztec/noir-test-contracts.js": "0.0.1-commit.f504929",
136
- "@aztec/protocol-contracts": "0.0.1-commit.f504929",
137
- "@aztec/stdlib": "0.0.1-commit.f504929"
129
+ "@aztec/accounts": "0.0.1-commit.f81dbcf",
130
+ "@aztec/bb-prover": "0.0.1-commit.f81dbcf",
131
+ "@aztec/ethereum": "0.0.1-commit.f81dbcf",
132
+ "@aztec/l1-artifacts": "0.0.1-commit.f81dbcf",
133
+ "@aztec/noir-contracts.js": "0.0.1-commit.f81dbcf",
134
+ "@aztec/noir-protocol-circuits-types": "0.0.1-commit.f81dbcf",
135
+ "@aztec/noir-test-contracts.js": "0.0.1-commit.f81dbcf",
136
+ "@aztec/protocol-contracts": "0.0.1-commit.f81dbcf",
137
+ "@aztec/stdlib": "0.0.1-commit.f81dbcf"
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/chain_l2_config.ts CHANGED
@@ -45,9 +45,7 @@ export function enrichEnvironmentWithChainName(networkName: NetworkNames) {
45
45
  }
46
46
 
47
47
  // Apply generated network config from defaults.yml
48
- // For devnet iterations (v4-devnet-1, etc.), use the base devnet config
49
- const configKey = /^v\d+-devnet-\d+$/.test(networkName) ? 'devnet' : networkName;
50
- const generatedConfig = NetworkConfigs[configKey];
48
+ const generatedConfig = NetworkConfigs[networkName];
51
49
  if (generatedConfig) {
52
50
  enrichEnvironmentWithNetworkConfig(generatedConfig);
53
51
  }
package/src/config/generated/networks.ts CHANGED
@@ -27,11 +27,11 @@ 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: 80,
30
+ SLASH_MAX_PAYLOAD_SIZE: 50,
31
31
  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
32
32
  P2P_ENABLED: true,
33
33
  BOOTSTRAP_NODES: '',
34
- SEQ_MIN_TX_PER_BLOCK: 0,
34
+ SEQ_MIN_TX_PER_BLOCK: 1,
35
35
  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
36
36
  SEQ_BLOCK_DURATION_MS: 6000,
37
37
  SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
@@ -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 = {
@@ -82,7 +81,7 @@ export const testnetConfig = {
82
81
  AZTEC_EPOCH_DURATION: 32,
83
82
  AZTEC_TARGET_COMMITTEE_SIZE: 48,
84
83
  AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
85
- AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
84
+ AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 1,
86
85
  AZTEC_EXIT_DELAY_SECONDS: 172800,
87
86
  AZTEC_INBOX_LAG: 1,
88
87
  AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
@@ -95,11 +94,11 @@ 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: 80,
97
+ SLASH_MAX_PAYLOAD_SIZE: 50,
99
98
  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
100
99
  P2P_ENABLED: true,
101
100
  BOOTSTRAP_NODES: '',
102
- SEQ_MIN_TX_PER_BLOCK: 0,
101
+ SEQ_MIN_TX_PER_BLOCK: 1,
103
102
  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
104
103
  SEQ_BLOCK_DURATION_MS: 6000,
105
104
  SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
@@ -126,23 +125,25 @@ export const testnetConfig = {
126
125
  AZTEC_SLASH_AMOUNT_LARGE: 1E+23,
127
126
  L1_CHAIN_ID: 11155111,
128
127
  TEST_ACCOUNTS: false,
129
- SPONSORED_FPC: true,
128
+ SPONSORED_FPC: false,
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
- SLASH_PRUNE_PENALTY: 10000000000000000000,
135
- SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000,
136
- SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9,
137
- SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1,
138
- SLASH_INACTIVITY_PENALTY: 10000000000000000000,
139
- SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000,
140
- SLASH_DUPLICATE_PROPOSAL_PENALTY: 10000000000000000000,
141
- SLASH_DUPLICATE_ATTESTATION_PENALTY: 10000000000000000000,
142
- SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000,
143
- SLASH_UNKNOWN_PENALTY: 10000000000000000000,
144
- SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
145
- SLASH_GRACE_PERIOD_L2_SLOTS: 64,
134
+ SLASH_PRUNE_PENALTY: 0,
135
+ SLASH_DATA_WITHHOLDING_PENALTY: 0,
136
+ SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.7,
137
+ SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 2,
138
+ SLASH_INACTIVITY_PENALTY: 1E+23,
139
+ SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 1E+23,
140
+ SLASH_DUPLICATE_PROPOSAL_PENALTY: 0,
141
+ SLASH_DUPLICATE_ATTESTATION_PENALTY: 0,
142
+ SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 1E+23,
143
+ SLASH_UNKNOWN_PENALTY: 1E+23,
144
+ SLASH_INVALID_BLOCK_PENALTY: 1E+23,
145
+ SLASH_GRACE_PERIOD_L2_SLOTS: 3600,
146
+ ENABLE_VERSION_CHECK: true,
146
147
  } as const;
147
148
 
148
149
  export const mainnetConfig = {
@@ -150,7 +151,7 @@ export const mainnetConfig = {
150
151
  AZTEC_EPOCH_DURATION: 32,
151
152
  AZTEC_TARGET_COMMITTEE_SIZE: 48,
152
153
  AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
153
- AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
154
+ AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 1,
154
155
  AZTEC_INBOX_LAG: 1,
155
156
  AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
156
157
  AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
@@ -160,11 +161,11 @@ 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: 80,
164
+ SLASH_MAX_PAYLOAD_SIZE: 50,
164
165
  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
165
166
  P2P_ENABLED: true,
166
167
  BOOTSTRAP_NODES: '',
167
- SEQ_MIN_TX_PER_BLOCK: 0,
168
+ SEQ_MIN_TX_PER_BLOCK: 1,
168
169
  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
169
170
  SEQ_BLOCK_DURATION_MS: 6000,
170
171
  SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
@@ -200,28 +201,26 @@ 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
- SYNC_SNAPSHOTS_URLS: 'https://aztec-labs-snapshots.com/mainnet/',
207
207
  BLOB_ALLOW_EMPTY_SOURCES: true,
208
- P2P_MAX_PENDING_TX_COUNT: 0,
208
+ P2P_MAX_PENDING_TX_COUNT: 1000,
209
209
  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',
210
+ PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '',
211
+ PUBLIC_OTEL_COLLECT_FROM: '',
212
+ ENABLE_VERSION_CHECK: false,
214
213
  SLASH_PRUNE_PENALTY: 0,
215
214
  SLASH_DATA_WITHHOLDING_PENALTY: 0,
216
- SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.8,
215
+ SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.7,
217
216
  SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 2,
218
217
  SLASH_INACTIVITY_PENALTY: 2E+21,
219
218
  SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 2E+21,
220
- SLASH_DUPLICATE_PROPOSAL_PENALTY: 2E+21,
221
- SLASH_DUPLICATE_ATTESTATION_PENALTY: 2E+21,
219
+ SLASH_DUPLICATE_PROPOSAL_PENALTY: 0,
220
+ SLASH_DUPLICATE_ATTESTATION_PENALTY: 0,
222
221
  SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 2E+21,
223
222
  SLASH_UNKNOWN_PENALTY: 2E+21,
224
223
  SLASH_INVALID_BLOCK_PENALTY: 2E+21,
225
- SLASH_GRACE_PERIOD_L2_SLOTS: 1200,
224
+ SLASH_GRACE_PERIOD_L2_SLOTS: 8400,
226
225
  } as const;
227
226
 
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:') {
@@ -141,6 +139,9 @@ export async function enrichEnvironmentWithNetworkConfig(networkName: NetworkNam
141
139
  if (networkConfig.blobFileStoreUrls?.length) {
142
140
  enrichVar('BLOB_FILE_STORE_URLS', networkConfig.blobFileStoreUrls.join(','));
143
141
  }
142
+ if (networkConfig.txCollectionFileStoreUrls?.length) {
143
+ enrichVar('TX_COLLECTION_FILE_STORE_URLS', networkConfig.txCollectionFileStoreUrls.join(','));
144
+ }
144
145
  if (networkConfig.blockDurationMs !== undefined) {
145
146
  enrichVar('SEQ_BLOCK_DURATION_MS', String(networkConfig.blockDurationMs));
146
147
  }