@aztec/cli 0.0.1-commit.ff7989d6c → 0.0.1-commit.ffe5b04ea

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 +36 -25
  5. package/dest/config/generated/networks.d.ts.map +1 -1
  6. package/dest/config/generated/networks.js +37 -26
  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 +35 -24
  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
@@ -1,6 +1,6 @@
1
1
  export declare const devnetConfig: {
2
2
  readonly ETHEREUM_SLOT_DURATION: 12;
3
- readonly AZTEC_SLOT_DURATION: 36;
3
+ readonly AZTEC_SLOT_DURATION: 72;
4
4
  readonly AZTEC_TARGET_COMMITTEE_SIZE: 48;
5
5
  readonly AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000;
6
6
  readonly AZTEC_EJECTION_THRESHOLD: 50000000000000000000;
@@ -24,12 +24,14 @@ 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: "";
31
31
  readonly SEQ_MIN_TX_PER_BLOCK: 0;
32
32
  readonly SEQ_BUILD_CHECKPOINT_IF_EMPTY: true;
33
+ readonly SEQ_BLOCK_DURATION_MS: 6000;
34
+ readonly SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36;
33
35
  readonly DATA_STORE_MAP_SIZE_KB: 134217728;
34
36
  readonly ARCHIVER_STORE_MAP_SIZE_KB: 1073741824;
35
37
  readonly NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824;
@@ -45,7 +47,7 @@ export declare const devnetConfig: {
45
47
  readonly TEST_ACCOUNTS: true;
46
48
  readonly SPONSORED_FPC: true;
47
49
  readonly TRANSACTIONS_DISABLED: false;
48
- readonly SEQ_MAX_TX_PER_BLOCK: 32;
50
+ readonly SEQ_MAX_TX_PER_BLOCK: 18;
49
51
  readonly PROVER_REAL_PROOFS: false;
50
52
  readonly PXE_PROVER_ENABLED: false;
51
53
  readonly SYNC_SNAPSHOTS_URLS: "";
@@ -53,8 +55,6 @@ export declare const devnetConfig: {
53
55
  readonly BLOB_ALLOW_EMPTY_SOURCES: false;
54
56
  readonly P2P_MAX_PENDING_TX_COUNT: 1000;
55
57
  readonly P2P_TX_POOL_DELETE_TXS_AFTER_REORG: false;
56
- readonly AUTO_UPDATE: "none";
57
- readonly AUTO_UPDATE_URL: "";
58
58
  readonly PUBLIC_OTEL_OPT_OUT: true;
59
59
  readonly PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: "";
60
60
  readonly PUBLIC_OTEL_COLLECT_FROM: "";
@@ -70,6 +70,7 @@ export declare const devnetConfig: {
70
70
  readonly SLASH_UNKNOWN_PENALTY: 10000000000000000000;
71
71
  readonly SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000;
72
72
  readonly SLASH_GRACE_PERIOD_L2_SLOTS: 0;
73
+ readonly ENABLE_VERSION_CHECK: true;
73
74
  };
74
75
  export declare const testnetConfig: {
75
76
  readonly ETHEREUM_SLOT_DURATION: 12;
@@ -80,25 +81,23 @@ export declare const testnetConfig: {
80
81
  readonly AZTEC_EXIT_DELAY_SECONDS: 172800;
81
82
  readonly AZTEC_INBOX_LAG: 1;
82
83
  readonly AZTEC_PROOF_SUBMISSION_EPOCHS: 1;
83
- readonly AZTEC_PROVING_COST_PER_MANA: 100;
84
84
  readonly AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000;
85
85
  readonly AZTEC_SLASHER_FLAVOR: "tally";
86
86
  readonly AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4;
87
87
  readonly AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5;
88
88
  readonly AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2;
89
89
  readonly AZTEC_SLASHING_DISABLE_DURATION: 432000;
90
- readonly AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000;
91
- readonly AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000;
92
- readonly AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000;
93
90
  readonly SLASH_MIN_PENALTY_PERCENTAGE: 0.5;
94
91
  readonly SLASH_MAX_PENALTY_PERCENTAGE: 2;
95
92
  readonly SLASH_OFFENSE_EXPIRATION_ROUNDS: 4;
96
- readonly SLASH_MAX_PAYLOAD_SIZE: 50;
93
+ readonly SLASH_MAX_PAYLOAD_SIZE: 80;
97
94
  readonly SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4;
98
95
  readonly P2P_ENABLED: true;
99
96
  readonly BOOTSTRAP_NODES: "";
100
97
  readonly SEQ_MIN_TX_PER_BLOCK: 0;
101
98
  readonly SEQ_BUILD_CHECKPOINT_IF_EMPTY: true;
99
+ readonly SEQ_BLOCK_DURATION_MS: 6000;
100
+ readonly SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36;
102
101
  readonly DATA_STORE_MAP_SIZE_KB: 134217728;
103
102
  readonly ARCHIVER_STORE_MAP_SIZE_KB: 1073741824;
104
103
  readonly NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824;
@@ -115,13 +114,18 @@ export declare const testnetConfig: {
115
114
  readonly AZTEC_SLASHING_QUORUM: 33;
116
115
  readonly AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 100;
117
116
  readonly AZTEC_GOVERNANCE_PROPOSER_QUORUM: 60;
118
- readonly AZTEC_MANA_TARGET: 150000000;
117
+ readonly AZTEC_MANA_TARGET: 75000000;
118
+ readonly AZTEC_PROVING_COST_PER_MANA: 25000000;
119
+ readonly AZTEC_SLASH_AMOUNT_SMALL: 1e+23;
120
+ readonly AZTEC_SLASH_AMOUNT_MEDIUM: 1e+23;
121
+ readonly AZTEC_SLASH_AMOUNT_LARGE: 1e+23;
119
122
  readonly L1_CHAIN_ID: 11155111;
120
123
  readonly TEST_ACCOUNTS: false;
121
124
  readonly SPONSORED_FPC: true;
122
125
  readonly TRANSACTIONS_DISABLED: false;
123
- readonly SEQ_MAX_TX_PER_BLOCK: 8;
126
+ readonly SEQ_MAX_TX_PER_CHECKPOINT: 72;
124
127
  readonly PROVER_REAL_PROOFS: true;
128
+ readonly P2P_MAX_PENDING_TX_COUNT: 1000;
125
129
  readonly P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true;
126
130
  readonly SLASH_PRUNE_PENALTY: 10000000000000000000;
127
131
  readonly SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000;
@@ -135,10 +139,12 @@ export declare const testnetConfig: {
135
139
  readonly SLASH_UNKNOWN_PENALTY: 10000000000000000000;
136
140
  readonly SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000;
137
141
  readonly SLASH_GRACE_PERIOD_L2_SLOTS: 64;
142
+ readonly ENABLE_VERSION_CHECK: true;
138
143
  };
139
144
  export declare const mainnetConfig: {
140
145
  readonly ETHEREUM_SLOT_DURATION: 12;
141
146
  readonly AZTEC_EPOCH_DURATION: 32;
147
+ readonly AZTEC_TARGET_COMMITTEE_SIZE: 48;
142
148
  readonly AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2;
143
149
  readonly AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2;
144
150
  readonly AZTEC_INBOX_LAG: 1;
@@ -150,12 +156,14 @@ export declare const mainnetConfig: {
150
156
  readonly SLASH_MIN_PENALTY_PERCENTAGE: 0.5;
151
157
  readonly SLASH_MAX_PENALTY_PERCENTAGE: 2;
152
158
  readonly SLASH_OFFENSE_EXPIRATION_ROUNDS: 4;
153
- readonly SLASH_MAX_PAYLOAD_SIZE: 50;
159
+ readonly SLASH_MAX_PAYLOAD_SIZE: 80;
154
160
  readonly SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4;
155
161
  readonly P2P_ENABLED: true;
156
162
  readonly BOOTSTRAP_NODES: "";
157
163
  readonly SEQ_MIN_TX_PER_BLOCK: 0;
158
164
  readonly SEQ_BUILD_CHECKPOINT_IF_EMPTY: true;
165
+ readonly SEQ_BLOCK_DURATION_MS: 6000;
166
+ readonly SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36;
159
167
  readonly DATA_STORE_MAP_SIZE_KB: 134217728;
160
168
  readonly ARCHIVER_STORE_MAP_SIZE_KB: 1073741824;
161
169
  readonly NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824;
@@ -164,10 +172,9 @@ export declare const mainnetConfig: {
164
172
  readonly PUBLIC_OTEL_INCLUDE_METRICS: "aztec.validator,aztec.tx_collector,aztec.mempool,aztec.p2p.gossip.agg_,aztec.ivc_verifier.agg_";
165
173
  readonly SENTINEL_ENABLED: true;
166
174
  readonly AZTEC_SLOT_DURATION: 72;
167
- readonly AZTEC_TARGET_COMMITTEE_SIZE: 24;
168
175
  readonly AZTEC_ACTIVATION_THRESHOLD: 2e+23;
169
176
  readonly AZTEC_EJECTION_THRESHOLD: 1e+23;
170
- readonly AZTEC_LOCAL_EJECTION_THRESHOLD: 1.96e+23;
177
+ readonly AZTEC_LOCAL_EJECTION_THRESHOLD: 1.9e+23;
171
178
  readonly AZTEC_SLASH_AMOUNT_SMALL: 2e+21;
172
179
  readonly AZTEC_SLASH_AMOUNT_MEDIUM: 2e+21;
173
180
  readonly AZTEC_SLASH_AMOUNT_LARGE: 2e+21;
@@ -177,24 +184,28 @@ export declare const mainnetConfig: {
177
184
  readonly AZTEC_SLASHING_QUORUM: 65;
178
185
  readonly AZTEC_GOVERNANCE_PROPOSER_QUORUM: 600;
179
186
  readonly AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 1000;
180
- readonly AZTEC_MANA_TARGET: 0;
181
- readonly AZTEC_PROVING_COST_PER_MANA: 0;
187
+ readonly AZTEC_MANA_TARGET: 75000000;
188
+ readonly AZTEC_PROVING_COST_PER_MANA: 25000000;
182
189
  readonly AZTEC_EXIT_DELAY_SECONDS: 345600;
183
190
  readonly AZTEC_SLASHING_DISABLE_DURATION: 259200;
191
+ readonly AZTEC_ENTRY_QUEUE_BOOTSTRAP_VALIDATOR_SET_SIZE: 500;
192
+ readonly AZTEC_ENTRY_QUEUE_BOOTSTRAP_FLUSH_SIZE: 500;
193
+ readonly AZTEC_ENTRY_QUEUE_FLUSH_SIZE_MIN: 1;
194
+ readonly AZTEC_ENTRY_QUEUE_FLUSH_SIZE_QUOTIENT: 400;
195
+ readonly AZTEC_ENTRY_QUEUE_MAX_FLUSH_SIZE: 4;
184
196
  readonly L1_CHAIN_ID: 1;
185
197
  readonly TEST_ACCOUNTS: false;
186
198
  readonly SPONSORED_FPC: false;
187
- readonly TRANSACTIONS_DISABLED: true;
188
- readonly SEQ_MAX_TX_PER_BLOCK: 0;
199
+ readonly TRANSACTIONS_DISABLED: false;
200
+ readonly SEQ_MAX_TX_PER_CHECKPOINT: 72;
189
201
  readonly PROVER_REAL_PROOFS: true;
190
202
  readonly SYNC_SNAPSHOTS_URLS: "https://aztec-labs-snapshots.com/mainnet/";
191
203
  readonly BLOB_ALLOW_EMPTY_SOURCES: true;
192
- readonly P2P_MAX_PENDING_TX_COUNT: 0;
204
+ readonly P2P_MAX_PENDING_TX_COUNT: 1000;
193
205
  readonly P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true;
194
- readonly AUTO_UPDATE: "notify";
195
- readonly AUTO_UPDATE_URL: "https://storage.googleapis.com/aztec-mainnet/auto-update/mainnet.json";
196
- readonly PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: "https://telemetry.alpha-testnet.aztec-labs.com/v1/metrics";
197
- 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;
198
209
  readonly SLASH_PRUNE_PENALTY: 0;
199
210
  readonly SLASH_DATA_WITHHOLDING_PENALTY: 0;
200
211
  readonly SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.8;
@@ -208,4 +219,4 @@ export declare const mainnetConfig: {
208
219
  readonly SLASH_INVALID_BLOCK_PENALTY: 2e+21;
209
220
  readonly SLASH_GRACE_PERIOD_L2_SLOTS: 1200;
210
221
  };
211
- //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29ya3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25maWcvZ2VuZXJhdGVkL25ldHdvcmtzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLGVBQU8sTUFBTSxZQUFZOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0F3RWYsQ0FBQztBQUVYLGVBQU8sTUFBTSxhQUFhOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBZ0VoQixDQUFDO0FBRVgsZUFBTyxNQUFNLGFBQWE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBdUVoQixDQUFDIn0=
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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwEf,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgEhB,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEhB,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
@@ -2,7 +2,7 @@
2
2
  // Do not edit manually - run yarn generate to regenerate
3
3
  export const devnetConfig = {
4
4
  ETHEREUM_SLOT_DURATION: 12,
5
- AZTEC_SLOT_DURATION: 36,
5
+ AZTEC_SLOT_DURATION: 72,
6
6
  AZTEC_TARGET_COMMITTEE_SIZE: 48,
7
7
  AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000,
8
8
  AZTEC_EJECTION_THRESHOLD: 50000000000000000000,
@@ -26,12 +26,14 @@ 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: '',
33
33
  SEQ_MIN_TX_PER_BLOCK: 0,
34
34
  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
35
+ SEQ_BLOCK_DURATION_MS: 6000,
36
+ SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
35
37
  DATA_STORE_MAP_SIZE_KB: 134217728,
36
38
  ARCHIVER_STORE_MAP_SIZE_KB: 1073741824,
37
39
  NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824,
@@ -47,7 +49,7 @@ export const devnetConfig = {
47
49
  TEST_ACCOUNTS: true,
48
50
  SPONSORED_FPC: true,
49
51
  TRANSACTIONS_DISABLED: false,
50
- SEQ_MAX_TX_PER_BLOCK: 32,
52
+ SEQ_MAX_TX_PER_BLOCK: 18,
51
53
  PROVER_REAL_PROOFS: false,
52
54
  PXE_PROVER_ENABLED: false,
53
55
  SYNC_SNAPSHOTS_URLS: '',
@@ -55,8 +57,6 @@ export const devnetConfig = {
55
57
  BLOB_ALLOW_EMPTY_SOURCES: false,
56
58
  P2P_MAX_PENDING_TX_COUNT: 1000,
57
59
  P2P_TX_POOL_DELETE_TXS_AFTER_REORG: false,
58
- AUTO_UPDATE: 'none',
59
- AUTO_UPDATE_URL: '',
60
60
  PUBLIC_OTEL_OPT_OUT: true,
61
61
  PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '',
62
62
  PUBLIC_OTEL_COLLECT_FROM: '',
@@ -71,7 +71,8 @@ export const devnetConfig = {
71
71
  SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000,
72
72
  SLASH_UNKNOWN_PENALTY: 10000000000000000000,
73
73
  SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
74
- SLASH_GRACE_PERIOD_L2_SLOTS: 0
74
+ SLASH_GRACE_PERIOD_L2_SLOTS: 0,
75
+ ENABLE_VERSION_CHECK: true
75
76
  };
76
77
  export const testnetConfig = {
77
78
  ETHEREUM_SLOT_DURATION: 12,
@@ -82,25 +83,23 @@ export const testnetConfig = {
82
83
  AZTEC_EXIT_DELAY_SECONDS: 172800,
83
84
  AZTEC_INBOX_LAG: 1,
84
85
  AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
85
- AZTEC_PROVING_COST_PER_MANA: 100,
86
86
  AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
87
87
  AZTEC_SLASHER_FLAVOR: 'tally',
88
88
  AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
89
89
  AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
90
90
  AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
91
91
  AZTEC_SLASHING_DISABLE_DURATION: 432000,
92
- AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000,
93
- AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000,
94
- AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000,
95
92
  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
96
93
  SLASH_MAX_PENALTY_PERCENTAGE: 2,
97
94
  SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
98
- SLASH_MAX_PAYLOAD_SIZE: 50,
95
+ SLASH_MAX_PAYLOAD_SIZE: 80,
99
96
  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
100
97
  P2P_ENABLED: true,
101
98
  BOOTSTRAP_NODES: '',
102
99
  SEQ_MIN_TX_PER_BLOCK: 0,
103
100
  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
101
+ SEQ_BLOCK_DURATION_MS: 6000,
102
+ SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
104
103
  DATA_STORE_MAP_SIZE_KB: 134217728,
105
104
  ARCHIVER_STORE_MAP_SIZE_KB: 1073741824,
106
105
  NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824,
@@ -117,13 +116,18 @@ export const testnetConfig = {
117
116
  AZTEC_SLASHING_QUORUM: 33,
118
117
  AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 100,
119
118
  AZTEC_GOVERNANCE_PROPOSER_QUORUM: 60,
120
- AZTEC_MANA_TARGET: 150000000,
119
+ AZTEC_MANA_TARGET: 75000000,
120
+ AZTEC_PROVING_COST_PER_MANA: 25000000,
121
+ AZTEC_SLASH_AMOUNT_SMALL: 1E+23,
122
+ AZTEC_SLASH_AMOUNT_MEDIUM: 1E+23,
123
+ AZTEC_SLASH_AMOUNT_LARGE: 1E+23,
121
124
  L1_CHAIN_ID: 11155111,
122
125
  TEST_ACCOUNTS: false,
123
126
  SPONSORED_FPC: true,
124
127
  TRANSACTIONS_DISABLED: false,
125
- SEQ_MAX_TX_PER_BLOCK: 8,
128
+ SEQ_MAX_TX_PER_CHECKPOINT: 72,
126
129
  PROVER_REAL_PROOFS: true,
130
+ P2P_MAX_PENDING_TX_COUNT: 1000,
127
131
  P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true,
128
132
  SLASH_PRUNE_PENALTY: 10000000000000000000,
129
133
  SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000,
@@ -136,11 +140,13 @@ export const testnetConfig = {
136
140
  SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000,
137
141
  SLASH_UNKNOWN_PENALTY: 10000000000000000000,
138
142
  SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
139
- SLASH_GRACE_PERIOD_L2_SLOTS: 64
143
+ SLASH_GRACE_PERIOD_L2_SLOTS: 64,
144
+ ENABLE_VERSION_CHECK: true
140
145
  };
141
146
  export const mainnetConfig = {
142
147
  ETHEREUM_SLOT_DURATION: 12,
143
148
  AZTEC_EPOCH_DURATION: 32,
149
+ AZTEC_TARGET_COMMITTEE_SIZE: 48,
144
150
  AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
145
151
  AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
146
152
  AZTEC_INBOX_LAG: 1,
@@ -152,12 +158,14 @@ export const mainnetConfig = {
152
158
  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
153
159
  SLASH_MAX_PENALTY_PERCENTAGE: 2,
154
160
  SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
155
- SLASH_MAX_PAYLOAD_SIZE: 50,
161
+ SLASH_MAX_PAYLOAD_SIZE: 80,
156
162
  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
157
163
  P2P_ENABLED: true,
158
164
  BOOTSTRAP_NODES: '',
159
165
  SEQ_MIN_TX_PER_BLOCK: 0,
160
166
  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
167
+ SEQ_BLOCK_DURATION_MS: 6000,
168
+ SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
161
169
  DATA_STORE_MAP_SIZE_KB: 134217728,
162
170
  ARCHIVER_STORE_MAP_SIZE_KB: 1073741824,
163
171
  NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824,
@@ -166,10 +174,9 @@ export const mainnetConfig = {
166
174
  PUBLIC_OTEL_INCLUDE_METRICS: 'aztec.validator,aztec.tx_collector,aztec.mempool,aztec.p2p.gossip.agg_,aztec.ivc_verifier.agg_',
167
175
  SENTINEL_ENABLED: true,
168
176
  AZTEC_SLOT_DURATION: 72,
169
- AZTEC_TARGET_COMMITTEE_SIZE: 24,
170
177
  AZTEC_ACTIVATION_THRESHOLD: 2E+23,
171
178
  AZTEC_EJECTION_THRESHOLD: 1E+23,
172
- AZTEC_LOCAL_EJECTION_THRESHOLD: 1.96E+23,
179
+ AZTEC_LOCAL_EJECTION_THRESHOLD: 1.9E+23,
173
180
  AZTEC_SLASH_AMOUNT_SMALL: 2E+21,
174
181
  AZTEC_SLASH_AMOUNT_MEDIUM: 2E+21,
175
182
  AZTEC_SLASH_AMOUNT_LARGE: 2E+21,
@@ -179,24 +186,28 @@ export const mainnetConfig = {
179
186
  AZTEC_SLASHING_QUORUM: 65,
180
187
  AZTEC_GOVERNANCE_PROPOSER_QUORUM: 600,
181
188
  AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 1000,
182
- AZTEC_MANA_TARGET: 0,
183
- AZTEC_PROVING_COST_PER_MANA: 0,
189
+ AZTEC_MANA_TARGET: 75000000,
190
+ AZTEC_PROVING_COST_PER_MANA: 25000000,
184
191
  AZTEC_EXIT_DELAY_SECONDS: 345600,
185
192
  AZTEC_SLASHING_DISABLE_DURATION: 259200,
193
+ AZTEC_ENTRY_QUEUE_BOOTSTRAP_VALIDATOR_SET_SIZE: 500,
194
+ AZTEC_ENTRY_QUEUE_BOOTSTRAP_FLUSH_SIZE: 500,
195
+ AZTEC_ENTRY_QUEUE_FLUSH_SIZE_MIN: 1,
196
+ AZTEC_ENTRY_QUEUE_FLUSH_SIZE_QUOTIENT: 400,
197
+ AZTEC_ENTRY_QUEUE_MAX_FLUSH_SIZE: 4,
186
198
  L1_CHAIN_ID: 1,
187
199
  TEST_ACCOUNTS: false,
188
200
  SPONSORED_FPC: false,
189
- TRANSACTIONS_DISABLED: true,
190
- SEQ_MAX_TX_PER_BLOCK: 0,
201
+ TRANSACTIONS_DISABLED: false,
202
+ SEQ_MAX_TX_PER_CHECKPOINT: 72,
191
203
  PROVER_REAL_PROOFS: true,
192
204
  SYNC_SNAPSHOTS_URLS: 'https://aztec-labs-snapshots.com/mainnet/',
193
205
  BLOB_ALLOW_EMPTY_SOURCES: true,
194
- P2P_MAX_PENDING_TX_COUNT: 0,
206
+ P2P_MAX_PENDING_TX_COUNT: 1000,
195
207
  P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true,
196
- AUTO_UPDATE: 'notify',
197
- AUTO_UPDATE_URL: 'https://storage.googleapis.com/aztec-mainnet/auto-update/mainnet.json',
198
- PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: 'https://telemetry.alpha-testnet.aztec-labs.com/v1/metrics',
199
- PUBLIC_OTEL_COLLECT_FROM: 'sequencer',
208
+ PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '',
209
+ PUBLIC_OTEL_COLLECT_FROM: '',
210
+ ENABLE_VERSION_CHECK: false,
200
211
  SLASH_PRUNE_PENALTY: 0,
201
212
  SLASH_DATA_WITHHOLDING_PENALTY: 0,
202
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.ff7989d6c",
3
+ "version": "0.0.1-commit.ffe5b04ea",
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.ff7989d6c",
81
- "@aztec/archiver": "0.0.1-commit.ff7989d6c",
82
- "@aztec/aztec.js": "0.0.1-commit.ff7989d6c",
83
- "@aztec/constants": "0.0.1-commit.ff7989d6c",
84
- "@aztec/entrypoints": "0.0.1-commit.ff7989d6c",
85
- "@aztec/ethereum": "0.0.1-commit.ff7989d6c",
86
- "@aztec/foundation": "0.0.1-commit.ff7989d6c",
87
- "@aztec/l1-artifacts": "0.0.1-commit.ff7989d6c",
88
- "@aztec/node-keystore": "0.0.1-commit.ff7989d6c",
89
- "@aztec/node-lib": "0.0.1-commit.ff7989d6c",
90
- "@aztec/p2p": "0.0.1-commit.ff7989d6c",
91
- "@aztec/protocol-contracts": "0.0.1-commit.ff7989d6c",
92
- "@aztec/sequencer-client": "0.0.1-commit.ff7989d6c",
93
- "@aztec/slasher": "0.0.1-commit.ff7989d6c",
94
- "@aztec/stdlib": "0.0.1-commit.ff7989d6c",
95
- "@aztec/wallets": "0.0.1-commit.ff7989d6c",
96
- "@aztec/world-state": "0.0.1-commit.ff7989d6c",
80
+ "@aztec/accounts": "0.0.1-commit.ffe5b04ea",
81
+ "@aztec/archiver": "0.0.1-commit.ffe5b04ea",
82
+ "@aztec/aztec.js": "0.0.1-commit.ffe5b04ea",
83
+ "@aztec/constants": "0.0.1-commit.ffe5b04ea",
84
+ "@aztec/entrypoints": "0.0.1-commit.ffe5b04ea",
85
+ "@aztec/ethereum": "0.0.1-commit.ffe5b04ea",
86
+ "@aztec/foundation": "0.0.1-commit.ffe5b04ea",
87
+ "@aztec/l1-artifacts": "0.0.1-commit.ffe5b04ea",
88
+ "@aztec/node-keystore": "0.0.1-commit.ffe5b04ea",
89
+ "@aztec/node-lib": "0.0.1-commit.ffe5b04ea",
90
+ "@aztec/p2p": "0.0.1-commit.ffe5b04ea",
91
+ "@aztec/protocol-contracts": "0.0.1-commit.ffe5b04ea",
92
+ "@aztec/sequencer-client": "0.0.1-commit.ffe5b04ea",
93
+ "@aztec/slasher": "0.0.1-commit.ffe5b04ea",
94
+ "@aztec/stdlib": "0.0.1-commit.ffe5b04ea",
95
+ "@aztec/wallets": "0.0.1-commit.ffe5b04ea",
96
+ "@aztec/world-state": "0.0.1-commit.ffe5b04ea",
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.ff7989d6c",
111
- "@aztec/kv-store": "0.0.1-commit.ff7989d6c",
112
- "@aztec/telemetry-client": "0.0.1-commit.ff7989d6c",
110
+ "@aztec/aztec-node": "0.0.1-commit.ffe5b04ea",
111
+ "@aztec/kv-store": "0.0.1-commit.ffe5b04ea",
112
+ "@aztec/telemetry-client": "0.0.1-commit.ffe5b04ea",
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.ff7989d6c",
130
- "@aztec/bb-prover": "0.0.1-commit.ff7989d6c",
131
- "@aztec/ethereum": "0.0.1-commit.ff7989d6c",
132
- "@aztec/l1-artifacts": "0.0.1-commit.ff7989d6c",
133
- "@aztec/noir-contracts.js": "0.0.1-commit.ff7989d6c",
134
- "@aztec/noir-protocol-circuits-types": "0.0.1-commit.ff7989d6c",
135
- "@aztec/noir-test-contracts.js": "0.0.1-commit.ff7989d6c",
136
- "@aztec/protocol-contracts": "0.0.1-commit.ff7989d6c",
137
- "@aztec/stdlib": "0.0.1-commit.ff7989d6c"
129
+ "@aztec/accounts": "0.0.1-commit.ffe5b04ea",
130
+ "@aztec/bb-prover": "0.0.1-commit.ffe5b04ea",
131
+ "@aztec/ethereum": "0.0.1-commit.ffe5b04ea",
132
+ "@aztec/l1-artifacts": "0.0.1-commit.ffe5b04ea",
133
+ "@aztec/noir-contracts.js": "0.0.1-commit.ffe5b04ea",
134
+ "@aztec/noir-protocol-circuits-types": "0.0.1-commit.ffe5b04ea",
135
+ "@aztec/noir-test-contracts.js": "0.0.1-commit.ffe5b04ea",
136
+ "@aztec/protocol-contracts": "0.0.1-commit.ffe5b04ea",
137
+ "@aztec/stdlib": "0.0.1-commit.ffe5b04ea"
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
@@ -3,7 +3,7 @@
3
3
 
4
4
  export const devnetConfig = {
5
5
  ETHEREUM_SLOT_DURATION: 12,
6
- AZTEC_SLOT_DURATION: 36,
6
+ AZTEC_SLOT_DURATION: 72,
7
7
  AZTEC_TARGET_COMMITTEE_SIZE: 48,
8
8
  AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000,
9
9
  AZTEC_EJECTION_THRESHOLD: 50000000000000000000,
@@ -27,12 +27,14 @@ 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: '',
34
34
  SEQ_MIN_TX_PER_BLOCK: 0,
35
35
  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
36
+ SEQ_BLOCK_DURATION_MS: 6000,
37
+ SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
36
38
  DATA_STORE_MAP_SIZE_KB: 134217728,
37
39
  ARCHIVER_STORE_MAP_SIZE_KB: 1073741824,
38
40
  NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824,
@@ -48,7 +50,7 @@ export const devnetConfig = {
48
50
  TEST_ACCOUNTS: true,
49
51
  SPONSORED_FPC: true,
50
52
  TRANSACTIONS_DISABLED: false,
51
- SEQ_MAX_TX_PER_BLOCK: 32,
53
+ SEQ_MAX_TX_PER_BLOCK: 18,
52
54
  PROVER_REAL_PROOFS: false,
53
55
  PXE_PROVER_ENABLED: false,
54
56
  SYNC_SNAPSHOTS_URLS: '',
@@ -56,8 +58,6 @@ export const devnetConfig = {
56
58
  BLOB_ALLOW_EMPTY_SOURCES: false,
57
59
  P2P_MAX_PENDING_TX_COUNT: 1000,
58
60
  P2P_TX_POOL_DELETE_TXS_AFTER_REORG: false,
59
- AUTO_UPDATE: 'none',
60
- AUTO_UPDATE_URL: '',
61
61
  PUBLIC_OTEL_OPT_OUT: true,
62
62
  PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '',
63
63
  PUBLIC_OTEL_COLLECT_FROM: '',
@@ -73,6 +73,7 @@ export const devnetConfig = {
73
73
  SLASH_UNKNOWN_PENALTY: 10000000000000000000,
74
74
  SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
75
75
  SLASH_GRACE_PERIOD_L2_SLOTS: 0,
76
+ ENABLE_VERSION_CHECK: true,
76
77
  } as const;
77
78
 
78
79
  export const testnetConfig = {
@@ -84,25 +85,23 @@ export const testnetConfig = {
84
85
  AZTEC_EXIT_DELAY_SECONDS: 172800,
85
86
  AZTEC_INBOX_LAG: 1,
86
87
  AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
87
- AZTEC_PROVING_COST_PER_MANA: 100,
88
88
  AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
89
89
  AZTEC_SLASHER_FLAVOR: 'tally',
90
90
  AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
91
91
  AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
92
92
  AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
93
93
  AZTEC_SLASHING_DISABLE_DURATION: 432000,
94
- AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000,
95
- AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000,
96
- AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000,
97
94
  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
98
95
  SLASH_MAX_PENALTY_PERCENTAGE: 2,
99
96
  SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
100
- SLASH_MAX_PAYLOAD_SIZE: 50,
97
+ SLASH_MAX_PAYLOAD_SIZE: 80,
101
98
  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
102
99
  P2P_ENABLED: true,
103
100
  BOOTSTRAP_NODES: '',
104
101
  SEQ_MIN_TX_PER_BLOCK: 0,
105
102
  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
103
+ SEQ_BLOCK_DURATION_MS: 6000,
104
+ SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
106
105
  DATA_STORE_MAP_SIZE_KB: 134217728,
107
106
  ARCHIVER_STORE_MAP_SIZE_KB: 1073741824,
108
107
  NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824,
@@ -119,13 +118,18 @@ export const testnetConfig = {
119
118
  AZTEC_SLASHING_QUORUM: 33,
120
119
  AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 100,
121
120
  AZTEC_GOVERNANCE_PROPOSER_QUORUM: 60,
122
- AZTEC_MANA_TARGET: 150000000,
121
+ AZTEC_MANA_TARGET: 75000000,
122
+ AZTEC_PROVING_COST_PER_MANA: 25000000,
123
+ AZTEC_SLASH_AMOUNT_SMALL: 1E+23,
124
+ AZTEC_SLASH_AMOUNT_MEDIUM: 1E+23,
125
+ AZTEC_SLASH_AMOUNT_LARGE: 1E+23,
123
126
  L1_CHAIN_ID: 11155111,
124
127
  TEST_ACCOUNTS: false,
125
128
  SPONSORED_FPC: true,
126
129
  TRANSACTIONS_DISABLED: false,
127
- SEQ_MAX_TX_PER_BLOCK: 8,
130
+ SEQ_MAX_TX_PER_CHECKPOINT: 72,
128
131
  PROVER_REAL_PROOFS: true,
132
+ P2P_MAX_PENDING_TX_COUNT: 1000,
129
133
  P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true,
130
134
  SLASH_PRUNE_PENALTY: 10000000000000000000,
131
135
  SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000,
@@ -139,11 +143,13 @@ export const testnetConfig = {
139
143
  SLASH_UNKNOWN_PENALTY: 10000000000000000000,
140
144
  SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
141
145
  SLASH_GRACE_PERIOD_L2_SLOTS: 64,
146
+ ENABLE_VERSION_CHECK: true,
142
147
  } as const;
143
148
 
144
149
  export const mainnetConfig = {
145
150
  ETHEREUM_SLOT_DURATION: 12,
146
151
  AZTEC_EPOCH_DURATION: 32,
152
+ AZTEC_TARGET_COMMITTEE_SIZE: 48,
147
153
  AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
148
154
  AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
149
155
  AZTEC_INBOX_LAG: 1,
@@ -155,12 +161,14 @@ export const mainnetConfig = {
155
161
  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
156
162
  SLASH_MAX_PENALTY_PERCENTAGE: 2,
157
163
  SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
158
- SLASH_MAX_PAYLOAD_SIZE: 50,
164
+ SLASH_MAX_PAYLOAD_SIZE: 80,
159
165
  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
160
166
  P2P_ENABLED: true,
161
167
  BOOTSTRAP_NODES: '',
162
168
  SEQ_MIN_TX_PER_BLOCK: 0,
163
169
  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
170
+ SEQ_BLOCK_DURATION_MS: 6000,
171
+ SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
164
172
  DATA_STORE_MAP_SIZE_KB: 134217728,
165
173
  ARCHIVER_STORE_MAP_SIZE_KB: 1073741824,
166
174
  NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824,
@@ -169,10 +177,9 @@ export const mainnetConfig = {
169
177
  PUBLIC_OTEL_INCLUDE_METRICS: 'aztec.validator,aztec.tx_collector,aztec.mempool,aztec.p2p.gossip.agg_,aztec.ivc_verifier.agg_',
170
178
  SENTINEL_ENABLED: true,
171
179
  AZTEC_SLOT_DURATION: 72,
172
- AZTEC_TARGET_COMMITTEE_SIZE: 24,
173
180
  AZTEC_ACTIVATION_THRESHOLD: 2E+23,
174
181
  AZTEC_EJECTION_THRESHOLD: 1E+23,
175
- AZTEC_LOCAL_EJECTION_THRESHOLD: 1.96E+23,
182
+ AZTEC_LOCAL_EJECTION_THRESHOLD: 1.9E+23,
176
183
  AZTEC_SLASH_AMOUNT_SMALL: 2E+21,
177
184
  AZTEC_SLASH_AMOUNT_MEDIUM: 2E+21,
178
185
  AZTEC_SLASH_AMOUNT_LARGE: 2E+21,
@@ -182,24 +189,28 @@ export const mainnetConfig = {
182
189
  AZTEC_SLASHING_QUORUM: 65,
183
190
  AZTEC_GOVERNANCE_PROPOSER_QUORUM: 600,
184
191
  AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 1000,
185
- AZTEC_MANA_TARGET: 0,
186
- AZTEC_PROVING_COST_PER_MANA: 0,
192
+ AZTEC_MANA_TARGET: 75000000,
193
+ AZTEC_PROVING_COST_PER_MANA: 25000000,
187
194
  AZTEC_EXIT_DELAY_SECONDS: 345600,
188
195
  AZTEC_SLASHING_DISABLE_DURATION: 259200,
196
+ AZTEC_ENTRY_QUEUE_BOOTSTRAP_VALIDATOR_SET_SIZE: 500,
197
+ AZTEC_ENTRY_QUEUE_BOOTSTRAP_FLUSH_SIZE: 500,
198
+ AZTEC_ENTRY_QUEUE_FLUSH_SIZE_MIN: 1,
199
+ AZTEC_ENTRY_QUEUE_FLUSH_SIZE_QUOTIENT: 400,
200
+ AZTEC_ENTRY_QUEUE_MAX_FLUSH_SIZE: 4,
189
201
  L1_CHAIN_ID: 1,
190
202
  TEST_ACCOUNTS: false,
191
203
  SPONSORED_FPC: false,
192
- TRANSACTIONS_DISABLED: true,
193
- SEQ_MAX_TX_PER_BLOCK: 0,
204
+ TRANSACTIONS_DISABLED: false,
205
+ SEQ_MAX_TX_PER_CHECKPOINT: 72,
194
206
  PROVER_REAL_PROOFS: true,
195
207
  SYNC_SNAPSHOTS_URLS: 'https://aztec-labs-snapshots.com/mainnet/',
196
208
  BLOB_ALLOW_EMPTY_SOURCES: true,
197
- P2P_MAX_PENDING_TX_COUNT: 0,
209
+ P2P_MAX_PENDING_TX_COUNT: 1000,
198
210
  P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true,
199
- AUTO_UPDATE: 'notify',
200
- AUTO_UPDATE_URL: 'https://storage.googleapis.com/aztec-mainnet/auto-update/mainnet.json',
201
- PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: 'https://telemetry.alpha-testnet.aztec-labs.com/v1/metrics',
202
- PUBLIC_OTEL_COLLECT_FROM: 'sequencer',
211
+ PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '',
212
+ PUBLIC_OTEL_COLLECT_FROM: '',
213
+ ENABLE_VERSION_CHECK: false,
203
214
  SLASH_PRUNE_PENALTY: 0,
204
215
  SLASH_DATA_WITHHOLDING_PENALTY: 0,
205
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
  }